@gajae-code/coding-agent 0.15.5 → 0.16.0

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 };
+}
 
-	const parts: string[] = [withIcon(icon, "Goal")];
+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(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 = {
@@ -307,7 +321,9 @@ const jobsSegment: StatusLineSegment = {
 	id: "jobs",
 	render(ctx) {
 		const { jobs } = ctx;
-		const visible = jobs.activeMonitorCount > 0 || jobs.activeCronCount > 0 || jobs.worstState === "failed";
+		const foldedJobCount = jobs.foldedJobs?.filter(job => job.backgrounded).length ?? 0;
+		const visible =
+			jobs.activeMonitorCount > 0 || jobs.activeCronCount > 0 || foldedJobCount > 0 || jobs.worstState === "failed";
 		if (!visible) {
 			return { content: "", visible: false };
 		}
@@ -318,6 +334,9 @@ const jobsSegment: StatusLineSegment = {
 		if (jobs.activeCronCount > 0) {
 			parts.push(withIcon(theme.icon.time, `${jobs.activeCronCount}`));
 		}
+		if (foldedJobCount > 0) {
+			parts.push(withIcon(theme.icon.pause || theme.icon.agents, `${foldedJobCount} folded`));
+		}
 		if (parts.length === 0) {
 			// Nothing active but a failure is unacknowledged — keep a drill-in marker.
 			parts.push(withIcon(theme.icon.warning, "jobs"));

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/extension-ui-controller.ts

@@ -312,7 +312,7 @@ export class ExtensionUiController {
 				session.retryNow();
 				return { retried: true, immediate: true };
 			case "bash.background":
-				if (!session.requestForegroundBashBackground())
+				if (!(await session.requestForegroundBashBackground()))
 					throw Object.assign(new Error("The active bash command cannot be moved to a managed background job."), {
 						code: "not_foldable",
 					});

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

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { type AgentMessage, ThinkingLevel } from "@gajae-code/agent-core";
-import { type AutocompleteProvider, matchesKey, type SlashCommand } from "@gajae-code/tui";
+import { type AutocompleteProvider, getKeybindings, matchesKey, type SlashCommand } from "@gajae-code/tui";
 import { $pickenv, logger, sanitizeText } from "@gajae-code/utils";
 import { type AppKeybinding, KEYBINDINGS } from "../../config/keybindings";
 import { isSettingsInitialized, settings } from "../../config/settings";
@@ -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
@@ -1855,19 +1883,36 @@ export class InputController {
 		const now = Date.now();
 		if (now - this.#lastBackgroundFoldKeyTime > BACKGROUND_FOLD_DOUBLE_PRESS_MS) {
 			this.#lastBackgroundFoldKeyTime = now;
-			this.ctx.showStatus("Press Ctrl+B again to fold supported foreground bash into a background job");
+			const foldKeys = getKeybindings().getKeys("app.tool.backgroundFold");
+			this.ctx.showStatus(
+				`Press ${foldKeys.join(" / ")} again to fold supported foreground bash into a background job`,
+			);
 			return true;
 		}
 		this.#lastBackgroundFoldKeyTime = 0;
 
-		if (!this.ctx.session.requestForegroundBashBackground?.()) {
+		try {
+			const request = this.ctx.session.requestForegroundBashBackground?.() ?? Promise.resolve(false);
+			void request
+				.then(backgrounded => {
+					if (backgrounded) {
+						this.ctx.showStatus("Folding foreground bash into a quiet background job…");
+						return;
+					}
+					this.ctx.showWarning(
+						"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
+					);
+				})
+				.catch(() => {
+					this.ctx.showWarning(
+						"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
+					);
+				});
+		} catch {
 			this.ctx.showWarning(
 				"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
 			);
-			return true;
 		}
-
-		this.ctx.showStatus("Folding foreground bash into a quiet background job…");
 		return true;
 	}