pi-cockpit 0.7.0 → 0.8.0

package/src/index.ts

@@ -1,12 +1,23 @@
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { readFileSync, statSync } from "node:fs";
+import { getAgentDir, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
 import type { TUI } from "@earendil-works/pi-tui";
 import { Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { AgentsStore, type CompletePayload, type MessagePayload, type StartedPayload } from "./agents-store.ts";
 import { statusText, titleFor, workingMessage, type AmbientState } from "./ambient.ts";
+import { generateTitleWithModel } from "./title-llm.ts";
+import { suggestTitle } from "./title-gen.ts";
 import { BashBgStore } from "./bash-bg-store.ts";
 import { MaestroStore } from "./maestro-store.ts";
 import { createSidebarController, type SidebarController } from "./sidebar-controller.ts";
+import { COCKPIT_SPLIT_PANE_MARKER } from "./split-pane.ts";
+import {
+	COCKPIT_EDITOR_BOTTOM_MARKER,
+	EDITOR_BOTTOM_WIDGET_KEY,
+	createEditorBottomController,
+	createEditorBottomSentinel,
+	type EditorBottomController,
+} from "./editor-bottom.ts";
 import { BashBgOverlay } from "./bash-bg-overlay.ts";
 import { renderBashBgSummary } from "./bash-bg-widget.ts";
 import { registerQuietTools } from "./quiet-tools.ts";
@@ -21,6 +32,10 @@ import { collectExtensionStatuses } from "./extension-status.ts";
 import { ANIMATION_PERIOD_MS, resolveGlyphs, spinFrame } from "./icons.ts";
 import { ensureConfigExists, loadConfig, saveConfig } from "./config.ts";
 import { applyRow, buildRows, rowKeyForAccel, type SaveState } from "./settings-view.ts";
+import { createCockpitSettingsProvider, registerCockpitSettingsProvider } from "./settings/cockpit-provider.ts";
+import { SettingsLocaleState, getMaestroUiPreferencesPath } from "./settings/locale-state.ts";
+import { SettingsProviderRegistry } from "./settings/registry.ts";
+import { showMaestroSettingsShell } from "./settings/settings-shell.ts";
 import {
 	COCKPIT_MAESTRO_QUERY_EVENT,
 	MAESTRO_UI_SNAPSHOT_EVENT,
@@ -47,6 +62,10 @@ const FOOTER_UTILS: WidthUtils = { measure: visibleWidth, clip: truncateToWidth
 const BASH_BG_OVERLAY_KEY = "alt+j";
 const SIDEBAR_RESIZE_KEY = "ctrl+shift+r";
 const COCKPIT_STATUS_KEY = "cockpit";
+// Claude Code title chrome: a static marker when idle, two braille frames while
+// a turn runs (screens/REPL.tsx TITLE_STATIC_PREFIX / TITLE_ANIMATION_FRAMES).
+const TITLE_STATIC = "✳";
+const TITLE_FRAMES = ["⠂", "⠐"];
 const WIDTH_POLL_INTERVAL_MS = 250;
 // Static mode keeps token totals fresh enough without recomputing on every message.
 const USAGE_REFRESH_THROTTLE_MS = 10_000;
@@ -83,6 +102,82 @@ function formatCwd(cwd: string): string {
 	return rel === "" ? "~" : `~${sep}${rel}`;
 }
 
+/**
+ * Cheap synchronous git branch read straight from .git/HEAD — no process spawn,
+ * so it is safe on every title refresh. Returns the branch name, "detached" for
+ * a raw HEAD hash, or null outside a repo (including linked worktrees).
+ */
+function readGitBranch(cwd: string): string | null {
+	let headPath: string | undefined;
+	try {
+		const gitDir = join(cwd, ".git");
+		const st = statSync(gitDir);
+		if (st.isDirectory()) {
+			headPath = join(gitDir, "HEAD");
+		} else if (st.isFile()) {
+			const link = readFileSync(gitDir, "utf8").trim();
+			if (link.startsWith("gitdir:")) {
+				headPath = join(resolve(cwd, link.slice("gitdir:".length).trim()), "HEAD");
+			}
+		}
+		if (!headPath) return null;
+		const head = readFileSync(headPath, "utf8").trim();
+		const branch = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
+		return branch ? branch[1] : "detached";
+	} catch {
+		return null;
+	}
+}
+
+/** Session summary for the title: the session_info name, else the generated
+ * title, else the short id — the Claude Code chain of sessionTitle ?? haikuTitle. */
+function sessionTag(sm: { getSessionName(): string | undefined; getSessionId(): string }, generated: string | undefined): string | undefined {
+	const name = sm.getSessionName();
+	if (name) return name;
+	if (generated) return generated;
+	const id = sm.getSessionId();
+	return id ? id.slice(0, 8) : undefined;
+}
+
+/** Active model short id (drops any "provider/" prefix). */
+function modelTag(model: { id: string } | undefined): string | undefined {
+	if (!model) return undefined;
+	const last = model.id.split("/").at(-1);
+	return last || undefined;
+}
+
+/** Thinking level tag; "off" and unknown values add no noise. */
+function thinkingTag(level: string | undefined): string | undefined {
+	return level === undefined || level === "off" ? undefined : level;
+}
+
+/** Maestro workflow tag: run status when a run is active, else session status. */
+function maestroWorkflowTag(
+	workflow: { run: { status: string } | null; session: { status: string } } | null | undefined,
+): string | undefined {
+	if (!workflow) return undefined;
+	return workflow.run ? workflow.run.status : workflow.session.status;
+}
+
+/** Extract plain text from an agent message (string content or text blocks). */
+function messageText(message: unknown): string | undefined {
+	if (!message || typeof message !== "object") return undefined;
+	const content = (message as { content?: unknown }).content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return undefined;
+	const parts: string[] = [];
+	for (const block of content) {
+		if (
+			block && typeof block === "object"
+			&& (block as { type?: unknown }).type === "text"
+			&& typeof (block as { text?: unknown }).text === "string"
+		) {
+			parts.push((block as { text: string }).text);
+		}
+	}
+	return parts.length > 0 ? parts.join("\n") : undefined;
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null;
 }
@@ -115,14 +210,28 @@ export default function (pi: ExtensionAPI): void {
 	const bashBg = new BashBgStore();
 	const todos = new TodoStore();
 	const maestro = new MaestroStore();
+	const settingsRegistry = new SettingsProviderRegistry({
+		on: (event, handler) => pi.events.on(event, handler),
+		emit: (event, payload) => pi.events.emit(event, payload),
+	});
+	settingsRegistry.start();
+	const settingsLocale = new SettingsLocaleState(getMaestroUiPreferencesPath(getAgentDir()), settingsRegistry);
 	let config: CockpitConfig = structuredClone(DEFAULT_CONFIG);
 	let lastCtx: ExtensionContext | undefined;
+	let settingsCommandCtx: ExtensionCommandContext | undefined;
 	let capturedTui: TUI | undefined;
 	let sidebarController: SidebarController | undefined;
+	let editorBottomController: EditorBottomController | undefined;
 	let dockEffectiveVisible = false;
 	let surfaceState: CockpitSurfaceState = "disabled";
 	let running = false;
 	let runningStartedAt: number | undefined;
+	// Auto-generated session title from the first turn (the rule-based / LLM
+	// stand-in for Claude Code's Haiku title). Cleared per session.
+	let aiTitle: string | undefined;
+	let firstUserText: string | undefined;
+	let titleRequested = false;
+	let titleFrameIndex = 0;
 	const activeTools = new Map<string, { name: string; startedAt: number }>();
 	let tick: ReturnType<typeof setInterval> | undefined;
 	// Persisted rather than toasted: a config that failed to load silently downgrades
@@ -176,6 +285,15 @@ export default function (pi: ExtensionAPI): void {
 
 	// The streaming line, the tab title and the footer status slot are all fed from
 	// the same snapshots the widgets read, so they can never disagree with them.
+	// Leading title glyph: spinner frames while a turn runs (advanced by the
+	// tick), a static marker when idle; static mode freezes it. Failure keeps
+	// its own ✗ and ignores the frame entirely.
+	const titleFrame = (isRunning: boolean): string | undefined => {
+		if (isRunning && !config.staticMode) {
+			return TITLE_FRAMES[titleFrameIndex % TITLE_FRAMES.length];
+		}
+		return TITLE_STATIC;
+	};
 	const refreshAmbient = (): void => {
 		const ctx = lastCtx;
 		if (!ctx || !isTuiContext(ctx)) return;
@@ -187,19 +305,28 @@ export default function (pi: ExtensionAPI): void {
 				return;
 			}
 			const activeTool = [...activeTools.values()].at(-1);
+			const title = config.title;
 			const state: AmbientState = {
 				todos: todos.snapshot(),
 				agents: agents.snapshot(),
 				jobs: bashBg.snapshot(),
 				running,
-				cwd: formatCwd(ctx.sessionManager.getCwd()),
+				cwd: title.showCwd ? formatCwd(ctx.sessionManager.getCwd()) : undefined,
 				activeTool: activeTool?.name,
 				workingStartedAt: activeTool?.startedAt ?? runningStartedAt,
 				hideLiveDuration: config.staticMode,
 				separator: ` ${g.separator} `,
 			};
 			ctx.ui.setWorkingMessage(workingMessage(state));
-			ctx.ui.setTitle(titleFor(state, { ok: g.check, fail: g.cross }, g.separator));
+			if (title.enabled) {
+				state.session = title.showSession ? sessionTag(ctx.sessionManager, aiTitle) : undefined;
+				state.model = title.showModel ? modelTag(ctx.model) : undefined;
+				state.thinking = title.showThinking ? thinkingTag(ctx.thinkingLevel) : undefined;
+				state.gitBranch = title.showGit ? (readGitBranch(ctx.cwd) ?? undefined) : undefined;
+				state.maestro = title.showMaestro ? maestroWorkflowTag(maestro.snapshot()?.workflow) : undefined;
+				state.frame = titleFrame(running);
+				ctx.ui.setTitle(titleFor(state, { ok: g.check, fail: g.cross }, g.separator, { maxLength: title.maxLength }));
+			}
 			ctx.ui.setStatus(COCKPIT_STATUS_KEY, statusText(configProblem, g.blocked));
 		} catch {
 			// ambient surfaces are best-effort; never let them break a render
@@ -243,6 +370,7 @@ export default function (pi: ExtensionAPI): void {
 					agents.snapshot();
 					if (agents.size !== before) req();
 				} else {
+					titleFrameIndex += 1;
 					req();
 				}
 			} else {
@@ -331,6 +459,36 @@ export default function (pi: ExtensionAPI): void {
 		ctx.ui.setWidget(AGENT_WIDGET_KEY, undefined);
 	};
 
+	const ensureEditorBottomController = (ctx: ExtensionContext): EditorBottomController => {
+		if (editorBottomController) return editorBottomController;
+		editorBottomController = createEditorBottomController({
+			onError: (error) => ctx.ui.notify(
+				`Bottom-pinned input disabled: ${error instanceof Error ? error.message : String(error)}`,
+				"warning",
+			),
+		});
+		return editorBottomController;
+	};
+
+	const installEditorBottom = (ctx: ExtensionContext): void => {
+		const controller = ensureEditorBottomController(ctx);
+		ctx.ui.setWidget(
+			EDITOR_BOTTOM_WIDGET_KEY,
+			(tui) => {
+				capturedTui = tui;
+				controller.attach(tui);
+				controller.show();
+				return createEditorBottomSentinel();
+			},
+			{ placement: "aboveEditor" },
+		);
+	};
+
+	const clearEditorBottom = (ctx: ExtensionContext): void => {
+		ctx.ui.setWidget(EDITOR_BOTTOM_WIDGET_KEY, undefined);
+		editorBottomController?.hide();
+	};
+
 	const installWidgets = (ctx: ExtensionContext): void => {
 		ctx.ui.setWidget(
 			STACK_WIDGET_KEY,
@@ -406,6 +564,7 @@ export default function (pi: ExtensionAPI): void {
 
 	const syncSidebarMode = (ctx: ExtensionContext): void => {
 		const controller = ensureSidebarController(ctx);
+		controller.setWidth(config.sidebar.width);
 		if (config.sidebar.mode === "off") {
 			dockEffectiveVisible = false;
 			controller.hide();
@@ -415,10 +574,25 @@ export default function (pi: ExtensionAPI): void {
 		reconcileSurface(ctx);
 	};
 
+	const disposeLayoutControllers = (): void => {
+		const render = capturedTui?.render as (TUI["render"] & Record<symbol, unknown>) | undefined;
+		const editorBottomIsTop = Boolean(render?.[COCKPIT_EDITOR_BOTTOM_MARKER]);
+		const splitPaneIsTop = Boolean(render?.[COCKPIT_SPLIT_PANE_MARKER]);
+		if (editorBottomIsTop && !splitPaneIsTop) {
+			editorBottomController?.dispose();
+			sidebarController?.dispose();
+		} else {
+			sidebarController?.dispose();
+			editorBottomController?.dispose();
+		}
+		sidebarController = undefined;
+		editorBottomController = undefined;
+	};
+
 	const uninstallUi = (ctx: ExtensionContext): void => {
 		dockEffectiveVisible = false;
-		sidebarController?.dispose();
-		sidebarController = undefined;
+		clearEditorBottom(ctx);
+		disposeLayoutControllers();
 		clearWidgets(ctx);
 		ctx.ui.setFooter(undefined);
 		surfaceState = "disabled";
@@ -442,6 +616,8 @@ export default function (pi: ExtensionAPI): void {
 			return;
 		}
 		ctx.ui.setWorkingIndicator({ frames: [] });
+		if (config.pinEditorBottom) installEditorBottom(ctx);
+		else clearEditorBottom(ctx);
 		ctx.ui.setFooter((tui, theme, footerData) => {
 			capturedTui = tui;
 			let observedWidth = tui.terminal.columns;
@@ -521,6 +697,59 @@ export default function (pi: ExtensionAPI): void {
 	};
 
 	// --- teammate lifecycle (custom event bus; subscribed once for the extension lifetime) ---
+	// Session-title generation: after the first turn settles, ask the configured
+	// model (api-manager provider) with the user message + assistant reply, else
+	// fall back to the offline rule-based suggestTitle. A model ref that cannot
+	// be resolved or fails is never fatal — the title just stays rule-based.
+	const generateTitleWithConfiguredModel = async (
+		ctx: ExtensionContext,
+		modelRef: string,
+		text: string,
+	): Promise<string | null> => {
+		const slash = modelRef.indexOf("/");
+		if (slash <= 0 || slash === modelRef.length - 1) return null;
+		const model = ctx.modelRegistry.find(modelRef.slice(0, slash), modelRef.slice(slash + 1));
+		if (!model) return null;
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (!auth.ok) return null;
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), 10_000);
+		try {
+			return await generateTitleWithModel(
+				{ baseUrl: model.baseUrl, modelId: model.id, apiKey: auth.apiKey, headers: auth.headers },
+				text,
+				controller.signal,
+			);
+		} finally {
+			clearTimeout(timer);
+		}
+	};
+	const generateSessionTitle = async (
+		ctx: ExtensionContext,
+		userText: string,
+		assistantMessage: unknown,
+		refresh: () => void,
+	): Promise<void> => {
+		const fallback = suggestTitle(userText);
+		const assistantText = messageText(assistantMessage);
+		const llmInput = assistantText
+			? `${userText}\n\nAssistant:\n${assistantText.slice(0, 500)}`
+			: userText;
+		const modelRef = config.title.generationModel;
+		const title = modelRef
+			? await generateTitleWithConfiguredModel(ctx, modelRef, llmInput)
+			: null;
+		if (title) {
+			aiTitle = title;
+		} else if (fallback) {
+			aiTitle = fallback;
+		} else {
+			titleRequested = false; // nothing usable; a later turn may retry
+			return;
+		}
+		refresh();
+	};
+
 	pi.events.on(TEAMMATE_STARTED_EVENT, (payload) => {
 		if (!isStartedPayload(payload)) return;
 		agents.applyStarted(payload);
@@ -576,6 +805,10 @@ export default function (pi: ExtensionAPI): void {
 		activeTools.clear();
 		thinkingTimer.reset();
 		maestro.clear();
+		aiTitle = undefined;
+		firstUserText = undefined;
+		titleRequested = false;
+		titleFrameIndex = 0;
 		ensureConfigExists();
 		config = loadConfig((m, l) => {
 			try {
@@ -584,6 +817,8 @@ export default function (pi: ExtensionAPI): void {
 				// notify unavailable
 			}
 		});
+		settingsLocale.reload();
+		settingsRegistry.emitLocale(settingsLocale.locale);
 		invalidateUsageCache();
 		// Quiet mode: register compact tool renderers and fold thinking blocks.
 		// Tools are normally registered at extension load time (above) so they
@@ -622,7 +857,18 @@ export default function (pi: ExtensionAPI): void {
 		req();
 	});
 
-	pi.on("session_shutdown", (_e, ctx) => {
+	pi.on("session_shutdown", (e, ctx) => {
+		// Claude Code clears the terminal title on exit (CLEAR_TERMINAL_TITLE) so
+		// the tab does not keep a stale title after the process dies. Only on
+		// quit: reload/new/resume/fork are immediately followed by a new session
+		// that sets its own title, and clearing would flash the tab.
+		if (e.reason === "quit" && lastCtx && isTuiContext(lastCtx) && config.title.enabled) {
+			try {
+				lastCtx.ui.setTitle("");
+			} catch {
+				// mid-teardown: best-effort
+			}
+		}
 		if (lastCtx) uninstallUi(lastCtx);
 		const released: CockpitUiOwnershipV1 = {
 			todo: false,
@@ -681,6 +927,31 @@ export default function (pi: ExtensionAPI): void {
 		invalidateUsageCache();
 		if (isTuiContext(ctx)) req();
 	});
+	pi.on("session_info_changed", (_e, ctx) => {
+		// A session rename (or the /session name set at startup) changes the
+		// session summary the tab title leads with.
+		if (isTuiContext(ctx)) req();
+	});
+	pi.on("thinking_level_select", (_e, ctx) => {
+		if (isTuiContext(ctx)) req();
+	});
+	pi.on("input", (e) => {
+		// Remember the first real user message; the title is generated after the
+		// first turn completes, so it can reflect the whole exchange. Slash
+		// commands and bash-mode inputs are synthetic, not the user's topic.
+		if (!firstUserText && e.source === "interactive" && e.text) {
+			const isSynthetic = e.text.startsWith("/") || e.text.startsWith("!");
+			if (!isSynthetic) firstUserText = e.text;
+		}
+	});
+	pi.on("turn_end", (e, ctx) => {
+		// Claude Code generates its title from the first user message; we wait
+		// for the first turn to settle so the title can reflect what the model
+		// actually did, then ask the configured model (or the rule fallback).
+		if (titleRequested || !firstUserText || !isTuiContext(ctx)) return;
+		titleRequested = true;
+		void generateSessionTitle(ctx, firstUserText, e.message, () => req());
+	});
 
 	const openBashBgOverlay = async (ctx: ExtensionContext): Promise<void> => {
 		if (!ctx.hasUI) return;
@@ -816,6 +1087,53 @@ export default function (pi: ExtensionAPI): void {
 		return result.ok;
 	};
 
+	const cockpitSettingsProvider = createCockpitSettingsProvider({
+		getRuntimeConfig: () => config,
+		applyRuntimeConfig: async (nextConfig, changedKeys) => {
+			const previous = config;
+			config = nextConfig;
+			const ctx = lastCtx;
+			if (!ctx || !isTuiContext(ctx)) return;
+			if (previous.enabled !== nextConfig.enabled) {
+				if (nextConfig.enabled) {
+					publishUiOwnership();
+					applyUi(ctx);
+				} else {
+					uninstallUi(ctx);
+					publishUiOwnership();
+				}
+				return;
+			}
+			if (!nextConfig.enabled) return;
+			if (previous.staticMode !== nextConfig.staticMode) {
+				syncTick();
+				thinkingTimer.syncMode();
+			}
+			if (previous.quietMode !== nextConfig.quietMode) {
+				applyQuietMode(ctx, previous.quietMode, nextConfig.quietMode);
+			}
+			if (previous.pinEditorBottom !== nextConfig.pinEditorBottom) {
+				if (nextConfig.pinEditorBottom) installEditorBottom(ctx);
+				else clearEditorBottom(ctx);
+			}
+			if (changedKeys.some((key) => key.startsWith("sidebar."))) syncSidebarMode(ctx);
+			publishUiOwnership();
+			req();
+		},
+		getThemeName: () => config.theme || undefined,
+		getThinkingFolded: () => lastCtx ? readHideThinkingBlock(lastCtx.cwd) : undefined,
+		openLegacySettings: async () => { if (settingsCommandCtx) await openSettings(settingsCommandCtx); },
+		openThemeSettings: async () => { if (settingsCommandCtx) await openThemePicker(settingsCommandCtx); },
+		toggleThinkingFold: () => {
+			if (!lastCtx) return;
+			ensureThinkingFolded(capturedTui, lastCtx.cwd, !readHideThinkingBlock(lastCtx.cwd));
+		},
+	});
+	registerCockpitSettingsProvider({
+		on: (event, handler) => pi.events.on(event, handler),
+		emit: (event, payload) => pi.events.emit(event, payload),
+	}, cockpitSettingsProvider);
+
 	pi.registerShortcut(BASH_BG_OVERLAY_KEY, {
 		description: "Open background Bash jobs — live status, command, cwd, duration and output tail",
 		async handler(ctx) {
@@ -834,7 +1152,23 @@ export default function (pi: ExtensionAPI): void {
 		},
 	});
 
-	// --- /cockpit: settings plus direct surface controls ---
+	pi.registerCommand("maestro-settings", {
+		description: "Open unified Maestro settings for Cockpit, Flow, Teammate and integrations",
+		async handler(_args, ctx) {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("Maestro settings require interactive TUI mode", "warning");
+				return;
+			}
+			settingsCommandCtx = ctx;
+			try {
+				await showMaestroSettingsShell(ctx, settingsRegistry, settingsLocale);
+			} finally {
+				settingsCommandCtx = undefined;
+			}
+		},
+	});
+
+	// --- /cockpit: legacy settings plus direct surface controls ---
 	pi.registerCommand("cockpit", {
 		description: "Open pi-cockpit settings; /cockpit sidebar controls the dock, /cockpit bg shows jobs",
 		getArgumentCompletions: (prefix) => {
@@ -946,6 +1280,7 @@ export default function (pi: ExtensionAPI): void {
 				const wasEnabled = config.enabled;
 				const wasQuiet = config.quietMode;
 				const wasStatic = config.staticMode;
+				const wasPinEditorBottom = config.pinEditorBottom;
 				const wasSidebarMode = config.sidebar.mode;
 				if (key === "theme") {
 					// Delegate: the picker previews live and reverts on Esc, neither of
@@ -989,7 +1324,12 @@ export default function (pi: ExtensionAPI): void {
 						publishUiOwnership();
 					}
 				} else {
-					if (config.enabled && wasSidebarMode !== config.sidebar.mode) syncSidebarMode(ctx);
+					if (config.enabled && wasPinEditorBottom !== config.pinEditorBottom) {
+						if (config.pinEditorBottom) installEditorBottom(ctx);
+						else clearEditorBottom(ctx);
+					} else if (config.enabled && wasSidebarMode !== config.sidebar.mode) {
+						syncSidebarMode(ctx);
+					}
 					publishUiOwnership();
 				}
 				if (wasQuiet !== config.quietMode) {

package/src/render.ts

@@ -285,6 +285,14 @@ export function renderAgents(
 			{ text: theme.fg(status.color, status.glyph), priority: 99, clippable: false },
 		];
 		if (status.label) segs.push({ text: theme.fg(status.color, status.label), priority: 95, clippable: false });
+		if (r.phase) segs.push({ text: theme.fg("dim", r.phase), priority: 92, minWidth: 6 });
+		if (r.lastOutcome?.status === "failed") {
+			segs.push({
+				text: theme.fg("error", r.lastOutcome.message ? `last failed: ${r.lastOutcome.message}` : "last failed"),
+				priority: 91,
+				minWidth: 8,
+			});
+		}
 		segs.push({ text: theme.fg(rc, r.role), priority: 90 });
 		if (r.task) segs.push({ text: r.task, priority: 80, minWidth: 6 });
 		const live = r.status === "running" || r.status === "retrying";
@@ -299,9 +307,17 @@ export function renderAgents(
 		if (r.tail) segs.push({ text: theme.fg("dim", r.tail), priority: 40, minWidth: 8 });
 		const model = r.resolvedModel ?? r.requestedModel;
 		if (model) {
-			const fallback = r.requestedModel && r.resolvedModel && r.requestedModel !== r.resolvedModel;
+			const resolved = r.resolvedModel ?? "";
+			const requested = r.requestedModel ?? "";
+			const baseName = (id: string): string => id.slice(id.lastIndexOf("/") + 1);
+			const both = requested !== "" && resolved !== "" && requested !== resolved;
+			// Same underlying model written in two id formats (e.g. provider/model vs
+			// bare model) is not a fallback; only differing base names are.
+			const formatOnly = both && baseName(requested) === baseName(resolved);
+			const fallback = both && !formatOnly;
+			const displayModel = formatOnly ? (resolved.includes("/") ? resolved : requested) : model;
 			segs.push({
-				text: theme.fg(fallback ? "warning" : "muted", fallback ? `model ${r.requestedModel}→${r.resolvedModel}` : `model ${model}`),
+				text: theme.fg(fallback ? "warning" : "muted", fallback ? `model ${requested}→${resolved}` : `model ${displayModel}`),
 				priority: 25,
 				minWidth: 8,
 			});