opencode-autognosis 2.0.2 → 2.0.4

package/dist/database.d.ts

@@ -4,17 +4,37 @@ export declare class CodeGraphDB {
     private workerRunning;
     constructor();
     private initialize;
+    /**
+     * Background Job Management
+     */
+    createJob(id: string, type: string, metadata?: any): void;
+    updateJob(id: string, updates: {
+        status?: string;
+        progress?: number;
+        result?: string;
+        error?: string;
+    }): void;
+    getJob(id: string): unknown;
+    listJobs(type?: string, limit?: number): unknown[];
     private startWorker;
     private processEmbeddingQueue;
     /**
      * Syncs a ChunkCard (JSON) into the SQLite Index.
-     * This is an "Upsert" operation.
      */
     ingestChunkCard(card: ChunkCard): void;
-    /**
-     * Remove a card from the index
-     */
     deleteChunkCard(cardId: string): void;
+    recordExecution(planId: string | undefined, toolName: string, args: any, isOnPlan: boolean): void;
+    ingestCommits(commits: any[]): void;
+    getHotFiles(pathPrefix?: string, limit?: number): {
+        path: string;
+        count: number;
+    }[];
+    getPlanMetrics(planId: string): {
+        total: number;
+        on_plan: number;
+        off_plan: number;
+        compliance: number;
+    };
     findDependents(filePath: string): string[];
     searchSymbols(query: string): any[];
     semanticSearch(query: string, limit?: number): Promise<any[]>;

package/dist/database.js

@@ -62,10 +62,40 @@ export class CodeGraphDB {
         FOREIGN KEY(source_chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
       );
 
+      CREATE TABLE IF NOT EXISTS commits (
+        hash TEXT PRIMARY KEY,
+        author TEXT,
+        date DATETIME,
+        message TEXT,
+        files_touched TEXT -- JSON array of paths
+      );
+
+      CREATE TABLE IF NOT EXISTS plan_ledger (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        plan_id TEXT,
+        tool_name TEXT,
+        args TEXT,
+        is_on_plan BOOLEAN,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS background_jobs (
+        id TEXT PRIMARY KEY,
+        type TEXT, -- 'validation', 'setup', 'indexing'
+        status TEXT DEFAULT 'pending', -- pending, running, completed, failed
+        progress INTEGER DEFAULT 0,
+        result TEXT,
+        error TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        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 {
@@ -73,6 +103,47 @@ export class CodeGraphDB {
         }
         catch { }
     }
+    /**
+     * Background Job Management
+     */
+    createJob(id, type, metadata) {
+        this.db.prepare(`
+      INSERT INTO background_jobs (id, type, status, progress, result)
+      VALUES (?, ?, 'pending', 0, ?)
+    `).run(id, type, metadata ? JSON.stringify(metadata) : null);
+    }
+    updateJob(id, updates) {
+        const sets = [];
+        const params = [];
+        if (updates.status) {
+            sets.push("status = ?");
+            params.push(updates.status);
+        }
+        if (updates.progress !== undefined) {
+            sets.push("progress = ?");
+            params.push(updates.progress);
+        }
+        if (updates.result) {
+            sets.push("result = ?");
+            params.push(updates.result);
+        }
+        if (updates.error) {
+            sets.push("error = ?");
+            params.push(updates.error);
+        }
+        sets.push("updated_at = CURRENT_TIMESTAMP");
+        params.push(id);
+        this.db.prepare(`UPDATE background_jobs SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+    }
+    getJob(id) {
+        return this.db.prepare("SELECT * FROM background_jobs WHERE id = ?").get(id);
+    }
+    listJobs(type, limit = 10) {
+        if (type) {
+            return this.db.prepare("SELECT * FROM background_jobs WHERE type = ? ORDER BY created_at DESC LIMIT ?").all(type, limit);
+        }
+        return this.db.prepare("SELECT * FROM background_jobs ORDER BY created_at DESC LIMIT ?").all(limit);
+    }
     async startWorker() {
         if (this.workerRunning)
             return;
@@ -83,7 +154,7 @@ export class CodeGraphDB {
                 await this.processEmbeddingQueue();
             }
             catch (e) {
-                // console.error("Worker error:", e);
+                // Log to file if needed, but avoid console to protect TUI
             }
         }, 5000); // Check every 5s
     }
@@ -123,18 +194,15 @@ export class CodeGraphDB {
         }
         catch (error) {
             if (task.retries > 3) {
-                // Give up
                 this.db.prepare("UPDATE embedding_queue SET status = 'failed' WHERE chunk_id = ?").run(task.chunk_id);
             }
             else {
-                // Retry
                 this.db.prepare("UPDATE embedding_queue SET status = 'pending', retries = retries + 1 WHERE chunk_id = ?").run(task.chunk_id);
             }
         }
     }
     /**
      * Syncs a ChunkCard (JSON) into the SQLite Index.
-     * This is an "Upsert" operation.
      */
     ingestChunkCard(card) {
         const insertFile = this.db.prepare(`
@@ -169,22 +237,17 @@ export class CodeGraphDB {
         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(() => {
-            // 1. Upsert File
             const fileRes = insertFile.get(card.file_path, card.metadata.hash);
             const fileId = fileRes.id;
-            // 2. Upsert Chunk
-            insertChunk.run(card.id, fileId, card.chunk_type, card.metadata.complexity_score, card.content.slice(0, 500) // Store preview
-            );
-            // 3. Queue for Embedding
-            // Use the summary or content as the text to embed
-            const textToEmbed = `${card.chunk_type.toUpperCase()} for ${path.basename(card.file_path)}\n\n${card.content.slice(0, 2000)}`;
+            insertChunk.run(card.id, fileId, card.chunk_type, card.metadata.complexity_score, card.content.slice(0, 500));
+            const textToEmbed = `${card.chunk_type.toUpperCase()} for ${path.basename(card.file_path)}
+
+${card.content.slice(0, 2000)}`;
             queueEmbedding.run(card.id, textToEmbed);
-            // 4. Replace Symbols
             deleteOldSymbols.run(card.id);
             for (const sym of card.metadata.symbols) {
                 insertSymbol.run(card.id, sym);
             }
-            // 5. Replace Dependencies
             deleteOldDeps.run(card.id);
             for (const dep of card.metadata.dependencies) {
                 insertDep.run(card.id, dep);
@@ -192,18 +255,61 @@ export class CodeGraphDB {
         });
         transaction();
     }
-    /**
-     * Remove a card from the index
-     */
     deleteChunkCard(cardId) {
         this.db.prepare('DELETE FROM chunks WHERE id = ?').run(cardId);
     }
-    // ===========================================================================
-    // QUERY METHODS
-    // ===========================================================================
+    recordExecution(planId, toolName, args, isOnPlan) {
+        this.db.prepare(`
+      INSERT INTO plan_ledger (plan_id, tool_name, args, is_on_plan)
+      VALUES (?, ?, ?, ?)
+    `).run(planId || 'no-plan', toolName, JSON.stringify(args), isOnPlan ? 1 : 0);
+    }
+    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) {
+                insert.run(c.hash, c.author, c.date, c.message, JSON.stringify(c.files));
+            }
+        });
+        transaction(commits);
+    }
+    getHotFiles(pathPrefix = '', limit = 10) {
+        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)) {
+                        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);
+    }
+    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
+        };
+    }
     findDependents(filePath) {
-        // Find all chunks that depend on this file path
-        // Note: dependency paths might be relative or absolute, simplistic matching for now
         const query = this.db.prepare(`
       SELECT DISTINCT f.path 
       FROM files f
@@ -211,7 +317,6 @@ export class CodeGraphDB {
       JOIN dependencies d ON c.id = d.source_chunk_id
       WHERE d.target_path LIKE ? OR d.target_path = ?
     `);
-        // Attempt to match exact path or likely relative imports (simplistic)
         const basename = path.basename(filePath);
         const results = query.all(`%/${basename}%`, basename);
         return results.map(r => r.path);
@@ -234,9 +339,6 @@ export class CodeGraphDB {
         const queryVec = await ollama.getEmbedding(query);
         if (queryVec.length === 0)
             return [];
-        // Get all embeddings from DB
-        // SQLite doesn't have vector math, so we fetch all and sort in JS
-        // Optimizations: In future, use sqlite-vec or filter by complexity/type first
         const chunks = this.db.prepare(`
       SELECT c.id, c.content_summary, c.type, f.path, c.embedding
       FROM chunks c
@@ -246,15 +348,13 @@ export class CodeGraphDB {
         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 }; // Don't return blob
+            return { ...chunk, similarity, embedding: undefined };
         });
         results.sort((a, b) => b.similarity - a.similarity);
         return results.slice(0, limit);
     }
     cosineSimilarity(vecA, vecB) {
-        let dot = 0;
-        let normA = 0;
-        let normB = 0;
+        let dot = 0, normA = 0, normB = 0;
         for (let i = 0; i < vecA.length; i++) {
             dot += vecA[i] * vecB[i];
             normA += vecA[i] * vecA[i];
@@ -270,69 +370,60 @@ export class CodeGraphDB {
         const embedded = this.db.prepare('SELECT COUNT(*) as c FROM chunks WHERE embedding IS NOT NULL').get();
         const queue = this.db.prepare("SELECT COUNT(*) as c FROM embedding_queue WHERE status = 'pending'").get();
         return {
-            files: files.c,
-            chunks: chunks.c,
-            symbols: symbols.c,
-            dependencies: deps.c,
-            embeddings: {
-                completed: embedded.c,
-                pending: queue.c
-            }
+            files: files.c, chunks: chunks.c, symbols: symbols.c, dependencies: deps.c,
+            embeddings: { completed: embedded.c, pending: queue.c }
         };
     }
 }
-// Singleton instance for the plugin
 let dbInstance = null;
 export function getDb() {
-    if (!dbInstance) {
+    if (!dbInstance)
         dbInstance = new CodeGraphDB();
-    }
     return dbInstance;
 }
 export function graphTools() {
     return {
         autognosis_setup_ai: tool({
-            description: "Configure local AI capabilities (Ollama). Checks installation, installs if needed, and pulls the embedding model.",
-            args: {
-                model: tool.schema.string().optional().default(DEFAULT_EMBEDDING_MODEL).describe("Embedding model to pull")
-            },
+            description: "Configure local AI capabilities (Ollama) in the background.",
+            args: { model: tool.schema.string().optional().default(DEFAULT_EMBEDDING_MODEL) },
             async execute({ model }) {
-                try {
-                    const installed = await ollama.isInstalled();
-                    let statusMsg = "Ollama is installed.";
-                    if (!installed) {
-                        statusMsg = await ollama.install();
-                    }
-                    await ollama.startServer();
-                    await ollama.pullModel(model);
-                    return JSON.stringify({
-                        status: "SUCCESS",
-                        message: `${statusMsg} Server is running. Model ${model} is ready.`,
-                        config: {
-                            model,
-                            base_url: "http://127.0.0.1:11434"
+                const jobId = `job-setup-ai-${Date.now()}`;
+                getDb().createJob(jobId, "setup", { model });
+                (async () => {
+                    try {
+                        getDb().updateJob(jobId, { status: "running", progress: 10 });
+                        if (!(await ollama.isInstalled())) {
+                            await ollama.install();
                         }
-                    }, null, 2);
-                }
-                catch (error) {
-                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
-                }
+                        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 });
+                    }
+                })();
+                return JSON.stringify({
+                    status: "STARTED",
+                    message: "AI Setup started in background.",
+                    job_id: jobId,
+                    instruction: "Use graph_background_status to check progress."
+                }, null, 2);
             }
         }),
         graph_semantic_search: tool({
-            description: "Search the codebase using natural language (Vector/Semantic Search). Requires AI setup.",
-            args: {
-                query: tool.schema.string().describe("Natural language query"),
-                limit: tool.schema.number().optional().default(10).describe("Max results")
-            },
+            description: "Search the codebase using natural language (Vector/Semantic Search).",
+            args: { query: tool.schema.string(), limit: tool.schema.number().optional().default(10) },
             async execute({ query, limit }) {
                 try {
                     const results = await getDb().semanticSearch(query, limit);
-                    return JSON.stringify({
-                        status: "SUCCESS",
-                        query,
-                        results
-                    }, null, 2);
+                    return JSON.stringify({ status: "SUCCESS", query, results }, null, 2);
                 }
                 catch (error) {
                     return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
@@ -340,19 +431,12 @@ export function graphTools() {
             }
         }),
         graph_query_dependents: tool({
-            description: "Find all files that depend on a specific file (upstream impact analysis).",
-            args: {
-                file_path: tool.schema.string().describe("File path to analyze"),
-            },
+            description: "Find all files that depend on a specific file.",
+            args: { file_path: tool.schema.string() },
             async execute({ file_path }) {
                 try {
                     const dependents = getDb().findDependents(file_path);
-                    return JSON.stringify({
-                        status: "SUCCESS",
-                        file_path,
-                        dependents,
-                        count: dependents.length
-                    }, null, 2);
+                    return JSON.stringify({ status: "SUCCESS", file_path, dependents, count: dependents.length }, null, 2);
                 }
                 catch (error) {
                     return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
@@ -360,19 +444,12 @@ export function graphTools() {
             }
         }),
         graph_search_symbols: tool({
-            description: "Fast fuzzy search for symbols (functions, classes) across the entire codebase index.",
-            args: {
-                query: tool.schema.string().describe("Symbol name query"),
-            },
+            description: "Fast fuzzy search for symbols across the entire codebase index.",
+            args: { query: tool.schema.string() },
             async execute({ query }) {
                 try {
                     const results = getDb().searchSymbols(query);
-                    return JSON.stringify({
-                        status: "SUCCESS",
-                        query,
-                        results,
-                        count: results.length
-                    }, null, 2);
+                    return JSON.stringify({ status: "SUCCESS", query, results, count: results.length }, null, 2);
                 }
                 catch (error) {
                     return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
@@ -384,11 +461,70 @@ export function graphTools() {
             args: {},
             async execute() {
                 try {
-                    const stats = getDb().getStats();
-                    return JSON.stringify({
-                        status: "SUCCESS",
-                        stats
-                    }, null, 2);
+                    return JSON.stringify({ status: "SUCCESS", stats: getDb().getStats() }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        }),
+        journal_build: tool({
+            description: "Scan git history and populate the Change Journal.",
+            args: { limit: tool.schema.number().optional().default(100) },
+            async execute({ limit }) {
+                try {
+                    const { execSync } = await import("node:child_process");
+                    const logOut = execSync(`git log -n ${limit} --pretty=format:"%H|%an|%ad|%s" --date=iso`, { encoding: 'utf-8' });
+                    const commits = logOut.split('\n').filter(Boolean).map(line => {
+                        const [hash, author, date, message] = line.split('|');
+                        const files = execSync(`git show --name-only --pretty="" ${hash}`, { encoding: 'utf-8' }).split('\n').filter(Boolean);
+                        return { hash, author, date, message, files };
+                    });
+                    getDb().ingestCommits(commits);
+                    return JSON.stringify({ status: "SUCCESS", message: `Ingested ${commits.length} commits.` }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        }),
+        journal_query_hot_files: tool({
+            description: "Query the Change Journal for frequently changed files.",
+            args: { path_prefix: tool.schema.string().optional().default(""), limit: tool.schema.number().optional().default(10) },
+            async execute({ path_prefix, limit }) {
+                try {
+                    return JSON.stringify({ status: "SUCCESS", hot_files: getDb().getHotFiles(path_prefix, limit) }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        }),
+        graph_get_plan_metrics: tool({
+            description: "Retrieve execution metrics for a specific plan ID.",
+            args: { plan_id: tool.schema.string() },
+            async execute({ plan_id }) {
+                try {
+                    return JSON.stringify({ status: "SUCCESS", plan_id, metrics: getDb().getPlanMetrics(plan_id) }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        }),
+        graph_background_status: tool({
+            description: "Check status of background tasks (validation, setup, indexing).",
+            args: {
+                job_id: tool.schema.string().optional(),
+                type: tool.schema.enum(["validation", "setup", "indexing"]).optional(),
+                limit: tool.schema.number().optional().default(5)
+            },
+            async execute({ job_id, type, limit }) {
+                try {
+                    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) {
                     return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export declare const AutognosisPlugin: () => Promise<{
     tool: {
-        [x: string]: any;
+        [key: string]: any;
     };
 }>;
 export default AutognosisPlugin;

package/dist/index.js

@@ -1,22 +1,8 @@
-import { systemTools } from "./system-tools.js";
-import { gitWorktreeTools } from "./git-worktree.js";
-import { testingTools } from "./testing-infrastructure.js";
-import { chunkCardsTools } from "./chunk-cards.js";
-import { activeSetTools } from "./activeset.js";
-import { moduleSummariesTools } from "./module-summaries.js";
-import { performanceTools } from "./performance-optimization.js";
-import { graphTools } from "./database.js";
+import { unifiedTools } from "./unified-api.js";
 export const AutognosisPlugin = async () => {
     return {
         tool: {
-            ...systemTools(),
-            ...gitWorktreeTools(),
-            ...testingTools(),
-            ...chunkCardsTools(),
-            ...activeSetTools(),
-            ...moduleSummariesTools(),
-            ...performanceTools(),
-            ...graphTools(),
+            ...unifiedTools(),
         },
     };
 };

package/dist/performance-optimization.js

@@ -433,29 +433,40 @@ export function performanceTools() {
             description: "Check status of background tasks and operations.",
             args: {
                 task_id: tool.schema.string().optional().describe("Specific task ID to check"),
-                task_type: tool.schema.enum(["indexing", "caching", "cleanup", "analysis"]).optional().describe("Filter by task type")
+                task_type: tool.schema.enum(["indexing", "caching", "cleanup", "analysis", "validation", "setup"]).optional().describe("Filter by task type")
             },
             async execute({ task_id, task_type }) {
                 log("Tool call: perf_background_status", { task_id, task_type });
                 try {
+                    const tasks = [];
+                    // 1. Check DB Jobs
+                    if (task_id) {
+                        const job = getDb().getJob(task_id);
+                        if (job)
+                            tasks.push(job);
+                    }
+                    else {
+                        const dbJobs = getDb().listJobs(task_type, 10);
+                        tasks.push(...dbJobs);
+                    }
+                    // 2. Check File-based tasks
                     await ensurePerfDirs();
                     const files = await fs.readdir(PERF_DIR);
-                    const tasks = [];
                     for (const file of files) {
                         if (file.startsWith('task-') && file.endsWith('.json')) {
                             try {
                                 const taskPath = path.join(PERF_DIR, file);
                                 const task = JSON.parse(await fs.readFile(taskPath, 'utf-8'));
-                                // Apply filters
                                 if (task_id && task.id !== task_id)
                                     continue;
                                 if (task_type && task.type !== task_type)
                                     continue;
-                                tasks.push(task);
-                            }
-                            catch (error) {
-                                // Skip corrupted files
+                                // Avoid duplication if already in DB (shouldn't happen with new ID scheme)
+                                if (!tasks.some(t => t.id === task.id)) {
+                                    tasks.push(task);
+                                }
                             }
+                            catch (error) { }
                         }
                     }
                     return JSON.stringify({

package/dist/system-tools.js

@@ -6,6 +6,7 @@ import * as path from "node:path";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
 import { Logger } from "./services/logger.js";
+import { getDb } from "./database.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
@@ -94,7 +95,10 @@ async function maintainSymbolIndex() {
 // TOOLS
 // =============================================================================
 export function systemTools() {
-    let pendingInitToken = null; // State for init token
+    let pendingInitToken = null;
+    const record = (planId, tool, args) => {
+        getDb().recordExecution(planId, tool, args, !!planId);
+    };
     return {
         autognosis_init: tool({
             description: "Initialize or check the Autognosis environment. Two-phase: 'plan' (default) generates a token, 'apply' executes it.",
@@ -104,6 +108,7 @@ export function systemTools() {
             },
             async execute({ mode, token }) {
                 log("Tool call: autognosis_init", { mode });
+                record(undefined, "autognosis_init", { mode });
                 if (mode === "plan") {
                     const checks = {
                         rg: await checkBinary("rg"),
@@ -139,10 +144,12 @@ export function systemTools() {
             args: {
                 query: tool.schema.string(),
                 mode: tool.schema.enum(["filename", "content"]).optional().default("filename"),
-                path: tool.schema.string().optional().default(".")
+                path: tool.schema.string().optional().default("."),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ query, mode, path: searchPath }) {
-                log("Tool call: fast_search", { query, mode, searchPath });
+            async execute({ query, mode, path: searchPath, plan_id }) {
+                log("Tool call: fast_search", { query, mode, searchPath, plan_id });
+                record(plan_id, "fast_search", { query, mode, searchPath });
                 if (mode === "content") {
                     if (!(await checkBinary("rg")))
                         return "Error: 'rg' not installed.";
@@ -166,10 +173,12 @@ export function systemTools() {
             args: {
                 file: tool.schema.string(),
                 start_line: tool.schema.number(),
-                end_line: tool.schema.number()
+                end_line: tool.schema.number(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ file, start_line, end_line }) {
-                log("Tool call: read_slice", { file, start_line, end_line });
+            async execute({ file, start_line, end_line, plan_id }) {
+                log("Tool call: read_slice", { file, start_line, end_line, plan_id });
+                record(plan_id, "read_slice", { file, start_line, end_line });
                 const { stdout, stderr } = await runCmd(`sed -n '${start_line},${end_line}p;${end_line + 1}q' "${file}"`);
                 if (stderr)
                     return `Error: ${stderr}`;
@@ -179,10 +188,12 @@ export function systemTools() {
         symbol_query: tool({
             description: "Query the symbol index. Rebuilds automatically if stale.",
             args: {
-                symbol: tool.schema.string()
+                symbol: tool.schema.string(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ symbol }) {
-                log("Tool call: symbol_query", { symbol });
+            async execute({ symbol, plan_id }) {
+                log("Tool call: symbol_query", { symbol, plan_id });
+                record(plan_id, "symbol_query", { symbol });
                 const maint = await maintainSymbolIndex();
                 if (maint.status === "unavailable")
                     return JSON.stringify({ error: maint.reason });
@@ -194,10 +205,12 @@ export function systemTools() {
         jump_to_symbol: tool({
             description: "Jump to a symbol's definition by querying the index and reading the slice.",
             args: {
-                symbol: tool.schema.string()
+                symbol: tool.schema.string(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ symbol }) {
-                log("Tool call: jump_to_symbol", { symbol });
+            async execute({ symbol, plan_id }) {
+                log("Tool call: jump_to_symbol", { symbol, plan_id });
+                record(plan_id, "jump_to_symbol", { symbol });
                 const maint = await maintainSymbolIndex();
                 if (maint.status !== "ok")
                     return JSON.stringify({ error: maint.reason });
@@ -223,34 +236,121 @@ export function systemTools() {
             async execute({ symbol, intent }) {
                 log("Tool call: brief_fix_loop", { symbol, intent });
                 const planId = `plan-${Date.now()}`;
-                return JSON.stringify({ plan_id: planId, symbol, intent, status: "PLAN_GENERATED" }, null, 2);
+                record(planId, "brief_fix_loop", { symbol, intent });
+                const maint = await maintainSymbolIndex();
+                const tagsFile = path.join(CACHE_DIR, "tags");
+                const { stdout: tagLine } = await runCmd(`grep -P "^${symbol}\t" "${tagsFile}" | head -n 1`);
+                const locusFile = tagLine ? tagLine.split('\t')[1] : null;
+                let dependents = [];
+                let hotFiles = [];
+                if (locusFile) {
+                    dependents = getDb().findDependents(locusFile);
+                    hotFiles = getDb().getHotFiles('', 20);
+                }
+                const worklist = dependents.map(d => ({
+                    file: d,
+                    is_hot: hotFiles.some(h => h.path === d),
+                    reason: "Dependency impact"
+                }));
+                return JSON.stringify({
+                    plan_id: planId,
+                    symbol,
+                    intent,
+                    locus: { file: locusFile },
+                    worklist,
+                    status: "PLAN_GENERATED",
+                    metadata: {
+                        fingerprint: maint.status,
+                        generated_at: new Date().toISOString()
+                    }
+                }, null, 2);
             }
         }),
         prepare_patch: tool({
             description: "Generate a .diff artifact for the current changes.",
             args: {
-                message: tool.schema.string()
+                message: tool.schema.string(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ message }) {
-                log("Tool call: prepare_patch", { message });
+            async execute({ message, plan_id }) {
+                log("Tool call: prepare_patch", { message, plan_id });
+                record(plan_id, "prepare_patch", { message });
                 await ensureCache();
-                const patchPath = path.join(CACHE_DIR, `patch-${Date.now()}.diff`);
-                const { stdout } = await runCmd("git diff");
-                if (!stdout)
+                const patchId = `patch-${Date.now()}`;
+                const patchPath = path.join(CACHE_DIR, `${patchId}.diff`);
+                const { stdout: diff } = await runCmd("git diff");
+                if (!diff)
                     return "No changes to patch.";
-                await fs.writeFile(patchPath, `// MSG: ${message}\n\n${stdout}`);
-                return `Patch saved to ${patchPath}`;
+                const header = {
+                    patch_id: patchId,
+                    plan_id: plan_id || "adhoc",
+                    message,
+                    created_at: new Date().toISOString()
+                };
+                await fs.writeFile(patchPath, `// PATCH_METADATA: ${JSON.stringify(header)}\n\n${diff}`);
+                return JSON.stringify({ status: "SUCCESS", patch_id: patchId, path: patchPath }, null, 2);
             }
         }),
         validate_patch: tool({
-            description: "Validate a patch by applying it in a fresh worktree.",
+            description: "Validate a patch by applying it in a fresh worktree and running build (Background Job).",
             args: {
-                patch_path: tool.schema.string()
+                patch_path: tool.schema.string(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ patch_path }) {
-                log("Tool call: validate_patch", { patch_path });
-                const { error } = await runCmd(`git apply --check "${patch_path}"`);
-                return error ? `FAILED: ${error.message}` : "SUCCESS: Patch is valid against current HEAD.";
+            async execute({ patch_path, plan_id }) {
+                log("Tool call: validate_patch (background)", { patch_path, plan_id });
+                record(plan_id, "validate_patch", { patch_path });
+                const jobId = `job-validate-${Date.now()}`;
+                getDb().createJob(jobId, "validation", { patch_path, plan_id });
+                // Spawn background worker
+                (async () => {
+                    getDb().updateJob(jobId, { status: "running", progress: 10 });
+                    const tempWorktree = path.join(PROJECT_ROOT, ".opencode", "temp-" + jobId);
+                    try {
+                        await runCmd(`git worktree add -d "${tempWorktree}"`);
+                        getDb().updateJob(jobId, { progress: 30 });
+                        const content = await fs.readFile(patch_path, "utf-8");
+                        const parts = content.split('\n\n');
+                        const diffOnly = parts.length > 1 ? parts.slice(1).join('\n\n') : content;
+                        const tempDiff = path.join(tempWorktree, "valid.diff");
+                        await fs.writeFile(tempDiff, diffOnly);
+                        const { error: applyError } = await runCmd(`git apply "${tempDiff}"`, tempWorktree);
+                        if (applyError)
+                            throw new Error(`Apply failed: ${applyError.message}`);
+                        getDb().updateJob(jobId, { progress: 60 });
+                        let buildStatus = "SKIPPED";
+                        if (fsSync.existsSync(path.join(tempWorktree, "package.json"))) {
+                            const { error: buildError } = await runCmd("npm run build", tempWorktree);
+                            buildStatus = buildError ? "FAILED" : "SUCCESS";
+                        }
+                        else if (fsSync.existsSync(path.join(tempWorktree, "Package.swift"))) {
+                            const { error: buildError } = await runCmd("swift build", tempWorktree);
+                            buildStatus = buildError ? "FAILED" : "SUCCESS";
+                        }
+                        getDb().updateJob(jobId, {
+                            status: "completed",
+                            progress: 100,
+                            result: JSON.stringify({ apply: "OK", build: buildStatus })
+                        });
+                    }
+                    catch (error) {
+                        getDb().updateJob(jobId, { status: "failed", error: error.message });
+                    }
+                    finally {
+                        try {
+                            await runCmd(`git worktree remove -f "${tempWorktree}"`);
+                            if (fsSync.existsSync(tempWorktree))
+                                await fs.rm(tempWorktree, { recursive: true, force: true });
+                        }
+                        catch (e) { }
+                    }
+                })();
+                return JSON.stringify({
+                    status: "STARTED",
+                    message: "Validation started in background.",
+                    job_id: jobId,
+                    instruction: "Use perf_background_status to check progress."
+                }, null, 2);
             }
         }),
         finalize_plan: tool({
@@ -261,11 +361,17 @@ export function systemTools() {
             },
             async execute({ plan_id, outcome }) {
                 log("Tool call: finalize_plan", { plan_id, outcome });
-                await ensureCache();
-                const report = { plan_id, outcome, time: new Date().toISOString() };
+                record(plan_id, "finalize_plan", { outcome });
+                const metrics = getDb().getPlanMetrics(plan_id);
+                const report = {
+                    plan_id,
+                    outcome,
+                    metrics,
+                    finished_at: new Date().toISOString()
+                };
                 await fs.appendFile(path.join(CACHE_DIR, "gaps.jsonl"), JSON.stringify(report) + "\n");
                 const deleted = await cleanCache();
-                return `Finalized. Cache hygiene: deleted ${deleted} old items.`;
+                return JSON.stringify({ status: "FINALIZED", report, cache_cleared: deleted }, null, 2);
             }
         })
     };

package/dist/unified-api.d.ts

@@ -0,0 +1,3 @@
+export declare function unifiedTools(): {
+    [key: string]: any;
+};

package/dist/unified-api.js

@@ -0,0 +1,160 @@
+import { tool } from "@opencode-ai/plugin";
+import { systemTools } from "./system-tools.js";
+import { activeSetTools } from "./activeset.js";
+import { chunkCardsTools } from "./chunk-cards.js";
+import { moduleSummariesTools } from "./module-summaries.js";
+import { performanceTools } from "./performance-optimization.js";
+import { graphTools } from "./database.js";
+// Aggregate all internal tools
+const internal = {
+    ...systemTools(),
+    ...activeSetTools(),
+    ...chunkCardsTools(),
+    ...moduleSummariesTools(),
+    ...performanceTools(),
+    ...graphTools(),
+};
+export function unifiedTools() {
+    return {
+        code_search: tool({
+            description: "Search the codebase using various engines (filename, content, symbol, or semantic/vector).",
+            args: {
+                query: tool.schema.string().describe("Search query"),
+                mode: tool.schema.enum(["filename", "content", "symbol", "semantic"]).optional().default("filename").describe("Search strategy"),
+                path: tool.schema.string().optional().default(".").describe("Root path for search"),
+                limit: tool.schema.number().optional().default(10).describe("Max results"),
+                plan_id: tool.schema.string().optional()
+            },
+            async execute(args) {
+                switch (args.mode) {
+                    case "content": return internal.fast_search.execute({ ...args, mode: "content" });
+                    case "symbol": return internal.graph_search_symbols.execute({ query: args.query });
+                    case "semantic": return internal.graph_semantic_search.execute({ query: args.query, limit: args.limit });
+                    default: return internal.fast_search.execute({ ...args, mode: "filename" });
+                }
+            }
+        }),
+        code_analyze: tool({
+            description: "Perform structural analysis on files or modules. Generates summaries, API maps, and impact reports.",
+            args: {
+                target: tool.schema.string().describe("File path or module ID"),
+                mode: tool.schema.enum(["summary", "api", "invariant", "module", "impact", "reasoning"]).optional().default("summary"),
+                force: tool.schema.boolean().optional().default(false),
+                plan_id: tool.schema.string().optional()
+            },
+            async execute(args) {
+                switch (args.mode) {
+                    case "module": return internal.module_synthesize.execute({ file_path: args.target, force_resynthesize: args.force });
+                    case "impact": return internal.brief_fix_loop.execute({ symbol: args.target, intent: "impact_analysis" });
+                    case "reasoning": return internal.module_hierarchical_reasoning.execute({ module_id: args.target });
+                    default: return internal.chunk_create_card.execute({ file_path: args.target, chunk_type: args.mode, force_recreate: args.force });
+                }
+            }
+        }),
+        code_context: tool({
+            description: "Manage working memory (ActiveSets). Limits context window usage by loading/unloading specific chunks.",
+            args: {
+                action: tool.schema.enum(["create", "load", "add", "remove", "status", "list", "close"]),
+                target: tool.schema.string().optional().describe("ActiveSet ID or Chunk IDs (comma separated)"),
+                name: tool.schema.string().optional().describe("Name for new ActiveSet"),
+                plan_id: tool.schema.string().optional()
+            },
+            async execute(args) {
+                const chunk_ids = args.target?.split(',').map(s => s.trim());
+                switch (args.action) {
+                    case "create": return internal.activeset_create.execute({ name: args.name || "Context", chunk_ids });
+                    case "load": return internal.activeset_load.execute({ set_id: args.target });
+                    case "add": return internal.activeset_add_chunks.execute({ chunk_ids: chunk_ids });
+                    case "remove": return internal.activeset_remove_chunks.execute({ chunk_ids: chunk_ids });
+                    case "list": return internal.activeset_list.execute({});
+                    case "close": return internal.activeset_close.execute({});
+                    default: return internal.activeset_get_current.execute({});
+                }
+            }
+        }),
+        code_read: tool({
+            description: "Precise reading of symbols or file slices. Follows the current plan.",
+            args: {
+                symbol: tool.schema.string().optional().describe("Symbol to jump to"),
+                file: tool.schema.string().optional().describe("File path to read"),
+                start_line: tool.schema.number().optional(),
+                end_line: tool.schema.number().optional(),
+                plan_id: tool.schema.string().optional()
+            },
+            async execute(args) {
+                if (args.symbol)
+                    return internal.jump_to_symbol.execute({ symbol: args.symbol, plan_id: args.plan_id });
+                if (args.file && args.start_line && args.end_line) {
+                    return internal.read_slice.execute({ file: args.file, start_line: args.start_line, end_line: args.end_line, plan_id: args.plan_id });
+                }
+                throw new Error("Either 'symbol' or 'file' with line range must be provided.");
+            }
+        }),
+        code_propose: tool({
+            description: "Plan and propose changes. Generates worklists, diffs, and validates them.",
+            args: {
+                action: tool.schema.enum(["plan", "patch", "validate", "finalize"]),
+                symbol: tool.schema.string().optional().describe("Locus symbol for plan"),
+                intent: tool.schema.string().optional().describe("Work intent (e.g. refactor)"),
+                message: tool.schema.string().optional().describe("Commit message for patch"),
+                patch_path: tool.schema.string().optional().describe("Path to .diff file"),
+                plan_id: tool.schema.string().optional(),
+                outcome: tool.schema.string().optional()
+            },
+            async execute(args) {
+                switch (args.action) {
+                    case "plan": return internal.brief_fix_loop.execute({ symbol: args.symbol, intent: args.intent });
+                    case "patch": return internal.prepare_patch.execute({ message: args.message, plan_id: args.plan_id });
+                    case "validate": return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id });
+                    case "finalize": return internal.finalize_plan.execute({ plan_id: args.plan_id, outcome: args.outcome });
+                }
+            }
+        }),
+        code_status: tool({
+            description: "Monitor system health, background jobs, and plan metrics.",
+            args: {
+                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan"]).optional().default("stats"),
+                job_id: tool.schema.string().optional(),
+                plan_id: tool.schema.string().optional(),
+                path: tool.schema.string().optional().default("")
+            },
+            async execute(args) {
+                switch (args.mode) {
+                    case "hot_files": return internal.journal_query_hot_files.execute({ path_prefix: args.path });
+                    case "jobs": return internal.graph_background_status.execute({ job_id: args.job_id });
+                    case "plan": return internal.graph_get_plan_metrics.execute({ plan_id: args.plan_id });
+                    default: return internal.graph_stats.execute({});
+                }
+            }
+        }),
+        code_setup: tool({
+            description: "One-time setup and maintenance tasks (AI, Git Journal, Indexing).",
+            args: {
+                action: tool.schema.enum(["init", "ai", "index", "journal"]),
+                model: tool.schema.string().optional().describe("AI Model name"),
+                limit: tool.schema.number().optional().describe("History limit")
+            },
+            async execute(args) {
+                switch (args.action) {
+                    case "ai": return internal.autognosis_setup_ai.execute({ model: args.model });
+                    case "index": return internal.perf_incremental_index.execute({ background: true });
+                    case "journal": return internal.journal_build.execute({ limit: args.limit });
+                    default: return internal.autognosis_init.execute({ mode: "apply", token: "adhoc" }); // Simplified
+                }
+            }
+        }),
+        internal_call: tool({
+            description: "Advanced access to specialized internal tools. Use only when unified tools are insufficient.",
+            args: {
+                tool_name: tool.schema.string().describe("Internal tool name"),
+                args: tool.schema.any().describe("Arguments for the internal tool")
+            },
+            async execute({ tool_name, args }) {
+                const target = internal[tool_name];
+                if (!target)
+                    throw new Error(`Internal tool '${tool_name}' not found.`);
+                return target.execute(args);
+            }
+        })
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-autognosis",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Advanced RAG-powered codebase awareness for OpenCode agents. Features Chunk Cards synthesis, hierarchical reasoning, ActiveSet working memory, and performance optimization for enterprise-scale repositories.",
   "type": "module",
   "main": "dist/index.js",