@gajae-code/coding-agent 0.2.5 → 0.3.1

package/src/task/spawn-gate.ts

@@ -0,0 +1,132 @@
+/** The hard, locked batch threshold enforced by the runtime gate. */
+export const DEFAULT_SPAWN_THRESHOLD = 4;
+
+/** The justification a large batch or reviewer-spawned explorer must supply to pass the hard gate. */
+export interface SpawnPlanReceipt {
+	whyParallel: string;
+	whyNotLocal: string;
+	independence: string;
+	expectedReceiptShape: string;
+	maxInlineTokens: number;
+}
+
+export interface SpawnGateRequest {
+	/** Number of children the batch wants to spawn. */
+	childCount: number;
+	/** The spawn-plan receipt, when provided. */
+	plan?: SpawnPlanReceipt;
+}
+
+export interface ReviewerExploreGateRequest {
+	/** Agent type/name doing the spawning, when known. */
+	spawningAgentType?: string | null;
+	/** Target agent type/name requested by the task call. */
+	targetAgent: string;
+	/** The spawn-plan receipt, when provided. */
+	plan?: SpawnPlanReceipt;
+}
+
+export type SpawnGateOutcome = "allowed" | "rejected";
+
+export interface SpawnGateDecision {
+	outcome: SpawnGateOutcome;
+	/** Human-readable reason, suitable for a blocked-result message. */
+	reason: string;
+	/** Whether a plan was required for this request. */
+	planRequired: boolean;
+	/** Missing plan field names when rejected for an incomplete plan. */
+	missingFields: readonly string[];
+}
+
+const REQUIRED_STRING_FIELDS = ["whyParallel", "whyNotLocal", "independence", "expectedReceiptShape"] as const;
+
+export function findMissingPlanFields(plan: SpawnPlanReceipt | undefined): string[] {
+	if (plan === undefined) {
+		return [...REQUIRED_STRING_FIELDS, "maxInlineTokens"];
+	}
+	const missing: string[] = [];
+	for (const field of REQUIRED_STRING_FIELDS) {
+		const value = plan[field];
+		if (typeof value !== "string" || value.trim().length === 0) {
+			missing.push(field);
+		}
+	}
+	if (
+		typeof plan.maxInlineTokens !== "number" ||
+		!Number.isFinite(plan.maxInlineTokens) ||
+		plan.maxInlineTokens <= 0
+	) {
+		missing.push("maxInlineTokens");
+	}
+	return missing;
+}
+
+export function decide(childCount: number, threshold: number, plan: SpawnPlanReceipt | undefined): SpawnGateDecision {
+	if (!Number.isInteger(childCount) || childCount < 0) {
+		throw new RangeError("childCount must be a non-negative integer");
+	}
+	if (!Number.isInteger(threshold) || threshold < 1) {
+		throw new RangeError("threshold must be a positive integer");
+	}
+
+	const planRequired = childCount > threshold;
+	if (!planRequired) {
+		return {
+			outcome: "allowed",
+			reason: `batch of ${childCount} is at or below threshold ${threshold}`,
+			planRequired: false,
+			missingFields: [],
+		};
+	}
+
+	const missingFields = findMissingPlanFields(plan);
+	if (missingFields.length > 0) {
+		return {
+			outcome: "rejected",
+			reason: `batch of ${childCount} exceeds threshold ${threshold} and the spawn-plan receipt is ${
+				plan === undefined ? "missing" : `incomplete (${missingFields.join(", ")})`
+			}`,
+			planRequired: true,
+			missingFields,
+		};
+	}
+
+	return {
+		outcome: "allowed",
+		reason: `batch of ${childCount} exceeds threshold ${threshold} and a complete spawn-plan receipt was provided`,
+		planRequired: true,
+		missingFields: [],
+	};
+}
+
+export function evaluateSpawnGate(request: SpawnGateRequest): SpawnGateDecision {
+	return decide(request.childCount, DEFAULT_SPAWN_THRESHOLD, request.plan);
+}
+
+export function evaluateReviewerExploreGate(request: ReviewerExploreGateRequest): SpawnGateDecision {
+	if (request.spawningAgentType !== "reviewer" || request.targetAgent !== "explore") {
+		return {
+			outcome: "allowed",
+			reason: "reviewer->explore gate does not apply",
+			planRequired: false,
+			missingFields: [],
+		};
+	}
+
+	const missingFields = findMissingPlanFields(request.plan);
+	if (missingFields.length > 0) {
+		return {
+			outcome: "rejected",
+			reason: `reviewer->explore spawn requires a complete spawn-plan receipt (${missingFields.join(", ")})`,
+			planRequired: true,
+			missingFields,
+		};
+	}
+
+	return {
+		outcome: "allowed",
+		reason: "reviewer->explore spawn has a complete spawn-plan receipt",
+		planRequired: true,
+		missingFields: [],
+	};
+}

package/src/task/types.ts

@@ -2,12 +2,16 @@ import type { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Usage } from "@gajae-code/ai";
 import { $env } from "@gajae-code/utils";
 import * as z from "zod/v4";
+import { isValidTaskId, TASK_ID_DESCRIPTION } from "./id";
+import type { TaskResultReceipt } from "./receipt";
 import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
+import type { SpawnPlanReceipt } from "./spawn-gate";
 import type { NestedRepoPatch } from "./worktree";
 
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
 export type ForkContextPolicy = "forbidden" | "allowed";
+export type ForkContextMode = "none" | "receipt" | "last-turn" | "bounded" | "full";
 
 const parseNumber = (value: string | undefined, defaultValue: number): number => {
 	if (value) {
@@ -53,22 +57,33 @@ export interface SubagentLifecyclePayload {
 	agent: string;
 	agentSource: AgentSource;
 	description?: string;
-	status: "started" | "completed" | "failed" | "aborted";
+	status: "started" | "completed" | "failed" | "aborted" | "paused";
 	sessionFile?: string;
 	index: number;
 }
 
 const assignmentDescription = "per-task instructions; self-contained";
+const spawnPlanSchema = z
+	.object({
+		whyParallel: z.string(),
+		whyNotLocal: z.string(),
+		independence: z.string(),
+		expectedReceiptShape: z.string(),
+		maxInlineTokens: z.number(),
+	})
+	.describe("justification required before spawning more than four tasks or reviewer-spawned explore tasks");
 
 const createTaskItemSchema = (_contextEnabled: boolean) =>
 	z.object({
-		id: z.string().max(48).describe("camelcase identifier"),
+		id: z.string().max(48).refine(isValidTaskId, TASK_ID_DESCRIPTION).describe("filesystem-safe task identifier"),
 		description: z.string().describe("ui label, not seen by subagent"),
 		assignment: z.string().describe(assignmentDescription),
 		inheritContext: z
-			.boolean()
+			.enum(["none", "receipt", "last-turn", "bounded", "full"])
 			.optional()
-			.describe("explicit request to seed a subagent with sanitized parent context"),
+			.describe(
+				"fork-context mode: none/omitted copies no parent context; receipt copies a minimal receipt-sized snapshot; last-turn copies only the latest exchange; bounded copies the bounded default snapshot; full copies a larger sanitized snapshot up to the configured/model token cap",
+			),
 	});
 
 /** Single task item for parallel execution (default shape with context enabled). */
@@ -77,11 +92,23 @@ export type TaskItem = z.infer<typeof taskItemSchema>;
 
 const createTaskSchema = (options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }) => {
 	const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(options.simpleMode);
-	const itemSchema = createTaskItemSchema(contextEnabled);
+	let itemSchema = createTaskItemSchema(contextEnabled);
+	if (!contextEnabled) {
+		itemSchema = itemSchema.superRefine((item, ctx) => {
+			if (item.inheritContext !== undefined && item.inheritContext !== "none") {
+				ctx.addIssue({
+					code: "custom",
+					path: ["inheritContext"],
+					message: "Independent tasks cannot inherit parent context; omit inheritContext or set it to none.",
+				});
+			}
+		});
+	}
 
 	let schema = z.object({
 		agent: z.string().describe("agent type"),
 		tasks: z.array(itemSchema).describe("tasks to execute in parallel"),
+		spawnPlan: spawnPlanSchema.optional(),
 	});
 	if (contextEnabled) {
 		schema = schema.extend({
@@ -139,6 +166,7 @@ export interface TaskParams {
 	agent: string;
 	context?: string;
 	schema?: string;
+	spawnPlan?: SpawnPlanReceipt;
 	tasks: TaskItem[];
 	isolated?: boolean;
 }
@@ -192,7 +220,7 @@ export interface AgentProgress {
 	id: string;
 	agent: string;
 	agentSource: AgentSource;
-	status: "pending" | "running" | "completed" | "failed" | "aborted";
+	status: "pending" | "running" | "completed" | "failed" | "aborted" | "paused";
 	task: string;
 	assignment?: string;
 	description?: string;
@@ -230,6 +258,7 @@ export interface AgentProgress {
 	retryState?: {
 		attempt: number;
 		maxAttempts: number;
+		unbounded?: boolean;
 		delayMs: number;
 		errorMessage: string;
 		startedAtMs: number;
@@ -279,6 +308,7 @@ export interface SingleResult {
 	error?: string;
 	aborted?: boolean;
 	abortReason?: string;
+	paused?: boolean;
 	/** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
 	usage?: Usage;
 	/** Output path for the task result */
@@ -289,6 +319,8 @@ export interface SingleResult {
 	branchName?: string;
 	/** Nested repo patches to apply after parent merge */
 	nestedPatches?: NestedRepoPatch[];
+	/** Whether isolated execution produced a non-empty root or nested patch. */
+	producedChanges?: boolean;
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
 	extractedToolData?: Record<string, unknown[]>;
 	/**
@@ -302,21 +334,83 @@ export interface SingleResult {
 		errorMessage: string;
 	};
 	/** Output metadata for agent:// URL integration */
-	outputMeta?: { lineCount: number; charCount: number };
+	outputMeta?: { lineCount: number; charCount: number; byteSize?: number; sha256?: string };
+	/** Fork-context seed accounting for this subagent, when inherited parent context was cloned. */
+	forkContext?: { mode: ForkContextMode; clonedTokens: number };
 }
 
 /** Tool details for TUI rendering */
 export interface TaskToolDetails {
 	projectAgentsDir: string | null;
-	results: SingleResult[];
+	results: TaskResultReceipt[];
 	totalDurationMs: number;
 	/** Aggregated usage across all subagents. */
 	usage?: Usage;
-	outputPaths?: string[];
+	/** Aggregate cloned tokens copied into fork-context seeds across subagents. */
+	forkContextClonedTokens?: number;
+	roiSummary?: {
+		childCount: number;
+		totalTokens: number;
+		totalCostTotal?: number;
+		totalClonedTokens?: number;
+		/** Advisory ids for terminal children that spent tokens without detectable output/review/changes. */
+		lowRoiChildIds: string[];
+	};
 	progress?: AgentProgress[];
 	async?: {
-		state: "running" | "completed" | "failed";
+		state: "running" | "paused" | "queued" | "completed" | "failed";
 		jobId: string;
 		type: "task";
 	};
 }
+/**
+ * Persisted per-turn / per-subagent token record (Phase 0 instrumentation).
+ *
+ * Additive: this does not alter any existing task result shape. It is the
+ * durable, model-independent unit the deterministic orchestration-token
+ * benchmark (`@gajae-code/orchestration-token-benchmark`) consumes to measure
+ * token efficiency without any live-model calls.
+ */
+export interface TaskTokenLog {
+	/** Subagent id, or "root" for the orchestrator's own turn. */
+	subagentId: string;
+	/** Agent name for attribution, when known. */
+	agent?: string;
+	/** 1-based turn index within the subagent's session. */
+	turn: number;
+	/** ISO-8601 timestamp the turn completed. */
+	at: string;
+	/** Cost-bearing input tokens (excludes cache reads), mirrors `Usage.input`. */
+	input: number;
+	/** Total output tokens for the turn, mirrors `Usage.output`. */
+	output: number;
+	/** Tokens read from the prompt cache, mirrors `Usage.cacheRead`. */
+	cacheRead: number;
+	/** Tokens written to the prompt cache, mirrors `Usage.cacheWrite`. */
+	cacheWrite: number;
+	/** input + output + cacheRead + cacheWrite. */
+	totalTokens: number;
+	/** Latest per-turn context-window occupancy, when known. */
+	contextTokens?: number;
+	/** Estimated USD cost for the turn, when known. */
+	cost?: number;
+	/** Model id used for the turn, when known. */
+	model?: string;
+}
+
+/**
+ * Deterministic aggregate token metrics computed from a set of `TaskTokenLog`
+ * entries. The cache-hit-rate field is the primary prompt-cache signal called
+ * out by the prefix-stability invariant (see the approved plan).
+ */
+export interface TaskTokenMetrics {
+	/** Number of token-log entries aggregated. */
+	turns: number;
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	totalTokens: number;
+	/** cacheRead / (input + cacheRead); 0 when there is no input-class traffic. */
+	cacheHitRate: number;
+}

package/src/tools/ask.ts

@@ -28,6 +28,11 @@ import {
 } from "@gajae-code/tui";
 import { prompt, untilAborted } from "@gajae-code/utils";
 import * as z from "zod/v4";
+import {
+	formatDeepInterviewSelectorPrompt,
+	isDeepInterviewAskQuestion,
+	renderDeepInterviewAskQuestion,
+} from "../deep-interview/render-middleware";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
@@ -84,6 +89,7 @@ export interface AskToolDetails {
 
 const OTHER_OPTION = "Other (type your own)";
 const RECOMMENDED_SUFFIX = " (Recommended)";
+const DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS = Number.MAX_SAFE_INTEGER;
 
 function getDoneOptionLabel(): string {
 	return `${theme.status.success} Done selecting`;
@@ -115,6 +121,17 @@ function stripRecommendedSuffix(label: string): string {
 	return label.endsWith(RECOMMENDED_SUFFIX) ? label.slice(0, -RECOMMENDED_SUFFIX.length) : label;
 }
 
+function formatNumberedOptionLabel(label: string, index: number): string {
+	if (/^\s*\d+[.)]\s+/.test(label)) {
+		return label;
+	}
+	return `${index + 1}. ${label}`;
+}
+
+function numberOptionLabels(labels: string[]): string[] {
+	return labels.map(formatNumberedOptionLabel);
+}
+
 // =============================================================================
 // Question Selection Logic
 // =============================================================================
@@ -138,6 +155,8 @@ interface AskSingleQuestionOptions {
 	signal?: AbortSignal;
 	initialSelection?: Pick<SelectionResult, "selectedOptions" | "customInput">;
 	navigation?: NavigationControls;
+	scrollTitleRows?: number;
+	otherOptionLabel?: string;
 }
 
 interface UIContext {
@@ -150,6 +169,7 @@ interface UIContext {
 			signal?: AbortSignal;
 			outline?: boolean;
 			wrapFocused?: boolean;
+			scrollTitleRows?: number;
 			onTimeout?: () => void;
 			onLeft?: () => void;
 			onRight?: () => void;
@@ -171,7 +191,7 @@ async function askSingleQuestion(
 	multi: boolean,
 	options: AskSingleQuestionOptions = {},
 ): Promise<SelectionResult> {
-	const { recommended, timeout, signal, initialSelection, navigation } = options;
+	const { recommended, timeout, signal, initialSelection, navigation, scrollTitleRows } = options;
 	const doneLabel = getDoneOptionLabel();
 	let selectedOptions = [...(initialSelection?.selectedOptions ?? [])];
 	let customInput = initialSelection?.customInput;
@@ -187,15 +207,18 @@ async function askSingleQuestion(
 			timeoutTriggered = true;
 		};
 		let navigationAction: "back" | "forward" | undefined;
-		const helpText = navigation
+		const baseHelpText = navigation
 			? "up/down navigate  enter select  ←/→ question  esc cancel"
 			: "up/down navigate  enter select  esc cancel";
+		const helpText =
+			scrollTitleRows === undefined ? baseHelpText : `${baseHelpText}  wheel/PgUp/PgDn scroll question`;
 		const dialogOptions = {
 			initialIndex,
 			timeout,
 			signal,
 			outline: true,
 			wrapFocused: true,
+			scrollTitleRows,
 			onTimeout,
 			helpText,
 			onLeft: navigation?.allowBack
@@ -225,6 +248,7 @@ async function askSingleQuestion(
 		const input = signal ? await untilAborted(signal, showCustomInput) : await showCustomInput();
 		return { input };
 	};
+	const otherOptionLabel = options.otherOptionLabel ?? OTHER_OPTION;
 
 	const promptWithProgress = navigation?.progressText ? `${question} (${navigation.progressText})` : question;
 	if (multi) {
@@ -246,7 +270,7 @@ async function askSingleQuestion(
 			if (!navigation?.allowForward && selected.size > 0) {
 				opts.push(doneLabel);
 			}
-			opts.push(OTHER_OPTION);
+			opts.push(otherOptionLabel);
 
 			const prefix = selected.size > 0 ? `(${selected.size} selected) ` : "";
 			const {
@@ -267,7 +291,7 @@ async function askSingleQuestion(
 			}
 			if (choice === doneLabel) break;
 
-			if (choice === OTHER_OPTION) {
+			if (choice === otherOptionLabel) {
 				if (selectTimedOut) {
 					timedOut = true;
 					break;
@@ -309,7 +333,7 @@ async function askSingleQuestion(
 		selectedOptions = Array.from(selected);
 	} else {
 		const displayLabels = addRecommendedSuffix(optionLabels, recommended);
-		const optionsWithNavigation = [...displayLabels, OTHER_OPTION];
+		const optionsWithNavigation = [...displayLabels, otherOptionLabel];
 
 		let initialIndex = recommended;
 		const previouslySelected = selectedOptions[0];
@@ -338,7 +362,7 @@ async function askSingleQuestion(
 			if (!timedOut) {
 				return { selectedOptions, customInput, timedOut, cancelled: true };
 			}
-		} else if (choice === OTHER_OPTION) {
+		} else if (choice === otherOptionLabel) {
 			if (!selectTimedOut) {
 				const customResult = await promptForCustomInput();
 				if (customResult.input !== undefined) {
@@ -452,22 +476,46 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 			q: AskParams["questions"][number],
 			options?: { previous?: QuestionResult; navigation?: NavigationControls },
 		) => {
-			const optionLabels = q.options.map(o => o.label);
+			const rawOptionLabels = q.options.map(o => o.label);
 			try {
-				const { selectedOptions, customInput, navigation, cancelled, timedOut } = await askSingleQuestion(
-					ui,
-					q.question,
-					optionLabels,
-					q.multi ?? false,
-					{
-						recommended: q.recommended,
-						timeout: timeout ?? undefined,
-						signal,
-						initialSelection: options?.previous,
-						navigation: options?.navigation,
-					},
-				);
-				return { optionLabels, selectedOptions, customInput, navigation, cancelled, timedOut };
+				const deepInterviewPrompt = formatDeepInterviewSelectorPrompt(q.question);
+				const displayQuestion = deepInterviewPrompt ?? q.question;
+				const shouldNumberOptions = isDeepInterviewAskQuestion(q.question);
+				const optionLabels = shouldNumberOptions ? numberOptionLabels(rawOptionLabels) : rawOptionLabels;
+				const initialSelection =
+					shouldNumberOptions && options?.previous
+						? {
+								...options.previous,
+								selectedOptions: options.previous.selectedOptions.map(selected => {
+									const rawIndex = rawOptionLabels.indexOf(selected);
+									return rawIndex >= 0 ? (optionLabels[rawIndex] ?? selected) : selected;
+								}),
+							}
+						: options?.previous;
+				const {
+					selectedOptions: displaySelectedOptions,
+					customInput,
+					navigation,
+					cancelled,
+					timedOut,
+				} = await askSingleQuestion(ui, displayQuestion, optionLabels, q.multi ?? false, {
+					recommended: q.recommended,
+					timeout: timeout ?? undefined,
+					signal,
+					initialSelection,
+					navigation: options?.navigation,
+					scrollTitleRows: deepInterviewPrompt === null ? undefined : DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS,
+					otherOptionLabel: shouldNumberOptions
+						? formatNumberedOptionLabel(OTHER_OPTION, optionLabels.length)
+						: undefined,
+				});
+				const selectedOptions = shouldNumberOptions
+					? displaySelectedOptions.map(selected => {
+							const displayIndex = optionLabels.indexOf(selected);
+							return displayIndex >= 0 ? (rawOptionLabels[displayIndex] ?? selected) : selected;
+						})
+					: displaySelectedOptions;
+				return { optionLabels: rawOptionLabels, selectedOptions, customInput, navigation, cancelled, timedOut };
 			} catch (error) {
 				if (error instanceof Error && error.name === "AbortError") {
 					throw new ToolAbortError("Ask input was cancelled");
@@ -659,14 +707,17 @@ export const askToolRenderer = {
 				container.addChild(
 					new Text(` ${uiTheme.fg("dim", qBranch)} ${uiTheme.fg("dim", `[${q.id}]`)}${metaStr}`, 0, 0),
 				);
-				container.addChild(new Markdown(q.question, 3, 0, mdTheme, accentStyle));
+				const deepInterviewQuestion = renderDeepInterviewAskQuestion(q.question, uiTheme);
+				container.addChild(deepInterviewQuestion ?? new Markdown(q.question, 3, 0, mdTheme, accentStyle));
 
 				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));
+						const shouldNumberOption = deepInterviewQuestion !== null || isDeepInterviewAskQuestion(q.question);
+						const displayLabel = shouldNumberOption ? formatNumberedOptionLabel(opt.label, j) : opt.label;
+						const optLabel = renderInlineMarkdown(displayLabel, mdTheme, t => uiTheme.fg("muted", t));
 						return {
 							prefix: ` ${uiTheme.fg("dim", continuation)}   ${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} `,
 							label: optLabel,
@@ -682,20 +733,24 @@ export const askToolRenderer = {
 		if (!args.question) {
 			return new Text(formatErrorMessage("No question provided", uiTheme), 0, 0);
 		}
+		const question = args.question;
 
 		const container = new Container();
 		const meta: string[] = [];
 		if (args.multi) meta.push("multi");
 		if (args.options?.length) meta.push(`options:${args.options.length}`);
 		container.addChild(new Text(`${label}${formatMeta(meta, uiTheme)}`, 0, 0));
-		container.addChild(new Markdown(args.question, 1, 0, mdTheme, accentStyle));
+		const deepInterviewQuestion = renderDeepInterviewAskQuestion(question, uiTheme);
+		container.addChild(deepInterviewQuestion ?? new Markdown(question, 1, 0, mdTheme, accentStyle));
 
 		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));
+				const shouldNumberOption = deepInterviewQuestion !== null || isDeepInterviewAskQuestion(question);
+				const displayLabel = shouldNumberOption ? formatNumberedOptionLabel(opt.label, i) : opt.label;
+				const optLabel = renderInlineMarkdown(displayLabel, mdTheme, t => uiTheme.fg("muted", t));
 				return {
 					prefix: ` ${uiTheme.fg("dim", branch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} `,
 					label: optLabel,
@@ -752,7 +807,10 @@ export const askToolRenderer = {
 				container.addChild(
 					new Text(` ${uiTheme.fg("dim", branch)} ${statusIcon} ${uiTheme.fg("dim", `[${r.id}]`)}`, 0, 0),
 				);
-				container.addChild(new Markdown(r.question, 3, 0, mdTheme, accentStyle));
+				container.addChild(
+					renderDeepInterviewAskQuestion(r.question, uiTheme) ??
+						new Markdown(r.question, 3, 0, mdTheme, accentStyle),
+				);
 
 				const answerLines: string[] = [];
 				for (let j = 0; j < r.selectedOptions.length; j++) {
@@ -795,7 +853,10 @@ export const askToolRenderer = {
 		const header = renderStatusLine({ icon: hasSelection ? "success" : "warning", title: "Ask" }, uiTheme);
 		const container = new Container();
 		container.addChild(new Text(header, 0, 0));
-		container.addChild(new Markdown(details.question, 1, 0, mdTheme, accentStyle));
+		container.addChild(
+			renderDeepInterviewAskQuestion(details.question, uiTheme) ??
+				new Markdown(details.question, 1, 0, mdTheme, accentStyle),
+		);
 
 		const answerLines: string[] = [];
 		if (details.selectedOptions && details.selectedOptions.length > 0) {

package/src/tools/ast-edit.ts

@@ -204,6 +204,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			const scope = await resolveToolSearchScope({
 				rawPaths: params.paths,
 				cwd: this.session.cwd,
+				getArtifactsDir: this.session.getArtifactsDir,
 				internalUrlAction: "rewrite",
 			});
 			const { searchPath: resolvedSearchPath, scopePath, isDirectory, multiTargets, globFilter } = scope;

package/src/tools/ast-grep.ts

@@ -151,6 +151,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 			const scope = await resolveToolSearchScope({
 				rawPaths: params.paths,
 				cwd: this.session.cwd,
+				getArtifactsDir: this.session.getArtifactsDir,
 				internalUrlAction: "search",
 			});
 			const { searchPath: resolvedSearchPath, scopePath, isDirectory, multiTargets, globFilter } = scope;

package/src/tools/bash.ts

@@ -693,7 +693,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					throw error instanceof Error ? error : new Error(String(error));
 				}
 			},
-			{ ownerId },
+			{ ownerId, metadata: { monitor: true } },
 		);
 		currentJobId = jobId;
 		return { jobId, label, commandCwd: prepared.commandCwd };