@oh-my-pi/pi-coding-agent 15.11.4 → 15.11.6

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

@@ -4,12 +4,11 @@ import {
 	type Component,
 	Container,
 	extractPrintableText,
-	fuzzyFilter,
+	fuzzyRank,
 	getKeybindings,
 	getSettingItemFilterText,
 	Input,
 	matchesKey,
-	padding,
 	parseSgrMouse,
 	type SelectItem,
 	SelectList,
@@ -68,8 +67,6 @@ class TextInputSubmenu extends Container {
 		this.#input = new Input();
 		if (currentValue) {
 			this.#input.setValue(currentValue);
-			// Move cursor to end of pre-filled value (ctrl+e = cursorLineEnd).
-			this.#input.handleInput("\x05");
 		}
 		this.#input.onSubmit = value => {
 			this.onSubmit(value); // empty string clears the setting
@@ -291,6 +288,8 @@ export class SettingsSelectorComponent implements Component {
 	#currentTabId: SettingTab | "plugins" = "appearance";
 	#preSearchTabId: SettingTab | "plugins" = "appearance";
 	#searchQuery = "";
+	/** Single-line editor backing the search banner (cursor, word ops, paste). */
+	#searchInput = new Input();
 	#searchMatchCount = 0;
 	/** First matching item id per tab id, for Tab-key jumps while searching. */
 	#searchFirstMatch = new Map<string, string>();
@@ -354,7 +353,7 @@ export class SettingsSelectorComponent implements Component {
 
 	#footerHintText(): string {
 		if (this.#searchList) {
-			return "Enter/Space to change · Tab to jump tabs · Backspace to edit · Esc to exit search";
+			return "Enter to change · Tab to jump tabs · Esc to exit search";
 		}
 		if (this.#currentTabId === "plugins") {
 			return "Tab to switch tabs · Esc to close";
@@ -366,28 +365,17 @@ export class SettingsSelectorComponent implements Component {
 		return `Enter/Space to change · ${nav} · Type to search · Esc to close`;
 	}
 
-	/** Single-line search banner: accent icon, bold query + caret, right-aligned match count. */
+	/** Single-line search banner: accent icon, editable query with live cursor, right-aligned match count. */
 	#renderSearchBanner(width: number): string {
 		const icon = theme.symbol("icon.search");
 		const countText = this.#searchMatchCount === 1 ? "1 match" : `${this.#searchMatchCount} matches`;
 		const rightWidth = visibleWidth(countText) + 1; // trailing margin
-		// Fixed chrome: " <icon> " prefix plus the "▌" cursor cell.
-		const queryBudget = Math.max(4, width - visibleWidth(icon) - 4 - rightWidth - 1);
-
-		// Keep the tail visible (where the cursor is) when the query overflows.
-		let display = this.#searchQuery;
-		if (visibleWidth(display) > queryBudget) {
-			const chars = [...display];
-			while (chars.length > 1 && visibleWidth(chars.join("")) > queryBudget - 1) {
-				chars.shift();
-			}
-			display = `…${chars.join("")}`;
-		}
-
-		const left = ` ${theme.fg("accent", icon)} ${theme.bold(display)}${theme.fg("accent", "▌")}`;
+		const prefix = ` ${theme.fg("accent", icon)} `;
+		// The input pads itself to exactly this width and keeps the cursor in view.
+		const inputWidth = Math.max(4, width - visibleWidth(prefix) - rightWidth - 1);
+		const inputLine = this.#searchInput.render(inputWidth)[0] ?? "";
 		const count = theme.fg(this.#searchMatchCount > 0 ? "dim" : "warning", countText);
-		const gap = Math.max(1, width - visibleWidth(left) - rightWidth);
-		return truncateToWidth(`${left}${padding(gap)}${count} `, width);
+		return truncateToWidth(`${prefix}${theme.bold(inputLine)} ${count} `, width);
 	}
 
 	/**
@@ -511,6 +499,9 @@ export class SettingsSelectorComponent implements Component {
 	/** Swap the tab content for the global search result list. */
 	#startSearch(initialQuery: string): void {
 		this.#preSearchTabId = this.#currentTabId;
+		this.#searchInput = new Input();
+		this.#searchInput.prompt = "";
+		this.#searchInput.setValue(initialQuery);
 		const list = new SettingsList(
 			[],
 			10,
@@ -547,6 +538,7 @@ export class SettingsSelectorComponent implements Component {
 
 		const counts = new Map<SettingTab, number>();
 		const items: SettingItem[] = [];
+		const tabResults: { tab: SettingTab; matched: SettingItem[]; bestScore: number; order: number }[] = [];
 		this.#searchFirstMatch.clear();
 		let total = 0;
 		for (const tab of SETTING_TABS) {
@@ -555,24 +547,40 @@ export class SettingsSelectorComponent implements Component {
 				const item = this.#defToItem(def);
 				if (item) candidates.push(item);
 			}
-			const matched = fuzzyFilter(candidates, query, getSettingItemFilterText);
+			const ranked = fuzzyRank(candidates, query, getSettingItemFilterText);
+			const matched = ranked.map(result => result.item);
 			counts.set(tab, matched.length);
 			if (matched.length === 0) continue;
 			total += matched.length;
-			const meta = TAB_METADATA[tab];
+			tabResults.push({
+				tab,
+				matched,
+				bestScore: ranked[0]?.score ?? 0,
+				order: SETTING_TABS.indexOf(tab),
+			});
+		}
+
+		tabResults.sort((a, b) => a.bestScore - b.bestScore || a.order - b.order);
+		for (const result of tabResults) {
+			const meta = TAB_METADATA[result.tab];
 			items.push({
-				id: `__tab:${tab}`,
+				id: `__tab:${result.tab}`,
 				label: `${theme.symbol(meta.icon as Parameters<typeof theme.symbol>[0])} ${meta.label}`,
 				currentValue: "",
 				heading: true,
 			});
-			this.#searchFirstMatch.set(tab, matched[0].id);
-			items.push(...matched);
+			this.#searchFirstMatch.set(result.tab, result.matched[0]?.id ?? "");
+			items.push(...result.matched);
 		}
 
 		this.#searchList.setItems(items);
 		this.#searchMatchCount = total;
-		this.#tabBar.setTabs(this.#buildSearchTabs(counts));
+		this.#tabBar.setTabs(
+			this.#buildSearchTabs(
+				counts,
+				tabResults.map(result => result.tab),
+			),
+		);
 		this.#syncTabBarToSelection(this.#searchList.getSelectedItem());
 	}
 
@@ -597,20 +605,25 @@ export class SettingsSelectorComponent implements Component {
 		}
 	}
 
-	/** Matching tabs first (counts attached), the rest muted at the end. */
-	#buildSearchTabs(counts: Map<SettingTab, number>): Tab[] {
+	/** Matching tabs first (counts attached), ordered by best result score; the rest stay muted at the end. */
+	#buildSearchTabs(counts: Map<SettingTab, number>, matchedTabOrder: readonly SettingTab[]): Tab[] {
 		const matched: Tab[] = [];
 		const empty: Tab[] = [];
-		for (const id of SETTING_TABS) {
+		const matchedIds = new Set<SettingTab>(matchedTabOrder);
+		for (const id of matchedTabOrder) {
 			const meta = TAB_METADATA[id];
 			const icon = theme.symbol(meta.icon as Parameters<typeof theme.symbol>[0]);
 			const count = counts.get(id) ?? 0;
 			if (count > 0) {
 				matched.push({ id, label: `${icon} ${meta.label} (${count})`, short: `${icon} ${count}` });
-			} else {
-				empty.push({ id, label: `${icon} ${meta.label}`, short: icon, muted: true });
 			}
 		}
+		for (const id of SETTING_TABS) {
+			if (matchedIds.has(id)) continue;
+			const meta = TAB_METADATA[id];
+			const icon = theme.symbol(meta.icon as Parameters<typeof theme.symbol>[0]);
+			empty.push({ id, label: `${icon} ${meta.label}`, short: icon, muted: true });
+		}
 		// Plugins hosts its own UI; it is not part of the schema-backed search.
 		empty.push({ id: "plugins", label: `${theme.icon.package} Plugins`, short: theme.icon.package, muted: true });
 		return [...matched, ...empty];
@@ -1029,25 +1042,27 @@ export class SettingsSelectorComponent implements Component {
 			this.#endSearch(true);
 			return;
 		}
-		if (kb.matches(data, "tui.editor.deleteCharBackward")) {
-			this.#setSearchQuery([...this.#searchQuery].slice(0, -1).join(""));
-			return;
-		}
-		if (
-			matchesKey(data, "tab") ||
-			matchesKey(data, "shift+tab") ||
-			matchesKey(data, "left") ||
-			matchesKey(data, "right")
-		) {
+		if (matchesKey(data, "tab") || matchesKey(data, "shift+tab")) {
 			// Jump between tabs that have matches (muted tabs are skipped).
 			this.#tabBar.handleInput(data);
 			return;
 		}
-		const printable = extractPrintableText(data);
-		if (printable !== undefined) {
-			this.#setSearchQuery(this.#searchQuery + printable);
+		// Selection, paging, and activation stay with the result list.
+		if (
+			kb.matches(data, "tui.select.up") ||
+			kb.matches(data, "tui.select.down") ||
+			kb.matches(data, "tui.select.pageUp") ||
+			kb.matches(data, "tui.select.pageDown") ||
+			kb.matches(data, "tui.select.confirm") ||
+			data === "\n"
+		) {
+			list.handleInput(data);
 			return;
 		}
-		list.handleInput(data);
+		// Everything else edits the query like a regular single-line editor:
+		// cursor movement, word ops, kill ring, undo, paste.
+		this.#searchInput.handleInput(data);
+		const value = this.#searchInput.getValue();
+		if (value !== this.#searchQuery) this.#setSearchQuery(value);
 	}
 }

package/src/modes/components/tool-execution.ts

@@ -589,6 +589,24 @@ export class ToolExecutionComponent extends Container {
 		return (this.#result.details as { async?: { state?: string } } | undefined)?.async?.state === "running";
 	}
 
+	/**
+	 * Whether this still-live block's settled rows may enter native scrollback
+	 * (see `FinalizableBlock.isTranscriptBlockCommitStable`). A pending
+	 * collapsed preview is provisional: the tail-window streaming views
+	 * (edit/bash/eval caps) are re-anchored top-first by the result render, so
+	 * promoting their visually static head — e.g. an edit preview idling on
+	 * its last frame while the apply + LSP pass runs — would strand a stale
+	 * copy of the call box above the final block the moment the result lands.
+	 * Expanded pending blocks stream top-anchored append-shaped content whose
+	 * rows the result render preserves byte-stable (the over-tall write/eval
+	 * scrollback contract), so they stay commit-eligible. Displaceable waiting
+	 * polls are removed wholesale by the next poll and must never commit.
+	 */
+	isTranscriptBlockCommitStable(): boolean {
+		if (this.#displaceable) return false;
+		return this.#expanded || this.isTranscriptBlockFinalized();
+	}
+
 	/**
 	 * Mark the tool terminal even though no result arrived (the turn aborted or
 	 * abandoned it) and stop animating, so it can freeze and stops pinning the

package/src/modes/components/transcript-container.ts

@@ -63,6 +63,19 @@ interface FinalizableBlock {
 	 * never mutate post-finalize simply omit the method.
 	 */
 	getTranscriptBlockVersion?(): number;
+	/**
+	 * Whether a still-live block's visually settled leading rows are durable —
+	 * guaranteed to survive the block's remaining transitions (finalize,
+	 * displacement) byte-stable — and may therefore be promoted as commit-safe
+	 * by {@link deriveLiveCommitState}. Blocks whose pending render is
+	 * provisional (a tool call's tail-window streaming preview, replaced
+	 * wholesale by the result render) return `false`: committing such rows
+	 * strands a stale copy in immutable terminal history the moment the real
+	 * content re-lays-out the block (the engine audit recommits below it —
+	 * "duplication, never loss"). Absent = `true`, the default for blocks
+	 * whose live rows persist (a streaming assistant message).
+	 */
+	isTranscriptBlockCommitStable?(): boolean;
 }
 
 function isBlockFinalized(child: Component): boolean {
@@ -75,6 +88,11 @@ function getBlockVersion(child: Component): number | undefined {
 	return fn ? fn.call(child) : undefined;
 }
 
+function isBlockCommitStable(child: Component): boolean {
+	const fn = (child as Component & FinalizableBlock).isTranscriptBlockCommitStable;
+	return fn ? fn.call(child) : true;
+}
+
 // A "plain blank" row is empty or whitespace-only with no ANSI bytes. It marks
 // separation padding (a `Spacer`, or a no-background `paddingY` row) as opposed
 // to a background-colored padding row, whose escape sequences contain `\S` and
@@ -598,7 +616,11 @@ export class TranscriptContainer
 					previous.generation === this.#generation);
 			const contribution = reusable ? previous.contribution : stripPlainBlankEdges(raw);
 			let liveCommitState: LiveCommitState | undefined;
-			if (i >= liveStartIndex && !finalized) {
+			// Provisional live renders (commit-unstable blocks) never feed the
+			// promotion machinery: their settled-looking rows are replaced
+			// wholesale on finalize, so offering them would commit a stale
+			// preview the result render can only duplicate, never erase.
+			if (i >= liveStartIndex && !finalized && isBlockCommitStable(child)) {
 				liveCommitState = deriveLiveCommitState(previousSnapshot, contribution, width, this.#generation);
 			}
 			// Cache the latest contribution as the next frame's diff input.

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

@@ -456,7 +456,7 @@ export class CommandController {
 	}
 
 	handleContextCommand(): void {
-		const breakdown = computeContextBreakdown(this.ctx.session);
+		const breakdown = computeContextBreakdown(this.ctx.session, { snapcompactSavings: true });
 		if (breakdown.contextWindow <= 0) {
 			this.ctx.showWarning("Context usage is unavailable: no model is selected for this session.");
 			return;
@@ -1528,6 +1528,29 @@ function renderUsageReports(
 			lines.push(`  ${uiTheme.fg("accent", "in use by this session:")} ${activeAccountLabel}`);
 		}
 
+		const resetAccountLines: string[] = [];
+		for (const report of providerReports) {
+			const count = report.resetCredits?.availableCount ?? 0;
+			if (count <= 0) continue;
+			const label =
+				(report.metadata?.email as string | undefined) ??
+				(report.metadata?.accountId as string | undefined) ??
+				"account";
+			const isActive =
+				!!activeAccount &&
+				((!!activeAccount.accountId && activeAccount.accountId === report.metadata?.accountId) ||
+					(!!activeAccount.email && activeAccount.email === report.metadata?.email));
+			resetAccountLines.push(
+				`    • ${label}: ${count} saved reset${count === 1 ? "" : "s"}${isActive ? " (active)" : ""}`,
+			);
+		}
+		if (resetAccountLines.length > 0) {
+			lines.push(
+				`  ${uiTheme.fg("accent", "Saved rate-limit resets")} ${uiTheme.fg("dim", "(/usage reset to spend)")}`,
+			);
+			for (const line of resetAccountLines) lines.push(uiTheme.fg("dim", line));
+		}
+
 		const renderableGroups = Array.from(limitGroups.values()).map(group => {
 			const entries = group.limits.map((limit, index) => ({
 				limit,

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

@@ -27,8 +27,14 @@ import {
 	theme,
 } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
+import type { ResetCreditRedeemOutcome } from "../../session/auth-storage";
 import { type SessionInfo, SessionManager } from "../../session/session-manager";
 import { FileSessionStorage } from "../../session/session-storage";
+import {
+	describeRedeemOutcome,
+	type ResetUsageAccount,
+	toResetUsageAccounts,
+} from "../../slash-commands/helpers/reset-usage";
 import { AUTO_THINKING, type ConfiguredThinkingLevel } from "../../thinking";
 import {
 	isImageProviderPreference,
@@ -48,6 +54,7 @@ import { HistorySearchComponent } from "../components/history-search";
 import { ModelSelectorComponent } from "../components/model-selector";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
+import { ResetUsageSelectorComponent } from "../components/reset-usage-selector";
 import { SessionSelectorComponent } from "../components/session-selector";
 import { SettingsSelectorComponent } from "../components/settings-selector";
 import { ToolExecutionComponent } from "../components/tool-execution";
@@ -1091,6 +1098,67 @@ export class SelectorController {
 		});
 	}
 
+	async showResetUsageSelector(): Promise<void> {
+		const session = this.ctx.session;
+		this.ctx.showStatus("Checking saved rate-limit resets…", { dim: true });
+		let statuses: Awaited<ReturnType<typeof session.listResetCredits>>;
+		try {
+			statuses = await session.listResetCredits();
+		} catch (error) {
+			this.ctx.showError(`Could not load saved resets: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		const accounts = toResetUsageAccounts(statuses);
+		if (accounts.length === 0) {
+			this.ctx.showStatus("No Codex accounts found. Use /login to add one.");
+			return;
+		}
+		if (!accounts.some(account => account.availableCount > 0)) {
+			this.ctx.showStatus(
+				accounts.some(account => account.error)
+					? "No saved resets available — some accounts couldn't be reached (try /login)."
+					: "No saved rate-limit resets available to spend right now.",
+			);
+			return;
+		}
+		this.showSelector(done => {
+			const selector = new ResetUsageSelectorComponent(
+				accounts,
+				account => {
+					done();
+					void this.#redeemReset(account);
+				},
+				() => {
+					done();
+					this.ctx.ui.requestRender();
+				},
+			);
+			return { component: selector, focus: selector };
+		});
+	}
+
+	async #redeemReset(account: ResetUsageAccount): Promise<void> {
+		this.ctx.showStatus(`Spending 1 saved reset for ${account.label}…`, { dim: true });
+		let outcome: ResetCreditRedeemOutcome;
+		try {
+			outcome = await this.ctx.session.redeemResetCredit(account.target);
+		} catch (error) {
+			this.ctx.showError(
+				`Reset failed for ${account.label}: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return;
+		}
+		const message = describeRedeemOutcome(outcome, account.label);
+		if (outcome.ok) {
+			this.ctx.showStatus(message);
+			// Refresh the status-line usage so the freshly-reset window shows.
+			this.ctx.statusLine.invalidate();
+			this.ctx.ui.requestRender();
+		} else {
+			this.ctx.showWarning(message);
+		}
+	}
+
 	async showDebugSelector(): Promise<void> {
 		const { DebugSelectorComponent } = await import("../../debug");
 		this.showSelector(done => {

package/src/modes/interactive-mode.ts

@@ -86,8 +86,10 @@ import { BUILTIN_SLASH_COMMAND_RESERVED_NAMES } from "../slash-commands/builtin-
 import { formatDuration } from "../slash-commands/helpers/format";
 import { STTController, type SttState } from "../stt";
 import { discoverTitleSystemPromptFile, resolvePromptInput } from "../system-prompt";
+import { formatTaskId } from "../task/render";
 import type { LspStartupServerInfo } from "../tools";
 import { normalizeLocalScheme } from "../tools/path-utils";
+import { replaceTabs, TRUNCATE_LENGTHS, truncateToWidth } from "../tools/render-utils";
 import { setAutoQaConsentHandler } from "../tools/report-tool-issue";
 import { type ResolveToolDetails, runResolveInvocation } from "../tools/resolve";
 import { formatPhaseDisplayName, selectStickyTodoWindow, todoMatchesAnyDescription } from "../tools/todo";
@@ -132,6 +134,7 @@ import {
 	parseLoopLimitArgs,
 } from "./loop-limit";
 import { OAuthManualInputManager } from "./oauth-manual-input";
+import type { ObservableSession } from "./session-observer-registry";
 import { SessionObserverRegistry } from "./session-observer-registry";
 import { runProviderSetupWizard } from "./setup-wizard/lazy";
 import { interruptHint } from "./shared";
@@ -277,6 +280,41 @@ class StatusContainer extends Container implements NativeScrollbackLiveRegion {
 	}
 }
 
+/**
+ * Build the anchored subagent HUD block: a bold accent "Subagents" header plus
+ * one hooked row per running agent in the same `Id: description` shape the
+ * inline task rows use (muted task preview when no description was given).
+ * Returns an empty array when nothing is running so the container can clear.
+ */
+export function renderSubagentHudLines(sessions: ObservableSession[], columns: number): string[] {
+	const running = sessions.filter(session => session.kind === "subagent" && session.status === "active");
+	if (running.length === 0) return [];
+
+	const indent = "  ";
+	const hook = theme.tree.hook;
+	const dot = theme.styledSymbol("status.done", "accent");
+	const lines = ["", indent + theme.bold(theme.fg("accent", "Subagents"))];
+	running.forEach((session, index) => {
+		const prefix = `${indent}${index === 0 ? hook : " "} `;
+		const displayId = formatTaskId(session.id);
+		let line = `${prefix}${dot} ${theme.fg("accent", theme.bold(displayId))}`;
+		const description = session.description?.trim() || session.progress?.description?.trim();
+		if (description) {
+			const budget = Math.max(TRUNCATE_LENGTHS.SHORT, columns - visibleWidth(prefix) - visibleWidth(displayId) - 6);
+			line += `${theme.fg("accent", ":")} ${theme.fg("accent", truncateToWidth(replaceTabs(description), budget))}`;
+		} else {
+			// No spawn description: fall back to a muted task preview, same as
+			// the inline task rows when a row has no label.
+			const taskPreview = session.progress?.task?.trim();
+			if (taskPreview) {
+				line += ` ${theme.fg("muted", truncateToWidth(replaceTabs(taskPreview), TRUNCATE_LENGTHS.SHORT))}`;
+			}
+		}
+		lines.push(line);
+	});
+	return lines;
+}
+
 export class InteractiveMode implements InteractiveModeContext {
 	session: AgentSession;
 	sessionManager: SessionManager;
@@ -291,6 +329,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	pendingMessagesContainer: Container;
 	statusContainer: Container;
 	todoContainer: Container;
+	subagentContainer: Container;
 	btwContainer: Container;
 	omfgContainer: Container;
 	errorBannerContainer: Container;
@@ -440,6 +479,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.pendingMessagesContainer = new Container();
 		this.statusContainer = new StatusContainer();
 		this.todoContainer = new Container();
+		this.subagentContainer = new Container();
 		this.btwContainer = new Container();
 		this.omfgContainer = new Container();
 		this.errorBannerContainer = new Container();
@@ -606,6 +646,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.addChild(this.pendingMessagesContainer);
 		this.ui.addChild(this.statusContainer);
 		this.ui.addChild(this.todoContainer);
+		this.ui.addChild(this.subagentContainer);
 		this.ui.addChild(this.btwContainer);
 		this.ui.addChild(this.omfgContainer);
 		this.ui.addChild(this.errorBannerContainer);
@@ -632,6 +673,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#reconcileTodosWithSubagents();
 			this.#syncTodoAutoClearTimer();
 			this.#renderTodoList();
+			this.#renderSubagentList();
 			this.ui.requestRender();
 		});
 
@@ -1282,6 +1324,19 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.todoContainer.addChild(new Text(lines.join("\n"), 1, 0));
 	}
 
+	/**
+	 * Anchored HUD of in-flight subagents, mirroring the Todos block above the
+	 * editor. Driven entirely by observer-registry change events, so rows appear
+	 * on spawn and the whole block clears itself once the last subagent leaves
+	 * the "active" state.
+	 */
+	#renderSubagentList(): void {
+		this.subagentContainer.clear();
+		const lines = renderSubagentHudLines(this.#observerRegistry.getSessions(), this.ui.terminal.columns);
+		if (lines.length === 0) return;
+		this.subagentContainer.addChild(new Text(lines.join("\n"), 1, 0));
+	}
+
 	async #loadTodoList(): Promise<void> {
 		this.todoPhases = this.session.getTodoPhases();
 		this.#syncTodoAutoClearTimer();
@@ -3235,6 +3290,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#selectorController.showOAuthSelector(mode, providerId);
 	}
 
+	showResetUsageSelector(): Promise<void> {
+		return this.#selectorController.showResetUsageSelector();
+	}
+
 	showProviderSetup(): Promise<void> {
 		return runProviderSetupWizard(this);
 	}

package/src/modes/session-observer-registry.ts

@@ -10,6 +10,8 @@ export interface ObservableSession {
 	description?: string;
 	status: "active" | "completed" | "failed" | "aborted";
 	sessionFile?: string;
+	parentToolCallId?: string;
+	index?: number;
 	lastUpdate: number;
 	/** Latest progress snapshot from the subagent executor */
 	progress?: AgentProgress;
@@ -26,6 +28,9 @@ export class SessionObserverRegistry {
 	#sessions = new Map<string, ObservableSession>();
 	#listeners = new Set<() => void>();
 	#eventBusUnsubscribers: Array<() => void> = [];
+	#sortOrderById = new Map<string, number>();
+	#parentSortOrderById = new Map<string, number>();
+	#nextSortOrder = 0;
 
 	/** Add a change listener. Returns unsubscribe function. */
 	onChange(cb: () => void): () => void {
@@ -37,8 +42,34 @@ export class SessionObserverRegistry {
 		for (const cb of this.#listeners) cb();
 	}
 
+	#ensureSortOrder(id: string): number {
+		const existing = this.#sortOrderById.get(id);
+		if (existing !== undefined) return existing;
+		const order = this.#nextSortOrder++;
+		this.#sortOrderById.set(id, order);
+		return order;
+	}
+
+	#ensureParentSortOrder(parentToolCallId: string | undefined, order: number): void {
+		if (!parentToolCallId) return;
+		if (this.#parentSortOrderById.has(parentToolCallId)) return;
+		this.#parentSortOrderById.set(parentToolCallId, order);
+	}
+
+	#getStableOrder(session: ObservableSession): number {
+		return this.#sortOrderById.get(session.id) ?? Number.MAX_SAFE_INTEGER;
+	}
+
+	#getGroupOrder(session: ObservableSession): number {
+		const parentOrder = session.parentToolCallId
+			? this.#parentSortOrderById.get(session.parentToolCallId)
+			: undefined;
+		return parentOrder ?? this.#getStableOrder(session);
+	}
+
 	setMainSession(sessionFile?: string): void {
 		const existing = this.#sessions.get("main");
+		this.#ensureSortOrder("main");
 		this.#sessions.set("main", {
 			id: "main",
 			kind: "main",
@@ -53,9 +84,18 @@ export class SessionObserverRegistry {
 	getSessions(): ObservableSession[] {
 		const sessions = [...this.#sessions.values()];
 		sessions.sort((a, b) => {
-			if (a.kind === "main") return -1;
-			if (b.kind === "main") return 1;
-			return a.lastUpdate - b.lastUpdate;
+			if (a.kind === "main" && b.kind !== "main") return -1;
+			if (b.kind === "main" && a.kind !== "main") return 1;
+			if (a.kind === "main" || b.kind === "main") return 0;
+
+			const groupDiff = this.#getGroupOrder(a) - this.#getGroupOrder(b);
+			if (groupDiff !== 0) return groupDiff;
+
+			const aIndex = a.index ?? Number.MAX_SAFE_INTEGER;
+			const bIndex = b.index ?? Number.MAX_SAFE_INTEGER;
+			if (aIndex !== bIndex) return aIndex - bIndex;
+
+			return this.#getStableOrder(a) - this.#getStableOrder(b);
 		});
 		return sessions;
 	}
@@ -71,6 +111,9 @@ export class SessionObserverRegistry {
 	/** Clear all tracked sessions (e.g. on session switch). Keeps EventBus subscriptions and listeners. */
 	resetSessions(): void {
 		this.#sessions.clear();
+		this.#sortOrderById.clear();
+		this.#parentSortOrderById.clear();
+		this.#nextSortOrder = 0;
 		this.#notifyListeners();
 	}
 
@@ -78,6 +121,9 @@ export class SessionObserverRegistry {
 		for (const unsub of this.#eventBusUnsubscribers) unsub();
 		this.#eventBusUnsubscribers = [];
 		this.#sessions.clear();
+		this.#sortOrderById.clear();
+		this.#parentSortOrderById.clear();
+		this.#nextSortOrder = 0;
 		this.#listeners.clear();
 	}
 
@@ -92,10 +138,14 @@ export class SessionObserverRegistry {
 				const status = STATUS_MAP[payload.status];
 				if (!status) return;
 
+				const sortOrder = this.#ensureSortOrder(payload.id);
+				this.#ensureParentSortOrder(payload.parentToolCallId, sortOrder);
 				const existing = this.#sessions.get(payload.id);
 				if (existing) {
 					existing.status = status;
 					existing.lastUpdate = Date.now();
+					existing.index = payload.index;
+					existing.parentToolCallId = payload.parentToolCallId ?? existing.parentToolCallId;
 					if (payload.description) existing.description = payload.description;
 					if (payload.sessionFile) existing.sessionFile = payload.sessionFile;
 				} else {
@@ -107,6 +157,8 @@ export class SessionObserverRegistry {
 						description: payload.description,
 						status,
 						sessionFile: payload.sessionFile,
+						parentToolCallId: payload.parentToolCallId,
+						index: payload.index,
 						lastUpdate: Date.now(),
 					});
 				}
@@ -121,8 +173,12 @@ export class SessionObserverRegistry {
 				const id = progress.id;
 				const existing = this.#sessions.get(id);
 
+				const sortOrder = this.#ensureSortOrder(id);
+				this.#ensureParentSortOrder(payload.parentToolCallId, sortOrder);
 				if (existing) {
 					existing.lastUpdate = Date.now();
+					existing.index = payload.index;
+					existing.parentToolCallId = payload.parentToolCallId ?? existing.parentToolCallId;
 					existing.progress = progress;
 					if (progress.description) existing.description = progress.description;
 					if (payload.sessionFile) existing.sessionFile = payload.sessionFile;
@@ -135,6 +191,8 @@ export class SessionObserverRegistry {
 						description: progress.description,
 						status: "active",
 						sessionFile: payload.sessionFile,
+						parentToolCallId: payload.parentToolCallId,
+						index: payload.index,
 						lastUpdate: Date.now(),
 						progress,
 					});