@iowarp/clio-coder 0.3.3 → 0.3.6

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

@@ -1,3 +1,8 @@
+import {
+	classifyDecisionPresentation,
+	type DecisionPresentation,
+	decisionFactsForAnswer,
+} from "../../domains/safety/decision-presentation.js";
 import {
 	type Component,
 	Input,
@@ -18,16 +23,14 @@ import { type ClioToken, clioTheme, dotSep, GLYPH, screenTitle } from "../theme/
 import { nextContentScrollOffset, type ViewScrollAction } from "../view/view-overlay.js";
 
 /**
- * The border and title token while a decision is pending.
- *
- * Orange is the token that means Clio is acting, and a prompt holding the
- * keyboard is the moment the operator has to act with it. Everything
- * informational keeps the teal frame, so the one border that is not teal is the
- * one asking for an answer. All three surfaces carry it: what changes between
- * them is the size and the place, never the signal.
+ * The default title and border token for a local conversational answer.
+ * Outward and other consequence tiers replace both values with their typed
+ * presentation. All ask_user surfaces carry the same classified signal.
  */
-export const ASK_USER_DECISION_TONE: ClioToken = "action";
-export const ASK_USER_DECISION_TITLE = "Decision required";
+const DEFAULT_ASK_USER_PRESENTATION = classifyDecisionPresentation(decisionFactsForAnswer("local"));
+
+export const ASK_USER_DECISION_TONE: ClioToken = DEFAULT_ASK_USER_PRESENTATION.semanticToken;
+export const ASK_USER_DECISION_TITLE = DEFAULT_ASK_USER_PRESENTATION.title;
 export const ASK_USER_WAITING_TITLE = "Ask User";
 
 /**
@@ -73,7 +76,7 @@ interface AskUserSurfaceGeometry {
  * `ASK_USER_FRAME_AND_MARGIN_ROWS` counts alongside the two border rows.
  */
 export const ASK_USER_SURFACE_GEOMETRY: Record<AskUserSurface, AskUserSurfaceGeometry> = {
-	compact: { width: 68, maxInnerRows: 10, anchor: "bottom-center", margin: { top: 1, right: 2, bottom: 1, left: 2 } },
+	compact: { width: 68, maxInnerRows: 14, anchor: "bottom-center", margin: { top: 1, right: 2, bottom: 1, left: 2 } },
 	panel: { width: 88, maxInnerRows: 18, anchor: "center", margin: 1 },
 	// The interview is a workspace, not a modal. A cap of 42 turned a 66-row
 	// terminal into a centered box with twenty blank rows around it, so the
@@ -111,7 +114,7 @@ export interface OpenAskUserOverlayDeps {
 }
 
 export interface AskUserOverlaySession extends OverlayHandle {
-	ask(questions: ReadonlyArray<AskUserQuestion>): Promise<AskUserResult>;
+	ask(questions: ReadonlyArray<AskUserQuestion>, presentation?: DecisionPresentation): Promise<AskUserResult>;
 	cancel(): void;
 	close(): void;
 	isWaiting(): boolean;
@@ -242,16 +245,21 @@ class AskUserOverlayView implements Component {
 	private contentRegionHeight = 1;
 	/** Rows the scroll region wanted on the last render. */
 	private contentTotalRows = 0;
+	private presentation: DecisionPresentation = DEFAULT_ASK_USER_PRESENTATION;
 
 	constructor(private readonly deps: AskUserOverlayViewDeps) {}
 
-	begin(questions: ReadonlyArray<AskUserQuestion>): Promise<AskUserResult> {
+	begin(
+		questions: ReadonlyArray<AskUserQuestion>,
+		presentation: DecisionPresentation = DEFAULT_ASK_USER_PRESENTATION,
+	): Promise<AskUserResult> {
 		if (this.phase === "closed") return Promise.resolve(cancelledAskUserResult());
 		if (this.resolveCurrent) return Promise.resolve(cancelledAskUserResult());
 		this.phase = "asking";
 		this.index = 0;
 		this.status = "";
 		this.questions = [...questions];
+		this.presentation = presentation;
 		this.states = this.questions.map((question) => createQuestionState(question));
 		this.list = null;
 		this.input = null;
@@ -288,6 +296,14 @@ class AskUserOverlayView implements Component {
 		return this.surface;
 	}
 
+	decisionTitle(): string {
+		return this.presentation.title;
+	}
+
+	decisionTone(): ClioToken {
+		return this.presentation.semanticToken;
+	}
+
 	invalidate(): void {
 		this.list?.invalidate();
 		this.input?.invalidate();
@@ -358,10 +374,17 @@ class AskUserOverlayView implements Component {
 		const statusLines = this.status.length > 0 ? ["", fitLine(clioTheme().fg("dim", this.status), safeWidth)] : [];
 		const headerLine = this.renderQuestionHeader(question, safeWidth);
 		const headerLines = headerLine.length > 0 ? [headerLine] : [];
-		const spent = headerLines.length + statusLines.length + 1 + controlLines.length;
-		const questionLines = wrapTextWithAnsi(question.question, safeWidth).slice(0, Math.max(1, maxRows - spent));
-
-		return [...headerLines, ...questionLines, ...statusLines, "", ...controlLines].slice(0, maxRows);
+		const bottom = [...statusLines, "", ...controlLines];
+		const topBudget = Math.max(1, maxRows - bottom.length);
+		const contextLines = this.renderDecisionContext(safeWidth);
+		const top = [
+			contextLines[0] ?? "",
+			...headerLines,
+			...wrapTextWithAnsi(question.question, safeWidth),
+			...contextLines.slice(1),
+		].slice(0, topBudget);
+
+		return [...top, ...bottom].slice(0, maxRows);
 	}
 
 	/**
@@ -380,7 +403,12 @@ class AskUserOverlayView implements Component {
 		const headerLine = this.renderQuestionHeader(question, width);
 		const headerLines = headerLine.length > 0 ? [headerLine] : [];
 		const stripLines = [this.renderQuestionStrip(width), ""];
-		const content = [...wrapTextWithAnsi(question.question, width), ...this.renderAnswerLedger(width)];
+		const content = [
+			...wrapTextWithAnsi(question.question, width),
+			"",
+			...this.renderDecisionContext(width),
+			...this.renderAnswerLedger(width),
+		];
 
 		// Chrome sheds from the outside in when the terminal is too short to carry
 		// all of it: the round strip first, then the header, then the status, and
@@ -460,36 +488,52 @@ class AskUserOverlayView implements Component {
 		const question = this.currentQuestion();
 		const state = this.currentState();
 		if (!question || !state) return buildHint([]);
+		const recordAnswer =
+			this.presentation.requiredActions.find((action) => action.id === "record-answer")?.label.toLowerCase() ??
+			"record answer";
 		if (state.mode === "text") {
 			return this.questions.length > 1
 				? this.withScrollHint([
-						{ key: "Enter", verb: "submit" },
+						{ key: "Enter", verb: recordAnswer },
 						{ key: "Alt+Left/Right", verb: "question" },
 					])
-				: this.withScrollHint([{ key: "Enter", verb: "submit" }]);
+				: this.withScrollHint([{ key: "Enter", verb: recordAnswer }]);
 		}
-		// `accept` rather than `select` or `commit`: the footer of a decision prompt
-		// has one job, which is to name the key that answers it. Esc keeps the
-		// product's one word for the way out, since it closes the prompt and the
-		// interview together.
+		// 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.
 		if (question.multi_select === true) {
 			return this.questions.length > 1
 				? this.withScrollHint([
 						{ key: "Left/Right", verb: "question" },
 						{ key: "Space", verb: "toggle" },
-						{ key: "Enter", verb: "accept" },
+						{ key: "Enter", verb: recordAnswer },
 					])
 				: this.withScrollHint([
 						{ key: "Space", verb: "toggle" },
-						{ key: "Enter", verb: "accept" },
+						{ key: "Enter", verb: recordAnswer },
 					]);
 		}
 		return this.questions.length > 1
 			? this.withScrollHint([
 					{ key: "Left/Right", verb: "question" },
-					{ key: "Enter", verb: "accept" },
+					{ key: "Enter", verb: recordAnswer },
 				])
-			: this.withScrollHint([{ key: "Enter", verb: "accept" }]);
+			: this.withScrollHint([{ key: "Enter", verb: recordAnswer }]);
+	}
+
+	private renderDecisionContext(width: number): string[] {
+		const theme = clioTheme();
+		const tier = theme.style(this.presentation.semanticToken, this.presentation.tierLabel, { bold: true });
+		const requested = theme.fg("dim", `requested by ${this.presentation.requestedByCopy}`);
+		const effect = `${theme.fg("dim", "Effect:")} ${theme.fg("muted", this.presentation.authorizationCopy)}`;
+		return [
+			fitLine(`${tier}${dotSep(theme)}${requested}`, width),
+			...wrapTextWithAnsi(effect, width).map((line) => fitLine(line, width)),
+			...wrapTextWithAnsi(theme.fg("muted", this.presentation.reversibilityCopy), width).map((line) =>
+				fitLine(line, width),
+			),
+		];
 	}
 
 	/**
@@ -1012,8 +1056,8 @@ export function openAskUserOverlay(tui: TUI, deps: OpenAskUserOverlayDeps): AskU
 			// the terminal has left after the margins.
 			...(geometry.maxInnerRows > 0 ? { maxHeight: geometry.maxInnerRows + ASK_USER_FRAME_ROWS } : {}),
 			margin: geometry.margin,
-			title: () => (view.isDecisionPending() ? ASK_USER_DECISION_TITLE : ASK_USER_WAITING_TITLE),
-			tone: () => (view.isDecisionPending() ? ASK_USER_DECISION_TONE : undefined),
+			title: () => (view.isDecisionPending() ? view.decisionTitle() : ASK_USER_WAITING_TITLE),
+			tone: () => (view.isDecisionPending() ? view.decisionTone() : undefined),
 			footerHint: () => view.footerHint(),
 		});
 		mounted = surface;
@@ -1034,7 +1078,7 @@ export function openAskUserOverlay(tui: TUI, deps: OpenAskUserOverlayDeps): AskU
 		focus: () => handle?.focus(),
 		unfocus: (options) => (options ? handle?.unfocus(options) : handle?.unfocus()),
 		isFocused: () => handle?.isFocused() ?? false,
-		ask: (questions) => view.begin(questions),
+		ask: (questions, presentation) => view.begin(questions, presentation),
 		cancel: () => view.cancel(),
 		close,
 		hide: close,

package/src/interactive/overlays/decisions.ts

@@ -1,3 +1,4 @@
+import { classifyDecisionPresentation, decisionFactsForAnswer } from "../../domains/safety/decision-presentation.js";
 import type { DecisionLedgerEntry, DecisionRecord } from "../../domains/session/entries.js";
 import {
 	type Component,
@@ -73,10 +74,11 @@ function selectableRows(interviews: ReadonlyArray<DecisionLedgerEntry>): Selecta
 
 function interviewHeader(interview: DecisionLedgerEntry, width: number, now: number): string[] {
 	const theme = clioTheme();
+	const presentation = classifyDecisionPresentation(decisionFactsForAnswer(interview.exposure ?? "local"));
 	const rounds = `${interview.roundCount} round${interview.roundCount === 1 ? "" : "s"}`;
 	const status =
 		interview.interviewStatus === "complete" ? theme.fg("success", "complete") : theme.fg("warning", "cancelled");
-	const heading = `${theme.fg("accent", relativeTime(interview.endedAt, now))}${theme.fg("dim", " · ")}${theme.fg("muted", rounds)}${theme.fg("dim", " · ")}${status}`;
+	const heading = `${theme.style(presentation.semanticToken, presentation.tierLabel, { bold: true })}${theme.fg("dim", " · ")}${theme.fg("accent", relativeTime(interview.endedAt, now))}${theme.fg("dim", " · ")}${theme.fg("muted", rounds)}${theme.fg("dim", " · ")}${status}`;
 	const lines = [fitLine(heading, width)];
 	if (interview.summary) {
 		lines.push(...wrapTextWithAnsi(theme.fg("dim", interview.summary), width).map((line) => fitLine(line, width)));

package/src/interactive/permission-hint.ts

@@ -0,0 +1,35 @@
+import type { HintEntry } from "./overlay-frame.js";
+
+/**
+ * The keys that answer a parked call, as data, so the dialog footer and the
+ * composer rail render the same policy at any width.
+ *
+ * This is its own leaf because the composer is part of the Stage 0 boot shell
+ * and the permission overlay is not: importing the overlay from the editor
+ * pulled the safety domain's approval modules into the instant-shell closure.
+ *
+ * At 40 columns the old positional elider removed `[s] stop turn` and left
+ * "allow once" and an ambiguous "close" in front of an operator trying to
+ * refuse. The key kept working, so the layout was hiding a live safety action.
+ * Allow and stop are marked critical, Esc is marked droppable, and
+ * `fitHintEntries` shortens every label before it drops anything.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export function permissionHintEntries(composerHasDraft = false): 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 },
+		{ 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.
+		{ key: "Esc", verb: "deny", critical: composerHasDraft },
+	];
+}

package/src/interactive/permission-overlay.ts

@@ -1,25 +1,37 @@
-import type { Component } from "../engine/tui.js";
-import { buildResponsiveHint } from "./overlay-frame.js";
+import type { ActionClass } from "../domains/safety/action-classifier.js";
+import type { AutonomyExposure } from "../domains/safety/autonomy.js";
+import {
+	classifyDecisionPresentation,
+	type DecisionPresentation,
+	decisionFactsForPermission,
+} from "../domains/safety/decision-presentation.js";
+import type { Component, OverlayOptions, TUI } from "../engine/tui.js";
+import { fitHintEntries } from "./overlay-frame.js";
+import { 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 interface ApprovalRequestView {
 	requestId: string;
 	tool: string;
-	actionClass: string;
+	actionClass: ActionClass;
 	axis: { kind: "net"; ruleId: string } | { kind: "autonomy"; level: string };
 	origin: { kind: "main" } | { kind: "worker"; agentId: string; runId: string };
+	/** Admission-normalized exposure. Caller prose never supplies presentation fields. */
+	exposure?: AutonomyExposure;
 	reason: string;
 	/** Typed, sanitized multi-line artifact that this one approval authorizes. */
 	artifact?: { kind: "dispatch-plan"; text: string };
 	/**
-	 * One-line preview of the call's object: the command for bash, the path
-	 * for file tools, else a compact args preview. The operator is deciding
-	 * whether to allow this exact call, so the overlay must show what the
-	 * call will touch, not just the tool name. Main-agent asks derive it from
-	 * the parked call's args; worker escalations carry it in the escalation
-	 * payload. Absent only when nothing meaningful is derivable.
+	 * One-line preview of the call's allowlisted object fields. The operator is
+	 * deciding whether to allow this exact call, so the overlay must show what
+	 * the call will touch, not just the tool name. Unlisted fields appear only as
+	 * type-and-size summaries. Main-agent asks derive it from the parked call's
+	 * args; worker escalations carry it in the escalation payload. Absent only
+	 * when nothing meaningful is derivable.
 	 */
 	target?: string;
 	queueDepth?: number;
@@ -29,6 +41,44 @@ const PERMISSION_OVERLAY_CONTENT_WIDTH = 78;
 
 export const PERMISSION_OVERLAY_WIDTH = PERMISSION_OVERLAY_CONTENT_WIDTH + 4;
 
+/**
+ * Place a permission frame immediately above the live composer in both TUI
+ * modes. The editor grows with wrapped and multiline drafts, while the footer
+ * can add notice rows, so their rendered heights are the bottom dock rather
+ * than a fixed clearance. Regular mode preserves terminal scrollback and may
+ * leave that dock above the viewport bottom when the transcript is short.
+ * Recompute its viewport row on every frame so draft changes and terminal
+ * resizes move the dialog with the composer.
+ */
+export function permissionOverlayPlacement(
+	tui: Pick<TUI, "mode" | "render">,
+	editor: Pick<Component, "render">,
+	footer: Pick<Component, "render">,
+): OverlayOptions {
+	const margin = { bottom: 0 };
+	return {
+		anchor: "bottom-center",
+		margin,
+		visible: (termWidth, termHeight) => {
+			const dockHeight = editor.render(termWidth).length + footer.render(termWidth).length;
+			if (tui.mode === "fullscreen") {
+				margin.bottom = dockHeight;
+				return true;
+			}
+
+			const baseHeight = tui.render(termWidth).length;
+			const composerTop = Math.max(0, baseHeight - dockHeight);
+			const viewportStart = Math.max(0, baseHeight - termHeight);
+			const composerViewportRow = composerTop - viewportStart;
+			margin.bottom =
+				composerViewportRow >= 0 && composerViewportRow < termHeight
+					? Math.max(0, termHeight - composerViewportRow)
+					: dockHeight;
+			return true;
+		},
+	};
+}
+
 class PermissionOverlayBody implements Component {
 	constructor(private readonly view: ApprovalRequestView) {}
 
@@ -89,46 +139,41 @@ function wrapArtifactLine(value: string, max: number): string[] {
 	return lines;
 }
 
-function axisLabel(axis: ApprovalRequestView["axis"], style: ApprovalRequestView["origin"]["kind"]): string {
-	if (axis.kind === "net") return `safety-net rail ${axis.ruleId}`;
-	return style === "worker" ? `autonomy level ${axis.level}` : `autonomy level (${axis.level})`;
+export function permissionDecisionPresentation(view: ApprovalRequestView): DecisionPresentation {
+	return classifyDecisionPresentation(
+		decisionFactsForPermission({
+			tool: view.tool,
+			actionClass: view.actionClass,
+			axis:
+				view.axis.kind === "net"
+					? { kind: "safety-net", ruleId: view.axis.ruleId }
+					: { kind: "autonomy", level: view.axis.level },
+			origin: view.origin,
+			...(view.exposure !== undefined ? { exposure: view.exposure } : {}),
+		}),
+	);
 }
 
-function askedBy(view: ApprovalRequestView): string {
-	if (view.origin.kind === "worker") {
-		return `worker ${view.origin.agentId} (run ${view.origin.runId}), ${axisLabel(view.axis, "worker")}`;
-	}
-	return axisLabel(view.axis, "main");
+export function permissionOverlayTitle(view: ApprovalRequestView): string {
+	return permissionDecisionPresentation(view).title;
 }
 
-export function permissionOverlayTitle(): string {
-	return "Allow this action once?";
+export function permissionOverlayTone(view: ApprovalRequestView): ClioToken {
+	return permissionDecisionPresentation(view).semanticToken;
 }
 
 /**
- * The footer for a box `innerWidth` columns wide inside its borders.
- *
- * At 40 columns the old positional elider removed `[s] stop turn` and left
- * "allow once" and an ambiguous "close" in front of an operator trying to
- * refuse. The key kept working, so the layout was hiding a live safety action.
- * This surface used to answer that with three hand-written width tiers; it now
- * states the same policy as data. Allow and stop are marked critical, Esc is
- * marked droppable, and `fitHintEntries` shortens every label before it drops
- * anything, which reproduces the three tiers exactly.
+ * The footer for a box `innerWidth` columns wide inside its borders. The
+ * 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 const permissionOverlayHint = buildResponsiveHint(
-	[
-		{ key: "Enter", verb: "allow once", short: "allow", critical: true },
-		{ key: "s", verb: "stop turn", short: "stop", critical: true },
-	],
-	{ key: "Esc", verb: "close", critical: false },
-);
-
-const SAFETY_SENTENCES: ReadonlyArray<string> = [
-	"Parked until you decide; allow or deny applies to this call only.",
-	"Stopping the turn denies it and ends the run, so nothing asks again.",
-	"Hard-blocked actions remain blocked.",
-];
+export function permissionOverlayHint(innerWidth: number, composerHasDraft = false): string {
+	return fitHintEntries(permissionHintEntries(composerHasDraft), innerWidth - 3);
+}
+
+function actionConsequence(presentation: DecisionPresentation, id: "deny" | "stop"): string {
+	return presentation.requiredActions.find((action) => action.id === id)?.consequence ?? "";
+}
 
 /**
  * The overlay's body, laid out for the width the frame gives it.
@@ -140,15 +185,15 @@ const SAFETY_SENTENCES: ReadonlyArray<string> = [
  */
 export function permissionOverlayLines(view: ApprovalRequestView, width: number): string[] {
 	const content = Math.max(8, Math.floor(width));
+	const presentation = permissionDecisionPresentation(view);
 	// The parked call is awaiting a decision, not blocked: the raw rejection
 	// short ("<tool> blocked: <class>") is never rendered here because its
 	// wording contradicts the ask. Tool, Target, Action, and the asking axis
 	// carry everything the operator needs to decide.
 	const lines = [
-		field("Tool: ", view.tool, content),
+		field("Tool: ", `${view.tool} · Action: ${view.actionClass}`, content),
 		...(view.target !== undefined && view.target.length > 0 ? [field("Target: ", view.target, content)] : []),
-		field("Action: ", view.actionClass, content),
-		field("Asked by: ", askedBy(view), content),
+		...wrapSentence(`Requested by: ${presentation.requestedByCopy}`, content),
 		...(view.artifact !== undefined
 			? [
 					"",
@@ -157,7 +202,12 @@ export function permissionOverlayLines(view: ApprovalRequestView, width: number)
 				]
 			: []),
 		"",
-		...SAFETY_SENTENCES.flatMap((sentence) => wrapSentence(sentence, content)),
+		...wrapSentence(`Approval: ${presentation.authorizationCopy}`, content),
+		...wrapSentence(`Consequence: ${presentation.consequenceCopy}`, content),
+		...wrapSentence(presentation.reversibilityCopy, content),
+		...wrapSentence(`Deny: ${actionConsequence(presentation, "deny")}`, content),
+		...wrapSentence(`Stop: ${actionConsequence(presentation, "stop")}`, content),
+		...wrapSentence("Hard-blocked actions remain blocked.", content),
 	];
 	if (view.queueDepth !== undefined && view.queueDepth > 1) {
 		lines.splice(lines.indexOf(""), 0, `1 of ${view.queueDepth} parked`);

package/src/interactive/renderers/tool-execution.ts

@@ -13,15 +13,20 @@
  */
 
 import { sanitizeCallTargetText } from "../../domains/safety/call-target.js";
+import { redactSecretString, redactToolArgs } from "../../domains/safety/redaction.js";
 import { formatSize } from "../../engine/truncate.js";
 import { visibleWidth, wrapTextWithAnsi } from "../../engine/tui.js";
 import { classifyResourceRead, toolPresentationPolicy } from "../../tools/presentation.js";
+import { toolResultPresentationPolicy, toolResultPresentationText } from "../../tools/result-disposition.js";
 import type { ApprovalRequestView } from "../permission-overlay.js";
 import { clioTheme, formatCompactMs, GLYPH } from "../theme/index.js";
 import { renderDiffLines } from "./diff.js";
 import { tryRenderJson, tryRenderXml } from "./structured.js";
 
-export { classifyResourceRead };
+// The argument projection lives in the safety domain so the worker tool seam
+// scrubs by the same rules; re-exported here because this renderer is where
+// callers and tests have always reached for it.
+export { classifyResourceRead, redactToolArgs };
 
 const theme = clioTheme();
 const dim = (text: string): string => theme.fg("dim", text);
@@ -81,6 +86,13 @@ export interface ToolExecutionFinished {
 	 * model reading the same transcript, to guess at the rule.
 	 */
 	blockReason?: string | undefined;
+	/**
+	 * Working-set eviction reason, when the projection has replaced this
+	 * result's body for the model. The transcript still renders the full body:
+	 * the ledger is what the operator scrolls, the projection is only what the
+	 * next request carries. The tag says the two now differ here.
+	 */
+	evictedReason?: string | undefined;
 	/** Structured exit status when the caller has one; text parsing is legacy fallback only. */
 	exitCode?: number | string | null | undefined;
 	/** Local `!!` bash output is visible to the operator but excluded from model context. */
@@ -119,52 +131,6 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-const SECRET_KEY_RE =
-	/(?:api[-_]?key|access[-_]?key|auth(?:orization)?|credential|password|private[-_]?key|secret|token)/iu;
-const ENV_KEY_RE = /^env(?:ironment)?$/iu;
-const SECRET_STRING_RE = /(https?:\/\/[^\s/@]+:)[^\s/@]+@/giu;
-const SECRET_URL_PARAM_RE =
-	/([?&](?:api[-_]?key|access[-_]?token|auth(?:orization)?|credential|password|secret|token)[^=\s]*=)[^&#\s]+/giu;
-const SECRET_ASSIGNMENT_RE =
-	/(?<![A-Z0-9_])((?:[A-Z0-9_]*(?:ACCESS|API|AUTH|CREDENTIAL|KEY|PASS(?:WORD)?|PRIVATE|SECRET|TOKEN)[A-Z0-9_]*)=)[^\s;&|]+/giu;
-const SECRET_FLAG_RE =
-	/(--?(?:[a-z0-9-]*(?:api[-_]?key|access[-_]?token|auth(?:orization)?|credential|password|secret|token)[a-z0-9-]*))(=|\s+)([^\s;&|]+)/giu;
-
-function redactSecretString(value: string): string {
-	return value
-		.replace(SECRET_STRING_RE, "$1[redacted]@")
-		.replace(SECRET_URL_PARAM_RE, "$1[redacted]")
-		.replace(SECRET_ASSIGNMENT_RE, "$1[redacted]")
-		.replace(SECRET_FLAG_RE, "$1$2[redacted]");
-}
-
-function redactEnvironmentValue(value: unknown, depth: number): unknown {
-	if (depth > 8) return "[redacted nested values]";
-	if (typeof value === "string") return "[redacted]";
-	if (Array.isArray(value)) return value.map((item) => redactEnvironmentValue(item, depth + 1));
-	if (!isPlainObject(value)) return value;
-	const out: Record<string, unknown> = {};
-	for (const [childKey, childValue] of Object.entries(value)) {
-		out[childKey] = redactEnvironmentValue(childValue, depth + 1);
-	}
-	return out;
-}
-
-/** Project tool arguments for display only; execution and receipts retain the original values. */
-export function redactToolArgs(value: unknown, key = "", depth = 0): unknown {
-	if (SECRET_KEY_RE.test(key)) return "[redacted]";
-	if (ENV_KEY_RE.test(key)) return redactEnvironmentValue(value, depth);
-	if (typeof value === "string") return redactSecretString(value);
-	if (depth > 8) return "[redacted nested values]";
-	if (Array.isArray(value)) return value.map((item) => redactToolArgs(item, key, depth + 1));
-	if (!isPlainObject(value)) return value;
-	const out: Record<string, unknown> = {};
-	for (const [childKey, childValue] of Object.entries(value)) {
-		out[childKey] = redactToolArgs(childValue, childKey, depth + 1);
-	}
-	return out;
-}
-
 function readStringField(args: unknown, key: string): string | null {
 	if (!isPlainObject(args)) return null;
 	const value = args[key];
@@ -381,6 +347,10 @@ function offloadPathOf(finished: ToolExecutionFinished): string | null {
 	return isPlainObject(resultSize) ? stringField(resultSize, "offloadPath") : null;
 }
 
+function offloadFileMissing(finished: ToolExecutionFinished): boolean {
+	return finished.resultSummary?.offloadFileMissing === true;
+}
+
 function shownBytesOf(finished: ToolExecutionFinished): number | null {
 	const observation = observationOf(finished);
 	const fromObservation = numberField(observation, "shownBytes");
@@ -456,10 +426,16 @@ function ledgerTail(finished: ToolExecutionFinished): { facts: string; offload:
 		if (details?.outputCapped === true) parts.push("output capped");
 	}
 	if (finished.excludeFromContext === true) parts.push("excluded from context");
+	if (finished.evictedReason !== undefined) parts.push("evicted", finished.evictedReason);
 	const offloadPath = executed ? offloadPathOf(finished) : null;
 	return {
 		facts: parts.length > 0 ? dim(` · ${parts.join(" · ")}`) : "",
-		offload: offloadPath !== null ? dim(` · full: ${offloadPath}`) : "",
+		offload:
+			offloadPath === null
+				? ""
+				: offloadFileMissing(finished)
+					? dim(" · full: gone after the 14-day retention sweep")
+					: dim(` · full: ${offloadPath}`),
 	};
 }
 
@@ -473,7 +449,9 @@ const FAILURE_EXCERPT_LIMIT = 80;
  * its failures carry one; the renderer never names a tool here.
  */
 function failureExcerpt(finished: ToolExecutionFinished, width: number): string {
-	if (!finished.isError || !toolPresentationPolicy(finished.toolName, finished.args).failureExcerpt) return "";
+	const presentation =
+		toolResultPresentationPolicy(finished.result) ?? toolPresentationPolicy(finished.toolName, finished.args);
+	if (!finished.isError || !presentation.failureExcerpt) return "";
 	if (isNonExecutedOutcome(finished.outcome)) return "";
 	const text = unwrapResultEnvelope(finished.result);
 	if (typeof text !== "string") return "";
@@ -871,6 +849,8 @@ function renderArgsBody(toolName: string, args: unknown, width: number, isError:
  */
 function unwrapResultEnvelope(result: unknown): unknown {
 	if (typeof result === "string" || result === null || result === undefined) return result;
+	const presentationText = toolResultPresentationText(result);
+	if (presentationText !== null) return presentationText;
 	const blocks = Array.isArray(result)
 		? result
 		: isPlainObject(result) && Array.isArray(result.content)
@@ -1041,6 +1021,7 @@ function outputFacts(finished: ToolExecutionFinished): string[] {
 	}
 	if (isPlainObject(finished.result) && finished.result.terminate === true) parts.push("terminal result");
 	if (finished.excludeFromContext === true) parts.push("excluded from context");
+	if (finished.evictedReason !== undefined) parts.push("evicted", finished.evictedReason);
 	return parts;
 }
 
@@ -1058,7 +1039,10 @@ function renderOutputMeta(
 function renderOutputFooter(finished: ToolExecutionFinished, width: number, isError: boolean): string[] {
 	const out: string[] = [];
 	const offloadPath = isNonExecutedOutcome(finished.outcome) ? null : offloadPathOf(finished);
-	if (offloadPath !== null) out.push(...indentAndWrap(`${yellow("full output")}  ${offloadPath}`, width, isError));
+	if (offloadPath !== null) {
+		const pointer = offloadFileMissing(finished) ? "gone after the 14-day retention sweep" : offloadPath;
+		out.push(...indentAndWrap(`${yellow("full output")}  ${pointer}`, width, isError));
+	}
 	const hint =
 		stringField(resultSizeOf(finished), "followUpHint") ?? stringField(finished.resultSummary ?? null, "followUpHint");
 	if (hint !== null) out.push(...indentAndWrap(`${dim("next")}  ${hint}`, width, isError));
@@ -1174,7 +1158,9 @@ export interface ToolSublineRenderOptions {
 function foldedDiffRows(finished: ToolExecutionFinished, width: number, opts: ToolSublineRenderOptions): string[] {
 	if (opts.foldedExtras === "none") return [];
 	if (finished.isError || isNonExecutedOutcome(finished.outcome)) return [];
-	if (!toolPresentationPolicy(finished.toolName, finished.args).showDiffWhenFolded) return [];
+	const presentation =
+		toolResultPresentationPolicy(finished.result) ?? toolPresentationPolicy(finished.toolName, finished.args);
+	if (!presentation.showDiffWhenFolded) return [];
 	const diff = resultDiff(finished.result);
 	if (diff === null) return [];
 	return truncateRowsMiddle(

package/src/interactive/session-last-turn.ts

@@ -17,6 +17,7 @@
  * back off replayed thinking text.
  */
 
+import { type ResponseModelIdObservation, responseModelIdObservationFromRecord } from "../core/response-model-id.js";
 import { rawDurationMs } from "../core/timers.js";
 import { extractReasoningTokens } from "../domains/session/context-accounting.js";
 import type { MessageEntry, SessionEntry, SessionUsageDefaults } from "../domains/session/index.js";
@@ -133,6 +134,10 @@ export function lastTurnSummaryFromLedger(
 	let toolErrorCount = 0;
 	let targetId = turn.targetId;
 	let modelId = turn.modelId;
+	let responseModelIdObservation: ResponseModelIdObservation = {
+		state: "legacy-difference-only",
+		differingModelId: null,
+	};
 
 	for (const row of turn.rows) {
 		const record = payloadRecord(row.payload);
@@ -148,7 +153,8 @@ export function lastTurnSummaryFromLedger(
 		const reason = stopReasonOf(record.stopReason);
 		if (reason && reason !== "stop") stopReason = reason;
 		targetId = targetId ?? nonEmptyString(record, "provider", "api");
-		modelId = modelId ?? nonEmptyString(record, "responseModel", "model");
+		modelId = modelId ?? nonEmptyString(record, "model");
+		responseModelIdObservation = responseModelIdObservationFromRecord(record, "legacy-difference-only");
 		const usage = payloadRecord(record.usage);
 		if (!usage) continue;
 		inputTokens += positiveNumber(usage.input);
@@ -177,6 +183,7 @@ export function lastTurnSummaryFromLedger(
 		stopReason,
 		watchdogPeak: 0,
 		truncated: false,
+		responseModelIdObservation,
 	};
 	if (sawReasoning) {
 		summary.reasoningTokens = reasoningTokens;