opencode-autognosis 2.3.0 → 2.3.1

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): {

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);

package/dist/unified-api.js

@@ -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,22 @@ export function unifiedTools() {
                 if (resourceId) {
                     getDb().logAccess(resourceId, args.plan_id);
                     const lock = getDb().isLocked(resourceId);
-                    const graffiti = getDb().getGraffiti(resourceId);
+                    // Smart History Housekeeping
+                    const graffiti = getDb().getGraffiti(resourceId, 3); // Limit to top 3 recent/pinned notes
+                    // Contextual Verification: Get current hash
+                    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 +168,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);
                 }
@@ -180,22 +195,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") {
@@ -232,12 +244,13 @@ export function unifiedTools() {
             }
         }),
         code_status: tool({
-            description: "Monitor system health, background jobs, Multi-Agent Blackboard, and Resource Locks.",
+            description: "Monitor system health, 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(),
+                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 (file/symbol) 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(),
@@ -258,9 +271,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 });

package/package.json

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