@gajae-code/coding-agent 0.8.1 → 0.9.0

package/src/session/agent-storage.ts

@@ -420,6 +420,10 @@ FROM model_usage_legacy
 		this.#authStore.setCache(key, value, expiresAtSec);
 	}
 
+	deleteCachePrefix(prefix: string): void {
+		this.#authStore.deleteCachePrefix?.(prefix);
+	}
+
 	/**
 	 * Deletes expired cache entries. Call periodically for cleanup.
 	 */

package/src/session/file-mention-pruning.ts

@@ -0,0 +1,64 @@
+/**
+ * Staleness pruning for auto-read file-mention entries.
+ *
+ * A `@path` mention is superseded once a newer read or mention of the same
+ * resolved path appears later in the branch. Stale bodies are replaced with an
+ * explicit digest notice (never silently deleted) so context shrinks without
+ * losing the reference.
+ */
+import type { FileMentionMessage } from "./messages";
+import type { SessionEntry, SessionMessageEntry } from "./session-manager";
+
+export interface FileMentionPruneResult {
+	changed: SessionMessageEntry[];
+	bytesSaved: number;
+}
+
+/** Notice injected in place of a superseded file-mention body. */
+export function stalefileMentionNotice(path: string): string {
+	return `(pruned: a newer view of \`${path}\` appears later in the conversation; use the read tool to fetch it again)`;
+}
+
+export function pruneStaleFileMentions(
+	entries: readonly SessionEntry[],
+	resolveAbs: (path: string) => string,
+): FileMentionPruneResult {
+	// Latest branch index at which each absolute path was shown (read or mention).
+	const latestShownIndex = new Map<string, number>();
+	entries.forEach((entry, i) => {
+		if (entry.type !== "message") return;
+		const msg = entry.message;
+		if (msg.role === "fileMention") {
+			for (const file of msg.files) {
+				if (file.duplicate || file.pruned) continue;
+				latestShownIndex.set(resolveAbs(file.path), i);
+			}
+		} else if (msg.role === "toolResult") {
+			const resolved = (msg.details as { resolvedPath?: unknown } | undefined)?.resolvedPath;
+			if (typeof resolved === "string" && resolved) latestShownIndex.set(resolveAbs(resolved), i);
+		}
+	});
+
+	const changed: SessionMessageEntry[] = [];
+	let bytesSaved = 0;
+	entries.forEach((entry, i) => {
+		if (entry.type !== "message" || entry.message.role !== "fileMention") return;
+		const msg = entry.message as FileMentionMessage;
+		let mutated = false;
+		for (const file of msg.files) {
+			if (file.duplicate || file.pruned || !file.content) continue;
+			const latest = latestShownIndex.get(resolveAbs(file.path));
+			if (latest !== undefined && latest > i) {
+				const notice = stalefileMentionNotice(file.path);
+				bytesSaved += Math.max(0, Buffer.byteLength(file.content, "utf-8") - Buffer.byteLength(notice, "utf-8"));
+				file.content = notice;
+				file.pruned = true;
+				file.image = undefined;
+				file.lineCount = undefined;
+				mutated = true;
+			}
+		}
+		if (mutated) changed.push(entry as SessionMessageEntry);
+	});
+	return { changed, bytesSaved };
+}

package/src/session/messages.ts

@@ -192,6 +192,10 @@ export interface FileMentionMessage {
 		/** Why the file contents were omitted from auto-read. */
 		skippedReason?: "tooLarge";
 		image?: ImageContent;
+		/** Set when this mention duplicated a recently shown path (compact note, no full body). */
+		duplicate?: boolean;
+		/** Set when a stale entry was pruned to a digest notice (never silently deleted). */
+		pruned?: boolean;
 	}>;
 	timestamp: number;
 }

package/src/session/session-manager.ts

@@ -27,7 +27,9 @@ import {
 	Snowflake,
 	toError,
 } from "@gajae-code/utils";
+import type { TtsrInjectionRecord } from "../export/ttsr";
 import { writeTextAtomic } from "../gjc-runtime/state-writer";
+
 import * as git from "../utils/git";
 import { ArtifactManager } from "./artifacts";
 import {
@@ -221,6 +223,10 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
 	type: "ttsr_injection";
 	/** Names of rules that were injected */
 	injectedRules: string[];
+	/** Rich rule injection records with repeat state. */
+	injectedRuleRecords?: TtsrInjectionRecord[];
+	/** TTSR manager message count when this injection was recorded. */
+	ttsrMessageCount?: number;
 }
 
 /** Persisted MCP discovery selection state for a session branch. */
@@ -313,6 +319,11 @@ export interface SessionContext {
 	models: Record<string, string>;
 	/** Names of TTSR rules that have been injected this session */
 	injectedTtsrRules: string[];
+	/** Rich TTSR rule injection records for repeat resume. */
+	injectedTtsrRuleRecords?: TtsrInjectionRecord[];
+	/** TTSR manager message count for repeat resume. */
+	ttsrMessageCount?: number;
+
 	/** MCP tool names selected through discovery for this session branch. */
 	selectedMCPToolNames: string[];
 	/** Whether this branch contains an explicit persisted MCP selection entry. */
@@ -612,6 +623,9 @@ export function buildSessionContext(
 			serviceTier: undefined,
 			models: {},
 			injectedTtsrRules: [],
+			injectedTtsrRuleRecords: [],
+			ttsrMessageCount: 0,
+
 			selectedMCPToolNames: [],
 			hasPersistedMCPToolSelection: false,
 			mode: "none",
@@ -632,6 +646,8 @@ export function buildSessionContext(
 			serviceTier: undefined,
 			models: {},
 			injectedTtsrRules: [],
+			injectedTtsrRuleRecords: [],
+			ttsrMessageCount: 0,
 			selectedMCPToolNames: [],
 			hasPersistedMCPToolSelection: false,
 			mode: "none",
@@ -656,6 +672,9 @@ export function buildSessionContext(
 	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
 	const injectedTtsrRulesSet = new Set<string>();
+	const injectedTtsrRuleRecords = new Map<string, TtsrInjectionRecord>();
+	let ttsrMessageCount = 0;
+
 	let selectedMCPToolNames: string[] = [];
 	let hasPersistedMCPToolSelection = false;
 	let mode = "none";
@@ -695,9 +714,19 @@ export function buildSessionContext(
 		} else if (entry.type === "compaction") {
 			compaction = entry;
 		} else if (entry.type === "ttsr_injection") {
-			// Collect injected TTSR rule names
+			// Collect injected TTSR rule names and richer records when present.
 			for (const ruleName of entry.injectedRules) {
 				injectedTtsrRulesSet.add(ruleName);
+				if (!injectedTtsrRuleRecords.has(ruleName)) {
+					injectedTtsrRuleRecords.set(ruleName, { name: ruleName, lastInjectedAt: 0 });
+				}
+			}
+			for (const record of entry.injectedRuleRecords ?? []) {
+				injectedTtsrRulesSet.add(record.name);
+				injectedTtsrRuleRecords.set(record.name, record);
+			}
+			if (typeof entry.ttsrMessageCount === "number" && Number.isFinite(entry.ttsrMessageCount)) {
+				ttsrMessageCount = entry.ttsrMessageCount;
 			}
 		} else if (entry.type === "mcp_tool_selection") {
 			selectedMCPToolNames = [...entry.selectedToolNames];
@@ -709,6 +738,7 @@ export function buildSessionContext(
 	}
 
 	const injectedTtsrRules = Array.from(injectedTtsrRulesSet);
+	const injectedTtsrRuleRecordsArray = Array.from(injectedTtsrRuleRecords.values());
 
 	// Build messages and collect corresponding entries
 	// When there's a compaction, we need to:
@@ -797,6 +827,9 @@ export function buildSessionContext(
 		serviceTier,
 		models,
 		injectedTtsrRules,
+		injectedTtsrRuleRecords: injectedTtsrRuleRecordsArray,
+		ttsrMessageCount,
+
 		selectedMCPToolNames,
 		hasPersistedMCPToolSelection,
 		mode,
@@ -810,6 +843,9 @@ function cloneSessionContext(context: SessionContext): SessionContext {
 		messages: cloneJsonSemantic(context.messages),
 		models: { ...context.models },
 		injectedTtsrRules: [...context.injectedTtsrRules],
+		injectedTtsrRuleRecords: context.injectedTtsrRuleRecords?.map(record => ({ ...record })),
+		ttsrMessageCount: context.ttsrMessageCount,
+
 		selectedMCPToolNames: [...context.selectedMCPToolNames],
 		modeData: cloneJsonSemantic(context.modeData),
 	};
@@ -1308,6 +1344,45 @@ function isImageBlock(value: unknown): value is { type: "image"; data: string; m
 	);
 }
 
+function stripUndefinedPlainObjectFields(value: unknown, path = "entry"): unknown {
+	if (value === undefined) return undefined;
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) {
+		let changed = false;
+		const result: unknown[] = new Array(value.length);
+		for (let index = 0; index < value.length; index++) {
+			const item = value[index];
+			if (item === undefined) {
+				throw new Error(`Session entry contains undefined array item at ${path}[${index}]`);
+			}
+			const next = stripUndefinedPlainObjectFields(item, `${path}[${index}]`);
+			if (next !== item) changed = true;
+			result[index] = next;
+		}
+		return changed ? result : value;
+	}
+
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+
+	let changed = false;
+	const entries: Array<readonly [string, unknown]> = [];
+	for (const [key, item] of Object.entries(value)) {
+		if (item === undefined) {
+			changed = true;
+			continue;
+		}
+		const next = stripUndefinedPlainObjectFields(item, `${path}.${key}`);
+		if (next !== item) changed = true;
+		entries.push([key, next]);
+	}
+	return changed ? Object.fromEntries(entries) : value;
+}
+
+function normalizeSessionEntryForStorage(entry: SessionEntry): SessionEntry {
+	return stripUndefinedPlainObjectFields(entry) as SessionEntry;
+}
+
 const RESIDENT_EXTERNALIZE_STRING_EXCLUDED_KEYS = new Set([
 	"id",
 	"type",
@@ -2254,10 +2329,12 @@ class NdjsonFileWriter {
 	}
 }
 
+const DEFAULT_WELCOME_RECENT_SESSION_LIMIT = 20;
+
 /** Get recent sessions for display in welcome screen */
 export async function getRecentSessions(
 	sessionDir: string,
-	limit = 3,
+	limit = DEFAULT_WELCOME_RECENT_SESSION_LIMIT,
 	storage: SessionStorage = new FileSessionStorage(),
 ): Promise<RecentSessionInfo[]> {
 	const sessions = await getSortedSessions(sessionDir, storage);
@@ -3734,7 +3811,8 @@ export class SessionManager {
 	}
 
 	#appendEntry(entry: SessionEntry): void {
-		const residentEntry = prepareEntryForResidentSync(entry, this.#residentBlobStores()) as SessionEntry;
+		const normalizedEntry = normalizeSessionEntryForStorage(entry);
+		const residentEntry = prepareEntryForResidentSync(normalizedEntry, this.#residentBlobStores()) as SessionEntry;
 		this.#fileEntries.push(residentEntry);
 		this.#byId.set(residentEntry.id, residentEntry);
 		this.#leafId = residentEntry.id;
@@ -3915,6 +3993,25 @@ export class SessionManager {
 		return entry.id;
 	}
 
+	/**
+	 * Append a root marker that starts a fresh active branch without changing the
+	 * session id or deleting earlier durable entries. Subsequent messages descend
+	 * from this marker, so provider context is clear while history remains
+	 * available for diagnostics/export.
+	 */
+	appendContextClearEntry(data?: Record<string, unknown>): string {
+		const entry: CustomEntry = {
+			type: "custom",
+			customType: "context_clear",
+			data,
+			id: generateId(this.#byId),
+			parentId: null,
+			timestamp: new Date().toISOString(),
+		};
+		this.#appendEntry(entry);
+		return entry.id;
+	}
+
 	/**
 	 * Write mutated message entries back into the canonical entry store by id.
 	 *
@@ -4006,13 +4103,15 @@ export class SessionManager {
 	 * @param ruleNames Names of rules that were injected
 	 * @returns Entry id
 	 */
-	appendTtsrInjection(ruleNames: string[]): string {
+	appendTtsrInjection(ruleNames: string[], records?: TtsrInjectionRecord[], ttsrMessageCount?: number): string {
 		const entry: TtsrInjectionEntry = {
 			type: "ttsr_injection",
 			id: generateId(this.#byId),
 			parentId: this.#leafId,
 			timestamp: new Date().toISOString(),
 			injectedRules: ruleNames,
+			injectedRuleRecords: records,
+			ttsrMessageCount,
 		};
 		this.#appendEntry(entry);
 		return entry.id;

package/src/skill-state/active-state.ts

@@ -1,11 +1,19 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import * as logger from "@gajae-code/utils/logger";
-import { activeSnapshotPath, assertNonEmptyGjcSessionId, modeStatePath } from "../gjc-runtime/session-layout";
+import {
+	activeSnapshotPath,
+	activeStateDir,
+	assertNonEmptyGjcSessionId,
+	modeStatePath,
+} from "../gjc-runtime/session-layout";
 import { resolveGjcSessionForRead, SessionResolutionError } from "../gjc-runtime/session-resolution";
 import {
 	type ActiveSessionScope,
 	readActiveEntries,
 	rebuildActiveSnapshot,
 	removeActiveEntry,
+	setActiveStateCacheInvalidator,
 	writeActiveEntry,
 } from "../gjc-runtime/state-writer";
 import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "./canonical-skills";
@@ -614,14 +622,108 @@ async function mergeVisibleEntries(
 	return collapsePlanningPipeline(visibleEntries).toSorted(comparePipelineEntry);
 }
 
-export async function readVisibleSkillActiveState(cwd: string, sessionId?: string): Promise<SkillActiveState | null> {
-	let resolvedSessionId: string;
+export type VisibleSkillActiveStateCacheTier = "security" | "hud";
+export interface ReadVisibleSkillActiveStateOptions {
+	tier?: VisibleSkillActiveStateCacheTier;
+}
+
+interface ActiveStateStatSignature {
+	path: string;
+	mtimeMs: number;
+	size: number;
+}
+
+interface ActiveStateSignature {
+	sessionPath: ActiveStateStatSignature | null;
+	activeDir: ActiveStateStatSignature | null;
+	activeEntries: ActiveStateStatSignature[];
+	ralplanModeState: ActiveStateStatSignature | null;
+}
+
+interface VisibleSkillActiveStateCacheEntry {
+	signature: ActiveStateSignature;
+	value: SkillActiveState | null;
+	cachedAtMs: number;
+}
+
+const HUD_VISIBLE_STATE_TTL_MS = 500;
+const SECURITY_VISIBLE_STATE_TTL_MS = 30_000;
+const visibleSkillActiveStateCache = new Map<string, VisibleSkillActiveStateCacheEntry>();
+
+async function statSignature(filePath: string): Promise<ActiveStateStatSignature | null> {
 	try {
-		resolvedSessionId = await resolveBoundarySessionId(cwd, sessionId);
+		const stat = await fs.stat(filePath);
+		return { path: filePath, mtimeMs: stat.mtimeMs, size: stat.size };
 	} catch (error) {
-		if (error instanceof SessionResolutionError && error.code === "no_session") return null;
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
 		throw error;
 	}
+}
+
+function signaturesEqual(a: ActiveStateSignature, b: ActiveStateSignature): boolean {
+	const statEqual = (left: ActiveStateStatSignature | null, right: ActiveStateStatSignature | null): boolean =>
+		left === right ||
+		(Boolean(left) &&
+			Boolean(right) &&
+			left?.path === right?.path &&
+			left?.mtimeMs === right?.mtimeMs &&
+			left?.size === right?.size);
+	if (!statEqual(a.sessionPath, b.sessionPath)) return false;
+	if (!statEqual(a.activeDir, b.activeDir)) return false;
+	if (!statEqual(a.ralplanModeState, b.ralplanModeState)) return false;
+	if (a.activeEntries.length !== b.activeEntries.length) return false;
+	return a.activeEntries.every((entry, index) => statEqual(entry, b.activeEntries[index] ?? null));
+}
+
+export async function computeActiveStateSignature(cwd: string, sessionId: string): Promise<ActiveStateSignature> {
+	const resolvedCwd = path.resolve(cwd);
+	const { sessionPath } = getSkillActiveStatePaths(resolvedCwd, sessionId);
+	const activeDirPath = activeStateDir(resolvedCwd, sessionId);
+	const activeDir = await statSignature(activeDirPath);
+	let activeEntries: ActiveStateStatSignature[] = [];
+	try {
+		const names = await fs.readdir(activeDirPath);
+		activeEntries = (
+			await Promise.all(
+				names
+					.filter(name => name.endsWith(".json"))
+					.sort()
+					.map(name => statSignature(path.join(activeDirPath, name))),
+			)
+		).filter((entry): entry is ActiveStateStatSignature => entry !== null);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	return {
+		sessionPath: await statSignature(sessionPath),
+		activeDir,
+		activeEntries,
+		ralplanModeState: await statSignature(modeStatePath(resolvedCwd, sessionId, "ralplan")),
+	};
+}
+
+function visibleActiveStateCacheKey(cwd: string, sessionId: string): string {
+	return `${path.resolve(cwd)}\0${sessionId}`;
+}
+
+export function invalidateVisibleSkillActiveStateCache(cwd?: string, sessionId?: string): void {
+	if (!cwd && !sessionId) {
+		visibleSkillActiveStateCache.clear();
+		return;
+	}
+	const resolvedCwd = cwd ? path.resolve(cwd) : undefined;
+	const suffix = sessionId ? `\0${sessionId}` : undefined;
+	for (const key of [...visibleSkillActiveStateCache.keys()]) {
+		if (resolvedCwd && !key.startsWith(`${resolvedCwd}\0`)) continue;
+		if (suffix && !key.endsWith(suffix)) continue;
+		visibleSkillActiveStateCache.delete(key);
+	}
+}
+
+async function readVisibleSkillActiveStateUncached(
+	cwd: string,
+	resolvedSessionId: string,
+): Promise<SkillActiveState | null> {
 	const { sessionPath } = getSkillActiveStatePaths(cwd, resolvedSessionId);
 	const sessionState = await readRawActiveStateForHandoff(sessionPath, false);
 	const activeSkills = await mergeVisibleEntries(cwd, sessionState, resolvedSessionId);
@@ -639,6 +741,40 @@ export async function readVisibleSkillActiveState(cwd: string, sessionId?: strin
 	};
 }
 
+setActiveStateCacheInvalidator(invalidateVisibleSkillActiveStateCache);
+
+export async function readVisibleSkillActiveState(
+	cwd: string,
+	sessionId?: string,
+	opts?: ReadVisibleSkillActiveStateOptions,
+): Promise<SkillActiveState | null> {
+	let resolvedSessionId: string;
+	try {
+		resolvedSessionId = await resolveBoundarySessionId(cwd, sessionId);
+	} catch (error) {
+		if (error instanceof SessionResolutionError && error.code === "no_session") return null;
+		throw error;
+	}
+	const resolvedCwd = path.resolve(cwd);
+	const cacheKey = visibleActiveStateCacheKey(resolvedCwd, resolvedSessionId);
+	const tier = opts?.tier ?? "security";
+	const now = Date.now();
+	const cached = visibleSkillActiveStateCache.get(cacheKey);
+	if (tier === "hud" && cached && now - cached.cachedAtMs < HUD_VISIBLE_STATE_TTL_MS) return cached.value;
+
+	const signature = await computeActiveStateSignature(resolvedCwd, resolvedSessionId);
+	if (
+		cached &&
+		signaturesEqual(cached.signature, signature) &&
+		(tier === "hud" || now - cached.cachedAtMs < SECURITY_VISIBLE_STATE_TTL_MS)
+	) {
+		return cached.value;
+	}
+	const value = await readVisibleSkillActiveStateUncached(resolvedCwd, resolvedSessionId);
+	visibleSkillActiveStateCache.set(cacheKey, { signature, value, cachedAtMs: now });
+	return value;
+}
+
 function activeStateWriterAudit(verb: string, sessionScope?: ActiveSessionScope | string) {
 	const sessionId = typeof sessionScope === "string" ? sessionScope : sessionScope?.sessionId;
 	return { category: "state" as const, verb, owner: "gjc-runtime" as const, ...(sessionId ? { sessionId } : {}) };

package/src/skill-state/deep-interview-mutation-guard.ts

@@ -33,10 +33,18 @@ function planningPhaseBlockMessage(skill: CanonicalGjcWorkflowSkill): string {
 	return DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE;
 }
 
-const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit"]);
+const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit", "bash"]);
 const ARCHIVE_OR_SQLITE_BASE_RE = /^(.+?\.(?:tar\.gz|sqlite3|sqlite|db3|zip|tgz|tar|db))(?:$|:)/i;
 const INTERNAL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
 const VIM_FILE_SWITCH_RE = /^\s*:(?:e|e!|edit|edit!)(?:\s+([^<\r\n]+))?(?:<CR>|\r|\n|$)/i;
+const BASH_MUTATION_COMMAND_RE =
+	/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:tee|touch|rm|mkdir|cp|mv|install|truncate)\b([^;&|\n]*)|(?:^|[^<>])(?:>>?|\d>>?)\s*([^\s;&|]+)/gi;
+const BASH_IN_PLACE_MUTATION_COMMAND_RE = /(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:sed|perl)\b([^;&|\n]*)/gi;
+const BASH_OPAQUE_INTERPRETER_WRITE_RE =
+	/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:python3?|node|ruby)\b[^;&|\n]*(?:-c|-e)\b[^;&|\n]*(?:open\s*\(|writeFile(?:Sync)?\s*\(|\.write\s*\()/i;
+const BASH_HEREDOC_OPAQUE_INTERPRETER_WRITE_RE =
+	/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:python3?|node|ruby)\b[^;&|\n]*(?:<<[-]?\s*['"]?\w+['"]?)[\s\S]*(?:open\s*\(|writeFile(?:Sync)?\s*\(|\.write\s*\()/i;
+const BASH_DD_OUTPUT_RE = /(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?dd\b([^;&|\n]*)/gi;
 
 type ToolWithEditMode = AgentTool & {
 	mode?: unknown;
@@ -214,7 +222,7 @@ async function getActivePlanningSkill(
 ): Promise<ActivePlanningSkill | null> {
 	const resolvedSessionId = await resolveBoundarySessionId(cwd, sessionId);
 	if (!resolvedSessionId) return null;
-	const skillState = await readVisibleSkillActiveState(cwd, resolvedSessionId);
+	const skillState = await readVisibleSkillActiveState(cwd, resolvedSessionId, { tier: "security" });
 	if (!skillState) return null;
 	const activeEntries = listActiveSkills(skillState).filter(entry =>
 		entryMatchesContext(entry, resolvedSessionId, threadId),
@@ -329,11 +337,66 @@ function extractEditTargets(args: unknown, tool: ToolWithEditMode): ExtractedTar
 	if (targets.paths.length === 0) targets.unknown = true;
 	return targets;
 }
+function shellWords(argsText: string): string[] {
+	return argsText.match(/(?:[^\s'"\\]+|'[^']*'|"[^"]*")+/g) ?? [];
+}
+
+function cleanShellWord(value: string): string {
+	return value.replace(/^['"]|['"]$/g, "");
+}
 
+function extractBashTargets(args: unknown): ExtractedTargets {
+	const record = getRecord(args);
+	const command = safeString(record?.command);
+	const targets: ExtractedTargets = { paths: [], unknown: false };
+	if (!command.trim()) {
+		targets.unknown = true;
+		return targets;
+	}
+	if (BASH_OPAQUE_INTERPRETER_WRITE_RE.test(command) || BASH_HEREDOC_OPAQUE_INTERPRETER_WRITE_RE.test(command)) {
+		targets.unknown = true;
+	}
+	for (const match of command.matchAll(BASH_DD_OUTPUT_RE)) {
+		const parts = shellWords(match[1] ?? "").map(cleanShellWord);
+		const output = parts.find(part => part.startsWith("of="));
+		if (output) addPath(targets, output.slice(3));
+		else targets.unknown = true;
+	}
+	for (const match of command.matchAll(BASH_IN_PLACE_MUTATION_COMMAND_RE)) {
+		const parts = shellWords(match[1] ?? "").map(cleanShellWord);
+		const hasInPlaceFlag = parts.some(part => /^-.*i/.test(part));
+		if (!hasInPlaceFlag) continue;
+		const target = [...parts].reverse().find(part => part && !part.startsWith("-"));
+		if (target) addPath(targets, target);
+		else targets.unknown = true;
+	}
+	for (const match of command.matchAll(BASH_MUTATION_COMMAND_RE)) {
+		const redirected = match[2]?.trim();
+		if (redirected) {
+			addPath(targets, cleanShellWord(redirected));
+			continue;
+		}
+		const parts = shellWords(match[1] ?? "");
+		const commandName = match[0]
+			?.match(/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(tee|touch|rm|mkdir|cp|mv|install|truncate)\b/i)?.[1]
+			?.toLowerCase();
+		const targetParts =
+			commandName === "cp" || commandName === "mv" || commandName === "install" || commandName === "truncate"
+				? parts.slice(-1)
+				: parts;
+		for (const part of targetParts) {
+			const cleaned = cleanShellWord(part);
+			if (!cleaned || cleaned.startsWith("-")) continue;
+			addPath(targets, cleaned);
+		}
+	}
+	return targets;
+}
 function extractTargets(tool: ToolWithEditMode, args: unknown): ExtractedTargets {
 	if (tool.name === "write") return extractWriteTargets(args);
 	if (tool.name === "ast_edit") return extractAstEditTargets(args);
 	if (tool.name === "edit") return extractEditTargets(args, tool);
+	if (tool.name === "bash") return extractBashTargets(args);
 	return { paths: [], unknown: true };
 }
 
@@ -490,6 +553,7 @@ async function isNeutralTempPath(cwd: string, rawPath: string): Promise<boolean>
 async function planningBlockedTargets(cwd: string, targets: ExtractedTargets): Promise<string[]> {
 	const blocked: string[] = [];
 	for (const rawPath of targets.paths) {
+		if (isAllowlistedPath(cwd, rawPath)) continue;
 		if (!(await isNeutralTempPath(cwd, rawPath))) blocked.push(rawPath);
 	}
 	return blocked;
@@ -523,7 +587,7 @@ export async function getDeepInterviewMutationDecision(
 ): Promise<DeepInterviewMutationDecision> {
 	if (!BLOCKED_TOOL_NAMES.has(input.tool.name)) return { blocked: false, targets: [] };
 	const targets = extractTargets(input.tool, input.args);
-	if (input.enforceWorkflowState !== false && hasBlockedGjcTarget(input.cwd, targets)) {
+	if (input.tool.name !== "bash" && input.enforceWorkflowState !== false && hasBlockedGjcTarget(input.cwd, targets)) {
 		const stateSkill = firstBlockedWorkflowStateSkill(input.cwd, targets);
 		const command = stateSkill ? sanctionedWorkflowStateCommand(stateSkill) : "gjc <workflow-command>";
 		return {