opencode-workflow-guard 1.8.1 → 1.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-workflow-guard",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "Deterministic workflow and safety policy enforcement for OpenCode",
   "license": "MIT",
   "type": "module",

package/src/lib/audit.ts

@@ -1,7 +1,8 @@
 import { appendFileSync, chmodSync, existsSync, mkdirSync, openSync, readSync, closeSync, renameSync, statSync, readFileSync, writeFileSync } from "node:fs";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 import type { AuditEntry, VerifyResult } from "./types.ts";
 import { asRecord } from "./utils.ts";
 
@@ -17,6 +18,37 @@ const MAX_AUDIT_BYTES = 4 * 1024 * 1024;
 const RETAIN_AUDIT_BYTES = 2 * 1024 * 1024;
 const MAX_VERIFY_HISTORY_BYTES = 1024 * 1024;
 const RETAIN_VERIFY_HISTORY_BYTES = 512 * 1024;
+let verifiedHistoryState: { size: number; mtimeMs: number; ctimeMs: number; ino: number | bigint } | undefined;
+const lockDatabases = new Map<string, DatabaseSync>();
+
+function getVerifyHistoryState(): typeof verifiedHistoryState {
+	const stat = statSync(VERIFY_HISTORY_FILE);
+	return { size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, ino: stat.ino };
+}
+
+function sameVerifyHistoryState(a: typeof verifiedHistoryState, b: typeof verifiedHistoryState): boolean {
+	return a?.size === b?.size && a?.mtimeMs === b?.mtimeMs && a?.ctimeMs === b?.ctimeMs && a?.ino === b?.ino;
+}
+
+function withFileLock<T>(path: string, action: () => T): T {
+	let db = lockDatabases.get(path);
+	if (!db) {
+		const lockPath = `${path}.lock.sqlite`;
+		db = new DatabaseSync(lockPath);
+		db.exec("PRAGMA busy_timeout = 5000");
+		chmodSync(lockPath, 0o600);
+		lockDatabases.set(path, db);
+	}
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		const result = action();
+		db.exec("COMMIT");
+		return result;
+	} catch (error) {
+		try { db.exec("ROLLBACK"); } catch {}
+		throw error;
+	}
+}
 
 export function getAuditFilePath(): string {
 	return AUDIT_FILE;
@@ -30,7 +62,7 @@ export function getVerifyHistoryFilePath(): string {
 	return VERIFY_HISTORY_FILE;
 }
 
-function appendBoundedJsonl(path: string, value: unknown, maxBytes: number, retainBytes: number): void {
+function appendBoundedJsonlUnlocked(path: string, value: unknown, maxBytes: number, retainBytes: number): void {
 	appendFileSync(path, JSON.stringify(value) + "\n", { encoding: "utf8", mode: 0o600 });
 	chmodSync(path, 0o600);
 	const stat = statSync(path);
@@ -46,31 +78,43 @@ function appendBoundedJsonl(path: string, value: unknown, maxBytes: number, reta
 	const text = buffer.toString("utf8");
 	const firstNewline = text.indexOf("\n");
 	const retained = firstNewline >= 0 ? text.slice(firstNewline + 1) : "";
-	const temp = `${path}.${process.pid}.tmp`;
+	const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
 	writeFileSync(temp, retained, { encoding: "utf8", mode: 0o600 });
 	renameSync(temp, path);
 }
 
+function appendBoundedJsonl(path: string, value: unknown, maxBytes: number, retainBytes: number): void {
+	withFileLock(path, () => appendBoundedJsonlUnlocked(path, value, maxBytes, retainBytes));
+}
+
+function verifyHistoryNeedsSanitation(): boolean {
+	if (!existsSync(VERIFY_HISTORY_FILE)) return false;
+	const state = getVerifyHistoryState();
+	if (sameVerifyHistoryState(verifiedHistoryState, state)) return false;
+	return readFileSync(VERIFY_HISTORY_FILE, "utf8").split("\n").some((line) => {
+		if (!line.trim()) return false;
+		try {
+			const value = JSON.parse(line) as { command?: unknown; output?: unknown };
+			return typeof value.command !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value.command) || typeof value.output !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value.output);
+		} catch {
+			return true;
+		}
+	});
+}
+
 export function persistVerifyHistory(verifyData: NonNullable<VerifyResult>): void {
 	try {
 		mkdirSync(AUDIT_DIR, { recursive: true });
-		if (existsSync(VERIFY_HISTORY_FILE)) {
-			const legacy = readFileSync(VERIFY_HISTORY_FILE, "utf8").split("\n").some((line) => {
-				if (!line.trim()) return false;
-				try {
-					const value = JSON.parse(line) as { command?: unknown; output?: unknown };
-					return typeof value.command !== "string" || !value.command.startsWith("sha256:") || typeof value.output !== "string" || !value.output.startsWith("sha256:");
-				} catch {
-					return true;
-				}
-			});
-			if (legacy) writeFileSync(VERIFY_HISTORY_FILE, "", { encoding: "utf8", mode: 0o600 });
-		}
-		appendBoundedJsonl(VERIFY_HISTORY_FILE, {
-			...verifyData,
-			command: `sha256:${createHash("sha256").update(verifyData.command).digest("hex")}`,
-			output: `sha256:${createHash("sha256").update(verifyData.output).digest("hex")}`,
-		}, MAX_VERIFY_HISTORY_BYTES, RETAIN_VERIFY_HISTORY_BYTES);
+		withFileLock(VERIFY_HISTORY_FILE, () => {
+			if (verifyHistoryNeedsSanitation()) writeFileSync(VERIFY_HISTORY_FILE, "", { encoding: "utf8", mode: 0o600 });
+			appendBoundedJsonlUnlocked(VERIFY_HISTORY_FILE, {
+				...verifyData,
+				command: `sha256:${createHash("sha256").update(verifyData.command).digest("hex")}`,
+				output: `sha256:${createHash("sha256").update(verifyData.output).digest("hex")}`,
+			}, MAX_VERIFY_HISTORY_BYTES, RETAIN_VERIFY_HISTORY_BYTES);
+			const state = getVerifyHistoryState();
+			verifiedHistoryState = verifyHistoryNeedsSanitation() ? undefined : state;
+		});
 	} catch {}
 }
 

package/src/lib/project-memory.ts

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 import { DatabaseSync } from "node:sqlite";
 import type { ProjectMemoryInput, ProjectMemoryKind, ProjectMemoryRecord, ProjectMemorySource, ReviewFollowup, ReviewFollowupInput } from "./types.ts";
 
@@ -45,6 +45,24 @@ export function isProjectMemoryFresh(memory: ProjectMemoryRecord, root: string):
 	return untracked.status === 0 && !untracked.stdout.trim();
 }
 
+function execGit(root: string, args: string[]): Promise<{ status: number; stdout: string }> {
+	return new Promise((resolve) => {
+		execFile("git", ["-C", root, ...args], { encoding: "utf8", timeout: 2_000 }, (error, stdout) => {
+			resolve({ status: error ? (typeof error.code === "number" ? error.code : -1) : 0, stdout });
+		});
+	});
+}
+
+export async function isProjectMemoryFreshAsync(memory: ProjectMemoryRecord, root: string): Promise<boolean> {
+	if (!memory.commit || memory.paths.length === 0) return true;
+	if (!/^[0-9a-f]{7,64}$/i.test(memory.commit)) return false;
+	const [diff, untracked] = await Promise.all([
+		execGit(root, ["diff", "--quiet", memory.commit, "--", ...memory.paths]),
+		execGit(root, ["ls-files", "--others", "--exclude-standard", "--", ...memory.paths]),
+	]);
+	return diff.status === 0 && untracked.status === 0 && !untracked.stdout.trim();
+}
+
 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 });

package/src/lib/tool-outcomes.ts

@@ -21,8 +21,11 @@ export interface ToolOutcome {
 	repeatedFailureCount?: number;
 }
 
+const MAX_TRACKED_CALLS = 4096;
+
 export class ToolOutcomeTracker {
 	private readonly terminalCalls = new Map<string, Set<string>>();
+	private readonly fallbackCalls = new Map<string, Set<string>>();
 	private readonly failures = new Map<string, { signature: string; count: number }>();
 
 	record(part: ToolOutcomePart): ToolOutcome | undefined {
@@ -35,7 +38,13 @@ export class ToolOutcomeTracker {
 			this.terminalCalls.set(part.sessionID, terminalCalls);
 		}
 		if (terminalCalls.has(part.callID)) return undefined;
+		const fallbackCalls = this.fallbackCalls.get(part.sessionID);
+		if (fallbackCalls?.delete(part.callID) && status === "completed") {
+			terminalCalls.add(part.callID);
+			return undefined;
+		}
 		terminalCalls.add(part.callID);
+		if (terminalCalls.size > MAX_TRACKED_CALLS) terminalCalls.delete(terminalCalls.values().next().value!);
 
 		const start = part.state?.time?.start;
 		const end = part.state?.time?.end;
@@ -53,8 +62,21 @@ export class ToolOutcomeTracker {
 		return { sessionID: part.sessionID, callID: part.callID, tool: part.tool, status, durationMs, repeatedFailureCount: count };
 	}
 
+	recordFallbackCompleted(sessionID: string, callID: string, tool: string, durationMs?: number): ToolOutcome | undefined {
+		if (this.terminalCalls.get(sessionID)?.has(callID) || this.fallbackCalls.get(sessionID)?.has(callID)) return undefined;
+		let fallbackCalls = this.fallbackCalls.get(sessionID);
+		if (!fallbackCalls) {
+			fallbackCalls = new Set();
+			this.fallbackCalls.set(sessionID, fallbackCalls);
+		}
+		fallbackCalls.add(callID);
+		if (fallbackCalls.size > MAX_TRACKED_CALLS) fallbackCalls.delete(fallbackCalls.values().next().value!);
+		return { sessionID, callID, tool, status: "completed", durationMs };
+	}
+
 	clearSession(sessionID: string): void {
 		this.failures.delete(sessionID);
 		this.terminalCalls.delete(sessionID);
+		this.fallbackCalls.delete(sessionID);
 	}
 }

package/src/lib/types.ts

@@ -12,7 +12,7 @@ export interface TodoSdkClient {
 		get?: (opts: { path: { id: string } }) => Promise<{ data?: { parentID?: unknown } }>;
 		promptAsync?: (opts: {
 			path: { id: string };
-			body: { messageID?: string; parts: Array<{ type: "text"; text: string }> };
+			body: { messageID?: string; parts: Array<{ type: "text"; text: string; synthetic?: boolean }> };
 		}) => Promise<unknown>;
 	};
 	tui?: {

package/src/policies/continuation.ts

@@ -48,6 +48,7 @@ export async function continueUnfinishedSession(sessionID: string): Promise<bool
 					parts: [{
 						type: "text",
 						text: "Workflow Guard: unfinished todos remain. Continue working through them. If you need user input, use the question tool instead of ending the run.",
+						synthetic: true,
 					}],
 				},
 			});

package/src/workflow-guard.ts

@@ -131,7 +131,7 @@ export {
 	exportProjectKnowledge,
 	importProjectKnowledge,
 } from "./lib/project-memory.ts";
-import { ensureProjectMemoryExcluded, getProjectMemoryIdentity, getRecentProjectMemory, importProjectKnowledge, isProjectMemoryFresh, listReviewFollowups, openProjectMemory } from "./lib/project-memory.ts";
+import { ensureProjectMemoryExcluded, getProjectMemoryIdentity, getRecentProjectMemory, importProjectKnowledge, isProjectMemoryFreshAsync, listReviewFollowups, openProjectMemory } from "./lib/project-memory.ts";
 
 // ── Audit & durable verification cache ───────────────────────────────────────
 import {
@@ -416,15 +416,19 @@ export const WorkflowGuard: Plugin = async (ctx) => {
 
 		"tool.execute.after": async (input, output) => {
 			const startedAt = toolLifecycle.finish(input.sessionID, input.callID);
-			audit({
-				ts: new Date().toISOString(),
-				sessionID: input.sessionID,
-				callID: input.callID,
-				tool: input.tool,
-				decision: "allow",
-				phase: "outcome",
-				durationMs: startedAt === undefined ? undefined : Date.now() - startedAt,
-			});
+			const outcome = toolOutcomes.recordFallbackCompleted(input.sessionID, input.callID, input.tool, startedAt === undefined ? undefined : Date.now() - startedAt);
+			if (outcome) {
+				audit({
+					ts: new Date().toISOString(),
+					sessionID: outcome.sessionID,
+					callID: outcome.callID,
+					tool: outcome.tool,
+					decision: "allow",
+					phase: "outcome",
+					durationMs: outcome.durationMs,
+					reason: outcome.status,
+				});
+			}
 			releaseFileClaims(input.sessionID, input.callID);
 			if (input.tool === "read") {
 				const observation = toolLifecycle.takeReadObservation(input.sessionID, input.callID);
@@ -503,8 +507,10 @@ export const WorkflowGuard: Plugin = async (ctx) => {
 				contextBlocks.push(stateLines.join("\n"));
 				let projectKnowledge: ReturnType<typeof getRecentProjectMemory> = [];
 				try {
-					projectKnowledge = (projectMemory ? getRecentProjectMemory(projectMemory, 8) : [])
-						.filter((memory) => memory.source !== "portable" && isProjectMemoryFresh(memory, effectiveRoot));
+					const candidates = (projectMemory ? getRecentProjectMemory(projectMemory, 8) : [])
+						.filter((memory) => memory.source !== "portable");
+					const freshness = await Promise.all(candidates.map((memory) => isProjectMemoryFreshAsync(memory, effectiveRoot)));
+					projectKnowledge = candidates.filter((_, index) => freshness[index]);
 				} catch {}
 				if (projectKnowledge.length > 0) {
 					const lines = projectKnowledge.map((memory) => `- [${memory.kind}:${memory.id.slice(0, 8)}] ${memory.content.slice(0, 300)}`);