@iowarp/clio-coder 0.4.0 → 0.4.1

package/src/interactive/editor-submit.ts

@@ -6,7 +6,7 @@ import type { SessionContract, SessionEntry } from "../domains/session/index.js"
 import { toolPresentationPolicy } from "../tools/presentation.js";
 import type { ChatLoop } from "./chat-loop.js";
 import type { ChatPanel } from "./chat-panel.js";
-import { bashExecutionEntryInput, parseEditorBashCommand } from "./editor-bash.js";
+import { bashExecutionEntryInput, parseEditorBashCommand, unguardPastedEditorOperator } from "./editor-bash.js";
 import {
 	formatSteerCandidates,
 	parseEditorSteerMention,
@@ -57,6 +57,8 @@ export interface EditorSubmitExpansion {
 
 export interface EditorSubmitEditor {
 	getText(): string;
+	/** Draft spelling for an immediate send, including any editor provenance envelope. */
+	getTextForSubmit(): string;
 	setText(text: string): void;
 	addToHistory(text: string): void;
 }
@@ -318,18 +320,19 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 		submitEditorSteerMention(mention) !== "unhandled";
 
 	const submitEditorText = (text: string): void => {
-		const trimmed = text.trim();
+		const literalText = unguardPastedEditorOperator(text);
+		const trimmed = literalText.trim();
 		if (trimmed.length === 0) return;
 		deps.collapseLaunchpadBeforeSubmit?.();
 		if (parseEditorBashCommand(text)) {
 			if (!deps.chat.isStreaming() && !activeEditorBash) {
-				deps.editor.addToHistory(text);
+				deps.editor.addToHistory(literalText);
 				deps.editor.setText("");
 			} else {
 				// Pi Editor clears the buffer before invoking onSubmit. A command
 				// refused by either admission guard is still a draft, so put it back
 				// for the operator instead of silently discarding it.
-				deps.editor.setText(text);
+				deps.editor.setText(literalText);
 			}
 			if (runEditorBash(text)) deps.ui.requestRender();
 			return;
@@ -339,12 +342,12 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			const submission = submitEditorSteerMention(steerMention);
 			if (submission !== "unhandled") {
 				if (submission === "accepted") {
-					deps.editor.addToHistory(text);
+					deps.editor.addToHistory(literalText);
 					deps.editor.setText("");
 				} else {
 					// Resolution and dispatch failures are correctable rejections. Pi
 					// has already cleared the editor, so explicitly restore the draft.
-					deps.editor.setText(text);
+					deps.editor.setText(literalText);
 				}
 				deps.ui.requestRender();
 				return;
@@ -352,18 +355,18 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 		}
 		const command = parseSlashCommand(trimmed);
 		if (isRejectedCommand(command)) {
-			deps.editor.setText(text);
+			deps.editor.setText(literalText);
 			deps.dispatchCommand(trimmed);
 		} else if (command.kind === "unknown-command") {
 			const result = deps.dispatchCommand(trimmed);
 			if (result === "rejected") {
-				deps.editor.setText(text);
+				deps.editor.setText(literalText);
 			} else {
-				deps.editor.addToHistory(text);
+				deps.editor.addToHistory(literalText);
 				deps.editor.setText("");
 			}
 		} else {
-			deps.editor.addToHistory(text);
+			deps.editor.addToHistory(literalText);
 			deps.editor.setText("");
 			deps.dispatchCommand(trimmed);
 		}
@@ -388,7 +391,8 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 	};
 
 	const admitCapturedText = async (text: string, signal?: AbortSignal): Promise<void> => {
-		const trimmed = text.trim();
+		const literalText = unguardPastedEditorOperator(text);
+		const trimmed = literalText.trim();
 		if (trimmed.length === 0) return;
 		signal?.throwIfAborted();
 		deps.collapseLaunchpadBeforeSubmit?.();
@@ -396,7 +400,7 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			while (deps.chat.isStreaming()) await awaitWithAbort(deps.chat.whenSettled(), signal);
 			while (activeEditorBashSettlement) await awaitWithAbort(activeEditorBashSettlement, signal);
 			signal?.throwIfAborted();
-			deps.editor.addToHistory(text);
+			deps.editor.addToHistory(literalText);
 			runEditorBash(text);
 			deps.ui.requestRender();
 			return;
@@ -408,7 +412,7 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 				if (submission === "rejected") {
 					throw new Error("queued boot steer was not admitted; preserving it for recovery");
 				}
-				deps.editor.addToHistory(text);
+				deps.editor.addToHistory(literalText);
 				deps.ui.requestRender();
 				return;
 			}
@@ -421,7 +425,7 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			deps.ui.requestRender();
 			throw new Error("queued boot command needs correction; preserving it for recovery");
 		}
-		deps.editor.addToHistory(text);
+		deps.editor.addToHistory(literalText);
 		signal?.throwIfAborted();
 		if (deps.dispatchCommandAsync) await deps.dispatchCommandAsync(trimmed, signal);
 		else deps.dispatchCommand(trimmed);
@@ -429,9 +433,10 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 	};
 
 	const queueFollowUpFromEditor = (): void => {
-		const text = deps.editor.getText().trim();
+		const streaming = deps.chat.isStreaming();
+		const text = (streaming ? deps.editor.getText() : deps.editor.getTextForSubmit()).trim();
 		if (text.length === 0) return;
-		if (!deps.chat.isStreaming()) {
+		if (!streaming) {
 			deps.editor.setText("");
 			submitEditorText(text);
 			deps.ui.requestRender();
@@ -458,9 +463,10 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 	};
 
 	const interruptFromEditor = (): void => {
-		const text = deps.editor.getText().trim();
+		const streaming = deps.chat.isStreaming();
+		const text = (streaming ? deps.editor.getText() : deps.editor.getTextForSubmit()).trim();
 		if (text.length === 0) return;
-		if (!deps.chat.isStreaming()) {
+		if (!streaming) {
 			deps.editor.setText("");
 			submitEditorText(text);
 			deps.ui.requestRender();

package/src/interactive/external-editor.ts

@@ -50,7 +50,7 @@ export function resolveExternalEditor(
 
 export function editTextExternally(initialText: string, command: string | null): ExternalEditResult {
 	if (!command) return { ok: false, error: "no external editor configured; set VISUAL or EDITOR" };
-	const tmpFile = join(tmpdir(), `clio-editor-${process.pid}-${randomUUID()}.md`);
+	const tmpFile = join(tmpdir(), `clio-coder-editor-${process.pid}-${randomUUID()}.md`);
 	try {
 		writeFileSync(tmpFile, initialText, "utf8");
 		const result = runEditor(command, tmpFile);

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`;