@gajae-code/coding-agent 0.15.6 → 0.16.1

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

@@ -1161,7 +1161,7 @@ export class CommandController {
 		}
 
 		try {
-			await this.ctx.sessionManager.runExclusiveCwdTransition(async () => {
+			await this.ctx.sessionManager.runExclusiveCwdMoveTransition(async () => {
 				await this.ctx.sessionManager.flush();
 				await this.ctx.sessionManager.moveTo(resolvedPath);
 				setProjectDir(resolvedPath);

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

@@ -57,6 +57,17 @@ export const __eventControllerPerfCounters = {
 };
 
 const COMPLETION_NOTIFY_COMMAND_TIMEOUT_MS = 10_000;
+const TEXTLESS_LENGTH_WARNING =
+	'Response ended with stopReason "length" before producing visible text or a tool call. Check the model\'s output and context token limits (maxTokens in models.yml) or lower the reasoning level (/reasoning), then retry.';
+
+function isTextlessLengthStop(message: AssistantMessage | undefined): boolean {
+	return (
+		message?.stopReason === "length" &&
+		!message.content.some(
+			block => (block.type === "text" && block.text.trim().length > 0) || block.type === "toolCall",
+		)
+	);
+}
 
 interface CompletionNotifyPayload {
 	type: "agent-turn-complete";
@@ -904,7 +915,7 @@ export class EventController {
 		}
 	}
 
-	async #handleAgentEnd(_event: Extract<AgentSessionEvent, { type: "agent_end" }>): Promise<void> {
+	async #handleAgentEnd(event: Extract<AgentSessionEvent, { type: "agent_end" }>): Promise<void> {
 		this.ctx.setWorkingMessage(undefined);
 		stopInteractiveActivityIndicator(this.ctx, { foregroundSettled: true });
 		if (this.ctx.streamingComponent) {
@@ -929,6 +940,14 @@ export class EventController {
 		this.ctx.ui.requestRender();
 		this.#scheduleIdleCompaction();
 		emitHostStatus("finished");
+		const lastAssistant = this.ctx.session.getLastAssistantMessage();
+		if (
+			event.stopReason !== "cancelled" &&
+			event.stopReason !== "maintenance" &&
+			isTextlessLengthStop(lastAssistant)
+		) {
+			this.ctx.showWarning(TEXTLESS_LENGTH_WARNING);
+		}
 		this.sendCompletionNotification();
 		this.ctx.promptSuggestion?.onAgentEnd();
 	}
@@ -1204,13 +1223,20 @@ export class EventController {
 		// errored — those are not "Task complete" events. Mirrors the gate
 		// already used by #currentContextTokens, #handleMessageEnd, and the
 		// retry / TTSR / compaction skip paths across agent-session.ts.
-		const last = this.ctx.session.getLastAssistantMessage?.();
+		const last = this.ctx.session.getLastAssistantMessage();
 		if (last?.stopReason === "aborted" || last?.stopReason === "error") return;
 
 		const sessionName = this.ctx.sessionManager.getSessionName();
-		const title = sessionName ? `${sessionName}: Complete` : "Complete";
+		const textlessLengthStop = isTextlessLengthStop(last);
+		const title = textlessLengthStop
+			? sessionName
+				? `${sessionName}: Output limit reached`
+				: "Output limit reached"
+			: sessionName
+				? `${sessionName}: Complete`
+				: "Complete";
 		const summary = summaryFromMessage(last, 1000);
-		const body = summary ?? "Complete";
+		const body = textlessLengthStop ? TEXTLESS_LENGTH_WARNING : (summary ?? "Complete");
 		const sessionManager = this.ctx.sessionManager as { getCwd?: () => string; getSessionId?: () => string };
 		const payload: CompletionNotifyPayload = {
 			type: "agent-turn-complete",

package/src/modes/controllers/extension-ui-controller.ts

@@ -39,6 +39,7 @@ import {
 	SYNTHETIC_PROVIDER_ID,
 	syntheticNamespaceCollision,
 } from "../../sdk/model-profile-model";
+import { bashBackgroundControlError } from "../../session/fold-coordinator";
 import { createReadonlySessionManager } from "../../session/session-manager";
 import { parseThinkingLevel } from "../../thinking";
 import type { TodoPhase } from "../../tools/todo-write";
@@ -311,12 +312,11 @@ export class ExtensionUiController {
 					throw Object.assign(new Error("No retry backoff is pending."), { code: "retry_not_pending" });
 				session.retryNow();
 				return { retried: true, immediate: true };
-			case "bash.background":
-				if (!(await session.requestForegroundBashBackground()))
-					throw Object.assign(new Error("The active bash command cannot be moved to a managed background job."), {
-						code: "not_foldable",
-					});
-				return { backgrounded: true };
+			case "bash.background": {
+				const outcome = await session.requestForegroundBashBackgroundOutcome("sdk_control");
+				if (outcome.status !== "folded") throw bashBackgroundControlError(outcome);
+				return { backgrounded: true, jobId: outcome.jobId };
+			}
 			case "compaction.auto.set":
 				session.setAutoCompactionEnabled(input.on === true);
 				return { changed: true };
@@ -591,8 +591,8 @@ export class ExtensionUiController {
 					this.ctx.session.setFollowUpMode(mode);
 					return true;
 				}
-				if (kind === "interrupt" && (mode === "immediate" || mode === "wait")) {
-					this.ctx.session.setInterruptMode(mode);
+				if (kind === "tool_interrupt" && (mode === "abort_tools" || mode === "finish_tools")) {
+					this.ctx.session.setToolInterruptPolicy(mode);
 					return true;
 				}
 				return false;
@@ -821,8 +821,8 @@ export class ExtensionUiController {
 					this.ctx.session.setFollowUpMode(mode);
 					return true;
 				}
-				if (kind === "interrupt" && (mode === "immediate" || mode === "wait")) {
-					this.ctx.session.setInterruptMode(mode);
+				if (kind === "tool_interrupt" && (mode === "abort_tools" || mode === "finish_tools")) {
+					this.ctx.session.setToolInterruptPolicy(mode);
 					return true;
 				}
 				return false;
@@ -962,8 +962,8 @@ export class ExtensionUiController {
 								this.ctx.session.setFollowUpMode(mode);
 								return true;
 							}
-							if (kind === "interrupt" && (mode === "immediate" || mode === "wait")) {
-								this.ctx.session.setInterruptMode(mode);
+							if (kind === "tool_interrupt" && (mode === "abort_tools" || mode === "finish_tools")) {
+								this.ctx.session.setToolInterruptPolicy(mode);
 								return true;
 							}
 							return false;
@@ -973,7 +973,7 @@ export class ExtensionUiController {
 						getConfigItems: () => ({
 							steeringMode: this.ctx.session.steeringMode,
 							followUpMode: this.ctx.session.followUpMode,
-							interruptMode: this.ctx.session.interruptMode,
+							toolInterruptPolicy: this.ctx.session.toolInterruptPolicy,
 						}),
 						getBranchCandidates: () => this.ctx.sessionManager.getTree(),
 						getExtensions: () => this.ctx.session.extensionRunner?.getExtensionPaths() ?? [],

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
@@ -1142,7 +1170,7 @@ export class InputController {
 			const promptOptions =
 				streamingBehavior === "followUp"
 					? { streamingBehavior, images, followUpQueuePolicy: "sequential" as const }
-					: { streamingBehavior, images };
+					: { streamingBehavior, images, steerQueuePolicy: "sequential" as const };
 			await this.ctx.withLocalSubmission(text, () => this.ctx.session.prompt(text, promptOptions), {
 				imageCount: images?.length ?? 0,
 			});
@@ -1655,7 +1683,7 @@ export class InputController {
 					},
 					streamingBehavior === "followUp"
 						? { streamingBehavior, followUpQueuePolicy: "sequential" }
-						: { streamingBehavior },
+						: { streamingBehavior, steerQueuePolicy: "sequential" },
 				);
 			}
 			if (this.ctx.session.isStreaming) {