@sayknow-cli/coding-agent 0.3.0 → 0.3.2

package/src/lsp/config.ts

@@ -88,6 +88,7 @@ function normalizeServerConfig(name: string, config: RawServerConfig): ServerCon
 		: isRecord(config.initializationOptions)
 			? config.initializationOptions
 			: undefined;
+	const supersedes = normalizeStringArray(config.supersedes);
 
 	return {
 		...config,
@@ -96,6 +97,7 @@ function normalizeServerConfig(name: string, config: RawServerConfig): ServerCon
 		fileTypes,
 		rootMarkers,
 		...(initOptions ? { initOptions } : {}),
+		...(supersedes ? { supersedes } : {}),
 	};
 }
 
@@ -144,6 +146,18 @@ function mergeServers(
 	return merged;
 }
 
+function applyServerPrecedence(servers: Record<string, ServerConfig>): Record<string, ServerConfig> {
+	const suppressed = new Set<string>();
+	for (const config of Object.values(servers)) {
+		for (const serverName of config.supersedes ?? []) {
+			suppressed.add(serverName);
+		}
+	}
+	if (suppressed.size === 0) return servers;
+
+	return Object.fromEntries(Object.entries(servers).filter(([name]) => !suppressed.has(name)));
+}
+
 function applyRuntimeDefaults(servers: Record<string, ServerConfig>): Record<string, ServerConfig> {
 	const updated: Record<string, ServerConfig> = { ...servers };
 
@@ -422,9 +436,8 @@ export function loadConfig(cwd: string): LspConfig {
 			detected[name] = { ...config, resolvedCommand: resolved };
 		}
 
-		return { servers: detected, idleTimeoutMs };
+		return { servers: applyServerPrecedence(detected), idleTimeoutMs };
 	}
-
 	// Merge overrides with defaults and filter to available servers
 	const mergedWithRuntime = applyRuntimeDefaults(mergedServers);
 	const available: Record<string, ServerConfig> = {};
@@ -437,7 +450,7 @@ export function loadConfig(cwd: string): LspConfig {
 		available[name] = { ...config, resolvedCommand: resolved };
 	}
 
-	return { servers: available, idleTimeoutMs };
+	return { servers: applyServerPrecedence(available), idleTimeoutMs };
 }
 
 // =============================================================================

package/src/lsp/defaults.json

@@ -342,6 +342,13 @@
 		"fileTypes": [".php"],
 		"rootMarkers": ["composer.json", ".phpactor.json", ".phpactor.yml"]
 	},
+	"csharp-ls": {
+		"command": "csharp-ls",
+		"args": [],
+		"fileTypes": [".cs", ".csx"],
+		"rootMarkers": ["*.sln", "*.slnx", "*.csproj", "global.json"],
+		"supersedes": ["omnisharp"]
+	},
 	"omnisharp": {
 		"command": "omnisharp",
 		"args": ["-z", "--hostPID", "$PID", "--encoding", "utf-8", "--languageserver"],

package/src/lsp/types.ts

@@ -358,6 +358,8 @@ export interface ServerConfig {
 	/** Per-server warmup timeout in milliseconds. Overrides the global WARMUP_TIMEOUT_MS for this server during startup. */
 	warmupTimeoutMs?: number;
 	capabilities?: ServerCapabilities;
+	/** Names of lower-precedence servers to drop when this server is available. */
+	supersedes?: string[];
 	/** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
 	isLinter?: boolean;
 	/** Resolved absolute path to the command binary (set during config loading) */

package/src/main.ts

@@ -52,7 +52,7 @@ import { formatModelOnboardingGuidance } from "./setup/model-onboarding-guidance
 import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { resolvePromptInput } from "./system-prompt";
 import type { LspStartupServerInfo } from "./tools";
-import { getDisplayChangelogEntries, getNewEntries } from "./utils/changelog";
+import { getDisplayChangelogEntries, getInstalledVersionChangelogEntry, getNewEntries } from "./utils/changelog";
 import type { EventBus } from "./utils/event-bus";
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
@@ -407,7 +407,7 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 		if (entries.length > 0) {
 			settings.set("lastChangelogVersion", VERSION);
 			await flushChangelogVersion();
-			return entries.map(e => e.content).join("\n\n");
+			return getInstalledVersionChangelogEntry(entries, VERSION)?.content;
 		}
 	} else {
 		const newEntries = getNewEntries(entries, lastVersion);
@@ -429,7 +429,7 @@ async function flushChangelogVersion(): Promise<void> {
 	}
 }
 
-async function createSessionManager(
+export async function createSessionManager(
 	parsed: Args,
 	cwd: string,
 	activeSettings: Settings = settings,
@@ -482,6 +482,17 @@ async function createSessionManager(
 	if (parsed.sessionDir) {
 		return SessionManager.create(cwd, parsed.sessionDir);
 	}
+	// A lifecycle `/session_create` child must start a FRESH session that adopts
+	// the pre-allocated id (SKC_SESSION_ID), never auto-resume existing history in
+	// the target cwd — otherwise the daemon/tmux id and the session header id
+	// diverge and close/resume-by-create-id break. Resume children are launched
+	// with `--resume <id>` (handled above) and carry no SKC_LIFECYCLE_REQUEST_ID.
+	if (
+		process.env.SKC_LIFECYCLE_REQUEST_ID &&
+		/^[A-Za-z0-9._-]{1,128}$/.test(process.env.SKC_SESSION_ID?.trim() ?? "")
+	) {
+		return undefined;
+	}
 	// Auto-resume: behave like --continue if the setting is enabled and a prior
 	// session exists. When a prior session is resumed, mark parsed.continue so
 	// buildSessionOptions restores the session's model/thinking instead of

package/src/modes/bridge/bridge-mode.ts

@@ -153,6 +153,14 @@ function jsonResponse(status: number, body: unknown): Response {
 	});
 }
 
+function isBridgeControllerOwner(options: BridgeFetchHandlerOptions, ownerToken: string): boolean {
+	if (!ownerToken) return false;
+	const ownerTokens = [options.permissionBroker?.ownerToken, options.uiBroker?.ownerToken].filter(
+		(token): token is string => typeof token === "string" && token.length > 0,
+	);
+	return ownerTokens.length > 0 && ownerTokens.every(token => token === ownerToken);
+}
+
 function parseBridgeScopes(value: string | undefined): readonly BridgeCommandScope[] {
 	if (!value?.trim()) return DEFAULT_BRIDGE_SCOPES;
 	const allowed = new Set(BRIDGE_COMMAND_SCOPES);
@@ -425,6 +433,9 @@ export function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (r
 				"answer" in payload &&
 				(correlationId === (payload as RpcWorkflowGateResponse).gate_id || correlationId.startsWith("wg_"))
 			) {
+				if (!isBridgeControllerOwner(options, ownerToken)) {
+					return jsonResponse(403, { status: "rejected", code: "not_controller" });
+				}
 				try {
 					const resolution = await options.unattendedControlPlane?.resolveGate({
 						gate_id: (payload as RpcWorkflowGateResponse).gate_id,

package/src/modes/components/assistant-message.ts

@@ -7,6 +7,54 @@ import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { isSilentAbort } from "../../session/messages";
 import { resolveImageOptions } from "../../tools/render-utils";
 
+const THINKING_REPETITION_ELIDE_MIN_RUN = 24;
+const THINKING_REPETITION_VISIBLE_TOKENS = 3;
+const THINKING_REPETITION_TOKEN_PATTERN = /[\p{L}\p{N}_'-]{1,32}/gu;
+
+interface ThinkingRepetitionToken {
+	text: string;
+	normalized: string;
+	start: number;
+	end: number;
+}
+
+function elideRunawayThinkingRepetition(text: string): string {
+	const tokens: ThinkingRepetitionToken[] = [];
+	for (const match of text.matchAll(THINKING_REPETITION_TOKEN_PATTERN)) {
+		if (match.index === undefined) continue;
+		tokens.push({
+			text: match[0],
+			normalized: match[0].toLocaleLowerCase("en-US"),
+			start: match.index,
+			end: match.index + match[0].length,
+		});
+	}
+
+	let runStart = 0;
+	for (let i = 1; i <= tokens.length; i++) {
+		const current = tokens[i];
+		const previous = tokens[i - 1];
+		if (current && previous && current.normalized === previous.normalized) continue;
+
+		const runLength = i - runStart;
+		if (runLength >= THINKING_REPETITION_ELIDE_MIN_RUN) {
+			const first = tokens[runStart];
+			const last = tokens[i - 1];
+			if (!first || !last) return text;
+
+			const visibleCount = Math.min(THINKING_REPETITION_VISIBLE_TOKENS, runLength);
+			const visible = Array.from({ length: visibleCount }, () => first.text).join(" ");
+			const omitted = runLength - visibleCount;
+			const marker = `${visible} … [thinking loop elided: "${first.text}" repeated ${omitted} more times]`;
+			return `${text.slice(0, first.start)}${marker}${text.slice(last.end)}`.trim();
+		}
+
+		runStart = i;
+	}
+
+	return text;
+}
+
 /**
  * Component that renders a complete assistant message
  */
@@ -128,7 +176,7 @@ export class AssistantMessageComponent extends Container {
 	#renderThinkingBlock(content: { thinking: string }): Markdown {
 		const cached = this.#contentBlocksCache.get(content);
 		if (cached?.source === content.thinking) return cached.component as Markdown;
-		const trimmed = content.thinking.trim();
+		const trimmed = elideRunawayThinkingRepetition(content.thinking.trim());
 		const component = new Markdown(trimmed, 1, 0, getMarkdownTheme(), {
 			color: (text: string) => theme.fg("thinkingText", text),
 			italic: true,

package/src/modes/components/custom-editor.ts

@@ -18,6 +18,7 @@ type ConfigurableEditorAction = Extract<
 	| "app.editor.external"
 	| "app.history.search"
 	| "app.message.dequeue"
+	| "app.message.followUp"
 	| "app.message.queue"
 	| "app.clipboard.pasteImage"
 	| "app.clipboard.copyPrompt"
@@ -40,6 +41,7 @@ const CONFIGURABLE_EDITOR_ACTIONS = [
 	"app.thinking.toggle",
 	"app.editor.external",
 	"app.history.search",
+	"app.message.followUp",
 	"app.message.queue",
 	"app.message.dequeue",
 	"app.clipboard.pasteImage",

package/src/modes/components/footer.ts

@@ -8,6 +8,7 @@ import { shortenPath } from "../../tools/render-utils";
 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";
 
 /**
  * Footer component that shows pwd, token stats, and context usage
@@ -103,9 +104,7 @@ export class FooterComponent implements Component {
 			return this.#cachedBranch;
 		}
 
-		const headState = git.head.resolveSync(getProjectDir());
-		this.#cachedBranch =
-			headState === null ? null : headState.kind === "ref" ? (headState.branchName ?? headState.ref) : "detached";
+		this.#cachedBranch = resolveCurrentBranch(getProjectDir()).branch;
 		return this.#cachedBranch;
 	}
 

package/src/modes/components/hook-editor.ts

@@ -66,7 +66,7 @@ export class HookEditorComponent extends Container {
 
 		// Hint
 		const hint = this.#promptStyle
-			? "enter submit  esc cancel  ctrl+g external editor"
+			? "enter submit  shift+enter/ctrl+j newline  esc cancel  ctrl+g external editor"
 			: "ctrl+enter submit  esc cancel  ctrl+g external editor";
 		this.addChild(new Text(theme.fg("dim", hint), 1, 0));
 

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

@@ -29,22 +29,6 @@ import { getEditorCommand, openInEditor } from "../../utils/external-editor";
 import { CountdownTimer } from "./countdown-timer";
 import { DynamicBorder } from "./dynamic-border";
 
-const SGR_MOUSE_PRESS_PATTERN = /^\x1b\[<(\d+);\d+;\d+M$/;
-const MOUSE_WHEEL_TITLE_SCROLL_ROWS = 3;
-
-function getMouseWheelTitleScrollRows(keyData: string): number {
-	const match = SGR_MOUSE_PRESS_PATTERN.exec(keyData);
-	if (!match) return 0;
-
-	const button = Number.parseInt(match[1] ?? "", 10);
-	if (!Number.isFinite(button) || (button & 64) === 0) return 0;
-
-	const wheelDirection = button & 3;
-	if (wheelDirection === 0) return -MOUSE_WHEEL_TITLE_SCROLL_ROWS;
-	if (wheelDirection === 1) return MOUSE_WHEEL_TITLE_SCROLL_ROWS;
-	return 0;
-}
-
 export interface HookSelectorOptions {
 	tui?: TUI;
 	timeout?: number;
@@ -133,26 +117,58 @@ class ScrollableTitle extends Container {
 
 	render(width: number): string[] {
 		const lines = this.#markdown.render(width);
-		const maxScrollOffset = Math.max(0, lines.length - this.#maxRows);
-		this.#lastMaxScrollOffset = maxScrollOffset;
-		this.#scrollOffset = Math.max(0, Math.min(this.#scrollOffset, maxScrollOffset));
+		if (lines.length <= this.#maxRows) {
+			this.#lastMaxScrollOffset = 0;
+			this.#scrollOffset = 0;
+			return lines;
+		}
 
-		const visibleLines = lines.slice(this.#scrollOffset, this.#scrollOffset + this.#maxRows);
-		if (maxScrollOffset === 0 || visibleLines.length === 0) {
+		if (this.#maxRows < 3) {
+			const maxScrollOffset = Math.max(0, lines.length - this.#maxRows);
+			this.#lastMaxScrollOffset = maxScrollOffset;
+			this.#scrollOffset = Math.max(0, Math.min(this.#scrollOffset, maxScrollOffset));
+
+			const visibleLines = lines.slice(this.#scrollOffset, this.#scrollOffset + this.#maxRows);
+			const indicator =
+				this.#scrollOffset === 0
+					? theme.fg("dim", " PgDn↓")
+					: this.#scrollOffset >= maxScrollOffset
+						? theme.fg("dim", " PgUp↑")
+						: theme.fg("dim", " PgUp/PgDn↕");
+			const lastIndex = visibleLines.length - 1;
+			const availableWidth = Math.max(1, width - visibleWidth(indicator));
+			const fittedLine = truncateToWidth(visibleLines[lastIndex] ?? "", availableWidth);
+			visibleLines[lastIndex] = `${fittedLine}${indicator}`;
 			return visibleLines;
 		}
 
-		const indicator =
-			this.#scrollOffset === 0
-				? theme.fg("dim", " PgDn↓")
-				: this.#scrollOffset >= maxScrollOffset
-					? theme.fg("dim", " PgUp↑")
-					: theme.fg("dim", " PgUp/PgDn↕");
-		const lastIndex = visibleLines.length - 1;
-		const availableWidth = Math.max(1, width - visibleWidth(indicator));
-		const fittedLine = truncateToWidth(visibleLines[lastIndex] ?? "", availableWidth);
-		visibleLines[lastIndex] = `${fittedLine}${indicator}`;
-		return visibleLines;
+		let showTopIndicator = this.#scrollOffset > 0;
+		let showBottomIndicator = true;
+		let contentRows = 1;
+		let maxScrollOffset = 0;
+
+		for (let i = 0; i < 4; i++) {
+			contentRows = Math.max(1, this.#maxRows - (showTopIndicator ? 1 : 0) - (showBottomIndicator ? 1 : 0));
+			maxScrollOffset = Math.max(0, lines.length - contentRows);
+			this.#scrollOffset = Math.max(0, Math.min(this.#scrollOffset, maxScrollOffset));
+
+			const nextShowTopIndicator = this.#scrollOffset > 0;
+			const nextShowBottomIndicator = this.#scrollOffset + contentRows < lines.length;
+			if (nextShowTopIndicator === showTopIndicator && nextShowBottomIndicator === showBottomIndicator) {
+				break;
+			}
+			showTopIndicator = nextShowTopIndicator;
+			showBottomIndicator = nextShowBottomIndicator;
+		}
+
+		this.#lastMaxScrollOffset = maxScrollOffset;
+
+		const visibleLines = lines.slice(this.#scrollOffset, this.#scrollOffset + contentRows);
+		const result: string[] = [];
+		if (showTopIndicator) result.push(theme.fg("dim", truncateToWidth("▲ more", width)));
+		result.push(...visibleLines);
+		if (showBottomIndicator) result.push(theme.fg("dim", truncateToWidth("▼ more", width)));
+		return result.slice(0, this.#maxRows);
 	}
 }
 
@@ -455,13 +471,6 @@ export class HookSelectorComponent extends Container {
 		// Reset countdown on any interaction
 		this.#countdown?.reset();
 
-		if (this.#scrollTitleRows !== undefined) {
-			const wheelRows = getMouseWheelTitleScrollRows(keyData);
-			if (wheelRows !== 0) {
-				this.#scrollableTitle?.scrollBy(wheelRows);
-				return;
-			}
-		}
 		if (this.#scrollTitleRows !== undefined && matchesKey(keyData, "pageUp")) {
 			this.#scrollableTitle?.scrollBy(-this.#scrollTitleRows);
 			return;
@@ -470,6 +479,14 @@ export class HookSelectorComponent extends Container {
 			this.#scrollableTitle?.scrollBy(this.#scrollTitleRows);
 			return;
 		}
+		if (!this.#inlineEditor && this.#scrollTitleRows !== undefined && matchesKey(keyData, "ctrl+u")) {
+			this.#scrollableTitle?.scrollBy(-this.#scrollTitleRows);
+			return;
+		}
+		if (!this.#inlineEditor && this.#scrollTitleRows !== undefined && matchesKey(keyData, "ctrl+d")) {
+			this.#scrollableTitle?.scrollBy(this.#scrollTitleRows);
+			return;
+		}
 		if (this.#inlineEditor) {
 			this.#handleInputModeKey(keyData, this.#inlineEditor);
 			return;
@@ -538,16 +555,23 @@ export class HookSelectorComponent extends Container {
 		editor.setBorderVisible(false);
 		editor.setPromptGutter("> ");
 		editor.disableSubmit = true;
+		// Mark the inline editor focused only when mirroring the app's hardware-cursor
+		// mode, so it emits CURSOR_MARKER at the input caret for IME preedit anchoring
+		// without changing legacy non-hardware-cursor layout.
+		const useTerminalCursor = this.#tui?.getShowHardwareCursor() ?? false;
+		editor.focused = useTerminalCursor;
+		editor.setUseTerminalCursor(useTerminalCursor);
 		if (this.#autocompleteProvider) {
 			editor.setAutocompleteProvider(this.#autocompleteProvider);
 		}
 		this.#inlineEditor = editor;
 		this.#inputArea.addChild(new Spacer(1));
 		this.#inputArea.addChild(editor);
-		const scrollHint = this.#scrollTitleRows === undefined ? "" : "  wheel/PgUp/PgDn scroll question";
-		this.#helpTextComponent.setText(
-			theme.fg("dim", `enter submit  esc back to options  ctrl+g external editor${scrollHint}`),
-		);
+		const helpText =
+			this.#scrollTitleRows === undefined
+				? "enter submit  esc back to options  ctrl+g external editor"
+				: "enter submit  esc back to options  PgUp/PgDn: question · Wheel: transcript";
+		this.#helpTextComponent.setText(theme.fg("dim", helpText));
 		this.invalidate();
 	}
 

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

@@ -228,8 +228,11 @@ export class ModelSelectorComponent extends Container {
 	#scopedModels: ReadonlyArray<ScopedModelItem>;
 	#temporaryOnly: boolean;
 	#currentModel?: Model;
+	#currentThinkingLevel?: ThinkingLevel;
+	#activeModelProfile?: string;
 	#isFastForProvider: (provider?: string) => boolean = () => false;
 	#isFastForSubagentProvider: (provider?: string) => boolean = () => false;
+	#isCurrentModelFastModeActive: () => boolean = () => false;
 	#pendingActionItem?: ModelItem | CanonicalModelItem;
 	#selectedActionIndex: number = 0;
 	#pendingThinkingChoice?: PendingThinkingChoice;
@@ -265,6 +268,9 @@ export class ModelSelectorComponent extends Container {
 			sessionId?: string;
 			isFastForProvider?: (provider?: string) => boolean;
 			isFastForSubagentProvider?: (provider?: string) => boolean;
+			isCurrentModelFastModeActive?: () => boolean;
+			currentThinkingLevel?: ThinkingLevel;
+			activeModelProfile?: string;
 		},
 	) {
 		super();
@@ -278,8 +284,16 @@ export class ModelSelectorComponent extends Container {
 		this.#temporaryOnly = options?.temporaryOnly ?? false;
 		this.#authSessionId = options?.sessionId;
 		this.#currentModel = _currentModel;
+		this.#currentThinkingLevel = options?.currentThinkingLevel;
+		this.#activeModelProfile = options?.activeModelProfile;
 		this.#isFastForProvider = options?.isFastForProvider ?? (() => false);
 		this.#isFastForSubagentProvider = options?.isFastForSubagentProvider ?? (() => false);
+		// Current-model EFFECTIVE fast state. Defaults to intent for the current
+		// model so existing callers/tests keep prior behavior; production wires the
+		// session's effective predicate so an auto-disabled provider shows no glyph.
+		this.#isCurrentModelFastModeActive =
+			options?.isCurrentModelFastModeActive ??
+			(() => (this.#currentModel ? this.#isFastForProvider(this.#currentModel.provider) : false));
 		const initialSearchInput = options?.initialSearchInput;
 		this.#viewMode = this.#temporaryOnly || initialSearchInput || scopedModels.length > 0 ? "models" : "presets";
 
@@ -373,6 +387,23 @@ export class ModelSelectorComponent extends Container {
 				};
 			}
 		}
+		if (this.#activeModelProfile && this.#currentModel) {
+			this.#roles.default = {
+				model: this.#currentModel,
+				thinkingLevel: this.#currentThinkingLevel ?? ThinkingLevel.Inherit,
+			};
+		}
+	}
+
+	refreshRoleAssignments(
+		options: { currentModel?: Model; currentThinkingLevel?: ThinkingLevel; activeModelProfile?: string } = {},
+	): void {
+		if ("currentModel" in options) this.#currentModel = options.currentModel;
+		if ("currentThinkingLevel" in options) this.#currentThinkingLevel = options.currentThinkingLevel;
+		if ("activeModelProfile" in options) this.#activeModelProfile = options.activeModelProfile;
+		this.#roles = {};
+		this.#loadRoleModels();
+		this.#applyTabFilter();
 	}
 
 	#sortModels(models: ModelItem[]): void {
@@ -980,32 +1011,46 @@ export class ModelSelectorComponent extends Container {
 
 			// Build role badges (inverted: color as background, black text)
 			const roleBadgeTokens: string[] = [];
-			let roleMatched = false;
+			// Whether a non-subagent (modelRoles) badge on the CURRENT model row already
+			// rendered the current-model EFFECTIVE glyph. Only that case should suppress
+			// the standalone current glyph below — a subagent-only match must NOT, since
+			// subagent badges reflect the subagent tier, not the current model.
+			let currentModelEffectiveGlyphRendered = false;
 			for (const role of SKC_MODEL_ASSIGNMENT_TARGET_IDS) {
 				const roleInfo = SKC_MODEL_ASSIGNMENT_TARGETS[role];
 				const assigned = this.#roles[role];
 				if (roleInfo.tag && assigned && modelsAreEqual(assigned.model, item.model)) {
-					roleMatched = true;
 					const badge = makeInvertedBadge(roleInfo.tag, roleInfo.color ?? "muted");
 					const thinkingLabel = getThinkingLevelMetadata(assigned.thinkingLevel).label;
-					// Subagent roles (task.agentModelOverrides) run under task.serviceTier, so
-					// their ⚡ must reflect the effective subagent tier, not the main session tier.
-					const roleFast =
-						roleInfo.settingsPath === "task.agentModelOverrides"
-							? this.#isFastForSubagentProvider(assigned.model.provider)
+
+					// Subagent roles (task.agentModelOverrides) run under task.serviceTier,
+					// so their ⚡ uses the effective subagent tier. A non-subagent
+					// (modelRoles) badge on the CURRENT model row uses the current-model
+					// effective predicate so a provider auto-disable hides the glyph;
+					// other modelRoles rows show pure intent.
+					const isSubagentRole = roleInfo.settingsPath === "task.agentModelOverrides";
+					const isCurrentRow = this.#currentModel !== undefined && modelsAreEqual(this.#currentModel, item.model);
+					const roleFast = isSubagentRole
+						? this.#isFastForSubagentProvider(assigned.model.provider)
+						: isCurrentRow
+							? this.#isCurrentModelFastModeActive()
 							: this.#isFastForProvider(assigned.model.provider);
+					if (roleFast && isCurrentRow && !isSubagentRole) {
+						currentModelEffectiveGlyphRendered = true;
+					}
 					const fastSuffix = roleFast ? ` ${theme.icon.fast}` : "";
 					roleBadgeTokens.push(`${badge} ${theme.fg("dim", `(${thinkingLabel})`)}${fastSuffix}`);
 				}
 			}
 			// Active/current non-role row: show the fast glyph on the session's current
-			// model row even when it carries no role badge. Skip when a role token for
-			// this row already rendered the glyph (duplicate-glyph guard).
+			// model row. Suppress only when a non-subagent current-row badge already
+			// rendered the current-model effective glyph (duplicate-glyph guard) — a
+			// subagent-only match must not hide the current model's own indicator.
 			if (
-				!roleMatched &&
+				!currentModelEffectiveGlyphRendered &&
 				this.#currentModel !== undefined &&
 				modelsAreEqual(this.#currentModel, item.model) &&
-				this.#isFastForProvider(item.model.provider)
+				this.#isCurrentModelFastModeActive()
 			) {
 				roleBadgeTokens.push(theme.icon.fast);
 			}

package/src/modes/components/status-line/git-utils.ts

@@ -1,3 +1,6 @@
+import type { GitHeadState } from "../../../utils/git";
+import * as git from "../../../utils/git";
+
 /**
  * Extract "owner/repo" from a GitHub remote URL.
  * Handles HTTPS, SSH (scp-style), and git:// protocols.
@@ -40,3 +43,25 @@ export function canReuseCachedPr(
 ): boolean {
 	return cachedPr !== undefined && currentContext !== null && isSamePrCacheContext(cachedContext, currentContext);
 }
+
+export interface CurrentBranchState {
+	readonly branch: string | null;
+	readonly repoId: string | null;
+}
+
+export function resolveCurrentBranch(
+	cwd: string,
+	resolveHead: (cwd: string) => GitHeadState | null = git.head.resolveSync,
+): CurrentBranchState {
+	try {
+		const head = resolveHead(cwd);
+		if (!head) return { branch: null, repoId: null };
+		return {
+			branch: head.kind === "ref" ? (head.branchName ?? head.ref) : "detached",
+			repoId: head.headPath,
+		};
+	} catch (error) {
+		if (error instanceof Error) return { branch: null, repoId: null };
+		throw error;
+	}
+}

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

@@ -20,6 +20,7 @@ import {
 	createPrCacheContext,
 	isSamePrCacheContext,
 	type PrCacheContext,
+	resolveCurrentBranch,
 } from "./status-line/git-utils";
 import { getPreset } from "./status-line/presets";
 import { renderSegment, type SegmentContext } from "./status-line/segments";
@@ -303,19 +304,13 @@ export class StatusLineComponent implements Component {
 		this.#cachedPrContext = undefined;
 	}
 	#getCurrentBranch(): string | null {
-		const head = git.head.resolveSync(getProjectDir());
-		const gitHeadPath = head?.headPath ?? null;
-		if (this.#cachedBranch !== undefined && this.#cachedBranchRepoId === gitHeadPath) {
+		const current = resolveCurrentBranch(getProjectDir());
+		if (this.#cachedBranch !== undefined && this.#cachedBranchRepoId === current.repoId) {
 			return this.#cachedBranch;
 		}
 
-		this.#cachedBranchRepoId = gitHeadPath;
-		if (!head) {
-			this.#cachedBranch = null;
-			return null;
-		}
-
-		this.#cachedBranch = head.kind === "ref" ? (head.branchName ?? head.ref) : "detached";
+		this.#cachedBranchRepoId = current.repoId;
+		this.#cachedBranch = current.branch;
 
 		return this.#cachedBranch ?? null;
 	}
@@ -680,7 +675,11 @@ export class StatusLineComponent implements Component {
 		const effectiveSettings = this.#resolveSettings();
 		const separatorDef = getSeparator(effectiveSettings.separator ?? "powerline-thin", theme);
 
-		const bgAnsi = theme.getBgAnsi("statusLineBg");
+		// Use the subtle surface tone (the same elevated background as user-message
+		// bubbles) instead of the heavy `statusLineBg` block, so the rail layers
+		// just above the base background as a quiet zone rather than a solid bar.
+		// Resolving through a semantic slot keeps it correct across every theme.
+		const bgAnsi = theme.getBgAnsi("userMessageBg");
 		const fgAnsi = theme.getFgAnsi("text");
 		const sepAnsi = theme.getFgAnsi("statusLineSep");
 

package/src/modes/components/welcome.ts

@@ -76,9 +76,8 @@ export class WelcomeComponent implements Component {
 	}
 
 	render(termWidth: number): string[] {
-		// Box dimensions - responsive with max width and small-terminal support
-		const maxWidth = 100;
-		const boxWidth = Math.min(maxWidth, Math.max(0, termWidth - 2));
+		// Box dimensions track the live viewport so wide terminals feel intentionally full-screen.
+		const boxWidth = Math.max(0, termWidth - 2);
 		if (boxWidth < 4) {
 			return [];
 		}