@selesai/code 0.9.14 → 0.10.0

package/dist/extensions/pi-powerline-footer/index.ts

@@ -1,3428 +0,0 @@
-import {
-  copyToClipboard,
-  CONFIG_DIR_NAME,
-  getAgentDir,
-  getSettingsPath,
-  VERSION,
-  type ExtensionAPI,
-  type ReadonlyFooterDataProvider,
-  type Theme,
-} from "@selesai/code";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
-import { CURSOR_MARKER, isKeyRelease, type AutocompleteProvider, type SelectItem, SelectList, truncateToWidth, TUI_KEYBINDINGS, visibleWidth } from "@earendil-works/pi-tui";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
-import { join, dirname } from "node:path";
-
-import type { ColorScheme, SegmentContext, StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "./types.ts";
-import type { PowerlineConfig } from "./powerline-config.ts";
-import { BashTranscriptStore } from "./bash-mode/transcript.ts";
-import {
-  BashCompletionEngine,
-  BashAutocompleteProvider,
-  getOneOffBashCommandContext,
-  ModeAwareAutocompleteProvider,
-  OneOffBashAutocompleteProvider,
-} from "./bash-mode/completion.ts";
-import { BashModeEditor, isPrintableInput } from "./bash-mode/editor.ts";
-import { ManagedShellSession } from "./bash-mode/shell-session.ts";
-import { matchHistoryEntries, readGlobalShellHistory, readProjectHistory, appendProjectHistory } from "./bash-mode/history.ts";
-import type { BashModeSettings } from "./bash-mode/types.ts";
-import { getPreset, PRESETS } from "./presets.ts";
-import { getAgentPath } from "./paths.ts";
-import { collectHiddenExtensionStatusKeys, getNotificationExtensionStatuses, mergeSegmentOptions, mergeSegmentsWithCustomItems, nextPowerlineSettingWithOptions, nextPowerlineSettingWithPreset, parsePowerlineConfig } from "./powerline-config.ts";
-import { getSeparator } from "./separators.ts";
-import { renderSegment } from "./segments.ts";
-import { getGitStatus, invalidateGitStatus, invalidateGitBranch, subscribeGitUpdates } from "./git-status.ts";
-import { SessionBranchCache, SessionTokenStatsCache } from "./token-stats.ts";
-import { ansi, getFgAnsiCode } from "./colors.ts";
-import { WelcomeComponent, WelcomeHeader, discoverLoadedCounts, getRecentSessions } from "./welcome.ts";
-import { getGuidePreferences, getNewGuideFeatures, markGuideVersionSeen, resolveGuideDisplayMode, saveGuidePreferences, type GuideFeature } from "./guide.ts";
-import { createRenderScheduler } from "./render-scheduler.ts";
-import { createWelcomeDismissScheduler } from "./welcome-dismiss.ts";
-import { getEditorAutocompleteProvider, passAutocompleteProviderThroughPreviousEditor } from "./editor-composition.ts";
-import { EditorPerfProfiler, readEditorPerfOptions } from "./editor-performance.ts";
-import { CoreContextUsageCache, estimateInitialContextTokens, estimateUnknownContextUsage, resolveDisplayContextUsage, type CoreContextUsage } from "./context-usage.ts";
-import { isStaleExtensionContextError, shouldShowStartupWelcome } from "./lifecycle.ts";
-import { getDefaultColors } from "./theme.ts";
-import { registerCdCommand } from "./cd-command.ts";
-import {
-  isSupportedSuperShortcut,
-  matchesConfiguredShortcut,
-  matchesStashShortcutInput,
-  shortcutConflictKey,
-  shortcutUsesSuper,
-} from "./shortcuts.ts";
-import {
-  initVibeManager,
-  onVibeBeforeAgentStart,
-  onVibeAgentStart,
-  onVibeAgentEnd,
-  onVibeToolCall,
-  getVibeTheme,
-  setVibeTheme,
-  getVibeModel,
-  setVibeModel,
-  getVibeMode,
-  setVibeMode,
-  hasVibeFile,
-  getVibeFileCount,
-  generateVibesBatch,
-  parseVibeGenerateArgs,
-} from "./working-vibes.ts";
-import { setupTpsTracker } from "./tps.ts";
-import { readAsyncSubagentUsage } from "./session-usage.ts";
-import { PowerlineQueueStore, currentQueueContext, formatQueueDeliveryText, parseCompactQueuedPrompt } from "./queue/store.ts";
-import type { PowerlineQueueItem, QueueContext, QueueIntent, QueueSummary, QueueTarget } from "./queue/types.ts";
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Configuration
-// ═══════════════════════════════════════════════════════════════════════════
-
-let config: PowerlineConfig = {
-  preset: "default",
-  customItems: [],
-  fixedEditorPromptGlyph: "",
-  disabledSegments: [],
-  invalidDisabledSegments: [],
-  layout: null,
-  invalidLayoutSegments: [],
-  separator: null,
-  segmentOptions: {},
-  placement: "above",
-  invalidPlacement: null,
-  welcome: true,
-  stashSharpSShortcut: false,
-};
-
-const CUSTOM_COMPACTION_STATUS_KEY = "compact-policy";
-let customCompactionEnabled = false;
-
-type ShortcutBinding = string | null;
-
-export interface PowerlineShortcuts {
-  stashHistory: ShortcutBinding;
-  copyEditor: ShortcutBinding;
-  cutEditor: ShortcutBinding;
-  queueOpen: ShortcutBinding;
-  editorStart: ShortcutBinding;
-  editorEnd: ShortcutBinding;
-}
-
-type PowerlineShortcutKey = keyof PowerlineShortcuts;
-type PowerlineShortcutAction =
-  | { kind: "stashHistory" }
-  | { kind: "copyEditor" }
-  | { kind: "cutEditor" }
-  | { kind: "queueOpen" }
-  | { kind: "bashMode" };
-const STASH_HISTORY_LIMIT = 12;
-const PROJECT_PROMPT_HISTORY_LIMIT = 50;
-const STASH_PREVIEW_WIDTH = 72;
-const DEFAULT_SHORTCUTS: PowerlineShortcuts = {
-  stashHistory: "ctrl+alt+h",
-  copyEditor: "ctrl+alt+c",
-  cutEditor: "ctrl+alt+x",
-  queueOpen: "ctrl+alt+q",
-  editorStart: "super+shift+up",
-  editorEnd: "super+shift+down",
-};
-const DEFAULT_BASH_MODE_SETTINGS = {
-  toggleShortcut: "ctrl+shift+b",
-  completions: false,
-  transcriptMaxLines: 2000,
-  transcriptMaxBytes: 512 * 1024,
-} as const satisfies BashModeSettings;
-const SHORTCUT_KEYS: PowerlineShortcutKey[] = ["stashHistory", "copyEditor", "cutEditor", "queueOpen", "editorStart", "editorEnd"];
-const APP_RESERVED_SHORTCUTS = [
-  "escape",
-  "ctrl+c",
-  "ctrl+d",
-  "ctrl+z",
-  "shift+tab",
-  "ctrl+p",
-  "shift+ctrl+p",
-  "ctrl+l",
-  "ctrl+o",
-  "shift+ctrl+o",
-  "ctrl+t",
-  "ctrl+n",
-  "ctrl+g",
-  "alt+enter",
-  "alt+up",
-  "alt+down",
-  "ctrl+v",
-  "alt+v",
-  "shift+l",
-  "shift+t",
-  "ctrl+s",
-  "ctrl+r",
-  "ctrl+backspace",
-  "ctrl+a",
-  "ctrl+x",
-  "ctrl+u",
-] as const;
-const EXTRA_RESERVED_SHORTCUTS = ["alt+s"] as const;
-const SHORTCUT_MODIFIER_ORDER = ["ctrl", "alt", "super", "shift"] as const;
-const SHORTCUT_MODIFIERS = new Set<string>(SHORTCUT_MODIFIER_ORDER);
-const SHORTCUT_NAMED_KEYS = new Set([
-  "escape", "esc", "enter", "return", "tab", "space", "backspace", "delete", "insert", "clear",
-  "home", "end", "pageup", "pagedown", "up", "down", "left", "right",
-]);
-const SHORTCUT_SYMBOL_KEYS = new Set([
-  "`", "-", "=", "[", "]", "\\", ";", "'", ",", ".", "/",
-  "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "_", "|", "~", "{", "}", ":", "<", ">", "?",
-]);
-const PROMPT_HISTORY_LIMIT = 100;
-const LAYOUT_CACHE_TTL_MS = 250;
-const STREAMING_LAYOUT_CACHE_TTL_MS = 1000;
-const STATUS_RENDER_DEBOUNCE_MS = 33;
-const CONTEXT_STATUS_RENDER_MS = 250;
-const EDITOR_STATUS_DEFER_MS = 150;
-const QUEUE_SUMMARY_CACHE_TTL_MS = 250;
-const PROMPT_HISTORY_TRACKED = Symbol.for("powerlinePromptHistoryTracked");
-const PROMPT_HISTORY_STATE_KEY = Symbol.for("powerlinePromptHistoryState");
-
-interface PromptHistoryEditor {
-  addToHistory?: (text: string) => void;
-}
-
-type PromptHistoryState = { savedPromptHistory: string[] };
-type SessionAssistantUsage = AssistantMessage["usage"];
-
-function getUsageTokenTotal(usage: SessionAssistantUsage): number {
-  const totalTokens = "totalTokens" in usage && typeof usage.totalTokens === "number" ? usage.totalTokens : 0;
-  return totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
-}
-
-function hasSessionAssistantUsage(value: unknown): value is SessionAssistantUsage {
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  if (
-    typeof value.input !== "number" ||
-    typeof value.output !== "number" ||
-    typeof value.cacheRead !== "number" ||
-    typeof value.cacheWrite !== "number"
-  ) {
-    return false;
-  }
-
-  return isRecord(value.cost) && typeof value.cost.total === "number";
-}
-
-function isSessionAssistantMessage(value: unknown): value is AssistantMessage {
-  return isRecord(value)
-    && value.role === "assistant"
-    && hasSessionAssistantUsage(value.usage)
-    && (value.stopReason === undefined || typeof value.stopReason === "string");
-}
-
-function isPromptHistoryState(value: unknown): value is PromptHistoryState {
-  return isRecord(value)
-    && Array.isArray(value.savedPromptHistory)
-    && value.savedPromptHistory.every((entry) => typeof entry === "string");
-}
-
-function getPromptHistoryState(): PromptHistoryState {
-  const existing = Reflect.get(globalThis, PROMPT_HISTORY_STATE_KEY);
-  if (isPromptHistoryState(existing)) {
-    return existing;
-  }
-
-  const state: PromptHistoryState = { savedPromptHistory: [] };
-  Reflect.set(globalThis, PROMPT_HISTORY_STATE_KEY, state);
-  return state;
-}
-
-function readPromptHistory(editor: PromptHistoryEditor | null | undefined): string[] {
-  if (!editor) return [];
-  const history = Reflect.get(editor, "history");
-  if (!Array.isArray(history)) return [];
-
-  const normalized: string[] = [];
-  for (const entry of history) {
-    if (typeof entry !== "string") continue;
-    const trimmed = entry.trim();
-    if (!trimmed) continue;
-    if (normalized.length > 0 && normalized[normalized.length - 1] === trimmed) continue;
-    normalized.push(trimmed);
-    if (normalized.length >= PROMPT_HISTORY_LIMIT) break;
-  }
-
-  return normalized;
-}
-
-function snapshotPromptHistory(editor: PromptHistoryEditor | null | undefined): void {
-  const history = readPromptHistory(editor);
-  if (history.length > 0) {
-    getPromptHistoryState().savedPromptHistory = [...history];
-  }
-}
-
-function restorePromptHistory(editor: PromptHistoryEditor | null | undefined): void {
-  const { savedPromptHistory } = getPromptHistoryState();
-  if (!savedPromptHistory.length || typeof editor?.addToHistory !== "function") return;
-
-  for (let i = savedPromptHistory.length - 1; i >= 0; i--) {
-    editor.addToHistory(savedPromptHistory[i]);
-  }
-}
-
-function trackPromptHistory(editor: PromptHistoryEditor | null | undefined): void {
-  if (!editor || typeof editor.addToHistory !== "function") return;
-  if (Reflect.get(editor, PROMPT_HISTORY_TRACKED)) {
-    snapshotPromptHistory(editor);
-    return;
-  }
-
-  const originalAddToHistory = editor.addToHistory.bind(editor);
-  editor.addToHistory = (text: string) => {
-    originalAddToHistory(text);
-    snapshotPromptHistory(editor);
-  };
-  Reflect.set(editor, PROMPT_HISTORY_TRACKED, true);
-  snapshotPromptHistory(editor);
-}
-
-function getProjectSettingsPath(cwd: string): string {
-  return join(cwd, CONFIG_DIR_NAME, "settings.json");
-}
-
-function getGlobalCompactionPolicyPath(): string {
-  return join(getAgentDir(), "compaction-policy.json");
-}
-
-function getCustomCompactionExtensionPath(): string {
-  return join(getAgentDir(), "extensions", "pi-custom-compaction");
-}
-
-function mergeSettings(base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown> {
-  const merged: Record<string, unknown> = { ...base };
-
-  for (const [key, overrideValue] of Object.entries(override)) {
-    const baseValue = merged[key];
-    merged[key] = isRecord(baseValue) && isRecord(overrideValue)
-      ? mergeSettings(baseValue, overrideValue)
-      : overrideValue;
-  }
-
-  return merged;
-}
-
-function readSettingsFile(settingsPath: string): Record<string, unknown> {
-  try {
-    if (!existsSync(settingsPath)) {
-      return {};
-    }
-
-    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    if (!isRecord(parsed)) {
-      console.debug(`[powerline-footer] Ignoring non-object settings at ${settingsPath}`);
-      return {};
-    }
-
-    return parsed;
-  } catch (error) {
-    // Settings are user-edited input. Log and keep the extension running with defaults
-    // instead of crashing the UI during startup.
-    console.debug(`[powerline-footer] Failed to read settings from ${settingsPath}:`, error);
-    return {};
-  }
-}
-
-function readWritableSettingsFile(settingsPath: string): Record<string, unknown> | null {
-  if (!existsSync(settingsPath)) {
-    return {};
-  }
-
-  try {
-    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    if (!isRecord(parsed)) {
-      console.debug(`[powerline-footer] Refusing to write settings to non-object file at ${settingsPath}`);
-      return null;
-    }
-
-    return parsed;
-  } catch (error) {
-    // Do not overwrite malformed user settings with partial data. Surface the failure
-    // through the command handler so the user can fix the file intentionally.
-    console.debug(`[powerline-footer] Failed to parse settings at ${settingsPath}:`, error);
-    return null;
-  }
-}
-
-function readCompactionPolicyEnabled(configPath: string): boolean | undefined {
-  if (!existsSync(configPath)) return undefined;
-  try {
-    const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
-    if (!isRecord(parsed) || typeof parsed.enabled !== "boolean") return false;
-    return parsed.enabled;
-  } catch (error) {
-    console.debug(`[powerline-footer] Failed to read compaction policy from ${configPath}:`, error);
-    return false;
-  }
-}
-
-function detectCustomCompactionEnabled(cwd: string): boolean {
-  if (!existsSync(getCustomCompactionExtensionPath())) return false;
-
-  const projectSetting = readCompactionPolicyEnabled(join(cwd, CONFIG_DIR_NAME, "compaction-policy.json"));
-  if (projectSetting !== undefined) return projectSetting;
-
-  return readCompactionPolicyEnabled(getGlobalCompactionPolicyPath()) ?? false;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function getStashHistoryPath(): string {
-  return join(getAgentDir(), "powerline-footer", "stash-history.json");
-}
-
-function getSessionsPath(): string {
-  return join(getAgentDir(), "sessions");
-}
-
-function getProjectSessionsPath(cwd: string): string {
-  const projectKey = cwd
-    .replace(/^[/\\]+|[/\\]+$/g, "")
-    .replace(/[\\/]+/g, "-");
-
-  return join(getSessionsPath(), `--${projectKey}--`);
-}
-
-function getPromptHistoryText(content: unknown): string {
-  if (typeof content === "string") {
-    return content.replace(/\s+/g, " ").trim();
-  }
-
-  if (!Array.isArray(content)) {
-    return "";
-  }
-
-  const parts: string[] = [];
-  for (const block of content) {
-    if (!isRecord(block) || block.type !== "text" || typeof block.text !== "string") {
-      continue;
-    }
-    parts.push(block.text);
-  }
-
-  return parts.join("\n").replace(/\s+/g, " ").trim();
-}
-
-function readRecentProjectPrompts(cwd: string, limit: number): string[] {
-  const sessionsPath = getProjectSessionsPath(cwd);
-  if (!existsSync(sessionsPath)) {
-    return [];
-  }
-
-  const promptEntries: { text: string; timestamp: number }[] = [];
-  const fileNames = readdirSync(sessionsPath)
-    .filter((fileName) => fileName.endsWith(".jsonl"));
-
-  for (const fileName of fileNames) {
-    const filePath = join(sessionsPath, fileName);
-    const lines = readFileSync(filePath, "utf-8").split("\n");
-
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const line = lines[i];
-      if (!line || !line.includes('"type":"message"') || !line.includes('"role":"user"')) {
-        continue;
-      }
-
-      let entry: unknown;
-      try {
-        entry = JSON.parse(line);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to parse session file ${filePath}: ${message}`, { cause: error });
-      }
-
-      if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message) || entry.message.role !== "user") {
-        continue;
-      }
-
-      const text = getPromptHistoryText(entry.message.content);
-      if (!hasNonWhitespaceText(text)) {
-        continue;
-      }
-
-      const timestamp = typeof entry.message.timestamp === "number"
-        ? entry.message.timestamp
-        : typeof entry.timestamp === "string"
-          ? Date.parse(entry.timestamp)
-          : 0;
-
-      promptEntries.push({ text, timestamp: Number.isFinite(timestamp) ? timestamp : 0 });
-    }
-  }
-
-  promptEntries.sort((a, b) => b.timestamp - a.timestamp);
-
-  const prompts: string[] = [];
-  const seen = new Set<string>();
-  for (const entry of promptEntries) {
-    if (seen.has(entry.text)) {
-      continue;
-    }
-
-    seen.add(entry.text);
-    prompts.push(entry.text);
-    if (prompts.length >= limit) {
-      return prompts;
-    }
-  }
-
-  return prompts;
-}
-
-function normalizeStashHistoryEntries(value: unknown): string[] {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-
-  const history: string[] = [];
-  for (const entry of value) {
-    if (typeof entry !== "string") {
-      continue;
-    }
-
-    if (!hasNonWhitespaceText(entry)) {
-      continue;
-    }
-
-    if (history[history.length - 1] === entry) {
-      continue;
-    }
-
-    history.push(entry);
-    if (history.length >= STASH_HISTORY_LIMIT) {
-      break;
-    }
-  }
-
-  return history;
-}
-
-function readPersistedStashHistory(): string[] {
-  const stashHistoryPath = getStashHistoryPath();
-
-  try {
-    if (!existsSync(stashHistoryPath)) {
-      return [];
-    }
-
-    const parsed = JSON.parse(readFileSync(stashHistoryPath, "utf-8"));
-    if (!isRecord(parsed)) {
-      console.debug(`[powerline-footer] Ignoring invalid stash history at ${stashHistoryPath}`);
-      return [];
-    }
-
-    return normalizeStashHistoryEntries(parsed.history);
-  } catch (error) {
-    console.debug(`[powerline-footer] Failed to read stash history from ${stashHistoryPath}:`, error);
-    return [];
-  }
-}
-
-function persistStashHistory(history: string[]): void {
-  const stashHistoryPath = getStashHistoryPath();
-  const payload = {
-    version: 1,
-    history: history.slice(0, STASH_HISTORY_LIMIT),
-  };
-
-  try {
-    mkdirSync(dirname(stashHistoryPath), { recursive: true });
-    writeFileSync(stashHistoryPath, JSON.stringify(payload, null, 2) + "\n");
-  } catch (error) {
-    console.debug(`[powerline-footer] Failed to persist stash history to ${stashHistoryPath}:`, error);
-  }
-}
-
-function readSettings(cwd: string = process.cwd()): Record<string, unknown> {
-  return mergeSettings(readSettingsFile(getSettingsPath()), readSettingsFile(getProjectSettingsPath(cwd)));
-}
-
-function writePowerlineSetting(cwd: string, update: (existingPowerlineSetting: unknown) => unknown): boolean {
-  const globalSettingsPath = getSettingsPath();
-  const projectSettingsPath = getProjectSettingsPath(cwd);
-  const globalSettings = readWritableSettingsFile(globalSettingsPath);
-  const projectSettings = readWritableSettingsFile(projectSettingsPath);
-
-  if (globalSettings === null || projectSettings === null) {
-    return false;
-  }
-
-  const writeToProject = Object.prototype.hasOwnProperty.call(projectSettings, "powerline");
-  const settingsPath = writeToProject ? projectSettingsPath : globalSettingsPath;
-  const settings = writeToProject ? projectSettings : globalSettings;
-
-  settings.powerline = update(settings.powerline);
-
-  try {
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-    return true;
-  } catch (error) {
-    console.debug(`[powerline-footer] Failed to persist powerline setting to ${settingsPath}:`, error);
-    return false;
-  }
-}
-
-function writePowerlinePresetSetting(preset: StatusLinePreset, cwd: string = process.cwd()): boolean {
-  return writePowerlineSetting(cwd, (existingPowerlineSetting) => (
-    nextPowerlineSettingWithPreset(existingPowerlineSetting, preset)
-  ));
-}
-
-function writePowerlineOptionSetting(
-  cwd: string,
-  updates: Partial<Pick<PowerlineConfig, "welcome" | "stashSharpSShortcut" | "placement">>,
-  currentPreset: StatusLinePreset,
-): boolean {
-  return writePowerlineSetting(cwd, (existingPowerlineSetting) => (
-    nextPowerlineSettingWithOptions(existingPowerlineSetting, updates, currentPreset)
-  ));
-}
-
-const PRESET_NAMES = Object.keys(PRESETS) as StatusLinePreset[];
-
-function isValidPreset(value: unknown): value is StatusLinePreset {
-  return typeof value === "string" && Object.prototype.hasOwnProperty.call(PRESETS, value);
-}
-
-function normalizePreset(value: unknown): StatusLinePreset | null {
-  if (typeof value !== "string") {
-    return null;
-  }
-
-  const preset = value.trim().toLowerCase();
-  return isValidPreset(preset) ? preset : null;
-}
-
-function hasNonWhitespaceText(text: string): boolean {
-  return text.trim().length > 0;
-}
-
-function getCurrentEditorText(ctx: any, editor: any): string {
-  const editorText = editor?.getExpandedText?.();
-  if (typeof editorText === "string" && editorText.length > 0) return editorText;
-  return ctx.ui.getEditorText?.() ?? editorText ?? "";
-}
-
-function buildStashPreview(text: string, maxWidth: number): string {
-  const compact = text.replace(/\s+/g, " ").trim();
-  if (!compact) return "(empty)";
-  return truncateToWidth(compact, maxWidth, "…");
-}
-
-function pushStashHistory(history: string[], text: string): boolean {
-  if (!hasNonWhitespaceText(text)) return false;
-  if (history[0] === text) return false;
-
-  history.unshift(text);
-  if (history.length > STASH_HISTORY_LIMIT) {
-    history.length = STASH_HISTORY_LIMIT;
-  }
-
-  return true;
-}
-
-function normalizeShortcut(value: string): string {
-  const parts = value.trim().toLowerCase().split("+");
-  if (parts.length <= 1) return parts[0] ?? "";
-
-  const modifierRank = new Map<string, number>(SHORTCUT_MODIFIER_ORDER.map((modifier, index) => [modifier, index]));
-  const modifiers = parts.slice(0, -1).sort((a, b) => (modifierRank.get(a) ?? 99) - (modifierRank.get(b) ?? 99));
-  return [...modifiers, parts[parts.length - 1]].join("+");
-}
-
-function reservedShortcuts(): Set<string> {
-  const shortcuts = new Set<string>([
-    ...EXTRA_RESERVED_SHORTCUTS,
-    ...APP_RESERVED_SHORTCUTS,
-  ].map(normalizeShortcut));
-
-  for (const definition of Object.values(TUI_KEYBINDINGS)) {
-    const defaultKeys = definition.defaultKeys;
-    const keys = defaultKeys === undefined ? [] : Array.isArray(defaultKeys) ? defaultKeys : [defaultKeys];
-    for (const key of keys) {
-      shortcuts.add(normalizeShortcut(key));
-    }
-  }
-
-  return shortcuts;
-}
-
-function isValidShortcutKeyPart(keyPart: string): boolean {
-  const lowerKeyPart = keyPart.toLowerCase();
-
-  if (/^[a-z0-9]$/i.test(keyPart)) return true;
-  if (/^f([1-9]|1[0-2])$/i.test(keyPart)) return true;
-  if (SHORTCUT_NAMED_KEYS.has(lowerKeyPart)) return true;
-
-  return SHORTCUT_SYMBOL_KEYS.has(keyPart);
-}
-
-function parseShortcutOverride(value: unknown): string | null {
-  if (typeof value !== "string") {
-    return null;
-  }
-
-  const trimmed = value.trim();
-  if (!trimmed || /\s/.test(trimmed)) {
-    return null;
-  }
-
-  const parts = trimmed.split("+");
-  if (parts.some((part) => part.length === 0)) {
-    return null;
-  }
-
-  const modifierParts = parts.slice(0, -1).map((part) => {
-    const modifier = part.toLowerCase();
-    return modifier === "cmd" || modifier === "command" ? "super" : modifier;
-  });
-  if (new Set(modifierParts).size !== modifierParts.length) {
-    return null;
-  }
-
-  for (const modifier of modifierParts) {
-    if (!SHORTCUT_MODIFIERS.has(modifier)) {
-      return null;
-    }
-  }
-
-  const keyPart = parts[parts.length - 1];
-  if (!isValidShortcutKeyPart(keyPart)) {
-    return null;
-  }
-
-  const normalizedKey = SHORTCUT_SYMBOL_KEYS.has(keyPart) ? keyPart : keyPart.toLowerCase();
-  const normalizedShortcut = normalizeShortcut([...modifierParts, normalizedKey].join("+"));
-  if (shortcutUsesSuper(normalizedShortcut) && !isSupportedSuperShortcut(normalizedShortcut)) {
-    return null;
-  }
-
-  return normalizedShortcut;
-}
-
-function shortcutUsageKey(shortcut: string): string {
-  return shortcutConflictKey(normalizeShortcut(shortcut));
-}
-
-function parseShortcutSetting(value: unknown): ShortcutBinding | undefined {
-  if (value === null || value === undefined) return null;
-  if (typeof value === "string" && value.trim() === "") return null;
-  return parseShortcutOverride(value) ?? undefined;
-}
-
-function findShortcutReplacement(key: PowerlineShortcutKey, used: Set<string>): string | null {
-  const preferred = DEFAULT_SHORTCUTS[key];
-  if (preferred && !used.has(shortcutUsageKey(preferred))) {
-    return preferred;
-  }
-
-  for (const shortcutKey of SHORTCUT_KEYS) {
-    const candidate = DEFAULT_SHORTCUTS[shortcutKey];
-    if (candidate && !used.has(shortcutUsageKey(candidate))) {
-      return candidate;
-    }
-  }
-
-  return null;
-}
-
-function bashToggleShortcutReservation(settings: Record<string, unknown>): ShortcutBinding {
-  const raw = isRecord(settings.bashMode) ? settings.bashMode : {};
-  if (!Object.prototype.hasOwnProperty.call(raw, "toggleShortcut")) {
-    return DEFAULT_BASH_MODE_SETTINGS.toggleShortcut;
-  }
-
-  const parsed = parseShortcutSetting(raw.toggleShortcut);
-  return parsed === undefined ? DEFAULT_BASH_MODE_SETTINGS.toggleShortcut : parsed;
-}
-
-export function resolveShortcutConfig(settings: Record<string, unknown>): PowerlineShortcuts {
-  const resolved: PowerlineShortcuts = { ...DEFAULT_SHORTCUTS };
-  const shortcutSettings = settings.powerlineShortcuts;
-
-  if (isRecord(shortcutSettings)) {
-    for (const key of SHORTCUT_KEYS) {
-      if (!Object.prototype.hasOwnProperty.call(shortcutSettings, key)) {
-        continue;
-      }
-
-      const override = parseShortcutSetting(shortcutSettings[key]);
-      if (override !== undefined) {
-        resolved[key] = override;
-      }
-    }
-  }
-
-  const used = new Set(Array.from(reservedShortcuts(), shortcutUsageKey));
-  const reservedBashToggle = bashToggleShortcutReservation(settings);
-  if (reservedBashToggle) {
-    used.add(shortcutUsageKey(reservedBashToggle));
-  }
-
-  for (const key of SHORTCUT_KEYS) {
-    const configured = resolved[key];
-    if (configured === null) {
-      continue;
-    }
-
-    const configuredUsageKey = shortcutUsageKey(configured);
-
-    if (!used.has(configuredUsageKey)) {
-      used.add(configuredUsageKey);
-      continue;
-    }
-
-    const replacement = findShortcutReplacement(key, used);
-    if (!replacement) {
-      console.debug(`[powerline-footer] Shortcut conflict for ${key}: "${configured}" is already in use`);
-      continue;
-    }
-
-    console.debug(
-      `[powerline-footer] Shortcut conflict for ${key}: "${configured}" replaced with "${replacement}"`,
-    );
-
-    resolved[key] = replacement;
-    used.add(shortcutUsageKey(replacement));
-  }
-
-  return resolved;
-}
-
-export function parseBashModeSettings(settings: Record<string, unknown>, powerlineShortcuts?: PowerlineShortcuts): BashModeSettings {
-  const raw = isRecord(settings.bashMode) ? settings.bashMode : {};
-  const used = new Set(Array.from(reservedShortcuts(), shortcutUsageKey));
-  if (powerlineShortcuts) {
-    for (const shortcut of Object.values(powerlineShortcuts)) {
-      if (shortcut) {
-        used.add(shortcutUsageKey(shortcut));
-      }
-    }
-  }
-
-  const configuredToggleShortcut = Object.prototype.hasOwnProperty.call(raw, "toggleShortcut")
-    ? parseShortcutSetting(raw.toggleShortcut)
-    : undefined;
-  const fallbackToggleShortcut = used.has(shortcutUsageKey(DEFAULT_BASH_MODE_SETTINGS.toggleShortcut))
-    ? null
-    : DEFAULT_BASH_MODE_SETTINGS.toggleShortcut;
-  const toggleShortcut = configuredToggleShortcut === null
-    ? null
-    : configuredToggleShortcut
-      && !used.has(shortcutUsageKey(configuredToggleShortcut))
-      ? configuredToggleShortcut
-      : fallbackToggleShortcut;
-
-  if (configuredToggleShortcut && toggleShortcut !== configuredToggleShortcut) {
-    console.debug(
-      `[powerline-footer] Bash mode shortcut conflict: "${configuredToggleShortcut}" replaced with "${toggleShortcut ?? "disabled"}"`,
-    );
-  }
-  const completions = typeof raw.completions === "boolean"
-    ? raw.completions
-    : DEFAULT_BASH_MODE_SETTINGS.completions;
-  const transcriptMaxLines = typeof raw.transcriptMaxLines === "number" && Number.isFinite(raw.transcriptMaxLines)
-    ? Math.max(100, Math.floor(raw.transcriptMaxLines))
-    : DEFAULT_BASH_MODE_SETTINGS.transcriptMaxLines;
-  const transcriptMaxBytes = typeof raw.transcriptMaxBytes === "number" && Number.isFinite(raw.transcriptMaxBytes)
-    ? Math.max(16 * 1024, Math.floor(raw.transcriptMaxBytes))
-    : DEFAULT_BASH_MODE_SETTINGS.transcriptMaxBytes;
-
-  return {
-    toggleShortcut,
-    completions,
-    transcriptMaxLines,
-    transcriptMaxBytes,
-  };
-}
-
-const FAST_EDITOR_RENDER_LINE_THRESHOLD = 80;
-const FAST_EDITOR_RENDER_COLUMN_THRESHOLD = 1200;
-
-interface FastEditorState {
-  lines: string[];
-  cursorLine: number;
-  cursorCol: number;
-}
-
-interface FastEditorVisualLine {
-  text: string;
-  cursorCol?: number;
-}
-
-function readFastEditorState(editor: unknown): FastEditorState | null {
-  const state = Reflect.get(editor as object, "state");
-  if (!isRecord(state) || !Array.isArray(state.lines)) return null;
-  if (typeof state.cursorLine !== "number" || typeof state.cursorCol !== "number") return null;
-
-  const lines = state.lines as string[];
-  const cursorLine = Math.max(0, Math.min(lines.length - 1, Math.floor(state.cursorLine)));
-  const cursorText = lines[cursorLine] ?? "";
-  if (typeof cursorText !== "string") return null;
-  const cursorCol = Math.max(0, Math.min(cursorText.length, Math.floor(state.cursorCol)));
-  return { lines, cursorLine, cursorCol };
-}
-
-function fastChunkCount(line: string, width: number): number {
-  return Math.max(1, Math.ceil(Math.max(1, line.length) / width));
-}
-
-function fastChunk(line: string, width: number, chunkIndex: number): { text: string; startCol: number } {
-  const startCol = chunkIndex * width;
-  return { text: line.slice(startCol, startCol + width), startCol };
-}
-
-function isFastRenderableText(text: string): boolean {
-  return /^[\x20-\x7E]*$/.test(text);
-}
-
-function pushTrailingChunks(target: FastEditorVisualLine[], line: string, width: number, maxCount: number): void {
-  const count = fastChunkCount(line, width);
-  const start = Math.max(0, count - maxCount);
-  for (let index = start; index < count; index++) {
-    target.push({ text: fastChunk(line, width, index).text });
-  }
-}
-
-function collectFastEditorVisualLines(state: FastEditorState, layoutWidth: number, maxVisibleLines: number): {
-  lines: FastEditorVisualLine[];
-  hasBefore: boolean;
-  hasAfter: boolean;
-} {
-  const cursorText = state.lines[state.cursorLine] ?? "";
-  const cursorChunkIndex = Math.floor(state.cursorCol / layoutWidth);
-  const cursorChunkCount = Math.max(fastChunkCount(cursorText, layoutWidth), cursorChunkIndex + 1);
-  const firstCursorChunk = Math.max(0, cursorChunkIndex - maxVisibleLines + 1);
-
-  const visualLines: FastEditorVisualLine[] = [];
-  for (let lineIndex = state.cursorLine - 1; lineIndex >= 0 && visualLines.length < maxVisibleLines - 1; lineIndex--) {
-    const chunks: FastEditorVisualLine[] = [];
-    pushTrailingChunks(chunks, state.lines[lineIndex] ?? "", layoutWidth, maxVisibleLines - 1 - visualLines.length);
-    visualLines.unshift(...chunks);
-  }
-
-  for (let chunkIndex = firstCursorChunk; chunkIndex < cursorChunkIndex && visualLines.length < maxVisibleLines - 1; chunkIndex++) {
-    visualLines.push({ text: fastChunk(cursorText, layoutWidth, chunkIndex).text });
-  }
-
-  const cursorChunk = fastChunk(cursorText, layoutWidth, cursorChunkIndex);
-  visualLines.push({
-    text: cursorChunk.text,
-    cursorCol: state.cursorCol - cursorChunk.startCol,
-  });
-
-  for (let chunkIndex = cursorChunkIndex + 1; chunkIndex < cursorChunkCount && visualLines.length < maxVisibleLines; chunkIndex++) {
-    visualLines.push({ text: fastChunk(cursorText, layoutWidth, chunkIndex).text });
-  }
-
-  for (let lineIndex = state.cursorLine + 1; lineIndex < state.lines.length && visualLines.length < maxVisibleLines; lineIndex++) {
-    const line = state.lines[lineIndex] ?? "";
-    const count = fastChunkCount(line, layoutWidth);
-    for (let chunkIndex = 0; chunkIndex < count && visualLines.length < maxVisibleLines; chunkIndex++) {
-      visualLines.push({ text: fastChunk(line, layoutWidth, chunkIndex).text });
-    }
-  }
-
-  return {
-    lines: visualLines.slice(-maxVisibleLines),
-    hasBefore: state.cursorLine > 0 || firstCursorChunk > 0,
-    hasAfter: state.cursorLine < state.lines.length - 1 || cursorChunkIndex < cursorChunkCount - 1,
-  };
-}
-
-function renderFastCursorLine(line: string, cursorCol: number, focused: boolean): string {
-  const before = line.slice(0, cursorCol);
-  const target = line[cursorCol];
-  const marker = focused ? CURSOR_MARKER : "";
-  if (target) {
-    return `${before}${marker}\x1b[7m${target}\x1b[0m${line.slice(cursorCol + target.length)}`;
-  }
-  return `${before}${marker}\x1b[7m \x1b[0m`;
-}
-
-function padToWidth(line: string, width: number): string {
-  return `${line}${" ".repeat(Math.max(0, width - visibleWidth(line)))}`;
-}
-
-export function renderFastPowerlineEditor(
-  editor: unknown,
-  width: number,
-  options: { bashModeActive: boolean; completionsEnabled: boolean },
-): string[] | null {
-  if (width < 10 || options.completionsEnabled) return null;
-  if (Reflect.get(editor as object, "isInPaste") === true || Reflect.get(editor as object, "jumpMode") != null) return null;
-  if (Reflect.get(editor as object, "autocompleteState") != null) return null;
-
-  const isShowingAutocomplete = Reflect.get(editor as object, "isShowingAutocomplete");
-  if (typeof isShowingAutocomplete === "function" && isShowingAutocomplete.call(editor)) return null;
-
-  const state = readFastEditorState(editor);
-  if (!state) return null;
-
-  const cursorText = state.lines[state.cursorLine] ?? "";
-  if (state.lines.length < FAST_EDITOR_RENDER_LINE_THRESHOLD && cursorText.length < FAST_EDITOR_RENDER_COLUMN_THRESHOLD) {
-    return null;
-  }
-
-  const terminalRows = Reflect.get(Reflect.get(editor as object, "tui") ?? {}, "terminal")?.rows;
-  const maxVisibleLines = Math.max(5, Math.floor((typeof terminalRows === "number" ? terminalRows : 24) * 0.3));
-  const innerWidth = Math.max(1, width - 3);
-  const layoutWidth = Math.max(1, innerWidth - 1);
-  const viewport = collectFastEditorVisualLines(state, layoutWidth, maxVisibleLines);
-  if (viewport.lines.some((line) => !isFastRenderableText(line.text))) return null;
-
-  Reflect.set(editor as object, "lastWidth", layoutWidth);
-
-  const bc = (s: string) =>
-    typeof (editor as { borderColor?: unknown }).borderColor === "function"
-      ? (editor as { borderColor: (s: string) => string }).borderColor(s)
-      : `${getFgAnsiCode("sep")}${s}${ansi.reset}`;
-  const border = (marker: "↑" | "↓" | "─") => {
-    const text = marker === "─" ? "─".repeat(width - 2) : `${marker}${"─".repeat(Math.max(0, width - 3))}`;
-    return ` ${bc(text)}`;
-  };
-  const promptGlyph = options.bashModeActive ? "$" : config.fixedEditorPromptGlyph;
-  const prompt = promptGlyph ? `${ansi.getFgAnsi(200, 200, 200)}${promptGlyph}${ansi.reset}` : "";
-  const promptPrefix = prompt ? ` ${prompt} ` : " ";
-  const contPrefix = "   ";
-
-  const lines = [border(viewport.hasBefore ? "↑" : "─")];
-  for (let index = 0; index < viewport.lines.length; index++) {
-    const visual = viewport.lines[index]!;
-    const content = visual.cursorCol === undefined
-      ? visual.text
-      : renderFastCursorLine(visual.text, visual.cursorCol, Reflect.get(editor as object, "focused") === true);
-    lines.push(`${index === 0 ? promptPrefix : contPrefix}${padToWidth(content, innerWidth)}`);
-  }
-  lines.push(border(viewport.hasAfter ? "↓" : "─"));
-  return lines;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Status Line Builder
-// ═══════════════════════════════════════════════════════════════════════════
-
-/** Render a single segment and return its content with width */
-function renderSegmentWithWidth(
-  segId: StatusLineSegmentId,
-  ctx: SegmentContext
-): { content: string; width: number; visible: boolean } {
-  const rendered = renderSegment(segId, ctx);
-  if (!rendered.visible || !rendered.content) {
-    return { content: "", width: 0, visible: false };
-  }
-  return { content: rendered.content, width: visibleWidth(rendered.content), visible: true };
-}
-
-/** Build content string from pre-rendered parts */
-function buildContentFromParts(
-  parts: string[],
-  separatorStyle: StatusLineSeparatorStyle,
-): string {
-  if (parts.length === 0) return "";
-  const separatorDef = getSeparator(separatorStyle);
-  const sepAnsi = getFgAnsiCode("sep");
-  const sep = separatorDef.left;
-  return " " + parts.join(`${sepAnsi}${sep}${ansi.reset}`) + ansi.reset + " ";
-}
-
-/**
- * Responsive segment layout - fits segments into top bar, overflows to secondary row.
- * When terminal is wide enough, secondary segments move up to top bar.
- * When narrow, top bar segments overflow down to secondary row.
- */
-function computeResponsiveLayout(
-  ctx: SegmentContext,
-  presetDef: ReturnType<typeof getPreset>,
-  availableWidth: number
-): { topContent: string; secondaryContent: string } {
-  const separatorStyle = config.separator ?? presetDef.separator;
-  const separatorDef = getSeparator(separatorStyle);
-  const sepWidth = visibleWidth(separatorDef.left) + 2; // separator + spaces around it
-
-  // Get all segments: primary first, then secondary
-  const mergedSegments = mergeSegmentsWithCustomItems(presetDef, config.customItems, {
-    layout: config.layout,
-    disabledSegments: config.disabledSegments,
-  });
-  const primaryIds = [...mergedSegments.leftSegments, ...mergedSegments.rightSegments];
-  const secondaryIds = mergedSegments.secondarySegments;
-  const allSegmentIds = [...primaryIds, ...secondaryIds];
-
-  // Render all segments and get their widths
-  const renderedSegments: { content: string; width: number }[] = [];
-  for (const segId of allSegmentIds) {
-    const { content, width, visible } = renderSegmentWithWidth(segId, ctx);
-    if (visible) {
-      renderedSegments.push({ content, width });
-    }
-  }
-
-  if (renderedSegments.length === 0) {
-    return { topContent: "", secondaryContent: "" };
-  }
-
-  // Calculate how many segments fit in top bar
-  // Account for: leading space (1) + trailing space (1) = 2 chars overhead
-  const baseOverhead = 2;
-  let currentWidth = baseOverhead;
-  let topSegments: string[] = [];
-  let overflowSegments: { content: string; width: number }[] = [];
-  let overflow = false;
-
-  for (const seg of renderedSegments) {
-    const neededWidth = seg.width + (topSegments.length > 0 ? sepWidth : 0);
-
-    if (!overflow && currentWidth + neededWidth <= availableWidth) {
-      topSegments.push(seg.content);
-      currentWidth += neededWidth;
-    } else {
-      overflow = true;
-      overflowSegments.push(seg);
-    }
-  }
-
-  // Fit overflow segments into secondary row (same width constraint)
-  // Stop at first non-fitting segment to preserve ordering
-  let secondaryWidth = baseOverhead;
-  let secondarySegments: string[] = [];
-
-  for (const seg of overflowSegments) {
-    const neededWidth = seg.width + (secondarySegments.length > 0 ? sepWidth : 0);
-    if (secondaryWidth + neededWidth <= availableWidth) {
-      secondarySegments.push(seg.content);
-      secondaryWidth += neededWidth;
-    } else {
-      break;
-    }
-  }
-
-  return {
-    topContent: buildContentFromParts(topSegments, separatorStyle),
-    secondaryContent: buildContentFromParts(secondarySegments, separatorStyle),
-  };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Extension
-// ═══════════════════════════════════════════════════════════════════════════
-
-function warnInvalidSegmentSettings(ctx: any): void {
-  if (config.invalidDisabledSegments.length > 0) {
-    const invalid = config.invalidDisabledSegments.map((id) => JSON.stringify(id)).join(", ");
-    const message = `Ignoring unknown powerline disabled segment${config.invalidDisabledSegments.length === 1 ? "" : "s"}: ${invalid}`;
-    console.warn(`[powerline-footer] ${message}`);
-    if (ctx.hasUI) ctx.ui.notify(message, "warning");
-  }
-
-  if (config.invalidLayoutSegments.length > 0) {
-    const invalid = config.invalidLayoutSegments.map((id) => JSON.stringify(id)).join(", ");
-    const message = `Ignoring unknown powerline layout segment${config.invalidLayoutSegments.length === 1 ? "" : "s"}: ${invalid}`;
-    console.warn(`[powerline-footer] ${message}`);
-    if (ctx.hasUI) ctx.ui.notify(message, "warning");
-  }
-
-  if (config.invalidPlacement !== null) {
-    const message = `Ignoring invalid powerline placement: ${JSON.stringify(config.invalidPlacement)}`;
-    console.warn(`[powerline-footer] ${message}`);
-    if (ctx.hasUI) ctx.ui.notify(message, "warning");
-  }
-}
-
-export default function powerlineFooter(pi: ExtensionAPI) {
-  const editorPerf = new EditorPerfProfiler(readEditorPerfOptions());
-  const startupSettings = readSettings();
-  config = parsePowerlineConfig(startupSettings.powerline, PRESET_NAMES);
-  let resolvedShortcuts = resolveShortcutConfig(startupSettings);
-  let bashModeSettings = parseBashModeSettings(startupSettings, resolvedShortcuts);
-
-  let enabled = true;
-  let sessionStartTime = Date.now();
-  let sessionGeneration = 0;
-  let currentCtx: any = null;
-  let footerDataRef: ReadonlyFooterDataProvider | null = null;
-  let getThinkingLevelFn: (() => string) | null = null;
-  let currentThinkingLevel: string | null = null;
-  let liveAssistantUsage: SessionAssistantUsage | null = null;
-  const completedAsyncSubagentUsage = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number }>();
-  let approximateContextUsage: CoreContextUsage | null = null;
-  let isStreaming = false;
-  let tuiRef: any = null;
-  let restoreFooterStatusRepaintHook: (() => void) | null = null;
-  let stashShortcutInputUnsubscribe: (() => void) | null = null;
-  let dismissWelcomeOverlay: (() => void) | null = null;
-  let guideOverlayBlocking = false;
-  let welcomeHeaderActive = false;
-  let welcomeOverlayShouldDismiss = false;
-  let lastUserPrompt = "";
-  let showLastPrompt = true;
-  let lastPromptRenderCache: {
-    source: string;
-    compact: string;
-    width: number;
-    color: string;
-    lines: string[];
-  } | null = null;
-  let stashedEditorText: string | null = null;
-  let stashedPromptHistory: string[] = readPersistedStashHistory();
-  let currentEditor: any = null;
-  let bashModeActive = false;
-  let bashTranscript = new BashTranscriptStore(bashModeSettings);
-  let bashCompletionEngine = new BashCompletionEngine();
-  let shellSession: ManagedShellSession | null = null;
-  const queueStore = new PowerlineQueueStore();
-  let queueSummaryCache: {
-    cwd: string;
-    sessionId?: string;
-    compacting: boolean;
-    expiresAt: number;
-    summary: QueueSummary;
-  } | null = null;
-  let powerlineCompacting = false;
-  let deliverAfterRetrySettles = false;
-  let queueDeliveryTimer: ReturnType<typeof setTimeout> | null = null;
-
-  // Cache for the top and secondary powerline widgets.
-  let lastLayoutWidth = 0;
-  let lastLayoutResult: { topContent: string; secondaryContent: string } | null = null;
-  let lastLayoutTimestamp = 0;
-  let layoutDirty = true;
-  let forceNextLayoutRecompute = false;
-  let lastEditorInputAt = 0;
-  let lastLayoutSessionName: string | undefined;
-
-  // Cache for token counting: avoid re-scanning the full session event list
-  // on every render (250ms-1s cadence). Revalidates the trailing event's
-  // stats signature so in-place streaming updates are not served stale.
-  const sessionBranchCache = new SessionBranchCache();
-  const tokenStatsCache = new SessionTokenStatsCache();
-  const coreContextUsageCache = new CoreContextUsageCache();
-
-  const getShellPath = () => process.env.SHELL || "/bin/sh";
-  const getShellCwd = () => shellSession?.state.cwd ?? currentCtx?.cwd ?? process.cwd();
-
-  const statusRenderScheduler = createRenderScheduler(() => {
-    const msSinceInput = Date.now() - lastEditorInputAt;
-    if (layoutDirty && !forceNextLayoutRecompute && msSinceInput < EDITOR_STATUS_DEFER_MS) {
-      statusRenderScheduler.schedule(Math.max(0, EDITOR_STATUS_DEFER_MS - msSinceInput));
-      return;
-    }
-
-    tuiRef?.requestRender();
-  }, STATUS_RENDER_DEBOUNCE_MS);
-
-  const welcomeDismissScheduler = createWelcomeDismissScheduler({
-    dismiss: (ctx: unknown) => dismissWelcome(ctx),
-    getGeneration: () => sessionGeneration,
-    isEnabled: () => enabled,
-  });
-
-  const resetLayoutCache = () => {
-    lastLayoutResult = null;
-    lastLayoutSessionName = undefined;
-    layoutDirty = true;
-    sessionBranchCache.reset();
-    tokenStatsCache.reset();
-    coreContextUsageCache.reset();
-  };
-
-  const requestStatusRender = (delayMs?: number) => {
-    layoutDirty = true;
-    statusRenderScheduler.schedule(delayMs);
-  };
-
-  const requestImmediateStatusRender = (options: { deferDuringTyping?: boolean } = {}) => {
-    layoutDirty = true;
-    if (options.deferDuringTyping !== false && Date.now() - lastEditorInputAt < EDITOR_STATUS_DEFER_MS) {
-      statusRenderScheduler.schedule();
-      return;
-    }
-
-    forceNextLayoutRecompute = true;
-    statusRenderScheduler.cancel();
-    statusRenderScheduler.schedule(0);
-  };
-
-  const installFooterStatusRepaintHook = (footerData: ReadonlyFooterDataProvider) => {
-    restoreFooterStatusRepaintHook?.();
-    restoreFooterStatusRepaintHook = null;
-
-    const writableFooterData = footerData as ReadonlyFooterDataProvider & {
-      setExtensionStatus?: (key: string, text: string | undefined) => void;
-      clearExtensionStatuses?: () => void;
-    };
-    if (typeof writableFooterData.setExtensionStatus !== "function") return;
-
-    const originalSetExtensionStatus = writableFooterData.setExtensionStatus;
-    const originalClearExtensionStatuses = writableFooterData.clearExtensionStatuses;
-    const setExtensionStatusAndRepaint = function setExtensionStatusAndRepaint(this: unknown, key: string, text: string | undefined) {
-      originalSetExtensionStatus.call(this, key, text);
-      requestImmediateStatusRender();
-    };
-    writableFooterData.setExtensionStatus = setExtensionStatusAndRepaint;
-
-    let clearExtensionStatusesAndRepaint: (() => void) | null = null;
-    if (typeof originalClearExtensionStatuses === "function") {
-      clearExtensionStatusesAndRepaint = function clearExtensionStatusesAndRepaint(this: unknown) {
-        originalClearExtensionStatuses.call(this);
-        requestImmediateStatusRender();
-      };
-      writableFooterData.clearExtensionStatuses = clearExtensionStatusesAndRepaint;
-    }
-
-    restoreFooterStatusRepaintHook = () => {
-      if (writableFooterData.setExtensionStatus === setExtensionStatusAndRepaint) {
-        writableFooterData.setExtensionStatus = originalSetExtensionStatus;
-      }
-      if (clearExtensionStatusesAndRepaint && writableFooterData.clearExtensionStatuses === clearExtensionStatusesAndRepaint) {
-        writableFooterData.clearExtensionStatuses = originalClearExtensionStatuses;
-      }
-    };
-  };
-
-  const getShellHistoryEntries = (prefix: string): string[] => {
-    const project = matchHistoryEntries(
-      readProjectHistory(currentCtx?.cwd ?? process.cwd()).map((entry) => entry.command),
-      prefix,
-      50,
-    );
-    const global = matchHistoryEntries(readGlobalShellHistory(getShellPath()), prefix, 50);
-    return [...new Set([...project, ...global])];
-  };
-
-  const ensureShellSession = async (): Promise<ManagedShellSession> => {
-    if (!shellSession) {
-      shellSession = new ManagedShellSession(
-        getShellPath(),
-        currentCtx?.cwd ?? process.cwd(),
-        bashTranscript,
-        requestStatusRender,
-        (command, cwd) => appendProjectHistory(currentCtx?.cwd ?? process.cwd(), command, cwd),
-      );
-    }
-    await shellSession.ensureReady();
-    return shellSession;
-  };
-
-  const runShellCommand = async (command: string, ctx: any): Promise<void> => {
-    try {
-      const session = await ensureShellSession();
-      await session.runCommand(command);
-      requestStatusRender();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      ctx.ui.notify(`Failed to run shell command: ${message}`, "error");
-    }
-  };
-
-  const setBashModeActive = async (value: boolean, ctx: any): Promise<void> => {
-    if (value === bashModeActive) return;
-    if (!value && shellSession?.state.running) {
-      ctx.ui.notify("Wait for the current shell command to finish before leaving bash mode", "warning");
-      return;
-    }
-
-    if (value) {
-      try {
-        const session = await ensureShellSession();
-        bashModeActive = true;
-        currentEditor?.dismissBashModeUi?.();
-        currentEditor?.refreshGhostSuggestion?.();
-        requestStatusRender();
-        ctx.ui.notify(`Bash mode enabled (${session.state.shellName})`, "info");
-      } catch (error) {
-        shellSession?.dispose();
-        shellSession = null;
-        bashModeActive = false;
-        requestStatusRender();
-        const message = error instanceof Error ? error.message : String(error);
-        ctx.ui.notify(`Failed to start shell session: ${message}`, "error");
-      }
-      return;
-    }
-
-    bashModeActive = value;
-    currentEditor?.dismissBashModeUi?.();
-    requestStatusRender();
-    ctx.ui.notify("Bash mode disabled", "info");
-  };
-
-  function overlaySelectListTheme(theme: Theme) {
-    return {
-      selectedPrefix: (text: string) => theme.fg("accent", text),
-      selectedText: (text: string) => theme.fg("accent", text),
-      description: (text: string) => theme.fg("muted", text),
-      scrollInfo: (text: string) => theme.fg("dim", text),
-      noMatch: (text: string) => theme.fg("warning", text),
-    };
-  }
-
-  async function showSelectOverlay(
-    ctx: any,
-    title: string,
-    hint: string,
-    items: SelectItem[],
-    maxVisible: number,
-  ): Promise<SelectItem | null> {
-    return ctx.ui.custom(
-      (tui: any, theme: Theme, _keybindings: any, done: (result: SelectItem | null) => void) => {
-        const selectList = new SelectList(items, maxVisible, overlaySelectListTheme(theme));
-        const border = (text: string) => theme.fg("dim", text);
-        const wrapRow = (text: string, innerWidth: number): string => {
-          return `${border("│")}${truncateToWidth(text, innerWidth, "…", true)}${border("│")}`;
-        };
-
-        selectList.onSelect = (item) => done(item);
-        selectList.onCancel = () => done(null);
-
-        return {
-          render: (width: number) => {
-            const innerWidth = Math.max(1, width - 2);
-            const lines: string[] = [];
-
-            lines.push(border(`╭${"─".repeat(innerWidth)}╮`));
-            lines.push(wrapRow(theme.fg("accent", theme.bold(title)), innerWidth));
-            lines.push(border(`├${"─".repeat(innerWidth)}┤`));
-
-            for (const line of selectList.render(innerWidth)) {
-              lines.push(wrapRow(line, innerWidth));
-            }
-
-            lines.push(border(`├${"─".repeat(innerWidth)}┤`));
-            lines.push(wrapRow(theme.fg("dim", hint), innerWidth));
-            lines.push(border(`╰${"─".repeat(innerWidth)}╯`));
-
-            return lines;
-          },
-          invalidate: () => selectList.invalidate(),
-          handleInput: (data: string) => {
-            selectList.handleInput(data);
-            tui.requestRender();
-          },
-        };
-      },
-      {
-        overlay: true,
-        overlayOptions: () => ({
-          verticalAlign: "center",
-          horizontalAlign: "center",
-        }),
-      },
-    );
-  }
-
-  function getQueueSessionId(ctx: any): string | undefined {
-    const sessionId = ctx.sessionManager?.getSessionId?.();
-    return typeof sessionId === "string" && sessionId.trim() ? sessionId : undefined;
-  }
-
-  function getQueueContext(ctx: any): QueueContext {
-    return currentQueueContext(ctx.cwd ?? process.cwd(), getQueueSessionId(ctx));
-  }
-
-  function getQueueSummary(ctx: any): QueueSummary {
-    const context = getQueueContext(ctx);
-    const now = Date.now();
-    if (
-      queueSummaryCache
-      && queueSummaryCache.cwd === context.cwd
-      && queueSummaryCache.sessionId === context.sessionId
-      && queueSummaryCache.compacting === powerlineCompacting
-      && now < queueSummaryCache.expiresAt
-    ) {
-      return queueSummaryCache.summary;
-    }
-
-    const summary = queueStore.summarize(context, powerlineCompacting);
-    queueSummaryCache = {
-      cwd: context.cwd,
-      ...(context.sessionId ? { sessionId: context.sessionId } : {}),
-      compacting: powerlineCompacting,
-      expiresAt: now + QUEUE_SUMMARY_CACHE_TTL_MS,
-      summary,
-    };
-    return summary;
-  }
-
-  function requestQueueRender(): void {
-    queueSummaryCache = null;
-    requestImmediateStatusRender({ deferDuringTyping: false });
-  }
-
-  function queueItemLabel(item: PowerlineQueueItem): string {
-    const status = item.status === "queued" ? item.intent : `${item.intent}/${item.status}`;
-    return `${item.id} ${status} ${buildStashPreview(item.text, 56)}`;
-  }
-
-  function queueItemDescription(item: PowerlineQueueItem): string {
-    if (item.target.kind === "global") return "global";
-    if (item.target.kind === "current-session") return "current session";
-    return item.target.alias ? `@${item.target.alias}` : item.target.cwd;
-  }
-
-  function captureQueueItem(ctx: any, text: string, intent: QueueIntent, target: QueueTarget): PowerlineQueueItem {
-    const item = queueStore.add({
-      text,
-      intent,
-      target,
-      source: getQueueContext(ctx),
-    });
-    requestQueueRender();
-    return item;
-  }
-
-  function capturePostCompactPrompt(ctx: any, text: string): PowerlineQueueItem | null {
-    const trimmed = text.trim();
-    if (!trimmed) return null;
-
-    const item = captureQueueItem(ctx, trimmed, "post-compact", { kind: "current-session" });
-    ctx.ui.notify(`Queued for after compaction (${item.id})`, "info");
-    return item;
-  }
-
-  function deliveryModeForItem(ctx: any, item: PowerlineQueueItem): "steer" | "followUp" | undefined {
-    const idle = typeof ctx.isIdle === "function" ? ctx.isIdle() : true;
-    if (idle) return undefined;
-    return item.intent === "steer" ? "steer" : "followUp";
-  }
-
-  function deliverQueueItem(ctx: any, item: PowerlineQueueItem): boolean {
-    if (powerlineCompacting) {
-      queueStore.update(item.id, { status: "queued" });
-      requestQueueRender();
-      return false;
-    }
-
-    queueStore.update(item.id, { status: "delivering", error: undefined });
-    requestQueueRender();
-
-    let sent = false;
-    try {
-      const deliverAs = deliveryModeForItem(ctx, item);
-      const deliveryText = formatQueueDeliveryText(item);
-      if (deliverAs) {
-        pi.sendUserMessage(deliveryText, { deliverAs });
-      } else {
-        pi.sendUserMessage(deliveryText);
-      }
-      sent = true;
-      queueStore.update(item.id, { status: "sent", error: undefined });
-      try {
-        ctx.ui.notify(`Sent queued item ${item.id}`, "info");
-      } catch (error) {
-        if (!isStaleExtensionContextError(error)) throw error;
-        currentCtx = null;
-      }
-      requestQueueRender();
-      return true;
-    } catch (error) {
-      if (isStaleExtensionContextError(error)) {
-        if (!sent) queueStore.update(item.id, { status: "queued", error: undefined });
-        currentCtx = null;
-        throw error;
-      }
-      const message = error instanceof Error ? error.message : String(error);
-      queueStore.update(item.id, { status: "failed", error: message });
-      ctx.ui.notify(`Failed to send ${item.id}: ${message}`, "error");
-      requestQueueRender();
-      return false;
-    }
-  }
-
-  function schedulePostCompactionDelivery(ctx: any): void {
-    if (queueDeliveryTimer) clearTimeout(queueDeliveryTimer);
-    const queueContext = getQueueContext(ctx);
-    const scheduledGeneration = sessionGeneration;
-    queueDeliveryTimer = setTimeout(() => {
-      queueDeliveryTimer = null;
-      if (scheduledGeneration !== sessionGeneration) return;
-      try {
-        const item = queueStore.queuedDeliveryItems(queueContext, "post-compact")[0];
-        if (item) deliverQueueItem(ctx, item);
-      } catch (error) {
-        if (!isStaleExtensionContextError(error)) throw error;
-        currentCtx = null;
-      }
-    }, 50);
-  }
-
-  function blockPostCompactionQueue(ctx: any, errorMessage: string): void {
-    const items = queueStore.queuedDeliveryItems(getQueueContext(ctx), "post-compact");
-    for (const item of items) {
-      queueStore.update(item.id, { status: "blocked", error: errorMessage });
-    }
-    if (items.length > 0) {
-      ctx.ui.notify(`Kept ${items.length} post-compaction item${items.length === 1 ? "" : "s"} blocked`, "warning");
-      requestQueueRender();
-    }
-  }
-
-  function finishFailedCompaction(ctx: any, errorMessage: string): void {
-    powerlineCompacting = false;
-    deliverAfterRetrySettles = false;
-    blockPostCompactionQueue(ctx, errorMessage);
-    requestQueueRender();
-  }
-
-  async function chooseQueueAction(ctx: any, item: PowerlineQueueItem): Promise<void> {
-    const actions: SelectItem[] = [
-      { value: "send", label: "Send to current session", description: "Deliver as prompt/follow-up" },
-      { value: "edit", label: "Edit in prompt", description: "Move text into the editor" },
-      { value: "retry", label: "Retry", description: "Mark queued and deliver" },
-      { value: "clear", label: "Clear", description: "Mark item done" },
-      { value: "cancel", label: "Cancel" },
-    ];
-    const selected = await showSelectOverlay(ctx, `Queue item ${item.id}`, buildStashPreview(item.text, 72), actions, actions.length);
-    if (!selected || selected.value === "cancel") return;
-
-    if (selected.value === "send") {
-      deliverQueueItem(ctx, item);
-      return;
-    }
-
-    if (selected.value === "retry") {
-      const updated = queueStore.update(item.id, { status: "queued", error: undefined });
-      if (updated) deliverQueueItem(ctx, updated);
-      return;
-    }
-
-    if (selected.value === "edit") {
-      ctx.ui.setEditorText(item.text);
-      queueStore.clear(item.id);
-      requestQueueRender();
-      return;
-    }
-
-    if (selected.value === "clear") {
-      queueStore.clear(item.id);
-      ctx.ui.notify(`Cleared ${item.id}`, "info");
-      requestQueueRender();
-    }
-  }
-
-  async function openQueuePicker(ctx: any): Promise<void> {
-    const active = queueStore.activeItems(getQueueContext(ctx));
-    if (active.length === 0) {
-      ctx.ui.notify("No queued items", "info");
-      return;
-    }
-
-    const items: SelectItem[] = active.map((item) => ({
-      value: item.id,
-      label: queueItemLabel(item),
-      description: queueItemDescription(item),
-    }));
-    const selected = await showSelectOverlay(
-      ctx,
-      "Powerline queue",
-      "↑↓ navigate • enter manage • esc cancel",
-      items,
-      Math.min(active.length, 12),
-    );
-    if (!selected) return;
-
-    const item = active.find((candidate) => candidate.id === selected.value);
-    if (item) await chooseQueueAction(ctx, item);
-  }
-
-  function resolveCommandTarget(ctx: any, spec: string): QueueTarget {
-    const normalized = spec.trim().replace(/^@/, "");
-    if (normalized === "current") return { kind: "current-session" };
-    if (normalized === "global") return { kind: "global" };
-
-    const cwd = queueStore.resolveAlias(normalized);
-    if (!cwd) throw new Error(`Unknown project alias @${normalized}. Use /queue alias ${normalized} <path> first.`);
-    return { kind: "project", cwd, alias: normalized };
-  }
-
-  function sendOrRetryQueueItem(ctx: any, idPrefix: string): void {
-    const item = queueStore.get(idPrefix);
-    if (!item) {
-      ctx.ui.notify(`No unique queue item matches ${idPrefix}`, "warning");
-      return;
-    }
-    const updated = queueStore.update(item.id, { status: "queued", error: undefined });
-    if (updated) deliverQueueItem(ctx, updated);
-  }
-
-  // Track session start
-  setupTpsTracker(pi);
-
-  pi.on("session_start", async (event, ctx) => {
-    shellSession?.dispose();
-    shellSession = null;
-    sessionGeneration++;
-    sessionStartTime = Date.now();
-    currentCtx = ctx;
-    customCompactionEnabled = detectCustomCompactionEnabled(ctx.cwd);
-    lastUserPrompt = "";
-    isStreaming = false;
-    liveAssistantUsage = null;
-    completedAsyncSubagentUsage.clear();
-    approximateContextUsage = event.reason === "reload" ? estimateUnknownContextUsage(ctx) : null;
-    powerlineCompacting = false;
-    deliverAfterRetrySettles = false;
-    stashedEditorText = null;
-
-    const settings = readSettings(ctx.cwd);
-    const guidePreferences = getGuidePreferences(settings);
-    const guideDisplayMode = resolveGuideDisplayMode({
-      reason: event.reason,
-      hasUI: ctx.hasUI,
-      guideMode: guidePreferences.mode,
-    });
-    const newGuideFeatures = getNewGuideFeatures(guidePreferences.lastSeenVersion, VERSION);
-    resolvedShortcuts = resolveShortcutConfig(settings);
-    bashModeSettings = parseBashModeSettings(settings, resolvedShortcuts);
-    showLastPrompt = settings.showLastPrompt !== false;
-    config = parsePowerlineConfig(settings.powerline, PRESET_NAMES);
-    warnInvalidSegmentSettings(ctx);
-    stashedPromptHistory = readPersistedStashHistory();
-    bashModeActive = false;
-    bashTranscript = new BashTranscriptStore(bashModeSettings);
-    bashCompletionEngine = new BashCompletionEngine();
-
-    getThinkingLevelFn = () => ctx.thinkingLevel ?? "off";
-    currentThinkingLevel = getThinkingLevelFn();
-
-    if (ctx.hasUI) {
-      ctx.ui.setStatus("stash", undefined);
-    }
-
-    // Initialize vibe manager (needs modelRegistry from ctx)
-    initVibeManager(ctx);
-
-    if (enabled && ctx.hasUI) {
-      setupCustomEditor(ctx);
-      if (guideDisplayMode === "full") {
-        setupWelcomeOverlay(ctx, newGuideFeatures);
-      } else if (guideDisplayMode === "compact") {
-        setupWelcomeHeader(ctx, newGuideFeatures);
-      } else if (shouldShowStartupWelcome(event.reason, config.welcome)) {
-        if (settings.quietStartup === true) {
-          setupWelcomeHeader(ctx, newGuideFeatures);
-        } else {
-          setupWelcomeOverlay(ctx, newGuideFeatures);
-        }
-      } else {
-        dismissWelcome(ctx);
-      }
-    }
-
-  });
-
-  pi.on("session_shutdown", async (_event, ctx) => {
-    sessionGeneration++;
-    completedAsyncSubagentUsage.clear();
-    dismissWelcomeOverlay?.();
-    dismissWelcomeOverlay = null;
-    guideOverlayBlocking = false;
-    welcomeHeaderActive = false;
-    welcomeOverlayShouldDismiss = false;
-    statusRenderScheduler.cancel();
-    restoreFooterStatusRepaintHook?.();
-    restoreFooterStatusRepaintHook = null;
-    stashShortcutInputUnsubscribe?.();
-    stashShortcutInputUnsubscribe = null;
-    shellSession?.dispose();
-    shellSession = null;
-    if (queueDeliveryTimer) {
-      clearTimeout(queueDeliveryTimer);
-      queueDeliveryTimer = null;
-    }
-    powerlineCompacting = false;
-    deliverAfterRetrySettles = false;
-    bashModeActive = false;
-    currentCtx = null;
-    footerDataRef = null;
-    getThinkingLevelFn = null;
-    currentThinkingLevel = null;
-    liveAssistantUsage = null;
-    tuiRef = null;
-    currentEditor = null;
-    resetLayoutCache();
-  });
-
-  pi.events.on("subagent:async-complete", (event) => {
-    const completed = readAsyncSubagentUsage(event);
-    const sessionId = currentCtx?.sessionManager?.getSessionId?.();
-    if (!completed || !sessionId || completed.sessionId !== sessionId) return;
-
-    completedAsyncSubagentUsage.set(completed.runId, completed.usage);
-    layoutDirty = true;
-    requestImmediateStatusRender({ deferDuringTyping: false });
-  });
-
-  // Check if a bash command might change git branch
-  const mightChangeGitBranch = (cmd: string): boolean => {
-    const gitBranchPatterns = [
-      /\bgit\s+(checkout|switch|branch\s+-[dDmM]|merge|rebase|pull|reset|worktree)/,
-      /\bgit\s+stash\s+(pop|apply)/,
-    ];
-    return gitBranchPatterns.some(p => p.test(cmd));
-  };
-
-  // Invalidate git status on file changes, trigger re-render on potential branch changes
-  pi.on("tool_result", async (event, ctx) => {
-    if (event.toolName === "subagent") {
-      currentCtx = ctx;
-      layoutDirty = true;
-      requestImmediateStatusRender({ deferDuringTyping: false });
-    }
-    if (event.toolName === "write" || event.toolName === "edit") {
-      invalidateGitStatus();
-      requestStatusRender();
-    }
-    // Check for bash commands that might change git branch
-    if (event.toolName === "bash" && event.input?.command) {
-      const cmd = String(event.input.command);
-      if (mightChangeGitBranch(cmd)) {
-        // The command has completed, so start refreshing immediately.
-        invalidateGitStatus();
-        invalidateGitBranch();
-        requestStatusRender();
-      }
-    }
-  });
-
-  // Also catch user escape commands (! prefix)
-  // Note: This fires BEFORE execution, so we use a longer delay and multiple re-renders
-  // to ensure we catch the update after the command completes.
-  pi.on("user_bash", async (event) => {
-    if (mightChangeGitBranch(event.command)) {
-      // Invalidate immediately so next render fetches fresh data
-      invalidateGitStatus();
-      invalidateGitBranch();
-      // Multiple staggered re-renders to catch fast and slow commands
-      setTimeout(() => requestStatusRender(), 100);
-      setTimeout(() => requestStatusRender(), 300);
-      setTimeout(() => requestStatusRender(), 500);
-    }
-  });
-
-  pi.on("model_select", async (_event, ctx) => {
-    currentCtx = ctx;
-    coreContextUsageCache.reset();
-    requestStatusRender();
-  });
-
-  pi.on("thinking_level_select", async (event, ctx) => {
-    currentCtx = ctx;
-    currentThinkingLevel = getThinkingLevelFn?.() ?? (typeof event.level === "string" ? event.level : null);
-    requestImmediateStatusRender({ deferDuringTyping: false });
-  });
-
-  pi.on("session_tree", async (_event, ctx) => {
-    currentCtx = ctx;
-    currentThinkingLevel = null;
-    liveAssistantUsage = null;
-    requestImmediateStatusRender({ deferDuringTyping: false });
-  });
-
-  // Generate themed working message before agent starts (has access to user's prompt)
-  pi.on("before_agent_start", async (event, ctx) => {
-    lastUserPrompt = event.prompt;
-    if (ctx.hasUI) {
-      onVibeBeforeAgentStart(event.prompt, ctx.ui.setWorkingMessage);
-    }
-  });
-
-  // Track streaming state (footer only shows status during streaming).
-  // A visible guide remains blocking until its own key handler dismisses it.
-  pi.on("agent_start", async (_event, ctx) => {
-    isStreaming = true;
-    liveAssistantUsage = null;
-    onVibeAgentStart();
-    currentCtx = ctx;
-  });
-
-  pi.on("message_update", async (event, ctx) => {
-    if (isSessionAssistantMessage(event.message)
-      && event.message.stopReason !== "error"
-      && event.message.stopReason !== "aborted"
-      && getUsageTokenTotal(event.message.usage) > 0) {
-      liveAssistantUsage = event.message.usage;
-      currentCtx = ctx;
-      layoutDirty = true;
-      statusRenderScheduler.schedule(CONTEXT_STATUS_RENDER_MS);
-    }
-  });
-
-  pi.on("message_end", async (event, ctx) => {
-    currentCtx = ctx;
-    coreContextUsageCache.reset();
-    if (isSessionAssistantMessage(event.message)) {
-      if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
-        liveAssistantUsage = null;
-      } else if (getUsageTokenTotal(event.message.usage) > 0) {
-        liveAssistantUsage = event.message.usage;
-      }
-    }
-    requestImmediateStatusRender({ deferDuringTyping: false });
-  });
-
-  pi.on("turn_end", async (_event, ctx) => {
-    currentCtx = ctx;
-    coreContextUsageCache.reset();
-    requestImmediateStatusRender({ deferDuringTyping: false });
-  });
-
-  pi.on("session_before_compact", async (_event, ctx) => {
-    powerlineCompacting = true;
-    currentCtx = ctx;
-    isStreaming = false;
-    liveAssistantUsage = null;
-    approximateContextUsage = null;
-    coreContextUsageCache.reset();
-    requestQueueRender();
-  });
-
-  pi.on("session_compact", async (event, ctx) => {
-    powerlineCompacting = false;
-    currentCtx = ctx;
-    isStreaming = false;
-    liveAssistantUsage = null;
-    approximateContextUsage = estimateUnknownContextUsage(ctx);
-    coreContextUsageCache.reset();
-    if (event.willRetry) {
-      deliverAfterRetrySettles = true;
-    } else {
-      deliverAfterRetrySettles = false;
-      schedulePostCompactionDelivery(ctx);
-    }
-    requestQueueRender();
-  });
-
-  pi.on("agent_settled", async (_event, ctx) => {
-    if (powerlineCompacting) {
-      finishFailedCompaction(ctx, "Compaction did not complete");
-      return;
-    }
-    if (deliverAfterRetrySettles) {
-      deliverAfterRetrySettles = false;
-      schedulePostCompactionDelivery(ctx);
-    }
-  });
-
-  // Also dismiss on tool calls (agent is working) + refresh vibe if rate limit allows
-  pi.on("tool_call", async (event, ctx) => {
-    if (ctx.hasUI) {
-      // Extract recent agent context from session for richer vibe generation
-      const agentContext = getRecentAgentContext(ctx);
-      onVibeToolCall(event.toolName, event.input, ctx.ui.setWorkingMessage, agentContext);
-    }
-  });
-
-  // Helper to extract recent agent response text (skipping thinking blocks)
-  function getRecentAgentContext(ctx: any): string | undefined {
-    const sessionEvents = ctx.sessionManager?.getBranch?.() ?? [];
-
-    // Find the most recent assistant message
-    for (let i = sessionEvents.length - 1; i >= 0; i--) {
-      const e = sessionEvents[i];
-      if (e.type === "message" && e.message?.role === "assistant") {
-        const content = e.message.content;
-        if (!Array.isArray(content)) continue;
-
-        // Extract text content, skip thinking blocks
-        for (const block of content) {
-          if (block.type === "text" && block.text) {
-            // Return first ~200 chars of non-empty text
-            const text = block.text.trim();
-            if (text.length > 0) {
-              return text.slice(0, 200);
-            }
-          }
-        }
-      }
-    }
-    return undefined;
-  }
-
-  function dismissWelcome(ctx: any) {
-    if (guideOverlayBlocking) return;
-
-    if (dismissWelcomeOverlay) {
-      dismissWelcomeOverlay();
-      dismissWelcomeOverlay = null;
-    } else {
-      // The startup overlay mounts after a delay; dismiss it immediately if it appears later.
-      welcomeOverlayShouldDismiss = true;
-    }
-    if (welcomeHeaderActive) {
-      welcomeHeaderActive = false;
-      ctx.ui.setHeader(undefined);
-    }
-  }
-
-  function scheduleDismissWelcome(ctx: any) {
-    if (!dismissWelcomeOverlay && welcomeOverlayShouldDismiss && !welcomeHeaderActive) return;
-    welcomeDismissScheduler.schedule(ctx);
-  }
-
-  function closeWelcome(ctx: any): void {
-    dismissWelcomeOverlay?.();
-    dismissWelcomeOverlay = null;
-    guideOverlayBlocking = false;
-    if (welcomeHeaderActive) {
-      welcomeHeaderActive = false;
-      ctx.ui.setHeader(undefined);
-    }
-    welcomeOverlayShouldDismiss = false;
-  }
-
-  function currentGuideFeatures(ctx: any): GuideFeature[] {
-    const preferences = getGuidePreferences(readSettings(ctx.cwd));
-    return getNewGuideFeatures(preferences.lastSeenVersion, VERSION);
-  }
-
-  function addStashHistoryEntry(text: string): void {
-    const changed = pushStashHistory(stashedPromptHistory, text);
-    if (!changed) {
-      return;
-    }
-
-    persistStashHistory(stashedPromptHistory);
-  }
-
-  function copyTextToClipboard(ctx: any, text: string, successMessage?: string): void {
-    copyToClipboard(text);
-    if (successMessage) {
-      ctx.ui.notify(successMessage, "info");
-    }
-  }
-
-  function getEditorTextForClipboard(ctx: any): string | null {
-    const text = getCurrentEditorText(ctx, currentEditor);
-    if (hasNonWhitespaceText(text)) {
-      return text;
-    }
-
-    ctx.ui.notify("Editor is empty", "info");
-    return null;
-  }
-
-  async function selectStashedPromptFromHistory(ctx: any): Promise<string | null> {
-    const historyItems = [...stashedPromptHistory];
-    const items: SelectItem[] = historyItems.map((entry, index) => ({
-      value: String(index),
-      label: `#${index + 1} ${buildStashPreview(entry, STASH_PREVIEW_WIDTH)}`,
-    }));
-
-    const selected = await showSelectOverlay(
-      ctx, "Stash history", "↑↓ navigate • enter insert • esc cancel",
-      items, Math.min(items.length, 10));
-    if (!selected) return null;
-
-    const i = Number.parseInt(selected.value, 10);
-    return historyItems[i] ?? null;
-  }
-
-  async function selectProjectPromptFromHistory(ctx: any, prompts: string[]): Promise<string | null> {
-    const items: SelectItem[] = prompts.map((entry, index) => ({
-      value: String(index),
-      label: `#${index + 1} ${buildStashPreview(entry, STASH_PREVIEW_WIDTH)}`,
-    }));
-
-    const selected = await showSelectOverlay(
-      ctx, "Recent project prompts", "↑↓ navigate • enter insert • esc cancel",
-      items, Math.min(items.length, 10));
-    if (!selected) return null;
-
-    const i = Number.parseInt(selected.value, 10);
-    return prompts[i] ?? null;
-  }
-
-  async function selectPromptHistorySource(
-    ctx: any,
-    stashCount: number,
-    projectPromptCount: number,
-  ): Promise<"stash" | "project" | null> {
-    const items: SelectItem[] = [];
-
-    if (stashCount > 0) {
-      items.push({
-        value: "stash",
-        label: "Stashed prompts",
-        description: `${stashCount} saved`,
-      });
-    }
-
-    if (projectPromptCount > 0) {
-      items.push({
-        value: "project",
-        label: "Recent project prompts",
-        description: `${projectPromptCount} recent`,
-      });
-    }
-
-    if (items.length === 0) {
-      return null;
-    }
-
-    if (items.length === 1) {
-      return items[0]?.value === "project" ? "project" : "stash";
-    }
-
-    const selected = await showSelectOverlay(
-      ctx, "Prompt history", "↑↓ navigate • enter open • esc cancel",
-      items, items.length);
-    if (!selected) return null;
-
-    return selected.value === "project" ? "project" : "stash";
-  }
-
-  async function insertSelectedPromptHistoryEntry(ctx: any, selected: string): Promise<void> {
-    const currentText = getCurrentEditorText(ctx, currentEditor);
-    if (!hasNonWhitespaceText(currentText)) {
-      ctx.ui.setEditorText(selected);
-      ctx.ui.notify("Inserted prompt", "info");
-      return;
-    }
-
-    const action = await ctx.ui.select("Insert prompt", ["Replace", "Append", "Cancel"]);
-
-    if (action === "Replace") {
-      ctx.ui.setEditorText(selected);
-      ctx.ui.notify("Replaced editor with prompt", "info");
-      return;
-    }
-
-    if (action === "Append") {
-      const separator = currentText.endsWith("\n") || selected.startsWith("\n") ? "" : "\n";
-      ctx.ui.setEditorText(`${currentText}${separator}${selected}`);
-      ctx.ui.notify("Appended prompt", "info");
-    }
-  }
-
-  async function handleSelectedStashHistoryEntry(ctx: any, selected: string): Promise<void> {
-    const action = await ctx.ui.select("Stashed prompt", ["Insert", "Cancel"]);
-    if (action === "Insert") await insertSelectedPromptHistoryEntry(ctx, selected);
-  }
-
-  function isStashShortcutInput(data: string): boolean {
-    return matchesStashShortcutInput(data, { includePrintableSharpS: config.stashSharpSShortcut });
-  }
-
-  function isPromptHistoryShortcutInput(data: string): boolean {
-    return matchesConfiguredShortcut(data, resolvedShortcuts.stashHistory)
-      || (resolvedShortcuts.stashHistory === "ctrl+alt+h" && (
-        /^\x1b\[104(?::\d*)?(?::\d*)?;7(?::\d+)?u$/.test(data)
-        || data === "\x1b[27;7;104~"
-        || data === "\x1b[27;7;72~"
-      ));
-  }
-
-  function getPowerlineShortcutAction(data: string): PowerlineShortcutAction | null {
-    if (isKeyRelease(data)) return null;
-
-    if (isPromptHistoryShortcutInput(data)) {
-      return { kind: "stashHistory" };
-    }
-    if (matchesConfiguredShortcut(data, resolvedShortcuts.copyEditor)) {
-      return { kind: "copyEditor" };
-    }
-    if (matchesConfiguredShortcut(data, resolvedShortcuts.cutEditor)) {
-      return { kind: "cutEditor" };
-    }
-    if (matchesConfiguredShortcut(data, resolvedShortcuts.queueOpen)) {
-      return { kind: "queueOpen" };
-    }
-    if (matchesConfiguredShortcut(data, bashModeSettings.toggleShortcut)) {
-      return { kind: "bashMode" };
-    }
-
-    return null;
-  }
-
-  function runPowerlineShortcut(ctx: any, action: PowerlineShortcutAction): void {
-    if (action.kind === "stashHistory") {
-      void openStashHistory(ctx);
-      return;
-    }
-
-    if (action.kind === "copyEditor" || action.kind === "cutEditor") {
-      const text = getEditorTextForClipboard(ctx);
-      if (!text) return;
-
-      copyTextToClipboard(ctx, text, action.kind === "copyEditor" ? "Copied editor text" : undefined);
-      if (action.kind === "cutEditor") {
-        ctx.ui.setEditorText("");
-        ctx.ui.notify("Cut editor text", "info");
-      }
-      return;
-    }
-
-    if (action.kind === "queueOpen") {
-      void openQueuePicker(ctx);
-      return;
-    }
-
-    if (action.kind === "bashMode") {
-      void setBashModeActive(!bashModeActive, ctx);
-      return;
-    }
-  }
-
-  function stashOrRestoreEditorText(ctx: any): void {
-    const rawText = getCurrentEditorText(ctx, currentEditor);
-    const hasStash = stashedEditorText !== null;
-
-    if (!hasNonWhitespaceText(rawText)) {
-      if (!hasStash) {
-        ctx.ui.notify("Nothing to stash", "info");
-        return;
-      }
-
-      ctx.ui.setEditorText(stashedEditorText);
-      stashedEditorText = null;
-      ctx.ui.setStatus("stash", undefined);
-      ctx.ui.notify("Stash restored", "info");
-      return;
-    }
-
-    stashedEditorText = rawText;
-    addStashHistoryEntry(rawText);
-    ctx.ui.setEditorText("");
-    ctx.ui.setStatus("stash", "stash");
-    ctx.ui.notify(hasStash ? "Stash updated" : "Text stashed", "info");
-  }
-
-  async function openStashHistory(ctx: any): Promise<void> {
-    let projectPrompts: string[] = [];
-
-    try {
-      projectPrompts = readRecentProjectPrompts(ctx.cwd, PROJECT_PROMPT_HISTORY_LIMIT);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      ctx.ui.notify(`Failed to load project prompts: ${message}`, "warning");
-    }
-
-    if (stashedPromptHistory.length === 0 && projectPrompts.length === 0) {
-      ctx.ui.notify("No prompt history yet", "info");
-      return;
-    }
-
-    const source = await selectPromptHistorySource(ctx, stashedPromptHistory.length, projectPrompts.length);
-    if (!source) {
-      return;
-    }
-
-    const selected = source === "project"
-      ? await selectProjectPromptFromHistory(ctx, projectPrompts)
-      : await selectStashedPromptFromHistory(ctx);
-    if (!selected) return;
-
-    if (source === "stash") {
-      await handleSelectedStashHistoryEntry(ctx, selected);
-      return;
-    }
-
-    await insertSelectedPromptHistoryEntry(ctx, selected);
-  }
-
-  pi.on("agent_end", async (_event, ctx) => {
-    isStreaming = false;
-    liveAssistantUsage = null;
-    coreContextUsageCache.reset();
-
-    let hasUI = false;
-    try {
-      hasUI = Boolean(ctx.hasUI);
-    } catch (error) {
-      if (!isStaleExtensionContextError(error)) throw error;
-      currentCtx = null;
-      return;
-    }
-
-    currentCtx = ctx;
-    try {
-      if (hasUI) {
-        onVibeAgentEnd(ctx.ui.setWorkingMessage); // working-vibes internal state + reset message
-        if (stashedEditorText !== null) {
-          if (ctx.ui.getEditorText().trim() === "") {
-            ctx.ui.setEditorText(stashedEditorText);
-            stashedEditorText = null;
-            ctx.ui.setStatus("stash", undefined);
-            ctx.ui.notify("Stash restored", "info");
-          } else {
-            ctx.ui.notify("Stash preserved — clear editor then Alt+S to restore", "info");
-          }
-        }
-      }
-    } catch (error) {
-      if (!isStaleExtensionContextError(error)) throw error;
-      currentCtx = null;
-      return;
-    }
-
-    requestStatusRender();
-    if (!powerlineCompacting && !deliverAfterRetrySettles) {
-      schedulePostCompactionDelivery(ctx);
-    }
-  });
-
-  registerCdCommand(pi, () => currentCtx?.cwd ?? process.cwd());
-
-  pi.registerCommand("queue", {
-    description: "Manage Powerline queued prompts and project aliases",
-    handler: async (args, ctx) => {
-      currentCtx = ctx;
-      const parts = args.trim().split(/\s+/).filter(Boolean);
-      const action = parts[0];
-
-      if (!action) {
-        await openQueuePicker(ctx);
-        return;
-      }
-
-      if (action === "alias") {
-        const alias = parts[1];
-        const aliasPath = parts.slice(2).join(" ") || ctx.cwd || process.cwd();
-        if (!alias) {
-          ctx.ui.notify("Usage: /queue alias <name> [path]", "info");
-          return;
-        }
-        try {
-          queueStore.setAlias(alias, aliasPath);
-          ctx.ui.notify(`Alias @${alias} → ${aliasPath}`, "info");
-        } catch (error) {
-          ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-        }
-        return;
-      }
-
-      if (action === "send" || action === "retry") {
-        const id = parts[1];
-        if (!id) {
-          const item = queueStore.queuedDeliveryItems(getQueueContext(ctx))[0];
-          if (!item) {
-            ctx.ui.notify("No queued item to send", "info");
-            return;
-          }
-          sendOrRetryQueueItem(ctx, item.id);
-          return;
-        }
-        sendOrRetryQueueItem(ctx, id);
-        return;
-      }
-
-      if (action === "clear") {
-        const id = parts[1];
-        if (id === "all") {
-          const active = queueStore.activeItems(getQueueContext(ctx));
-          for (const item of active) queueStore.clear(item.id);
-          ctx.ui.notify(`Cleared ${active.length} queued item${active.length === 1 ? "" : "s"}`, "info");
-          requestQueueRender();
-          return;
-        }
-        if (!id) {
-          ctx.ui.notify("Usage: /queue clear <id|all>", "info");
-          return;
-        }
-        const item = queueStore.get(id);
-        if (!item) {
-          ctx.ui.notify(`No unique queued item matches ${id}`, "warning");
-          return;
-        }
-        queueStore.clear(item.id);
-        ctx.ui.notify(`Cleared ${item.id}`, "info");
-        requestQueueRender();
-        return;
-      }
-
-      if (action === "target") {
-        const id = parts[1];
-        const spec = parts[2];
-        if (!id || !spec) {
-          ctx.ui.notify("Usage: /queue target <id> @alias|global|current", "info");
-          return;
-        }
-        const item = queueStore.get(id);
-        if (!item) {
-          ctx.ui.notify(`No unique queue item matches ${id}`, "warning");
-          return;
-        }
-        try {
-          const target = resolveCommandTarget(ctx, spec);
-          queueStore.update(item.id, { target });
-          ctx.ui.notify(`Retargeted ${item.id}`, "info");
-          requestQueueRender();
-        } catch (error) {
-          ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-        }
-        return;
-      }
-
-      ctx.ui.notify("Usage: /queue [send|retry|clear|target|alias]", "info");
-    },
-  });
-
-  pi.registerCommand("guide", {
-    description: "Open the recurring Selesai feature guide",
-    handler: async (args, ctx) => {
-      if (!ctx.hasUI) return;
-
-      const mode = args?.trim().toLowerCase() ?? "";
-      if (mode !== "" && !["full", "compact", "off", "reset"].includes(mode)) {
-        ctx.ui.notify("Usage: /guide [full|compact|off|reset]", "warning");
-        return;
-      }
-
-      if (!enabled) {
-        ctx.ui.notify("Powerline is disabled; use /powerline first", "info");
-        return;
-      }
-
-      if (mode === "off") {
-        const saved = saveGuidePreferences({ mode: "off" }, getSettingsPath());
-        closeWelcome(ctx);
-        ctx.ui.notify(saved ? "Guide hidden for future sessions" : "Guide hidden for this session; settings.json was not updated", saved ? "info" : "warning");
-        return;
-      }
-
-      if (mode === "compact") {
-        const saved = saveGuidePreferences({ mode: "compact" }, getSettingsPath());
-        closeWelcome(ctx);
-        setupWelcomeHeader(ctx, currentGuideFeatures(ctx));
-        if (!saved) ctx.ui.notify("Compact guide enabled for this session; settings.json was not updated", "warning");
-        return;
-      }
-
-      if (mode === "full" || mode === "reset") {
-        const saved = saveGuidePreferences({
-          mode: "full",
-          ...(mode === "reset" ? { lastSeenVersion: null } : {}),
-        }, getSettingsPath());
-        if (!saved) ctx.ui.notify("Guide opened, but settings.json was not updated", "warning");
-      }
-
-      closeWelcome(ctx);
-      setupWelcomeOverlay(ctx, currentGuideFeatures(ctx));
-    },
-  });
-
-  // Command to toggle/configure
-  pi.registerCommand("powerline", {
-    description: "Configure powerline status (toggle, preset)",
-    handler: async (args, ctx) => {
-      // Update context reference (command ctx may have more methods)
-      currentCtx = ctx;
-
-      if (!args?.trim()) {
-        // Toggle
-        enabled = !enabled;
-        if (enabled) {
-          setupCustomEditor(ctx);
-          ctx.ui.notify("Powerline enabled", "info");
-        } else {
-          shellSession?.dispose();
-          shellSession = null;
-          bashTranscript.clear();
-          bashModeActive = false;
-          dismissWelcomeOverlay?.();
-          dismissWelcomeOverlay = null;
-          welcomeHeaderActive = false;
-          welcomeOverlayShouldDismiss = false;
-          getPromptHistoryState().savedPromptHistory = [];
-          stashedEditorText = null;
-                ctx.ui.setStatus("stash", undefined);
-          restoreFooterStatusRepaintHook?.();
-          restoreFooterStatusRepaintHook = null;
-          stashShortcutInputUnsubscribe?.();
-          stashShortcutInputUnsubscribe = null;
-          // Clear all custom UI components
-          ctx.ui.setEditorComponent(undefined);
-          ctx.ui.setFooter(undefined);
-          ctx.ui.setHeader(undefined);
-          ctx.ui.setWidget("powerline-top", undefined);
-          ctx.ui.setWidget("powerline-secondary", undefined);
-          ctx.ui.setWidget("powerline-bash-transcript", undefined);
-          ctx.ui.setWidget("powerline-status", undefined);
-          ctx.ui.setWidget("powerline-queue-preview", undefined);
-          ctx.ui.setWidget("powerline-last-prompt", undefined);
-          footerDataRef = null;
-          tuiRef = null;
-          currentEditor = null;
-          statusRenderScheduler.cancel();
-          resetLayoutCache();
-          ctx.ui.notify("Powerline disabled", "info");
-        }
-        return;
-      }
-
-      const normalizedArgs = args.trim().toLowerCase();
-      const placementMatch = /^placement(?:\s+(above|below|toggle))?$/.exec(normalizedArgs);
-      if (placementMatch) {
-        const requestedPlacement = placementMatch[1];
-        config.placement = requestedPlacement === "above" || requestedPlacement === "below"
-          ? requestedPlacement
-          : config.placement === "above" ? "below" : "above";
-        config.invalidPlacement = null;
-        if (enabled && ctx.hasUI) setupCustomEditor(ctx);
-
-        if (writePowerlineOptionSetting(ctx.cwd, { placement: config.placement }, config.preset)) {
-          ctx.ui.notify(`Powerline placement set to: ${config.placement}`, "info");
-        } else {
-          ctx.ui.notify(`Powerline placement set to: ${config.placement} (not persisted; check settings.json)`, "warning");
-        }
-        return;
-      }
-
-      const preset = normalizePreset(args);
-      if (preset) {
-        config.preset = preset;
-        resetLayoutCache();
-        if (enabled) {
-          setupCustomEditor(ctx);
-        }
-
-        if (writePowerlinePresetSetting(preset, ctx.cwd)) {
-          ctx.ui.notify(`Preset set to: ${preset}`, "info");
-        } else {
-          ctx.ui.notify(`Preset set to: ${preset} (not persisted; check settings.json)`, "warning");
-        }
-        return;
-      }
-
-      // Show available presets
-      const presetList = Object.keys(PRESETS).join(", ");
-      ctx.ui.notify(`Available presets: ${presetList}`, "info");
-    },
-  });
-
-  pi.registerCommand("stash-history", {
-    description: "Open prompt history picker",
-    handler: async (_args, ctx) => {
-      if (!ctx.hasUI) return;
-      if (!enabled) {
-        ctx.ui.notify("Powerline is disabled", "info");
-        return;
-      }
-
-      await openStashHistory(ctx);
-    },
-  });
-
-  pi.registerCommand("bash-mode", {
-    description: "Toggle sticky bash mode (on, off, toggle)",
-    handler: async (args, ctx) => {
-      const mode = args?.trim().toLowerCase() || "toggle";
-      if (mode === "on") {
-        await setBashModeActive(true, ctx);
-        return;
-      }
-      if (mode === "off") {
-        await setBashModeActive(false, ctx);
-        return;
-      }
-      if (mode === "toggle") {
-        await setBashModeActive(!bashModeActive, ctx);
-        return;
-      }
-      ctx.ui.notify("Usage: /bash-mode [on|off|toggle]", "warning");
-    },
-  });
-
-  pi.registerCommand("powerline-perf", {
-    description: "Show or reset opt-in editor performance profiling",
-    handler: async (args, ctx) => {
-      if (!editorPerf.options.enabled) {
-        ctx.ui.notify("Set POWERLINE_DEBUG_PERF=1 and reload to enable editor profiling", "info");
-        return;
-      }
-      if (args.trim().toLowerCase() === "reset") {
-        editorPerf.reset();
-        ctx.ui.notify("Powerline editor performance counters reset", "info");
-        return;
-      }
-      ctx.ui.notify(editorPerf.report(), "info");
-    },
-  });
-
-  pi.registerCommand("bash-reset", {
-    description: "Reset the managed bash session",
-    handler: async (_args, ctx) => {
-      shellSession?.dispose();
-      shellSession = null;
-      bashTranscript.clear();
-      if (bashModeActive) {
-        try {
-          await ensureShellSession();
-        } catch (error) {
-          bashModeActive = false;
-          const message = error instanceof Error ? error.message : String(error);
-          ctx.ui.notify(`Failed to restart shell session: ${message}`, "error");
-          requestStatusRender();
-          return;
-        }
-      }
-      requestStatusRender();
-      ctx.ui.notify("Bash session reset", "info");
-    },
-  });
-
-
-  // Command to set working message theme
-  pi.registerCommand("vibe", {
-    description: "Set working message theme. Usage: /vibe [theme|off|mode|model|generate]",
-    handler: async (args, ctx) => {
-      const parts = args?.trim().split(/\s+/) || [];
-      const subcommand = parts[0]?.toLowerCase();
-
-      // No args: show current status
-      if (!args || !args.trim()) {
-        const theme = getVibeTheme();
-        const mode = getVibeMode();
-        const model = getVibeModel();
-        let status = `Vibe: ${theme || "off"} | Mode: ${mode} | Model: ${model}`;
-        if (theme && mode === "file") {
-          const count = getVibeFileCount(theme);
-          status += count > 0 ? ` | File: ${count} vibes` : " | File: not found";
-        }
-        ctx.ui.notify(status, "info");
-        return;
-      }
-
-      // /vibe model [spec] - show or set model
-      if (subcommand === "model") {
-        const modelSpec = parts.slice(1).join(" ");
-        if (!modelSpec) {
-          ctx.ui.notify(`Current vibe model: ${getVibeModel()}`, "info");
-          return;
-        }
-        // Validate format (provider/modelId)
-        if (!modelSpec.includes("/")) {
-          ctx.ui.notify("Invalid model format. Use: provider/modelId (e.g., openai-codex/gpt-5.4-mini)", "error");
-          return;
-        }
-        const persisted = setVibeModel(modelSpec);
-        if (persisted) {
-          ctx.ui.notify(`Vibe model set to: ${modelSpec}`, "info");
-        } else {
-          ctx.ui.notify(`Vibe model set to: ${modelSpec} (not persisted; check settings.json)`, "warning");
-        }
-        return;
-      }
-
-      // /vibe mode [generate|file] - show or set mode
-      if (subcommand === "mode") {
-        const newMode = parts[1]?.toLowerCase();
-        if (!newMode) {
-          ctx.ui.notify(`Current vibe mode: ${getVibeMode()}`, "info");
-          return;
-        }
-        if (newMode !== "generate" && newMode !== "file") {
-          ctx.ui.notify("Invalid mode. Use: generate or file", "error");
-          return;
-        }
-        // Check if file exists when switching to file mode
-        const theme = getVibeTheme();
-        if (newMode === "file" && theme && !hasVibeFile(theme)) {
-          ctx.ui.notify(`No vibe file for "${theme}". Run /vibe generate ${theme} first`, "error");
-          return;
-        }
-        const persisted = setVibeMode(newMode);
-        if (persisted) {
-          ctx.ui.notify(`Vibe mode set to: ${newMode}`, "info");
-        } else {
-          ctx.ui.notify(`Vibe mode set to: ${newMode} (not persisted; check settings.json)`, "warning");
-        }
-        return;
-      }
-
-      // /vibe generate <theme> [count] - generate vibes and save to file
-      if (subcommand === "generate") {
-        const parsed = parseVibeGenerateArgs(parts.slice(1));
-        if (!parsed) {
-          ctx.ui.notify("Usage: /vibe generate <theme> [count]", "error");
-          return;
-        }
-
-        const { theme, count } = parsed;
-        ctx.ui.notify(`Generating ${count} vibes for "${theme}"...`, "info");
-
-        const result = await generateVibesBatch(theme, count);
-
-        if (result.success) {
-          ctx.ui.notify(`Generated ${result.count} vibes for "${theme}" → ${result.filePath}`, "info");
-        } else {
-          ctx.ui.notify(`Failed to generate vibes: ${result.error}`, "error");
-        }
-        return;
-      }
-
-      // /vibe off - disable
-      if (subcommand === "off") {
-        const persisted = setVibeTheme(null);
-        if (persisted) {
-          ctx.ui.notify("Vibe disabled", "info");
-        } else {
-          ctx.ui.notify("Vibe disabled (not persisted; check settings.json)", "warning");
-        }
-        return;
-      }
-
-      // /vibe <theme> - set theme (preserve original casing)
-      const theme = args.trim();
-      const persisted = setVibeTheme(theme);
-      const mode = getVibeMode();
-      if (mode === "file" && !hasVibeFile(theme)) {
-        const suffix = persisted ? "" : " (not persisted; check settings.json)";
-        ctx.ui.notify(`Vibe set to: ${theme} (file mode, but no file found - run /vibe generate ${theme})${suffix}`, "warning");
-      } else if (persisted) {
-        ctx.ui.notify(`Vibe set to: ${theme}`, "info");
-      } else {
-        ctx.ui.notify(`Vibe set to: ${theme} (not persisted; check settings.json)`, "warning");
-      }
-    },
-  });
-
-  function getCurrentSessionName(ctx: any): string | undefined {
-    const direct = pi.getSessionName?.() ?? ctx?.sessionManager?.getSessionName?.();
-    if (direct?.trim()) return direct.trim();
-
-    const entries = ctx?.sessionManager?.getEntries?.() ?? ctx?.sessionManager?.getBranch?.() ?? [];
-    for (let i = entries.length - 1; i >= 0; i--) {
-      const entry = entries[i];
-      if (entry?.type === "session_info") {
-        return entry.name?.trim() || undefined;
-      }
-    }
-
-    return undefined;
-  }
-
-  function buildSegmentContext(ctx: any, theme: Theme): SegmentContext {
-    const presetDef = getPreset(config.preset);
-    const colors: ColorScheme = presetDef.colors ?? getDefaultColors();
-
-    // Build usage stats and get thinking level from session (cached; the full
-    // event list is only re-scanned when events are appended or the trailing
-    // event's stats-relevant fields change, e.g. in-place streaming updates)
-    const sessionEvents = sessionBranchCache.get(ctx.sessionManager);
-    const tokenStats = tokenStatsCache.get(sessionEvents);
-    let { input, output, cacheRead, cacheWrite, cost, subagentCost } = tokenStats;
-    const lastAssistant = tokenStats.lastAssistant;
-    const thinkingLevelFromSession = tokenStats.thinkingLevelFromSession;
-
-    for (const subagentUsage of completedAsyncSubagentUsage.values()) {
-      input += subagentUsage.input;
-      output += subagentUsage.output;
-      cacheRead += subagentUsage.cacheRead;
-      cacheWrite += subagentUsage.cacheWrite;
-      cost += subagentUsage.cost;
-    }
-
-    // Calculate context percentage.
-    const latestUsage = isStreaming ? liveAssistantUsage ?? lastAssistant?.usage : lastAssistant?.usage;
-    const coreContextUsage = isStreaming && liveAssistantUsage ? null : coreContextUsageCache.get(ctx);
-    const fallbackContextTokens = latestUsage ? getUsageTokenTotal(latestUsage) : 0;
-    const {
-      contextTokens,
-      contextWindow,
-      contextPercent,
-    } = resolveDisplayContextUsage({
-      coreContextUsage,
-      unknownCoreFallback: approximateContextUsage,
-      fallbackContextTokens,
-      fallbackContextWindow: ctx.model?.contextWindow ?? 0,
-    });
-    const contextApproximate = coreContextUsage?.contextTokens === null && approximateContextUsage !== null;
-
-    const segmentOptions = mergeSegmentOptions(presetDef.segmentOptions, config.segmentOptions);
-
-    // Get git status (cached)
-    const gitBranch = footerDataRef?.getGitBranch() ?? null;
-    const gitStatus = getGitStatus(gitBranch, segmentOptions.git?.polling);
-    const extensionStatuses = footerDataRef?.getExtensionStatuses() ?? new Map();
-    const customItemsById = new Map(config.customItems.map((item) => [item.id, item]));
-    const hiddenExtensionStatusKeys = collectHiddenExtensionStatusKeys(config.customItems);
-
-    // Check if using OAuth subscription
-    const usingSubscription = ctx.model
-      ? ctx.modelRegistry?.isUsingOAuth?.(ctx.model) ?? false
-      : false;
-
-    const thinkingLevel = currentThinkingLevel ?? thinkingLevelFromSession ?? getThinkingLevelFn?.() ?? "off";
-    const queueSummary = getQueueSummary(ctx);
-
-    return {
-      model: ctx.model,
-      thinkingLevel,
-      sessionId: ctx.sessionManager?.getSessionId?.(),
-      sessionName: getCurrentSessionName(ctx),
-      cwd: ctx.cwd,
-      usageStats: { input, output, cacheRead, cacheWrite, cost, subagentCost },
-      contextTokens,
-      contextPercent,
-      contextWindow,
-      contextApproximate,
-      autoCompactEnabled: ctx.settingsManager?.getCompactionSettings?.()?.enabled ?? true,
-      customCompactionEnabled: customCompactionEnabled || extensionStatuses.has(CUSTOM_COMPACTION_STATUS_KEY),
-      usingSubscription,
-      queueSummary,
-      sessionStartTime,
-      shellModeActive: bashModeActive,
-      shellRunning: shellSession?.state.running ?? false,
-      shellName: shellSession?.state.shellName ?? null,
-      shellCwd: shellSession?.state.cwd ?? null,
-      git: gitStatus,
-      extensionStatuses,
-      hiddenExtensionStatusKeys,
-      customItemsById,
-      options: segmentOptions,
-      theme,
-      colors,
-    };
-  }
-
-  /**
-   * Get cached responsive layout or compute fresh one.
-   * The segment context scans session state, so keep it stable across render bursts.
-   */
-  function getResponsiveLayout(width: number, theme: Theme): { topContent: string; secondaryContent: string } {
-    const now = Date.now();
-    const cacheTtl = isStreaming ? STREAMING_LAYOUT_CACHE_TTL_MS : LAYOUT_CACHE_TTL_MS;
-
-    const currentSessionName = getCurrentSessionName(currentCtx);
-    if (lastLayoutResult && lastLayoutWidth === width && currentSessionName === lastLayoutSessionName) {
-      const msSinceInput = now - lastEditorInputAt;
-      const typingRecently = msSinceInput < EDITOR_STATUS_DEFER_MS;
-
-      if (!forceNextLayoutRecompute && typingRecently && (layoutDirty || now - lastLayoutTimestamp >= cacheTtl)) {
-        return lastLayoutResult;
-      }
-
-      if (!layoutDirty && now - lastLayoutTimestamp < cacheTtl) {
-        return lastLayoutResult;
-      }
-    }
-
-    const presetDef = getPreset(config.preset);
-    let segmentCtx: SegmentContext;
-    try {
-      segmentCtx = editorPerf.options.enabled
-        ? editorPerf.measure("layout.segment-context", () => buildSegmentContext(currentCtx, theme))
-        : buildSegmentContext(currentCtx, theme);
-    } catch (error) {
-      if (!isStaleExtensionContextError(error)) throw error;
-      currentCtx = null;
-      lastLayoutWidth = width;
-      lastLayoutResult = { topContent: "", secondaryContent: "" };
-      lastLayoutTimestamp = now;
-      layoutDirty = false;
-      forceNextLayoutRecompute = false;
-      return lastLayoutResult;
-    }
-
-    lastLayoutWidth = width;
-    lastLayoutResult = computeResponsiveLayout(segmentCtx, presetDef, width);
-    lastLayoutSessionName = currentSessionName;
-    lastLayoutTimestamp = now;
-    layoutDirty = false;
-    forceNextLayoutRecompute = false;
-
-    return lastLayoutResult;
-  }
-
-  function renderPowerlineStatusLines(width: number): string[] {
-    if (!currentCtx || !footerDataRef) return [];
-
-    const statuses = footerDataRef.getExtensionStatuses();
-    if (!statuses || statuses.size === 0) return [];
-    const hiddenExtensionStatusKeys = collectHiddenExtensionStatusKeys(config.customItems);
-
-    const notifications: string[] = [];
-    for (const value of getNotificationExtensionStatuses(statuses, hiddenExtensionStatusKeys)) {
-      const lineContent = ` ${value}`;
-      if (visibleWidth(lineContent) <= width) {
-        notifications.push(lineContent);
-      }
-    }
-
-    return notifications;
-  }
-
-  function renderPowerlinePrimaryLines(width: number, theme: Theme): string[] {
-    if (!currentCtx) return [];
-
-    const layout = getResponsiveLayout(width, theme);
-    return layout.topContent ? [layout.topContent] : [];
-  }
-
-  function renderPowerlineSecondaryLines(width: number, theme: Theme): string[] {
-    if (!currentCtx) return [];
-
-    const layout = getResponsiveLayout(width, theme);
-    return layout.secondaryContent ? [layout.secondaryContent] : [];
-  }
-
-  function renderPowerlineQueuePreviewLines(width: number, theme: Theme): string[] {
-    if (!currentCtx) return [];
-    const summary = getQueueSummary(currentCtx);
-    if (!summary.leadingText) return [];
-
-    const prefix = summary.leadingStatus === "blocked" || summary.leadingStatus === "failed"
-      ? "blocked: "
-      : summary.leadingStatus === "delivering"
-        ? "sending: "
-        : "queued: ";
-    const text = `${prefix}${summary.leadingText.replace(/\s+/g, " ").trim()}`;
-    const color = summary.leadingStatus === "blocked" || summary.leadingStatus === "failed" ? "warning" : "dim";
-    return [` ${theme.fg(color, truncateToWidth(text, Math.max(1, width - 1), "…"))}`];
-  }
-
-  function renderBashTranscriptLines(width: number, theme: Theme): string[] {
-    if (!bashModeActive) return [];
-
-    const snapshot = bashTranscript.getSnapshot();
-    if (snapshot.commands.length === 0) return [];
-
-    const lines: string[] = [];
-    if (snapshot.truncatedCommands > 0) {
-      lines.push(` ${theme.fg("dim", `… ${snapshot.truncatedCommands} earlier command${snapshot.truncatedCommands === 1 ? "" : "s"} truncated`)}`);
-    }
-
-    const recentCommands = snapshot.commands.slice(-4);
-    for (const command of recentCommands) {
-      const promptGlyph = (shellSession?.state.shellName ?? "shell") === "fish" ? ">" : "$";
-      const status = command.exitCode === null
-        ? theme.fg("accent", "running")
-        : command.exitCode === 0
-          ? theme.fg("success", "ok")
-          : theme.fg("error", `exit ${command.exitCode}`);
-      const commandLine = truncateToWidth(command.command.replace(/\s+/g, " ").trim(), Math.max(8, width - 8), "…");
-      lines.push(` ${theme.fg("accent", promptGlyph)} ${commandLine} ${theme.fg("dim", "(")}${status}${theme.fg("dim", ")")}`);
-
-      const outputTail = command.output.slice(-6);
-      for (const outputLine of outputTail) {
-        lines.push(`   ${truncateToWidth(outputLine, Math.max(1, width - 3), "…")}`);
-      }
-    }
-
-    return lines.slice(-16);
-  }
-
-  function renderLastPromptLines(width: number): string[] {
-    if (bashModeActive || !showLastPrompt || !lastUserPrompt) return [];
-
-    const color = getFgAnsiCode("sep");
-    if (
-      lastPromptRenderCache
-      && lastPromptRenderCache.source === lastUserPrompt
-      && lastPromptRenderCache.width === width
-      && lastPromptRenderCache.color === color
-    ) {
-      return lastPromptRenderCache.lines;
-    }
-
-    const compact = lastPromptRenderCache?.source === lastUserPrompt
-      ? lastPromptRenderCache.compact
-      : lastUserPrompt.replace(/\s+/g, " ").trim();
-    const prefix = ` ${color}↳${ansi.reset} `;
-    const availableWidth = width - visibleWidth(prefix);
-    const lines = compact && availableWidth >= 10
-      ? [truncateToWidth(`${prefix}${color}${truncateToWidth(compact, availableWidth, "…")}${ansi.reset}`, width, "…")]
-      : [];
-
-    lastPromptRenderCache = { source: lastUserPrompt, compact, width, color, lines };
-    return lines;
-  }
-
-  function installPowerlineWidgets(ctx: any) {
-    if (!editorPerf.options.widgets) return;
-
-    const measureWidget = (name: string, render: () => string[]): string[] => {
-      return editorPerf.options.enabled ? editorPerf.measure(`widget.${name}`, render) : render();
-    };
-
-    ctx.ui.setWidget("powerline-status", () => ({
-      dispose() {},
-      invalidate() {
-        requestStatusRender();
-      },
-      render(width: number): string[] {
-        return measureWidget("status", () => renderPowerlineStatusLines(width));
-      },
-    }), { placement: "aboveEditor" });
-
-    ctx.ui.setWidget("powerline-top", (_tui: any, theme: Theme) => ({
-      dispose() {},
-      invalidate() {
-        resetLayoutCache();
-      },
-      render(width: number): string[] {
-        return measureWidget("primary", () => renderPowerlinePrimaryLines(width, theme));
-      },
-    }), { placement: config.placement === "below" ? "belowEditor" : "aboveEditor" });
-
-    ctx.ui.setWidget("powerline-secondary", (_tui: any, theme: Theme) => ({
-      dispose() {},
-      invalidate() {
-        resetLayoutCache();
-      },
-      render(width: number): string[] {
-        return measureWidget("secondary", () => renderPowerlineSecondaryLines(width, theme));
-      },
-    }), { placement: "belowEditor" });
-
-    if (editorPerf.options.bashWidgets) {
-      ctx.ui.setWidget("powerline-bash-transcript", (_tui: any, theme: Theme) => ({
-        dispose() {},
-        invalidate() {},
-        render(width: number): string[] {
-          return measureWidget("bash-transcript", () => renderBashTranscriptLines(width, theme));
-        },
-      }), { placement: "belowEditor" });
-    }
-
-    ctx.ui.setWidget("powerline-queue-preview", (_tui: any, theme: Theme) => ({
-      dispose() {},
-      invalidate() {},
-      render(width: number): string[] {
-        return measureWidget("queue-preview", () => renderPowerlineQueuePreviewLines(width, theme));
-      },
-    }), { placement: "belowEditor" });
-
-    if (editorPerf.options.lastPrompt) {
-      ctx.ui.setWidget("powerline-last-prompt", () => ({
-        dispose() {},
-        invalidate() {},
-        render(width: number): string[] {
-          return measureWidget("last-prompt", () => renderLastPromptLines(width));
-        },
-      }), { placement: "belowEditor" });
-    }
-  }
-
-  function setupCustomEditor(ctx: any) {
-    snapshotPromptHistory(currentEditor);
-    if (!enabled) {
-      return;
-    }
-
-    stashShortcutInputUnsubscribe?.();
-    stashShortcutInputUnsubscribe = typeof ctx.ui.onTerminalInput === "function"
-      ? ctx.ui.onTerminalInput((data: string) => {
-        if (!enabled || !ctx.hasUI || tuiRef?.hasOverlay?.()) {
-          return undefined;
-        }
-        if (isStashShortcutInput(data)) {
-          stashOrRestoreEditorText(ctx);
-          tuiRef?.requestRender();
-          return { consume: true };
-        }
-
-        const powerlineShortcutAction = getPowerlineShortcutAction(data);
-        if (!powerlineShortcutAction) {
-          return undefined;
-        }
-
-        runPowerlineShortcut(ctx, powerlineShortcutAction);
-        tuiRef?.requestRender();
-        return { consume: true };
-      })
-      : null;
-
-    ctx.ui.setWidget("powerline-top", undefined);
-    ctx.ui.setWidget("powerline-secondary", undefined);
-    ctx.ui.setWidget("powerline-bash-transcript", undefined);
-    ctx.ui.setWidget("powerline-status", undefined);
-    ctx.ui.setWidget("powerline-queue-preview", undefined);
-    ctx.ui.setWidget("powerline-last-prompt", undefined);
-
-    let autocompleteFixed = !bashModeSettings.completions;
-    const previousEditorFactory = typeof ctx.ui.getEditorComponent === "function" ? ctx.ui.getEditorComponent() : undefined;
-
-    const editorFactory = (tui: any, editorTheme: any, keybindings: any) => {
-      const previousEditor = previousEditorFactory?.(tui, editorTheme, keybindings);
-      const editor = new BashModeEditor(tui, editorTheme, keybindings, {
-        keybindings,
-        isBashModeActive: () => bashModeActive,
-        isShellRunning: () => shellSession?.state.running ?? false,
-        onExitBashMode: () => {
-          void setBashModeActive(false, ctx);
-        },
-        onSubmitCommand: (command) => void runShellCommand(command, ctx),
-        editorBoundaryShortcuts: {
-          start: resolvedShortcuts.editorStart,
-          end: resolvedShortcuts.editorEnd,
-        },
-        onInterrupt: () => {
-          shellSession?.interrupt();
-          ctx.ui.notify("Sent interrupt to shell", "info");
-        },
-        onNotify: (message, level = "info") => ctx.ui.notify(message, level),
-        getHistoryEntries: (prefix) => getShellHistoryEntries(prefix),
-        areCompletionsEnabled: () => bashModeSettings.completions,
-        resolveGhostSuggestion: async (text, signal) => {
-          const oneOffBash = getOneOffBashCommandContext(text);
-          if (oneOffBash) {
-            const ghost = await bashCompletionEngine.getGhostSuggestion(
-              oneOffBash.command,
-              getShellCwd(),
-              getShellPath(),
-              signal,
-            );
-            return ghost ? { ...ghost, value: `${oneOffBash.prefix}${ghost.value}` } : null;
-          }
-
-          return bashCompletionEngine.getGhostSuggestion(text, getShellCwd(), getShellPath(), signal);
-        },
-      });
-
-      let installingPowerlineAutocompleteProvider = false;
-      const originalSetAutocompleteProvider = editor.setAutocompleteProvider.bind(editor);
-      editor.setAutocompleteProvider = (provider: AutocompleteProvider) => {
-        if (installingPowerlineAutocompleteProvider) {
-          originalSetAutocompleteProvider(provider);
-          return;
-        }
-
-        originalSetAutocompleteProvider(passAutocompleteProviderThroughPreviousEditor(provider, previousEditor));
-        attachAutocompleteProvider();
-      };
-
-      const getInstalledAutocompleteProvider = (): AutocompleteProvider | undefined => {
-        return getEditorAutocompleteProvider(editor) ?? getEditorAutocompleteProvider(previousEditor);
-      };
-
-      const attachAutocompleteProvider = (): boolean => {
-        if (!bashModeSettings.completions) return false;
-        if (editor.hasWrappedProvider()) return true;
-        const defaultProvider = getInstalledAutocompleteProvider();
-        if (!defaultProvider) return false;
-
-        const bashProvider = new BashAutocompleteProvider();
-        const oneOffBashProvider = new OneOffBashAutocompleteProvider();
-        installingPowerlineAutocompleteProvider = true;
-        try {
-          editor.installAutocompleteProvider(
-            new ModeAwareAutocompleteProvider(defaultProvider, bashProvider, oneOffBashProvider, () => bashModeActive),
-          );
-        } finally {
-          installingPowerlineAutocompleteProvider = false;
-        }
-        return true;
-      };
-
-      currentEditor = editor;
-      trackPromptHistory(editor);
-      restorePromptHistory(editor);
-      attachAutocompleteProvider();
-
-      const baseHandleInput = editor.handleInput.bind(editor);
-      const originalHandleInput = editorPerf.options.enabled
-        ? (data: string) => editorPerf.measure("input.base-editor", () => baseHandleInput(data))
-        : baseHandleInput;
-      const handlePowerlineEditorInput = (data: string) => {
-        lastEditorInputAt = Date.now();
-
-        if (isPrintableInput(data)) {
-          scheduleDismissWelcome(ctx);
-          originalHandleInput(data);
-          return;
-        }
-
-        const isSubmit = keybindings.matches(data, "tui.input.submit") && !keybindings.matches(data, "tui.input.newLine");
-        const isFollowUpSubmit = keybindings.matches(data, "app.message.followUp");
-        if (!powerlineCompacting && !bashModeActive && isSubmit && typeof ctx.compact === "function") {
-          const editorText = editor.getExpandedText().trim();
-          const compactQueuedPrompt = parseCompactQueuedPrompt(editorText);
-          if (editorText === "/compact" || compactQueuedPrompt) {
-            editor.addToHistory?.(editorText);
-            editor.setText("");
-            if (compactQueuedPrompt) {
-              capturePostCompactPrompt(ctx, compactQueuedPrompt);
-            }
-            powerlineCompacting = true;
-            deliverAfterRetrySettles = false;
-            requestQueueRender();
-            ctx.compact({
-              onError: (error: Error) => {
-                finishFailedCompaction(ctx, error.message);
-                ctx.ui.notify(error.message, "error");
-              },
-            });
-            scheduleDismissWelcome(ctx);
-            return;
-          }
-        }
-
-        if (powerlineCompacting && !bashModeActive && (isSubmit || isFollowUpSubmit)) {
-          const text = editor.getExpandedText().trim();
-          if (!text) return;
-          if (text.startsWith("/")) {
-            originalHandleInput(data);
-            return;
-          }
-          editor.addToHistory?.(text);
-          editor.setText("");
-          capturePostCompactPrompt(ctx, text);
-          scheduleDismissWelcome(ctx);
-          return;
-        }
-
-        if (isStashShortcutInput(data)) {
-          stashOrRestoreEditorText(ctx);
-          return;
-        }
-
-        const powerlineShortcutAction = getPowerlineShortcutAction(data);
-        if (powerlineShortcutAction) {
-          runPowerlineShortcut(ctx, powerlineShortcutAction);
-          return;
-        }
-
-        if (!autocompleteFixed && !getInstalledAutocompleteProvider()) {
-          autocompleteFixed = true;
-          snapshotPromptHistory(editor);
-          ctx.ui.setEditorComponent(editorFactory);
-          currentEditor?.handleInput(data);
-          return;
-        }
-
-        if (bashModeSettings.completions) {
-          attachAutocompleteProvider();
-        }
-        scheduleDismissWelcome(ctx);
-        originalHandleInput(data);
-      };
-      editor.handleInput = editorPerf.options.enabled
-        ? (data: string) => {
-            editorPerf.measure("input.total", () => handlePowerlineEditorInput(data));
-            const state = Reflect.get(editor, "state");
-            const lines = state && typeof state === "object" ? Reflect.get(state, "lines") : null;
-            if (Array.isArray(lines)) editorPerf.observeDraft(lines);
-          }
-        : handlePowerlineEditorInput;
-
-      const originalRender = editor.render.bind(editor);
-      editor.render = (width: number): string[] => {
-        const renderPowerlineEditor = (): string[] => {
-          if (!editorPerf.options.editorChrome) {
-            return editorPerf.options.enabled
-              ? editorPerf.measure("editor.render.base", () => originalRender(width))
-              : originalRender(width);
-          }
-
-          if (editorPerf.options.fastRender) {
-            const fastLines = editorPerf.options.enabled
-              ? editorPerf.measure("editor.render.fast-probe", () => renderFastPowerlineEditor(editor, width, {
-                  bashModeActive,
-                  completionsEnabled: bashModeSettings.completions,
-                }))
-              : renderFastPowerlineEditor(editor, width, {
-                  bashModeActive,
-                  completionsEnabled: bashModeSettings.completions,
-                });
-            if (fastLines) {
-              if (editorPerf.options.enabled) editorPerf.count("editor.render.fast-hit");
-              return fastLines;
-            }
-          }
-
-          if (width < 10) {
-            return editorPerf.options.enabled
-              ? editorPerf.measure("editor.render.base", () => originalRender(width))
-              : originalRender(width);
-          }
-
-          const bc = (s: string) =>
-            typeof editor.borderColor === "function"
-              ? editor.borderColor(s)
-              : `${getFgAnsiCode("sep")}${s}${ansi.reset}`;
-          const promptGlyph = bashModeActive ? "$" : config.fixedEditorPromptGlyph;
-          const promptColor = ansi.getFgAnsi(200, 200, 200);
-          const prompt = promptGlyph ? `${promptColor}${promptGlyph}${ansi.reset}` : "";
-          const promptPrefix = prompt ? ` ${prompt} ` : " ";
-          const contPrefix = " ";
-          const contentWidth = Math.max(1, width - 1);
-          const lines = editorPerf.options.enabled
-            ? editorPerf.measure("editor.render.base", () => originalRender(contentWidth))
-            : originalRender(contentWidth);
-
-          if (lines.length === 0) return lines;
-
-          let bottomBorderIndex = lines.length - 1;
-          for (let i = lines.length - 1; i >= 1; i--) {
-            const stripped = lines[i]?.replace(/\x1b\[[0-9;]*m/g, "") || "";
-            if (stripped.length > 0 && /^─{3,}/.test(stripped)) {
-              bottomBorderIndex = i;
-              break;
-            }
-          }
-
-          const result: string[] = [];
-          result.push(" " + bc("─".repeat(width - 2)));
-
-          for (let i = 1; i < bottomBorderIndex; i++) {
-            const prefix = i === 1 ? promptPrefix : contPrefix;
-            result.push(`${prefix}${lines[i] || ""}`);
-          }
-
-          if (bottomBorderIndex === 1) {
-            result.push(`${promptPrefix}${" ".repeat(contentWidth)}`);
-          }
-
-          result.push(" " + bc("─".repeat(width - 2)));
-
-          for (let i = bottomBorderIndex + 1; i < lines.length; i++) {
-            result.push(lines[i] || "");
-          }
-
-          return result;
-        };
-
-        return editorPerf.options.enabled
-          ? editorPerf.measure("editor.render.total", renderPowerlineEditor)
-          : renderPowerlineEditor();
-      };
-
-      return editor;
-    };
-
-    ctx.ui.setEditorComponent(editorFactory);
-
-    ctx.ui.setFooter((tui: any, _theme: Theme, footerData: ReadonlyFooterDataProvider) => {
-      footerDataRef = footerData;
-      tuiRef = tui;
-      installFooterStatusRepaintHook(footerData);
-      const unsub = footerData.onBranchChange(() => requestStatusRender());
-      const unsubGitUpdates = subscribeGitUpdates(() => requestStatusRender());
-
-      return {
-        dispose() {
-          unsub();
-          unsubGitUpdates();
-          restoreFooterStatusRepaintHook?.();
-          restoreFooterStatusRepaintHook = null;
-        },
-        invalidate() {
-          requestStatusRender();
-        },
-        render(): string[] {
-          return [""];
-        },
-      };
-    });
-
-    installPowerlineWidgets(ctx);
-  }
-
-  function setupWelcomeHeader(ctx: any, newFeatures: GuideFeature[] = []) {
-    const modelName = ctx.model?.name || ctx.model?.id || "No model";
-    const providerName = ctx.model?.provider || "Unknown";
-    const loadedCounts = discoverLoadedCounts();
-    const recentSessions = getRecentSessions(3);
-    const initialContextTokens = estimateInitialContextTokens(ctx);
-
-    const header = new WelcomeHeader(modelName, providerName, recentSessions, loadedCounts, "compact", newFeatures, initialContextTokens);
-    welcomeHeaderActive = true;
-    markGuideVersionSeen(VERSION, getSettingsPath());
-
-    ctx.ui.setHeader(() => {
-      return {
-        render(width: number): string[] {
-          return header.render(width);
-        },
-        invalidate() {
-          header.invalidate();
-        },
-      };
-    });
-  }
-
-  function setupWelcomeOverlay(ctx: any, newFeatures: GuideFeature[] = []) {
-    const modelName = ctx.model?.name || ctx.model?.id || "No model";
-    const providerName = ctx.model?.provider || "Unknown";
-    const loadedCounts = discoverLoadedCounts();
-    const recentSessions = getRecentSessions(3);
-
-    const overlaySessionGeneration = sessionGeneration;
-
-    // Small delay to let pi-mono finish initialization
-    setTimeout(() => {
-      if (!enabled || welcomeOverlayShouldDismiss || isStreaming || overlaySessionGeneration !== sessionGeneration) {
-        welcomeOverlayShouldDismiss = false;
-        return;
-      }
-
-      const sessionEvents = ctx.sessionManager?.getBranch?.() ?? [];
-      const hasActivity = sessionEvents.some((entry: unknown) => {
-        if (!isRecord(entry)) return false;
-        if (entry.type === "tool_call" || entry.type === "tool_result") return true;
-        return entry.type === "message" && isRecord(entry.message) && entry.message.role === "assistant";
-      });
-      if (hasActivity) {
-        return;
-      }
-
-      const initialContextTokens = estimateInitialContextTokens(ctx);
-
-      ctx.ui.custom(
-        (_tui: any, _theme: any, _keybindings: any, done: (result: void) => void) => {
-          const welcome = new WelcomeComponent(
-            modelName,
-            providerName,
-            recentSessions,
-            loadedCounts,
-            "full",
-            newFeatures,
-            initialContextTokens,
-          );
-          markGuideVersionSeen(VERSION, getSettingsPath());
-          guideOverlayBlocking = true;
-
-          let dismissed = false;
-
-          const dismiss = () => {
-            if (dismissed) return;
-            dismissed = true;
-            dismissWelcomeOverlay = null;
-            guideOverlayBlocking = false;
-            done();
-          };
-
-          dismissWelcomeOverlay = dismiss;
-
-          if (welcomeOverlayShouldDismiss) {
-            welcomeOverlayShouldDismiss = false;
-            dismiss();
-          }
-
-          return {
-            focused: true,
-            invalidate: () => welcome.invalidate(),
-            render: (width: number) => welcome.render(width),
-            handleInput: () => dismiss(),
-            dispose: () => {
-              dismissed = true;
-            },
-          };
-        },
-        {
-          overlay: true,
-          overlayOptions: () => ({
-            verticalAlign: "center",
-            horizontalAlign: "center",
-          }),
-        },
-      ).catch((error: unknown) => {
-        console.debug("[powerline-footer] Welcome overlay failed:", error);
-      });
-    }, 100);
-  }
-}