@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/interactive/file-reference-completion.ts

@@ -0,0 +1,360 @@
+import { execFile } from "node:child_process";
+import { open, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { enumerateWorkspaceFilesAsync } from "../core/workspace-files.js";
+import { fuzzyFilter, stripTerminalSequences } from "../engine/tui.js";
+import { isEditorSteerTargetToken } from "./editor-steer.js";
+
+const MAX_COMPLETION_ROWS = 40;
+const PREVIEW_BYTES = 2048;
+const PREVIEW_CHARS = 120;
+const SNAPSHOT_TTL_MS = 2_000;
+const GIT_OUTPUT_LIMIT_BYTES = 128 * 1024 * 1024;
+
+export interface FileReferenceCompletionRequest {
+	/** Text after the active `@`, decoded when the reference is quoted. */
+	query: string;
+	signal: AbortSignal;
+}
+
+export interface FileReferenceCompletionValue {
+	id: string;
+	/** Complete inline reference spelling, including `@` and any quotes. */
+	value: string;
+	/** Workspace/path spelling without the leading `@` or a trailing slash. */
+	path: string;
+	label: string;
+	description: string;
+	isDirectory: boolean;
+	tracked: boolean;
+}
+
+export type FileReferenceCompletionSource = (
+	request: FileReferenceCompletionRequest,
+) => Promise<ReadonlyArray<FileReferenceCompletionValue>>;
+
+export interface FileReferenceCompletionOptions {
+	basePath: string;
+	cacheTtlMs?: number;
+	/** Test/runtime seam; defaults to the repository's authoritative visible-file enumerator. */
+	listWorkspaceFiles?: (basePath: string) => Promise<ReadonlyArray<string>>;
+	/** Test/runtime seam; defaults to `git ls-files --cached`. */
+	listTrackedFiles?: (basePath: string) => Promise<ReadonlySet<string>>;
+}
+
+interface FileCandidate {
+	path: string;
+	absolutePath: string;
+	isDirectory: boolean;
+	tracked: boolean;
+	descendantFiles: number;
+	workspace: boolean;
+}
+
+interface WorkspaceSnapshot {
+	candidates: FileCandidate[];
+	directories: ReadonlySet<string>;
+	trackedFiles: ReadonlySet<string>;
+}
+
+function posixPath(path: string): string {
+	return sep === "\\" ? path.replaceAll("\\", "/") : path;
+}
+
+function safeRelativePath(path: string): string | null {
+	const normalized = posixPath(path).replace(/^\.\//u, "").replace(/\/$/u, "");
+	if (normalized.length === 0 || normalized.startsWith("/") || normalized.includes("\0") || /[\r\n]/u.test(normalized)) {
+		return null;
+	}
+	const segments = normalized.split("/");
+	if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) return null;
+	return segments.join("/");
+}
+
+function gitTrackedFiles(basePath: string): Promise<ReadonlySet<string>> {
+	return new Promise((resolveTracked) => {
+		execFile(
+			"git",
+			["--literal-pathspecs", "ls-files", "-z", "--cached"],
+			{ cwd: basePath, encoding: "utf8", maxBuffer: GIT_OUTPUT_LIMIT_BYTES },
+			(error, stdout) => {
+				if (error) {
+					resolveTracked(new Set());
+					return;
+				}
+				const tracked = new Set<string>();
+				for (const raw of stdout.split("\0")) {
+					const normalized = safeRelativePath(raw);
+					if (normalized) tracked.add(normalized);
+				}
+				resolveTracked(tracked);
+			},
+		);
+	});
+}
+
+function buildWorkspaceSnapshot(
+	basePath: string,
+	visibleFiles: ReadonlyArray<string>,
+	trackedFiles: ReadonlySet<string>,
+): WorkspaceSnapshot {
+	const files: FileCandidate[] = [];
+	const directoryFacts = new Map<string, { tracked: boolean; descendantFiles: number }>();
+	for (const raw of visibleFiles) {
+		const path = safeRelativePath(raw);
+		if (!path) continue;
+		const tracked = trackedFiles.has(path);
+		files.push({
+			path,
+			absolutePath: join(basePath, path),
+			isDirectory: false,
+			tracked,
+			descendantFiles: 0,
+			workspace: true,
+		});
+		const segments = path.split("/");
+		for (let index = 1; index < segments.length; index += 1) {
+			const directory = segments.slice(0, index).join("/");
+			const facts = directoryFacts.get(directory) ?? { tracked: false, descendantFiles: 0 };
+			facts.tracked ||= tracked;
+			facts.descendantFiles += 1;
+			directoryFacts.set(directory, facts);
+		}
+	}
+	const directories = [...directoryFacts].map(
+		([path, facts]): FileCandidate => ({
+			path,
+			absolutePath: join(basePath, path),
+			isDirectory: true,
+			tracked: facts.tracked,
+			descendantFiles: facts.descendantFiles,
+			workspace: true,
+		}),
+	);
+	return {
+		candidates: [...directories, ...files],
+		directories: new Set(directoryFacts.keys()),
+		trackedFiles,
+	};
+}
+
+function candidateParent(path: string): string {
+	const parent = posixPath(dirname(path));
+	return parent === "." ? "" : parent;
+}
+
+function fuzzyOrdered(candidates: ReadonlyArray<FileCandidate>, query: string): FileCandidate[] {
+	const buckets: FileCandidate[][] = [[], [], [], []];
+	for (const candidate of candidates) {
+		const bucket = candidate.tracked ? (candidate.isDirectory ? 0 : 1) : candidate.isDirectory ? 2 : 3;
+		buckets[bucket]?.push(candidate);
+	}
+	return buckets.flatMap((bucket) =>
+		fuzzyFilter(bucket, query, (candidate) => `${basename(candidate.path)} ${candidate.path}`),
+	);
+}
+
+function workspaceCandidates(snapshot: WorkspaceSnapshot, rawQuery: string): FileCandidate[] {
+	const explicitDot = rawQuery.startsWith("./");
+	const query = explicitDot ? rawQuery.slice(2) : rawQuery;
+	const slash = query.lastIndexOf("/");
+	if (query.length === 0) {
+		return fuzzyOrdered(
+			snapshot.candidates
+				.filter((candidate) => candidateParent(candidate.path) === "")
+				.map((candidate) => (explicitDot ? { ...candidate, path: `./${candidate.path}` } : candidate)),
+			"",
+		);
+	}
+	if (slash >= 0) {
+		const parent = query.slice(0, slash);
+		const fragment = query.slice(slash + 1);
+		if (parent.length === 0 || snapshot.directories.has(parent)) {
+			const displayPrefix = explicitDot ? "./" : "";
+			return fuzzyOrdered(
+				snapshot.candidates
+					.filter((candidate) => candidateParent(candidate.path) === parent)
+					.map((candidate) => ({ ...candidate, path: `${displayPrefix}${candidate.path}` })),
+				fragment,
+			);
+		}
+	}
+	return fuzzyOrdered(
+		snapshot.candidates.map((candidate) => (explicitDot ? { ...candidate, path: `./${candidate.path}` } : candidate)),
+		query,
+	);
+}
+
+function explicitPathQuery(query: string): boolean {
+	return query.startsWith("../") || query.startsWith("~/") || query.startsWith("/");
+}
+
+function resolveDisplayBase(basePath: string, displayBase: string): string {
+	if (displayBase.startsWith("~/")) return resolve(homedir(), displayBase.slice(2));
+	if (displayBase.startsWith("/")) return resolve(displayBase);
+	return resolve(basePath, displayBase);
+}
+
+function workspaceRelative(basePath: string, absolutePath: string): string | null {
+	const candidate = posixPath(relative(basePath, absolutePath));
+	if (candidate.length === 0 || candidate === ".." || candidate.startsWith("../")) return null;
+	return safeRelativePath(candidate);
+}
+
+async function explicitCandidates(
+	basePath: string,
+	query: string,
+	trackedFiles: ReadonlySet<string>,
+): Promise<FileCandidate[]> {
+	const slash = query.lastIndexOf("/");
+	if (slash < 0) return [];
+	const displayBase = query.slice(0, slash + 1);
+	const fragment = query.slice(slash + 1);
+	const directory = resolveDisplayBase(basePath, displayBase);
+	const candidates: FileCandidate[] = [];
+	for (const entry of await readdir(directory, { withFileTypes: true })) {
+		if (entry.name === ".git" || /[\r\n\0]/u.test(entry.name)) continue;
+		const absolutePath = join(directory, entry.name);
+		let isDirectory = entry.isDirectory();
+		let isFile = entry.isFile();
+		if (!isDirectory && !isFile && entry.isSymbolicLink()) {
+			try {
+				const facts = await stat(absolutePath);
+				isDirectory = facts.isDirectory();
+				isFile = facts.isFile();
+			} catch {
+				continue;
+			}
+		}
+		if (!isDirectory && !isFile) continue;
+		const relativePath = workspaceRelative(basePath, absolutePath);
+		candidates.push({
+			path: `${displayBase}${entry.name}`,
+			absolutePath,
+			isDirectory,
+			tracked: relativePath !== null && trackedFiles.has(relativePath),
+			descendantFiles: 0,
+			workspace: relativePath !== null,
+		});
+	}
+	return fuzzyOrdered(candidates, fragment);
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(bytes < 10 * 1024 ? 1 : 0)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(bytes < 10 * 1024 * 1024 ? 1 : 0)}MB`;
+}
+
+function cleanPreview(bytes: Buffer): string | null {
+	if (bytes.includes(0)) return "binary file";
+	const text = stripTerminalSequences(bytes.toString("utf8"));
+	const line = text
+		.split(/\r?\n/u)
+		.map((candidate) =>
+			Array.from(candidate, (character) => {
+				const code = character.codePointAt(0) ?? 0;
+				return code < 32 || code === 127 ? " " : character;
+			})
+				.join("")
+				.trim(),
+		)
+		.find((candidate) => candidate.length > 0);
+	if (!line) return null;
+	return line.length > PREVIEW_CHARS ? `${line.slice(0, PREVIEW_CHARS - 1)}…` : line;
+}
+
+async function candidateDescription(candidate: FileCandidate): Promise<string> {
+	const provenance = candidate.tracked ? "git tracked" : candidate.workspace ? "untracked" : "filesystem";
+	if (candidate.isDirectory) {
+		const count = candidate.descendantFiles > 0 ? ` · ${candidate.descendantFiles} files` : "";
+		return `${provenance} directory${count} · Tab/Enter opens`;
+	}
+	try {
+		const facts = await stat(candidate.absolutePath);
+		const handle = await open(candidate.absolutePath, "r");
+		let preview: string | null = null;
+		try {
+			const buffer = Buffer.alloc(Math.min(PREVIEW_BYTES, Math.max(0, facts.size)));
+			if (buffer.length > 0) {
+				const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+				preview = cleanPreview(buffer.subarray(0, bytesRead));
+			}
+		} finally {
+			await handle.close();
+		}
+		return `${provenance} · ${formatBytes(facts.size)}${preview ? ` · ${preview}` : ""}`;
+	} catch {
+		return `${provenance} · preview unavailable`;
+	}
+}
+
+/** Quote a completion exactly the way the inline-reference scanner accepts. */
+function formatInlineFileReference(path: string, isDirectory: boolean): string {
+	const completionPath = isDirectory ? `${path.replace(/\/$/u, "")}/` : path;
+	if (!/[\s"'\\]/u.test(completionPath) && !isEditorSteerTargetToken(completionPath)) return `@${completionPath}`;
+	return `@"${completionPath.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+function completionId(candidate: FileCandidate): string {
+	return `file-reference:${candidate.isDirectory ? "directory" : "file"}:${candidate.absolutePath}`;
+}
+
+/**
+ * Workspace-aware `@` source for Clio's one grammar-aware composer provider.
+ * A bare `@` is a top-level tree; text without a slash fuzzes the whole
+ * workspace; a real directory prefix becomes its child submenu. Explicit
+ * `../`, `~/`, and absolute prefixes stay scoped filesystem navigation.
+ */
+export function createFileReferenceCompletionSource(
+	options: FileReferenceCompletionOptions,
+): FileReferenceCompletionSource {
+	const basePath = resolve(options.basePath);
+	const listWorkspaceFiles = options.listWorkspaceFiles ?? ((cwd: string) => enumerateWorkspaceFilesAsync(cwd));
+	const listTrackedFiles = options.listTrackedFiles ?? gitTrackedFiles;
+	const cacheTtlMs = options.cacheTtlMs ?? SNAPSHOT_TTL_MS;
+	let cached: { expiresAt: number; snapshot: WorkspaceSnapshot } | null = null;
+	let loading: Promise<WorkspaceSnapshot> | null = null;
+
+	const snapshot = async (): Promise<WorkspaceSnapshot> => {
+		const now = Date.now();
+		if (cached && cached.expiresAt > now) return cached.snapshot;
+		loading ??= Promise.all([listWorkspaceFiles(basePath), listTrackedFiles(basePath)]).then(([visible, tracked]) =>
+			buildWorkspaceSnapshot(basePath, visible, tracked),
+		);
+		try {
+			const next = await loading;
+			cached = { expiresAt: now + cacheTtlMs, snapshot: next };
+			return next;
+		} finally {
+			loading = null;
+		}
+	};
+
+	return async (request) => {
+		if (request.signal.aborted) return [];
+		try {
+			const workspace = await snapshot();
+			if (request.signal.aborted) return [];
+			const candidates = explicitPathQuery(request.query)
+				? await explicitCandidates(basePath, request.query, workspace.trackedFiles)
+				: workspaceCandidates(workspace, request.query);
+			if (request.signal.aborted) return [];
+			const top = candidates.slice(0, MAX_COMPLETION_ROWS);
+			const descriptions = await Promise.all(top.map(candidateDescription));
+			if (request.signal.aborted) return [];
+			return top.map((candidate, index) => ({
+				id: completionId(candidate),
+				value: formatInlineFileReference(candidate.path, candidate.isDirectory),
+				path: candidate.path,
+				label: `${candidate.path}${candidate.isDirectory ? "/" : ""}`,
+				description: descriptions[index] ?? "preview unavailable",
+				isDirectory: candidate.isDirectory,
+				tracked: candidate.tracked,
+			}));
+		} catch {
+			return [];
+		}
+	};
+}

package/src/interactive/footer/dashboard.ts

@@ -208,7 +208,7 @@ function renderFooterDashboardLines(
  * Widths from 80 to 119 columns use a two by two grid.
  * Widths below 80 columns use a vertical stack with all sections retained.
  */
-export function renderFooterStatusLines(state: FooterDashboardRenderState, width: number): string[] {
+function renderFooterStatusLines(state: FooterDashboardRenderState, width: number): string[] {
 	const theme = clioTheme();
 	const safeWidth = Math.max(1, Math.floor(width));
 	const header = headerLine(state.session, safeWidth);
@@ -297,7 +297,7 @@ export function renderFooterStatusLines(state: FooterDashboardRenderState, width
  * current work the strongest column; surplus is shared by urgency until the
  * lower-priority sections reach their caps, then spills into Activity.
  */
-export function expandedWideColumnWidths(width: number, totalSepWidth: number): [number, number, number, number] {
+function expandedWideColumnWidths(width: number, totalSepWidth: number): [number, number, number, number] {
 	const available = Math.max(0, width - totalSepWidth);
 	const widths: [number, number, number, number] = [32, 31, 27, 21];
 	let remaining = Math.max(0, available - widths.reduce((sum, item) => sum + item, 0));
@@ -392,33 +392,31 @@ export function buildFooterDashboard(deps: FooterDashboardDeps): FooterDashboard
 		const tokensLabel = tokens || (usage?.totalTokens ? `Σ${formatFooterTokens(usage.totalTokens)}` : null);
 
 		const statuses = deps.providers.list();
-		const current = settings?.orchestrator?.target
-			? (statuses.find((s) => s.target.id === settings.orchestrator?.target) ?? null)
-			: null;
+		const current = settings?.chat?.target ? (statuses.find((s) => s.target.id === settings.chat?.target) ?? null) : null;
 
-		const target = formatTargetLabel(settings?.orchestrator?.target, settings?.orchestrator?.model);
+		const target = formatTargetLabel(settings?.chat?.target, settings?.chat?.model);
 
 		const resolution = resolveModelRuntimeCapabilitiesForProviders(
 			deps.providers,
-			settings?.orchestrator?.target,
-			settings?.orchestrator?.model,
-			settings?.orchestrator?.thinkingLevel ?? "off",
+			settings?.chat?.target,
+			settings?.chat?.model,
+			settings?.chat?.thinkingLevel ?? "off",
 		);
 
-		const thinking = resolution?.thinking.display ?? settings?.orchestrator?.thinkingLevel ?? "off";
+		const thinking = resolution?.thinking.display ?? settings?.chat?.thinkingLevel ?? "off";
 
-		const wireModelId = settings?.orchestrator?.model ?? current?.target.defaultModel ?? null;
+		const wireModelId = settings?.chat?.model ?? current?.target.defaultModel ?? null;
 		const detectedReasoning =
 			wireModelId && typeof deps.providers.getDetectedReasoning === "function"
-				? deps.providers.getDetectedReasoning(settings?.orchestrator?.target ?? "", wireModelId)
+				? deps.providers.getDetectedReasoning(settings?.chat?.target ?? "", wireModelId)
 				: null;
 		const caps = current
 			? resolveModelCapabilities(current, wireModelId, deps.providers.knowledgeBase, { detectedReasoning })
 			: null;
 		const capabilities = capabilityLabels(caps);
 
-		const safety = settings?.autonomy ?? "auto-edit";
-		const toolProfile = settings?.delegation?.defaults?.toolGovernance ?? "clio-policy";
+		const safety = settings?.safety.autonomy ?? "auto-edit";
+		const toolProfile = settings?.integrations.externalAgents?.defaults?.toolGovernance ?? "clio-coder-policy";
 
 		return {
 			workspace: workspaceFacts(deps, branchSlot),
@@ -436,7 +434,7 @@ export function buildFooterDashboard(deps: FooterDashboardDeps): FooterDashboard
 				capabilities,
 				safety,
 				toolProfile,
-				outputVerbosity: settings?.terminal.outputVerbosity ?? "default",
+				outputVerbosity: settings?.interface.outputDetail ?? "default",
 				leaderArmed: deps.getLeaderArmed?.() ?? false,
 				shutdownArmed: deps.getShutdownArmed?.() ?? false,
 				memoryIntervention: taskMemory
@@ -454,8 +452,8 @@ export function buildFooterDashboard(deps: FooterDashboardDeps): FooterDashboard
 				used: contextUsage?.tokens ?? null,
 				contextWindow: contextUsage?.contextWindow ?? null,
 				toolSchemaTokens: contextUsage?.breakdown?.toolSchemaTokens ?? null,
-				compactionThreshold: settings?.compaction?.threshold ?? null,
-				compactionAuto: settings?.compaction?.auto ?? null,
+				compactionThreshold: settings?.context.compaction?.threshold ?? null,
+				compactionAuto: settings?.context.compaction?.auto ?? null,
 				compactionActive,
 				clioMd: formatClioMdState(contextState?.clioMd),
 				memory: formatMemoryState(contextState?.memoryCount),

package/src/interactive/footer/notifications.ts

@@ -14,7 +14,7 @@
  * color lives in `theme/**`; every emitted line is width-clamped.
  */
 
-import { truncateToWidth, visibleWidth } from "../../engine/tui.js";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../../engine/tui.js";
 import { fitFooterText } from "../footer-panel.js";
 import { type ClioTheme, type ClioToken, clioTheme, GLYPH, rule } from "../theme/index.js";
 
@@ -152,7 +152,7 @@ function boundNotifyBytes(text: string, maxBytes: number): string {
 }
 
 /** The closed-vocabulary body for one event. */
-export function desktopNotifyBody(event: DesktopNotifyEvent): string {
+function desktopNotifyBody(event: DesktopNotifyEvent): string {
 	if (event.kind === "turn-finished") return "turn finished";
 	if (event.kind === "approval-needed") return "approval needed";
 	const shortId = boundNotifyBytes(sanitizeNotifyText(event.shortId), 32);
@@ -160,7 +160,7 @@ export function desktopNotifyBody(event: DesktopNotifyEvent): string {
 }
 
 /** True when the environment names a terminal that answers OSC 9 rather than OSC 777. */
-export function prefersOsc9(env: Readonly<Record<string, string | undefined>>): boolean {
+function prefersOsc9(env: Readonly<Record<string, string | undefined>>): boolean {
 	if (typeof env.WT_SESSION === "string" && env.WT_SESSION.length > 0) return true;
 	const program = (env.TERM_PROGRAM ?? "").trim().toLowerCase();
 	if (program.length === 0) return false;
@@ -173,7 +173,7 @@ export function prefersOsc9(env: Readonly<Record<string, string | undefined>>):
  * chosen for the terminals that implement it instead. Exactly one sequence is
  * returned, so a single event can never produce two notifications.
  */
-export function buildDesktopNotifySequence(
+function buildDesktopNotifySequence(
 	event: DesktopNotifyEvent,
 	env: Readonly<Record<string, string | undefined>> = process.env,
 ): string {
@@ -208,7 +208,7 @@ export interface DesktopNotifier {
  * events. Every call re-checks the setting and the surface, so turning
  * `terminal.notify` off mid-session silences the next event.
  */
-export function createDesktopNotifier(deps: DesktopNotifierDeps): DesktopNotifier {
+function createDesktopNotifier(deps: DesktopNotifierDeps): DesktopNotifier {
 	const env = deps.env ?? process.env;
 	return {
 		notify(event) {
@@ -470,8 +470,9 @@ export function formatNotificationBadge(
 }
 
 /**
- * Expanded notices panel for the dashboard. Header rule + one styled line per
- * entry, capped so a noisy boot cannot push the dashboard off-screen.
+ * Expanded notices panel for the dashboard. The entry count is capped so a
+ * noisy boot cannot take over the dashboard, but every included notice wraps
+ * in full: this is the detail surface that the compact badge points toward.
  */
 export function formatNotificationPanel(
 	entries: ReadonlyArray<Notification>,
@@ -485,7 +486,12 @@ export function formatNotificationPanel(
 	const lines: string[] = [rule(theme, width, { left: "notices" })];
 	for (const entry of entries.slice(0, maxRows)) {
 		const glyph = theme.fg(notificationToken(entry.level), notificationGlyph(entry.level));
-		lines.push(fitFooterText(`${glyph} ${theme.fg("muted", entry.text)}`, width, GLYPH.ellipsis));
+		const prefix = `${glyph} `;
+		const prefixWidth = visibleWidth(prefix);
+		const wrapped = wrapTextWithAnsi(theme.fg("muted", entry.text), Math.max(1, width - prefixWidth));
+		lines.push(
+			...wrapped.map((line, index) => fitFooterText(`${index === 0 ? prefix : " ".repeat(prefixWidth)}${line}`, width)),
+		);
 	}
 	const overflow = entries.length - maxRows;
 	const hint = overflow > 0 ? `+${overflow} more · ${dismiss} dismiss` : `${dismiss} dismiss`;

package/src/interactive/footer/widgets.ts

@@ -1,5 +1,4 @@
 import type { OutputVerbosity } from "../../core/defaults.js";
-import { responseModelIdObservationLabel } from "../../core/response-model-id.js";
 import { ToolNames } from "../../core/tool-names.js";
 import {
 	type CostAggregate,
@@ -28,7 +27,6 @@ import {
 	type TurnSummary,
 } from "../status/index.js";
 import {
-	abbreviateModelId,
 	type ClioTheme,
 	type ClioToken,
 	clioTheme,
@@ -370,6 +368,13 @@ function contextComposition(context: ContextEngineFacts): {
 	};
 }
 
+/** The live window after the percent; null when unknown or the row is too narrow to carry it. */
+export function compactContextWindowLabel(context: ContextEngineFacts, width: number): string | null {
+	if (width < 72) return null;
+	const window = finiteNonNegative(context.ledger?.contextWindow ?? context.contextWindow);
+	return window > 0 ? formatFooterTokens(window) : null;
+}
+
 export function compactSecondaryLine(
 	context: ContextEngineFacts,
 	agent: AgentWorkFacts,
@@ -405,6 +410,12 @@ export function compactSecondaryLine(
 	} else {
 		left = buildSegmentedContextBar(theme, barCells, context.contextWindow ?? 0, contextBreakdownForBar(context));
 	}
+	// A percentage alone does not say whether the window is 128k or 1M, so at
+	// widths that can afford it the live window follows the percent. It comes
+	// from the ledger when one is bound (the layer that answered the window is
+	// also the layer that produced the percent) and from the facts otherwise.
+	const windowLabel = compactContextWindowLabel(context, safeWidth);
+	if (windowLabel) left = `${left} ${theme.fg("dim", "of")} ${theme.fg("muted", windowLabel)}`;
 	const maxRightWidth = Math.max(0, safeWidth - visibleWidth(left) - 1);
 	const right = buildMetricStrip(
 		theme,
@@ -700,46 +711,6 @@ function stopReasonStyle(reason: TurnSummary["stopReason"]): { glyph: string; to
 	return { glyph: GLYPH.ok, token: "success" };
 }
 
-/**
- * Elegant single-line readout of the most recent completed turn. This is the
- * footer home for the metrics that used to print faintly under each assistant
- * reply: stop outcome, wall time, token in/out, reasoning, and tool work. The
- * model is intentionally omitted because the editor rail already carries it.
- */
-export function formatLastTurn(theme: ClioTheme, summary: TurnSummary): string {
-	const stop = stopReasonStyle(summary.stopReason);
-	const parts: string[] = [
-		theme.fg(stop.token, `${stop.glyph} ${formatCompactMs(summary.elapsedMs)}`),
-		theme.fg("muted", `${GLYPH.up}${summary.inputTokens} ${GLYPH.down}${summary.outputTokens}`),
-	];
-	// Zero suppresses the chip, the same rule the chat panel's turn line follows:
-	// a turn that spent no reasoning tokens states nothing by printing `r0`.
-	const chip = formatReasoningChip(reasoningFromSummary(summary), String);
-	if (chip !== null) parts.push(theme.fg("reason", chip));
-	if (summary.cacheReadTokens > 0 || summary.cacheWriteTokens > 0) {
-		parts.push(theme.fg("dim", `cache ${summary.cacheReadTokens}/${summary.cacheWriteTokens}`));
-	}
-	if (summary.toolCount > 0) {
-		const label = `${summary.toolCount} tool${summary.toolCount === 1 ? "" : "s"}`;
-		const errors = summary.toolErrorCount > 0 ? theme.fg("error", ` ${summary.toolErrorCount}${GLYPH.error}`) : "";
-		parts.push(`${theme.fg("muted", label)}${errors}`);
-	}
-	if (summary.watchdogPeak >= 2) parts.push(theme.fg("warning", "slow"));
-	if (summary.truncated) parts.push(theme.fg("warning", "trunc"));
-	const observation = summary.responseModelIdObservation;
-	const observedId =
-		observation.state === "reported"
-			? observation.reportedModelId
-			: observation.state === "legacy-difference-only"
-				? observation.differingModelId
-				: null;
-	const observationText = `response model id observation ${responseModelIdObservationLabel(observation)}${
-		observedId === null ? "" : ` ${abbreviateModelId(observedId)}`
-	}`;
-	parts.push(theme.fg("warning", observationText));
-	return parts.join(theme.fg("dim", " · "));
-}
-
 /**
  * One row per live worker: the origin glyph, the sub-process glyph when Clio
  * started the run for itself, the agent's own name, the fleet node it landed
@@ -1099,7 +1070,7 @@ function outputVerbosityLabel(verbosity: OutputVerbosity): string {
 	return verbosity === "minimal" ? "min" : verbosity === "verbose" ? "verbose" : "default";
 }
 
-export function buildHarnessStatePill(
+function buildHarnessStatePill(
 	theme: ClioTheme,
 	status: AgentStatus,
 	toolCounts: ToolTallySnapshot,
@@ -1175,7 +1146,7 @@ function selectChips(
 	return surviving();
 }
 
-export function buildMetricStrip(
+function buildMetricStrip(
 	theme: ClioTheme,
 	status: AgentStatus,
 	throughput: TokenThroughputSnapshot | null | undefined,