opencode-workflow-guard 1.5.1 → 1.7.0

package/src/lib/shell.ts

@@ -0,0 +1,399 @@
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return undefined;
+	}
+	return value as Record<string, unknown>;
+}
+
+export function extractCommands(input: unknown): string[] {
+	if (typeof input === "string") {
+		return [input];
+	}
+	const record = asRecord(input);
+	if (!record) {
+		return [];
+	}
+	const commands: string[] = [];
+	if (typeof record.command === "string") commands.push(record.command);
+	if (Array.isArray(record.commands)) {
+		for (const c of record.commands) {
+			if (typeof c === "string") commands.push(c);
+		}
+	}
+	return commands;
+}
+
+export function normalize(cmd: string): string {
+	return cmd.replace(/\s+/g, " ");
+}
+
+export function dynamicShellSyntaxIn(command: string): string | undefined {
+	let quote: "'" | '"' | undefined;
+	let escaped = false;
+	for (let i = 0; i < command.length; i += 1) {
+		const char = command[i]!;
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\" && quote !== "'") {
+			escaped = true;
+			continue;
+		}
+		if (char === "'") {
+			if (!quote) quote = "'";
+			else if (quote === "'") quote = undefined;
+			continue;
+		}
+		if (char === '"') {
+			if (!quote) quote = '"';
+			else if (quote === '"') quote = undefined;
+			continue;
+		}
+		if (quote === "'") continue;
+		if (char === "`" || (char === "$" && command[i + 1] === "(") || (!quote && (char === "<" || char === ">") && command[i + 1] === "(")) {
+			return "dynamic command/process substitution";
+		}
+		if (char === "$" && /^(?:IFS\b|\{IFS(?:\}|[:\[]))/.test(command.slice(i + 1))) return "dynamic IFS expansion";
+		if (!quote && (char === "\r" || /[\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/u.test(char))) {
+			return "ambiguous shell whitespace";
+		}
+	}
+	if (quote || escaped) return "malformed shell quoting";
+	return undefined;
+}
+
+export function decodeShellEscapes(text: string): string {
+	return text
+		// ANSI-C quoting wrapper: $'...' -> ...
+		.replace(/\$'([^']*)'/g, "$1")
+		// Hex escapes: \xHH
+		.replace(/\\x([0-9a-fA-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+		// Unicode escapes: \uHHHH
+		.replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+		// Octal escapes: \0OO or \OOO (e.g. \162 -> 'r')
+		.replace(/\\([0-3][0-7]{2})/g, (_, oct) => String.fromCharCode(parseInt(oct, 8)));
+}
+
+export function shellWords(command: string): string[] {
+	const words: string[] = [];
+	let word = "";
+	let quote: "'" | '"' | undefined;
+	let escaped = false;
+	let started = false;
+	for (const char of command) {
+		if (escaped) {
+			word += char;
+			escaped = false;
+			started = true;
+			continue;
+		}
+		if (char === "\\" && quote !== "'") {
+			escaped = true;
+			started = true;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			if (!quote) quote = char;
+			else if (quote === char) quote = undefined;
+			else word += char;
+			started = true;
+			continue;
+		}
+		if (!quote && /\s/.test(char)) {
+			if (started) words.push(word);
+			word = "";
+			started = false;
+			continue;
+		}
+		word += char;
+		started = true;
+	}
+	if (escaped) word += "\\";
+	if (started) words.push(word);
+	return words;
+}
+
+function envSplitWords(value: string): string[] {
+	const words: string[] = [];
+	let word = "";
+	let quote: "'" | '"' | undefined;
+	let started = false;
+	const push = () => {
+		if (started) words.push(word);
+		word = "";
+		started = false;
+	};
+	for (let i = 0; i < value.length; i += 1) {
+		const char = value[i]!;
+		if (char === "'" || char === '"') {
+			if (!quote) quote = char;
+			else if (quote === char) quote = undefined;
+			else word += char;
+			started = true;
+			continue;
+		}
+		if (char === "\\" && i + 1 < value.length) {
+			const next = value[++i]!;
+			if (quote === "'" && next !== "'" && next !== "\\") {
+				word += `\\${next}`;
+				started = true;
+				continue;
+			}
+			if (next === "c" && !quote) break;
+			if (next === "_" && quote !== "'") {
+				if (quote === '"') {
+					word += " ";
+					started = true;
+				} else push();
+				continue;
+			}
+			const escapes: Record<string, string> = { f: "\f", n: "\n", r: "\r", t: "\t", v: "\v", "#": "#", "$": "$", '"': '"', "'": "'", "\\": "\\" };
+			word += escapes[next] ?? next;
+			started = true;
+			continue;
+		}
+		if (!quote && /[\s\f\v]/.test(char)) {
+			push();
+			continue;
+		}
+		if (!quote && char === "#" && !started) break;
+		if (char === "$" && quote !== "'" && value[i + 1] === "{") {
+			const end = value.indexOf("}", i + 2);
+			if (end >= 0) {
+				const name = value.slice(i + 2, end);
+				word += process.env[name] ?? "";
+				started = true;
+				i = end;
+				continue;
+			}
+		}
+		word += char;
+		started = true;
+	}
+	push();
+	return words;
+}
+
+export function splitShellSegments(command: string): string[] {
+	const segments: string[] = [];
+	let current = "";
+	let quote: "'" | '"' | "ansi" | undefined;
+	let escaped = false;
+	for (let i = 0; i < command.length; i += 1) {
+		const char = command[i]!;
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (!quote && char === "$" && command[i + 1] === "'") {
+			current += "$'";
+			quote = "ansi";
+			i += 1;
+			continue;
+		}
+		if (char === "\\" && quote !== "'") {
+			current += char;
+			escaped = true;
+			continue;
+		}
+		if (quote === "ansi" && char === "'") {
+			quote = undefined;
+			current += char;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			if (!quote) quote = char;
+			else if (quote === char) quote = undefined;
+			current += char;
+			continue;
+		}
+		if (!quote && /[\n|;&]/.test(char)) {
+			if (current.trim()) segments.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current.trim()) segments.push(current.trim());
+	return segments;
+}
+
+function unwrapShellWordsImpl(command: string): { words: string[]; changesCwd: boolean } {
+	let cleanCmd = decodeShellEscapes(command.trim());
+	// Strip outer grouping parentheses/braces if present e.g. ( git commit ) or { git commit; }
+	while (
+		(cleanCmd.startsWith("(") && cleanCmd.endsWith(")")) ||
+		(cleanCmd.startsWith("{") && cleanCmd.endsWith("}"))
+	) {
+		cleanCmd = cleanCmd.slice(1, -1).trim();
+		if (cleanCmd.endsWith(";")) cleanCmd = cleanCmd.slice(0, -1).trim();
+	}
+
+	const words = shellWords(cleanCmd);
+	let i = 0;
+	let changesCwd = false;
+	while (i < words.length) {
+		const rawWord = words[i]!;
+		const word = rawWord.replace(/^[\({]+/, "").replace(/[\)};]+$/, "");
+		if (!word) {
+			i++;
+			continue;
+		}
+
+		if (word === "command" || word === "exec" || word === "eval" || word === "nohup") {
+			i++;
+			continue;
+		}
+		if (word === "nice") {
+			i++;
+			if (i < words.length && (words[i] === "-n" || words[i]?.startsWith("-n"))) {
+				if (words[i] === "-n") i += 2;
+				else i++;
+			}
+			continue;
+		}
+		if (word === "timeout") {
+			i++;
+			while (i < words.length && words[i]!.startsWith("-")) {
+				const opt = words[i++]!;
+				if ((opt === "-k" || opt === "-s" || opt === "--signal" || opt === "--kill-after") && i < words.length) {
+					i++;
+				}
+			}
+			if (i < words.length && /^\d+[smhd]?$/.test(words[i]!)) {
+				i++;
+			}
+			continue;
+		}
+		if (word === "stdbuf") {
+			i++;
+			while (i < words.length && words[i]!.startsWith("-")) {
+				const opt = words[i++]!;
+				if ((opt === "-i" || opt === "-o" || opt === "-e") && i < words.length) {
+					i++;
+				}
+			}
+			continue;
+		}
+		if (word === "time") {
+			i++;
+			while (i < words.length && words[i]!.startsWith("-")) {
+				i++;
+			}
+			continue;
+		}
+		if (word === "sudo" || word === "doas") {
+			i++;
+			const valueOptions = new Set([
+				"-u",
+				"--user",
+				"-g",
+				"--group",
+				"-h",
+				"--host",
+				"-p",
+				"--prompt",
+				"-C",
+				"--close-from",
+				"-R",
+				"--chroot",
+				"-D",
+				"--chdir",
+			]);
+			while (i < words.length && words[i]!.startsWith("-")) {
+				const option = words[i++]!;
+				if (option === "-D" || (option.startsWith("-D") && option !== "-D") || option === "--chdir" || option.startsWith("--chdir=")) changesCwd = true;
+				if (valueOptions.has(option) && i < words.length) i++;
+			}
+			continue;
+		}
+		if (word === "env") {
+			i++;
+			const valueOptions = new Set([
+				"-u",
+				"--unset",
+				"--argv0",
+				"-C",
+				"--chdir",
+				"-S",
+				"--split-string",
+			]);
+			while (i < words.length) {
+				const w = words[i]!;
+				if (w === "--") {
+					i++;
+					break;
+				}
+				if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(w)) {
+					i++;
+					continue;
+				}
+				let splitValue: string | undefined;
+				let consumed = 0;
+				const clustered = /^-[iv0]*([SC])(.*)$/.exec(w);
+				if (clustered?.[1] === "C") {
+					changesCwd = true;
+					i++;
+					if (!clustered[2] && i < words.length) i++;
+					continue;
+				}
+				if (clustered?.[1] === "S") {
+					if (clustered[2]) splitValue = clustered[2];
+					else if (i + 1 < words.length) {
+						splitValue = words[i + 1]!;
+						consumed = 1;
+					}
+				}
+				else if (w.startsWith("-S") && w !== "-S") splitValue = w.slice(2);
+				else if (w.startsWith("--split-string=")) splitValue = w.slice("--split-string=".length);
+				else if ((w === "-S" || w === "--split-string") && i + 1 < words.length) {
+					splitValue = words[i + 1]!;
+					consumed = 1;
+				}
+				if (splitValue !== undefined) {
+					words.splice(i, consumed + 1, ...envSplitWords(splitValue));
+					continue;
+				}
+				const clusteredValue = /^-[iv0]*([ua])(.*)$/.exec(w);
+				if (clusteredValue) {
+					i++;
+					if (!clusteredValue[2] && i < words.length) i++;
+					continue;
+				}
+				if (w.startsWith("-C") && w !== "-C") {
+					changesCwd = true;
+					i++;
+					continue;
+				}
+				if (!w.startsWith("-")) break;
+				i++;
+				if (w === "-C" || w === "--chdir" || w.startsWith("--chdir=")) changesCwd = true;
+				if (valueOptions.has(w) && i < words.length) i++;
+			}
+			continue;
+		}
+		if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) {
+			i++;
+			continue;
+		}
+		break;
+	}
+	return { words: words
+		.slice(i)
+		.map((w) => w.replace(/^[\({]+/, "").replace(/[\)};]+$/, ""))
+		.filter(Boolean), changesCwd };
+}
+
+export function unwrapShellWords(command: string): string[] {
+	return unwrapShellWordsImpl(command).words;
+}
+
+export function shellWrappersChangeCwd(command: string): boolean {
+	return unwrapShellWordsImpl(command).changesCwd;
+}
+
+export function unwrapShellCommand(command: string): string {
+	return unwrapShellWords(command).join(" ");
+}

package/src/lib/state.ts

@@ -1,7 +1,8 @@
-import { realpathSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { persistVerifyCache } from "./audit.ts";
+import { persistVerifyCache, persistVerifyHistory } from "./audit.ts";
+import { getCachedProjectConfig, loadProjectConfig } from "./project-config.ts";
 import { snipVerifyOutput, getCurrentGitCommitHash, getGitStatusSummary, getGitWorktreeFingerprint } from "./verify.ts";
 import type {
 	TodoSdkClient,
@@ -78,16 +79,16 @@ export const sessionVerifyResults = new Map<string, NonNullable<VerifyResult>>()
 export let lastReview: ReviewResult | undefined;
 export const sessionReviews = new Map<string, ReviewResult>();
 
-export function recordMutation(sessionID?: string): void {
+export function recordMutation(sessionID?: string, actorSessionID?: string): void {
 	lastMutationTimestamp = Date.now();
 	mutationCount++;
-	if (sessionID) {
-		sessionMutationTimestamps.set(sessionID, lastMutationTimestamp);
-		sessionMutationCounts.set(sessionID, (sessionMutationCounts.get(sessionID) ?? 0) + 1);
-		sessionVerifyResults.delete(sessionID);
+	for (const id of new Set([sessionID, actorSessionID].filter((value): value is string => Boolean(value)))) {
+		sessionMutationTimestamps.set(id, lastMutationTimestamp);
+		sessionMutationCounts.set(id, (sessionMutationCounts.get(id) ?? 0) + 1);
+		sessionVerifyResults.delete(id);
+		sessionReviews.delete(id);
 	}
-	if (sessionID) sessionReviews.delete(sessionID);
-	if (!lastReview?.targetSessionID || lastReview.targetSessionID === sessionID) {
+	if (!lastReview?.targetSessionID || lastReview.targetSessionID === sessionID || lastReview.targetSessionID === actorSessionID) {
 		lastReview = undefined;
 	}
 }
@@ -99,6 +100,10 @@ export function getMutationCount(sessionID?: string): number {
 	return mutationCount;
 }
 
+export function getSessionMutationCount(sessionID: string): number {
+	return sessionMutationCounts.get(sessionID) ?? 0;
+}
+
 export function getLastMutationTimestamp(): number {
 	return lastMutationTimestamp;
 }
@@ -124,6 +129,7 @@ export function recordVerifyResult(
 		workspaceRoot: resolve(root),
 	};
 	if (sessionID && lastVerify) sessionVerifyResults.set(sessionID, lastVerify);
+	persistVerifyHistory(lastVerify);
 	if (lastVerify.passed) {
 		persistVerifyCache(lastVerify);
 	}
@@ -173,99 +179,10 @@ export function resetReviewState(): void {
 	sessionReviews.clear();
 }
 
-export let cachedProjectConfig: ProjectConfig | undefined;
-
-/**
- * Strips single-line comments, block comments, and trailing commas from JSONC
- * text without corrupting comment markers inside string literals or URLs.
- */
-export function stripJsonComments(jsonc: string): string {
-	let insideString = false;
-	let stringQuote = "";
-	let escaped = false;
-	let output = "";
-	let i = 0;
-
-	while (i < jsonc.length) {
-		const char = jsonc[i]!;
-		const next = jsonc[i + 1];
-
-		if (escaped) {
-			output += char;
-			escaped = false;
-			i++;
-			continue;
-		}
-
-		if (char === "\\") {
-			output += char;
-			escaped = true;
-			i++;
-			continue;
-		}
-
-		if (char === '"' || char === "'") {
-			if (!insideString) {
-				insideString = true;
-				stringQuote = char;
-			} else if (stringQuote === char) {
-				insideString = false;
-			}
-			output += char;
-			i++;
-			continue;
-		}
-
-		if (!insideString) {
-			if (char === "/" && next === "/") {
-				i += 2;
-				while (i < jsonc.length && jsonc[i] !== "\n" && jsonc[i] !== "\r") {
-					i++;
-				}
-				continue;
-			}
-			if (char === "/" && next === "*") {
-				i += 2;
-				while (i < jsonc.length && !(jsonc[i] === "*" && jsonc[i + 1] === "/")) {
-					i++;
-				}
-				i += 2;
-				continue;
-			}
-		}
-
-		output += char;
-		i++;
-	}
-
-	return output.replace(/,(\s*[}\]])/g, "$1");
-}
-
-export function loadProjectConfig(root: string): ProjectConfig {
-	const candidates = [
-		join(root, ".opencode", "workflow-guard.json"),
-		join(root, ".opencode", "workflow-guard.jsonc"),
-		join(root, "workflow-guard.json"),
-		join(root, "workflow-guard.jsonc"),
-	];
-	for (const candidate of candidates) {
-		try {
-			const raw = readFileSync(candidate, "utf8");
-			const sanitized = stripJsonComments(raw);
-			return JSON.parse(sanitized);
-		} catch {}
-	}
-	return {};
-}
-
-export function reloadProjectConfig(root: string): void {
-	cachedProjectConfig = loadProjectConfig(root);
-}
-
 export function getProjectConfig(root: string): ProjectConfig {
 	const active = runtimeState.getStore();
 	if (active?.workspaceRoot === root) return active.projectConfig;
-	return cachedProjectConfig ?? loadProjectConfig(root);
+	return getCachedProjectConfig() ?? loadProjectConfig(root);
 }
 
 export function isReviewRequired(root: string): boolean {
@@ -289,11 +206,15 @@ export function getSubagentMutationBudget(root: string): number {
 	if (typeof cfg.maxSubagentMutations === "number" && cfg.maxSubagentMutations > 0) {
 		return cfg.maxSubagentMutations;
 	}
-	return 50;
+	return 100;
 }
 
 export function isLearningEnabled(root: string): boolean {
-	return process.env.WORKFLOW_GUARD_LEARNING === "1";
+	return process.env.WORKFLOW_GUARD_LEARNING === "1" || getProjectConfig(root).learning === true;
+}
+
+export function isProjectMemoryEnabled(root: string): boolean {
+	return getProjectConfig(root).projectMemory !== false;
 }
 
 export function getLearningInterventionBudget(root: string): number {

package/src/lib/tool-lifecycle.ts

@@ -0,0 +1,63 @@
+import type { FileSnapshot } from "../policies/post-edit-validation.ts";
+import type { ReadObservation } from "../policies/stale-write.ts";
+
+function invocationKey(sessionID: string, callID: string): string {
+	return `${sessionID}\0${callID}`;
+}
+
+export class ToolInvocationLifecycle {
+	private readonly postEditSnapshots = new Map<string, { root: string; snapshots: FileSnapshot[] }>();
+	private readonly startedAt = new Map<string, number>();
+	private readonly readObservations = new Map<string, ReadObservation>();
+	private readonly recoveryRuns = new Map<string, number>();
+
+	start(sessionID: string, callID: string): void {
+		this.startedAt.set(invocationKey(sessionID, callID), Date.now());
+	}
+
+	finish(sessionID: string, callID: string): number | undefined {
+		const key = invocationKey(sessionID, callID);
+		const startedAt = this.startedAt.get(key);
+		this.startedAt.delete(key);
+		return startedAt;
+	}
+
+	setReadObservation(sessionID: string, callID: string, observation: ReadObservation): void {
+		this.readObservations.set(invocationKey(sessionID, callID), observation);
+	}
+
+	takeReadObservation(sessionID: string, callID: string): ReadObservation | undefined {
+		const key = invocationKey(sessionID, callID);
+		const observation = this.readObservations.get(key);
+		this.readObservations.delete(key);
+		return observation;
+	}
+
+	setPostEditSnapshots(sessionID: string, callID: string, root: string, snapshots: FileSnapshot[]): void {
+		this.postEditSnapshots.set(invocationKey(sessionID, callID), { root, snapshots });
+	}
+
+	takePostEditSnapshots(sessionID: string, callID: string): { root: string; snapshots: FileSnapshot[] } | undefined {
+		const key = invocationKey(sessionID, callID);
+		const snapshots = this.postEditSnapshots.get(key);
+		this.postEditSnapshots.delete(key);
+		return snapshots;
+	}
+
+	setRecoveryRun(sessionID: string, run: number): void {
+		this.recoveryRuns.set(sessionID, run);
+	}
+
+	takeRecoveryRun(sessionID: string): number | undefined {
+		const run = this.recoveryRuns.get(sessionID);
+		this.recoveryRuns.delete(sessionID);
+		return run;
+	}
+
+	clearSession(sessionID: string): void {
+		const prefix = `${sessionID}\0`;
+		for (const key of this.startedAt.keys()) {
+			if (key.startsWith(prefix)) this.startedAt.delete(key);
+		}
+	}
+}

package/src/lib/tool-outcomes.ts

@@ -0,0 +1,64 @@
+import { createHash } from "node:crypto";
+
+export interface ToolOutcomePart {
+	type?: unknown;
+	sessionID?: unknown;
+	callID?: unknown;
+	tool?: unknown;
+	state?: {
+		status?: unknown;
+		error?: unknown;
+		time?: { start?: unknown; end?: unknown };
+	};
+}
+
+export interface ToolOutcome {
+	sessionID: string;
+	callID: string;
+	tool: string;
+	status: "completed" | "error";
+	durationMs?: number;
+	repeatedFailureCount?: number;
+}
+
+export class ToolOutcomeTracker {
+	private readonly terminalCalls = new Map<string, Set<string>>();
+	private readonly failures = new Map<string, { signature: string; count: number }>();
+	private static readonly maxTerminalCallsPerSession = 1024;
+
+	record(part: ToolOutcomePart): ToolOutcome | undefined {
+		if (part.type !== "tool" || typeof part.sessionID !== "string" || typeof part.callID !== "string" || typeof part.tool !== "string") return undefined;
+		const status = part.state?.status;
+		if (status !== "completed" && status !== "error") return undefined;
+		let terminalCalls = this.terminalCalls.get(part.sessionID);
+		if (!terminalCalls) {
+			terminalCalls = new Set();
+			this.terminalCalls.set(part.sessionID, terminalCalls);
+		}
+		if (terminalCalls.has(part.callID)) return undefined;
+		terminalCalls.add(part.callID);
+		if (terminalCalls.size > ToolOutcomeTracker.maxTerminalCallsPerSession) {
+			terminalCalls.delete(terminalCalls.values().next().value!);
+		}
+
+		const start = part.state?.time?.start;
+		const end = part.state?.time?.end;
+		const durationMs = typeof start === "number" && typeof end === "number" ? Math.max(0, end - start) : undefined;
+		if (status === "completed") {
+			this.failures.delete(part.sessionID);
+			return { sessionID: part.sessionID, callID: part.callID, tool: part.tool, status, durationMs };
+		}
+
+		const error = typeof part.state?.error === "string" ? part.state.error : "";
+		const signature = createHash("sha256").update(`${part.tool}\0${error}`).digest("hex");
+		const previous = this.failures.get(part.sessionID);
+		const count = previous?.signature === signature ? previous.count + 1 : 1;
+		this.failures.set(part.sessionID, { signature, count });
+		return { sessionID: part.sessionID, callID: part.callID, tool: part.tool, status, durationMs, repeatedFailureCount: count };
+	}
+
+	clearSession(sessionID: string): void {
+		this.failures.delete(sessionID);
+		this.terminalCalls.delete(sessionID);
+	}
+}