@oh-my-pi/pi-tui 18.4.0 → 18.4.2

package/src/components/image.ts

@@ -3,6 +3,7 @@ import {
 	getCellDimensions,
 	getImageDimensions,
 	type ImageDimensions,
+	ImageProtocol,
 	imageFallback,
 	renderImage,
 	TERMINAL,
@@ -84,7 +85,7 @@ interface SurfaceSplit {
 	 * id so a partial pass reproduces the on-screen live/text split without a
 	 * full, correctly-ordered walk.
 	 */
-	suppressedIds: Set<number>;
+	readonly suppressedIds: Set<number>;
 }
 
 function newSurfaceSplit(): SurfaceSplit {
@@ -96,7 +97,7 @@ function resetSurfaceSplit(split: SurfaceSplit): void {
 	split.onTerminal = 0;
 	split.planned = 0;
 	split.lastTotal = 0;
-	split.suppressedIds = new Set();
+	if (split.suppressedIds.size > 0) split.suppressedIds.clear();
 }
 
 let nextImageBudgetSeed = Math.floor(Math.random() * 0xffffff);
@@ -283,8 +284,8 @@ export class ImageBudget {
 	 */
 	beginPass(stable = false, altScreen = false): void {
 		this.#passIds.length = 0;
-		this.#passSuppression.clear();
-		this.#passIndex.clear();
+		if (this.#passSuppression.size > 0) this.#passSuppression.clear();
+		if (this.#passIndex.size > 0) this.#passIndex.clear();
 		this.#stablePass = stable;
 		this.#surface = altScreen ? "alt" : "screen";
 		this.#split = altScreen ? this.#altSplit : this.#screenSplit;
@@ -295,7 +296,7 @@ export class ImageBudget {
 		// first. Note that leaving alt mode is not the same as unstacking a
 		// fullscreen overlay: the flush must exclude one that is still stacked
 		// from the pass itself, which is that caller's job, not this line's.
-		if (!altScreen) this.#liveIds.alt.clear();
+		if (!altScreen && this.#liveIds.alt.size > 0) this.#liveIds.alt.clear();
 		this.#applyingReset = !stable && this.#cap > 0 && this.#split.planned > this.#split.onTerminal;
 	}
 
@@ -348,7 +349,10 @@ export class ImageBudget {
 		// [0, onTerminal) is what this surface currently shows as text. Partial
 		// passes replay this per id (see #stablePass) instead of re-deriving it
 		// from a reversed, tail-only walk.
-		split.suppressedIds = new Set(this.#passIds.slice(0, split.onTerminal));
+		const suppressedIds = split.suppressedIds;
+		if (suppressedIds.size > 0) suppressedIds.clear();
+		const suppressedCount = Math.min(total, split.onTerminal);
+		for (let i = 0; i < suppressedCount; i++) suppressedIds.add(this.#passIds[i]);
 		return retry;
 	}
 
@@ -361,7 +365,12 @@ export class ImageBudget {
 	 * the next pass on the *other* surface knows what it may not destroy.
 	 */
 	limitResidentImages(): void {
-		this.#liveIds[this.#surface] = new Set(this.#passIds.filter(id => this.#passShowsLive(id)));
+		const liveIds = this.#liveIds[this.#surface];
+		if (liveIds.size > 0) liveIds.clear();
+		for (let i = 0; i < this.#passIds.length; i++) {
+			const id = this.#passIds[i];
+			if (this.#passShowsLive(id)) liveIds.add(id);
+		}
 		const transmitted = this.#transmitted[this.#surface];
 		if (this.#cap <= 0 || transmitted.size <= this.#cap) return;
 		for (const id of transmitted) {
@@ -765,6 +774,13 @@ export class Image implements Component {
 		// toward (and are demoted by) the budget; without a protocol every image is
 		// already text.
 		const suppressed = hasProtocol && this.#budget !== undefined ? this.#budget.observe(this.#imageId ?? 0) : false;
+		// Only Kitty images with a budget id transmit their data separately from
+		// the placement; a pending re-transmit (after a purge or history clear)
+		// must rebuild the lines. SIXEL and iTerm2 carry the image inside the line
+		// itself and never register a transmit, so gating their cache on it would
+		// re-encode the full image on every render pass.
+		const imageId = this.#imageId;
+		const transmitsSeparately = imageProtocol === ImageProtocol.Kitty && imageId != null;
 
 		if (
 			this.#cachedLines &&
@@ -774,7 +790,7 @@ export class Image implements Component {
 			this.#cachedCellWidthPx === cellDimensions.widthPx &&
 			this.#cachedCellHeightPx === cellDimensions.heightPx &&
 			this.#cachedKittyUnicodePlaceholders === kittyUnicodePlaceholders &&
-			(this.#imageId == null || this.#budget?.shouldTransmit(this.#imageId) !== true)
+			(!transmitsSeparately || this.#budget?.shouldTransmit(imageId) !== true)
 		) {
 			return this.#cachedLines;
 		}
@@ -787,7 +803,7 @@ export class Image implements Component {
 		if (hasProtocol && !suppressed) {
 			// Transmit the data once (keyed by id); thereafter renderImage returns
 			// just the placement, so repaints never re-send the base64.
-			const needsTransmit = this.#imageId != null && (this.#budget?.shouldTransmit(this.#imageId) ?? false);
+			const needsTransmit = transmitsSeparately && (this.#budget?.shouldTransmit(imageId) ?? false);
 			const result = renderImage(this.#base64Data, this.#dimensions, {
 				maxWidthCells: maxWidth,
 				maxHeightCells: this.#options.maxHeightCells,

package/src/components/loader.ts

@@ -26,7 +26,14 @@ export class Loader extends Text {
 	#ui: TUI | null = null;
 	#lastSpinnerTick = 0;
 	#layoutSource?: readonly string[];
-	#layout?: readonly { leading: string; content: string; trailing: string }[];
+	#layout?: readonly {
+		leading: string;
+		message: string;
+		trailing: string;
+		spinner: boolean;
+		separator: string;
+		bodyWidth?: number;
+	}[];
 	#layoutFrames: readonly string[];
 	#layoutFrame: string;
 	#trailer?: () => string | undefined;
@@ -72,14 +79,28 @@ export class Loader extends Text {
 		if (source !== this.#layoutSource) {
 			const paddingX = getPaddingX(1);
 			this.#layoutSource = source;
-			this.#layout = source.map(line => {
+			this.#layout = source.map((line, i) => {
 				const clamped = visibleWidth(line) > width ? sliceByColumn(line, 0, width, true) : line;
 				const body = clamped.slice(paddingX);
 				const content = body.trimEnd();
+				const leading = clamped.slice(0, paddingX);
+				const spinner = i === 0 && content.startsWith(this.#layoutFrame);
+				const remainder = spinner ? content.slice(this.#layoutFrame.length) : content;
+				const separator = spinner && remainder.startsWith(" ") ? " " : "";
+				const message = remainder.slice(separator.length);
+				const plainMessage = i === 0 ? Bun.stripANSI(message) : "";
+				// A visible non-whitespace ending makes trimEnd independent of
+				// colorizer ANSI placement. The separator isolates spinner width
+				// from message graphemes; other cases retain whole-body measuring.
+				const stableBodyWidth =
+					plainMessage.length > 0 && plainMessage.trimEnd() === plainMessage && (!spinner || separator === " ");
 				return {
-					leading: clamped.slice(0, paddingX),
-					content,
+					leading,
+					message,
 					trailing: body.slice(content.length),
+					spinner,
+					separator,
+					bodyWidth: stableBodyWidth ? visibleWidth(leading + separator + message) : undefined,
 				};
 			});
 		}
@@ -88,28 +109,27 @@ export class Loader extends Text {
 		// The wrapped text carries one stable representative per frame width.
 		// Same-width frames swap only the visible glyph here; crossing widths
 		// rewraps against the representative selected by #syncText.
-		const sentinel = this.#layoutFrame;
 		const lines = [""];
 		const layout = this.#layout ?? [];
-		for (let i = 0; i < layout.length; i++) {
-			const { leading, content, trailing } = layout[i];
-			if (i === 0 && content.startsWith(sentinel)) {
-				const remainder = content.slice(sentinel.length);
-				const separator = remainder.startsWith(" ") ? " " : "";
-				const message = remainder.slice(separator.length);
-				lines.push(
-					`${leading}${this.spinnerColorFn(frame)}${separator}${message ? this.messageColorFn(message) : ""}${trailing}`,
-				);
-			} else {
-				lines.push(`${leading}${content ? this.messageColorFn(content) : ""}${trailing}`);
+		let coloredSpinner = "";
+		for (const { leading, message, trailing, spinner, separator } of layout) {
+			if (spinner) {
+				coloredSpinner = this.spinnerColorFn(frame);
 			}
+			lines.push(
+				`${leading}${spinner ? coloredSpinner : ""}${separator}${message ? this.messageColorFn(message) : ""}${trailing}`,
+			);
 		}
 		if (this.#trailer && lines.length > 1) {
 			const trailer = this.#trailer();
 			if (trailer) {
 				// Text pads rows to full width; drop that pad before docking right.
 				const body = lines[1].trimEnd();
-				const gap = width - visibleWidth(body) - visibleWidth(trailer);
+				const bodyWidth =
+					layout[0].bodyWidth === undefined
+						? visibleWidth(body)
+						: layout[0].bodyWidth + visibleWidth(coloredSpinner);
+				const gap = width - bodyWidth - visibleWidth(trailer);
 				if (gap >= 2) lines[1] = body + padding(gap) + trailer;
 			}
 		}

package/src/overlays/agent-hub.ts

@@ -102,13 +102,23 @@ function activityGlyph(row: AgentActivityRow): string {
 	}
 }
 
+const ACTIVITY_CLOCK_FORMAT = new Intl.DateTimeFormat(undefined, {
+	hour: "2-digit",
+	minute: "2-digit",
+	second: "2-digit",
+	hour12: false,
+});
+const ACTIVITY_CLOCK_CACHE_LIMIT = 512;
+const activityClockCache = new Map<number, string>();
+
 function activityClock(timestamp: number): string {
-	return new Date(timestamp).toLocaleTimeString(undefined, {
-		hour: "2-digit",
-		minute: "2-digit",
-		second: "2-digit",
-		hour12: false,
-	});
+	let text = activityClockCache.get(timestamp);
+	if (text === undefined) {
+		text = ACTIVITY_CLOCK_FORMAT.format(timestamp);
+		if (activityClockCache.size >= ACTIVITY_CLOCK_CACHE_LIMIT) activityClockCache.clear();
+		activityClockCache.set(timestamp, text);
+	}
+	return text;
 }
 /** Result of one host-backed transcript read for the Agent Hub viewer. */
 export interface AgentHubRemoteTranscript {

package/src/overlays/agents-hub.ts

@@ -81,7 +81,7 @@ interface SidebarEntry extends HubSidebarEntry<"all" | "source" | "new" | "separ
 type ListRow = { kind: "agent"; agent: HubAgent } | { kind: "new" };
 
 /** The per-agent knob a strip or the model browser is editing. */
-type PropertyKind = "model" | "prewalk" | "advisor";
+export type PropertyKind = "model" | "prewalk" | "advisor";
 
 type StripChip = HubStripChip<
 	| { kind: "toggle" }
@@ -110,8 +110,10 @@ export interface AgentsHubDeps {
 	resolvePatterns: (patterns: string[]) => string | undefined;
 	effectivePrewalkPattern: (agent: HubAgent) => string | undefined;
 	effectiveAdvisorPattern: (agent: HubAgent) => string | undefined;
-	setDisabledAgents: (names: string[]) => void;
-	setOverrides: (property: PropertyKind, overrides: Record<string, string>) => void;
+	/** Persist one agent's enabled state; other agents are untouched. */
+	setAgentDisabled: (name: string, options: { disabled: boolean }) => void;
+	/** Persist one agent's override for `property`; `undefined` clears it. Other agents are untouched. */
+	setAgentOverride: (property: PropertyKind, name: string, value: string | undefined) => void;
 	generateAgent: (description: string, onText: (text: string) => void) => Promise<string>;
 	saveAgent: (scope: "project" | "user", spec: GeneratedAgentSpec) => Promise<string>;
 }
@@ -341,24 +343,11 @@ export class AgentsHubComponent implements Component {
 
 	#toggleAgent(agent: HubAgent): void {
 		agent.disabled = !agent.disabled;
-		const disabled = this.#allAgents
-			.filter(entry => entry.disabled)
-			.map(entry => entry.name)
-			.sort((a, b) => a.localeCompare(b));
-		this.#deps.setDisabledAgents(disabled);
+		this.#deps.setAgentDisabled(agent.name, { disabled: agent.disabled });
 		this.#notice = `${agent.name} ${agent.disabled ? "disabled" : "enabled"}`;
 		this.#tui.requestRender();
 	}
 
-	#persistRecord(property: PropertyKind): void {
-		const overrides: Record<string, string> = {};
-		for (const agent of this.#allAgents) {
-			const value = this.#overrideFor(agent, property)?.trim();
-			if (value) overrides[agent.name] = value;
-		}
-		this.#deps.setOverrides(property, overrides);
-	}
-
 	#overrideFor(agent: HubAgent, property: PropertyKind): string | undefined {
 		switch (property) {
 			case "model":
@@ -383,7 +372,7 @@ export class AgentsHubComponent implements Component {
 				agent.advisorOverride = trimmed;
 				break;
 		}
-		this.#persistRecord(property);
+		this.#deps.setAgentOverride(property, agent.name, trimmed);
 		this.#notice = this.#describeProperty(agent, property);
 		this.#tui.requestRender();
 	}

package/src/overlays/copy-selector.ts

@@ -18,12 +18,12 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { type Component, matchesKey, routeSgrMouseInput, type TUI, truncateToWidth, visibleWidth } from "../index";
 import type { MessageRenderer } from "../chat/extension-types";
 import {
-	isUserRequestEntry,
+	recentTranscriptEntries,
+	type SessionMessageEntryLike as SessionMessageEntry,
 	type TranscriptEntryLike as TranscriptEntry,
 	transcriptEntryMessage,
 	userTurnDraft,
 } from "../chat/transcript-entry";
-import type { SessionMessageEntryLike as SessionMessageEntry } from "../chat/transcript-entry";
 import { expandKeyHint, replaceTabs } from "../render/render-utils";
 import { formatKeyHint } from "../app-keybindings";
 import { editorKey, editorKeys } from "../chrome/keybinding-hints";
@@ -92,13 +92,6 @@ export interface CopyBlock {
 const BLOCK_PREVIEW_LINES = 12;
 /** The copy picker's outline stroke — green, distinct from the rewind selector's accent. */
 const OUTLINE_COLOR: ThemeColor = "success";
-/**
- * Entries replayed when the picker opens. Replaying a long session's whole
- * branch costs seconds before the first frame (one component built and
- * rendered per entry), and the clipboard target is almost always recent, so
- * the picker starts at this tail and loads the rest on demand (`a`).
- */
-const INITIAL_ENTRIES = 600;
 
 /** A clickable control on a block caption, in composed-column columns. */
 interface ControlRegion {
@@ -132,7 +125,7 @@ export class CopySelectorComponent implements Component {
 		private readonly deps: CopySelectorDeps,
 	) {
 		this.#entries = entries;
-		const tail = recentEntries(entries, INITIAL_ENTRIES);
+		const tail = recentTranscriptEntries(entries);
 		this.#truncated = tail.length < entries.length;
 		this.#builder = this.#replay(tail);
 		this.#selected = Math.max(0, this.#targets.length - 1);
@@ -324,6 +317,11 @@ export class CopySelectorComponent implements Component {
 			}
 			index += delta;
 		}
+		// Stepping above the replayed tail continues into the earlier history.
+		if (delta < 0 && this.#truncated) {
+			this.#loadFullHistory();
+			this.#moveVertical(delta);
+		}
 	}
 
 	// ========================================================================
@@ -478,27 +476,6 @@ export class CopySelectorComponent implements Component {
 	}
 }
 
-/**
- * The trailing slice starting at the last turn initiator at or before
- * `entries.length - limit`: a user message, or a custom message that starts
- * a user-attributed turn (a directly invoked `/skill:` prompt, a collab peer's
- * prompt), the same boundary `ChatTranscriptBuilder` uses.
- *
- * The cut has to land on a turn boundary: the builder drops a tool result
- * whose initiating call was sliced away, so a tail beginning mid-turn renders
- * without its command — and a tail of nothing but orphaned results would
- * leave the picker with no target at all. Scanning backwards keeps the whole
- * final turn instead, and a branch whose last turn is itself longer than
- * `limit` replays in full.
- */
-function recentEntries(entries: TranscriptEntry[], limit: number): TranscriptEntry[] {
-	if (entries.length <= limit) return entries;
-	for (let index = entries.length - limit; index > 0; index--) {
-		if (isUserRequestEntry(entries[index]!)) return entries.slice(index);
-	}
-	return entries;
-}
-
 /** Raw multi-line text of a user message (string or text blocks). */
 function rawUserText(message: Extract<SessionMessageEntry["message"], { role: "user" }>): string {
 	if (typeof message.content === "string") return message.content;

package/src/overlays/model-browser.ts

@@ -113,6 +113,11 @@ export interface ResolvedModelRoleValue {
 
 /** Host-provided preferences and model-role resolution for the browser. */
 export interface ModelBrowserSource extends ModelRoleLookup {
+	/**
+	 * Changes whenever any preference this source reads or resolves against changes,
+	 * except the storage-backed `mruOrder` and `modelPerf`. Keys derived-scope caches.
+	 */
+	readonly revision: number;
 	readonly defaultThinkingLevel: string;
 	readonly modelProviderOrder: readonly string[];
 	readonly knownRoleIds: readonly string[];
@@ -175,16 +180,32 @@ export function resolveRoleAssignments(
 		return ThinkingLevel.Inherit;
 	};
 
+	// Roles sharing an `accepts` predicate share one filtered array, so the
+	// resolver's array-keyed indexes are built once per pool, not once per role.
+	const eligible = (
+		pool: ReadonlyArray<Model>,
+		byAccepts: Map<ModelBrowserRoleInfo["accepts"], Model[]>,
+		role: string,
+	): Model[] => {
+		const accepts = settings.getRoleInfo(role).accepts;
+		let models = byAccepts.get(accepts);
+		if (!models) {
+			models = pool.filter(accepts);
+			byAccepts.set(accepts, models);
+		}
+		return models;
+	};
+
 	const roles: RoleAssignments = {};
 	const knownRoles = settings.knownRoleIds;
 	const configuredRoles = new Set<string>();
-	const catalog = [...allModels];
+	const catalogByAccepts = new Map<ModelBrowserRoleInfo["accepts"], Model[]>();
 
 	for (const role of knownRoles) {
 		const roleValue = settings.getModelRole(role);
 		if (!roleValue) continue;
 		configuredRoles.add(role);
-		const resolved = settings.resolveRoleValue(roleValue, catalog.filter(settings.getRoleInfo(role).accepts));
+		const resolved = settings.resolveRoleValue(roleValue, eligible(allModels, catalogByAccepts, role));
 		if (resolved.model) {
 			roles[role] = {
 				model: resolved.model,
@@ -195,13 +216,10 @@ export function resolveRoleAssignments(
 	}
 
 	if (autoCandidates.length > 0) {
-		const candidates = [...autoCandidates];
+		const candidatesByAccepts = new Map<ModelBrowserRoleInfo["accepts"], Model[]>();
 		for (const role of knownRoles) {
 			if (configuredRoles.has(role)) continue;
-			const resolved = settings.resolveRoleValue(
-				`pi/${role}`,
-				candidates.filter(settings.getRoleInfo(role).accepts),
-			);
+			const resolved = settings.resolveRoleValue(`pi/${role}`, eligible(autoCandidates, candidatesByAccepts, role));
 			if (!resolved.model) continue;
 			roles[role] = {
 				model: resolved.model,
@@ -332,32 +350,95 @@ export interface SessionModelScope {
 	error: string | undefined;
 }
 
+/** Catalog inputs a {@link SessionModelScope} is derived from. */
+interface SessionModelScopeInputs {
+	models: ReadonlyArray<Model>;
+	allModels: ReadonlyArray<Model>;
+	error: string | undefined;
+}
+
+function readSessionModelScopeInputs(
+	registry: ModelBrowserRegistry,
+	scopedModels: ReadonlyArray<Model>,
+): SessionModelScopeInputs {
+	if (scopedModels.length > 0) return { models: scopedModels, allModels: scopedModels, error: undefined };
+	const loadError = registry.getError();
+	let error = loadError ? String(loadError) : undefined;
+	let models: ReadonlyArray<Model>;
+	try {
+		models = registry.getAvailable();
+	} catch (cause) {
+		error = cause instanceof Error ? cause.message : String(cause);
+		models = [];
+	}
+	return { models, allModels: registry.getAll("all"), error };
+}
+
+function scopeFromInputs(settings: ModelBrowserSource, inputs: SessionModelScopeInputs): SessionModelScope {
+	const roles = resolveRoleAssignments(settings, inputs.allModels, inputs.models);
+	const mruOrder = settings.mruOrder;
+	const items = buildBrowserItems(inputs.models);
+	sortModelItems(items, { roles, mruOrder });
+	return { items, roles, mruOrder, error: inputs.error };
+}
+
 /** Build the session picker's current scope without creating an interactive browser. */
 export function buildSessionModelScope(
 	settings: ModelBrowserSource,
 	registry: ModelBrowserRegistry,
 	scopedModels: ReadonlyArray<Model>,
 ): SessionModelScope {
-	let models: ReadonlyArray<Model>;
-	let error: string | undefined;
-	if (scopedModels.length > 0) {
-		models = scopedModels;
-	} else {
-		const loadError = registry.getError();
-		error = loadError ? String(loadError) : undefined;
-		try {
-			models = registry.getAvailable();
-		} catch (cause) {
-			error = cause instanceof Error ? cause.message : String(cause);
-			models = [];
+	return scopeFromInputs(settings, readSessionModelScopeInputs(registry, scopedModels));
+}
+
+function sameEntries<T>(a: ReadonlyArray<T>, b: ReadonlyArray<T>): boolean {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i]) return false;
+	}
+	return true;
+}
+
+/**
+ * {@link buildSessionModelScope} for per-keystroke callers: returns the same
+ * scope until the source revision, MRU order, scoped models, or the registry's
+ * available models, catalog, or load error change.
+ */
+export class SessionModelScopeCache {
+	#settings: ModelBrowserSource;
+	#registry: ModelBrowserRegistry;
+	#revision = 0;
+	#inputs: SessionModelScopeInputs | undefined;
+	#scope: SessionModelScope | undefined;
+
+	constructor(settings: ModelBrowserSource, registry: ModelBrowserRegistry) {
+		this.#settings = settings;
+		this.#registry = registry;
+	}
+
+	get(scopedModels: ReadonlyArray<Model>): SessionModelScope {
+		const revision = this.#settings.revision;
+		const inputs = readSessionModelScopeInputs(this.#registry, scopedModels);
+		const cachedInputs = this.#inputs;
+		const cached = this.#scope;
+		if (
+			cached &&
+			cachedInputs &&
+			revision === this.#revision &&
+			inputs.error === cachedInputs.error &&
+			sameEntries(inputs.models, cachedInputs.models) &&
+			sameEntries(inputs.allModels, cachedInputs.allModels) &&
+			sameEntries(this.#settings.mruOrder, cached.mruOrder)
+		) {
+			return cached;
 		}
+		const scope = scopeFromInputs(this.#settings, inputs);
+		this.#revision = revision;
+		this.#inputs = inputs;
+		this.#scope = scope;
+		return scope;
 	}
-	const allModels = scopedModels.length > 0 ? models : registry.getAll("all");
-	const roles = resolveRoleAssignments(settings, allModels, models);
-	const mruOrder = settings.mruOrder;
-	const items = buildBrowserItems(models);
-	sortModelItems(items, { roles, mruOrder });
-	return { items, roles, mruOrder, error };
 }
 
 interface RoleProviderStats {

package/src/overlays/model-hub.ts

@@ -984,7 +984,11 @@ export class ModelHubComponent implements Component {
 		);
 	}
 
-	/** Persist `role → item`, preserving a still-supported thinking level, then open the thinking strip. */
+	/**
+	 * Persist `role → item`, preserving a still-supported thinking level, then
+	 * open the thinking strip — skipped for models with no reasoning surface,
+	 * where every chip would be a no-op ({@link #thinkingOptionsFor}).
+	 */
 	#assignRole(item: ModelBrowserItem, role: string, returnToRoles: boolean, scope?: ModelRoleSelectionScope): void {
 		if (this.#settings.modelRoleStorage === "project" && scope === undefined) {
 			this.#openScopeStrip(item, role, returnToRoles);
@@ -1003,6 +1007,13 @@ export class ModelHubComponent implements Component {
 		const result = this.#callbacks.onAssign(item.model, role, level, item.selector, scope);
 		this.#finishAssignment(result, () => {
 			this.#refreshAfterMutation();
+			if (supported.length === 0) {
+				if (returnToRoles) {
+					this.#setActiveEntry("roles");
+					this.#focus = "list";
+				}
+				return;
+			}
 			this.#openThinkingStrip(item, role, returnToRoles, scope, level);
 		});
 	}
@@ -1019,10 +1030,39 @@ export class ModelHubComponent implements Component {
 		this.#refreshAfterMutation();
 	}
 
+	/**
+	 * Thinking levels a role assignment can actually apply. A model that does
+	 * not reason gets none: no request path sends reasoning for it, and
+	 * `applyAutoThinkingLevel` early-returns on `!model.reasoning`, so
+	 * `inherit`/`off`/`auto` would all be no-ops. Reasoners without an effort
+	 * dial (`thinking: undefined`, e.g. `xai/grok-code-fast-1`) keep the three
+	 * always-on levels — their thinking is real, only the ladder is absent.
+	 */
 	#thinkingOptionsFor(model: Model): ConfiguredThinkingLevel[] {
+		if (!model.reasoning) return [];
 		return [ThinkingLevel.Inherit, ThinkingLevel.Off, AUTO_THINKING, ...getSupportedEfforts(model)];
 	}
 
+	/**
+	 * Resolve what `t` on a role row would edit: the role's model in its
+	 * persisted scope. Undefined when the role is unassigned or its model has
+	 * no thinking levels to offer, which makes both `t` and its footer hint
+	 * inert — the same rule wildcard fallback rows follow.
+	 */
+	#roleThinkingTarget(role: string): { item: ModelBrowserItem; scope?: ModelRoleSelectionScope } | undefined {
+		const assignment = this.#roles[role];
+		if (!assignment) return undefined;
+		const source =
+			this.#settings.modelRoleStorage === "project" ? this.#settings.getModelRoleSource(role) : "default";
+		const scope = source === "project" || source === "global" ? source : undefined;
+		const model = scope ? this.#roleForScope(role, scope).model : assignment.model;
+		if (!model || this.#thinkingOptionsFor(model).length === 0) return undefined;
+		return {
+			item: { provider: model.provider, id: model.id, model, selector: `${model.provider}/${model.id}` },
+			scope,
+		};
+	}
+
 	/** Offer only the roles this model can actually fill (chat roles for chat models, `web` for search runners, …). */
 	#openRoleStrip(item: ModelBrowserItem): void {
 		const chips: StripChip[] = [];
@@ -1821,20 +1861,9 @@ export class ModelHubComponent implements Component {
 			return;
 		}
 		if (printable === "t") {
-			const assignment = role ? this.#roles[role] : undefined;
-			if (role && assignment) {
-				const source =
-					this.#settings.modelRoleStorage === "project" ? this.#settings.getModelRoleSource(role) : "default";
-				const scope = source === "project" || source === "global" ? source : undefined;
-				const scopedModel = scope ? this.#roleForScope(role, scope).model : assignment.model;
-				if (!scopedModel) return;
-				const item: ModelBrowserItem = {
-					provider: scopedModel.provider,
-					id: scopedModel.id,
-					model: scopedModel,
-					selector: `${scopedModel.provider}/${scopedModel.id}`,
-				};
-				this.#openThinkingStrip(item, role, true, scope);
+			if (role) {
+				const target = this.#roleThinkingTarget(role);
+				if (target) this.#openThinkingStrip(target.item, role, true, target.scope);
 			} else if (row?.kind === "fallback") {
 				this.#openFallbackThinkingStrip(row);
 			}
@@ -2338,7 +2367,11 @@ export class ModelHubComponent implements Component {
 			if (row?.kind === "newFallback") {
 				return `${upDown} rows · ${enter} new model/provider fallback chain · ${left} providers`;
 			}
-			return `${upDown} rows · ${enter} pick · ${formatKeyHint("f")} fallback · ${formatKeyHint("x")} clear · ${formatKeyHint("t")} thinking · ${formatKeyHint("c")} cycle · [/] reorder · ${formatKeyHint("n")} new`;
+			// Same rule as fallback rows: advertise `t` only where a strip would
+			// open — an assigned role whose model has thinking levels to offer.
+			const editable = row?.kind === "role" && this.#roleThinkingTarget(row.role) !== undefined;
+			const thinking = editable ? ` · ${formatKeyHint("t")} thinking` : "";
+			return `${upDown} rows · ${enter} pick · ${formatKeyHint("f")} fallback · ${formatKeyHint("x")} clear${thinking} · ${formatKeyHint("c")} cycle · [/] reorder · ${formatKeyHint("n")} new`;
 		}
 		if (entry.kind === "provider" && entry.locked) {
 			return entry.oauth