@iowarp/clio-coder 0.3.8 → 0.3.9

package/src/interactive/overlays/ask-user.ts

@@ -129,6 +129,14 @@ interface QuestionState {
 	customAnswer: string;
 	inputValue: string;
 	answer: string;
+	/**
+	 * The operator's typed text exactly as submitted, empty when they typed
+	 * nothing. `answer` is the one-line rendering of the whole decision and gets
+	 * trimmed and joined; this is the record of what they actually typed, and
+	 * losing it is what made an interview re-ask for the same figures three times
+	 * (issue #228).
+	 */
+	rawValue: string;
 	focusedValue?: string;
 }
 
@@ -154,6 +162,7 @@ function createQuestionState(question: AskUserQuestion): QuestionState {
 		customAnswer: "",
 		inputValue: "",
 		answer: "",
+		rawValue: "",
 	};
 }
 
@@ -205,12 +214,18 @@ function optionIndexFromValue(value: string): number | null {
 	return Number.isInteger(index) && index >= 0 ? index : null;
 }
 
-function answerText(question: AskUserQuestion, selected: ReadonlySet<number>, customAnswer: string): string {
-	const parts: string[] = [];
+/** The labels the operator chose, in list order. */
+function selectedOptionLabels(question: AskUserQuestion, selected: ReadonlySet<number>): string[] {
+	const labels: string[] = [];
 	for (const index of [...selected].sort((a, b) => a - b)) {
 		const label = question.options?.[index]?.label;
-		if (label) parts.push(label);
+		if (label) labels.push(label);
 	}
+	return labels;
+}
+
+function answerText(question: AskUserQuestion, selected: ReadonlySet<number>, customAnswer: string): string {
+	const parts = selectedOptionLabels(question, selected);
 	const custom = customAnswer.trim();
 	if (custom.length > 0) parts.push(custom);
 	return parts.join("; ");
@@ -348,6 +363,10 @@ class AskUserOverlayView implements Component {
 			this.commitMultiSelectOrOpenOther(state);
 			return;
 		}
+		if (this.isAddTextKey(data)) {
+			this.chooseFocusedAndOpenText(question, state);
+			return;
+		}
 		this.list?.handleInput(data);
 	}
 
@@ -502,24 +521,22 @@ class AskUserOverlayView implements Component {
 		// The classified action label distinguishes recording an answer from
 		// granting authority. Esc keeps the product's one word for the way out,
 		// since it closes the prompt and the interview together.
+		// `t` is on every select footer because the operator cannot tell from a
+		// label whether the option needs a figure attached until they read it.
+		const addText: HintEntry = { key: "t", verb: "add text", short: "text" };
 		if (question.multi_select === true) {
 			return this.questions.length > 1
 				? this.withScrollHint([
 						{ key: "Left/Right", verb: "question" },
 						{ key: "Space", verb: "toggle" },
+						addText,
 						{ key: "Enter", verb: recordAnswer },
 					])
-				: this.withScrollHint([
-						{ key: "Space", verb: "toggle" },
-						{ key: "Enter", verb: recordAnswer },
-					]);
+				: this.withScrollHint([{ key: "Space", verb: "toggle" }, addText, { key: "Enter", verb: recordAnswer }]);
 		}
 		return this.questions.length > 1
-			? this.withScrollHint([
-					{ key: "Left/Right", verb: "question" },
-					{ key: "Enter", verb: recordAnswer },
-				])
-			: this.withScrollHint([{ key: "Enter", verb: recordAnswer }]);
+			? this.withScrollHint([{ key: "Left/Right", verb: "question" }, addText, { key: "Enter", verb: recordAnswer }])
+			: this.withScrollHint([addText, { key: "Enter", verb: recordAnswer }]);
 	}
 
 	private renderDecisionContext(width: number): string[] {
@@ -644,6 +661,34 @@ class AskUserOverlayView implements Component {
 		return this.questions.length > 1 && (matchesKey(data, "alt+right") || matchesKey(data, "ctrl+right"));
 	}
 
+	/**
+	 * The key that adds typed text to the option under the cursor.
+	 *
+	 * Choosing an option used to be the whole answer, so a model that offered
+	 * "Exact number - I'll type it" gave the operator a label and nowhere to put
+	 * the number; the interview then spent two of its four rounds asking for the
+	 * figures again (issue #228). The list itself only reads the arrows, Enter,
+	 * and Esc, so a letter is free here.
+	 */
+	private isAddTextKey(data: string): boolean {
+		return matchesKey(data, "t");
+	}
+
+	/**
+	 * Take the focused option and open the text field for it, without committing.
+	 * Submitting the text records the label and the text together.
+	 */
+	private chooseFocusedAndOpenText(question: AskUserQuestion, state: QuestionState): void {
+		const current = this.list?.getSelectedItem();
+		const optionIndex = current && current.value !== "other" ? optionIndexFromValue(current.value) : null;
+		if (optionIndex !== null) {
+			if (question.multi_select === true) state.selected.add(optionIndex);
+			else state.selected = new Set<number>([optionIndex]);
+			state.focusedValue = `option:${optionIndex}`;
+		}
+		this.openTextInput(state.selected.size > 0 ? "Add your answer to the chosen option" : "Other answer");
+	}
+
 	/**
 	 * The row above the question, or nothing.
 	 *
@@ -829,14 +874,20 @@ class AskUserOverlayView implements Component {
 				return;
 			}
 			state.inputValue = answer;
+			// Verbatim, before any joining or trimming the display line does. The
+			// typed text is the answer; the one-line `answer` is a rendering of it.
+			state.rawValue = value;
 			if (questionHasOptions(question) && question.multi_select === true) {
 				state.customAnswer = answer;
 				this.commitCurrentAnswer();
-			} else {
-				state.customAnswer = questionHasOptions(question) ? answer : "";
-				state.answer = answer;
-				this.finishIfCompleteOrAdvance();
+				return;
 			}
+			state.customAnswer = questionHasOptions(question) ? answer : "";
+			// The chosen labels and the typed text compose, so a question answered
+			// with an option that says "I will type it" keeps both. With nothing
+			// selected, which is the implicit Other path, this is the text alone.
+			state.answer = questionHasOptions(question) ? answerText(question, state.selected, state.customAnswer) : answer;
+			this.finishIfCompleteOrAdvance();
 		};
 		activeInput.onEscape = () => this.cancel();
 		this.input = activeInput;
@@ -866,7 +917,14 @@ class AskUserOverlayView implements Component {
 				return;
 			}
 			state.selected = new Set<number>([optionIndex]);
-			state.answer = question.options?.[optionIndex]?.label ?? item.label;
+			// Choosing a plain option is a label-only answer, so the typed text
+			// clears with the choice: it was given for a label the operator has
+			// just moved off, and the composed answer runs through the same
+			// `answerText` every other path uses.
+			state.customAnswer = "";
+			state.rawValue = "";
+			state.inputValue = "";
+			state.answer = answerText(question, state.selected, state.customAnswer) || item.label;
 			state.focusedValue = item.value;
 			this.status = "";
 			this.finishIfCompleteOrAdvance();
@@ -992,12 +1050,26 @@ class AskUserOverlayView implements Component {
 		return this.states.length > 0 && this.states.every((state) => state.answer.trim().length > 0);
 	}
 
+	/**
+	 * What the round captured, as three separable facts per question: the one-line
+	 * answer, the labels chosen, and the text typed. A reader tells a label-only
+	 * answer from a label-plus-value one by whether `value` is there, which the
+	 * joined string alone could never say.
+	 */
 	private answers(): AskUserResult["answers"] {
 		const answers: AskUserResult["answers"] = [];
 		for (let index = 0; index < this.questions.length; index += 1) {
 			const question = this.questions[index];
-			const answer = this.states[index]?.answer.trim();
-			if (question && answer && answer.length > 0) answers.push({ question: question.question, answer });
+			const state = this.states[index];
+			const answer = state?.answer.trim();
+			if (!question || !state || !answer || answer.length === 0) continue;
+			const options = selectedOptionLabels(question, state.selected);
+			answers.push({
+				question: question.question,
+				answer,
+				...(options.length > 0 ? { options } : {}),
+				...(state.rawValue.length > 0 ? { value: state.rawValue } : {}),
+			});
 		}
 		return answers;
 	}

package/src/interactive/overlays/help-reference.ts

@@ -129,6 +129,10 @@ export function openHelpOverlay(
 					"auto-edit parks unrecognized commands, and full-auto runs them.",
 				"**Approvals**: a parked call waits for a one-shot operator decision; approving resumes only that call. " +
 					"Workers resolve asks per `workers.onPermission` (Approvals Routing); headless runs auto-deny.",
+				"**Inspecting a mutation**: a parked `write` or `edit` card carries the target, the byte count, and a `sha256` digest of the exact call arguments. " +
+					"Press `v` to read the complete proposed content, or the complete effective diff against the file on disk, and `v` again to put it away; ↑/↓ and PageUp/PageDown scroll it. " +
+					"Enter still allows, `s` still stops, and Esc still denies while it is open. The mutation text is shown locally and never enters the transcript, a notice, a desktop notification, or the render trace. " +
+					"A worker escalation has no preview because the call's arguments never leave the worker, and its card says so.",
 			],
 		},
 	];

package/src/interactive/overlays/prompts.ts

@@ -22,13 +22,23 @@ export function openPromptsOverlay(tui: TUI, ctx: SlashCommandContext, onClose:
 					lines.push(`**Argument Hint:** \`${template.argumentHint}\``);
 				}
 				lines.push(`**Source:** ${template.sourceInfo.source ?? template.sourceInfo.scope}`);
+				if (template.unavailable !== undefined) {
+					lines.push(`**Unavailable:** ${template.unavailable}`);
+				}
 				if (!template.trusted) {
 					lines.push("**Untrusted:** set `skills.trustProjectCompatRoots` before this template will expand.");
 				}
 				return lines;
 			},
 		};
-		const marker = template.trusted ? undefined : clioTheme().fg("warning", "untrusted");
+		// A template that loaded in a refusing state is listed, because the
+		// operator's command does exist; the marker is what says it will not run.
+		const marker =
+			template.unavailable !== undefined
+				? clioTheme().fg("error", "unavailable")
+				: template.trusted
+					? undefined
+					: clioTheme().fg("warning", "untrusted");
 		if (marker) item.meta = template.argumentHint ? `${template.argumentHint} · ${marker}` : marker;
 		else if (template.argumentHint) item.meta = template.argumentHint;
 		return item;

package/src/interactive/overlays/settings.ts

@@ -9,6 +9,7 @@ import {
 import { DEFAULT_SETTINGS, THINKING_LEVELS } from "../../core/defaults.js";
 import { getAtPath, isRoutingPath } from "../../core/session-routing.js";
 import { MAX_TIMER_DELAY_MS } from "../../core/timers.js";
+import { capacityLeaseUsage } from "../../domains/dispatch/capacity-lease.js";
 import {
 	delegationEntryForKind,
 	type InteropAgentId,
@@ -17,6 +18,8 @@ import {
 } from "../../domains/interop/index.js";
 import {
 	type CapabilityFlags,
+	endpointCapacitiesForStatuses,
+	endpointCapacityForStatus,
 	isDispatchEligibleRuntime,
 	isOrchestratorEligibleRuntime,
 	type ProvidersContract,
@@ -225,7 +228,8 @@ type EntrySettingId =
 	| `workers.profiles.${string}`
 	| `workers.agentBindings.${string}`
 	| `targets.${string}`
-	| `fleet.nodes.${string}`;
+	| `fleet.nodes.${string}`
+	| `fleet.endpoints.${string}`;
 export type EditableSettingId = keyof typeof SETTINGS_LABELS_BY_ID | EntrySettingId;
 type FleetGroupHeaderId = `fleet.group.${"defaults" | "profiles" | "agent-routes" | "placement"}`;
 type TargetsCtaId = "targets.add-cta";
@@ -1482,6 +1486,7 @@ export function buildSettingItems(
 		}),
 		fleetGroupHeader("fleet.group.placement", "Placement"),
 		...fleetNodeRows(options?.getFleetNodes?.() ?? []),
+		...fleetEndpointRows(options?.providers),
 		settingItem("targets", "", {
 			description: "Live inference target inventory and routing roles.",
 			affordance: "column heading",
@@ -1860,6 +1865,35 @@ function fleetNodeRows(nodes: ReadonlyArray<FleetNodeSnapshot>): SettingsCenterI
 	});
 }
 
+/** Read-only endpoint rows show the independent inference scheduler dimension. */
+function fleetEndpointRows(providers: ProvidersContract | undefined): SettingsCenterItem[] {
+	if (providers === undefined) return [];
+	let usage: Readonly<Record<string, number>> = {};
+	try {
+		usage = capacityLeaseUsage().endpoints;
+	} catch {
+		// A damaged capacity file belongs to admission. Settings still shows the configured limits.
+	}
+	const capacities = endpointCapacitiesForStatuses(providers.list());
+	const targetsByEndpoint = new Map<string, string[]>();
+	for (const status of providers.list()) {
+		const endpoint = endpointCapacityForStatus(status);
+		if (endpoint === null) continue;
+		targetsByEndpoint.set(endpoint.key, [...(targetsByEndpoint.get(endpoint.key) ?? []), status.target.id]);
+	}
+	return Object.entries(capacities).map(([key, endpoint]) => {
+		const slots = `slots ${usage[key] ?? 0}/${endpoint.limit}`;
+		return settingItem(`fleet.endpoints.${key}`, slots, {
+			label: `endpoint ${endpoint.label}`,
+			description: `Targets: ${(targetsByEndpoint.get(key) ?? []).join(", ")} · Limit source: ${endpoint.source}`,
+			affordance: "read-only inference endpoint capacity",
+			readOnly: true,
+			presentationKind: "status",
+			valueSegments: [{ text: slots, tone: "neutral" }],
+		});
+	});
+}
+
 export function buildSettingsSections(items: readonly SettingsCenterItem[]): SettingsCenterSection[] {
 	return SETTINGS_SECTIONS.map((section) => ({
 		id: section.id,

package/src/interactive/permission-hint.ts

@@ -1,5 +1,19 @@
 import type { HintEntry } from "./overlay-frame.js";
 
+/**
+ * The key that opens and closes local inspection of a parked mutation. It lives
+ * here rather than beside the preview builder so the composer rail can name it
+ * without pulling the diff machinery into the Stage 0 boot shell closure.
+ */
+export const MUTATION_PREVIEW_KEY = "v";
+
+/**
+ * Whether this card has a mutation to read, and whether it is open.
+ * `none` covers every ask with nothing local to inspect, including a worker
+ * escalation, whose arguments never leave the worker.
+ */
+export type PermissionInspectionHint = "none" | "closed" | "open";
+
 /**
  * The keys that answer a parked call, as data, so the dialog footer and the
  * composer rail render the same policy at any width.
@@ -16,17 +30,35 @@ import type { HintEntry } from "./overlay-frame.js";
  *
  * Esc says `deny`, not `close`: closing the dialog denies the call, and on the
  * one surface where a misread is a wrong decision about a tool call the key
- * names its effect.
+ * names its effect. It keeps that meaning while the mutation is open, so the
+ * inspect key is what puts the mutation away again.
  *
  * With a draft in the composer, Enter is inert (issue #186): the habitual send
  * key must not resolve toward "allow" on a safety rail. The entry then says so
  * and names the key that clears the draft, which the router passes through.
+ *
+ * A parked `write` or `edit` adds the inspect key (issue #254). It is
+ * droppable, and deliberately so: at 40 columns the four entries do not fit,
+ * and the three keys that answer the call outrank the one that reads it. The
+ * key keeps working at every width; the `/help` Autonomy & safety net topic is
+ * where it is documented for the widths that cannot show it.
  */
-export function permissionHintEntries(composerHasDraft = false): HintEntry[] {
+export function permissionHintEntries(
+	composerHasDraft = false,
+	inspection: PermissionInspectionHint = "none",
+): HintEntry[] {
 	return [
 		composerHasDraft
 			? { key: "Backspace", verb: "clear the draft to allow", short: "clear draft", critical: true }
 			: { key: "Enter", verb: "allow once", short: "allow", critical: true },
+		...(inspection === "none"
+			? []
+			: inspection === "open"
+				? [
+						{ key: "↑↓", verb: "scroll", critical: false },
+						{ key: MUTATION_PREVIEW_KEY, verb: "hide mutation", short: "hide", critical: false },
+					]
+				: [{ key: MUTATION_PREVIEW_KEY, verb: "inspect mutation", short: "inspect", critical: false }]),
 		{ key: "s", verb: "stop turn", short: "stop", critical: true },
 		// With a draft, deny and stop are the only immediate answers, so Esc
 		// outranks the narrowing that would otherwise drop it first.

package/src/interactive/permission-overlay.ts

@@ -6,13 +6,21 @@ import {
 	decisionFactsForPermission,
 } from "../domains/safety/decision-presentation.js";
 import type { Component, OverlayOptions, TUI } from "../engine/tui.js";
+import {
+	MUTATION_PREVIEW_VISIBLE_ROWS,
+	type MutationFacts,
+	type MutationInspector,
+	type MutationPreview,
+	mutationFactsLine,
+	mutationPreviewWindow,
+} from "./mutation-preview.js";
 import { fitHintEntries } from "./overlay-frame.js";
-import { permissionHintEntries } from "./permission-hint.js";
+import { MUTATION_PREVIEW_KEY, type PermissionInspectionHint, permissionHintEntries } from "./permission-hint.js";
 import type { ClioToken } from "./theme/index.js";
 
 export { type AskAxis, askAxis } from "../domains/safety/approval-axis.js";
 export { describeCallTarget, sanitizeCallTargetText } from "../domains/safety/call-target.js";
-export { permissionHintEntries } from "./permission-hint.js";
+export { MUTATION_PREVIEW_KEY, type PermissionInspectionHint, permissionHintEntries } from "./permission-hint.js";
 
 export interface ApprovalRequestView {
 	requestId: string;
@@ -34,6 +42,14 @@ export interface ApprovalRequestView {
 	 * when nothing meaningful is derivable.
 	 */
 	target?: string;
+	/**
+	 * Size and digest facts for a parked `write` or `edit`, and nothing else
+	 * about it. The mutation text is deliberately absent: this view is what
+	 * reaches the transcript row, the parked notice, and the approval-state
+	 * event, so anything on it has already left the overlay. The text itself is
+	 * held by the inspector the overlay opener is given (issue #254).
+	 */
+	mutation?: MutationFacts;
 	queueDepth?: number;
 }
 
@@ -79,11 +95,59 @@ export function permissionOverlayPlacement(
 	};
 }
 
-class PermissionOverlayBody implements Component {
-	constructor(private readonly view: ApprovalRequestView) {}
+/**
+ * The overlay body, plus the inspection state the key router drives. The
+ * preview is built on the first toggle rather than per frame, so the file read
+ * and the diff happen once when the operator asks for them.
+ */
+export interface PermissionOverlayBodyHandle extends Component {
+	/** Whether this card has a mutation the operator can read locally. */
+	canInspect(): boolean;
+	isInspecting(): boolean;
+	toggleInspect(): void;
+	scrollInspect(delta: number): void;
+}
+
+class PermissionOverlayBody implements PermissionOverlayBodyHandle {
+	private preview: MutationPreview | null = null;
+	private scroll = 0;
+	private lastLineCount = 0;
+
+	constructor(
+		private readonly view: ApprovalRequestView,
+		private readonly inspect?: MutationInspector,
+	) {}
+
+	canInspect(): boolean {
+		return this.inspect !== undefined;
+	}
+
+	isInspecting(): boolean {
+		return this.preview !== null;
+	}
+
+	toggleInspect(): void {
+		if (this.inspect === undefined) return;
+		if (this.preview !== null) {
+			this.preview = null;
+			this.scroll = 0;
+			return;
+		}
+		this.preview = this.inspect();
+		this.scroll = 0;
+	}
+
+	scrollInspect(delta: number): void {
+		if (this.preview === null) return;
+		const maxScroll = Math.max(0, this.lastLineCount - MUTATION_PREVIEW_VISIBLE_ROWS);
+		this.scroll = Math.max(0, Math.min(this.scroll + delta, maxScroll));
+	}
 
 	render(width: number): string[] {
-		return permissionOverlayLines(this.view, width);
+		if (this.preview === null) return permissionOverlayLines(this.view, width);
+		const rendered = permissionInspectionLines(this.view, this.preview, width, this.scroll);
+		this.lastLineCount = rendered.wrappedLineCount;
+		return rendered.lines;
 	}
 
 	invalidate(): void {}
@@ -167,14 +231,74 @@ export function permissionOverlayTone(view: ApprovalRequestView): ClioToken {
  * three columns the bottom border spends on `─ ` and the trailing space come
  * off the top, which is what `buildResponsiveHint` does for every other frame.
  */
-export function permissionOverlayHint(innerWidth: number, composerHasDraft = false): string {
-	return fitHintEntries(permissionHintEntries(composerHasDraft), innerWidth - 3);
+export function permissionOverlayHint(
+	innerWidth: number,
+	composerHasDraft = false,
+	inspection: PermissionInspectionHint = "none",
+): string {
+	return fitHintEntries(permissionHintEntries(composerHasDraft, inspection), innerWidth - 3);
+}
+
+/** The tools whose parked call mutates a file, so a card without a preview owes the operator a reason. */
+function isFileMutationTool(tool: string): boolean {
+	return tool === "write" || tool === "edit";
 }
 
 function actionConsequence(presentation: DecisionPresentation, id: "deny" | "stop"): string {
 	return presentation.requiredActions.find((action) => action.id === id)?.consequence ?? "";
 }
 
+/**
+ * Hard wrap for mutation text. Prose wraps on words; a proposed file line and a
+ * diff row do not, because the column a character sits in is part of what the
+ * operator is reading. The continuation marker says the row was folded rather
+ * than cut, which is the difference between a wrap and unmarked truncation.
+ */
+function wrapMutationLine(value: string, max: number): string[] {
+	if (max <= 1) return [value];
+	if (value.length <= max) return [value];
+	const lines: string[] = [];
+	let remaining = value;
+	while (remaining.length > max) {
+		lines.push(`${remaining.slice(0, max - 1)}↩`);
+		remaining = remaining.slice(max - 1);
+	}
+	lines.push(remaining);
+	return lines;
+}
+
+/**
+ * The card with the mutation open. The tool, target, and digest facts stay at
+ * the top so the bytes on screen remain tied to the call they belong to, and
+ * the standing safety prose gives way to the mutation itself: the operator
+ * opened this to read what changes, and the keys that answer the ask are on the
+ * footer throughout.
+ */
+function permissionInspectionLines(
+	view: ApprovalRequestView,
+	preview: MutationPreview,
+	width: number,
+	scroll: number,
+): { lines: string[]; wrappedLineCount: number } {
+	const content = Math.max(8, Math.floor(width));
+	const wrapped = preview.body.flatMap((line) => wrapMutationLine(line, content));
+	const pane = mutationPreviewWindow(wrapped, scroll);
+	const notes: string[] = [];
+	if (preview.neutralized) notes.push("control characters shown as ·");
+	if (preview.tabsExpanded) notes.push("tabs shown as spaces");
+	const lines = [
+		field("Tool: ", `${view.tool} · Action: ${view.actionClass}`, content),
+		...(view.target !== undefined && view.target.length > 0 ? [field("Target: ", view.target, content)] : []),
+		...wrapSentence(`Mutation: ${mutationFactsLine(preview.facts)}`, content),
+		"",
+		...wrapSentence(preview.heading, content),
+		...pane.window,
+		...(pane.position === null ? [] : [pane.position]),
+		...(notes.length > 0 ? [`Rendered safely: ${notes.join(", ")}.`] : []),
+	];
+	return { lines, wrappedLineCount: wrapped.length };
+}
+
 /**
  * The overlay's body, laid out for the width the frame gives it.
  *
@@ -193,6 +317,24 @@ export function permissionOverlayLines(view: ApprovalRequestView, width: number)
 	const lines = [
 		field("Tool: ", `${view.tool} · Action: ${view.actionClass}`, content),
 		...(view.target !== undefined && view.target.length > 0 ? [field("Target: ", view.target, content)] : []),
+		// Size and digest stay on the collapsed card whether or not the operator
+		// opens the mutation, so the decision always carries the identity of the
+		// bytes it applies to.
+		// Wrapped, never ellipsized: at 40 columns the digest is the tail of the
+		// line, and ellipsizing it would drop the one fact that ties the decision
+		// to the bytes it applies to.
+		...(view.mutation !== undefined
+			? [
+					...wrapSentence(`Mutation: ${mutationFactsLine(view.mutation)}`, content),
+					...wrapSentence(`Press ${MUTATION_PREVIEW_KEY} to read it before deciding.`, content),
+				]
+			: []),
+		...(view.mutation === undefined && view.origin.kind === "worker" && isFileMutationTool(view.tool)
+			? wrapSentence(
+					"No local preview: this call's arguments stay inside the worker, so you are approving the target above without inspecting the mutation.",
+					content,
+				)
+			: []),
 		...wrapSentence(`Requested by: ${presentation.requestedByCopy}`, content),
 		...(view.artifact !== undefined
 			? [
@@ -215,6 +357,14 @@ export function permissionOverlayLines(view: ApprovalRequestView, width: number)
 	return lines;
 }
 
-export function createPermissionOverlayBody(view: ApprovalRequestView): Component {
-	return new PermissionOverlayBody(view);
+/**
+ * The overlay body for one parked call. The inspector, when present, is the
+ * only path the mutation text takes: it is never placed on `view`, so nothing
+ * that renders or forwards the view can carry the bytes with it.
+ */
+export function createPermissionOverlayBody(
+	view: ApprovalRequestView,
+	inspect?: MutationInspector,
+): PermissionOverlayBodyHandle {
+	return new PermissionOverlayBody(view, inspect);
 }