opencode-autognosis 2.2.0 → 2.3.1

package/dist/database.d.ts

@@ -13,8 +13,18 @@ export declare class CodeGraphDB {
     }): void;
     getJob(id: string): any;
     listJobs(type?: string, limit?: number): any;
-    postToBlackboard(author: string, message: string, topic?: 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;
+    acquireLock(resourceId: string, agentName: string, ttlSeconds?: number): void;
+    releaseLock(resourceId: string, agentName: string): void;
+    isLocked(resourceId: string): {
+        owner_agent: string;
+        expires_at: string;
+    } | undefined;
+    listLocks(): any;
     storeIntent(patchId: string, reasoning: string, planId: string): void;
     getIntent(patchId: string): any;
     addArchRule(source: string, target: string): void;

package/dist/database.js

@@ -146,9 +146,21 @@ export class CodeGraphDB {
         author TEXT,
         message TEXT,
         topic TEXT,
+        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
       );
 
+      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,
@@ -222,11 +234,53 @@ export class CodeGraphDB {
         }
         return this.db.prepare("SELECT * FROM background_jobs ORDER BY created_at DESC LIMIT ?").all(limit);
     }
-    postToBlackboard(author, message, topic = 'general') {
+    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, git_hash, is_pinned)
+      VALUES (?, ?, ?, ?, ?, ?)
+      RETURNING id
+    `);
+        const res = insert.get(author, message, topic, symbolId || null, currentHash, isPinned ? 1 : 0);
         this.db.prepare(`
-      INSERT INTO blackboard (author, message, topic)
-      VALUES (?, ?, ?)
-    `).run(author, message, topic);
+      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) {
@@ -238,6 +292,35 @@ export class CodeGraphDB {
       SELECT * FROM blackboard ORDER BY timestamp DESC LIMIT ?
     `).all(limit);
     }
+    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)

package/dist/unified-api.js

@@ -40,13 +40,13 @@ async function updateBridgePrompt(plugins) {
     if (!fsSync.existsSync(bridgePath))
         return "bridge.md not found at " + bridgePath;
     const toolsSection = `
-## Current Consolidated Tools (Autognosis v2.2)
+## Current Consolidated Tools (Autognosis v2.3)
 - code_search: Universal search (semantic, symbol, filename, content).
 - code_analyze: Deep structural analysis and impact reports.
-- code_context: Working memory (ActiveSet) management and LRU eviction.
-- code_read: Precise symbol jumping and file slicing.
+- 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, compliance, and Multi-Agent Blackboard.
+- code_status: System health, background jobs, Multi-Agent Blackboard, and Resource Locks.
 - code_setup: Environment initialization, AI setup, and Architectural Boundaries.
 
 ## Other Detected Plugins
@@ -63,14 +63,15 @@ ${plugins.filter(p => p !== "opencode-autognosis").map(p => `- ${p}`).join('\n')
     return "Updated bridge.md with consolidated tools and detected plugins.";
 }
 export function unifiedTools() {
+    const agentName = process.env.AGENT_NAME || `agent-${process.pid}`;
     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"),
+                mode: tool.schema.enum(["filename", "content", "symbol", "semantic"]).optional().default("filename"),
+                path: tool.schema.string().optional().default("."),
+                limit: tool.schema.number().optional().default(10),
                 plan_id: tool.schema.string().optional()
             },
             async execute(args) {
@@ -106,7 +107,7 @@ export function unifiedTools() {
                 action: tool.schema.enum(["create", "load", "add", "remove", "status", "list", "close", "evict"]),
                 target: tool.schema.string().optional().describe("ActiveSet ID or Chunk IDs"),
                 name: tool.schema.string().optional(),
-                limit: tool.schema.number().optional().default(5).describe("Eviction limit"),
+                limit: tool.schema.number().optional().default(5),
                 plan_id: tool.schema.string().optional()
             },
             async execute(args) {
@@ -126,7 +127,7 @@ export function unifiedTools() {
             }
         }),
         code_read: tool({
-            description: "Precise reading of symbols or file slices. Follows the current plan.",
+            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"),
@@ -135,24 +136,52 @@ export function unifiedTools() {
                 plan_id: tool.schema.string().optional()
             },
             async execute(args) {
-                if (args.symbol) {
-                    getDb().logAccess(args.symbol, args.plan_id);
-                    return internal.jump_to_symbol.execute({ symbol: args.symbol, plan_id: args.plan_id });
-                }
-                if (args.file && args.start_line && args.end_line) {
-                    getDb().logAccess(args.file, args.plan_id);
-                    return internal.read_slice.execute({ file: args.file, start_line: args.start_line, end_line: args.end_line, plan_id: args.plan_id });
+                const resourceId = args.symbol || args.file;
+                if (resourceId) {
+                    getDb().logAccess(resourceId, args.plan_id);
+                    const lock = getDb().isLocked(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 });
+                    }
+                    else {
+                        result = await internal.read_slice.execute({ file: args.file, start_line: args.start_line, end_line: args.end_line, plan_id: args.plan_id });
+                    }
+                    const parsed = JSON.parse(result);
+                    return JSON.stringify({
+                        ...parsed,
+                        coordination: {
+                            lock_status: lock ? `LOCKED by ${lock.owner_agent}` : "FREE",
+                            historical_notes: verifiedGraffiti.length > 0 ? verifiedGraffiti : undefined
+                        }
+                    }, null, 2);
                 }
-                throw new Error("Either 'symbol' or 'file' with line range must be provided.");
+                throw new Error("Either 'symbol' or 'file' must be provided.");
             }
         }),
         code_propose: tool({
-            description: "Plan, propose, and promote changes. Includes patch generation, Intent indexing, and PR promotion.",
+            description: "Plan, propose, and promote changes. Automatically handles coordination pulse and lock checks.",
             args: {
                 action: tool.schema.enum(["plan", "patch", "validate", "finalize", "promote"]),
                 symbol: tool.schema.string().optional(),
                 intent: tool.schema.string().optional(),
-                reasoning: tool.schema.string().optional().describe("Detailed reasoning for the change (Decision Indexing)"),
+                reasoning: tool.schema.string().optional(),
                 message: tool.schema.string().optional(),
                 patch_path: tool.schema.string().optional(),
                 branch: tool.schema.string().optional(),
@@ -161,8 +190,19 @@ export function unifiedTools() {
             },
             async execute(args) {
                 switch (args.action) {
-                    case "plan": return internal.brief_fix_loop.execute({ symbol: args.symbol, intent: args.intent });
+                    case "plan": {
+                        getDb().postToBlackboard(agentName, `Planning ${args.intent} for ${args.symbol}`, "pulse");
+                        return internal.brief_fix_loop.execute({ symbol: args.symbol, intent: args.intent });
+                    }
                     case "patch": {
+                        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}.` });
+                            }
+                        }
                         const { stdout: diff } = await internal.runCmd("git diff");
                         const violations = policyEngine.checkDiff(diff);
                         if (violations.some(v => v.severity === "error")) {
@@ -170,24 +210,15 @@ export function unifiedTools() {
                         }
                         const res = await internal.prepare_patch.execute({ message: args.message, plan_id: args.plan_id });
                         const json = JSON.parse(res);
-                        if (json.status === "SUCCESS" && args.reasoning) {
-                            getDb().storeIntent(json.patch_id, args.reasoning, args.plan_id || "adhoc");
+                        if (json.status === "SUCCESS") {
+                            if (args.reasoning)
+                                getDb().storeIntent(json.patch_id, args.reasoning, args.plan_id || "adhoc");
+                            getDb().postToBlackboard(agentName, `Proposed patch ${json.patch_id}: ${args.message}`, "pulse");
                         }
                         return res;
                     }
                     case "validate": {
-                        // Architectural Boundary 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);
-                            }
-                        }
+                        getDb().postToBlackboard(agentName, `Validating patch ${args.patch_path}`, "pulse");
                         return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id });
                     }
                     case "promote": {
@@ -198,22 +229,28 @@ export function unifiedTools() {
                             execSync(`git apply ${args.patch_path}`);
                             execSync(`git add . && git commit -m "${args.message || 'Automated promotion'}"`);
                             execSync(`gh pr create --title "${args.message}" --body "Automated promotion from Autognosis v2."`);
+                            getDb().postToBlackboard(agentName, `Promoted patch to PR on branch ${branch}`, "pulse");
                             return JSON.stringify({ status: "SUCCESS", promoted_to: branch, pr: "OPENED" }, null, 2);
                         }
                         catch (e) {
                             return JSON.stringify({ status: "ERROR", message: e.message }, null, 2);
                         }
                     }
-                    case "finalize": return internal.finalize_plan.execute({ plan_id: args.plan_id, outcome: args.outcome });
+                    case "finalize": {
+                        getDb().postToBlackboard(agentName, `Finalized plan ${args.plan_id} with outcome: ${args.outcome}`, "pulse");
+                        return internal.finalize_plan.execute({ plan_id: args.plan_id, outcome: args.outcome });
+                    }
                 }
             }
         }),
         code_status: tool({
-            description: "Monitor system health, background jobs, compliance, and Multi-Agent Blackboard.",
+            description: "Monitor system health, Multi-Agent Blackboard, and Resource Locks.",
             args: {
-                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan", "doctor", "blackboard"]).optional().default("stats"),
-                action: tool.schema.enum(["post", "read"]).optional(),
+                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan", "doctor", "blackboard", "locks"]).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) 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(),
@@ -221,11 +258,30 @@ export function unifiedTools() {
             },
             async execute(args) {
                 switch (args.mode) {
+                    case "locks": {
+                        if (args.action === "lock") {
+                            getDb().acquireLock(args.target, agentName);
+                            return JSON.stringify({ status: "SUCCESS", message: `Locked ${args.target}` });
+                        }
+                        else if (args.action === "unlock") {
+                            getDb().releaseLock(args.target, agentName);
+                            return JSON.stringify({ status: "SUCCESS", message: `Unlocked ${args.target}` });
+                        }
+                        return JSON.stringify({ status: "SUCCESS", active_locks: getDb().listLocks() });
+                    }
                     case "blackboard": {
                         if (args.action === "post") {
-                            getDb().postToBlackboard("Agent", args.message, args.topic);
+                            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.2.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",