@gajae-code/coding-agent 0.1.1 → 0.1.2

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

@@ -0,0 +1,303 @@
+import * as path from "node:path";
+import type { AgentTool } from "@gajae-code/agent-core";
+import { expandApplyPatchToEntries } from "../edit/modes/apply-patch";
+import { LocalProtocolHandler, resolveLocalUrlToPath } from "../internal-urls/local-protocol";
+import { resolveToCwd } from "../tools/path-utils";
+import { ToolError } from "../tools/tool-errors";
+import { listActiveSkills, readVisibleSkillActiveState, type SkillActiveEntry } from "./active-state";
+
+export const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE =
+	"Deep-interview is active; either continue interviewing with `ask`, or write/finalize the pending spec under `.gjc/specs/` / update state under `.gjc/state/`. Do not edit product code until explicit execution approval.";
+
+const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit"]);
+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 GLOB_META_RE = /[*?[\]{}]/;
+const VIM_FILE_SWITCH_RE = /^\s*:(?:e|e!|edit|edit!)(?:\s+([^<\r\n]+))?(?:<CR>|\r|\n|$)/i;
+
+type ToolWithEditMode = AgentTool & {
+	mode?: unknown;
+	customWireName?: unknown;
+};
+
+export interface DeepInterviewMutationGuardInput {
+	cwd: string;
+	sessionId?: string;
+	threadId?: string;
+	tool: ToolWithEditMode;
+	args: unknown;
+}
+
+interface ExtractedTargets {
+	paths: string[];
+	unknown: boolean;
+}
+
+export interface DeepInterviewMutationDecision {
+	blocked: boolean;
+	message?: string;
+	targets: string[];
+	reason?: string;
+}
+
+interface ModeState {
+	active?: boolean;
+	current_phase?: string;
+	session_id?: string;
+	thread_id?: string;
+	[key: string]: unknown;
+}
+
+function safeString(value: unknown): string {
+	return typeof value === "string" ? value : "";
+}
+
+function encodePathSegment(value: string): string {
+	return encodeURIComponent(value).replaceAll(".", "%2E");
+}
+
+function modeStatePath(cwd: string, skill: string, sessionId?: string): string {
+	const stateDir = path.join(cwd, ".gjc", "state");
+	const fileName = `${skill}-state.json`;
+	if (sessionId) return path.join(stateDir, "sessions", encodePathSegment(sessionId), fileName);
+	return path.join(stateDir, fileName);
+}
+
+async function readJsonFile<T>(filePath: string): Promise<T | null> {
+	try {
+		return JSON.parse(await Bun.file(filePath).text()) as T;
+	} catch {
+		return null;
+	}
+}
+async function readVisibleModeState(cwd: string, skill: string, sessionId?: string): Promise<ModeState | null> {
+	if (sessionId) {
+		const sessionState = await readJsonFile<ModeState>(modeStatePath(cwd, skill, sessionId));
+		if (sessionState) return sessionState;
+	}
+	return await readJsonFile<ModeState>(modeStatePath(cwd, skill));
+}
+
+function isTerminalModeState(state: ModeState | null): boolean {
+	if (!state || state.active !== true) return true;
+	const phase = String(state.current_phase ?? "")
+		.trim()
+		.toLowerCase();
+	return ["complete", "completed", "failed", "cancelled", "canceled", "inactive"].includes(phase);
+}
+
+function entryMatchesContext(entry: SkillActiveEntry, sessionId?: string, threadId?: string): boolean {
+	if (sessionId && entry.session_id && entry.session_id !== sessionId) return false;
+	if (threadId && entry.thread_id && entry.thread_id !== threadId) return false;
+	return true;
+}
+
+function modeStateMatchesContext(state: ModeState, sessionId?: string, threadId?: string): boolean {
+	if (sessionId && state.session_id && state.session_id !== sessionId) return false;
+	if (threadId && state.thread_id && state.thread_id !== threadId) return false;
+	return true;
+}
+
+async function isActiveDeepInterview(cwd: string, sessionId?: string, threadId?: string): Promise<boolean> {
+	const skillState = await readVisibleSkillActiveState(cwd, sessionId);
+	const activeDeepInterview = listActiveSkills(skillState).find(
+		entry => entry.skill === "deep-interview" && entryMatchesContext(entry, sessionId, threadId),
+	);
+	if (!activeDeepInterview) return false;
+
+	const modeState = await readVisibleModeState(cwd, "deep-interview", sessionId);
+	if (isTerminalModeState(modeState)) return false;
+	if (modeState && !modeStateMatchesContext(modeState, sessionId, threadId)) return false;
+	return true;
+}
+
+function normalizePosix(value: string): string {
+	return value.replace(/\\/g, "/");
+}
+
+function addPath(targets: ExtractedTargets, value: unknown): void {
+	if (typeof value === "string" && value.trim().length > 0) {
+		targets.paths.push(value.trim());
+	}
+}
+
+function getRecord(value: unknown): Record<string, unknown> | null {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
+}
+
+function extractWriteTargets(args: unknown): ExtractedTargets {
+	const record = getRecord(args);
+	const targets: ExtractedTargets = { paths: [], unknown: false };
+	addPath(targets, record?.path);
+	if (targets.paths.length === 0) targets.unknown = true;
+	return targets;
+}
+
+function extractAstEditTargets(args: unknown): ExtractedTargets {
+	const record = getRecord(args);
+	const targets: ExtractedTargets = { paths: [], unknown: false };
+	const paths = record?.paths;
+	if (Array.isArray(paths)) {
+		for (const entry of paths) addPath(targets, entry);
+	}
+	if (targets.paths.length === 0) targets.unknown = true;
+	return targets;
+}
+
+function extractVimSwitchTargets(steps: unknown, targets: ExtractedTargets): void {
+	if (!Array.isArray(steps)) return;
+	for (const step of steps) {
+		const record = getRecord(step);
+		const keys = record?.kbd;
+		if (!Array.isArray(keys)) continue;
+		for (const key of keys) {
+			if (typeof key !== "string") continue;
+			const match = key.match(VIM_FILE_SWITCH_RE);
+			if (!match) continue;
+			const targetPath = match[1]?.trim();
+			if (!targetPath) {
+				targets.unknown = true;
+				continue;
+			}
+			targets.paths.push(targetPath);
+		}
+	}
+}
+
+function extractApplyPatchTargets(args: unknown, targets: ExtractedTargets): boolean {
+	const record = getRecord(args);
+	const input = record?.input;
+	if (typeof input !== "string") return false;
+	try {
+		for (const entry of expandApplyPatchToEntries({ input })) {
+			addPath(targets, entry.path);
+			addPath(targets, entry.rename);
+		}
+	} catch {
+		targets.unknown = true;
+	}
+	return true;
+}
+
+function extractEditTargets(args: unknown, tool: ToolWithEditMode): ExtractedTargets {
+	const record = getRecord(args);
+	const targets: ExtractedTargets = { paths: [], unknown: false };
+	const customWireName = safeString(tool.customWireName);
+	const mode = safeString(tool.mode);
+
+	const isApplyPatchMode = customWireName === "apply_patch" || mode === "apply_patch";
+	const hasApplyPatchInput = typeof record?.input === "string";
+	if (isApplyPatchMode || hasApplyPatchInput) {
+		extractApplyPatchTargets(args, targets);
+		if (targets.paths.length === 0) targets.unknown = true;
+		return targets;
+	}
+
+	addPath(targets, record?.path);
+	addPath(targets, record?.file);
+	const edits = record?.edits;
+	if (Array.isArray(edits)) {
+		for (const edit of edits) {
+			const editRecord = getRecord(edit);
+			addPath(targets, editRecord?.rename);
+			addPath(targets, editRecord?.path);
+		}
+	}
+	if (record?.file !== undefined || mode === "vim") {
+		extractVimSwitchTargets(record?.steps, targets);
+	}
+	if (targets.paths.length === 0) targets.unknown = true;
+	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);
+	return { paths: [], unknown: true };
+}
+
+function stripSelectorBase(rawPath: string): string {
+	const archiveOrSqlite = rawPath.match(ARCHIVE_OR_SQLITE_BASE_RE);
+	if (archiveOrSqlite?.[1]) return archiveOrSqlite[1];
+	return rawPath;
+}
+
+function resolveRawPath(cwd: string, rawPath: string): { absolutePath?: string; unknown: boolean } {
+	const normalized = rawPath.trim();
+	if (!normalized) return { unknown: true };
+	if (normalized === ".") return { absolutePath: path.resolve(cwd), unknown: false };
+	if (normalized.startsWith("local://") || normalized.startsWith("local:/")) {
+		const options = LocalProtocolHandler.resolveOptions();
+		if (!options) return { unknown: true };
+		try {
+			return { absolutePath: resolveLocalUrlToPath(normalized, options), unknown: false };
+		} catch {
+			return { unknown: true };
+		}
+	}
+	if (INTERNAL_SCHEME_RE.test(normalized)) return { unknown: true };
+
+	const basePath = stripSelectorBase(normalized);
+	try {
+		return { absolutePath: resolveToCwd(basePath, cwd), unknown: false };
+	} catch {
+		return { unknown: true };
+	}
+}
+
+function isAllowlistedPath(cwd: string, rawPath: string): boolean {
+	const { absolutePath, unknown } = resolveRawPath(cwd, rawPath);
+	if (unknown || !absolutePath) return false;
+	const relative = path.relative(path.resolve(cwd), path.resolve(absolutePath));
+	if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) return false;
+	const segments = normalizePosix(relative).split("/").filter(Boolean);
+	return segments[0] === ".gjc" && (segments[1] === "specs" || segments[1] === "state");
+}
+
+function allTargetsAllowlisted(cwd: string, targets: ExtractedTargets): boolean {
+	if (targets.unknown || targets.paths.length === 0) return false;
+	return targets.paths.every(rawPath => {
+		if (GLOB_META_RE.test(rawPath)) {
+			return isAllowlistedPath(cwd, rawPath);
+		}
+		return isAllowlistedPath(cwd, rawPath);
+	});
+}
+
+export async function assertDeepInterviewMutationRawPathsAllowed(input: {
+	cwd: string;
+	sessionId?: string;
+	threadId?: string;
+	rawPaths: string[];
+}): Promise<void> {
+	if (!(await isActiveDeepInterview(input.cwd, input.sessionId, input.threadId))) return;
+	const targets: ExtractedTargets = { paths: input.rawPaths, unknown: input.rawPaths.length === 0 };
+	if (!allTargetsAllowlisted(input.cwd, targets)) {
+		throw new ToolError(DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE);
+	}
+}
+
+export async function getDeepInterviewMutationDecision(
+	input: DeepInterviewMutationGuardInput,
+): Promise<DeepInterviewMutationDecision> {
+	if (!BLOCKED_TOOL_NAMES.has(input.tool.name)) return { blocked: false, targets: [] };
+	if (!(await isActiveDeepInterview(input.cwd, input.sessionId, input.threadId))) {
+		return { blocked: false, targets: [] };
+	}
+	const targets = extractTargets(input.tool, input.args);
+	if (allTargetsAllowlisted(input.cwd, targets)) {
+		return { blocked: false, targets: targets.paths };
+	}
+	return {
+		blocked: true,
+		message: DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE,
+		targets: targets.paths,
+		reason: targets.unknown ? "unknown-target" : "product-target",
+	};
+}
+
+export async function assertDeepInterviewMutationAllowed(input: DeepInterviewMutationGuardInput): Promise<void> {
+	const decision = await getDeepInterviewMutationDecision(input);
+	if (decision.blocked) throw new ToolError(decision.message ?? DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE);
+}

package/src/slash-commands/builtin-registry.ts

@@ -1,7 +1,15 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import type { ThinkingLevel } from "@gajae-code/agent-core";
+import { type Model, modelsAreEqual } from "@gajae-code/ai";
 import { getOAuthProviders } from "@gajae-code/ai/utils/oauth";
 import { setProjectDir } from "@gajae-code/utils";
+import {
+	GJC_MODEL_ASSIGNMENT_TARGET_IDS,
+	GJC_MODEL_ASSIGNMENT_TARGETS,
+	type GjcModelAssignmentTargetId,
+} from "../config/model-registry";
+import { extractExplicitThinkingSelector, formatModelSelectorValue, parseModelPattern } from "../config/model-resolver";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../discovery/helpers.js";
 import { resolveMemoryBackend } from "../memory-backend";
 import type { InteractiveModeContext } from "../modes/types";
@@ -11,6 +19,7 @@ import {
 	formatProviderSetupResult,
 	parseProviderCompatibility,
 } from "../setup/provider-onboarding";
+import { parseThinkingLevel } from "../thinking";
 import { formatDuration } from "./helpers/format";
 import { commandConsumed, errorMessage, parseSlashCommand, usage } from "./helpers/parse";
 import { handleSshAcp } from "./helpers/ssh";
@@ -92,8 +101,82 @@ function providerSetupUsage(): string {
 	].join("\n");
 }
 
-function modelSelectionUsage(currentModelLine?: string): string {
-	return [currentModelLine, formatModelOnboardingGuidance()]
+function formatModelAssignmentSummary(runtime: SlashCommandRuntime): string {
+	const agentModelOverrides = runtime.settings.get("task.agentModelOverrides");
+	const lines = ["Model assignments:"];
+	for (const targetId of GJC_MODEL_ASSIGNMENT_TARGET_IDS) {
+		const target = GJC_MODEL_ASSIGNMENT_TARGETS[targetId];
+		const modelSelector =
+			target.settingsPath === "modelRoles" ? runtime.settings.getModelRole(targetId) : agentModelOverrides[targetId];
+		lines.push(`  ${target.tag ?? target.id.toUpperCase()} (${target.name}): ${modelSelector ?? "(unset)"}`);
+	}
+	return lines.join("\n");
+}
+
+function parseModelCommandArgs(args: string): { targetId: GjcModelAssignmentTargetId; selector: string } {
+	const tokens = args.trim().split(/\s+/).filter(Boolean);
+	const first = tokens[0]?.toLowerCase();
+	const explicitTarget = GJC_MODEL_ASSIGNMENT_TARGET_IDS.includes(first as GjcModelAssignmentTargetId)
+		? (first as GjcModelAssignmentTargetId)
+		: undefined;
+	if (explicitTarget) {
+		return { targetId: explicitTarget, selector: tokens.slice(1).join(" ") };
+	}
+	if (first === "set") {
+		const second = tokens[1]?.toLowerCase();
+		if (GJC_MODEL_ASSIGNMENT_TARGET_IDS.includes(second as GjcModelAssignmentTargetId)) {
+			return { targetId: second as GjcModelAssignmentTargetId, selector: tokens.slice(2).join(" ") };
+		}
+	}
+	return { targetId: "default", selector: args.trim() };
+}
+
+function splitExplicitThinkingSelector(selector: string): { baseSelector: string; thinkingLevel?: ThinkingLevel } {
+	const trimmed = selector.trim();
+	const colonIndex = trimmed.lastIndexOf(":");
+	if (colonIndex === -1) {
+		return { baseSelector: trimmed };
+	}
+	const thinkingLevel = parseThinkingLevel(trimmed.slice(colonIndex + 1));
+	return thinkingLevel ? { baseSelector: trimmed.slice(0, colonIndex), thinkingLevel } : { baseSelector: trimmed };
+}
+
+function resolveModelCommandSelection(
+	runtime: SlashCommandRuntime,
+	selector: string,
+): { model: Model; selector: string; thinkingLevel?: ThinkingLevel } | undefined {
+	const availableModels = runtime.session.getAvailableModels?.() ?? [];
+	const matchPreferences = { usageOrder: runtime.settings.getStorage()?.getModelUsageOrder() };
+	const resolved = parseModelPattern(selector, availableModels, matchPreferences, {
+		modelRegistry: runtime.session.modelRegistry,
+	});
+	if (!resolved.model) {
+		return undefined;
+	}
+
+	const splitSelector = splitExplicitThinkingSelector(selector);
+	const canonicalModel = runtime.session.modelRegistry.resolveCanonicalModel?.(splitSelector.baseSelector, {
+		availableOnly: false,
+		candidates: availableModels,
+	});
+	const persistedSelector =
+		canonicalModel && modelsAreEqual(canonicalModel, resolved.model)
+			? splitSelector.baseSelector
+			: `${resolved.model.provider}/${resolved.model.id}`;
+	return {
+		model: resolved.model,
+		selector: persistedSelector,
+		thinkingLevel: resolved.explicitThinkingLevel ? resolved.thinkingLevel : undefined,
+	};
+}
+
+function modelSelectionUsage(runtime: SlashCommandRuntime, currentModelLine?: string): string {
+	return [
+		currentModelLine,
+		formatModelAssignmentSummary(runtime),
+		"ACP/text mode: use /model <model> for DEFAULT, or /model <target> <model> for EXECUTOR, ARCHITECT, PLANNER, or CRITIC.",
+		formatModelOnboardingGuidance(),
+	]
 		.filter((line): line is string => Boolean(line))
 		.join("\n\n");
 }
@@ -159,25 +242,60 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		aliases: ["models"],
 		description: "Select model (opens selector UI)",
 		acpDescription: "Show current model selection",
+		inlineHint: "[target] <model>",
+		acpInputHint: "[target] <model>",
 		handle: async (command, runtime) => {
 			if (command.args) {
-				const modelId = command.args.trim();
-				const availableModels = runtime.session.getAvailableModels?.() ?? [];
-				const match = availableModels.find(
-					model => model.id === modelId || `${model.provider}/${model.id}` === modelId,
-				);
-				if (!match) {
+				const parsedArgs = parseModelCommandArgs(command.args);
+				const modelId = parsedArgs.selector;
+				if (!modelId) {
+					return usage(
+						modelSelectionUsage(runtime, `Missing model for ${parsedArgs.targetId.toUpperCase()}.`),
+						runtime,
+					);
+				}
+				const selection = resolveModelCommandSelection(runtime, modelId);
+				if (!selection) {
 					return usage(
 						modelSelectionUsage(
+							runtime,
 							`Unknown model: ${modelId}. Configure or login to a provider first, then list/select models with /model.`,
 						),
 						runtime,
 					);
 				}
 				try {
-					await runtime.session.setModel(match);
-					await runtime.output(`Model set to ${match.provider}/${match.id}.`);
-					await runtime.notifyTitleChanged?.();
+					const persistedSelector = formatModelSelectorValue(selection.selector, selection.thinkingLevel);
+					if (parsedArgs.targetId === "default") {
+						await runtime.session.setModel(selection.model, "default", {
+							selector: selection.selector,
+							thinkingLevel: selection.thinkingLevel,
+						});
+						if (selection.thinkingLevel) {
+							runtime.session.setThinkingLevel(selection.thinkingLevel);
+						}
+						await runtime.output(`Default model set to ${persistedSelector}.`);
+						await runtime.notifyTitleChanged?.();
+					} else {
+						const apiKey = await runtime.session.modelRegistry.getApiKey(
+							selection.model,
+							runtime.session.sessionId,
+						);
+						if (!apiKey) {
+							throw new Error(`No API key for ${selection.model.provider}/${selection.model.id}`);
+						}
+						const overrides = runtime.settings.get("task.agentModelOverrides");
+						const thinkingLevel =
+							selection.thinkingLevel ??
+							extractExplicitThinkingSelector(overrides[parsedArgs.targetId], runtime.settings);
+						const roleSelector = formatModelSelectorValue(selection.selector, thinkingLevel);
+						runtime.settings.set("task.agentModelOverrides", {
+							...overrides,
+							[parsedArgs.targetId]: roleSelector,
+						});
+						runtime.settings.getStorage()?.recordModelUsage(`${selection.model.provider}/${selection.model.id}`);
+						await runtime.output(`${parsedArgs.targetId} agent model set to ${roleSelector}.`);
+					}
 					await runtime.notifyConfigChanged?.();
 					return commandConsumed();
 				} catch (err) {
@@ -188,6 +306,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			const model = runtime.session.model;
 			await runtime.output(
 				modelSelectionUsage(
+					runtime,
 					model ? `Current model: ${model.provider}/${model.id}` : "No model is currently selected.",
 				),
 			);

package/src/tools/ask.ts

@@ -16,7 +16,16 @@
  */
 
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
-import { type Component, Container, Markdown, renderInlineMarkdown, TERMINAL, Text } from "@gajae-code/tui";
+import {
+	type Component,
+	Container,
+	Markdown,
+	renderInlineMarkdown,
+	TERMINAL,
+	Text,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "@gajae-code/tui";
 import { prompt, untilAborted } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -598,6 +607,31 @@ function renderCustomInput(
 	return text;
 }
 
+interface RenderOptionListEntry {
+	prefix: string;
+	label: string;
+}
+
+class AskOptionList implements Component {
+	constructor(private readonly entries: RenderOptionListEntry[]) {}
+
+	render(width: number): string[] {
+		const lines: string[] = [];
+		for (const entry of this.entries) {
+			const prefixWidth = visibleWidth(entry.prefix);
+			const availableWidth = Math.max(1, width - prefixWidth);
+			const wrapped = wrapTextWithAnsi(entry.label, availableWidth);
+			const continuation = " ".repeat(prefixWidth);
+			for (let i = 0; i < wrapped.length; i++) {
+				lines.push(`${i === 0 ? entry.prefix : continuation}${wrapped[i]}`);
+			}
+		}
+		return lines;
+	}
+
+	invalidate(): void {}
+}
+
 export const askToolRenderer = {
 	renderCall(args: AskRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const label = formatTitle("Ask", uiTheme);
@@ -625,16 +659,18 @@ export const askToolRenderer = {
 				);
 				container.addChild(new Markdown(q.question, 3, 0, mdTheme, accentStyle));
 
-				if (q.options?.length) {
-					let optText = "";
-					for (let j = 0; j < q.options.length; j++) {
-						const opt = q.options[j];
-						const isLastOpt = j === q.options.length - 1;
+				const qOptions = q.options;
+				if (qOptions?.length) {
+					const entries = qOptions.map((opt, j) => {
+						const isLastOpt = j === qOptions.length - 1;
 						const optBranch = isLastOpt ? uiTheme.tree.last : uiTheme.tree.branch;
 						const optLabel = renderInlineMarkdown(opt.label, mdTheme, t => uiTheme.fg("muted", t));
-						optText += `\n ${uiTheme.fg("dim", continuation)}   ${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} ${optLabel}`;
-					}
-					container.addChild(new Text(optText, 0, 0));
+						return {
+							prefix: ` ${uiTheme.fg("dim", continuation)}   ${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} `,
+							label: optLabel,
+						};
+					});
+					container.addChild(new AskOptionList(entries));
 				}
 			}
 			return container;
@@ -652,16 +688,18 @@ export const askToolRenderer = {
 		container.addChild(new Text(`${label}${formatMeta(meta, uiTheme)}`, 0, 0));
 		container.addChild(new Markdown(args.question, 1, 0, mdTheme, accentStyle));
 
-		if (args.options?.length) {
-			let optText = "";
-			for (let i = 0; i < args.options.length; i++) {
-				const opt = args.options[i];
-				const isLast = i === args.options.length - 1;
+		const options = args.options;
+		if (options?.length) {
+			const entries = options.map((opt, i) => {
+				const isLast = i === options.length - 1;
 				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
 				const optLabel = renderInlineMarkdown(opt.label, mdTheme, t => uiTheme.fg("muted", t));
-				optText += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} ${optLabel}`;
-			}
-			container.addChild(new Text(optText, 0, 0));
+				return {
+					prefix: ` ${uiTheme.fg("dim", branch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} `,
+					label: optLabel,
+				};
+			});
+			container.addChild(new AskOptionList(entries));
 		}
 
 		return container;

package/src/tools/ast-edit.ts

@@ -9,6 +9,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { computeLineHash, HL_BODY_SEP } from "../hashline/hash";
 import type { Theme } from "../modes/theme/theme";
 import astEditDescription from "../prompts/tools/ast-edit.md" with { type: "text" };
+import { assertDeepInterviewMutationRawPathsAllowed } from "../skill-state/deep-interview-mutation-guard";
 import { Ellipsis, fileHyperlink, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
@@ -322,10 +323,16 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			if (!result.applied && result.totalReplacements > 0) {
 				const previewReplacementPlural = result.totalReplacements !== 1 ? "s" : "";
 				const previewFilePlural = result.filesTouched !== 1 ? "s" : "";
+				const previewedFiles = fileList;
 				queueResolveHandler(this.session, {
 					label: `AST Edit: ${result.totalReplacements} replacement${previewReplacementPlural} in ${result.filesTouched} file${previewFilePlural}`,
 					sourceToolName: this.name,
 					apply: async (_reason: string) => {
+						await assertDeepInterviewMutationRawPathsAllowed({
+							cwd: this.session.cwd,
+							sessionId: this.session.getSessionId?.() ?? undefined,
+							rawPaths: previewedFiles,
+						});
 						const applyResult = await runAstEditOnce(multiTargets, resolvedSearchPath, globFilter, {
 							rewrites: normalizedRewrites,
 							dryRun: false,

package/src/tools/bash.ts

@@ -519,6 +519,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			},
 		};
 		command = await expandInternalUrls(command, { ...internalUrlOptions, ensureLocalParentDirs: true });
+		const sessionFile = this.session.getSessionFile?.() ?? null;
 		const expandedEnv = env
 			? Object.fromEntries(
 					await Promise.all(
@@ -535,7 +536,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			: undefined;
 		const resolvedEnv = {
 			...buildGjcRuntimeSessionEnv({
-				sessionFile: this.session.getSessionFile(),
+				sessionFile,
 				sessionId: this.session.getSessionId?.(),
 				cwd: this.session.cwd,
 			}),