@vanillagreen/pi-qol 1.2.0 → 1.4.0

package/extensions/qol/session-search/types.ts

@@ -0,0 +1,96 @@
+export type QolSessionSearchScope = "current" | "all";
+
+export interface QolSessionSearchSession {
+	allMessagesText: string;
+	created: Date;
+	cwd: string;
+	firstMessage: string;
+	id: string;
+	messageCount: number;
+	modified: Date;
+	name?: string;
+	parentSessionPath?: string;
+	path: string;
+}
+
+export interface QolSessionSearchResult extends QolSessionSearchSession {
+	rank: number;
+	snippets: string[];
+}
+
+export interface QolSessionUserMessage {
+	entryId?: string;
+	index: number;
+	parentId?: string | null;
+	text: string;
+	timestamp?: number;
+}
+
+export interface QolSessionSearchHit {
+	message: QolSessionUserMessage;
+	rank: number;
+	result: QolSessionSearchResult;
+	snippet: string;
+}
+
+export interface QolParsedSessionQuery {
+	mode: "tokens" | "regex";
+	tokens: Array<{ kind: "fuzzy" | "phrase"; value: string }>;
+	regex?: RegExp;
+	error?: string;
+}
+
+export interface QolSessionSearchState {
+	cursor: number;
+	query: string;
+	results: QolSessionSearchHit[];
+	selected: number;
+	scope: QolSessionSearchScope;
+	total: number;
+}
+
+export interface QolSessionMessagesState {
+	messages: QolSessionUserMessage[];
+	result: QolSessionSearchResult;
+	selected: number;
+}
+
+export interface QolSessionActionState {
+	message: QolSessionUserMessage;
+	result: QolSessionSearchResult;
+}
+
+export interface QolSessionContextConfirmState {
+	message: QolSessionUserMessage;
+	result: QolSessionSearchResult;
+	returnScreen: "search" | "messages" | "actions";
+	type: "summarize" | "newSession";
+}
+
+export interface QolSessionForkConfirmState {
+	messages: QolSessionUserMessage[];
+	result: QolSessionSearchResult;
+	returnScreen: "search" | "messages" | "actions";
+	selected: number;
+}
+
+export interface QolSessionConfirmModelState {
+	result: QolSessionSearchResult;
+	returnScreen: "search" | "messages" | "actions";
+	selected: 0 | 1;
+	previousModel: { provider: string; id: string };
+	currentModel: { provider: string; id: string };
+}
+
+export interface QolSessionSearchPendingMessage {
+	content: string;
+	details: Record<string, unknown>;
+}
+
+export interface QolSessionPaletteAction {
+	type: "cancel" | "resume" | "fork" | "copy" | "summarize" | "newSession";
+	customPrompt?: string;
+	keepCurrentModel?: boolean;
+	message?: QolSessionUserMessage;
+	result?: QolSessionSearchResult;
+}

package/extensions/qol/settings.ts

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { CONFIG_ID } from "./constants.js";
+
+export type VstackConfig = Record<string, unknown>;
+
+export function expandHome(input: string): string {
+	if (input === "~") return homedir();
+	if (input.startsWith("~/")) return join(homedir(), input.slice(2));
+	return input;
+}
+
+export function projectSettingsPath(cwd: string): string {
+	let current = resolve(cwd);
+	while (true) {
+		const candidate = join(current, ".pi", "settings.json");
+		if (existsSync(candidate)) return candidate;
+		if (existsSync(join(current, ".pi")) || existsSync(join(current, ".git")) || existsSync(join(current, ".vstack-lock.json"))) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return join(resolve(cwd), ".pi", "settings.json");
+		current = parent;
+	}
+}
+
+export function piSettingsPaths(cwd = process.cwd()): string[] {
+	const userDir = resolve(expandHome(process.env.PI_CODING_AGENT_DIR?.trim() || "~/.pi/agent"));
+	return [join(userDir, "settings.json"), projectSettingsPath(cwd)];
+}
+
+export function readVstackConfig(cwd?: string): VstackConfig {
+	const merged: VstackConfig = {};
+	for (const path of piSettingsPaths(cwd)) {
+		if (!existsSync(path)) continue;
+		try {
+			const parsed = JSON.parse(readFileSync(path, "utf8"));
+			const config = parsed?.vstack?.extensionManager?.config?.[CONFIG_ID];
+			if (config && typeof config === "object" && !Array.isArray(config)) Object.assign(merged, config);
+		} catch {
+			// Ignore malformed optional manager config.
+		}
+	}
+	return merged;
+}
+
+export function settingBoolean(key: string, fallback: boolean, cwd?: string): boolean {
+	const value = readVstackConfig(cwd)[key];
+	return typeof value === "boolean" ? value : fallback;
+}
+
+export function settingString(key: string, fallback: string, cwd?: string): string {
+	const value = readVstackConfig(cwd)[key];
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+
+export function settingStringAllowEmpty(key: string, fallback: string, cwd?: string): string {
+	const value = readVstackConfig(cwd)[key];
+	return typeof value === "string" ? value.trim() : fallback;
+}
+
+export function newlineFallbackKey(cwd?: string): "ctrl+j" | "none" {
+	const configured = settingString("newlineFallbackKey", "ctrl+j", cwd).toLowerCase();
+	return configured === "none" ? "none" : "ctrl+j";
+}
+
+export function settingNumber(key: string, fallback: number, cwd?: string): number {
+	const value = readVstackConfig(cwd)[key];
+	const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+	return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+export function boundedSettingNumber(key: string, fallback: number, min: number, max: number, cwd?: string): number {
+	return Math.max(min, Math.min(max, Math.floor(settingNumber(key, fallback, cwd))));
+}

package/extensions/qol/status-message.ts

@@ -0,0 +1,41 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { compactionProfile } from "./compaction.js";
+import {
+	DEFAULT_AUTO_RENAME_MODEL,
+	DEFAULT_COMPACTION_MODEL,
+	DEFAULT_IDLE_COMPACTION_SECONDS,
+	DEFAULT_PERMISSION_GATE_PREVIEW_CHARS,
+	DEFAULT_PERMISSION_GATE_PREVIEW_LINES,
+} from "./constants.js";
+import { currentEditorText } from "./editor.js";
+import { attachmentLabels } from "./images.js";
+import { permissionGateCommands } from "./permission-gate.js";
+import { autoRenameEnabled } from "./session-rename.js";
+import { sessionSearchShortcut } from "./session-search/index.js";
+import { boundedSettingNumber, newlineFallbackKey, settingBoolean, settingNumber, settingString } from "./settings.js";
+
+export function statusMessage(ctx: ExtensionContext): string {
+	const labels = attachmentLabels(currentEditorText(ctx), ctx.cwd);
+	const searchShortcut = sessionSearchShortcut(ctx.cwd);
+	return [
+		"Pi QOL status",
+		`Statusline: ${settingBoolean("replaceFooter", true, ctx.cwd) ? "replaces footer" : "footer preserved"}; prompt=${settingBoolean("compactPrompt", true, ctx.cwd) ? "π compact" : "default chrome"}`,
+		`shift+enter newline: ${settingBoolean("newlineOnShiftEnter", true, ctx.cwd) ? "enabled" : "disabled"}`,
+		`Fallback newline key: ${newlineFallbackKey(ctx.cwd)}`,
+		`Pending queue preview: ${settingBoolean("pendingQueue.asciiGreen", true, ctx.cwd) ? "ANSI green" : "Pi default"}`,
+		`Image chips: ${settingBoolean("showImageChips", true, ctx.cwd) ? "filled (placeholders and existing image paths)" : "off"}`,
+		`Image placeholders/paths in draft: ${labels.length ? labels.join(", ") : "none"}`,
+		`Rename command: ${settingBoolean("enableSessionNameCommand", true, ctx.cwd) ? "enabled (/rename)" : "disabled"}`,
+		`Auto session rename: ${autoRenameEnabled(ctx.cwd) ? `enabled (${settingString("sessionAutoRename.model", DEFAULT_AUTO_RENAME_MODEL, ctx.cwd)})` : "disabled"}`,
+		`Handoff command: ${settingBoolean("enableHandoffCommand", true, ctx.cwd) ? "enabled" : "disabled"}`,
+		`Handoff prompt review: ${settingBoolean("handoffReviewPrompt", true, ctx.cwd) ? "enabled" : "disabled"}`,
+		`Session search: ${settingBoolean("sessionSearch.enabled", true, ctx.cwd) ? `enabled (/search${searchShortcut ? `, ${searchShortcut}` : ""})` : "disabled"}`,
+		`Custom compaction: ${settingBoolean("compaction.customEnabled", false, ctx.cwd) ? `enabled (${settingString("compaction.model", DEFAULT_COMPACTION_MODEL, ctx.cwd)}, ${compactionProfile(ctx.cwd)})` : "disabled (Pi default)"}`,
+		`Idle compaction: ${settingBoolean("compaction.idleEnabled", false, ctx.cwd) ? `enabled after ${Math.max(1, Math.floor(settingNumber("compaction.idleTimeoutSeconds", DEFAULT_IDLE_COMPACTION_SECONDS, ctx.cwd)))}s idle` : "disabled"}`,
+		`Branch summary override: ${settingBoolean("compaction.branchSummaryEnabled", false, ctx.cwd) ? "enabled" : "disabled"}`,
+		`Notifications: ${settingBoolean("notification.enabled", true, ctx.cwd) ? `enabled (bell=${settingBoolean("notification.bell", true, ctx.cwd)}, native=${settingBoolean("notification.native", true, ctx.cwd)}, tmuxClientTty=${settingBoolean("notification.tmuxNativeClientTty", true, ctx.cwd)}, tmuxMessage=${settingBoolean("notification.tmux", false, ctx.cwd)})` : "disabled"}`,
+		`Permission gate: ${settingBoolean("permissionGate.enabled", false, ctx.cwd) ? `enabled (${permissionGateCommands(ctx.cwd).join(", ") || "none configured"}; preview ${boundedSettingNumber("permissionGate.previewLines", DEFAULT_PERMISSION_GATE_PREVIEW_LINES, 4, 40, ctx.cwd)} lines/${boundedSettingNumber("permissionGate.previewChars", DEFAULT_PERMISSION_GATE_PREVIEW_CHARS, 200, 5000, ctx.cwd)} chars)` : "disabled"}`,
+		`Thinking timer: ${settingBoolean("thinkingTimer.enabled", true, ctx.cwd) ? "enabled" : "disabled"}`,
+		"If shift+enter still submits, configure your terminal/tmux to send a distinct shift+enter sequence or use the fallback key.",
+	].join("\n");
+}

package/extensions/qol/statusline.ts

@@ -0,0 +1,219 @@
+import { execFile } from "node:child_process";
+import { basename } from "node:path";
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { subagentStatuslineMarker } from "./agent-statusline.js";
+import { stripAnsi } from "./ansi.js";
+import { readCavemanBridge } from "./bridges.js";
+import { CAVEMAN_ICON_ACTIVE, CAVEMAN_ICON_INACTIVE } from "./constants.js";
+import { settingBoolean, settingNumber } from "./settings.js";
+
+export interface GitState {
+	projectName: string;
+	branch?: string;
+	dirty: boolean;
+	inLinkedWorktree: boolean;
+}
+
+function repoNameFromRemote(remote: string): string | undefined {
+	const trimmed = remote.trim().replace(/\.git$/, "");
+	const match = trimmed.match(/([^/:]+)$/);
+	return match?.[1];
+}
+
+function formatModelName(ctx: ExtensionContext): string {
+	const model = ctx.model;
+	if (!model) return "no model";
+	let name = model.name || model.id;
+	name = name.replace(/^Claude\s+/i, "");
+	name = name.replace(/^claude[-_]/i, "");
+	name = name.replace(/[-_](20\d{6}|latest)$/i, "");
+	name = name.replace(/^gpt[-_]/i, "GPT ");
+	name = name.replace(/[-_]/g, " ");
+	name = name.replace(/\bopus\b/i, "Opus");
+	name = name.replace(/\bsonnet\b/i, "Sonnet");
+	name = name.replace(/\bhaiku\b/i, "Haiku");
+	name = name.replace(/\s+/g, " ").trim();
+	name = name.replace(/\b(Opus|Sonnet|Haiku) (\d) (\d)\b/, "$1 $2.$3");
+	return name;
+}
+
+type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+const THINKING_TOKEN: Record<ThinkingLevel, "thinkingOff" | "thinkingMinimal" | "thinkingLow" | "thinkingMedium" | "thinkingHigh" | "thinkingXhigh"> = {
+	off: "thinkingOff",
+	minimal: "thinkingMinimal",
+	low: "thinkingLow",
+	medium: "thinkingMedium",
+	high: "thinkingHigh",
+	xhigh: "thinkingXhigh",
+};
+
+function normalizeThinkingLevel(value: string | undefined): ThinkingLevel {
+	switch ((value ?? "").toLowerCase()) {
+		case "off": return "off";
+		case "minimal": return "minimal";
+		case "low": return "low";
+		case "medium": return "medium";
+		case "high": return "high";
+		case "xhigh": return "xhigh";
+		default: return "off";
+	}
+}
+
+function formatWindow(tokens: number | undefined): string {
+	if (!tokens || tokens <= 0) return "?";
+	if (tokens >= 1_000_000) {
+		const value = tokens / 1_000_000;
+		return `${Number.isInteger(value) ? value.toFixed(0) : value.toFixed(1)}M`;
+	}
+	if (tokens >= 1_000) {
+		const value = tokens / 1_000;
+		return `${Number.isInteger(value) ? value.toFixed(0) : value.toFixed(1)}k`;
+	}
+	return `${tokens}`;
+}
+
+function statuslineContextInfo(ctx: ExtensionContext): { label: string; percent: number | null } {
+	const usage = ctx.getContextUsage();
+	const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+	if (typeof usage?.percent !== "number") return { label: formatWindow(contextWindow), percent: null };
+	const usedPercent = Math.max(0, Math.min(100, Math.round(usage.percent)));
+	return { label: formatWindow(contextWindow), percent: 100 - usedPercent };
+}
+
+function gitBadge(state: GitState, showDirtyMarker: boolean): string {
+	if (!state.branch) return "";
+	const icon = state.inLinkedWorktree || state.branch !== "main" ? `🌳 ${state.branch}` : "🦀";
+	return ` (${icon}${state.dirty && showDirtyMarker ? "*" : ""})`;
+}
+
+export function makeFallbackGitState(cwd: string): GitState {
+	return { projectName: basename(cwd), dirty: false, inLinkedWorktree: false };
+}
+
+async function runGit(pi: ExtensionAPI, cwd: string, args: string[]): Promise<string | undefined> {
+	try {
+		const result = await pi.exec("git", ["-C", cwd, ...args], { timeout: settingNumber("gitRefreshTimeoutMs", 1500, cwd) });
+		if (result.code !== 0) return undefined;
+		const stdout = result.stdout.trim();
+		return stdout.length > 0 ? stdout : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export async function refreshGitState(pi: ExtensionAPI, ctx: ExtensionContext): Promise<GitState> {
+	const cwd = ctx.cwd;
+	const topLevel = await runGit(pi, cwd, ["rev-parse", "--show-toplevel"]);
+	if (!topLevel) return makeFallbackGitState(cwd);
+	const [remote, worktreesRaw, branchRaw, shortHead, diffExit] = await Promise.all([
+		runGit(pi, cwd, ["remote", "get-url", "origin"]),
+		runGit(pi, cwd, ["worktree", "list", "--porcelain"]),
+		runGit(pi, cwd, ["branch", "--show-current"]),
+		runGit(pi, cwd, ["rev-parse", "--short", "HEAD"]),
+		pi.exec("git", ["-C", cwd, "diff-index", "--quiet", "HEAD", "--"], { timeout: settingNumber("gitRefreshTimeoutMs", 1500, cwd) })
+			.then((result) => result.code)
+			.catch(() => 0),
+	]);
+	const firstWorktreeLine = worktreesRaw?.split("\n").find((line) => line.startsWith("worktree "));
+	const mainWorktree = firstWorktreeLine?.slice("worktree ".length).trim();
+	const inLinkedWorktree = Boolean(mainWorktree && mainWorktree !== topLevel);
+	const projectName = repoNameFromRemote(remote ?? "") ?? basename(mainWorktree || topLevel);
+	const branch = branchRaw || shortHead;
+	return { projectName, branch, dirty: diffExit === 1, inLinkedWorktree };
+}
+
+export function normalizedSessionName(pi: ExtensionAPI): string | undefined {
+	const name = pi.getSessionName();
+	if (!name) return undefined;
+	const normalized = stripAnsi(name).replace(/[\x00-\x1f\x7f]/g, " ").replace(/\s+/g, " ").trim();
+	return normalized || undefined;
+}
+
+export function sessionNameHeader(width: number, pi: ExtensionAPI, theme: Pick<Theme, "fg" | "bg">): string[] {
+	const name = normalizedSessionName(pi);
+	if (!name || width < 4) return [];
+	const prefixPlain = "Session ";
+	const prefix = theme.fg("muted", prefixPlain);
+	const innerWidth = Math.max(1, width - visibleWidth(prefixPlain) - 2);
+	const inner = truncateToWidth(name, innerWidth, "…");
+	const plain = ` ${inner} `;
+	const badge = theme.bg("selectedBg", theme.fg("text", plain));
+	return [truncateToWidth(`${prefix}${badge}`, width, "")];
+}
+
+export function formatTmuxSessionTitle(sessionName: string): string {
+	return `π ${sessionName}`;
+}
+
+export function tmuxPaneTarget(): string | undefined {
+	return process.env.TMUX && process.env.TMUX_PANE ? process.env.TMUX_PANE : undefined;
+}
+
+export function readTmuxPaneTitle(target: string, callback: (title: string | undefined) => void): void {
+	execFile("tmux", ["display-message", "-p", "-t", target, "#{pane_title}"], { timeout: 1000 }, (error, stdout) => callback(error ? undefined : stdout.replace(/\r?\n$/, "")));
+}
+
+export function readTmuxWindowOption(target: string, option: string, callback: (value: string | undefined) => void): void {
+	execFile("tmux", ["show-options", "-wqv", "-t", target, option], { timeout: 1000 }, (error, stdout) => callback(error ? undefined : stdout.replace(/\r?\n$/, "")));
+}
+
+export function setTmuxPaneTitle(target: string, title: string): void {
+	execFile("tmux", ["select-pane", "-t", target, "-T", title], { timeout: 1000 }, () => undefined);
+}
+
+export function setTmuxWindowOption(target: string, option: string, value: string): void {
+	execFile("tmux", ["set-option", "-wq", "-t", target, option, value], { timeout: 1000 }, () => undefined);
+}
+
+export function readTmuxWindowName(target: string, callback: (name: string | undefined) => void): void {
+	execFile("tmux", ["display-message", "-p", "-t", target, "#{window_name}"], { timeout: 1000 }, (error, stdout) => callback(error ? undefined : stdout.replace(/\r?\n$/, "")));
+}
+
+export function setTmuxWindowName(target: string, name: string): void {
+	execFile("tmux", ["rename-window", "-t", target, name], { timeout: 1000 }, () => undefined);
+}
+
+function cavemanIconTone(mode: string, active: boolean): "muted" | "text" | "success" | "thinkingHigh" | "error" {
+	if (!active) return "muted";
+	switch (mode) {
+		case "micro": return "text";
+		case "lite": return "success";
+		case "full": return "thinkingHigh";
+		case "ultra": return "error";
+		default: return "muted";
+	}
+}
+
+export function renderStatusLine(width: number, ctx: ExtensionContext, git: GitState, pi: ExtensionAPI, theme: Pick<Theme, "fg">): string {
+	const { label: contextLabel, percent } = statuslineContextInfo(ctx);
+	const projectChunk = `${git.projectName}${gitBadge(git, settingBoolean("showDirtyMarker", true, ctx.cwd))} ${formatModelName(ctx)}`;
+	const statusSeparator = " / ";
+	const thinkingLevel = normalizeThinkingLevel(pi.getThinkingLevel());
+	const thinkingChunk = thinkingLevel;
+	const contextChunk = ` ${contextLabel}`;
+	const cavemanBridge = readCavemanBridge();
+	const cavemanVisible = !!cavemanBridge && (cavemanBridge.isStatusBadgeEnabled?.(ctx.cwd) ?? true);
+	const caveman = cavemanVisible ? cavemanBridge : undefined;
+	const cavemanActive = caveman?.isActive() ?? false;
+	const cavemanGlyph = caveman ? (cavemanActive ? CAVEMAN_ICON_ACTIVE : CAVEMAN_ICON_INACTIVE) : "";
+	const cavemanTone = cavemanIconTone(caveman?.getMode() ?? "off", cavemanActive);
+	const cavemanSegment = caveman ? `${statusSeparator}${cavemanGlyph}` : "";
+	const contextSeparator = caveman ? ` ${statusSeparator}` : "";
+	const leftPlain = `${projectChunk}${statusSeparator}${thinkingChunk}${cavemanSegment}${contextSeparator}${contextChunk.trimStart()}`;
+	const percentPlain = percent === null ? "…%" : `${percent}%`;
+	const subagentMarker = subagentStatuslineMarker(ctx.cwd);
+	const rightPlain = subagentMarker ? `${percentPlain} ${subagentMarker.plain}` : percentPlain;
+	const percentColor = percent === null ? "muted" : percent <= 15 ? "error" : percent <= 30 ? "warning" : "success";
+	const separatorColored = theme.fg("muted", statusSeparator);
+	const leftColored = caveman
+		? `${theme.fg("accent", projectChunk)}${separatorColored}${theme.fg(THINKING_TOKEN[thinkingLevel], thinkingChunk)}${separatorColored}${theme.fg(cavemanTone, cavemanGlyph)}${theme.fg("muted", contextSeparator)}${theme.fg("accent", contextChunk.trimStart())}`
+		: `${theme.fg("accent", projectChunk)}${separatorColored}${theme.fg(THINKING_TOKEN[thinkingLevel], thinkingChunk)}${theme.fg("accent", contextChunk)}`;
+	const right = subagentMarker ? `${theme.fg(percentColor, percentPlain)} ${subagentMarker.styled}` : theme.fg(percentColor, percentPlain);
+	const minimumGap = 1;
+	const gapWidth = Math.max(minimumGap, width - visibleWidth(leftPlain) - visibleWidth(rightPlain) - 2);
+	const filled = percent === null ? 0 : Math.round(gapWidth * (percent / 100));
+	const empty = Math.max(0, gapWidth - filled);
+	const bar = " ".repeat(empty) + theme.fg("warning", "─".repeat(filled));
+	return truncateToWidth(`${leftColored} ${bar} ${right}`, width, "");
+}

package/extensions/qol/thinking-timer.ts

@@ -0,0 +1,97 @@
+import { AssistantMessageComponent, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { THINKING_LABEL_DEFAULT, THINKING_TIMER_PATCH_SYMBOL, THINKING_TIMER_STORE_SYMBOL } from "./constants.js";
+import { settingString } from "./settings.js";
+
+export interface ThinkingTimerStore {
+	cwd?: string;
+	enabled: boolean;
+	starts: Map<string, number>;
+	durations: Map<string, number>;
+	labels: Map<string, Text>;
+	theme?: ExtensionContext["ui"]["theme"];
+}
+
+export function getThinkingTimerStore(): ThinkingTimerStore | undefined {
+	return (globalThis as unknown as Record<PropertyKey, unknown>)[THINKING_TIMER_STORE_SYMBOL] as ThinkingTimerStore | undefined;
+}
+
+export function formatThinkingElapsed(ms: number): string {
+	const totalSeconds = ms / 1000;
+	if (totalSeconds < 60) return `${totalSeconds.toFixed(1)}s`;
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds - minutes * 60;
+	return `${minutes}:${seconds.toFixed(1).padStart(4, "0")}`;
+}
+
+export function thinkingLabel(cwd?: string): string {
+	const configured = settingString("thinkingLabel.text", THINKING_LABEL_DEFAULT, cwd);
+	return configured.trim() ? configured : THINKING_LABEL_DEFAULT;
+}
+
+export function thinkingTimerLabel(theme: ThinkingTimerStore["theme"], ms: number, cwd?: string): string {
+	const base = thinkingLabel(cwd);
+	const separator = /\s$/.test(base) ? "" : " ";
+	const elapsed = `${separator}${formatThinkingElapsed(ms)}`;
+	if (!theme) return `${base}${elapsed}`;
+	return theme.italic(theme.fg("muted", base) + theme.fg("dim", elapsed));
+}
+
+export function hiddenThinkingLabel(theme: ThinkingTimerStore["theme"], cwd?: string): string {
+	const base = thinkingLabel(cwd);
+	return theme ? theme.fg("muted", base) : base;
+}
+
+export function thinkingTimerKey(timestamp: number, contentIndex: number): string {
+	return `${timestamp}:${contentIndex}`;
+}
+
+export function installThinkingTimerPatch(): void {
+	const proto = AssistantMessageComponent.prototype as unknown as Record<PropertyKey, any>;
+	if (proto[THINKING_TIMER_PATCH_SYMBOL]) return;
+	const originalUpdateContent = proto.updateContent;
+	if (typeof originalUpdateContent !== "function") return;
+	proto[THINKING_TIMER_PATCH_SYMBOL] = true;
+	proto.updateContent = function patchedUpdateContent(this: any, message: any): void {
+		originalUpdateContent.call(this, message);
+		try {
+			const store = getThinkingTimerStore();
+			if (!store?.enabled) return;
+			if (!message || !Array.isArray(message.content) || typeof message.timestamp !== "number") return;
+			if (!this.hideThinkingBlock) return;
+			if (!this.contentContainer || !Array.isArray(this.contentContainer.children)) return;
+
+			const thinkingIndices: number[] = [];
+			for (let i = 0; i < message.content.length; i++) {
+				const content = message.content[i];
+				if (content?.type === "thinking" && typeof content.thinking === "string" && content.thinking.trim()) thinkingIndices.push(i);
+			}
+			if (thinkingIndices.length === 0) return;
+
+			const labelComponents: Text[] = [];
+			for (const child of this.contentContainer.children as any[]) {
+				if (!child || typeof child !== "object") continue;
+				if (typeof child.setText !== "function") continue;
+				if (typeof child.text !== "string") continue;
+				const expectedLabel = thinkingLabel(store.cwd);
+				if (!child.text.includes(expectedLabel) && !child.text.includes("Thinking...")) continue;
+				labelComponents.push(child as Text);
+			}
+			if (labelComponents.length === 0) return;
+
+			const count = Math.min(thinkingIndices.length, labelComponents.length);
+			for (let i = 0; i < count; i++) {
+				const contentIndex = thinkingIndices[i]!;
+				const label = labelComponents[i]!;
+				const key = thinkingTimerKey(message.timestamp, contentIndex);
+				store.labels.set(key, label);
+				const duration = store.durations.get(key);
+				const start = store.starts.get(key);
+				const ms = duration ?? (start === undefined ? undefined : Date.now() - start);
+				if (ms !== undefined) label.setText(thinkingTimerLabel(store.theme, ms, store.cwd));
+			}
+		} catch {
+			// Rendering must never break because of this optional monkey-patch.
+		}
+	};
+}

package/extensions/qol/util.ts

@@ -0,0 +1,7 @@
+export function stringifyError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+export function escapeRegex(input: string): string {
+	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}