opencode-workflow-guard 1.8.3 → 1.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-workflow-guard",
-  "version": "1.8.3",
+  "version": "1.8.4",
   "description": "Deterministic workflow and safety policy enforcement for OpenCode",
   "license": "MIT",
   "type": "module",
@@ -34,7 +34,7 @@
     "workflow"
   ],
   "scripts": {
-    "test": "node test/test.mts",
+    "test": "node test/run-test.mjs",
     "test:install": "node test/test-e2e.mts",
     "test:all": "npm run typecheck && npm test && npm run test:install",
     "typecheck": "tsc --noEmit -p tsconfig.json",

package/src/lib/project-memory.ts

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { appendFileSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { execFile, spawnSync } from "node:child_process";
 import { Database, type SqliteDatabase } from "./sqlite.ts";
@@ -7,13 +7,27 @@ import type { ProjectMemoryInput, ProjectMemoryKind, ProjectMemoryRecord, Projec
 
 const KINDS = new Set<ProjectMemoryKind>(["fact", "decision", "constraint", "lesson"]);
 const SOURCES = new Set<ProjectMemorySource>(["user", "file", "git", "tool", "agent", "portable"]);
+const DAY_MS = 24 * 60 * 60 * 1000;
+const OBSOLETE_RETENTION_MS = 90 * DAY_MS;
+const MAINTENANCE_INTERVAL_MS = DAY_MS;
+const STORAGE_LIMIT_BYTES = 100 * 1024 * 1024;
+const STORAGE_TARGET_BYTES = 80 * 1024 * 1024;
 
 export interface ProjectMemoryStore {
 	db: SqliteDatabase;
 	projectId: string;
+	path: string;
+	activeMarker?: string;
 	close(): void;
 }
 
+interface MaintenanceOptions {
+	force?: boolean;
+	now?: number;
+	storageLimitBytes?: number;
+	storageTargetBytes?: number;
+}
+
 export function getProjectMemoryDir(): string {
 	const base = process.env.XDG_DATA_HOME || join(process.env.HOME || process.cwd(), ".local", "share");
 	return join(base, "opencode", "workflow-guard", "project-memory");
@@ -66,14 +80,20 @@ export async function isProjectMemoryFreshAsync(memory: ProjectMemoryRecord, roo
 export function openProjectMemory(projectId: string, directory = getProjectMemoryDir()): ProjectMemoryStore {
 	if (!projectId || projectId.length > 200) throw new Error("Invalid project memory identity.");
 	mkdirSync(directory, { recursive: true, mode: 0o700 });
-	const db = new Database(join(directory, `${projectId.replace(/[^a-zA-Z0-9._-]/g, "_")}.sqlite`));
-	db.exec(`
+	const path = join(directory, `${projectId.replace(/[^a-zA-Z0-9._-]/g, "_")}.sqlite`);
+	const activeMarker = `${path}.active.${process.pid}.${randomUUID()}`;
+	const releaseLock = acquireDatabaseLock(directory);
+	let db: SqliteDatabase | undefined;
+	try {
+		writeFileSync(activeMarker, "", { mode: 0o600 });
+		db = new Database(path);
+		db.exec(`
 		PRAGMA journal_mode = WAL;
 		PRAGMA busy_timeout = 2000;
 		CREATE TABLE IF NOT EXISTS memories (
 			id TEXT PRIMARY KEY, project_id TEXT NOT NULL, kind TEXT NOT NULL, content TEXT NOT NULL,
 			source TEXT NOT NULL, created_at INTEGER NOT NULL, session_id TEXT, commit_sha TEXT,
-			paths TEXT NOT NULL, supersedes TEXT, status TEXT NOT NULL DEFAULT 'current'
+			paths TEXT NOT NULL, supersedes TEXT, status TEXT NOT NULL DEFAULT 'current', superseded_at INTEGER
 		);
 		CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(id UNINDEXED, content);
 		CREATE TABLE IF NOT EXISTS review_followups (
@@ -81,8 +101,105 @@ export function openProjectMemory(projectId: string, directory = getProjectMemor
 			reviewer TEXT NOT NULL, created_at INTEGER NOT NULL, resolved_at INTEGER, session_id TEXT,
 			commit_sha TEXT, paths TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'open'
 		);
-	`);
-	return { db, projectId, close: () => db.close() };
+		`);
+		const memoryColumns = db.prepare("PRAGMA table_info(memories)").all() as Array<{ name: string }>;
+		if (!memoryColumns.some((column) => column.name === "superseded_at")) {
+			db.exec("ALTER TABLE memories ADD COLUMN superseded_at INTEGER");
+			db.exec("UPDATE memories SET superseded_at = created_at WHERE status = 'superseded'");
+		}
+	} catch (error) {
+		try { db?.close(); } finally { rmSync(activeMarker, { force: true }); }
+		throw error;
+	} finally {
+		releaseLock();
+	}
+	if (!db) throw new Error("Project memory database failed to initialize.");
+	const store: ProjectMemoryStore = { db, projectId, path, activeMarker, close: () => { try { db.close(); } finally { rmSync(activeMarker, { force: true }); } } };
+	try { maintainProjectMemoryStorage(store, directory); } catch {}
+	return store;
+}
+
+function acquireDatabaseLock(directory: string): () => void {
+	const lock = new Database(join(directory, ".coordination"));
+	try {
+		lock.exec("PRAGMA busy_timeout = 2000; BEGIN IMMEDIATE");
+	} catch (error) {
+		lock.close();
+		throw error;
+	}
+	return () => { try { lock.exec("COMMIT"); } finally { lock.close(); } };
+}
+
+function databaseDiskUsage(path: string): number {
+	let size = 0;
+	for (const suffix of ["", "-wal", "-shm"]) try { size += statSync(path + suffix).size; } catch {}
+	return size;
+}
+
+function databaseIsActive(path: string, directory: string): boolean {
+	const prefix = `${path.slice(directory.length + 1)}.active.`;
+	let active = false;
+	for (const name of readdirSync(directory).filter((entry) => entry.startsWith(prefix))) {
+		const pid = Number(name.slice(prefix.length).split(".", 1)[0]);
+		if (!Number.isInteger(pid) || pid <= 0) { active = true; continue; }
+		try { process.kill(pid, 0); active = true; } catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ESRCH") rmSync(join(directory, name), { force: true });
+			else active = true;
+		}
+	}
+	return active;
+}
+
+export function maintainProjectMemoryStorage(store: ProjectMemoryStore, directory = getProjectMemoryDir(), options: MaintenanceOptions = {}): void {
+	const now = options.now ?? Date.now();
+	const maintenanceMarker = `${store.path}.maintenance`;
+	const releaseMaintenanceLock = acquireDatabaseLock(directory);
+	try {
+		let lastMaintained = 0;
+		try { lastMaintained = statSync(maintenanceMarker).mtimeMs; } catch {}
+		if (!options.force && now - lastMaintained < MAINTENANCE_INTERVAL_MS) return;
+
+		const cutoff = now - OBSOLETE_RETENTION_MS;
+		store.db.exec("BEGIN IMMEDIATE");
+		try {
+			store.db.prepare("DELETE FROM memories_fts WHERE id IN (SELECT id FROM memories WHERE status = 'superseded' AND superseded_at < ?)").run(cutoff);
+			store.db.prepare("DELETE FROM memories WHERE status = 'superseded' AND superseded_at < ?").run(cutoff);
+			store.db.prepare("DELETE FROM review_followups WHERE status = 'resolved' AND resolved_at < ?").run(cutoff);
+			store.db.exec("COMMIT");
+		} catch (error) {
+			store.db.exec("ROLLBACK");
+			throw error;
+		}
+		store.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+		store.db.exec("PRAGMA optimize");
+		store.db.exec("VACUUM");
+		try { utimesSync(store.path, now / 1000, now / 1000); } catch {}
+		writeFileSync(maintenanceMarker, "", { mode: 0o600 });
+		try { utimesSync(maintenanceMarker, now / 1000, now / 1000); } catch {}
+	} finally {
+		releaseMaintenanceLock();
+	}
+
+	const limit = options.storageLimitBytes ?? STORAGE_LIMIT_BYTES;
+	const target = Math.min(limit, options.storageTargetBytes ?? STORAGE_TARGET_BYTES);
+	const candidates = readdirSync(directory)
+		.filter((name) => name.endsWith(".sqlite"))
+		.map((name) => join(directory, name))
+		.filter((path) => path !== store.path)
+		.flatMap((path) => { try { const stat = statSync(path); return [{ path, size: databaseDiskUsage(path), mtimeMs: stat.mtimeMs }]; } catch { return []; } });
+	let total = candidates.reduce((sum, item) => sum + item.size, databaseDiskUsage(store.path));
+	if (total <= limit) return;
+	for (const candidate of candidates.sort((a, b) => a.mtimeMs - b.mtimeMs)) {
+		const releaseCandidateLock = acquireDatabaseLock(directory);
+		try {
+			if (databaseIsActive(candidate.path, directory)) continue;
+			for (const suffix of ["", "-wal", "-shm", ".maintenance"]) rmSync(candidate.path + suffix, { force: true });
+		} finally {
+			releaseCandidateLock();
+		}
+		total -= candidate.size;
+		if (total <= target) break;
+	}
 }
 
 function followupRowToRecord(row: Record<string, unknown>): ReviewFollowup {
@@ -147,8 +264,8 @@ export function recordProjectMemory(store: ProjectMemoryStore, input: ProjectMem
 	const createdAt = Date.now();
 	store.db.exec("BEGIN IMMEDIATE");
 	try {
-		if (input.supersedes) store.db.prepare("UPDATE memories SET status = 'superseded' WHERE id = ? AND project_id = ?").run(input.supersedes, store.projectId);
-		store.db.prepare("INSERT INTO memories VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'current')").run(
+		if (input.supersedes) store.db.prepare("UPDATE memories SET status = 'superseded', superseded_at = ? WHERE id = ? AND project_id = ?").run(createdAt, input.supersedes, store.projectId);
+		store.db.prepare("INSERT INTO memories (id, project_id, kind, content, source, created_at, session_id, commit_sha, paths, supersedes, status, superseded_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'current', NULL)").run(
 			id, store.projectId, input.kind, input.content.trim(), input.source, createdAt,
 			input.sessionID ?? null, input.commit ?? null, JSON.stringify(input.paths ?? []), input.supersedes ?? null,
 		);

package/src/policies/shell-safety.ts

@@ -129,7 +129,7 @@ export function escapeAppleScriptString(str: string): string {
 
 /**
  * Dispatches a native OS desktop notification (macOS osascript or Linux notify-send)
- * on important guard events (policy blocks, verification completion).
+ * for events that explicitly require the user's attention.
  * Non-blocking, fails gracefully.
  */
 export function sendDesktopNotification(title: string, message: string): void {

package/src/workflow-guard-ui.ts

@@ -31,9 +31,9 @@ function text(props: Record<string, unknown>, children: Child[]) {
 }
 
 const BADGE_ACTIVE = "Workflow Guard 🛡️";
+const BLOCKED_BADGE_DURATION_MS = 5_000;
 let lastBlockedReason: string | undefined;
 const sessionBlockedReasons = new Map<string, string>();
-const badgeNodes = new Map<string, BaseRenderable>();
 
 export function readProjectOption(root: string, option: "recoveryCheckpoints" | "projectMemory" | "learning"): boolean {
 	const path = projectConfigPath(root);
@@ -86,12 +86,15 @@ export function formatBadge(sessionID?: string): { text: string; isBlocked: bool
 	if (!reason) {
 		return { text: BADGE_ACTIVE, isBlocked: false };
 	}
-	const cleanReason = reason.replace(/^\[workflow-guard\]\s*/, "").replace(/^Blocked:\s*/, "");
+	const cleanReason = reason.replace(/^\[workflow-guard\]\s*/i, "").replace(/^Blocked(?::|\s+)\s*/i, "");
 	const shortReason = cleanReason.length > 30 ? cleanReason.slice(0, 27) + "..." : cleanReason;
 	return { text: `[Workflow Guard: Blocked: ${shortReason}]`, isBlocked: true };
 }
 
 export const WorkflowGuardTui: TuiPlugin = async (api) => {
+	const badgeNodes = new Map<string, BaseRenderable>();
+	const blockedBadgeTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
 	api.keymap.registerLayer({
 		commands: [{
 			name: "workflow-guard.project-options",
@@ -125,18 +128,34 @@ export const WorkflowGuardTui: TuiPlugin = async (api) => {
 		bindings: [],
 	});
 
+	function scheduleBadgeReset(sessionID?: string): void {
+		const key = sessionID ?? "home";
+		const existing = blockedBadgeTimers.get(key);
+		if (existing) clearTimeout(existing);
+		blockedBadgeTimers.set(key, setTimeout(() => {
+			blockedBadgeTimers.delete(key);
+			if (sessionID) sessionBlockedReasons.delete(sessionID);
+			else lastBlockedReason = undefined;
+			const node = badgeNodes.get(key);
+			if (node) {
+				setProp(node, "content", BADGE_ACTIVE);
+				setProp(node, "fg", api.theme.current.success);
+			}
+		}, BLOCKED_BADGE_DURATION_MS));
+	}
+
 	try {
 		api.event.on("tui.toast.show", (e) => {
 			const title = e.properties.title;
 			const msg = e.properties.message;
 			if (title === "Workflow Guard Blocked" && typeof msg === "string") {
-				lastBlockedReason = msg;
 				const route = api.route.current;
 				const sessionID =
 					route.name === "session" && typeof route.params?.sessionID === "string"
 						? route.params.sessionID
 						: undefined;
 				if (sessionID) sessionBlockedReasons.set(sessionID, msg);
+				else lastBlockedReason = msg;
 				const key = sessionID ?? "home";
 				const node = badgeNodes.get(key);
 				if (node) {
@@ -144,6 +163,7 @@ export const WorkflowGuardTui: TuiPlugin = async (api) => {
 					setProp(node, "content", badge.text);
 					setProp(node, "fg", badge.isBlocked ? api.theme.current.warning : api.theme.current.success);
 				}
+				scheduleBadgeReset(sessionID);
 			}
 		});
 	} catch {}

package/src/workflow-guard.ts

@@ -122,6 +122,7 @@ export {
 	ensureProjectMemoryExcluded,
 	isProjectMemoryFresh,
 	openProjectMemory,
+	maintainProjectMemoryStorage,
 	recordProjectMemory,
 	searchProjectMemory,
 	getRecentProjectMemory,
@@ -270,7 +271,6 @@ export { branchHasDocumentationChange };
 import {
 	checkInteractiveTtyCommand,
 	checkPackageHygiene,
-	sendDesktopNotification,
 	escapeAppleScriptString,
 } from "./policies/shell-safety.ts";
 
@@ -278,7 +278,8 @@ import { checkCompletionClaims } from "./policies/completion.ts";
 
 export { checkCompletionClaims };
 
-export { checkInteractiveTtyCommand, checkPackageHygiene, sendDesktopNotification, escapeAppleScriptString };
+export { sendDesktopNotification } from "./policies/shell-safety.ts";
+export { checkInteractiveTtyCommand, checkPackageHygiene, escapeAppleScriptString };
 
 function logObservation(client: unknown, message: string): void {
 	try {
@@ -322,9 +323,6 @@ export async function guardToolCall(
 }
 
 async function emitBlockFeedback(message: string): Promise<void> {
-	try {
-		sendDesktopNotification("Workflow Guard Blocked", message);
-	} catch {}
 	await showBlockToast(message);
 }