opencode-workflow-guard 1.8.6 → 1.9.0

package/src/lib/state.ts

@@ -2,7 +2,7 @@ import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { persistVerifyCache, persistVerifyHistory } from "./audit.ts";
-import { getCachedProjectConfig, loadProjectConfig } from "./project-config.ts";
+import { getCachedProjectConfig, loadProjectConfig, projectRootKey } from "./project-config.ts";
 import { snipVerifyOutput, getCurrentGitCommitHash, getGitStatusSummary, getGitWorktreeFingerprint } from "./verify.ts";
 import type {
 	TodoSdkClient,
@@ -70,6 +70,8 @@ export function runWithRuntimeState<T>(root: string, client: unknown, fn: () =>
 
 export let lastMutationTimestamp = 0;
 export let mutationCount = 0;
+const workspaceMutationTimestamps = new Map<string, number>();
+const workspaceMutationCounts = new Map<string, number>();
 export const sessionMutationTimestamps = new Map<string, number>();
 export const sessionMutationCounts = new Map<string, number>();
 
@@ -82,6 +84,9 @@ export const sessionReviews = new Map<string, ReviewResult>();
 export function recordMutation(sessionID?: string, actorSessionID?: string): void {
 	lastMutationTimestamp = Date.now();
 	mutationCount++;
+	const workspace = projectRootKey(runtimeState.getStore()?.workspaceRoot ?? getWorkspaceRoot());
+	workspaceMutationTimestamps.set(workspace, lastMutationTimestamp);
+	workspaceMutationCounts.set(workspace, (workspaceMutationCounts.get(workspace) ?? 0) + 1);
 	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);
@@ -108,10 +113,26 @@ export function getLastMutationTimestamp(): number {
 	return lastMutationTimestamp;
 }
 
+export function getWorkspaceMutationTimestamp(root: string): number {
+	return workspaceMutationTimestamps.get(projectRootKey(root)) ?? 0;
+}
+
+export function getWorkspaceMutationCount(root: string): number {
+	return workspaceMutationCounts.get(projectRootKey(root)) ?? 0;
+}
+
 export function getLastVerifyResult(): typeof lastVerify {
 	return lastVerify;
 }
 
+export function getLastVerifyResultForWorkspace(root: string): typeof lastVerify {
+	const workspace = projectRootKey(root);
+	const candidates = [lastVerify, ...sessionVerifyResults.values()].filter(
+		(result): result is NonNullable<VerifyResult> => result?.workspaceRoot != null && projectRootKey(result.workspaceRoot) === workspace,
+	);
+	return candidates.reduce<NonNullable<VerifyResult> | undefined>((latest, result) => !latest || result.timestamp > latest.timestamp ? result : latest, undefined);
+}
+
 export function recordVerifyResult(
 	command: string,
 	result: { passed: boolean; output: string; durationMs?: number },
@@ -126,7 +147,8 @@ export function recordVerifyResult(
 		durationMs: result.durationMs,
 		commitHash: getCurrentGitCommitHash(root),
 		gitStatus: getGitStatusSummary(root),
-		workspaceRoot: resolve(root),
+		workspaceRoot: projectRootKey(root),
+		worktreeFingerprint: getGitWorktreeFingerprint(root),
 	};
 	if (sessionID && lastVerify) sessionVerifyResults.set(sessionID, lastVerify);
 	persistVerifyHistory(lastVerify);
@@ -145,6 +167,8 @@ export function resetVerifyState(): void {
 	lastVerify = undefined;
 	sessionMutationTimestamps.clear();
 	sessionMutationCounts.clear();
+	workspaceMutationTimestamps.clear();
+	workspaceMutationCounts.clear();
 	sessionVerifyResults.clear();
 }
 
@@ -155,7 +179,7 @@ export function recordReviewResult(
 	targetSessionID?: string,
 	workspace?: string,
 ): void {
-	const root = resolve(workspace ?? getWorkspaceRoot());
+	const root = projectRootKey(workspace ?? getWorkspaceRoot());
 	lastReview = {
 		reviewer,
 		summary: summary.slice(-4000),
@@ -174,6 +198,14 @@ export function getLastReviewResult(): typeof lastReview {
 	return lastReview;
 }
 
+export function getLastReviewResultForWorkspace(root: string): typeof lastReview {
+	const workspace = projectRootKey(root);
+	const candidates = [lastReview, ...sessionReviews.values()].filter(
+		(result): result is ReviewResult => result?.workspace != null && projectRootKey(result.workspace) === workspace,
+	);
+	return candidates.reduce<ReviewResult | undefined>((latest, result) => !latest || result.timestamp > latest.timestamp ? result : latest, undefined);
+}
+
 export function resetReviewState(): void {
 	lastReview = undefined;
 	sessionReviews.clear();
@@ -181,8 +213,8 @@ export function resetReviewState(): void {
 
 export function getProjectConfig(root: string): ProjectConfig {
 	const active = runtimeState.getStore();
-	if (active?.workspaceRoot === root) return active.projectConfig;
-	return getCachedProjectConfig() ?? loadProjectConfig(root);
+	if (active && projectRootKey(active.workspaceRoot) === projectRootKey(root)) return active.projectConfig;
+	return getCachedProjectConfig(root) ?? loadProjectConfig(root);
 }
 
 export function isReviewRequired(root: string): boolean {
@@ -197,6 +229,25 @@ export function isDocumentationRequired(root: string): boolean {
 	return cfg.requireDocumentation === true;
 }
 
+export function getOperationProfile(root: string): "interactive" | "autonomous" {
+	return getProjectConfig(root).profile === "autonomous" ? "autonomous" : "interactive";
+}
+
+export function isRecoveryCheckpointsEnabled(root: string): boolean {
+	const cfg = getProjectConfig(root);
+	return cfg.recoveryCheckpoints ?? getOperationProfile(root) === "autonomous";
+}
+
+export function isRalphModeEnabled(root: string): boolean {
+	return getProjectConfig(root).ralphMode === true;
+}
+
+export function getRalphMaxIterations(root: string): number {
+	const configured = getProjectConfig(root).ralphMaxIterations;
+	if (typeof configured === "number" && Number.isInteger(configured) && configured > 0 && configured <= 100) return configured;
+	return 10;
+}
+
 export function getSubagentMutationBudget(root: string): number {
 	if (process.env.WORKFLOW_GUARD_MAX_SUBAGENT_MUTATIONS) {
 		const parsed = parseInt(process.env.WORKFLOW_GUARD_MAX_SUBAGENT_MUTATIONS, 10);

package/src/lib/types.ts

@@ -24,6 +24,7 @@ export interface TodoSdkClient {
 }
 
 export interface ProjectConfig {
+	profile?: "interactive" | "autonomous";
 	protectedBranches?: string[];
 	verifyCommand?: string;
 	postEditValidators?: Array<{
@@ -37,10 +38,22 @@ export interface ProjectConfig {
 	projectMemory?: boolean;
 	learning?: boolean;
 	titleSettleWorkaround?: boolean;
+	ralphMode?: boolean;
+	ralphMaxIterations?: number;
 	maxSubagentMutations?: number;
 	maxLearningInterventions?: number;
 }
 
+export type PolicyDecisionStatus = "allowed" | "blocked" | "needs_approval" | "verification_failed";
+
+export interface PolicyDecision {
+	status: PolicyDecisionStatus;
+	code: string;
+	policy?: string;
+	message: string;
+	details?: Record<string, unknown>;
+}
+
 export interface VerifyResult {
 	passed: boolean;
 	command: string;
@@ -50,6 +63,7 @@ export interface VerifyResult {
 	commitHash?: string;
 	gitStatus?: string;
 	workspaceRoot?: string;
+	worktreeFingerprint?: string;
 }
 
 export interface ReviewResult {
@@ -64,12 +78,33 @@ export interface ReviewResult {
 	worktreeFingerprint?: string;
 }
 
+export type EvidenceConfidence = "deterministic_observation" | "attestation" | "derived_state" | "agent_assertion";
+
+export interface EvidenceRecord {
+	id: string;
+	kind: "verification" | "review" | "tool_outcome" | "policy_evaluation" | "lifecycle_state" | "agent_assertion";
+	confidence: EvidenceConfidence;
+	observedAt: number;
+	subject: {
+		workspace?: string;
+		commitHash?: string;
+		worktreeFingerprint?: string;
+		sessionID?: string;
+		callID?: string;
+		actor?: string;
+	};
+	source: Record<string, unknown>;
+}
+
+export type EvidenceSubject = EvidenceRecord["subject"];
+
 export interface AuditEntry {
 	ts: string;
 	sessionID?: string;
 	callID?: string;
 	tool: string;
 	decision: "allow" | "block";
+	policyDecision?: PolicyDecision;
 	phase?: "decision" | "outcome" | "event";
 	durationMs?: number;
 	reason?: string;

package/src/policies/boundary.ts

@@ -317,6 +317,7 @@ export function detectShellMutation(command: string): ShellMutation | undefined
 export async function guardShellMutation(
 	command: string,
 	sessionID: string | undefined,
+	record = true,
 ): Promise<string | undefined> {
 	const root = getWorkspaceRoot();
 	let hasMutation = false;
@@ -383,7 +384,7 @@ export async function guardShellMutation(
 			}
 		}
 	}
-	if (hasMutation) {
+	if (hasMutation && record) {
 		recordMutation(await effectiveTodoOwnerSessionID(sessionID), sessionID);
 	}
 	return undefined;

package/src/policies/completion.ts

@@ -1,5 +1,8 @@
-import { sessionVerifyResults, lastVerify, sessionMutationTimestamps, lastMutationTimestamp } from "../lib/state.ts";
+import { isEvidenceFresh, verificationEvidence } from "../lib/evidence.ts";
+import { projectRootKey } from "../lib/project-config.ts";
+import { getWorkspaceRoot, sessionVerifyResults, lastVerify, sessionMutationTimestamps, lastMutationTimestamp } from "../lib/state.ts";
 import type { VerifyResult } from "../lib/types.ts";
+import { getCurrentGitCommitHash, getGitWorktreeFingerprint } from "../lib/verify.ts";
 
 /**
  * Claims-vs-evidence check (Policy 24): when the assistant's final text
@@ -60,7 +63,12 @@ export function checkCompletionClaims(
 	} else if (!verifyResult.passed) {
 		evidenceState = "failing";
 	} else if (
-		verifyResult.timestamp < mutationTimestamp ||
+		!isEvidenceFresh(verificationEvidence(verifyResult, context?.sessionID), {
+			workspace: projectRootKey(getWorkspaceRoot()),
+			commitHash: getCurrentGitCommitHash(getWorkspaceRoot()),
+			worktreeFingerprint: getGitWorktreeFingerprint(getWorkspaceRoot()),
+			sessionID: context?.sessionID,
+		}, mutationTimestamp) ||
 		Date.now() - verifyResult.timestamp > VERIFICATION_FRESH_WINDOW_MS
 	) {
 		evidenceState = "stale-pass";

package/src/policies/continuation.ts

@@ -1,17 +1,22 @@
 import { randomUUID } from "node:crypto";
-import { getSdkClient } from "../lib/state.ts";
+import { getRalphMaxIterations, getSdkClient, getWorkspaceRoot, isRalphModeEnabled } from "../lib/state.ts";
+import { projectRootKey } from "../lib/project-config.ts";
 import { effectiveTodosWithOwner, hasActiveTodo } from "./todo.ts";
 
 const MAX_CONSECUTIVE_CONTINUATIONS = 3;
+const MAX_GENERATED_MESSAGE_IDS = 100;
 const TITLE_SETTLE_MS = 250;
 const TITLE_SETTLE_ATTEMPTS = 8;
 const DEFAULT_SESSION_TITLE = /^(?:New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 type ContinuationState = {
 	counts: Map<string, number>;
+	ralphOutcomes: Map<string, RalphOutcome>;
 	generatedMessageIDs: Map<string, Set<string>>;
+	lastUserMessageIDs: Map<string, string>;
 	inFlight: Set<string>;
 };
-const states = new WeakMap<object, ContinuationState>();
+export type RalphOutcome = "running" | "completed" | "blocked" | "budget_exhausted" | "user_stopped";
+const states = new WeakMap<object, Map<string, ContinuationState>>();
 
 export async function waitForSessionTitle(sessionID: string): Promise<void> {
 	const session = getSdkClient()?.session;
@@ -30,10 +35,16 @@ export async function waitForSessionTitle(sessionID: string): Promise<void> {
 function getState(): ContinuationState | undefined {
 	const client = getSdkClient();
 	if (!client || (typeof client !== "object" && typeof client !== "function")) return undefined;
-	let state = states.get(client as object);
+	let clientStates = states.get(client as object);
+	if (!clientStates) {
+		clientStates = new Map();
+		states.set(client as object, clientStates);
+	}
+	const root = projectRootKey(getWorkspaceRoot());
+	let state = clientStates.get(root);
 	if (!state) {
-		state = { counts: new Map(), generatedMessageIDs: new Map(), inFlight: new Set() };
-		states.set(client as object, state);
+		state = { counts: new Map(), ralphOutcomes: new Map(), generatedMessageIDs: new Map(), lastUserMessageIDs: new Map(), inFlight: new Set() };
+		clientStates.set(root, state);
 	}
 	return state;
 }
@@ -43,19 +54,33 @@ export async function continueUnfinishedSession(sessionID: string, settleTitle =
 	if (!state || state.inFlight.has(sessionID)) return false;
 	state.inFlight.add(sessionID);
 	try {
+		const ralph = isRalphModeEnabled(getWorkspaceRoot());
+		if (ralph && state.ralphOutcomes.get(sessionID) === "user_stopped") return false;
 		const effective = await effectiveTodosWithOwner(sessionID);
-		if (!effective || effective.ownerSessionID !== sessionID || !hasActiveTodo(effective.todos)) return false;
+		if (!effective || effective.ownerSessionID !== sessionID || !hasActiveTodo(effective.todos)) {
+			if (ralph && state.ralphOutcomes.has(sessionID)) state.ralphOutcomes.set(sessionID, "completed");
+			return false;
+		}
 		if (settleTitle) await waitForSessionTitle(sessionID);
 
 		const count = state.counts.get(sessionID) ?? 0;
-		if (count >= MAX_CONSECUTIVE_CONTINUATIONS) return false;
+		const maxContinuations = ralph ? getRalphMaxIterations(getWorkspaceRoot()) : MAX_CONSECUTIVE_CONTINUATIONS;
+		if (count >= maxContinuations) {
+			if (ralph) state.ralphOutcomes.set(sessionID, "budget_exhausted");
+			return false;
+		}
 
 		const session = getSdkClient()?.session;
 		if (typeof session?.promptAsync !== "function") return false;
 
 		const messageID = `workflow-guard-${randomUUID()}`;
 		state.counts.set(sessionID, count + 1);
+		if (ralph) state.ralphOutcomes.set(sessionID, "running");
 		const generatedIDs = state.generatedMessageIDs.get(sessionID) ?? new Set<string>();
+		if (generatedIDs.size >= MAX_GENERATED_MESSAGE_IDS) {
+			const oldestID = generatedIDs.values().next().value;
+			if (oldestID) generatedIDs.delete(oldestID);
+		}
 		generatedIDs.add(messageID);
 		state.generatedMessageIDs.set(sessionID, generatedIDs);
 		try {
@@ -86,11 +111,18 @@ export function recordUserMessage(sessionID: string, messageID?: string): void {
 	const state = getState();
 	if (!state) return;
 	const generatedIDs = state.generatedMessageIDs.get(sessionID);
-	if (messageID && generatedIDs?.delete(messageID)) {
-		if (generatedIDs.size === 0) state.generatedMessageIDs.delete(sessionID);
-		return;
-	}
+	if (messageID && generatedIDs?.has(messageID)) return;
+	if (messageID && state.lastUserMessageIDs.get(sessionID) === messageID) return;
+	if (messageID) state.lastUserMessageIDs.set(sessionID, messageID);
 	state.counts.delete(sessionID);
+	if (isRalphModeEnabled(getWorkspaceRoot()) && state.ralphOutcomes.has(sessionID)) {
+		if (state.ralphOutcomes.get(sessionID) === "user_stopped") state.ralphOutcomes.delete(sessionID);
+		else state.ralphOutcomes.set(sessionID, "user_stopped");
+	}
+}
+
+export function getRalphOutcome(sessionID: string): RalphOutcome | undefined {
+	return getState()?.ralphOutcomes.get(sessionID);
 }
 
 export function isGeneratedContinuationMessage(sessionID: string, messageID?: string): boolean {
@@ -102,6 +134,8 @@ export function clearContinuationState(sessionID: string): void {
 	const state = getState();
 	if (!state) return;
 	state.counts.delete(sessionID);
+	state.ralphOutcomes.delete(sessionID);
 	state.generatedMessageIDs.delete(sessionID);
+	state.lastUserMessageIDs.delete(sessionID);
 	state.inFlight.delete(sessionID);
 }

package/src/policies/file-claims.ts

@@ -33,15 +33,22 @@ export function canonicalPath(path: string, seen = new Set<string>()): string {
 
 export function claimFiles(paths: string[], sessionID: string, callID: string): string | undefined {
 	const canonical = [...new Set(paths.map((path) => canonicalPath(path)))];
+	const conflict = fileClaimConflictReason(canonical, sessionID);
+	if (conflict) return conflict;
 	for (const path of canonical) {
-		const existing = claims.get(path);
-		if (existing && existing.sessionID !== sessionID) {
-			return `Blocked: file '${path}' is claimed by another active session ('${existing.sessionID}'). Wait for that edit to finish or use an isolated worktree.`;
+		if (!claims.has(path)) {
+			claims.set(path, { sessionID, callID });
 		}
 	}
+	return undefined;
+}
+
+export function fileClaimConflictReason(paths: string[], sessionID: string): string | undefined {
+	const canonical = [...new Set(paths.map((path) => canonicalPath(path)))];
 	for (const path of canonical) {
-		if (!claims.has(path)) {
-			claims.set(path, { sessionID, callID });
+		const existing = claims.get(path);
+		if (existing && existing.sessionID !== sessionID) {
+			return `Blocked: file '${path}' is claimed by another active session ('${existing.sessionID}'). Wait for that edit to finish or use an isolated worktree.`;
 		}
 	}
 	return undefined;

package/src/policies/git.ts

@@ -195,6 +195,7 @@ export function branchGuardReason(): string {
 export function isBranchAlreadyMergedOrClosed(
 	root: string,
 	branch: string,
+	checkRemotePrs = true,
 ): { merged: boolean; reason?: string } {
 	if (!branch || PROTECTED_BRANCHES.has(branch)) {
 		return { merged: false };
@@ -220,6 +221,7 @@ export function isBranchAlreadyMergedOrClosed(
 			}
 		}
 	}
+	if (!checkRemotePrs) return { merged: false };
 
 	try {
 		const ghRes = spawnSync(

package/src/workflow-guard-ui.ts

@@ -1,5 +1,4 @@
 import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui";
-import type { BaseRenderable } from "@opentui/core";
 import type { JSX } from "@opentui/solid";
 import { createElement, insert, setProp } from "@opentui/solid";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -31,11 +30,8 @@ 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>();
 
-type ProjectToggle = "recoveryCheckpoints" | "projectMemory" | "learning" | "titleSettleWorkaround";
+type ProjectToggle = "recoveryCheckpoints" | "projectMemory" | "learning" | "titleSettleWorkaround" | "ralphMode";
 
 export function readProjectOption(root: string, option: ProjectToggle): boolean {
 	const path = projectConfigPath(root);
@@ -74,29 +70,11 @@ export function writeRecoveryCheckpointsOption(root: string, enabled: boolean):
 	return writeProjectOption(root, "recoveryCheckpoints", enabled);
 }
 
-export function setLastBlockedReasonForTesting(reason: string | undefined): void {
-	lastBlockedReason = reason;
-	if (reason === undefined) sessionBlockedReasons.clear();
-}
-
-export function getLastBlockedReason(): string | undefined {
-	return lastBlockedReason;
-}
-
-export function formatBadge(sessionID?: string): { text: string; isBlocked: boolean } {
-	const reason = sessionID ? sessionBlockedReasons.get(sessionID) : lastBlockedReason;
-	if (!reason) {
-		return { text: BADGE_ACTIVE, isBlocked: false };
-	}
-	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 function formatBadge(): { text: string; isBlocked: boolean } {
+	return { text: BADGE_ACTIVE, isBlocked: false };
 }
 
 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",
@@ -110,6 +88,7 @@ export const WorkflowGuardTui: TuiPlugin = async (api) => {
 				const memory = readProjectOption(root, "projectMemory");
 				const learning = readProjectOption(root, "learning");
 				const titleSettle = readProjectOption(root, "titleSettleWorkaround");
+				const ralphMode = readProjectOption(root, "ralphMode");
 				api.ui.dialog.replace(() => api.ui.DialogSelect({
 					title: "Workflow Guard Project Options",
 					current: undefined,
@@ -118,6 +97,7 @@ export const WorkflowGuardTui: TuiPlugin = async (api) => {
 						{ title: `Project memory: ${memory ? "On" : "Off"}`, value: "projectMemory", description: "Toggle durable local project memory" },
 						{ title: `Learner mode: ${learning ? "On" : "Off"}`, value: "learning", description: "Toggle evidence-based learning tools" },
 						{ title: `Title settle workaround: ${titleSettle ? "On" : "Off"}`, value: "titleSettleWorkaround", description: "Delay automatic continuation while OpenCode generates a session title" },
+						{ title: `Ralph mode: ${ralphMode ? "On" : "Off"}`, value: "ralphMode", description: "Opt into bounded autonomous continuation of already-owned todos" },
 					],
 					onSelect: (option) => {
 						const key = option.value as ProjectToggle;
@@ -132,67 +112,18 @@ 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") {
-				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) {
-					const badge = formatBadge(sessionID);
-					setProp(node, "content", badge.text);
-					setProp(node, "fg", badge.isBlocked ? api.theme.current.warning : api.theme.current.success);
-				}
-				scheduleBadgeReset(sessionID);
-			}
-		});
-	} catch {}
-
 	api.slots.register({
 		order: 1,
 		slots: {
 			home_prompt_right() {
 				const theme = api.theme.current;
 				const badge = formatBadge();
-				const node = text({ fg: badge.isBlocked ? theme.warning : theme.success }, [badge.text]);
-				badgeNodes.set("home", node as unknown as BaseRenderable);
-				return node;
+				return text({ fg: theme.success }, [badge.text]);
 			},
 			session_prompt_right() {
 				const theme = api.theme.current;
-				const route = api.route.current;
-				const sessionID =
-					route.name === "session" && typeof route.params?.sessionID === "string"
-						? route.params.sessionID
-						: undefined;
-				const badge = formatBadge(sessionID);
-				const node = text({ fg: badge.isBlocked ? theme.warning : theme.success }, [badge.text]);
-				if (sessionID) badgeNodes.set(sessionID, node as unknown as BaseRenderable);
-				return node;
+				const badge = formatBadge();
+				return text({ fg: theme.success }, [badge.text]);
 			},
 		},
 	});

package/src/workflow-guard.ts

@@ -19,7 +19,7 @@ import { ToolInvocationLifecycle } from "./lib/tool-lifecycle.ts";
 import { ToolOutcomeTracker, type ToolOutcomePart } from "./lib/tool-outcomes.ts";
 import { guardToolCallImpl, isReadOnlyRole } from "./lib/guard-dispatcher.ts";
 import { createCustomTools } from "./lib/custom-tools.ts";
-import type { TodoSdkClient } from "./lib/types.ts";
+import type { PolicyDecision, TodoSdkClient } from "./lib/types.ts";
 export { isReadOnlyRole } from "./lib/guard-dispatcher.ts";
 export { extractReviewFollowups } from "./lib/custom-tools.ts";
 
@@ -30,6 +30,11 @@ export type {
 	VerifyResult,
 	ReviewResult,
 	AuditEntry,
+	PolicyDecision,
+	PolicyDecisionStatus,
+	EvidenceRecord,
+	EvidenceConfidence,
+	EvidenceSubject,
 	GitInvocation,
 	ShellMutation,
 	LearnerProfile,
@@ -37,6 +42,8 @@ export type {
 	LearningOpportunity,
 } from "./lib/types.ts";
 export type { TodoSdkClient };
+export { verificationEvidence, reviewEvidence, toolOutcomeEvidence, policyDecisionEvidence, lifecycleStateEvidence, agentAssertionEvidence, evidenceMatchesSubject, isEvidenceFresh } from "./lib/evidence.ts";
+export { getRalphOutcome } from "./policies/continuation.ts";
 
 // ── State & runtime context ──────────────────────────────────────────────────
 import {
@@ -57,6 +64,8 @@ import {
 	sessionMutationTimestamps,
 	sessionVerifyResults,
 	getProjectConfig,
+	getOperationProfile,
+	isRecoveryCheckpointsEnabled,
 	isReviewRequired,
 	isDocumentationRequired,
 	getSubagentMutationBudget,
@@ -83,6 +92,8 @@ export {
 	loadProjectConfig,
 	reloadProjectConfig,
 	stripJsonComments,
+	getOperationProfile,
+	isRecoveryCheckpointsEnabled,
 	isReviewRequired,
 	isDocumentationRequired,
 	getSubagentMutationBudget,
@@ -293,20 +304,28 @@ function logObservation(client: unknown, message: string): void {
  * Public guard entry point. Audits every decision (block or allow) to a
  * durable JSONL file before returning.
  */
-export async function guardToolCall(
+export async function guardToolDecision(
 	toolName: string,
 	input: unknown,
 	context?: { sessionID?: string; callID?: string; worktree?: string; directory?: string; agent?: string },
-): Promise<string | undefined> {
+): Promise<PolicyDecision> {
 	const customRoot = context?.worktree || context?.directory;
 	const runImpl = () => guardToolCallImpl(toolName, input, context);
-	const reason = customRoot
+	return customRoot
 		? await runWithRuntimeState(customRoot, getSdkClient(), runImpl)
 		: await runImpl();
+}
+
+export async function guardToolCall(
+	toolName: string,
+	input: unknown,
+	context?: { sessionID?: string; callID?: string; worktree?: string; directory?: string; agent?: string },
+): Promise<string | undefined> {
+	const decision = await guardToolDecision(toolName, input, context);
 	const allowLive = process.env.WORKFLOW_GUARD_ALLOW_LIVE === "1";
 	const isMutation = EDIT_TOOL_NAMES.has(toolName);
 	const targetPath = extractRecordTargetPath(input);
-	logDecision(toolName, input, context, reason, {
+	logDecision(toolName, input, context, decision, {
 		mutation: isMutation,
 		targetPath,
 		allowLive,
@@ -319,7 +338,7 @@ export async function guardToolCall(
 				}
 			: undefined,
 	});
-	return reason;
+	return decision.status === "allowed" ? undefined : decision.message;
 }
 
 async function emitBlockFeedback(message: string): Promise<void> {
@@ -371,7 +390,7 @@ export const WorkflowGuard: Plugin = async (ctx) => {
 	const toolOutcomes = new ToolOutcomeTracker();
 
 	return {
-		tool: createCustomTools({ effectiveRoot, projectMemoryEnabled, learningEnabled, projectMemory, followupStore, portableMemoryPath, learningInterventions }),
+		tool: createCustomTools({ effectiveRoot, projectMemoryEnabled, learningEnabled, projectMemory, followupStore, portableMemoryPath, learningInterventions, client: ctx.client }),
 
 		"tool.execute.before": async (input, output) => {
 			const toolWorktree =
@@ -597,7 +616,7 @@ export const WorkflowGuard: Plugin = async (ctx) => {
 		},
 
 		"chat.message": async (input) => {
-			if (getProjectConfig(effectiveRoot).recoveryCheckpoints !== true) return;
+			if (!isRecoveryCheckpointsEnabled(effectiveRoot)) return;
 			if (isGeneratedContinuationMessage(input.sessionID, input.messageID)) return;
 			const parent = await runWithRuntimeState(effectiveRoot, ctx.client, () => fetchParentSession(input.sessionID));
 			if (!parent.ok || parent.parentID) return;