@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/interactive/overlays/side-question.ts

@@ -37,7 +37,7 @@ export interface OpenSideQuestionOverlayOptions {
 const SIDE_QUESTION_OVERLAY_MIN_WIDTH = 44;
 const SIDE_QUESTION_OVERLAY_MAX_WIDTH = 100;
 
-export function sideQuestionOverlayWidth(columns: number): number {
+function sideQuestionOverlayWidth(columns: number): number {
 	return Math.max(SIDE_QUESTION_OVERLAY_MIN_WIDTH, Math.min(SIDE_QUESTION_OVERLAY_MAX_WIDTH, columns - 4));
 }
 
@@ -46,7 +46,7 @@ export function sideQuestionOverlayWidth(columns: number): number {
  * the question in dim above a rule, then the answer, then one status line that
  * says whether the round is still running, cancelled, or failed.
  */
-export function formatSideQuestionBody(
+function formatSideQuestionBody(
 	question: string,
 	phase: SideQuestionOverlayPhase,
 	width: number,
@@ -112,6 +112,7 @@ export function openSideQuestionOverlay(tui: TUI, options: OpenSideQuestionOverl
 	const handle = showClioOverlayFrame(tui, body, {
 		anchor: "center",
 		width: sideQuestionOverlayWidth(options.columns),
+		markerId: "side-question",
 		title: SIDE_QUESTION_OVERLAY_TITLE,
 		// Esc means two things here and the footer names the live one: it aborts a
 		// round that is still streaming, and it closes one that has settled.

package/src/interactive/overlays/skills-hub.ts

@@ -26,6 +26,7 @@ import type { NoticeLevel } from "../command-output.js";
 import { clioTheme, GLYPH } from "../theme/index.js";
 import type { LibraryInstallConfirmSubject } from "./library-install-confirm.js";
 import { openLibraryInstallConfirmOverlay } from "./library-install-confirm.js";
+import { isLibraryTab, LIBRARY_TABS } from "./library-tabs.js";
 import { type ListOverlayItem, type ListOverlayTab, openListOverlay } from "./list-overlay.js";
 
 /**
@@ -53,23 +54,13 @@ const GROUP_DIAGNOSTICS = "Diagnostics";
 const GROUP_INSTALLED = "Installed";
 const GROUP_AVAILABLE = "Available";
 
-/** The hub's tabs, in the order ←/→ walks them. `skill` is the original view. */
-export const LIBRARY_TABS: ReadonlyArray<{ id: LibraryEntryKind; label: string }> = [
-	{ id: "skill", label: "Skills" },
-	{ id: "agent", label: "Agents" },
-	{ id: "prompt", label: "Prompts" },
-	{ id: "fleet", label: "Fleets" },
-];
+export { isLibraryTab, LIBRARY_TABS };
 
 export const SKILLS_HUB_TITLE = "Skills Hub";
 
 /** Row id prefix for a library row, which is how an action tells the tabs apart. */
 export const LIBRARY_ROW_PREFIX = "library:";
 
-export function isLibraryTab(value: string): value is LibraryEntryKind {
-	return LIBRARY_TABS.some((tab) => tab.id === value);
-}
-
 /** @internal exported for contract tests */
 export const SKILLS_HUB_EMPTY =
 	"no skills installed and no local marketplace configured. install one with `clio-coder skills install <path|github-url>`, or point CLIO_CODER_SKILL_CATALOG_DIR at a skills/ catalog.";
@@ -122,7 +113,7 @@ interface LibraryTabContext {
  * approval preview instead, so this returns null for one and the caller routes
  * it there.
  */
-export function libraryUseInvocation(entry: Pick<LibraryEntry, "kind" | "name">): string | null {
+function libraryUseInvocation(entry: Pick<LibraryEntry, "kind" | "name">): string | null {
 	if (entry.kind === "fleet") return null;
 	if (entry.kind === "agent") return `/run ${entry.name} `;
 	if (entry.kind === "prompt") return `/${entry.name} `;
@@ -157,7 +148,7 @@ function skillBody(content: string): string {
 }
 
 /** @internal exported for contract tests */
-export function buildInstalledItems(list: ResourceList<Skill>): ListOverlayItem[] {
+function buildInstalledItems(list: ResourceList<Skill>): ListOverlayItem[] {
 	return list.items.map((skill) => {
 		const theme = clioTheme();
 		const flagged = list.diagnostics.some((diag) => diagnosticTouchesSkill(diag.path, skill));
@@ -191,7 +182,7 @@ export function buildInstalledItems(list: ResourceList<Skill>): ListOverlayItem[
 }
 
 /** @internal exported for contract tests */
-export function buildMarketplaceItems(
+function buildMarketplaceItems(
 	skills: ReadonlyArray<MarketplaceSkill>,
 	installed: ReadonlySet<string>,
 ): ListOverlayItem[] {
@@ -224,7 +215,7 @@ export function buildMarketplaceItems(
 }
 
 /** @internal exported for contract tests */
-export function buildDiagnosticItems(
+function buildDiagnosticItems(
 	list: ResourceList<Skill>,
 	marketplaceDiagnostics: ReadonlyArray<string> = [],
 ): ListOverlayItem[] {
@@ -261,7 +252,7 @@ export function buildDiagnosticItems(
 }
 
 /** @internal exported for contract tests */
-export function libraryRowId(entry: Pick<LibraryEntry, "kind" | "name">): string {
+function libraryRowId(entry: Pick<LibraryEntry, "kind" | "name">): string {
 	return `${LIBRARY_ROW_PREFIX}${libraryEntryRef(entry)}`;
 }
 
@@ -276,7 +267,7 @@ export function libraryRowId(entry: Pick<LibraryEntry, "kind" | "name">): string
  *
  * @internal exported for contract tests
  */
-export function buildLibraryItems(kind: LibraryEntryKind, context: LibraryTabContext): ListOverlayItem[] {
+function buildLibraryItems(kind: LibraryEntryKind, context: LibraryTabContext): ListOverlayItem[] {
 	const theme = clioTheme();
 	return context.discovery.entries
 		.filter((entry) => entry.kind === kind)
@@ -327,7 +318,7 @@ export function buildLibraryItems(kind: LibraryEntryKind, context: LibraryTabCon
  *
  * @internal exported for contract tests
  */
-export function buildLibraryDiagnosticItems(discovery: LibraryDiscoveryResult): ListOverlayItem[] {
+function buildLibraryDiagnosticItems(discovery: LibraryDiscoveryResult): ListOverlayItem[] {
 	const theme = clioTheme();
 	return discovery.diagnostics
 		.filter((message) => message !== MARKETPLACE_UNCONFIGURED)
@@ -369,7 +360,7 @@ export interface LibraryInstallRunner {
  *
  * @internal exported for contract tests
  */
-export async function runLibraryInstall(
+async function runLibraryInstall(
 	entry: LibraryEntry,
 	runner: LibraryInstallRunner,
 	options: { withRequirements: boolean },
@@ -557,6 +548,7 @@ export function openSkillsHub(tui: TUI, deps: SkillsHubDeps): OverlayHandle {
 	};
 
 	handle = openListOverlay(tui, {
+		markerId: "skills-hub",
 		title: SKILLS_HUB_TITLE,
 		items: [],
 		tabs,

package/src/interactive/overlays/tree-selector.ts

@@ -100,7 +100,7 @@ function fallbackPreview(node: TreeSnapshotNode): string {
  * of turns and the discarded branch had no route back. Returns null for a
  * session that was not forked.
  */
-export function forkParentLine(snapshot: TreeSnapshot, theme: ClioTheme): string | null {
+function forkParentLine(snapshot: TreeSnapshot, theme: ClioTheme): string | null {
 	const parentSessionId = snapshot.meta.parentSessionId;
 	if (typeof parentSessionId !== "string" || parentSessionId.length === 0) return null;
 	const parentTurnId = snapshot.meta.parentTurnId;
@@ -155,7 +155,7 @@ function flattenTreeSnapshot(snapshot: TreeSnapshot): TreeRow[] {
 const ROW_PREVIEW_BUDGET = 55;
 
 /** @internal */
-export function formatTreeRow(row: TreeRow, opts: { showTimestamps: boolean; width: number }): string {
+function formatTreeRow(row: TreeRow, opts: { showTimestamps: boolean; width: number }): string {
 	const theme = clioTheme();
 	const indent = "  ".repeat(row.depth);
 	// The active tip is where the next message lands; it gets its own glyph so
@@ -416,6 +416,7 @@ export function openTreeOverlay(tui: TUI, deps: OpenTreeOverlayDeps): OverlayHan
 	return showClioOverlayFrame(tui, box, {
 		anchor: "center",
 		width: TREE_OVERLAY_WIDTH,
+		markerId: "tree",
 		title: "Session Tree",
 		footerHint: () => view.getHint(),
 	});

package/src/interactive/pane-policy.ts

@@ -0,0 +1,46 @@
+/**
+ * The one decision function for opening a run-watching pane.
+ *
+ * Policy, stated whole: panes are pulled by the operator, never pushed by the
+ * fleet. A dispatch starting, detaching, backgrounding, or failing opens
+ * nothing; the native surfaces (transcript, Alt+W board, footer) already carry
+ * that state, and the v0.3/v0.4 behavior of opening a hidden viewer pane per
+ * dispatch produced panes nobody had asked for. A pane opens only when the
+ * operator names a run: Enter in the workers view, `/panes show`, or the
+ * `panes` tool acting on the conversation's behalf.
+ *
+ * The `dispatch` source is the seam for ever marking a dispatch watchable at
+ * enqueue time. It exists so the decision stays in this one function; today it
+ * always refuses, and any future exception must be argued here, not in a
+ * config key.
+ *
+ * This module is a leaf on purpose: `panes-runtime.ts` is a boundaries seam
+ * whose value closure must stay off the render graph, so the policy cannot
+ * live beside the dispatch board that shares its status vocabulary.
+ */
+
+export type PaneWatchSource = "workers-view" | "slash" | "tool" | "dispatch";
+
+/** Statuses with a live process behind them, in the dispatch board's vocabulary. */
+const WATCHABLE_STATUSES = new Set(["running", "stale", "cancelling", "enqueued", "retrying"]);
+
+export interface PaneWatchRequest {
+	source: PaneWatchSource;
+	/** The run's lifecycle status; anything unrecognized reads as terminal. */
+	runStatus: string;
+}
+
+export type PaneWatchDecision = { open: true } | { open: false; reason: string };
+
+export function paneWatchDecision(request: PaneWatchRequest): PaneWatchDecision {
+	if (request.source === "dispatch") {
+		return { open: false, reason: "dispatches run headless; watch a run from the workers view or /panes show" };
+	}
+	if (!WATCHABLE_STATUSES.has(request.runStatus)) {
+		return {
+			open: false,
+			reason: `run is ${request.runStatus}; use \`clio-coder fleet view <runId>\` for the post-mortem`,
+		};
+	}
+	return { open: true };
+}

package/src/interactive/panes-runtime.ts

@@ -0,0 +1,318 @@
+/**
+ * The one implementation of `PanesOperations`, shared by `/panes` and the
+ * `panes` orchestrator tool.
+ *
+ * Two rules run through it. Presets probe their binary through the toolchain
+ * ladder *before* the pane is split: `openUtilityPane` delivers its command by
+ * sending `exec <argv>` into the pane's shell, so a binary that is not there
+ * kills the pane the instant it appears, and the operator sees a flicker
+ * instead of an install hint (phase 1 report, open question 3). And every
+ * mutation is scoped to panes Clio created, because the contract's registry
+ * refuses anything else.
+ *
+ * `show` targets running dispatches, not panes: it resolves a fuzzy agent id
+ * or run-id prefix against the live dispatch snapshot and points the shared
+ * watch pane at the match, under the one policy decision in
+ * `pane-policy.ts`. There is no per-run pane inventory to search any more.
+ */
+
+import type { ClioSettings } from "../core/config.js";
+import type { DispatchSnapshot } from "../domains/dispatch/contract.js";
+import {
+	newestRunEventJournalRunId,
+	runEventJournalPath,
+	runEventJournalRoot,
+} from "../domains/dispatch/run-event-journal.js";
+import type { MuxContract, MuxPaneRecord } from "../domains/mux/index.js";
+import {
+	PANES_PRESETS,
+	type PanesCloseResult,
+	type PanesInventoryEntry,
+	type PanesOpenResult,
+	type PanesOperations,
+	type PanesShowResult,
+	type PanesStatus,
+	type PanesWatchController,
+	type PanesYaziController,
+	type PanesYaziStatus,
+	type PanesZoomResult,
+} from "../domains/mux/operations.js";
+import { resolveBinary } from "../tools/executables.js";
+import { type PaneWatchSource, paneWatchDecision } from "./pane-policy.js";
+
+export interface PanesRuntimeDeps {
+	mux: MuxContract;
+	getSettings: () => Readonly<ClioSettings>;
+	/** Live dispatch state, used to turn a fuzzy agent id into a run id. */
+	getDispatchSnapshot: () => DispatchSnapshot;
+	getCwd: () => string;
+	/** Injection seam for tests; production uses the toolchain ladder. */
+	resolveBinaryPath?: (name: string) => string | null;
+	/** Journal root override for tests. */
+	journalRoot?: () => string;
+	/** Newest run whose journal exists, for the `logs` preset. */
+	newestJournalRunId?: () => string | null;
+}
+
+const UNAVAILABLE = "the pane layer is not available in this session";
+
+/** Fuzzy operator addressing shared by `close` and `zoom`: id, label, purpose; newest first. */
+function matchOwnedPane(owned: ReadonlyArray<MuxPaneRecord>, target: string): MuxPaneRecord | null {
+	const needle = target.trim().toLowerCase();
+	const newestFirst = [...owned].reverse();
+	return (
+		newestFirst.find((record) => record.ref.paneId.toLowerCase() === needle) ??
+		newestFirst.find((record) => record.label.toLowerCase().includes(needle)) ??
+		newestFirst.find((record) => record.purpose === needle) ??
+		null
+	);
+}
+
+function inventory(records: ReadonlyArray<MuxPaneRecord>): ReadonlyArray<PanesInventoryEntry> {
+	return records.map((record) => ({
+		paneId: record.ref.paneId,
+		tabId: record.ref.tabId,
+		purpose: record.purpose,
+		label: record.label,
+		adopted: record.adopted === true,
+	}));
+}
+
+export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
+	const probe = deps.resolveBinaryPath ?? resolveBinary;
+	const journalRoot = deps.journalRoot ?? runEventJournalRoot;
+	let yaziController: PanesYaziController | null = null;
+	let watchController: PanesWatchController | null = null;
+	let nextPendingOpen = 0;
+	const pendingOpens = new Map<string, PanesInventoryEntry>();
+	const beginPendingOpen = (label: string): string => {
+		nextPendingOpen += 1;
+		const id = `pending:${nextPendingOpen}`;
+		pendingOpens.set(id, {
+			paneId: id,
+			tabId: "pending",
+			purpose: "utility",
+			label,
+			adopted: false,
+			pending: true,
+		});
+		return id;
+	};
+	const closedYaziStatus = (): PanesYaziStatus => ({
+		mode: "closed",
+		paneId: null,
+		paneCwd: null,
+		lastLineAt: null,
+		droppedLines: 0,
+	});
+
+	/**
+	 * Resolve one operator- or model-supplied target to a live dispatched run.
+	 *
+	 * Fuzzy agent id first, then runId prefix, most recent run winning: "the
+	 * tester" is what an operator types; a run id is what a tool call carries.
+	 * Retrying runs count as live; the watch pane shows them coming back.
+	 */
+	const matchRun = (target: string): { runId: string; agentId: string; status: string } | null => {
+		const needle = target.trim().toLowerCase();
+		if (needle.length === 0) return null;
+		const snapshot = deps.getDispatchSnapshot();
+		const live = [
+			...snapshot.running.map((run) => ({ runId: run.runId, agentId: run.agentId, status: "running" })),
+			...snapshot.retrying.map((run) => ({ runId: run.runId, agentId: run.agentId, status: "retrying" })),
+		];
+		// Newest first, so "the tester" means the tester the operator just started.
+		const newestFirst = [...live].reverse();
+		const byAgent = newestFirst.find((run) => run.agentId.toLowerCase().includes(needle));
+		if (byAgent) return byAgent;
+		return newestFirst.find((run) => run.runId.toLowerCase().startsWith(needle)) ?? null;
+	};
+
+	/** argv for one preset, once its binary has been found. */
+	const presetArgv = (presetId: string, binaryPath: string): ReadonlyArray<string> | null => {
+		if (presetId === "shell") return [binaryPath, "-l"];
+		if (presetId === "logs") {
+			const runId = (deps.newestJournalRunId ?? (() => newestRunEventJournalRunId(journalRoot())))();
+			if (runId === null) return null;
+			// `-F` rather than `-f`: the journal is recreated when its run's
+			// directory is pruned, and a viewer following an inode would silently
+			// stop at that point.
+			return [binaryPath, "-n", "200", "-F", runEventJournalPath(runId, journalRoot())];
+		}
+		return null;
+	};
+
+	const show = async (target: string, source: PaneWatchSource): Promise<PanesShowResult> => {
+		if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+		const match = matchRun(target);
+		if (match === null) {
+			// The candidate list is what turns a miss into a next step: it names
+			// the runs that are actually live right now.
+			const snapshot = deps.getDispatchSnapshot();
+			const candidates = [
+				...new Set([...snapshot.running.map((run) => run.agentId), ...snapshot.retrying.map((run) => run.agentId)]),
+			];
+			return { status: "not-found", target, candidates };
+		}
+		const decision = paneWatchDecision({ source, runStatus: match.status });
+		if (!decision.open) return { status: "refused", reason: decision.reason };
+		if (watchController === null) {
+			return { status: "unavailable", reason: "the watch pane is not wired in this session" };
+		}
+		const watched = await watchController.watch(match.runId);
+		if (watched.status !== "watching") return { status: "unavailable", reason: watched.reason };
+		return { status: "watching", runId: match.runId, agentId: match.agentId, opened: watched.opened };
+	};
+
+	return {
+		status(): PanesStatus {
+			const detection = deps.mux.detection();
+			const settings = deps.getSettings();
+			const panes = settings.interface.panes;
+			return {
+				mode: deps.mux.mode,
+				available: deps.mux.available(),
+				reason: detection.reason,
+				socketPath: detection.socketPath,
+				server: detection.server,
+				settings: {
+					enabled: panes.enabled,
+					notifications: panes.notifications,
+					layout: panes.layout,
+					journal: settings.fleet.history.journal,
+					yazi: { ...panes.files },
+				},
+				yazi: yaziController?.status() ?? closedYaziStatus(),
+				docks: deps.mux.docks().map((dock) => ({
+					slot: dock.slot,
+					paneId: dock.paneId,
+					targetShare: dock.targetShare,
+				})),
+				panes: [...inventory(deps.mux.list()), ...pendingOpens.values()],
+			};
+		},
+
+		show(target: string): Promise<PanesShowResult> {
+			// The slash command and the tool share this implementation; the policy
+			// treats both as operator pull, so the source only matters for logs.
+			return show(target, "slash");
+		},
+
+		async open(request: { preset?: string; argv?: ReadonlyArray<string>; once?: boolean }): Promise<PanesOpenResult> {
+			const cwd = deps.getCwd();
+			if (request.preset !== undefined) {
+				const preset = PANES_PRESETS.find((entry) => entry.id === request.preset);
+				if (!preset) {
+					return { status: "refused", reason: `unknown preset: ${request.preset}` };
+				}
+				if (preset.id === "yazi") {
+					if (!deps.getSettings().interface.panes.files.enabled) {
+						return { status: "refused", reason: "the files pane is disabled by panes.yazi.enabled" };
+					}
+					if (!yaziController) {
+						return { status: "unavailable", reason: "the files-pane return path is not ready" };
+					}
+					const pendingId = beginPendingOpen(preset.id);
+					try {
+						const result = await yaziController.open(request.once ? { once: true } : undefined);
+						if (result.status === "opened") {
+							return { status: "opened", label: preset.id, paneId: result.paneId };
+						}
+						if (result.status === "missing-binary") {
+							return {
+								status: "missing-binary",
+								preset: preset.id,
+								binary: result.binary,
+								installHint: preset.installHint,
+								detail: result.detail,
+							};
+						}
+						return {
+							status: result.status === "profile-error" ? "refused" : "unavailable",
+							reason: result.reason,
+						};
+					} finally {
+						pendingOpens.delete(pendingId);
+					}
+				}
+				if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+				const binaryPath = probe(preset.binary);
+				if (binaryPath === null) {
+					return {
+						status: "missing-binary",
+						preset: preset.id,
+						binary: preset.binary,
+						installHint: preset.installHint,
+						detail: `${preset.binary} was not found (install with \`${preset.installHint}\`)`,
+					};
+				}
+				const argv = presetArgv(preset.id, binaryPath);
+				if (argv === null) {
+					return { status: "refused", reason: `preset ${preset.id} has nothing to show yet` };
+				}
+				const pendingId = beginPendingOpen(preset.id);
+				try {
+					const ref = await deps.mux.openUtilityPane({ argv, cwd, label: preset.id });
+					if (ref === null) return { status: "unavailable", reason: `pane host refused to open ${preset.id}` };
+					return { status: "opened", label: preset.id, paneId: ref.paneId };
+				} finally {
+					pendingOpens.delete(pendingId);
+				}
+			}
+			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			const argv = request.argv ?? [];
+			if (argv.length === 0) return { status: "refused", reason: "nothing to run" };
+			const label = argv[0] ?? "pane";
+			const pendingId = beginPendingOpen(label);
+			try {
+				const ref = await deps.mux.openUtilityPane({ argv, cwd, label });
+				if (ref === null) return { status: "unavailable", reason: `pane host refused to open ${label}` };
+				return { status: "opened", label, paneId: ref.paneId };
+			} finally {
+				pendingOpens.delete(pendingId);
+			}
+		},
+
+		async zoom(target: string): Promise<PanesZoomResult> {
+			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			const match = matchOwnedPane(deps.mux.list(), target.trim().length === 0 ? "watch" : target);
+			if (!match) return { status: "not-found", target: target.trim().length === 0 ? "watch" : target };
+			const changed = await deps.mux.zoomPane(match.ref.paneId, "toggle");
+			if (!changed) {
+				return { status: "unavailable", reason: "the pane host does not support zoom (protocol below pane.zoom)" };
+			}
+			return { status: "zoomed", paneId: match.ref.paneId, label: match.label };
+		},
+
+		async close(target: string): Promise<PanesCloseResult> {
+			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			const owned = deps.mux.list();
+			if (target === "all") {
+				const labels: string[] = [];
+				// Snapshot first: closing mutates the registry the list came from.
+				for (const record of [...owned]) {
+					if (await deps.mux.closePane(record.ref.paneId)) labels.push(record.label);
+				}
+				return { status: "closed", closed: labels.length, labels };
+			}
+			const match = matchOwnedPane(owned, target);
+			if (!match) return { status: "not-found", target };
+			const closed = await deps.mux.closePane(match.ref.paneId);
+			return closed ? { status: "closed", closed: 1, labels: [match.label] } : { status: "not-found", target };
+		},
+
+		attachYazi(controller: PanesYaziController): () => void {
+			yaziController = controller;
+			return () => {
+				if (yaziController === controller) yaziController = null;
+			};
+		},
+
+		attachWatch(controller: PanesWatchController): () => void {
+			watchController = controller;
+			return () => {
+				if (watchController === controller) watchController = null;
+			};
+		},
+	};
+}

package/src/interactive/permission-overlay.ts

@@ -203,7 +203,7 @@ function wrapArtifactLine(value: string, max: number): string[] {
 	return lines;
 }
 
-export function permissionDecisionPresentation(view: ApprovalRequestView): DecisionPresentation {
+function permissionDecisionPresentation(view: ApprovalRequestView): DecisionPresentation {
 	return classifyDecisionPresentation(
 		decisionFactsForPermission({
 			tool: view.tool,
@@ -307,7 +307,7 @@ function permissionInspectionLines(
  * 80-column one saw the command being authorized end mid-argument, both with
  * nothing marking the cut.
  */
-export function permissionOverlayLines(view: ApprovalRequestView, width: number): string[] {
+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

package/src/interactive/renderers/compaction-summary.ts

@@ -49,6 +49,35 @@ export function renderCompactionSummaryLine(input: CompactionSummaryLineInput):
 	return `[context engine] llm_summary: ${input.messagesSummarized} messages summarized to ${input.summaryChars} chars; ~${input.tokensBefore} tokens before${tail}`;
 }
 
+/** Why the non-destructive stage had nothing to do before a summary ran. */
+export type EvictionSkipReason = "all-protected" | "nothing-evictable" | "disabled";
+
+export interface EvictionSkipLineInput {
+	reason: EvictionSkipReason;
+	/** Turn starts in the visible slice the policy was offered. */
+	turns: number;
+	protectLastTurns: number;
+	policyId: string;
+}
+
+/**
+ * One line saying the working-set stage was considered and declined, in the
+ * same `[context engine] working set:` voice its eviction notice uses. Without
+ * it a short session falls from the pressure threshold straight into the
+ * destructive summary with nothing in the transcript explaining why the cheap
+ * stage did not run (smoke pass 2, G1).
+ */
+export function renderEvictionSkipLine(input: EvictionSkipLineInput): string {
+	const turnWord = input.turns === 1 ? "turn" : "turns";
+	const cause =
+		input.reason === "disabled"
+			? "eviction is off (context.workingSet.enabled false)"
+			: input.reason === "all-protected"
+				? `nothing evictable, all ${input.turns} ${turnWord} are inside the protected window (protectLastTurns ${input.protectLastTurns})`
+				: `nothing evictable by ${input.policyId} above the protected window (protectLastTurns ${input.protectLastTurns})`;
+	return `[context engine] working set: ${cause}; llm_summary runs instead`;
+}
+
 export interface RenderCompactionSummaryOptions {
 	/** Override the default markdown theme. Defaults to the local theme above. */
 	theme?: MarkdownTheme;

package/src/interactive/renderers/retry-status.ts

@@ -1,13 +1,21 @@
 import type { RetryStatusPayload } from "../chat-loop.js";
 import { styleTaggedNotice } from "./notice.js";
 
-function shorten(value: string, limit: number): string {
-	if (value.length <= limit) return value;
-	return `${value.slice(0, Math.max(0, limit - 3))}...`;
+const RETRY_ERROR_MAX_CHARS = 2_000;
+const RETRY_ERROR_TRUNCATION_MARKER = "… [retry error truncated]";
+
+function boundedRetryError(value: string): string {
+	const characters = Array.from(value);
+	if (characters.length <= RETRY_ERROR_MAX_CHARS) return value;
+	return `${characters.slice(0, RETRY_ERROR_MAX_CHARS).join("").trimEnd()}${RETRY_ERROR_TRUNCATION_MARKER}`;
 }
 
 function rawRetryStatus(status: RetryStatusPayload): string {
-	const suffix = status.errorMessage ? `: ${shorten(status.errorMessage, 120)}` : "";
+	// Both live and replay renderers wrap this notice to their terminal width, so
+	// ordinary errors keep their complete remedy. Raw provider failures can also
+	// be an HTML proxy page, though; keep a generous ceiling so one retry does not
+	// turn that page into hundreds of transcript rows.
+	const suffix = status.errorMessage ? `: ${boundedRetryError(status.errorMessage)}` : "";
 	if (status.phase === "waiting") {
 		return `[retry] attempt ${status.attempt}/${status.maxAttempts} in ${status.seconds ?? 0}s${suffix}`;
 	}

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

@@ -426,7 +426,7 @@ function ledgerTail(finished: ToolExecutionFinished): { facts: string; offload:
 		if (details?.timedOut === true) parts.push("timed out");
 		if (details?.outputCapped === true) parts.push("output capped");
 	}
-	if (finished.excludeFromContext === true) parts.push("excluded from context");
+	if (finished.excludeFromContext === true) parts.push("not sent to model");
 	if (finished.evictedReason !== undefined) parts.push("evicted", finished.evictedReason);
 	const offloadPath = executed ? offloadPathOf(finished) : null;
 	return {
@@ -994,7 +994,7 @@ function toolUsageFact(result: unknown): string | null {
 function outputFacts(finished: ToolExecutionFinished): string[] {
 	const parts: string[] = [];
 	if (isNonExecutedOutcome(finished.outcome)) {
-		if (finished.excludeFromContext === true) parts.push("excluded from context");
+		if (finished.excludeFromContext === true) parts.push("not sent to model");
 		return parts;
 	}
 	const exitCode = structuredExitCode(finished) ?? (finished.toolName === "bash" && !finished.isError ? "0" : null);
@@ -1024,7 +1024,7 @@ function outputFacts(finished: ToolExecutionFinished): string[] {
 		if (added.length > 0) parts.push(`added ${added.join(", ")}`);
 	}
 	if (isPlainObject(finished.result) && finished.result.terminate === true) parts.push("terminal result");
-	if (finished.excludeFromContext === true) parts.push("excluded from context");
+	if (finished.excludeFromContext === true) parts.push("not sent to model");
 	if (finished.evictedReason !== undefined) parts.push("evicted", finished.evictedReason);
 	return parts;
 }
@@ -1379,7 +1379,7 @@ export function renderBashTranscriptExecution(
 	const shownBytes = Buffer.byteLength(execution.output, "utf8");
 	const totalBytes = execution.totalBytes ?? shownBytes;
 	const args: Record<string, unknown> = { command: execution.command };
-	if (execution.excludeFromContext === true) args.context = "excluded from model context";
+	if (execution.excludeFromContext === true) args.context = "not sent to model";
 	const details = {
 		resultSize: {
 			bytes: totalBytes,