@gajae-code/coding-agent 0.17.1 → 0.17.2

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

@@ -46,14 +46,20 @@ import {
 	AcpSdkAdapterError,
 	acpMcpLaunchFailure,
 } from "../../sdk/acp";
-import { resolveAcpFinalText } from "../../sdk/acp/final-text";
+import { hasAcpFinalTextContent, resolveAcpFinalText } from "../../sdk/acp/final-text";
 import type { SessionLifecycleMcpServer } from "../../sdk/acp/mcp";
 import { ensureBroker } from "../../sdk/broker/ensure";
 import { canonicalSessionCwd } from "../../sdk/broker/session-index";
 import { readSdkBrokerDiscovery, SdkClient, SdkClientError } from "../../sdk/client";
 import type { AbortScope } from "../../sdk/host/control/operations";
 import { SYNTHETIC_PROVIDER_ID } from "../../sdk/model-profile-namespace";
-import { failedPromptOutcome, isSdkPromptFailurePhase, rephaseFailedOutcome } from "../../sdk/prompt-failure";
+import {
+	failedPromptOutcome,
+	isSafePromptFailureCode,
+	isSdkPromptFailurePhase,
+	promptFailureRetryability,
+	rephaseFailedOutcome,
+} from "../../sdk/prompt-failure";
 import type { SdkPromptTerminalOutcome } from "../../sdk/prompt-status";
 import { PromptActivity, type PromptWatchdogClock, systemPromptWatchdogClock } from "../../sdk/prompt-watchdog";
 import { validateRequiredPromptText } from "../../sdk/protocol/adapter-validation";
@@ -177,6 +183,8 @@ interface PromptWaiter {
 	lastFrameAt: number;
 	/** Type of that prompt-owned frame, reported when the watchdog expires. */
 	lastFrameType: string;
+	/** True while the prompt is blocked in provider preflight, before the turn is dispatched. */
+	awaitingProviderPreflight: boolean;
 	/** Cancels the armed inactivity watchdog; re-armed by prompt-owned frames. */
 	cancelWatchdog?: () => void;
 	/** What the host is observably doing — a tool running, a model call unanswered — and the bound that follows from it. */
@@ -185,6 +193,12 @@ interface PromptWaiter {
 	observedTurnActivity: boolean;
 	/** True once a prompt-owned tool execution frame was observed; vetoes a first-turn retry that would re-run it. */
 	observedToolExecution: boolean;
+	/**
+	 * Newest `plan` update published for this prompt, retained so an abandoned turn can report
+	 * what it had left to do (issue #5669). Absent means no plan was ever observed, which is
+	 * evidence of nothing — distinct from an observed plan whose entries are all `completed`.
+	 */
+	planSnapshot?: AcpPlanSnapshot;
 	/** Coordinates a prompt-control rejection racing an acknowledged ACP cancellation. */
 	cancelAttempt?: Promise<boolean>;
 	/** Whether ANY overlapping cancel attempt for this prompt was acknowledged:
@@ -618,7 +632,7 @@ type SdkPromptFailedOutcome = Extract<SdkPromptTerminalOutcome, { kind: "failed"
  * category — so settlement carries that classification instead of discarding it into a bare
  * `AcpSdkAdapterError` (review P1, issue #5574).
  */
-class AcpPromptFailureError extends AcpSdkAdapterError {
+export class AcpPromptFailureError extends AcpSdkAdapterError {
 	readonly failure: SdkPromptFailedOutcome;
 	constructor(failure: SdkPromptFailedOutcome) {
 		super(failure.code, failure.message);
@@ -626,6 +640,103 @@ class AcpPromptFailureError extends AcpSdkAdapterError {
 	}
 }
 
+/**
+ * The wire projection of a prompt terminal's classification (issue #5615).
+ *
+ * `super(failure.code, failure.message)` above narrows the error to the generic
+ * `prompt_failed` plus its fixed redacted message, so the classification the
+ * terminal already computed used to die at the JSON-RPC boundary: an ACP client
+ * saw only `-32603 {code, details}` and could not tell a transient provider blip
+ * from a dead session without parsing English. These fields carry it across.
+ *
+ * `providerCode` is re-checked against the safe-token rule rather than trusted:
+ * `terminalOutcome` accepts the host's `providerCode` on a `typeof` check alone,
+ * and this is the first path that puts it on the wire, so an unbounded value is
+ * dropped instead of becoming a leak of provider text (the redaction contract in
+ * `sanitizePromptFailure`). A dropped or absent code is omitted, never nulled.
+ */
+function promptFailureWireData(failure: SdkPromptFailedOutcome): Record<string, string> {
+	return {
+		phase: failure.phase,
+		category: failure.category,
+		retryability: promptFailureRetryability(failure.category),
+		...(isSafePromptFailureCode(failure.providerCode) ? { providerCode: failure.providerCode } : {}),
+	};
+}
+
+/**
+ * What an ACP `plan` update said the turn intended to do. Structural rather than the SDK's
+ * `PlanEntry` so only the fields this evidence reads are depended on.
+ */
+type AcpPlanSnapshot = Array<{
+	content: string;
+	status: "pending" | "in_progress" | "completed";
+	_meta?: { gjcTodoStatus?: unknown } | null;
+}>;
+
+/**
+ * An abandoned prompt that still carries the plan its turn was working through (issue #5669).
+ *
+ * The watchdog settles a prompt whose host stopped producing frames, and that rejection used to
+ * be a bare `AcpSdkAdapterError`: `{code, details}` and nothing else. A wrapper could not tell
+ * "the agent finished" from "the agent stopped with work left", so an abandoned turn's unverified
+ * diff was published as if it were complete. The last observed plan is the evidence that settles
+ * that question, so settlement carries it instead of dropping it at the JSON-RPC boundary.
+ */
+export class AcpPromptAbandonedError extends AcpSdkAdapterError {
+	readonly plan: AcpPlanSnapshot | undefined;
+	constructor(code: string, message: string, plan: AcpPlanSnapshot | undefined) {
+		super(code, message);
+		this.plan = plan;
+	}
+}
+
+/** Most pending plan entries that may reach the wire. */
+const ACP_ABANDON_PLAN_MAX_ENTRIES = 10;
+/** Longest one pending entry's text may be on the wire. */
+const ACP_ABANDON_PLAN_MAX_CONTENT_CHARS = 200;
+
+/**
+ * Whether a plan entry describes work the turn never finished (issue #5669).
+ *
+ * An entry whose ACP status is `completed` can still be unfinished: ACP's `PlanEntryStatus` has no
+ * `abandoned` member, so a task dropped via `/todo drop` is projected as `completed` for the
+ * client's plan UI while the mapper keeps the internal status in `_meta.gjcTodoStatus`. Completion
+ * evidence has to read that internal truth — reading the wire status alone would report a plan of
+ * nothing but dropped tasks as a finished turn. `_meta` crosses a JSON boundary, so the internal
+ * status is compared as `unknown` rather than asserted into a type.
+ */
+function planEntryUnfinished(entry: AcpPlanSnapshot[number]): boolean {
+	return entry.status !== "completed" || entry._meta?.gjcTodoStatus === "abandoned";
+}
+
+/**
+ * The wire projection of an abandoned prompt's plan (issue #5669).
+ *
+ * Plan text is model-authored, so it is bounded the same way `promptFailureWireData` bounds a
+ * provider classifier: a capped number of entries, each capped in length, and never restated in
+ * the human message. The counts are what a wrapper actually gates on; the contents are there so
+ * the reader can name the unfinished steps without a log dive.
+ *
+ * An absent plan yields no keys at all. "No plan was ever observed" is not the same claim as
+ * "the plan was complete", and a client must be able to tell them apart, so the fields are
+ * omitted rather than nulled or reported as unknown.
+ */
+function promptAbandonWireData(plan: AcpPlanSnapshot | undefined): Record<string, string> {
+	if (!plan) return {};
+	const pending = plan.filter(planEntryUnfinished);
+	return {
+		planIncomplete: pending.length > 0 ? "true" : "false",
+		planPendingCount: String(pending.length),
+		planTotalCount: String(plan.length),
+		planPending: JSON.stringify(
+			pending
+				.slice(0, ACP_ABANDON_PLAN_MAX_ENTRIES)
+				.map(entry => entry.content.slice(0, ACP_ABANDON_PLAN_MAX_CONTENT_CHARS)),
+		),
+	};
+}
+
 /**
  * The startup-readiness failure class (issue #5574): the turn failed AFTER it started, with a
  * bounded provider/transport classifier — the signature of a host that accepted the turn before
@@ -1251,9 +1362,21 @@ export function acpRequestFailure(error: unknown): unknown {
 	const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
 	if (typeof code !== "string") return error;
 	const message = error instanceof Error ? error.message : code;
+	// A prompt terminal additionally publishes its classification (issue #5615). The
+	// spread is empty for every other error, so their payloads are byte-identical to
+	// before. `code`/`details` and the JSON-RPC code itself are untouched either way:
+	// this enriches `data`, it does not restate the redacted message.
+	const data =
+		error instanceof AcpPromptFailureError
+			? { code, details: message, ...promptFailureWireData(error.failure) }
+			: { code, details: message };
+	// An abandoned prompt additionally publishes the plan it never finished (issue #5669).
+	// Same rule as above: `code`/`details` and the JSON-RPC code are untouched, and an abandon
+	// that observed no plan adds no keys, so its payload stays byte-identical to before.
+	if (error instanceof AcpPromptAbandonedError) Object.assign(data, promptAbandonWireData(error.plan));
 	switch (code) {
 		case "authentication_failed":
-			return RequestError.authRequired({ code, details: message }, message);
+			return RequestError.authRequired(data, message);
 		// `not_found` stays -32603 with its discriminator in `data`: ACP's
 		// `resourceNotFound` (-32002) is a URI-addressed resource error, and an unknown
 		// session id is not a resource URI. Pinned ACP core-v1 conformance also requires
@@ -1261,12 +1384,15 @@ export function acpRequestFailure(error: unknown): unknown {
 		case "invalid_input":
 		case "unsupported":
 		case "unsupported_content":
-			return RequestError.invalidParams({ code, details: message }, message);
+			return RequestError.invalidParams(data, message);
 		default:
 			// The remaining internal codes (conflict, unavailable, busy, …) have no ACP
 			// counterpart and stay -32603. Keep the discriminator in `data` so a client can
-			// branch on retry/reconnect instead of parsing an English message.
-			return RequestError.internalError({ code, details: message }, message);
+			// branch on retry/reconnect instead of parsing an English message. `prompt_failed`
+			// and `prompt_deadline_exceeded` land here and keep -32603 by design: pinned ACP
+			// core-v1 conformance expects -32603/-32000 for this class, so the added
+			// classification travels in `data` rather than in a renumbered code.
+			return RequestError.internalError(data, message);
 	}
 }
 
@@ -2055,6 +2181,7 @@ export class AcpAgent implements Agent {
 			deferredActivityFrames: [],
 			lastFrameAt: this.#promptWatchdogClock.now(),
 			lastFrameType: "prompt_dispatch",
+			awaitingProviderPreflight: true,
 			activity: new PromptActivity(),
 			observedTurnActivity: false,
 			observedToolExecution: false,
@@ -2066,9 +2193,24 @@ export class AcpAgent implements Agent {
 		// pending. Retain the original promise for the caller, but mark that delayed rejection
 		// as observed until prompt() can resume and await it.
 		void response.catch(() => undefined);
+		// Silence has to be bounded from the moment the prompt owns the session: a host that
+		// dies before it ever answers is exactly the failure that leaves the client running.
+		// Provider preflight is part of that window — it awaits a lease the host may never win
+		// — so the bound is armed before it, not after (issue #5658). The arm below re-arms
+		// this same waiter once preflight clears, and #armPromptWatchdog cancels the previous
+		// timer first, so only one timer is ever live.
+		this.#armPromptWatchdog(params.sessionId, record, waiter);
+		// The watchdog settles `response`, not this await, so a preflight that never returns
+		// would pin session/prompt open with the caller's promise already rejected. Racing the
+		// settlement lets the re-checks below hand that rejection back to the caller.
+		const settlement = response.then(
+			() => undefined,
+			() => undefined,
+		);
 		try {
-			await record.adapter.ensureProviders();
+			await Promise.race([record.adapter.ensureProviders(), settlement]);
 		} catch (error) {
+			waiter.awaitingProviderPreflight = false;
 			if (waiter.settled || record.activePrompt !== waiter) {
 				this.#retiredPromptAcknowledgements.delete(params.sessionId);
 				return await response;
@@ -2081,11 +2223,13 @@ export class AcpAgent implements Agent {
 			if (record.activePrompt === waiter) {
 				record.activePrompt = undefined;
 				record.busy = record.backgroundBusy;
+				clearPromptWatchdog(waiter);
 				this.#retiredPromptAcknowledgements.delete(params.sessionId);
 				void this.#publishPromptPhaseIdle(params.sessionId, record.adapter);
 			}
 			throw error;
 		}
+		waiter.awaitingProviderPreflight = false;
 		if (waiter.settled || record.activePrompt !== waiter) {
 			this.#retiredPromptAcknowledgements.delete(params.sessionId);
 			return await response;
@@ -2096,8 +2240,9 @@ export class AcpAgent implements Agent {
 			return await response;
 		}
 
-		// Silence has to be bounded from the moment the prompt owns the session: a host that
-		// dies before it ever answers is exactly the failure that leaves the client running.
+		// Re-arm now that preflight is behind us: the bound armed before it already covered
+		// this prompt's ownership window, and this call replaces that timer rather than
+		// racing it, so the dispatched turn gets the full inactivity bound of its own.
 		this.#armPromptWatchdog(params.sessionId, record, waiter);
 		// Echo the user's own message back as `user_message_chunk`. Clients render their
 		// transcript from session/update, so without this a prompt's text and any attached
@@ -3257,15 +3402,32 @@ export class AcpAgent implements Agent {
 	async #expirePromptWatchdog(id: string, record: SessionRecord, waiter: PromptWaiter): Promise<void> {
 		if (record.activePrompt !== waiter || waiter.settled || waiter.terminalReserved) return;
 		const silenceMs = Math.max(0, this.#promptWatchdogClock.now() - waiter.lastFrameAt);
-		const cause = this.#promptTransportGone(id, record) ?? "the SDK session host stopped producing frames";
+		// A prompt still in preflight has never reached the host, so "stopped producing frames"
+		// would point the reader at the wrong phase: nothing was ever dispatched to produce them.
+		const cause =
+			this.#promptTransportGone(id, record) ??
+			(waiter.awaitingProviderPreflight
+				? "the SDK session host never finished provider preflight"
+				: "the SDK session host stopped producing frames");
+		// Counts only: the plan's contents are model-authored and belong on the bounded wire
+		// projection, not in the log line (issue #5669).
+		const plan = waiter.planSnapshot;
 		logger.error("acp_prompt_watchdog_expired", {
 			sessionId: id,
 			cause,
 			silenceMs,
 			lastFrameType: waiter.lastFrameType,
+			awaitingProviderPreflight: waiter.awaitingProviderPreflight,
 			inactivityBoundMs: waiter.activity.inactivityBoundMs,
 			toolRunning: waiter.activity.running,
 			awaitingModel: waiter.activity.awaitingModel,
+			...(plan
+				? {
+						planIncomplete: plan.some(planEntryUnfinished),
+						planPendingCount: plan.filter(planEntryUnfinished).length,
+						planTotalCount: plan.length,
+					}
+				: {}),
 			...(waiter.correlation.commandId ? { commandId: waiter.correlation.commandId } : {}),
 			...(waiter.correlation.turnId ? { turnId: waiter.correlation.turnId } : {}),
 		});
@@ -3273,11 +3435,12 @@ export class AcpAgent implements Agent {
 			record,
 			id,
 			waiter,
-			new AcpSdkAdapterError(
+			new AcpPromptAbandonedError(
 				"prompt_abandoned",
 				`ACP prompt was abandoned after ${Math.round(silenceMs / 1_000)}s of silence: ${cause}. Last frame was ` +
 					`"${waiter.lastFrameType}" (${describeCorrelation(waiter.correlation)}). The turn was settled so the ` +
 					`client stops waiting; the session still accepts the next prompt.`,
+				plan,
 			),
 		);
 	}
@@ -3467,7 +3630,11 @@ export class AcpAgent implements Agent {
 			// the first-turn retry gate — which the settlement below releases — would see
 			// "started, no output", resubmit, and let BOTH this terminal's final text and the
 			// retry's answer reach ACP consumers. Record the output before settling (review P1).
-			if (typeof event.finalText === "string" && event.finalText) record.promptObservedAssistantOutput = true;
+			// Whitespace-only final text carries no assistant content. `hasAcpFinalTextContent` is the
+			// single presence predicate shared with the terminal publication gate below, so a terminal
+			// this gate treats as "no output" can never publish a chunk alongside the retry's answer.
+			if (typeof event.finalText === "string" && hasAcpFinalTextContent(event.finalText))
+				record.promptObservedAssistantOutput = true;
 			// Failure diagnostics are useful but advisory. Settle before any mapped
 			// session update can await a backpressured client transport; otherwise an
 			// already-decided failure can still lose to the inactivity watchdog.
@@ -3534,6 +3701,12 @@ export class AcpAgent implements Agent {
 				notification.update.content.type === "text"
 			)
 				promptOwner.emittedAssistantText += notification.update.content.text;
+			// The newest plan REPLACES the retained one: a plan update is the whole list, not a
+			// delta, so `todo_auto_clear`'s empty `entries` correctly leaves no pending work behind
+			// (issue #5669). Retained here rather than at frame ingress because this is where the
+			// mapper has already decided what the client is being told the plan is.
+			if (promptOwner && notification.update.sessionUpdate === "plan")
+				promptOwner.planSnapshot = notification.update.entries;
 			// A live assistant text/thought chunk for this prompt owner has now been exposed to
 			// ACP consumers. Record it so the first-turn readiness retry is vetoed: a re-submit
 			// would deliver a second attempt's output on top of these chunks (issue #5574).
@@ -3628,7 +3801,7 @@ export class AcpAgent implements Agent {
 		if (promptOwner) this.#flushFailureDiagnostics(id, promptOwner, adapter);
 		let decorationStart = Promise.resolve();
 		const finalText = typeof event.finalText === "string" ? event.finalText : "";
-		if (promptOwner && finalText) {
+		if (promptOwner && hasAcpFinalTextContent(finalText)) {
 			const finalTextTask = (async () => {
 				await Bun.sleep(0);
 				const resolution = resolveAcpFinalText(promptOwner.emittedAssistantText, finalText);

package/src/modes/acp/acp-event-mapper.ts

@@ -239,6 +239,7 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 				content: todo.content,
 				priority: "medium" as const,
 				status: mapTodoStatus(todo.status),
+				_meta: { gjcTodoStatus: todo.status },
 			}));
 			return [toSessionNotification(sessionId, { sessionUpdate: "plan", entries })];
 		}
@@ -502,6 +503,13 @@ function toSessionNotification(sessionId: string, update: SessionUpdate): Sessio
 	return { sessionId, update };
 }
 
+/**
+ * ACP's `PlanEntryStatus` has only three members, so an `abandoned` todo has to be projected as
+ * one of them and `completed` is the one that stops a client's plan UI from showing a dropped task
+ * as outstanding work. That projection is lossy, so every plan entry also carries the internal
+ * status as `_meta.gjcTodoStatus` for readers that need the truth rather than the rendering
+ * (issue #5669).
+ */
 const todoStatusMap: Record<TodoStatus, "pending" | "in_progress" | "completed"> = {
 	pending: "pending",
 	in_progress: "in_progress",
@@ -529,6 +537,7 @@ function mapTodoWriteResultToPlanUpdate(
 			content: todo.content,
 			priority: "medium" as const,
 			status: mapTodoStatus(todo.status),
+			_meta: { gjcTodoStatus: todo.status },
 		})),
 	};
 }

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

@@ -1,5 +1,11 @@
 import { ThinkingLevel } from "@gajae-code/agent-core";
-import { getSupportedEfforts, type Model, modelSupportsServiceTier, modelsAreEqual } from "@gajae-code/ai/core";
+import {
+	getMiniMaxThinkingMode,
+	getSupportedEfforts,
+	type Model,
+	modelSupportsServiceTier,
+	modelsAreEqual,
+} from "@gajae-code/ai/core";
 import {
 	Container,
 	fuzzyFilter,
@@ -26,6 +32,7 @@ import type { BillingPath } from "../../config/billing-path";
 import {
 	getProxyRoutableProviders,
 	inspectProxyProviderId,
+	isModelProfileProxyConfigured,
 	requiresQualifiedModelProfileRoleResolution,
 	resolveProxyMode,
 	rewriteSelectorForProxy,
@@ -426,6 +433,7 @@ export class ModelSelectorComponent extends Container {
 	#presetScopeMenuOpen: boolean = false;
 	#presetScopeIndex: number = 0;
 	#providerAuthById = new Map<string, boolean>();
+	#credentiallessProviders = new Set<string>();
 	#bareProfileAuthByName = new Map<string, boolean>();
 	// Rebuilt with the provider and bare-selector snapshots on every catalog or credential refresh.
 	#profileAuthByName = new Map<string, boolean>();
@@ -1441,17 +1449,16 @@ export class ModelSelectorComponent extends Container {
 				const proxyProvider = tryResolveProxyProviderId(this.#settings);
 				if (
 					proxyProvider !== undefined &&
-					!(this.#modelRegistry.getConfiguredProviderIds?.() ?? []).includes(proxyProvider)
+					!isModelProfileProxyConfigured(
+						proxyProvider,
+						this.#modelRegistry.getConfiguredProviderIds?.(),
+						this.#credentiallessProviders.has(proxyProvider),
+					)
 				)
 					return false;
 				try {
 					if (resolveProxyMode(this.#settings) === "always") {
-						const configuredProviders = this.#modelRegistry.getConfiguredProviderIds?.() ?? [];
-						if (
-							proxyProvider === undefined ||
-							this.#isProviderAuthenticated(proxyProvider) !== true ||
-							!configuredProviders.includes(proxyProvider)
-						)
+						if (proxyProvider === undefined || this.#isProviderAuthenticated(proxyProvider) !== true)
 							return false;
 					}
 				} catch {
@@ -1530,6 +1537,7 @@ export class ModelSelectorComponent extends Container {
 	async #refreshProviderAuth(): Promise<void> {
 		const refreshGeneration = ++this.#providerAuthRefreshGeneration;
 		this.#providerAuthById = new Map();
+		this.#credentiallessProviders = new Set();
 		this.#bareProfileAuthByName = new Map();
 		this.#profileAuthByName = new Map();
 		const availableModels = this.#getProfileAvailableModels();
@@ -1586,9 +1594,9 @@ export class ModelSelectorComponent extends Container {
 				[...providers].map(async provider => {
 					try {
 						const apiKey = await this.#modelRegistry.getApiKeyForProvider(provider, this.#authSessionId);
-						return [provider, apiKey === kNoAuth || isAuthenticated(apiKey)] as const;
+						return [provider, apiKey === kNoAuth || isAuthenticated(apiKey), apiKey === kNoAuth] as const;
 					} catch {
-						return [provider, false] as const;
+						return [provider, false, false] as const;
 					}
 				}),
 			);
@@ -1598,7 +1606,10 @@ export class ModelSelectorComponent extends Container {
 				refreshGeneration !== this.#providerAuthRefreshGeneration
 			)
 				return;
-			this.#providerAuthById = new Map(entries);
+			this.#providerAuthById = new Map(entries.map(([provider, authenticated]) => [provider, authenticated]));
+			this.#credentiallessProviders = new Set(
+				entries.filter(([, , keyless]) => keyless).map(([provider]) => provider),
+			);
 			const profileAuthEntries = await Promise.all(
 				[...this.#getPresetGroups().values()].flat().map(async profile => {
 					const bindings = resolveProfileBindings(profile);
@@ -1853,7 +1864,7 @@ export class ModelSelectorComponent extends Container {
 		const modelLabel = sanitizeText(`${model.provider}/${model.id}`).replace(/\s+/g, " ").trim();
 		let label = modelLabel;
 		if (thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit) {
-			label += ` (${getThinkingLevelMetadata(thinkingLevel).label})`;
+			label += ` (${getThinkingLevelMetadata(thinkingLevel, model).label})`;
 		}
 		const billing = this.#billingPathForModel(model)?.label;
 		if (billing) label += ` [${billing}]`;
@@ -2214,7 +2225,7 @@ export class ModelSelectorComponent extends Container {
 				const assigned = this.#roles[role];
 				if (roleInfo.tag && assigned && modelsAreEqual(assigned.model, item.model)) {
 					const badge = makeInvertedBadge(roleInfo.tag, roleInfo.color ?? "muted");
-					const thinkingLabel = getThinkingLevelMetadata(assigned.thinkingLevel).label;
+					const thinkingLabel = getThinkingLevelMetadata(assigned.thinkingLevel, item.model).label;
 
 					// Subagent roles (task.agentModelOverrides) run under task.serviceTier,
 					// so their ⚡ uses the effective subagent tier. A non-subagent
@@ -2326,6 +2337,11 @@ export class ModelSelectorComponent extends Container {
 	#renderActionMenu(item: ModelItem | CanonicalModelItem): void {
 		this.#listContainer.addChild(new Spacer(1));
 		this.#listContainer.addChild(new Text(theme.fg("muted", `  Action for: ${item.model.id}`), 0, 0));
+		if (getMiniMaxThinkingMode(item.model) === "always-on") {
+			this.#listContainer.addChild(
+				new Text(theme.fg("muted", "  Reasoning: always on; effort control is unsupported"), 0, 0),
+			);
+		}
 		this.#listContainer.addChild(new Spacer(1));
 		const actionCount = this.#getActionCount(item.model);
 		for (let i = 0; i < actionCount; i++) {
@@ -2390,7 +2406,7 @@ export class ModelSelectorComponent extends Container {
 		// Show the highlighted reasoning level — never the model id (that mislabel
 		// made "Reasoning for Default: gpt-5.6-luna" look like a level).
 		const selectedLevel = choice.levels[this.#selectedThinkingIndex];
-		const selectedLevelLabel = selectedLevel ? getThinkingLevelMetadata(selectedLevel).label : "—";
+		const selectedLevelLabel = selectedLevel ? getThinkingLevelMetadata(selectedLevel, choice.item.model).label : "—";
 		this.#listContainer.addChild(new Spacer(1));
 		this.#listContainer.addChild(
 			new Text(theme.fg("muted", `  Reasoning for ${targetLabel}: ${selectedLevelLabel}`), 0, 0),
@@ -2398,7 +2414,7 @@ export class ModelSelectorComponent extends Container {
 		this.#listContainer.addChild(new Spacer(1));
 		for (let i = 0; i < choice.levels.length; i++) {
 			const level = choice.levels[i];
-			const metadata = getThinkingLevelMetadata(level);
+			const metadata = getThinkingLevelMetadata(level, choice.item.model);
 			const prefix = i === this.#selectedThinkingIndex ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
 			const label = `${metadata.label} — ${metadata.description}`;
 			this.#listContainer.addChild(

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

@@ -1,9 +1,11 @@
 import * as os from "node:os";
 import * as path from "node:path";
 import { ThinkingLevel } from "@gajae-code/agent-core";
+import { getMiniMaxThinkingMode } from "@gajae-code/ai/model-thinking";
 import { TERMINAL, truncateToWidth } from "@gajae-code/tui";
 import { formatDuration, formatNumber, getProjectDir, pathIsWithin, relativePathWithinRoot } from "@gajae-code/utils";
 import { type ThemeColor, theme } from "../../../modes/theme/theme";
+import { getThinkingLevelMetadata } from "../../../thinking";
 import { shortenPath } from "../../../tools/render-utils";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../../../utils/session-color";
 import { sanitizeStatusText } from "../../shared";
@@ -113,7 +115,10 @@ const modelSegment: StatusLineSegment = {
 		}
 
 		// Add thinking level with dot separator
-		if (opts.showThinkingLevel !== false && state.model?.thinking) {
+		const miniMaxMode = state.model && getMiniMaxThinkingMode(state.model);
+		if (opts.showThinkingLevel !== false && miniMaxMode) {
+			content += `${theme.sep.dot}${getThinkingLevelMetadata(state.thinkingLevel ?? ThinkingLevel.Off, state.model).label}`;
+		} else if (opts.showThinkingLevel !== false && state.model?.thinking) {
 			const level = state.thinkingLevel ?? ThinkingLevel.Off;
 			if (level !== ThinkingLevel.Off) {
 				const thinkingText = theme.thinking[level as keyof typeof theme.thinking];

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

@@ -1,7 +1,8 @@
 import { ThinkingLevel, type ThinkingLevel as ThinkingLevelValue } from "@gajae-code/agent-core";
+import type { Model } from "@gajae-code/ai/types";
 import { Container, type SelectItem, SelectList, Text } from "@gajae-code/tui";
 import { getSelectListTheme, theme } from "../../modes/theme/theme";
-import { getThinkingLevelMetadata, type ThinkingLevelValue as ThinkingMetadataValue } from "../../thinking-metadata";
+import { getThinkingLevelMetadata } from "../../thinking";
 import { DynamicBorder } from "./dynamic-border";
 
 const SCOPE_ITEMS = [
@@ -31,21 +32,24 @@ export class ThinkingSelectorComponent extends Container {
 	#selectedLevel: ThinkingLevelValue | undefined;
 	readonly #onSelect: (selection: ThinkingSelectorSelection) => void;
 	readonly #onCancel: () => void;
+	readonly #model: Model | undefined;
 
 	constructor(
 		currentLevel: ThinkingLevelValue | undefined,
 		availableLevels: ThinkingLevelValue[],
 		onSelect: (selection: ThinkingSelectorSelection) => void,
 		onCancel: () => void,
+		model?: Model,
 	) {
 		super();
 
 		this.#onSelect = onSelect;
 		this.#onCancel = onCancel;
+		this.#model = model;
 
 		const currentValue = currentLevel ?? ThinkingLevel.Off;
 		const thinkingLevels: SelectItem[] = availableLevels.map(level => {
-			const metadata = getThinkingLevelMetadata(level as ThinkingMetadataValue);
+			const metadata = getThinkingLevelMetadata(level, model);
 			return level === currentValue
 				? { ...metadata, label: metadata.label + theme.fg("muted", " (current)") }
 				: metadata;
@@ -96,7 +100,7 @@ export class ThinkingSelectorComponent extends Container {
 			this.#renderLevelList();
 		};
 
-		const metadata = getThinkingLevelMetadata(level as ThinkingMetadataValue);
+		const metadata = getThinkingLevelMetadata(level, this.#model);
 		this.detachAll();
 		this.#selectList = scopeList;
 		this.addChild(new DynamicBorder());

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

@@ -4,6 +4,7 @@ import {
 	type Api,
 	type AuthCredentialSelector,
 	type CredentialRemovalTarget,
+	getMiniMaxThinkingMode,
 	isSqliteCorruptionError,
 	isSqliteError,
 	type Model,
@@ -155,6 +156,7 @@ import {
 	MODEL_ONBOARDING_SETUP_COMMAND,
 } from "../../setup/model-onboarding-guidance";
 import { addApiCompatibleProvider, formatProviderSetupResult } from "../../setup/provider-onboarding";
+import { getThinkingLevelMetadata } from "../../thinking";
 import {
 	isConfigurableSearchProviderId,
 	isSearchProviderPreference,
@@ -1847,6 +1849,11 @@ export class SelectorController {
 	}
 
 	showEffortSelector(): void {
+		const model = this.ctx.session.model;
+		if (model && getMiniMaxThinkingMode(model) === "always-on") {
+			this.ctx.showStatus("Reasoning is always on for MiniMax M2.x; disabling and effort control are unsupported.");
+			return;
+		}
 		const availableLevels = [
 			ThinkingLevel.Inherit,
 			ThinkingLevel.Off,
@@ -1871,9 +1878,14 @@ export class SelectorController {
 
 					const effectiveLevel = this.ctx.session.thinkingLevel ?? ThinkingLevel.Off;
 					const requestedLabel =
-						level === ThinkingLevel.Inherit ? `${level} (configured default: ${configuredDefault})` : level;
+						level === ThinkingLevel.Inherit
+							? `${level} (configured default: ${configuredDefault})`
+							: getThinkingLevelMetadata(level, model).label;
+					const effectiveLabel = getThinkingLevelMetadata(effectiveLevel, model).label;
 					const clampedSuffix =
-						effectiveLevel === levelToApply ? "" : ` Requested ${levelToApply}; effective ${effectiveLevel}.`;
+						effectiveLevel === levelToApply
+							? ""
+							: ` Requested ${getThinkingLevelMetadata(levelToApply, model).label}; effective ${effectiveLabel}.`;
 
 					this.ctx.statusLine.invalidate();
 					this.ctx.updateEditorBorderColor();
@@ -1882,13 +1894,14 @@ export class SelectorController {
 					this.ctx.ui.requestRender();
 					const scopeLabel = persistDefault ? "Default reasoning effort" : "Reasoning effort";
 					this.ctx.showStatus(
-						`${scopeLabel} set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
+						`${scopeLabel} set to ${requestedLabel}. Effective effort: ${effectiveLabel}.${clampedSuffix}`,
 					);
 				},
 				() => {
 					done();
 					this.ctx.ui.requestRender();
 				},
+				model,
 			);
 			return { component: selector, focus: selector };
 		});