@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.4

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

@@ -9,6 +9,7 @@ import {
 	Input,
 	matchesKey,
 	ScrollView,
+	type SgrMouseEvent,
 	Spacer,
 	type Tab,
 	TabBar,
@@ -174,7 +175,12 @@ export class ModelSelectorComponent extends Container {
 	#tui: TUI;
 	#scopedModels: ReadonlyArray<ScopedModelItem>;
 	#temporaryOnly: boolean;
+	#directSelect: boolean;
+	#pickerHint: string | undefined;
 	#currentContextTokens: number;
+	#listLineOffset = 0;
+	#listStartIndex = 0;
+	#listVisibleCount = 0;
 
 	#menuRoleActions: MenuRoleAction[] = [];
 
@@ -200,7 +206,13 @@ export class ModelSelectorComponent extends Container {
 		scopedModels: ReadonlyArray<ScopedModelItem>,
 		onSelect: RoleSelectCallback,
 		onCancel: () => void,
-		options?: { temporaryOnly?: boolean; initialSearchInput?: string; currentContextTokens?: number },
+		options?: {
+			temporaryOnly?: boolean;
+			directSelect?: boolean;
+			pickerHint?: string;
+			initialSearchInput?: string;
+			currentContextTokens?: number;
+		},
 	) {
 		super();
 
@@ -211,6 +223,8 @@ export class ModelSelectorComponent extends Container {
 		this.#onSelectCallback = onSelect;
 		this.#onCancelCallback = onCancel;
 		this.#temporaryOnly = options?.temporaryOnly ?? false;
+		this.#directSelect = options?.directSelect ?? false;
+		this.#pickerHint = options?.pickerHint;
 		const currentContextTokens = options?.currentContextTokens ?? 0;
 		this.#currentContextTokens =
 			Number.isFinite(currentContextTokens) && currentContextTokens > 0 ? Math.floor(currentContextTokens) : 0;
@@ -236,6 +250,9 @@ export class ModelSelectorComponent extends Container {
 		if (this.#temporaryOnly) {
 			this.addChild(new Text(theme.fg("muted", TEMPORARY_MODEL_PICKER_HINT), 0, 0));
 			this.addChild(new Spacer(1));
+		} else if (this.#directSelect && this.#pickerHint) {
+			this.addChild(new Text(theme.fg("muted", this.#pickerHint), 0, 0));
+			this.addChild(new Spacer(1));
 		}
 
 		// Create header container for tab bar
@@ -714,10 +731,6 @@ export class ModelSelectorComponent extends Container {
 		return this.#temporaryOnly && this.#isModelOverCurrentContext(model);
 	}
 
-	#isDefaultRoleActionOverContextLimit(action: MenuRoleAction, model: Model): boolean {
-		return action.role === "default" && this.#isModelOverCurrentContext(model);
-	}
-
 	#formatCurrentContextLimitSuffix(model: Model): string {
 		return ` ${theme.status.disabled} context>${formatNumber(model.contextWindow ?? 0).toLowerCase()}`;
 	}
@@ -937,6 +950,8 @@ export class ModelSelectorComponent extends Container {
 			Math.min(this.#selectedIndex - Math.floor(maxVisible / 2), visibleItems.length - maxVisible),
 		);
 		const endIndex = Math.min(startIndex + maxVisible, visibleItems.length);
+		this.#listStartIndex = startIndex;
+		this.#listVisibleCount = Math.max(0, endIndex - startIndex);
 
 		const showProvider = this.#getActiveTabId() === ALL_TAB;
 
@@ -1065,47 +1080,16 @@ export class ModelSelectorComponent extends Container {
 			: this.#filteredModels[this.#selectedIndex];
 	}
 
-	#isMenuRoleIndexDisabled(index: number, selectedItem: ModelItem | CanonicalModelItem): boolean {
-		const action = this.#menuRoleActions[index];
-		return action ? this.#isDefaultRoleActionOverContextLimit(action, selectedItem.model) : false;
-	}
-
-	#coerceMenuSelectedIndex(index: number, selectedItem: ModelItem | CanonicalModelItem): number {
+	#coerceMenuSelectedIndex(index: number): number {
 		const maxIndex = this.#menuRoleActions.length - 1;
 		if (maxIndex < 0) {
 			return 0;
 		}
-		const clamped = Math.max(0, Math.min(index, maxIndex));
-		if (!this.#isMenuRoleIndexDisabled(clamped, selectedItem)) {
-			return clamped;
-		}
-		for (let i = clamped + 1; i <= maxIndex; i++) {
-			if (!this.#isMenuRoleIndexDisabled(i, selectedItem)) {
-				return i;
-			}
-		}
-		for (let i = clamped - 1; i >= 0; i--) {
-			if (!this.#isMenuRoleIndexDisabled(i, selectedItem)) {
-				return i;
-			}
-		}
-		return clamped;
+		return Math.max(0, Math.min(index, maxIndex));
 	}
 
-	#moveMenuSelection(delta: number, selectedItem: ModelItem | CanonicalModelItem, optionCount: number): void {
-		let index = this.#menuSelectedIndex;
-		for (let step = 0; step < optionCount; step++) {
-			index = (index + delta + optionCount) % optionCount;
-			if (this.#menuStep !== "role" || !this.#isMenuRoleIndexDisabled(index, selectedItem)) {
-				this.#menuSelectedIndex = index;
-				this.#updateMenu();
-				return;
-			}
-		}
-		this.#menuSelectedIndex =
-			this.#menuStep === "role"
-				? this.#coerceMenuSelectedIndex(this.#menuSelectedIndex, selectedItem)
-				: this.#menuSelectedIndex;
+	#moveMenuSelection(delta: number, _selectedItem: ModelItem | CanonicalModelItem, optionCount: number): void {
+		this.#menuSelectedIndex = (this.#menuSelectedIndex + delta + optionCount) % optionCount;
 		this.#updateMenu();
 	}
 
@@ -1116,7 +1100,7 @@ export class ModelSelectorComponent extends Container {
 		this.#isMenuOpen = true;
 		this.#menuStep = "role";
 		this.#menuSelectedRole = null;
-		this.#menuSelectedIndex = this.#coerceMenuSelectedIndex(0, selectedItem);
+		this.#menuSelectedIndex = this.#coerceMenuSelectedIndex(0);
 		// Collapse the model list while the action/thinking menu is open so the
 		// menu owns the full viewport instead of stacking below a now-irrelevant
 		// (and often off-screen) list.
@@ -1149,9 +1133,7 @@ export class ModelSelectorComponent extends Container {
 				})
 			: this.#menuRoleActions.map((action, index) => {
 					const prefix = index === this.#menuSelectedIndex ? `  ${theme.nav.cursor} ` : "    ";
-					const disabled = this.#isDefaultRoleActionOverContextLimit(action, selectedItem.model);
-					const suffix = disabled ? this.#formatCurrentContextLimitSuffix(selectedItem.model) : "";
-					return `${prefix}${action.label}${suffix}`;
+					return `${prefix}${action.label}`;
 				});
 
 		const selectedRoleName = this.#menuSelectedRole ? getRoleInfo(this.#menuSelectedRole, this.#settings).name : "";
@@ -1231,6 +1213,55 @@ export class ModelSelectorComponent extends Container {
 		return Math.max(MIN_VISIBLE_OPTIONS, Math.min(optionCount, terminalRows - MENU_CHROME_ROWS));
 	}
 
+	/**
+	 * Concatenate children like Container.render, recording where the model list
+	 * lands so routed mouse events can be hit-tested against it.
+	 */
+	override render(width: number): readonly string[] {
+		const lines: string[] = [];
+		for (const child of this.children) {
+			const childLines = child.render(Math.max(1, width));
+			if (child === this.#listContainer) {
+				this.#listLineOffset = lines.length;
+			}
+			lines.push(...childLines);
+		}
+		return lines;
+	}
+
+	routeMouse(event: SgrMouseEvent, line: number, _col: number): void {
+		if (this.#isMenuOpen) return;
+
+		if (event.wheel !== null) {
+			this.#moveSelection(event.wheel);
+			return;
+		}
+
+		const listLine = line - this.#listLineOffset;
+		if (listLine < 0 || listLine >= this.#listVisibleCount) return;
+
+		const index = this.#listStartIndex + listLine;
+		const item = this.#getVisibleItems()[index];
+		if (!item || this.#isItemDisabled(item)) return;
+
+		if (event.motion) {
+			if (index !== this.#selectedIndex) {
+				this.#selectedIndex = index;
+				this.#updateList();
+			}
+			return;
+		}
+
+		if (event.leftClick) {
+			this.#selectedIndex = index;
+			if (this.#temporaryOnly || this.#directSelect) {
+				this.#handleSelect(item, null);
+			} else {
+				this.#openMenu();
+			}
+		}
+	}
+
 	handleInput(keyData: string): void {
 		if (this.#isMenuOpen) {
 			this.#handleMenuInput(keyData);
@@ -1254,12 +1285,12 @@ export class ModelSelectorComponent extends Container {
 			return;
 		}
 
-		// Enter - open context menu or select directly in temporary mode
+		// Enter - open context menu or select directly in temporary/direct-select mode
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			const selectedItem = this.#getSelectedItem();
 			if (selectedItem && !this.#isItemDisabled(selectedItem)) {
-				if (this.#temporaryOnly) {
-					// In temporary mode, skip menu and select directly
+				if (this.#temporaryOnly || this.#directSelect) {
+					// In temporary/direct-select mode, skip menu and select directly
 					this.#handleSelect(selectedItem, null);
 				} else {
 					this.#openMenu();
@@ -1301,7 +1332,7 @@ export class ModelSelectorComponent extends Container {
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			if (this.#menuStep === "role") {
 				const action = this.#menuRoleActions[this.#menuSelectedIndex];
-				if (!action || this.#isDefaultRoleActionOverContextLimit(action, selectedItem.model)) return;
+				if (!action) return;
 				this.#menuSelectedRole = action.role;
 				this.#menuStep = "thinking";
 				this.#menuSelectedIndex = this.#getThinkingPreselectIndex(action.role, selectedItem.model);

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

@@ -387,6 +387,7 @@ export interface StatusLinePreviewSettings {
 	separator?: StatusLineSeparatorStyle;
 	sessionAccent?: boolean;
 	transparent?: boolean;
+	compactThinkingLevel?: boolean;
 }
 
 export interface SettingsCallbacks {

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

@@ -162,6 +162,29 @@ interface ActiveRepoCache {
 	effectiveGitCwd: string;
 }
 
+/**
+ * Per-{@link AgentSession} active-processing meter for the `time_spent`
+ * segment. `activeMs` is the union of every completed `agent_start`→
+ * `agent_end` window; `activeStartedAt` is the start timestamp of the
+ * currently-running window, or `null` when idle.
+ *
+ * `sessionFile` snapshots the loaded session-file path at meter-creation
+ * time. `AgentSession.switchSession` (/resume, /move, ACP fork, RPC
+ * `switch_session`, extension `switchSession`) mutates the loaded file
+ * under the same {@link AgentSession} ref, so the WeakMap key alone
+ * cannot tell two conversations apart. `#meter()` compares this snapshot
+ * against the live `session.sessionFile`, and a real-to-real change
+ * starts the meter fresh instead of crediting the new conversation with
+ * the previous one's accumulated active time. The undefined → real
+ * first-save transition does not reset, since the session identity has
+ * not changed.
+ */
+interface ActiveMeter {
+	activeMs: number;
+	activeStartedAt: number | null;
+	sessionFile: string | undefined;
+}
+
 const EMPTY_MESSAGES: readonly AgentMessage[] = [];
 const STATUS_USAGE_START_DELAY_MS = 0;
 const STATUS_USAGE_REFRESH_TIMEOUT_MS = 2_000;
@@ -200,7 +223,25 @@ export class StatusLineComponent implements Component {
 	#autoCompactEnabled: boolean = true;
 	#hookStatuses: Map<string, string> = new Map();
 	#subagentCount: number = 0;
-	#sessionStartTime: number = Date.now();
+	/**
+	 * Active-processing accounting for the `time_spent` segment, keyed per
+	 * {@link AgentSession} so the focus-controller mid-turn attach path
+	 * cannot leak an unmatched synthesized `agent_start` from a subagent
+	 * into the main session's meter.
+	 *
+	 * Each meter is `{ activeMs, activeStartedAt }`: `activeMs` is the union
+	 * of every completed `agent_start`→`agent_end` window since
+	 * {@link resetActiveTime} last reset it; `activeStartedAt` is the start
+	 * timestamp of the currently-running window (or `null` when idle).
+	 * `getActiveMs()` returns `activeMs + (now - activeStartedAt)` for the
+	 * currently-attached session, so the counter ticks live during a turn
+	 * and freezes the instant the agent yields.
+	 *
+	 * WeakMap so meters die with their session (e.g. a parked subagent
+	 * dropped from the registry); the main session's meter survives focus
+	 * round-trips because the same {@link AgentSession} ref is reused.
+	 */
+	#activeMeters: WeakMap<AgentSession, ActiveMeter> = new WeakMap();
 	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#loopModeStatus: { enabled: boolean } | null = null;
 	#goalModeStatus: { enabled: boolean; paused: boolean } | null = null;
@@ -250,6 +291,7 @@ export class StatusLineComponent implements Component {
 			segmentOptions: settings.getGroup("statusLine").segmentOptions,
 			sessionAccent: settings.get("statusLine.sessionAccent"),
 			transparent: settings.get("statusLine.transparent"),
+			compactThinkingLevel: settings.get("statusLine.compactThinkingLevel"),
 		};
 	}
 	#gitEnabled(): boolean {
@@ -283,10 +325,30 @@ export class StatusLineComponent implements Component {
 		if (!sessionChanged && this.#focusedAgentId === focusedAgentId) return;
 		this.session = session;
 		this.#focusedAgentId = focusedAgentId;
-		if (sessionChanged) this.#invalidateSessionCaches();
+		if (sessionChanged) {
+			this.#invalidateSessionCaches();
+			this.#closeStaleActiveWindow();
+		}
 		this.invalidate();
 	}
 
+	/**
+	 * Drop a meter's in-flight window when the newly-attached session is no
+	 * longer streaming. Handles the case where the focus controller
+	 * synthesized an `agent_start` on a mid-turn attach but the matching
+	 * real `agent_end` never reached us — the user detached before it
+	 * fired, and re-focusing later (after the agent finished) would
+	 * otherwise tick over the entire detached gap. Crediting that gap to
+	 * `activeMs` would be wrong (the agent finished at some point we never
+	 * observed), so the window is dropped rather than folded in.
+	 */
+	#closeStaleActiveWindow(): void {
+		const meter = this.#meter();
+		if (meter.activeStartedAt === null) return;
+		if (this.session.isStreaming) return;
+		meter.activeStartedAt = null;
+	}
+
 	updateSettings(settings: StatusLineSettings): void {
 		this.#settings = settings;
 		this.#effectiveSettings = undefined;
@@ -305,13 +367,95 @@ export class StatusLineComponent implements Component {
 		this.#subagentCount = count;
 	}
 
+	/**
+	 * Compatibility shim for callers predating the simplified subagent badge.
+	 * The status line now intentionally shows only the active count.
+	 */
+	setSubagentHubHint(_hint: string | undefined): void {}
+
 	/** Active subagent count as currently displayed (collab state mirroring). */
 	get subagentCount(): number {
 		return this.#subagentCount;
 	}
 
-	setSessionStartTime(time: number): void {
-		this.#sessionStartTime = time;
+	/**
+	 * Reset the currently-attached session's active-time accumulators so
+	 * the `time_spent` segment starts from zero. Called from `/clear`,
+	 * fresh-session, and joined-collab paths; both the completed
+	 * accumulator and any in-flight window are dropped, so a reset
+	 * mid-turn ignores the running window (the matching `markActivityEnd`
+	 * will see an idle meter and no-op).
+	 */
+	resetActiveTime(): void {
+		const meter = this.#meter();
+		meter.activeMs = 0;
+		meter.activeStartedAt = null;
+	}
+
+	/**
+	 * Mark the currently-attached session as having started a unit of
+	 * active processing. Idempotent: a second start while a window is
+	 * already open is a no-op, so reentrant `agent_start` events (e.g.
+	 * nested auto-compaction loops, focus-controller mid-turn attach onto
+	 * an already-running window) do not double-count.
+	 */
+	markActivityStart(): void {
+		const meter = this.#meter();
+		if (meter.activeStartedAt !== null) return;
+		meter.activeStartedAt = Date.now();
+	}
+
+	/**
+	 * Close the currently-attached session's open active-processing
+	 * window, folding its elapsed time into the accumulator. Idempotent
+	 * when the meter is already idle so callers can fire it on every
+	 * `agent_end` without guarding.
+	 */
+	markActivityEnd(): void {
+		const meter = this.#meter();
+		if (meter.activeStartedAt === null) return;
+		meter.activeMs += Math.max(0, Date.now() - meter.activeStartedAt);
+		meter.activeStartedAt = null;
+	}
+
+	/**
+	 * Snapshot of total active-processing time for the currently-attached
+	 * session, including any in-flight window. Exposed for the segment
+	 * context builder; tests assert against this too.
+	 */
+	getActiveMs(): number {
+		const meter = this.#meter();
+		if (meter.activeStartedAt === null) return meter.activeMs;
+		return meter.activeMs + Math.max(0, Date.now() - meter.activeStartedAt);
+	}
+
+	/**
+	 * Return (lazily creating) the meter for the currently-attached
+	 * session. Detects an in-place session-file swap under the same
+	 * {@link AgentSession} ref (`switchSession` paths: `/resume`, `/move`,
+	 * ACP fork/load, RPC `switch_session`, extension `switchSession`):
+	 * a real-to-real change starts the meter fresh so the new
+	 * conversation does not inherit the previous one's accumulated active
+	 * time. The undefined → real first-save transition only refreshes the
+	 * snapshot — the conversation identity has not changed.
+	 */
+	#meter(): ActiveMeter {
+		const currentFile = this.session.sessionFile;
+		let meter = this.#activeMeters.get(this.session);
+		if (meter) {
+			const switched =
+				currentFile !== undefined && meter.sessionFile !== undefined && meter.sessionFile !== currentFile;
+			if (switched) {
+				meter = undefined;
+			} else {
+				meter.sessionFile = currentFile;
+			}
+		}
+		if (!meter) {
+			meter = { activeMs: 0, activeStartedAt: null, sessionFile: currentFile };
+			this.#activeMeters.set(this.session, meter);
+		}
+		return meter;
 	}
 
 	setPlanModeStatus(status: { enabled: boolean; paused: boolean } | undefined): void {
@@ -854,6 +998,7 @@ export class StatusLineComponent implements Component {
 			activeRepo: activeRepoCache.activeRepo,
 			width,
 			options: segmentOptions ?? {},
+			compactThinkingLevel: this.#resolveSettings().compactThinkingLevel ?? false,
 			planMode: this.#planModeStatus,
 			loopMode: this.#loopModeStatus,
 			goalMode: this.#goalModeStatus,
@@ -864,7 +1009,7 @@ export class StatusLineComponent implements Component {
 			contextWindow,
 			autoCompactEnabled: this.#autoCompactEnabled,
 			subagentCount: this.#subagentCount,
-			sessionStartTime: this.#sessionStartTime,
+			activeMs: this.getActiveMs(),
 			git: {
 				branch: gitBranch,
 				status: gitStatus,

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

@@ -20,6 +20,16 @@ function withIcon(icon: string, text: string): string {
 	return icon ? `${icon} ${text}` : text;
 }
 
+/**
+ * Leading glyph of a thinking-level display string (e.g. "◉ xhigh" → "◉").
+ * Compact mode promotes this glyph to the model-segment icon so the level
+ * stays visible without the verbose " · <level>" tail.
+ */
+function thinkingGlyph(display: string): string {
+	const space = display.indexOf(" ");
+	return space === -1 ? display : display.slice(0, space);
+}
+
 function stripDisplayRoot(pwd: string): string {
 	for (const root of [path.join(os.homedir(), "Projects"), "/work"]) {
 		const relative = relativePathWithinRoot(root, pwd);
@@ -86,37 +96,46 @@ const modelSegment: StatusLineSegment = {
 			modelName = modelName.slice(7);
 		}
 
-		// Fast-mode icon and thinking-level suffix trail the model name and are
-		// colored together with it as `statusLineModel`. The advisor "++" badge
-		// sits between the name and that tail in `accent`, so it reads as a
-		// distinct marker. theme.fg resets only the fg, so the spans are
-		// concatenated (not nested) to keep each color intact.
-		let tail = "";
-		if (ctx.session.isFastModeActive() && theme.icon.fast) {
-			tail += ` ${theme.icon.fast}`;
-		}
-
+		// Resolve the current thinking-level display ("◉ xhigh", "⟳ auto", …)
+		// when the model supports thinking and the segment isn't hiding it.
+		let thinkingDisplay = "";
 		if (opts.showThinkingLevel !== false && state.model?.thinking) {
 			if (ctx.session.isAutoThinking) {
 				// Pending (no turn classified yet / classifying) shows a symbol-theme
 				// question-box marker; once resolved it shows `<level>`.
 				const resolved = ctx.session.autoResolvedThinkingLevel();
-				const resolvedText = resolved ? (theme.thinking[resolved as keyof typeof theme.thinking] ?? resolved) : "";
-				tail += `${theme.sep.dot}${resolved ? resolvedText : `${theme.thinking.autoPending} auto`}`;
+				thinkingDisplay = resolved
+					? (theme.thinking[resolved as keyof typeof theme.thinking] ?? resolved)
+					: `${theme.thinking.autoPending} auto`;
 			} else {
 				const level = state.thinkingLevel ?? ThinkingLevel.Off;
 				if (level !== ThinkingLevel.Off) {
-					const thinkingText = theme.thinking[level as keyof typeof theme.thinking];
-					if (thinkingText) {
-						tail += `${theme.sep.dot}${thinkingText}`;
-					}
+					thinkingDisplay = theme.thinking[level as keyof typeof theme.thinking] ?? "";
 				}
 			}
 		}
 
+		// Compact mode swaps the model icon for the thinking-level glyph and drops
+		// the " · <level>" tail, keeping the level visible as a single icon.
+		const compact = ctx.compactThinkingLevel && thinkingDisplay !== "";
+		const modelIcon = compact ? thinkingGlyph(thinkingDisplay) : theme.icon.model;
+
+		// Fast-mode icon and thinking-level suffix trail the model name and are
+		// colored together with it as `statusLineModel`. The advisor "++" badge
+		// sits between the name and that tail in `accent`, so it reads as a
+		// distinct marker. theme.fg resets only the fg, so the spans are
+		// concatenated (not nested) to keep each color intact.
+		let tail = "";
+		if (ctx.session.isFastModeActive() && theme.icon.fast) {
+			tail += ` ${theme.icon.fast}`;
+		}
+		if (!compact && thinkingDisplay) {
+			tail += `${theme.sep.dot}${thinkingDisplay}`;
+		}
+
 		// `statusLineModel` is aliased to `accent` in many themes, so the badge
 		// uses `success` to stay visibly distinct from the model name color.
-		let content = theme.fg("statusLineModel", withIcon(theme.icon.model, modelName));
+		let content = theme.fg("statusLineModel", withIcon(modelIcon, modelName));
 		if (ctx.session.isAdvisorActive()) {
 			content += theme.fg("success", "++");
 		}
@@ -400,13 +419,19 @@ const contextTotalSegment: StatusLineSegment = {
 	},
 };
 
+/**
+ * Total time the agent was actively processing this session — the union of
+ * every `agent_start`→`agent_end` window plus the currently-running window,
+ * sourced from {@link SegmentContext.activeMs}. Idle wall-clock between turns
+ * never accumulates, so the displayed total reflects how long the agent has
+ * been working for the user, not how long the session has been open. Hidden
+ * before the first second of activity to avoid flashing `0s` at session start.
+ */
 const timeSpentSegment: StatusLineSegment = {
 	id: "time_spent",
 	render(ctx) {
-		const elapsed = Date.now() - ctx.sessionStartTime;
-		if (elapsed < 1000) return { content: "", visible: false };
-
-		return { content: withIcon(theme.icon.time, formatDuration(elapsed)), visible: true };
+		if (ctx.activeMs < 1000) return { content: "", visible: false };
+		return { content: withIcon(theme.icon.time, formatDuration(ctx.activeMs)), visible: true };
 	},
 };
 

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

@@ -31,6 +31,9 @@ export interface StatusLineSettings {
 	/** Drop the theme's `statusLineBg` fill and powerline caps so the bar
 	 *  inherits the terminal's default background. */
 	transparent?: boolean;
+	/** Replace the model-segment icon with the thinking-level glyph and drop the
+	 *  " · <level>" suffix, so the thinking level reads as a single compact icon. */
+	compactThinkingLevel?: boolean;
 }
 
 export type EffectiveStatusLineSettings = Required<
@@ -51,6 +54,8 @@ export interface SegmentContext {
 	activeRepo: ActiveRepoContext | null;
 	width: number;
 	options: StatusLineSegmentOptions;
+	/** Render the model segment's thinking level as a compact leading glyph. */
+	compactThinkingLevel: boolean;
 	planMode: {
 		enabled: boolean;
 		paused: boolean;
@@ -79,7 +84,14 @@ export interface SegmentContext {
 	contextWindow: number;
 	autoCompactEnabled: boolean;
 	subagentCount: number;
-	sessionStartTime: number;
+	/**
+	 * Active processing time accumulated this session, in ms — the union of
+	 * every `agent_start`→`agent_end` window plus the currently-streaming
+	 * window if the agent is running. Idle wall-clock never contributes, so
+	 * this is what {@link StatusLineSegmentId.time_spent} renders instead of
+	 * `Date.now() - sessionStart`.
+	 */
+	activeMs: number;
 	git: {
 		branch: string | null;
 		status: { staged: number; unstaged: number; untracked: number } | null;