@gajae-code/coding-agent 0.15.6 → 0.16.0

package/src/modes/components/footer.ts

@@ -9,6 +9,7 @@ import * as git from "../../utils/git";
 import { sanitizeStatusText } from "../shared";
 import { getContextUsageLevel, getContextUsageThemeColor } from "./status-line/context-thresholds";
 import { resolveCurrentBranch } from "./status-line/git-utils";
+import { shortenModelId } from "./status-line/model-name";
 
 /**
  * Footer component that shows pwd, token stats, and context usage
@@ -191,8 +192,9 @@ export class FooterComponent implements Component {
 
 		let statsLeft = statsParts.join(" ");
 
-		// Add model name on the right side, plus thinking level if model supports it
-		const modelName = state.model?.id || "no-model";
+		// Add model name on the right side, plus thinking level if model supports it.
+		// Same shortest-recognizable form the status rail renders.
+		const modelName = shortenModelId(state.model?.id ?? state.model?.name);
 
 		// Add thinking level hint when the current model advertises supported efforts
 		let rightSide = modelName;

package/src/modes/components/frictionless-onboarding-selector.ts

@@ -1,9 +1,55 @@
-import { Container, matchesKey, Spacer, TruncatedText } from "@gajae-code/tui";
+import { Container, matchesKey, type SelectItem, SelectList, Spacer, TruncatedText } from "@gajae-code/tui";
 import type { OnboardingProfile } from "../../setup/frictionless-onboarding";
-import { theme } from "../theme/theme";
+import { getSelectListTheme, theme } from "../theme/theme";
+import { UI_LANGUAGES, type UiLanguage } from "../ui-language";
 import { matchesSelectCancel } from "../utils/keybinding-matchers";
 import { DynamicBorder } from "./dynamic-border";
 
+export const UI_LANGUAGE_CHOICES: readonly { value: UiLanguage; label: string }[] = [
+	{ value: "en", label: "English" },
+	{ value: "ko", label: "한국어" },
+	{ value: "zh", label: "简体中文" },
+	{ value: "ja", label: "日本語" },
+];
+
+export class InterfaceLanguageSelectorComponent extends Container {
+	readonly #selectList: SelectList;
+
+	constructor(onSelect: (language: UiLanguage) => void, onCancel: () => void) {
+		super();
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+		this.addChild(
+			new TruncatedText(
+				theme.bold(
+					"Choose your interface language / 언어를 선택하세요 / 选择界面语言 / インターフェース言語を選択",
+				),
+			),
+		);
+		this.addChild(new Spacer(1));
+		const items: SelectItem[] = UI_LANGUAGE_CHOICES.map(choice => ({ value: choice.value, label: choice.label }));
+		this.#selectList = new SelectList(items, items.length, getSelectListTheme());
+		this.#selectList.onSelect = item => {
+			if (UI_LANGUAGES.includes(item.value as UiLanguage)) onSelect(item.value as UiLanguage);
+		};
+		this.#selectList.onCancel = onCancel;
+		this.addChild(this.#selectList);
+		this.addChild(new Spacer(1));
+		this.addChild(new TruncatedText(theme.fg("dim", "↑/↓ select · Enter choose · Esc use English")));
+		this.addChild(new DynamicBorder());
+	}
+
+	handleInput(keyData: string): void {
+		// The app.exit action is owned by the parent editor and is not a TUI
+		// selector key id. Ctrl-D is its default byte when the editor is empty.
+		if (keyData === "\x04") {
+			this.#selectList.onCancel?.();
+			return;
+		}
+		this.#selectList.handleInput(keyData);
+	}
+}
+
 export type FrictionlessOnboardingAction =
 	| "analyze"
 	| "apply"

package/src/modes/components/oauth-selector.ts

@@ -56,6 +56,7 @@ export class OAuthSelectorComponent extends Container {
 	#onCancelCallback: () => void;
 	#statusMessage: string | undefined;
 	#validateAuthCallback?: (providerId: string) => Promise<boolean>;
+	#onValidationError?: (error: unknown) => boolean;
 	#requestRenderCallback?: () => void;
 	#authState: Map<string, "checking" | "valid" | "invalid"> = new Map();
 	#externalCredentialCandidates: ImportableCredential[] = [];
@@ -76,6 +77,7 @@ export class OAuthSelectorComponent extends Container {
 		onCancel: () => void,
 		options?: {
 			validateAuth?: (providerId: string) => Promise<boolean>;
+			onValidationError?: (error: unknown) => boolean;
 			requestRender?: () => void;
 			externalCredentialCandidates?: ImportableCredential[];
 		} & Partial<OAuthSelectorAccountOptions>,
@@ -86,6 +88,7 @@ export class OAuthSelectorComponent extends Container {
 		this.#onSelectCallback = onSelect;
 		this.#onCancelCallback = onCancel;
 		this.#validateAuthCallback = options?.validateAuth;
+		this.#onValidationError = options?.onValidationError;
 		this.#requestRenderCallback = options?.requestRender;
 		this.#externalCredentialCandidates = options?.externalCredentialCandidates ?? [];
 		this.#accountProviderId = options?.accountProviderId;
@@ -194,7 +197,9 @@ export class OAuthSelectorComponent extends Container {
 		let isValid = false;
 		try {
 			isValid = await this.#validateAuthCallback(providerId);
-		} catch {
+		} catch (error) {
+			if (generation !== this.#validationGeneration) return;
+			if (this.#onValidationError?.(error)) return;
 			isValid = false;
 		}
 		if (generation !== this.#validationGeneration) return;

package/src/modes/components/settings-selector.ts

@@ -1009,6 +1009,7 @@ export class SettingsSelectorComponent extends Container {
 			options = [
 				{ value: "en", label: uiString(language, "settings.language.english") },
 				{ value: "ko", label: uiString(language, "settings.language.korean") },
+				{ value: "zh", label: uiString(language, "settings.language.chinese") },
 				{ value: "ja", label: uiString(language, "settings.language.japanese") },
 			];
 		}

package/src/modes/components/status-line/model-name.ts

@@ -0,0 +1,53 @@
+/**
+ * Shortest recognizable model label, derived purely from the model id.
+ *
+ * The rail and the footer both render this form, so a narrow terminal spends
+ * its cells on the part of the id that actually identifies the model:
+ *
+ *   `anthropic/claude-sonnet-4-5-20250929` -> `sonnet-4.5`
+ *   `openai/gpt-4o-2024-05-13`             -> `gpt-4o`
+ *   `google/gemini-3-pro`                  -> `gemini-3-pro`
+ *   `qwen2.5:7b`                           -> `qwen2.5:7b`
+ *
+ * Deliberately a pure heuristic with no curated override table: every provider
+ * in `models.json` must degrade sanely without per-model maintenance. The
+ * function never returns an empty string — an id that the heuristic would
+ * strip to nothing falls back to the previous, longer form.
+ */
+
+/**
+ * Vendor family words that carry no information once the provider prefix is
+ * gone. Deliberately minimal: `gpt` and `gemini` are part of how those models
+ * are named and are kept.
+ */
+const VENDOR_FAMILY_WORDS: ReadonlySet<string> = new Set(["claude"]);
+
+/** Trailing snapshot dates and build stamps: `-20250929`, `-2024-05-13`, `-v2`. */
+const DATE_OR_BUILD_SUFFIX = /-(?:\d{4}-\d{2}-\d{2}|\d{8}|\d{6}|v\d+(?:\.\d+)*)$/;
+
+/** Split version parts read as one number: `sonnet-4-5` -> `sonnet-4.5`. */
+const SPLIT_VERSION = /(\d)-(\d)/g;
+
+export const NO_MODEL_LABEL = "no-model";
+
+export function shortenModelId(rawId: string | undefined | null): string {
+	const raw = (rawId ?? "").trim();
+	if (!raw) return NO_MODEL_LABEL;
+
+	// Provider prefix: `anthropic/claude-…`, `openrouter/anthropic/claude-…`.
+	const afterProvider = raw.slice(raw.lastIndexOf("/") + 1).trim() || raw;
+
+	const withoutDate = afterProvider.replace(DATE_OR_BUILD_SUFFIX, "") || afterProvider;
+
+	let name = withoutDate;
+	const dashIndex = name.indexOf("-");
+	if (dashIndex > 0) {
+		const head = name.slice(0, dashIndex).toLowerCase();
+		const rest = name.slice(dashIndex + 1);
+		if (rest && VENDOR_FAMILY_WORDS.has(head)) name = rest;
+	}
+
+	name = name.replace(SPLIT_VERSION, "$1.$2");
+
+	return name || withoutDate || afterProvider;
+}

package/src/modes/components/status-line/priority-row.ts

@@ -0,0 +1,107 @@
+/**
+ * Narrow-width survival row for the status rail.
+ *
+ * The rail evicts segments continuously as the terminal narrows. Without this
+ * row the last thing left at very small widths is the `…+N` overflow marker —
+ * the three things a user actually needs (how much context is left, whether a
+ * goal is running, which model is answering) are exactly what the generic
+ * eviction throws away first or last by accident.
+ *
+ * This row keeps them, in priority order, by stepping each item down its own
+ * ladder instead of dropping it:
+ *
+ *   full form -> shortened form -> single glyph -> dropped
+ *
+ * Context % is never dropped and is the last survivor; the model name is
+ * dropped first of the three. The row is rendered as bare colored text with no
+ * group padding or end caps, so — like the overflow marker — it can survive at
+ * widths where a normal segment group cannot.
+ */
+
+import { visibleWidth } from "@gajae-code/tui";
+import { formatNumber } from "@gajae-code/utils";
+import { theme } from "../../theme/theme";
+import { getContextUsageLevel, getContextUsageThemeColor } from "./context-thresholds";
+import { shortenModelId } from "./model-name";
+import { goalStatusDisplay } from "./segments";
+import type { SegmentContext } from "./types";
+
+const SEPARATOR = "·";
+
+/** Which priority items the active layout is supposed to be carrying. */
+export interface PriorityItemSet {
+	context: boolean;
+	goal: boolean;
+	model: boolean;
+}
+
+function contextForms(ctx: SegmentContext): { full: string; short: string } | null {
+	const window = ctx.contextWindow;
+	if (!(window > 0)) return null;
+
+	const raw = ctx.contextPercent;
+	const pct = typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+	const color = pct === null ? "statusLineContext" : getContextUsageThemeColor(getContextUsageLevel(pct, window));
+
+	return {
+		full: theme.fg(color, `${pct === null ? "?" : `${pct.toFixed(1)}%`}/${formatNumber(window)}`),
+		short: theme.fg(color, pct === null ? "?" : `${Math.round(pct)}%`),
+	};
+}
+
+function goalForms(ctx: SegmentContext): { label: string; glyph: string } | null {
+	const display = goalStatusDisplay(ctx);
+	if (!display) return null;
+
+	const glyph = display.icon || "G";
+	return {
+		label: theme.fg(display.color, display.icon ? `${display.icon} Goal` : "Goal"),
+		glyph: theme.fg(display.color, glyph),
+	};
+}
+
+function modelForms(ctx: SegmentContext): { short: string; glyph: string } {
+	const model = ctx.session.state.model;
+	const name = shortenModelId(model?.id ?? model?.name);
+	return {
+		short: theme.fg("statusLineModel", name),
+		glyph: theme.fg("statusLineModel", theme.icon.model || name.slice(0, 1)),
+	};
+}
+
+/**
+ * Widest priority row that fits `width`, or null when even the minimal form
+ * cannot fit (callers then fall back to the overflow marker).
+ *
+ * Returns null when neither context nor goal is available: the model name alone
+ * is the lowest-priority item and never justifies replacing the normal rail.
+ */
+export function buildPriorityRow(ctx: SegmentContext, width: number, include: PriorityItemSet): string | null {
+	if (width <= 0) return null;
+
+	const context = include.context ? contextForms(ctx) : null;
+	const goal = include.goal ? goalForms(ctx) : null;
+	const model = include.model ? modelForms(ctx) : null;
+	if (!context && !goal) return null;
+
+	// Ordered widest-first. Every item degrades through its own forms before any
+	// item is dropped, and drops run lowest-priority first (model, then goal).
+	const ladder: readonly (readonly (string | null)[])[] = [
+		[context?.full ?? null, goal?.label ?? null, model?.short ?? null],
+		[context?.full ?? null, goal?.glyph ?? null, model?.short ?? null],
+		[context?.full ?? null, goal?.glyph ?? null, model?.glyph ?? null],
+		[context?.short ?? null, goal?.glyph ?? null, model?.glyph ?? null],
+		[context?.short ?? null, goal?.glyph ?? null, null],
+		[context?.short ?? null, null, null],
+	];
+
+	const separator = theme.fg("dim", SEPARATOR);
+	for (const candidate of ladder) {
+		const parts = candidate.filter((part): part is string => part !== null);
+		if (parts.length === 0) continue;
+		const row = parts.join(separator);
+		if (visibleWidth(row) <= width) return row;
+	}
+
+	return null;
+}

package/src/modes/components/status-line/segments.ts

@@ -8,6 +8,7 @@ import { shortenPath } from "../../../tools/render-utils";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../../../utils/session-color";
 import { sanitizeStatusText } from "../../shared";
 import { getContextUsageLevel, getContextUsageThemeColor } from "./context-thresholds";
+import { shortenModelId } from "./model-name";
 import type { RenderedSegment, SegmentContext, StatusLineSegment, StatusLineSegmentId } from "./types";
 
 export type { SegmentContext } from "./types";
@@ -99,10 +100,10 @@ const modelSegment: StatusLineSegment = {
 		const state = ctx.session.state;
 		const opts = ctx.options.model ?? {};
 
-		let modelName = state.model?.name || state.model?.id || "no-model";
-		if (modelName.startsWith("Claude ")) {
-			modelName = modelName.slice(7);
-		}
+		// Shortest recognizable id-derived form (`sonnet-4.5`), the same label the
+		// footer renders, so a narrow rail never spends cells on a provider prefix
+		// or a snapshot date.
+		const modelName = shortenModelId(state.model?.id ?? state.model?.name);
 
 		let content = withIcon(theme.icon.model, modelName);
 
@@ -148,9 +149,16 @@ function formatGoalUsage(current: number): string {
 	return used;
 }
 
-function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: boolean }): RenderedSegment {
-	const goal = ctx.session.getGoalModeState()?.goal;
-	const status = goal?.status ?? (mode.paused ? "paused" : "active");
+/**
+ * Icon and color for the active goal indicator, or null when goal mode is not
+ * showing. Shared with the narrow-width priority row so the compact glyph keeps
+ * the same status color as the full label.
+ */
+export function goalStatusDisplay(ctx: SegmentContext): { icon: string; color: ThemeColor } | null {
+	const mode = ctx.goalMode;
+	if (!mode || (!mode.enabled && !mode.paused)) return null;
+
+	const status = ctx.session.getGoalModeState?.()?.goal?.status ?? (mode.paused ? "paused" : "active");
 
 	let icon: string = theme.icon.goal;
 	let color: ThemeColor = "accent";
@@ -170,13 +178,19 @@ function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: b
 		default:
 			break;
 	}
+	return { icon, color };
+}
+
+function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: boolean }): RenderedSegment {
+	const display = goalStatusDisplay(ctx) ?? { icon: theme.icon.goal, color: "accent" as ThemeColor };
+	const goal = ctx.session.getGoalModeState?.()?.goal;
 
-	const parts: string[] = [withIcon(icon, "Goal")];
+	const parts: string[] = [withIcon(display.icon, "Goal")];
 	const showUsage = ctx.session.settings.get("goal.statusInFooter") === true;
 	if (showUsage && goal) {
 		parts.push(formatGoalUsage(goal.tokensUsed));
 	}
-	return { content: theme.fg(color, parts.join(" ")), visible: true };
+	return { content: theme.fg(display.color, parts.join(" ")), visible: mode.enabled || mode.paused };
 }
 
 const modeSegment: StatusLineSegment = {

package/src/modes/components/tool-status-header.ts

@@ -28,6 +28,7 @@ import {
 	resolveCurrentBranch,
 } from "./status-line/git-utils";
 import { getPreset } from "./status-line/presets";
+import { buildPriorityRow, type PriorityItemSet } from "./status-line/priority-row";
 import { renderSegment, type SegmentContext } from "./status-line/segments";
 import { getSeparator } from "./status-line/separators";
 import { calculateTokensPerSecond } from "./status-line/token-rate";
@@ -132,6 +133,8 @@ interface CollectedStatusSegments {
 	left: string[];
 	leftSegIds: StatusLineSegmentId[];
 	right: string[];
+	/** Parallel to `right`; null for action hints, job counts and the version tag. */
+	rightSegIds: (StatusLineSegmentId | null)[];
 	previewHighlightSegment: StatusLineSegmentId | undefined;
 	sessionAccent: boolean | undefined;
 	leftSepWidth: number;
@@ -819,6 +822,7 @@ export class StatusLineComponent implements Component {
 		}
 
 		const right: string[] = [];
+		const rightSegIds: (StatusLineSegmentId | null)[] = [];
 		const actionHints =
 			effectiveSettings.showActionHints === false
 				? []
@@ -833,9 +837,13 @@ export class StatusLineComponent implements Component {
 			const rendered = renderSegment(segId, ctx);
 			if (rendered.visible && rendered.content) {
 				right.push(highlightSegment(segId, rendered.content));
+				rightSegIds.push(segId);
 			}
 		}
-		right.push(...actionHints.map(hint => hint.content));
+		for (const hint of actionHints) {
+			right.push(hint.content);
+			rightSegIds.push(null);
+		}
 
 		const runningBackgroundJobs =
 			this.session.getAsyncJobSnapshot()?.running.filter(job => job.metadata?.monitor !== true).length ?? 0;
@@ -843,9 +851,11 @@ export class StatusLineComponent implements Component {
 			const icon = theme.icon.agents ? `${theme.icon.agents} ` : "";
 			const label = `${formatCount("job", runningBackgroundJobs)} running`;
 			right.push(theme.fg("statusLineSubagents", `${icon}${label}`));
+			rightSegIds.push(null);
 		}
 		if (this.#version) {
 			right.push(theme.fg("dim", `v${this.#version}`));
+			rightSegIds.push(null);
 		}
 
 		return {
@@ -857,6 +867,7 @@ export class StatusLineComponent implements Component {
 			left,
 			leftSegIds,
 			right,
+			rightSegIds,
 			previewHighlightSegment,
 			sessionAccent: effectiveSettings.sessionAccent,
 			leftSepWidth: visibleWidth(separatorDef.left),
@@ -872,22 +883,108 @@ export class StatusLineComponent implements Component {
 		return Math.max(1, Math.min(3, Math.trunc(raw)));
 	}
 
+	/**
+	 * Which priority items this layout is carrying, and where.
+	 *
+	 * Context % has no segment of its own in most presets — it rides inside the
+	 * `model` segment — so `model` inherits the context rank whenever it does.
+	 * Items whose data is absent (no context window, no active goal) carry no
+	 * priority at all, which keeps a rail with nothing to protect evicting
+	 * exactly as it always did.
+	 */
+	#priorityItems(seg: CollectedStatusSegments): {
+		include: PriorityItemSet;
+		inlineContextPct: boolean;
+	} {
+		const collected = (id: StatusLineSegmentId): boolean =>
+			seg.leftSegIds.includes(id) || seg.rightSegIds.includes(id);
+		const inlineContextPct =
+			seg.ctx.options.model?.showContextPercent !== false && seg.ctx.contextPctSegmentActive !== true;
+		const goalMode = seg.ctx.goalMode;
+
+		return {
+			inlineContextPct,
+			include: {
+				context:
+					seg.ctx.contextWindow > 0 && (collected("context_pct") || (collected("model") && inlineContextPct)),
+				goal: collected("mode") && goalMode !== null && (goalMode.enabled || goalMode.paused),
+				model: collected("model"),
+			},
+		};
+	}
+
+	/**
+	 * Eviction rank: 0 is ordinary telemetry and goes first, 3 is context % and
+	 * goes last. The model name outranks telemetry but loses to the goal
+	 * indicator, matching context % > goal > model.
+	 */
+	#priorityRanker(seg: CollectedStatusSegments): (id: StatusLineSegmentId | null) => number {
+		const { include, inlineContextPct } = this.#priorityItems(seg);
+		const anyPriority = include.context || include.goal;
+
+		return (id: StatusLineSegmentId | null): number => {
+			if (id === null || !anyPriority) return 0;
+			if (id === "context_pct") return include.context ? 3 : 0;
+			if (id === "model") {
+				if (include.context && inlineContextPct) return 3;
+				return include.model ? 1 : 0;
+			}
+			if (id === "mode") return include.goal ? 2 : 0;
+			return 0;
+		};
+	}
+
+	/**
+	 * Priority row for a layout that could not keep everything the user needs on
+	 * screen, or null when the normal rail already carries context %, the goal
+	 * indicator and the model name.
+	 *
+	 * Context % has no segment of its own in most presets — it rides inside the
+	 * `model` segment — so losing `model` silently loses the highest-priority
+	 * item too. Survival is therefore resolved per item, not per segment.
+	 */
+	#priorityRowFor(
+		seg: CollectedStatusSegments,
+		survivingLeftIds: readonly (StatusLineSegmentId | null)[],
+		survivingRightIds: readonly (StatusLineSegmentId | null)[],
+		width: number,
+	): string | null {
+		const survived = (id: StatusLineSegmentId): boolean =>
+			survivingLeftIds.includes(id) || survivingRightIds.includes(id);
+
+		const { include, inlineContextPct } = this.#priorityItems(seg);
+		if (!include.context && !include.goal) return null;
+
+		const contextLost = include.context && !survived("context_pct") && !(inlineContextPct && survived("model"));
+		const goalLost = include.goal && !survived("mode");
+		const modelLost = include.model && !survived("model");
+		if (!contextLost && !goalLost && !modelLost) return null;
+
+		return buildPriorityRow(seg.ctx, width, include);
+	}
+
 	#buildStatusLine(width: number, precollected?: CollectedStatusSegments): string {
 		const seg = precollected ?? this.#collectStatusSegments(width, this.#resolveSettings());
 		const { ctx, separatorDef, bgAnsi, fgAnsi, sepAnsi, previewHighlightSegment } = seg;
 		const { leftSepWidth, rightSepWidth, leftCapWidth, rightCapWidth } = seg;
 		const topFillWidth = Math.max(0, width);
 
+		const rank = this.#priorityRanker(seg);
+
 		/**
-		 * Evict against `budget` using the existing configured-order semantics
-		 * (shrink path, then pop right, then pop left) and report how many
-		 * segments were dropped. Runs from the original segment lists each time so
-		 * the marker reservation can be recomputed without compounding evictions.
+		 * Evict against `budget`: shrink the path first, then drop the
+		 * lowest-priority segment still standing — right side before left, tail
+		 * first within a side, which is the historical order for everything that
+		 * carries no priority. Context %, the goal indicator and the model name
+		 * outrank ordinary telemetry and are therefore the last to go. Runs from
+		 * the original segment lists each time so the marker reservation can be
+		 * recomputed without compounding evictions.
 		 */
 		const layout = (budget: number) => {
 			const left = [...seg.left];
 			const leftIds = [...seg.leftSegIds];
 			const right = [...seg.right];
+			const rightIds = [...seg.rightSegIds];
 			let leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
 			let rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
 			const totalWidth = () => leftWidth + rightWidth + (left.length > 0 && right.length > 0 ? 1 : 0);
@@ -905,19 +1002,42 @@ export class StatusLineComponent implements Component {
 						leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
 					}
 				}
-				while (totalWidth() > budget && right.length > 0) {
-					right.pop();
-					dropped += 1;
-					rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
-				}
-				while (totalWidth() > budget && left.length > 0) {
-					left.pop();
-					leftIds.pop();
+				// Lowest rank loses first; equal ranks fall back to the historical
+				// right-then-left, tail-first order.
+				while (totalWidth() > budget && (left.length > 0 || right.length > 0)) {
+					let victimSide: "left" | "right" | null = null;
+					let victimIndex = -1;
+					let victimRank = Number.POSITIVE_INFINITY;
+					for (let index = right.length - 1; index >= 0; index -= 1) {
+						const candidate = rank(rightIds[index]);
+						if (candidate < victimRank) {
+							victimRank = candidate;
+							victimSide = "right";
+							victimIndex = index;
+						}
+					}
+					for (let index = left.length - 1; index >= 0; index -= 1) {
+						const candidate = rank(leftIds[index]);
+						if (candidate < victimRank) {
+							victimRank = candidate;
+							victimSide = "left";
+							victimIndex = index;
+						}
+					}
+					if (victimSide === null) break;
+					if (victimSide === "right") {
+						right.splice(victimIndex, 1);
+						rightIds.splice(victimIndex, 1);
+						rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
+					} else {
+						left.splice(victimIndex, 1);
+						leftIds.splice(victimIndex, 1);
+						leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
+					}
 					dropped += 1;
-					leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
 				}
 			}
-			return { left, right, leftWidth, rightWidth, dropped };
+			return { left, right, leftIds, rightIds, leftWidth, rightWidth, dropped };
 		};
 
 		// First pass with the full budget establishes whether anything is lost at
@@ -939,6 +1059,11 @@ export class StatusLineComponent implements Component {
 			}
 		}
 		const marker = this.#renderOverflowMarker(placed.dropped, reserved);
+		// Nothing survived that the user actually needs? Spend the rail on the
+		// priority row instead of an overflow marker. Suppressing the marker here
+		// is deliberate: at these widths its cells are worth more as context %.
+		const priorityRow = this.#priorityRowFor(seg, placed.leftIds, placed.rightIds, topFillWidth);
+		if (priorityRow !== null) return priorityRow;
 
 		const leftGroup = this.#renderStatusGroup(placed.left, "left", separatorDef, bgAnsi, fgAnsi, sepAnsi);
 		const rightGroup = this.#renderStatusGroup(placed.right, "right", separatorDef, bgAnsi, fgAnsi, sepAnsi);
@@ -1078,6 +1203,17 @@ export class StatusLineComponent implements Component {
 				if (row.length === 0) packedRows.splice(index, 1);
 			}
 
+			// Wrapping is supposed to be the lossless path. When even `maxRows` rows
+			// cannot hold everything, the priority row beats a partial rail plus a
+			// count of what is missing.
+			if (dropped > 0) {
+				const priorityRow = this.#priorityRowFor(seg, [], [], topFillWidth);
+				if (priorityRow !== null) {
+					this.#renderedRowsCache = { key: cacheKey, rows: [priorityRow] };
+					return [priorityRow];
+				}
+			}
+
 			// Reserve marker cells on whichever row ends up last, evicting from its
 			// tail until the cue fits. Never opens a new row: that would contradict
 			// maxRows. Emptying that row is fine -- the marker then occupies it alone.

package/src/modes/controllers/input-controller.ts

@@ -420,6 +420,34 @@ export class InputController {
 			if (this.ctx.cancelPendingSubmission()) {
 				return true;
 			}
+			if (options.processes && this.ctx.session.isBashRunning) {
+				this.ctx.session.abortBash();
+				return true;
+			}
+			if (options.processes && this.ctx.session.isEvalRunning) {
+				this.ctx.session.abortEval();
+				return true;
+			}
+			// A queued steer on a live stream is owned by the steering branch below,
+			// which silently consumes it and auto-continues. This branch counts the same
+			// queue as cancellable work, and a streaming turn always has the indicator
+			// mounted, so without this hand-off it short-circuited first and turned the
+			// documented steer-on-interrupt into a loud abort that dumped the steer back
+			// into the composer. `cancelPendingSubmission()` above still wins: a
+			// submission that has not started yet is cancelled before the stream owns
+			// the key, and one that has started returns false there by design.
+			if (
+				options.streaming === true &&
+				this.ctx.session.isStreaming &&
+				this.ctx.session.hasQueuedSteering &&
+				!this.ctx.session.isBashRunning &&
+				!this.ctx.session.isEvalRunning &&
+				!this.#steerConsumePending
+			) {
+				this.#steerConsumePending = true;
+				void this.#abortInteractive({ silent: true });
+				return true;
+			}
 			// Only count queues this handler can actually drain. The aggregate
 			// `queuedMessageCount` also counts hidden next-turn context, which
 			// `restoreQueuedMessagesToEditor()` never returns and which survives turn