opencode-autognosis 2.3.0 → 2.4.0

package/dist/database.d.ts

@@ -13,9 +13,11 @@ export declare class CodeGraphDB {
     }): void;
     getJob(id: string): any;
     listJobs(type?: string, limit?: number): any;
-    postToBlackboard(author: string, message: string, topic?: string, symbolId?: string): void;
+    postToBlackboard(author: string, message: string, topic?: string, symbolId?: string, isPinned?: boolean): void;
+    getGraffiti(symbolId: string, limit?: number): any;
+    archiveGraffiti(symbolId: string): void;
+    pinGraffiti(id: number, pinned?: boolean): void;
     readBlackboard(topic?: string, limit?: number): any;
-    getGraffiti(symbolId: string): any;
     acquireLock(resourceId: string, agentName: string, ttlSeconds?: number): void;
     releaseLock(resourceId: string, agentName: string): void;
     isLocked(resourceId: string): {
@@ -53,6 +55,7 @@ export declare class CodeGraphDB {
     };
     findDependents(filePath: string): string[];
     searchSymbols(query: string): any[];
+    findAffectedTests(symbolName: string): string[];
     semanticSearch(query: string, limit?: number): Promise<any[]>;
     private cosineSimilarity;
     getStats(): {

package/dist/database.js

@@ -146,8 +146,11 @@ export class CodeGraphDB {
         author TEXT,
         message TEXT,
         topic TEXT,
-        symbol_id TEXT, -- Optional link to a code symbol
-        embedding BLOB, -- For semantic search on the blackboard
+        symbol_id TEXT,
+        git_hash TEXT, -- Version of code when note was made
+        is_archived BOOLEAN DEFAULT 0,
+        is_pinned BOOLEAN DEFAULT 0,
+        embedding BLOB,
         timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
       );
 
@@ -231,19 +234,54 @@ 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) {
+    postToBlackboard(author, message, topic = 'general', symbolId, isPinned = false) {
+        // Get current git hash for contextual verification
+        let currentHash = "unknown";
+        try {
+            const { execSync } = require("node:child_process");
+            currentHash = execSync("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+        }
+        catch { }
         const insert = this.db.prepare(`
-      INSERT INTO blackboard (author, message, topic, symbol_id)
-      VALUES (?, ?, ?, ?)
+      INSERT INTO blackboard (author, message, topic, symbol_id, git_hash, is_pinned)
+      VALUES (?, ?, ?, ?, ?, ?)
       RETURNING id
     `);
-        const res = insert.get(author, message, topic, symbolId || null);
-        // Queue for embedding (blackboard search)
+        const res = insert.get(author, message, topic, symbolId || null, currentHash, isPinned ? 1 : 0);
         this.db.prepare(`
       INSERT INTO embedding_queue (chunk_id, text_to_embed)
       VALUES (?, ?)
     `).run(`blackboard-${res.id}`, `${topic.toUpperCase()}: ${message}`);
     }
+    getGraffiti(symbolId, limit = 3) {
+        // Automatically archive notes older than 7 days that aren't pinned
+        this.db.prepare(`
+        UPDATE blackboard 
+        SET is_archived = 1 
+        WHERE is_pinned = 0 
+        AND timestamp < datetime('now', '-7 days')
+    `).run();
+        return this.db.prepare(`
+      SELECT author, message, timestamp, git_hash, is_pinned
+      FROM blackboard 
+      WHERE symbol_id = ? 
+      AND is_archived = 0
+      ORDER BY is_pinned DESC, timestamp DESC
+      LIMIT ?
+    `).all(symbolId, limit);
+    }
+    archiveGraffiti(symbolId) {
+        this.db.prepare(`
+      UPDATE blackboard 
+      SET is_archived = 1 
+      WHERE symbol_id = ? AND is_pinned = 0
+    `).run(symbolId);
+    }
+    pinGraffiti(id, pinned = true) {
+        this.db.prepare(`
+      UPDATE blackboard SET is_pinned = ? WHERE id = ?
+    `).run(pinned ? 1 : 0, id);
+    }
     readBlackboard(topic, limit = 10) {
         if (topic) {
             return this.db.prepare(`
@@ -254,14 +292,6 @@ export class CodeGraphDB {
       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);
@@ -494,6 +524,29 @@ ${card.content.slice(0, 2000)}`;
     `);
         return stmt.all(`%${query}%`);
     }
+    findAffectedTests(symbolName) {
+        // Find all files that call this symbol and look like test files
+        const query = this.db.prepare(`
+      WITH RECURSIVE impact_tree(caller_chunk_id) AS (
+        -- Base case: chunks calling the symbol directly
+        SELECT caller_chunk_id FROM calls WHERE callee_name = ?
+        UNION
+        -- Recursive step: chunks calling chunks in the impact tree
+        SELECT c.caller_chunk_id 
+        FROM calls c
+        JOIN impact_tree it ON c.callee_name IN (
+          SELECT s.name FROM symbols s WHERE s.chunk_id = it.caller_chunk_id
+        )
+      )
+      SELECT DISTINCT f.path
+      FROM files f
+      JOIN chunks c ON f.id = c.file_id
+      JOIN impact_tree it ON c.id = it.caller_chunk_id
+      WHERE f.path LIKE '%.test.%' OR f.path LIKE '%Tests.%' OR f.path LIKE 'test_%'
+    `);
+        const results = query.all(symbolName);
+        return results.map(r => r.path);
+    }
     async semanticSearch(query, limit = 10) {
         if (!(await ollama.isRunning()))
             throw new Error("Ollama is not running.");

package/dist/unified-api.js

@@ -40,14 +40,14 @@ async function updateBridgePrompt(plugins) {
     if (!fsSync.existsSync(bridgePath))
         return "bridge.md not found at " + bridgePath;
     const toolsSection = `
-## Current Consolidated Tools (Autognosis v2.3)
+## Current Consolidated Tools (Autognosis v2.4)
 - code_search: Universal search (semantic, symbol, filename, content).
 - code_analyze: Deep structural analysis and impact reports.
-- code_context: Working memory (ActiveSet) management, LRU eviction, and Symbol Graffiti.
-- code_read: Precise symbol jumping and file slicing with Mutex Lock checks.
-- code_propose: Planning, patch generation, PR promotion, and Intent indexing.
-- code_status: System health, background jobs, Multi-Agent Blackboard, and Resource Locks.
-- code_setup: Environment initialization, AI setup, and Architectural Boundaries.
+- code_context: Working memory management and LRU eviction.
+- code_read: Precise reading with Mutex Lock checks and Graffiti retrieval.
+- code_propose: Planning, patching, validation, and PR promotion. Now features surgical test scoping.
+- code_status: Dashboard, background jobs, blackboard, and resource locks.
+- code_setup: Environment initialization and architectural boundaries.
 
 ## Other Detected Plugins
 ${plugins.filter(p => p !== "opencode-autognosis").map(p => `- ${p}`).join('\n')}
@@ -127,7 +127,7 @@ export function unifiedTools() {
             }
         }),
         code_read: tool({
-            description: "Precise reading of symbols or file slices. Follows current plan. Checks for locks and returns graffiti.",
+            description: "Precise reading of symbols or file slices. Follows current plan. Checks for locks and returns historical graffiti.",
             args: {
                 symbol: tool.schema.string().optional().describe("Symbol to jump to"),
                 file: tool.schema.string().optional().describe("File path to read"),
@@ -140,7 +140,20 @@ export function unifiedTools() {
                 if (resourceId) {
                     getDb().logAccess(resourceId, args.plan_id);
                     const lock = getDb().isLocked(resourceId);
-                    const graffiti = getDb().getGraffiti(resourceId);
+                    const graffiti = getDb().getGraffiti(resourceId, 3);
+                    let currentHash = "";
+                    try {
+                        const { execSync } = await import("node:child_process");
+                        currentHash = execSync("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+                    }
+                    catch { }
+                    const verifiedGraffiti = graffiti.map((g) => ({
+                        author: g.author,
+                        message: g.message,
+                        timestamp: g.timestamp,
+                        status: g.git_hash !== currentHash ? "LEGACY (Potentially Outdated)" : "CURRENT",
+                        is_pinned: !!g.is_pinned
+                    }));
                     let result;
                     if (args.symbol) {
                         result = await internal.jump_to_symbol.execute({ symbol: args.symbol, plan_id: args.plan_id });
@@ -153,7 +166,7 @@ export function unifiedTools() {
                         ...parsed,
                         coordination: {
                             lock_status: lock ? `LOCKED by ${lock.owner_agent}` : "FREE",
-                            graffiti: graffiti.length > 0 ? graffiti : undefined
+                            historical_notes: verifiedGraffiti.length > 0 ? verifiedGraffiti : undefined
                         }
                     }, null, 2);
                 }
@@ -161,10 +174,10 @@ export function unifiedTools() {
             }
         }),
         code_propose: tool({
-            description: "Plan, propose, and promote changes. Automatically handles coordination pulse and lock checks.",
+            description: "Plan, propose, and promote changes. Includes patch generation, surgical test scoping, and PR promotion.",
             args: {
                 action: tool.schema.enum(["plan", "patch", "validate", "finalize", "promote"]),
-                symbol: tool.schema.string().optional(),
+                symbol: tool.schema.string().optional().describe("Locus symbol for plan"),
                 intent: tool.schema.string().optional(),
                 reasoning: tool.schema.string().optional(),
                 message: tool.schema.string().optional(),
@@ -180,22 +193,19 @@ export function unifiedTools() {
                         return internal.brief_fix_loop.execute({ symbol: args.symbol, intent: args.intent });
                     }
                     case "patch": {
-                        // 1. Check for locks on all changed files
-                        const { stdout: diff } = await internal.runCmd("git diff");
                         const { stdout: files } = await internal.runCmd("git diff --name-only");
                         const changedFiles = files.split('\n').filter(Boolean);
                         for (const file of changedFiles) {
                             const lock = getDb().isLocked(file);
                             if (lock && lock.owner_agent !== agentName) {
-                                return JSON.stringify({ status: "COLLISION_PREVENTED", message: `File ${file} is locked by ${lock.owner_agent}. Use 'code_status' to investigate.` });
+                                return JSON.stringify({ status: "COLLISION_PREVENTED", message: `File ${file} is locked by ${lock.owner_agent}.` });
                             }
                         }
-                        // 2. Run Policy Engine
+                        const { stdout: diff } = await internal.runCmd("git diff");
                         const violations = policyEngine.checkDiff(diff);
                         if (violations.some(v => v.severity === "error")) {
                             return JSON.stringify({ status: "POLICY_VIOLATION", violations, message: "Patch rejected by policy engine." }, null, 2);
                         }
-                        // 3. Prepare patch and record intent
                         const res = await internal.prepare_patch.execute({ message: args.message, plan_id: args.plan_id });
                         const json = JSON.parse(res);
                         if (json.status === "SUCCESS") {
@@ -206,8 +216,26 @@ export function unifiedTools() {
                         return res;
                     }
                     case "validate": {
-                        getDb().postToBlackboard(agentName, `Validating patch ${args.patch_path}`, "pulse");
-                        return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id });
+                        // 1. Arch Check
+                        const { stdout: diff } = await internal.runCmd("git diff --name-only");
+                        const changedFiles = diff.split('\n').filter(Boolean);
+                        for (const file of changedFiles) {
+                            const deps = await internal.extractDependencies.execute({ content: "", ast: null, filePath: file });
+                            const imports = JSON.parse(deps);
+                            for (const imp of imports) {
+                                const violation = getDb().checkArchViolation(file, imp);
+                                if (violation)
+                                    return JSON.stringify({ status: "ARCH_VIOLATION", file, forbidden_import: imp, rule: violation }, null, 2);
+                            }
+                        }
+                        // 2. Surgical Test Scoping
+                        let focusTests = [];
+                        if (args.symbol) {
+                            focusTests = getDb().findAffectedTests(args.symbol);
+                        }
+                        getDb().postToBlackboard(agentName, `Validating patch ${args.patch_path}. Scoped tests: ${focusTests.length}`, "pulse");
+                        // Call validation with scoped tests hint
+                        return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id, tests: focusTests });
                     }
                     case "promote": {
                         const branch = args.branch || `autognosis-fix-${Date.now()}`;
@@ -234,10 +262,11 @@ export function unifiedTools() {
         code_status: tool({
             description: "Monitor system health, background jobs, Multi-Agent Blackboard, and Resource Locks.",
             args: {
-                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan", "doctor", "blackboard", "locks"]).optional().default("stats"),
-                action: tool.schema.enum(["post", "read", "lock", "unlock"]).optional(),
+                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan", "doctor", "blackboard", "locks", "dashboard"]).optional().default("stats"),
+                action: tool.schema.enum(["post", "read", "lock", "unlock", "archive", "pin"]).optional(),
                 topic: tool.schema.string().optional().default("general"),
-                target: tool.schema.string().optional().describe("Resource ID (file/symbol) for locks or Symbol ID for graffiti"),
+                target: tool.schema.string().optional().describe("Resource ID or Note ID"),
+                pinned: tool.schema.boolean().optional().default(false),
                 message: tool.schema.string().optional(),
                 job_id: tool.schema.string().optional(),
                 plan_id: tool.schema.string().optional(),
@@ -245,6 +274,25 @@ export function unifiedTools() {
             },
             async execute(args) {
                 switch (args.mode) {
+                    case "dashboard": {
+                        const stats = getDb().getStats();
+                        const locks = getDb().listLocks();
+                        const jobs = getDb().listJobs();
+                        const compliance = args.plan_id ? getDb().getPlanMetrics(args.plan_id) : null;
+                        let dashboard = `# Autognosis TUI Dashboard\n\n`;
+                        dashboard += `## 📊 System Stats\n- Files: ${stats.files}\n- Chunks: ${stats.chunks}\n- Embedded: ${stats.embeddings.completed}/${stats.chunks}\n\n`;
+                        dashboard += `## 🔒 Active Locks\n`;
+                        if (locks.length > 0)
+                            dashboard += locks.map((l) => `- ${l.resource_id} (${l.owner_agent})`).join('\n') + '\n\n';
+                        else
+                            dashboard += "_No active locks._\n\n";
+                        dashboard += `## ⚙️ Recent Jobs\n`;
+                        dashboard += jobs.map((j) => `- [${j.status.toUpperCase()}] ${j.type} (${j.progress}%)`).join('\n') + '\n\n';
+                        if (compliance) {
+                            dashboard += `## 📉 Plan Compliance (${args.plan_id})\n- Score: ${compliance.compliance}%\n- Total Calls: ${compliance.total}\n- Off-Plan: ${compliance.off_plan}\n`;
+                        }
+                        return dashboard;
+                    }
                     case "locks": {
                         if (args.action === "lock") {
                             getDb().acquireLock(args.target, agentName);
@@ -258,9 +306,17 @@ export function unifiedTools() {
                     }
                     case "blackboard": {
                         if (args.action === "post") {
-                            getDb().postToBlackboard(agentName, args.message, args.topic, args.target);
+                            getDb().postToBlackboard(agentName, args.message, args.topic, args.target, args.pinned);
                             return JSON.stringify({ status: "SUCCESS", message: "Posted to blackboard." });
                         }
+                        else if (args.action === "archive") {
+                            getDb().archiveGraffiti(args.target);
+                            return JSON.stringify({ status: "SUCCESS", message: `Archived notes for ${args.target}` });
+                        }
+                        else if (args.action === "pin") {
+                            getDb().pinGraffiti(parseInt(args.target, 10), true);
+                            return JSON.stringify({ status: "SUCCESS", message: `Pinned note ${args.target}` });
+                        }
                         return JSON.stringify({ status: "SUCCESS", entries: getDb().readBlackboard(args.topic) });
                     }
                     case "hot_files": return internal.journal_query_hot_files.execute({ path_prefix: args.path });
@@ -280,14 +336,14 @@ export function unifiedTools() {
             }
         }),
         code_setup: tool({
-            description: "Setup and maintenance tasks (AI, Git Journal, Indexing, Prompt Scouting, Arch Boundaries).",
+            description: "Setup tasks (AI, Git Journal, Indexing, Prompt Scouting, Arch Boundaries).",
             args: {
                 action: tool.schema.enum(["init", "ai", "index", "journal", "scout", "arch_rule"]),
                 provider: tool.schema.enum(["ollama", "mlx"]).optional().default("ollama"),
                 model: tool.schema.string().optional(),
                 limit: tool.schema.number().optional(),
-                source: tool.schema.string().optional().describe("Source target pattern"),
-                target: tool.schema.string().optional().describe("Target target pattern (forbidden)")
+                source: tool.schema.string().optional(),
+                target: tool.schema.string().optional()
             },
             async execute(args) {
                 switch (args.action) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-autognosis",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "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",