@gajae-code/coding-agent 0.11.7 → 0.11.8

package/src/internal-urls/local-protocol.ts

@@ -145,6 +145,8 @@ async function assertDirectoryNotSymlink(directoryPath: string): Promise<void> {
 const LEGACY_MIGRATION_MARKER = ".gjc-local-legacy-migrated-v1";
 const MAX_LEGACY_LOCAL_BYTES = 64 * 1024 * 1024;
 
+type LegacyMigrationState = "complete" | "cleanup_pending";
+
 interface LegacyEntrySnapshot {
 	readonly relativePath: string;
 	readonly dev: bigint;
@@ -334,7 +336,7 @@ async function migrateManagedLegacyLocal(
 	}
 	const staging = path.join(scratchParent, `.gjc-local-migration-${randomUUID()}`);
 	const installed: Array<{ readonly path: string; readonly dev: bigint; readonly ino: bigint }> = [];
-	let installedMarker: { readonly dev: bigint; readonly ino: bigint } | null = null;
+	let sourceRetired = false;
 	try {
 		await fs.mkdir(staging, { mode: 0o700 });
 		for (const entry of captured.entries) {
@@ -360,18 +362,22 @@ async function migrateManagedLegacyLocal(
 			const identity = await fs.lstat(destination, { bigint: true });
 			installed.push({ path: destination, dev: identity.dev, ino: identity.ino });
 		}
+		try {
+			source.retire(captured.snapshot);
+			sourceRetired = true;
+		} catch (error) {
+			if (!(error instanceof Error) || error.message !== "cleanup_pending") throw error;
+			await fs.writeFile(marker, "cleanup_pending\n", { mode: 0o600, flag: "wx" });
+			return;
+		}
 		await fs.writeFile(marker, "verified\n", { mode: 0o600, flag: "wx" });
-		const markerIdentity = await fs.lstat(marker, { bigint: true });
-		installedMarker = { dev: markerIdentity.dev, ino: markerIdentity.ino };
-		source.retire(captured.snapshot);
 	} catch (error) {
-		const currentMarker = await fs.lstat(marker, { bigint: true }).catch(() => null);
-		if (installedMarker && currentMarker?.dev === installedMarker.dev && currentMarker.ino === installedMarker.ino)
-			await fs.rm(marker, { force: true });
-		for (const destination of installed.reverse()) {
-			const current = await fs.lstat(destination.path, { bigint: true }).catch(() => null);
-			if (current?.dev === destination.dev && current.ino === destination.ino)
-				await fs.rm(destination.path, { recursive: true, force: true });
+		if (!sourceRetired) {
+			for (const destination of installed.reverse()) {
+				const current = await fs.lstat(destination.path, { bigint: true }).catch(() => null);
+				if (current?.dev === destination.dev && current.ino === destination.ino)
+					await fs.rm(destination.path, { recursive: true, force: true });
+			}
 		}
 		throw error;
 	} finally {
@@ -379,15 +385,16 @@ async function migrateManagedLegacyLocal(
 	}
 }
 
-async function readMigrationMarker(marker: string): Promise<boolean> {
+async function readMigrationMarker(marker: string): Promise<LegacyMigrationState | null> {
 	try {
 		const snapshot = await snapshotRegularFile(marker, LEGACY_MIGRATION_MARKER);
 		if (snapshot.size > 32n || snapshot.bytes === undefined) throw new Error("Unsafe local:// migration marker");
 		const value = snapshot.bytes.toString("utf8");
-		if (value !== "verified\n" && value !== "absent\n") throw new Error("Unsafe local:// migration marker");
-		return true;
+		if (value === "cleanup_pending\n") return "cleanup_pending";
+		if (value === "verified\n" || value === "absent\n") return "complete";
+		throw new Error("Unsafe local:// migration marker");
 	} catch (error) {
-		if (isEnoent(error)) return false;
+		if (isEnoent(error)) return null;
 		throw error;
 	}
 }
@@ -436,7 +443,17 @@ async function migrateLegacyLocal(
 			}
 			await fs.rename(path.join(staging, entry), path.join(localRoot, entry));
 		}
-		await retireLegacyTree(legacySource.root, manifest);
+		try {
+			await retireLegacyTree(legacySource.root, manifest);
+		} catch (error) {
+			if (
+				!(error instanceof Error) ||
+				error.message !== "Legacy local:// migration retirement failed: cleanup_pending"
+			)
+				throw error;
+			await fs.writeFile(marker, "cleanup_pending\n", { mode: 0o600, flag: "wx" });
+			return;
+		}
 		await fs.writeFile(marker, "verified\n", { mode: 0o600, flag: "wx" });
 	} finally {
 		await fs.rm(staging, { recursive: true, force: true });

package/src/internal-urls/mcp-protocol.ts

@@ -2,29 +2,91 @@ import { MCPManager } from "../runtime-mcp/manager";
 import type { MCPResourceReadResult } from "../runtime-mcp/types";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-function escapeRegex(text: string): string {
-	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const MAX_MCP_RESOURCE_URI_CHARS = 16_384;
+const MAX_MCP_URI_TEMPLATE_CHARS = 8_192;
+const MAX_MCP_URI_TEMPLATE_EXPRESSIONS = 32;
+
+interface CompiledUriTemplate {
+	literalSegments: string[];
+	literalChars: number;
+	expressionCount: number;
+}
+
+function containsExpressionLineTerminator(text: string, start: number, end: number): boolean {
+	for (let index = start; index < end; index++) {
+		const code = text.charCodeAt(index);
+		if (code === 0x0a || code === 0x0d || code === 0x2028 || code === 0x2029) return true;
+	}
+	return false;
+}
+
+function compileUriTemplate(uriTemplate: string): CompiledUriTemplate | undefined {
+	if (uriTemplate.length > MAX_MCP_URI_TEMPLATE_CHARS) return undefined;
+
+	const literalSegments: string[] = [];
+	let expressionCount = 0;
+	let literalChars = 0;
+	let segmentStart = 0;
+	let scanPosition = 0;
+	while (scanPosition < uriTemplate.length) {
+		const expressionStart = uriTemplate.indexOf("{", scanPosition);
+		if (expressionStart < 0) break;
+		const expressionEnd = uriTemplate.indexOf("}", expressionStart + 1);
+		if (expressionEnd < 0) break;
+		if (expressionEnd === expressionStart + 1) {
+			scanPosition = expressionStart + 1;
+			continue;
+		}
+		expressionCount++;
+		if (expressionCount > MAX_MCP_URI_TEMPLATE_EXPRESSIONS) return undefined;
+		const segment = uriTemplate.slice(segmentStart, expressionStart);
+		literalSegments.push(segment);
+		literalChars += segment.length;
+		segmentStart = expressionEnd + 1;
+		scanPosition = segmentStart;
+	}
+	const finalSegment = uriTemplate.slice(segmentStart);
+	literalSegments.push(finalSegment);
+	literalChars += finalSegment.length;
+	return { literalSegments, literalChars, expressionCount };
+}
+
+function matchesUriTemplate(uri: string, template: CompiledUriTemplate): boolean {
+	const { literalSegments, expressionCount } = template;
+	if (expressionCount === 0) return uri === literalSegments[0];
+	if (!uri.startsWith(literalSegments[0])) return false;
+
+	let cursor = literalSegments[0].length;
+	for (let index = 1; index < literalSegments.length - 1; index++) {
+		const segment = literalSegments[index];
+		const matchIndex = uri.indexOf(segment, cursor);
+		if (matchIndex < 0 || containsExpressionLineTerminator(uri, cursor, matchIndex)) return false;
+		cursor = matchIndex + segment.length;
+	}
+
+	const suffix = literalSegments.at(-1) ?? "";
+	const suffixStart = uri.length - suffix.length;
+	return suffixStart >= cursor && uri.endsWith(suffix) && !containsExpressionLineTerminator(uri, cursor, suffixStart);
 }
 
 function getUriTemplateMatchScore(
 	uri: string,
 	uriTemplate: string,
 ): { literalChars: number; expressionCount: number } | undefined {
-	const expressionPattern = /\{[^}]+\}/g;
-	const literalSegments = uriTemplate.split(expressionPattern);
-	const expressionCount = (uriTemplate.match(expressionPattern) ?? []).length;
-	const pattern = literalSegments.map(escapeRegex).join("(.*?)");
-	const regex = new RegExp(`^${pattern}$`);
-	if (!regex.test(uri)) return undefined;
-	const literalChars = literalSegments.reduce((total, segment) => total + segment.length, 0);
-	return { literalChars, expressionCount };
+	const template = compileUriTemplate(uriTemplate);
+	if (!template || !matchesUriTemplate(uri, template)) return undefined;
+	return { literalChars: template.literalChars, expressionCount: template.expressionCount };
 }
 
 function extractResourceUri(url: InternalUrl): string {
 	const host = url.rawHost || url.hostname;
 	const rawPathname = url.rawPathname ?? url.pathname;
 	const hasPath = rawPathname && rawPathname !== "/";
-	const uri = `${host}${hasPath ? rawPathname : ""}${url.search}${url.hash}`.trim();
+	const rawUri = `${host}${hasPath ? rawPathname : ""}${url.search}${url.hash}`;
+	if (rawUri.length > MAX_MCP_RESOURCE_URI_CHARS) {
+		throw new Error("MCP resource URI exceeds the 16384-character limit.");
+	}
+	const uri = rawUri.trim();
 	if (!uri) {
 		throw new Error("mcp:// URL requires a resource URI: mcp://<resource-uri>");
 	}

package/src/main.ts

@@ -11,7 +11,6 @@ import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
 import type { ImageContent } from "@gajae-code/ai";
 import {
-	$env,
 	$pickenv,
 	getAgentDir,
 	getProjectDir,
@@ -1119,6 +1118,27 @@ export function resolveModelRoleOverrides(parsed: Pick<Args, "smol" | "slow" | "
 	if (plan) overrides.plan = plan;
 	return overrides;
 }
+
+/**
+ * Apply the `--no-pty` / `--no-title` terminal-control flags to the environment.
+ *
+ * Sets the canonical `GJC_*` name (so an explicit flag wins over a user-set
+ * `GJC_*` value under the GJC-first resolver — CLI authority) and the legacy
+ * `PI_*` name for backward compatibility. `--acp` mode implies `--no-title`.
+ */
+export function applyTerminalControlFlagsToEnv(
+	parsed: Pick<Args, "noPty" | "noTitle" | "mode">,
+	env: NodeJS.ProcessEnv = Bun.env,
+): void {
+	if (parsed.noPty) {
+		env.GJC_NO_PTY = "1";
+		env.PI_NO_PTY = "1";
+	}
+	if (parsed.noTitle || parsed.mode === "acp") {
+		env.GJC_NO_TITLE = "1";
+		env.PI_NO_TITLE = "1";
+	}
+}
 export async function runRootCommand(
 	parsed: Args,
 	rawArgs: string[],
@@ -1258,12 +1278,7 @@ export async function runRootCommand(
 		applyAcpDefaultSettingOverrides(settingsInstance);
 	}
 	modelRegistry.applyConfiguredModelBindings(settingsInstance);
-	if (parsedArgs.noPty) {
-		Bun.env.PI_NO_PTY = "1";
-	}
-	if (parsedArgs.noTitle || parsedArgs.mode === "acp") {
-		Bun.env.PI_NO_TITLE = "1";
-	}
+	applyTerminalControlFlagsToEnv(parsedArgs);
 	const hasPreparedInput = parsedArgs.messages.length > 0 || parsedArgs.fileArgs.length > 0;
 	const { pipedInput, fileText, fileImages } = await logger.time("prepareInitialMessage", async () => {
 		const pipedInput =
@@ -1613,9 +1628,9 @@ export async function runRootCommand(
 					process.stdout.write(`${chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Alt+N to cycle)")}`)}\n`);
 				}
 
-				if ($env.PI_TIMING) {
+				if ($pickenv("GJC_TIMING", "PI_TIMING")) {
 					logger.printTimings();
-					exitForTiming = $env.PI_TIMING === "x";
+					exitForTiming = $pickenv("GJC_TIMING", "PI_TIMING") === "x";
 				}
 
 				if (!exitForTiming) {
@@ -1660,7 +1675,7 @@ export async function runRootCommand(
 					initialImages,
 					suppressProcessExit: deps.suppressProcessExit,
 				});
-				if ($env.PI_TIMING) {
+				if ($pickenv("GJC_TIMING", "PI_TIMING")) {
 					logger.printTimings();
 				}
 			} finally {

package/src/modes/DESIGN.md

@@ -94,6 +94,11 @@ empty space and list density for an operational setup flow.
   removing line breaks. Notification secrets will use the dedicated masked
   input from Work item 6; they must never appear in list values, descriptions,
   previews, artifacts, or logs.
+### Shortcut labels and binding authority
+
+Keybinding configuration is a portable canonical grammar: textual key IDs use `ctrl`, `alt`, `shift`, and `super` plus a key name (for example, `ctrl+p` or `alt+enter`). Do not serialize or require display-only labels. Runtime UI renders those IDs through the shared formatter for its explicit platform context; macOS uses MacBook-style glyphs (`⌃`, `⌥`, `⇧`, `⌘`, `↩`, `⎋`, `⇥`, `⌫`, `⌦`, and arrow glyphs) while other platforms use textual labels. A glyph is never configuration syntax.
+
+Static onboarding and generated documentation have authority only over shipped defaults. Keep generated tables host-independent by showing canonical textual IDs, not the capture host's labels. The runtime `KeybindingsManager` owns the effective binding set after user remaps and extensions load; `/hotkeys` and runtime hints must render that effective set with the platform context injected by their host. Do not let a static onboarding hint imply that it reflects remaps.
 
 ### Status, errors, confirmation, and disabled work
 

package/src/modes/acp/acp-agent.ts

@@ -42,7 +42,7 @@ import {
 	AcpSdkAdapterError,
 } from "../../sdk/acp";
 import { ensureBroker } from "../../sdk/broker/ensure";
-import { readSdkBrokerDiscovery, SdkClient } from "../../sdk/client";
+import { readSdkBrokerDiscovery, SdkClient, SdkClientError } from "../../sdk/client";
 import { mapAgentWireEventPayloadToAcpSessionUpdates } from "./acp-event-mapper";
 import { resolveAcpPermissionMode } from "./permission-mode";
 import type { AcpStartupOptions } from "./startup-options";
@@ -88,6 +88,7 @@ type PendingAttachment = { epoch: number; task: Promise<void> };
 type SessionRecord = {
 	cwd: string;
 	adapter: AcpSdkAdapter;
+	closeIdempotencyKey: string;
 	unsubscribe: () => void;
 	reconnectUnsubscribe: () => void;
 	/** Per-session frame work queue; callbacks never race prompt ownership. */
@@ -571,8 +572,10 @@ export class AcpAgent implements Agent {
 	readonly #attaching = new Map<string, PendingAttachment>();
 	readonly #resolvingExisting = new Map<string, PendingAttachment>();
 	readonly #knownSessionCwds = new Map<string, string>();
+	readonly #pendingCloseIdempotencyKeys = new Map<string, string>();
 	readonly #sessionEpochs = new Map<string, number>();
 	readonly #tearingDown = new Map<string, number>();
+	readonly #closing = new Map<string, Promise<CloseSessionResponse>>();
 	#clientCapabilities: ClientCapabilities | undefined;
 	#broker: Promise<BrokerConnection> | undefined;
 	readonly #startupOptions: AcpStartupOptions | undefined;
@@ -730,19 +733,21 @@ export class AcpAgent implements Agent {
 		return paginateAcpSessions(listed, params.cwd ?? undefined, this.#cursor(params.cursor));
 	}
 
-	async closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse> {
+	closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse> {
 		const record = this.#sessions.get(params.sessionId);
 		const cwd = record?.cwd ?? this.#knownSessionCwds.get(params.sessionId);
 		// ACP close has no cwd. Only connection-owned sessions may reach broker lifecycle control.
-		if (!cwd) return {};
-		this.#beginTeardown(params.sessionId);
-		try {
-			await this.#teardownSession(params.sessionId, "closed", true);
-			this.#knownSessionCwds.delete(params.sessionId);
-			return {};
-		} finally {
-			this.#finishTeardown(params.sessionId);
-		}
+		if (!cwd) return Promise.resolve({});
+		const existing = this.#closing.get(params.sessionId);
+		if (existing) return existing;
+		const deferred = Promise.withResolvers<CloseSessionResponse>();
+		this.#closing.set(params.sessionId, deferred.promise);
+		void this.#closeOwnedSession(params.sessionId).then(deferred.resolve, deferred.reject);
+		const cleanup = deferred.promise.finally(() => {
+			if (this.#closing.get(params.sessionId) === deferred.promise) this.#closing.delete(params.sessionId);
+		});
+		void cleanup.catch(() => undefined);
+		return deferred.promise;
 	}
 
 	async deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse> {
@@ -932,6 +937,15 @@ export class AcpAgent implements Agent {
 		);
 	}
 
+	#isDefinitiveBrokerResponse(error: unknown): boolean {
+		// Response-derived client errors retain the broker error as details. Responses
+		// that represent ongoing or ambiguous lifecycle work must keep their key.
+		if (!(error instanceof SdkClientError)) return false;
+		const details = object(error.details);
+		if (details?.code !== error.code || details.message !== error.message) return false;
+		return !["terminal_uncertain", "cleanup_pending", "broker_restarting", "unavailable"].includes(error.code);
+	}
+
 	async #attachExisting(id: string, cwd: string): Promise<void> {
 		const epoch = this.#sessionEpoch(id);
 		const attached = this.#sessions.get(id);
@@ -1045,6 +1059,7 @@ export class AcpAgent implements Agent {
 			const record: SessionRecord = {
 				cwd,
 				adapter,
+				closeIdempotencyKey: randomUUID(),
 				unsubscribe: () => {},
 				reconnectUnsubscribe: () => {},
 				frameTail: Promise.resolve(),
@@ -1059,6 +1074,7 @@ export class AcpAgent implements Agent {
 			this.#knownSessionCwds.set(id, cwd);
 			await applyAcpPermissionMode(adapter, this.#clientCapabilities);
 			this.#assertSessionEpoch(id, epoch);
+			this.#pendingCloseIdempotencyKeys.delete(id);
 		} catch (error) {
 			if (adapter && this.#sessions.get(id)?.adapter === adapter) {
 				try {
@@ -1103,6 +1119,21 @@ export class AcpAgent implements Agent {
 		this.#knownSessionCwds.delete(id);
 	}
 
+	async #closeOwnedSession(id: string): Promise<CloseSessionResponse> {
+		this.#beginTeardown(id);
+		try {
+			const attaching = this.#attaching.get(id);
+			// The record is published before permission initialization. Let a canceled
+			// provisional attachment retire it before selecting the generation key.
+			if (attaching) await Promise.allSettled([attaching.task]);
+			await this.#teardownSession(id, "closed", true);
+			this.#knownSessionCwds.delete(id);
+			return {};
+		} finally {
+			this.#finishTeardown(id);
+		}
+	}
+
 	/**
 	 * All local session disposal follows one path: remove ownership and reject a
 	 * waiting prompt before any awaited socket or broker work. A failed close is
@@ -1130,13 +1161,13 @@ export class AcpAgent implements Agent {
 				failures.push(error);
 			}
 			if (closeRemote) {
+				const closeIdempotencyKey =
+					record?.closeIdempotencyKey ?? this.#pendingCloseIdempotencyKeys.get(id) ?? randomUUID();
+				this.#pendingCloseIdempotencyKeys.set(id, closeIdempotencyKey);
 				try {
-					await (await this.#brokerAdapter()).global(
-						"session.close",
-						{ sessionId: id },
-						this.#lifecycleIdempotencyKey(id, "session.close"),
-					);
+					await (await this.#brokerAdapter()).global("session.close", { sessionId: id }, closeIdempotencyKey);
 				} catch (error) {
+					if (this.#isDefinitiveBrokerResponse(error)) this.#pendingCloseIdempotencyKeys.delete(id);
 					if (!(ownershipBound && this.#isAlreadyGone(error))) failures.push(error);
 				}
 			}
@@ -1146,6 +1177,7 @@ export class AcpAgent implements Agent {
 					.join("; ");
 				throw aggregateAcpFailure("terminal_uncertain", `ACP session cleanup is uncertain: ${detail}`, failures);
 			}
+			if (closeRemote) this.#pendingCloseIdempotencyKeys.delete(id);
 		} finally {
 			this.#finishTeardown(id);
 		}
@@ -1494,6 +1526,8 @@ export class AcpAgent implements Agent {
 		this.#attaching.clear();
 		this.#resolvingExisting.clear();
 		this.#knownSessionCwds.clear();
+		this.#pendingCloseIdempotencyKeys.clear();
+		if (this.#closing.size === 0) this.#closing.clear();
 		this.#tearingDown.clear();
 		if (this.#broker) {
 			const broker = this.#broker;

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

@@ -345,6 +345,8 @@ export class ModelSelectorComponent extends Container {
 	#selectedActionIndex: number = 0;
 	#pendingThinkingChoice?: PendingThinkingChoice;
 	#selectedThinkingIndex: number = 0;
+	#assignmentState: "idle" | "assigning" = "idle";
+	#closeAfterAssignment = false;
 
 	// Preset landing state
 	#viewMode: ModelSelectorViewMode = "presets";
@@ -1493,6 +1495,12 @@ export class ModelSelectorComponent extends Container {
 	}
 
 	handleInput(keyData: string): void {
+		if (this.#assignmentState === "assigning") {
+			if (getKeybindings().matches(keyData, "tui.select.cancel")) {
+				this.#closeAfterAssignment = true;
+			}
+			return;
+		}
 		if (this.#pendingThinkingChoice) {
 			this.#handleThinkingMenuInput(keyData);
 			return;
@@ -1861,24 +1869,50 @@ export class ModelSelectorComponent extends Container {
 				? item.selector
 				: formatModelSelectorValue(item.selector, selectedThinkingLevel);
 
-		// Update local state for UI
-		for (const targetRole of roles ?? [role]) {
-			this.#roles[targetRole] = { model: item.model, thinkingLevel: selectedThinkingLevel };
-		}
-
-		// Notify caller (for updating agent state if needed)
-		this.#onSelectCallback({
+		const selection: Extract<ModelSelectorSelection, { kind: "assignment" }> = {
 			kind: "assignment",
 			model: item.model,
 			role,
 			roles,
 			thinkingLevel: selectedThinkingLevel,
 			selector: selectorValue,
-		});
+		};
+		if (this.#isTrackedSingleAssignment(selection)) {
+			void this.#handleTrackedAssignment(selection);
+			return;
+		}
+
+		// Update local state for UI
+		for (const targetRole of roles ?? [role]) {
+			this.#roles[targetRole] = { model: item.model, thinkingLevel: selectedThinkingLevel };
+		}
+
+		// Notify caller (for updating agent state if needed)
+		this.#onSelectCallback(selection);
 
 		// Update list to show new badges
 		this.#updateList();
 	}
+	#isTrackedSingleAssignment(selection: Extract<ModelSelectorSelection, { kind: "assignment" }>): boolean {
+		return selection.role !== null && selection.roles === undefined;
+	}
+
+	async #handleTrackedAssignment(selection: Extract<ModelSelectorSelection, { kind: "assignment" }>): Promise<void> {
+		if (this.#assignmentState !== "idle") return;
+		this.#assignmentState = "assigning";
+		this.#tui.requestRender();
+		try {
+			await Promise.resolve(this.#onSelectCallback(selection));
+		} catch {
+			// The controller reports tracked assignment failures before rethrowing.
+		} finally {
+			this.#assignmentState = "idle";
+			const shouldClose = this.#closeAfterAssignment;
+			this.#closeAfterAssignment = false;
+			if (shouldClose) this.#onCancelCallback();
+			else this.#tui.requestRender();
+		}
+	}
 
 	getSearchInput(): Input {
 		return this.#searchInput;

package/src/modes/components/plan-preview-overlay.ts

@@ -122,7 +122,7 @@ export class PlanPreviewOverlay extends Container {
 				? `${this.#inputKind === "notes" ? "Notes" : `Comment for source line ${this.#sourceLine}`} (Enter save, Esc cancel): ${this.#input.getValue()}`
 				: this.#focus === "sourceSelect"
 					? `Source line ${this.#sourceLine}/${this.lines.length || 1}  j/k:select  c:comment  Esc:done`
-					: `${this.#scroll + 1}-${Math.min(this.#scroll + height, body.length)}/${body.length || 1}  s:source line  n:notes  ${this.options.externalEditorKey ? `${this.options.externalEditorKey.toLowerCase()}:edit  ` : ""}Tab:actions  PgUp/PgDn:page`;
+					: `${this.#scroll + 1}-${Math.min(this.#scroll + height, body.length)}/${body.length || 1}  s:source line  n:notes  ${this.options.externalEditorKey ? `${this.options.externalEditorKey}:edit  ` : ""}Tab:actions  PgUp/PgDn:page`;
 
 		const rendered = [
 			new DynamicBorder().render(width)[0] ?? "",

package/src/modes/components/runtime-mcp-add-wizard.ts

@@ -60,6 +60,7 @@ type WizardStep =
  */
 export interface MCPAddWizardOAuthResult {
 	credentialId: string;
+	tokenEndpoint: string;
 	clientId?: string;
 	clientSecret?: string;
 }
@@ -122,6 +123,7 @@ export class MCPAddWizard extends Container {
 	#onCancelCallback: () => void;
 	#onOAuthCallback:
 		| ((
+				endpointUrl: string,
 				authUrl: string,
 				tokenUrl: string,
 				clientId: string,
@@ -141,6 +143,7 @@ export class MCPAddWizard extends Container {
 		onComplete: (name: string, config: MCPServerConfig, scope: Scope) => void,
 		onCancel: () => void,
 		onOAuth?: (
+			endpointUrl: string,
 			authUrl: string,
 			tokenUrl: string,
 			clientId: string,
@@ -1189,6 +1192,7 @@ export class MCPAddWizard extends Container {
 		try {
 			// Call OAuth handler
 			const oauthResult = await this.#onOAuthCallback(
+				this.#state.url,
 				this.#state.oauthAuthUrl,
 				this.#state.oauthTokenUrl,
 				this.#state.oauthClientId,
@@ -1200,6 +1204,7 @@ export class MCPAddWizard extends Container {
 			// Store credential ID + any dynamically-registered client credentials,
 			// so the final mcp.json entry persists everything needed for refresh.
 			this.#state.oauthCredentialId = oauthResult.credentialId;
+			this.#state.oauthTokenUrl = oauthResult.tokenEndpoint;
 			if (oauthResult.clientId) this.#state.oauthClientId = oauthResult.clientId;
 			if (oauthResult.clientSecret) this.#state.oauthClientSecret = oauthResult.clientSecret;
 

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

@@ -3,8 +3,12 @@ import * as fs from "node:fs";
 import { type Component, truncateToWidth, visibleWidth } from "@gajae-code/tui";
 import { formatCount, getProjectDir } from "@gajae-code/utils";
 import { $ } from "bun";
-import type { AppKeybinding, KeybindingsManager } from "../../config/keybindings";
-import { KEYBINDINGS } from "../../config/keybindings";
+import {
+	type AppKeybinding,
+	KEYBINDINGS,
+	type KeybindingsManager,
+	type KeyDisplayContext,
+} from "../../config/keybindings";
 import { settings } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import { theme } from "../../modes/theme/theme";
@@ -56,6 +60,7 @@ export interface StatusLineComponentOptions {
 	actionRegistry?: ActionRegistry<void>;
 	getKeybindings?: () => KeybindingsManager;
 	focusDomain?: FocusDomain;
+	keyDisplayContext?: KeyDisplayContext;
 }
 
 export interface StatusLineActionHint {
@@ -93,6 +98,7 @@ export function getAvailableActionHints(
 	getKeybindings: (() => KeybindingsManager) | undefined,
 	width: number,
 	domain: FocusDomain = "composer",
+	keyDisplayContext?: KeyDisplayContext,
 ): StatusLineActionHint[] {
 	if (!actionRegistry || !getKeybindings || width <= 0) return [];
 	const keybindings = getKeybindings();
@@ -109,7 +115,9 @@ export function getAvailableActionHints(
 		if (!(bindingId in KEYBINDINGS)) continue;
 		const keys = keybindings.getKeys(bindingId);
 		if (keys.length === 0) continue;
-		const content = theme.fg("dim", keybindings.getDisplayString(bindingId)) + theme.fg("muted", ` ${action.title}`);
+		const content =
+			theme.fg("dim", keybindings.getDisplayString(bindingId, keyDisplayContext)) +
+			theme.fg("muted", ` ${action.title}`);
 		const nextWidth = visibleWidth(content) + (selected.length === 0 ? 0 : 3);
 		if (used + nextWidth > width) break;
 		selected.push({ id: action.id, content });
@@ -161,6 +169,7 @@ export class StatusLineComponent implements Component {
 	#actionRegistry: ActionRegistry<void> | undefined;
 	#getKeybindings: (() => KeybindingsManager) | undefined;
 	#focusDomain: FocusDomain;
+	#keyDisplayContext: KeyDisplayContext | undefined;
 
 	#resolvedSettingsCache:
 		| (Required<Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">> &
@@ -209,6 +218,7 @@ export class StatusLineComponent implements Component {
 		this.#actionRegistry = options.actionRegistry;
 		this.#getKeybindings = options.getKeybindings;
 		this.#focusDomain = options.focusDomain ?? "composer";
+		this.#keyDisplayContext = options.keyDisplayContext;
 	}
 
 	updateSettings(settings: StatusLineSettings): void {
@@ -796,7 +806,13 @@ export class StatusLineComponent implements Component {
 		const actionHints =
 			effectiveSettings.showActionHints === false
 				? []
-				: getAvailableActionHints(this.#actionRegistry, this.#getKeybindings, width, this.#focusDomain);
+				: getAvailableActionHints(
+						this.#actionRegistry,
+						this.#getKeybindings,
+						width,
+						this.#focusDomain,
+						this.#keyDisplayContext,
+					);
 		for (const segId of effectiveSettings.rightSegments) {
 			const rendered = renderSegment(segId, ctx);
 			if (rendered.visible && rendered.content) {