ccstatusline 2.2.13 → 2.2.15

package/dist/ccstatusline.js

@@ -1355,7 +1355,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
     exports.useTransition = function() {
       return resolveDispatcher().useTransition();
     };
-    exports.version = "19.2.5";
+    exports.version = "19.2.6";
     typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
   })();
 });
@@ -52341,13 +52341,31 @@ var init_Widget = __esm(() => {
 });
 
 // src/types/Settings.ts
-var CURRENT_VERSION = 3, SettingsSchema_v1, SettingsSchema, DEFAULT_SETTINGS;
+var CURRENT_VERSION = 3, InstallationMetadataSchema, SettingsSchema_v1, SettingsSchema, DEFAULT_SETTINGS;
 var init_Settings = __esm(() => {
   init_zod();
   init_ColorLevel();
   init_FlexMode();
   init_PowerlineConfig();
   init_Widget();
+  InstallationMetadataSchema = exports_external.discriminatedUnion("method", [
+    exports_external.object({
+      method: exports_external.literal("auto-update"),
+      packageManager: exports_external.enum(["npm", "bun"])
+    }),
+    exports_external.object({
+      method: exports_external.literal("pinned"),
+      installedVersion: exports_external.string().optional()
+    }),
+    exports_external.object({
+      method: exports_external.literal("self-managed"),
+      packageManager: exports_external.enum(["npm", "bun", "unknown"]).default("unknown")
+    }),
+    exports_external.object({
+      method: exports_external.literal("unknown"),
+      packageManager: exports_external.enum(["npm", "bun", "unknown"]).default("unknown")
+    })
+  ]);
   SettingsSchema_v1 = exports_external.object({
     lines: exports_external.array(exports_external.array(WidgetItemSchema)).optional(),
     flexMode: FlexModeSchema.optional(),
@@ -52398,7 +52416,8 @@ var init_Settings = __esm(() => {
     updatemessage: exports_external.object({
       message: exports_external.string().nullable().optional(),
       remaining: exports_external.number().nullable().optional()
-    }).optional()
+    }).optional(),
+    installation: InstallationMetadataSchema.optional()
   });
   DEFAULT_SETTINGS = SettingsSchema.parse({});
 });
@@ -56136,7 +56155,7 @@ function getTerminalWidth() {
 function canDetectTerminalWidth() {
   return probeTerminalWidth() !== null;
 }
-var __dirname = "/Users/sirmalloc/Projects/Personal/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.13";
+var __dirname = "/Users/sirmalloc/Projects/Personal/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.15";
 var init_terminal = () => {};
 
 // src/utils/renderer.ts
@@ -58896,19 +58915,21 @@ var require_supports_color = __commonJS((exports, module) => {
   var tty2 = __require("tty");
   var hasFlag2 = require_has_flag();
   var { env: env3 } = process;
-  var forceColor;
+  var flagForceColor2;
   if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false") || hasFlag2("color=never")) {
-    forceColor = 0;
+    flagForceColor2 = 0;
   } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
-    forceColor = 1;
+    flagForceColor2 = 1;
   }
-  if ("FORCE_COLOR" in env3) {
-    if (env3.FORCE_COLOR === "true") {
-      forceColor = 1;
-    } else if (env3.FORCE_COLOR === "false") {
-      forceColor = 0;
-    } else {
-      forceColor = env3.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env3.FORCE_COLOR, 10), 3);
+  function envForceColor2() {
+    if ("FORCE_COLOR" in env3) {
+      if (env3.FORCE_COLOR === "true") {
+        return 1;
+      }
+      if (env3.FORCE_COLOR === "false") {
+        return 0;
+      }
+      return env3.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env3.FORCE_COLOR, 10), 3);
     }
   }
   function translateLevel2(level) {
@@ -58922,15 +58943,22 @@ var require_supports_color = __commonJS((exports, module) => {
       has16m: level >= 3
     };
   }
-  function supportsColor2(haveStream, streamIsTTY) {
+  function supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+    const noFlagForceColor = envForceColor2();
+    if (noFlagForceColor !== undefined) {
+      flagForceColor2 = noFlagForceColor;
+    }
+    const forceColor = sniffFlags ? flagForceColor2 : noFlagForceColor;
     if (forceColor === 0) {
       return 0;
     }
-    if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag2("color=256")) {
-      return 2;
+    if (sniffFlags) {
+      if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag2("color=256")) {
+        return 2;
+      }
     }
     if (haveStream && !streamIsTTY && forceColor === undefined) {
       return 0;
@@ -58947,7 +58975,7 @@ var require_supports_color = __commonJS((exports, module) => {
       return 1;
     }
     if ("CI" in env3) {
-      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => (sign in env3)) || env3.CI_NAME === "codeship") {
+      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => (sign in env3)) || env3.CI_NAME === "codeship") {
         return 1;
       }
       return min2;
@@ -58959,7 +58987,7 @@ var require_supports_color = __commonJS((exports, module) => {
       return 3;
     }
     if ("TERM_PROGRAM" in env3) {
-      const version2 = parseInt((env3.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+      const version2 = Number.parseInt((env3.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
       switch (env3.TERM_PROGRAM) {
         case "iTerm.app":
           return version2 >= 3 ? 3 : 2;
@@ -58978,14 +59006,17 @@ var require_supports_color = __commonJS((exports, module) => {
     }
     return min2;
   }
-  function getSupportLevel(stream) {
-    const level = supportsColor2(stream, stream && stream.isTTY);
+  function getSupportLevel(stream, options = {}) {
+    const level = supportsColor2(stream, {
+      streamIsTTY: stream && stream.isTTY,
+      ...options
+    });
     return translateLevel2(level);
   }
   module.exports = {
     supportsColor: getSupportLevel,
-    stdout: translateLevel2(supportsColor2(true, tty2.isatty(1))),
-    stderr: translateLevel2(supportsColor2(true, tty2.isatty(2)))
+    stdout: getSupportLevel({ isTTY: tty2.isatty(1) }),
+    stderr: getSupportLevel({ isTTY: tty2.isatty(2) })
   };
 });
 
@@ -67592,6 +67623,23 @@ async function saveSettings(settings) {
     await syncWidgetHooks2(settings);
   } catch {}
 }
+async function saveInstallationMetadata(metadata) {
+  const paths = getSettingsPaths();
+  if (!metadata && !fs10.existsSync(paths.settingsPath)) {
+    return;
+  }
+  const settings = await loadSettings();
+  const settingsWithVersion = {
+    ...settings,
+    version: CURRENT_VERSION
+  };
+  if (metadata) {
+    settingsWithVersion.installation = metadata;
+  } else {
+    delete settingsWithVersion.installation;
+  }
+  await writeSettingsJson(settingsWithVersion, paths);
+}
 var readFile3, writeFile, mkdir, DEFAULT_SETTINGS_PATH, settingsPath;
 var init_config = __esm(async () => {
   init_Settings();
@@ -67610,7 +67658,7 @@ import * as fs11 from "fs";
 import * as os9 from "os";
 import * as path8 from "path";
 function isKnownCommand(command) {
-  const prefixes = [CCSTATUSLINE_COMMANDS.NPM, CCSTATUSLINE_COMMANDS.BUNX, CCSTATUSLINE_COMMANDS.SELF_MANAGED];
+  const prefixes = [CCSTATUSLINE_COMMANDS.AUTO_NPX, CCSTATUSLINE_COMMANDS.AUTO_BUNX, CCSTATUSLINE_COMMANDS.GLOBAL];
   return prefixes.some((prefix) => command === prefix || command.startsWith(`${prefix} --config `)) || /(?:^|[\s"'\\/])ccstatusline\.ts(?=$|[\s"'])/.test(command);
 }
 function needsQuoting(filePath) {
@@ -67719,15 +67767,35 @@ async function isInstalled() {
   const command = settings.statusLine?.command ?? "";
   return isKnownCommand(command) && (settings.statusLine?.padding === 0 || settings.statusLine?.padding === undefined);
 }
-function isBunxAvailable() {
+function isExecutableAvailable(executable) {
   try {
-    const command = process.platform === "win32" ? "where bunx" : "which bunx";
+    const command = process.platform === "win32" ? `where ${executable}` : `which ${executable}`;
     execSync4(command, { stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
+function isNpmAvailable() {
+  return isExecutableAvailable("npm");
+}
+function isNpxAvailable() {
+  return isExecutableAvailable("npx");
+}
+function isBunAvailable() {
+  return isExecutableAvailable("bun");
+}
+function isBunxAvailable() {
+  return isExecutableAvailable("bunx");
+}
+function getPackageCommandAvailability() {
+  return {
+    npm: isNpmAvailable(),
+    npx: isNpxAvailable(),
+    bun: isBunAvailable(),
+    bunx: isBunxAvailable()
+  };
+}
 function getClaudeCodeVersion() {
   try {
     const output = execSync4("claude --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"], timeout: 5000 }).trim();
@@ -67762,6 +67830,59 @@ function buildCommand(baseCommand) {
   }
   return baseCommand;
 }
+function getBaseCommandForMode(commandMode) {
+  switch (commandMode) {
+    case "auto-npx":
+      return CCSTATUSLINE_COMMANDS.AUTO_NPX;
+    case "auto-bunx":
+      return CCSTATUSLINE_COMMANDS.AUTO_BUNX;
+    case "global":
+      return CCSTATUSLINE_COMMANDS.GLOBAL;
+  }
+}
+function buildStatusLineCommand(commandMode) {
+  return buildCommand(getBaseCommandForMode(commandMode));
+}
+function matchesCommandBase(command, baseCommand) {
+  return command === baseCommand || command.startsWith(`${baseCommand} --config `);
+}
+function isLocalDevelopmentCommand(command) {
+  return /(?:^|[\s"'\\/])ccstatusline\.ts(?=$|[\s"'])/.test(command);
+}
+function classifyInstallation(command, metadata) {
+  const statusLineCommand = command ?? "";
+  if (matchesCommandBase(statusLineCommand, CCSTATUSLINE_COMMANDS.AUTO_NPX)) {
+    return {
+      method: "auto-update",
+      packageManager: "npm"
+    };
+  }
+  if (matchesCommandBase(statusLineCommand, CCSTATUSLINE_COMMANDS.AUTO_BUNX)) {
+    return {
+      method: "auto-update",
+      packageManager: "bun"
+    };
+  }
+  if (matchesCommandBase(statusLineCommand, CCSTATUSLINE_COMMANDS.GLOBAL)) {
+    if (metadata?.method === "pinned") {
+      return metadata;
+    }
+    return {
+      method: "self-managed",
+      packageManager: "unknown"
+    };
+  }
+  if (isLocalDevelopmentCommand(statusLineCommand)) {
+    return {
+      method: "self-managed",
+      packageManager: "unknown"
+    };
+  }
+  return {
+    method: "unknown",
+    packageManager: "unknown"
+  };
+}
 async function loadSavedSettingsForHookSync() {
   const configPath = getConfigPath();
   if (!fs11.existsSync(configPath)) {
@@ -67779,7 +67900,11 @@ async function loadSavedSettingsForHookSync() {
     return null;
   }
 }
-async function installStatusLine(useBunx = false, supportsRefreshInterval = false) {
+async function installStatusLine({
+  commandMode,
+  supportsRefreshInterval = false,
+  installationMetadata
+}) {
   let settings;
   const backupPath = await backupClaudeSettings(".orig");
   try {
@@ -67789,17 +67914,19 @@ async function installStatusLine(useBunx = false, supportsRefreshInterval = fals
     console.error(`Warning: Could not read existing Claude settings. A backup exists at ${backupPath ?? fallbackBackupPath}.`);
     settings = {};
   }
-  const baseCommand = useBunx ? CCSTATUSLINE_COMMANDS.BUNX : CCSTATUSLINE_COMMANDS.NPM;
   const existingRefreshInterval = settings.statusLine?.refreshInterval;
   settings.statusLine = {
     type: "command",
-    command: buildCommand(baseCommand),
+    command: buildStatusLineCommand(commandMode),
     padding: 0
   };
   if (supportsRefreshInterval) {
     settings.statusLine.refreshInterval = existingRefreshInterval ?? 10;
   }
   await saveClaudeSettings(settings);
+  if (installationMetadata !== undefined) {
+    await saveInstallationMetadata(installationMetadata);
+  }
   const savedSettings = await loadSavedSettingsForHookSync();
   if (savedSettings) {
     const { syncWidgetHooks: syncWidgetHooks2 } = await init_hooks().then(() => exports_hooks);
@@ -67818,6 +67945,7 @@ async function uninstallStatusLine() {
     delete settings.statusLine;
     await saveClaudeSettings(settings);
   }
+  await saveInstallationMetadata(undefined);
   try {
     const { removeManagedHooks: removeManagedHooks2 } = await init_hooks().then(() => exports_hooks);
     await removeManagedHooks2();
@@ -67900,7 +68028,7 @@ function getVoiceConfig(cwd2 = process.cwd()) {
   }
   return anyFileExisted ? { enabled: false } : null;
 }
-var readFile4, writeFile2, mkdir2, CCSTATUSLINE_COMMANDS, VoiceConfigSchema;
+var readFile4, writeFile2, mkdir2, CCSTATUSLINE_COMMANDS, PINNED_INSTALL_COMMANDS, VoiceConfigSchema;
 var init_claude_settings = __esm(async () => {
   init_zod();
   init_Settings();
@@ -67909,10 +68037,17 @@ var init_claude_settings = __esm(async () => {
   writeFile2 = fs11.promises.writeFile;
   mkdir2 = fs11.promises.mkdir;
   CCSTATUSLINE_COMMANDS = {
+    AUTO_NPX: "npx -y ccstatusline@latest",
+    AUTO_BUNX: "bunx -y ccstatusline@latest",
+    GLOBAL: "ccstatusline",
     NPM: "npx -y ccstatusline@latest",
     BUNX: "bunx -y ccstatusline@latest",
     SELF_MANAGED: "ccstatusline"
   };
+  PINNED_INSTALL_COMMANDS = {
+    NPM: (version2) => `npm install -g ccstatusline@${version2}`,
+    BUN: (version2) => `bun add -g ccstatusline@${version2}`
+  };
   VoiceConfigSchema = exports_external.object({ enabled: exports_external.boolean().optional() });
 });
 
@@ -68486,7 +68621,7 @@ var dist_default5 = Gradient;
 
 // src/tui/App.tsx
 await init_claude_settings();
-var import_react50 = __toESM(require_react(), 1);
+var import_react51 = __toESM(require_react(), 1);
 
 // src/utils/clone-settings.ts
 function cloneSettings(settings) {
@@ -68500,6 +68635,371 @@ function cloneSettings(settings) {
 // src/tui/App.tsx
 await init_config();
 
+// src/utils/global-command-resolution.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import * as path9 from "path";
+
+// src/utils/package-manager-executable.ts
+function getPackageManagerExecutable(packageManager, platform2 = process.platform) {
+  return packageManager === "npm" && platform2 === "win32" ? "npm.cmd" : packageManager;
+}
+
+// src/utils/global-command-resolution.ts
+var COMMAND_LOOKUP_TIMEOUT_MS = 5000;
+function splitCommandOutput(output) {
+  const seen = new Set;
+  const paths = [];
+  for (const line of output.split(/\r?\n/)) {
+    const candidate = line.trim();
+    if (!candidate || seen.has(candidate)) {
+      continue;
+    }
+    seen.add(candidate);
+    paths.push(candidate);
+  }
+  return paths;
+}
+function isTransientBunxStatusLinePath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return /(?:^|\/)bunx-[^/]*ccstatusline@[^/]+\/node_modules\/\.bin\/ccstatusline(?:\.(?:cmd|ps1))?$/i.test(normalized);
+}
+function getPersistentCommandResolutionPaths(paths) {
+  return paths.filter((path10) => !isTransientBunxStatusLinePath(path10));
+}
+function getCommandResolutionPaths(command, { platform: platform2 = process.platform } = {}) {
+  try {
+    const output = platform2 === "win32" ? execFileSync5("where", [command], { encoding: "utf-8", timeout: COMMAND_LOOKUP_TIMEOUT_MS }) : execFileSync5("which", ["-a", command], { encoding: "utf-8", timeout: COMMAND_LOOKUP_TIMEOUT_MS });
+    return splitCommandOutput(output);
+  } catch {
+    return [];
+  }
+}
+function getNpmGlobalBinDir(platform2) {
+  try {
+    const prefix = execFileSync5(getPackageManagerExecutable("npm", platform2), ["prefix", "-g"], {
+      encoding: "utf-8",
+      timeout: COMMAND_LOOKUP_TIMEOUT_MS
+    }).trim();
+    if (!prefix) {
+      return null;
+    }
+    return platform2 === "win32" || /^[a-z]:[\\/]/i.test(prefix) ? prefix : path9.join(prefix, "bin");
+  } catch {
+    return null;
+  }
+}
+function getBunGlobalBinDir() {
+  try {
+    const binDir = execFileSync5("bun", ["pm", "bin", "-g"], {
+      encoding: "utf-8",
+      timeout: COMMAND_LOOKUP_TIMEOUT_MS
+    }).trim();
+    return binDir || null;
+  } catch {
+    return null;
+  }
+}
+function getExpectedGlobalBinDir(packageManager, { platform: platform2 = process.platform } = {}) {
+  return packageManager === "npm" ? getNpmGlobalBinDir(platform2) : getBunGlobalBinDir();
+}
+function trimTrailingSlashes(value) {
+  if (/^[a-z]:\/$/i.test(value) || value === "/") {
+    return value;
+  }
+  return value.replace(/\/+$/, "");
+}
+function normalizePathForComparison(filePath) {
+  const normalized = trimTrailingSlashes(filePath.trim().replace(/\\/g, "/"));
+  return /^[a-z]:\//i.test(normalized) || normalized.startsWith("/mnt/") ? normalized.toLowerCase() : normalized;
+}
+function getPathComparisonVariants(filePath) {
+  const normalized = normalizePathForComparison(filePath);
+  const variants = new Set([normalized]);
+  const driveMatch = /^([a-z]):\/(.*)$/i.exec(normalized);
+  if (driveMatch) {
+    variants.add(`/mnt/${driveMatch[1]?.toLowerCase()}/${driveMatch[2] ?? ""}`);
+  }
+  const wslMountMatch = /^\/mnt\/([a-z])\/(.*)$/i.exec(normalized);
+  if (wslMountMatch) {
+    variants.add(`${wslMountMatch[1]?.toLowerCase()}:/${wslMountMatch[2] ?? ""}`);
+  }
+  return Array.from(variants);
+}
+function getDirectoryName(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const lastSlashIndex = normalized.lastIndexOf("/");
+  return lastSlashIndex === -1 ? "" : normalized.slice(0, lastSlashIndex);
+}
+function getUniqueResolvedDirs(resolvedPaths) {
+  const seen = new Set;
+  const dirs = [];
+  for (const resolvedPath of resolvedPaths) {
+    const dir = getDirectoryName(resolvedPath);
+    const comparableDir = normalizePathForComparison(dir);
+    if (seen.has(comparableDir)) {
+      continue;
+    }
+    seen.add(comparableDir);
+    dirs.push(dir);
+  }
+  return dirs;
+}
+function isPathInsideDir(filePath, dir) {
+  const pathVariants = getPathComparisonVariants(filePath);
+  const dirVariants = getPathComparisonVariants(dir);
+  return pathVariants.some((pathVariant) => dirVariants.some((dirVariant) => {
+    const withSlash = dirVariant.endsWith("/") ? dirVariant : `${dirVariant}/`;
+    return pathVariant === dirVariant || pathVariant.startsWith(withSlash);
+  }));
+}
+function formatPathList(paths) {
+  return paths.join(", ");
+}
+function getResolutionWarning(packageManager, resolvedPaths, expectedBinDir) {
+  const firstResolvedPath = resolvedPaths[0] ?? null;
+  if (!firstResolvedPath) {
+    return "⚠ ccstatusline is not currently resolvable on PATH. Claude Code runs ccstatusline, so restart your shell or update PATH if it cannot launch.";
+  }
+  const resolvedDirs = getUniqueResolvedDirs(resolvedPaths);
+  if (resolvedDirs.length > 1) {
+    return `⚠ Multiple ccstatusline binaries are on PATH. Claude Code will run the first match: ${firstResolvedPath}.
+Other matches: ${formatPathList(resolvedPaths.slice(1))}`;
+  }
+  if (expectedBinDir && !isPathInsideDir(firstResolvedPath, expectedBinDir)) {
+    return `⚠ ccstatusline resolves to ${firstResolvedPath}, which is outside the ${packageManager} global bin directory (${expectedBinDir}). Claude Code will run the first PATH match.`;
+  }
+  return null;
+}
+function inspectGlobalCommandResolution(packageManager, options = {}) {
+  const resolvedPaths = getPersistentCommandResolutionPaths(getCommandResolutionPaths("ccstatusline", options));
+  const expectedBinDir = getExpectedGlobalBinDir(packageManager, options);
+  return {
+    resolvedPaths,
+    firstResolvedPath: resolvedPaths[0] ?? null,
+    expectedBinDir,
+    warning: getResolutionWarning(packageManager, resolvedPaths, expectedBinDir)
+  };
+}
+
+// src/utils/global-package-manager.ts
+import {
+  execFile,
+  execFileSync as execFileSync6
+} from "child_process";
+import * as fs12 from "fs";
+var GLOBAL_PACKAGE_TIMEOUT_MS = 120000;
+var VERSION_LOOKUP_TIMEOUT_MS = 5000;
+var WINDOWS_SHIM_EXTENSIONS = [
+  "",
+  ".cmd",
+  ".ps1"
+];
+function isWindowsStylePath(filePath) {
+  return /^[a-z]:[\\/]/i.test(filePath);
+}
+function trimTrailingSeparators(filePath) {
+  return filePath.replace(/[\\/]+$/, "");
+}
+function appendPathSegment(dir, segment) {
+  const separator = dir.includes("\\") && !dir.includes("/") ? "\\" : "/";
+  return `${trimTrailingSeparators(dir)}${separator}${segment}`;
+}
+function toWindowsPath(filePath) {
+  const match = /^\/mnt\/([a-z])\/(.*)$/i.exec(filePath.replace(/\\/g, "/"));
+  if (!match) {
+    return null;
+  }
+  return `${match[1]?.toUpperCase()}:\\${(match[2] ?? "").replace(/\//g, "\\")}`;
+}
+function toWslPath(filePath) {
+  const match = /^([a-z]):[\\/](.*)$/i.exec(filePath);
+  if (!match) {
+    return null;
+  }
+  return `/mnt/${match[1]?.toLowerCase()}/${(match[2] ?? "").replace(/\\/g, "/")}`;
+}
+function getFilesystemPathVariants(filePath) {
+  const variants = new Set([filePath]);
+  const windowsPath = toWindowsPath(filePath);
+  const wslPath = toWslPath(filePath);
+  if (windowsPath) {
+    variants.add(windowsPath);
+  }
+  if (wslPath) {
+    variants.add(wslPath);
+  }
+  return Array.from(variants);
+}
+function getBinaryPathCandidates(binDir, platform2) {
+  const extensions = platform2 === "win32" || isWindowsStylePath(binDir) ? WINDOWS_SHIM_EXTENSIONS : [""];
+  return extensions.map((extension) => appendPathSegment(binDir, `ccstatusline${extension}`));
+}
+function hasBinaryOnDisk(binDir, platform2) {
+  return getBinaryPathCandidates(binDir, platform2).some((candidate) => getFilesystemPathVariants(candidate).some((variant) => fs12.existsSync(variant)));
+}
+function hasResolvedBinaryInDir(resolvedPaths, binDir) {
+  return resolvedPaths.some((resolvedPath) => isPathInsideDir(resolvedPath, binDir));
+}
+function getDirectoryName2(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const lastSlashIndex = normalized.lastIndexOf("/");
+  return lastSlashIndex === -1 ? "" : normalized.slice(0, lastSlashIndex);
+}
+function getComparablePath(filePath) {
+  return filePath.replace(/\\/g, "/").toLowerCase().replace(/\/+$/, "");
+}
+function getUniqueResolvedDirs2(resolvedPaths) {
+  const seen = new Set;
+  const dirs = [];
+  for (const resolvedPath of resolvedPaths) {
+    const dir = getDirectoryName2(resolvedPath);
+    const comparableDir = getComparablePath(dir);
+    if (seen.has(comparableDir)) {
+      continue;
+    }
+    seen.add(comparableDir);
+    dirs.push(dir);
+  }
+  return dirs;
+}
+function formatPathList2(paths) {
+  return paths.join(", ");
+}
+function readPackageVersion(packageJsonPath) {
+  for (const variant of getFilesystemPathVariants(packageJsonPath)) {
+    try {
+      if (!fs12.existsSync(variant)) {
+        continue;
+      }
+      const packageJson = JSON.parse(fs12.readFileSync(variant, "utf-8"));
+      return typeof packageJson.version === "string" ? packageJson.version : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function getNpmGlobalPackageVersion(platform2) {
+  try {
+    const rootDir = execFileSync6(getPackageManagerExecutable("npm", platform2), ["root", "-g"], {
+      encoding: "utf-8",
+      timeout: VERSION_LOOKUP_TIMEOUT_MS
+    }).trim();
+    return rootDir ? readPackageVersion(appendPathSegment(appendPathSegment(rootDir, "ccstatusline"), "package.json")) : null;
+  } catch {
+    return null;
+  }
+}
+function getBunInstallRoot(binDir) {
+  const normalized = trimTrailingSeparators(binDir.replace(/\\/g, "/"));
+  const lower = normalized.toLowerCase();
+  return lower.endsWith("/bin") ? normalized.slice(0, -4) : normalized;
+}
+function getBunGlobalPackageVersion(binDir) {
+  if (!binDir) {
+    return null;
+  }
+  return readPackageVersion(appendPathSegment(appendPathSegment(appendPathSegment(appendPathSegment(appendPathSegment(getBunInstallRoot(binDir), "install"), "global"), "node_modules"), "ccstatusline"), "package.json"));
+}
+function getGlobalPackageVersion(packageManager, binDir, platform2) {
+  if (packageManager === "npm") {
+    return getNpmGlobalPackageVersion(platform2);
+  }
+  if (packageManager === "bun") {
+    return getBunGlobalPackageVersion(binDir);
+  }
+  return null;
+}
+function inspectPackageManager(packageManager, available, resolvedPaths, platform2) {
+  const binDir = available ? getExpectedGlobalBinDir(packageManager, { platform: platform2 }) : null;
+  return {
+    packageManager,
+    available,
+    installed: !!binDir && (hasBinaryOnDisk(binDir, platform2) || hasResolvedBinaryInDir(resolvedPaths, binDir)),
+    binDir
+  };
+}
+function getManagerBinDir(packageManager, available, platform2) {
+  return available ? getExpectedGlobalBinDir(packageManager, { platform: platform2 }) : null;
+}
+function getActivePackageManager(resolvedPath, managerBins) {
+  if (managerBins.bun && isPathInsideDir(resolvedPath, managerBins.bun)) {
+    return {
+      packageManager: "bun",
+      binDir: managerBins.bun
+    };
+  }
+  if (managerBins.npm && isPathInsideDir(resolvedPath, managerBins.npm)) {
+    return {
+      packageManager: "npm",
+      binDir: managerBins.npm
+    };
+  }
+  return {
+    packageManager: "unknown",
+    binDir: null
+  };
+}
+function getActiveResolutionWarning(resolvedPaths, active) {
+  if (!active.resolvedPath) {
+    return "⚠ ccstatusline is not currently resolvable on PATH. Claude Code runs ccstatusline, so restart your shell or update PATH if it cannot launch.";
+  }
+  const resolvedDirs = getUniqueResolvedDirs2(resolvedPaths);
+  if (resolvedDirs.length > 1) {
+    return `⚠ Multiple ccstatusline binaries are on PATH. Claude Code will run the first match: ${active.resolvedPath}.
+Other matches: ${formatPathList2(resolvedPaths.slice(1))}`;
+  }
+  if (active.packageManager === "unknown") {
+    return `⚠ ccstatusline resolves to ${active.resolvedPath}, but it is outside the detected npm and bun global bin directories.`;
+  }
+  return null;
+}
+function inspectActiveGlobalCommand({
+  commandAvailability,
+  platform: platform2 = process.platform
+}) {
+  const resolvedPaths = getPersistentCommandResolutionPaths(getCommandResolutionPaths("ccstatusline", { platform: platform2 }));
+  const resolvedPath = resolvedPaths[0] ?? null;
+  const managerBins = {
+    npm: getManagerBinDir("npm", commandAvailability.npm, platform2),
+    bun: getManagerBinDir("bun", commandAvailability.bun, platform2)
+  };
+  const active = resolvedPath ? getActivePackageManager(resolvedPath, managerBins) : { packageManager: "unknown", binDir: null };
+  return {
+    ...active,
+    resolvedPath,
+    resolvedPaths,
+    version: resolvedPath ? getGlobalPackageVersion(active.packageManager, active.binDir, platform2) : null,
+    warning: getActiveResolutionWarning(resolvedPaths, {
+      packageManager: active.packageManager,
+      resolvedPath
+    })
+  };
+}
+function inspectGlobalPackageInstallations({
+  commandAvailability,
+  platform: platform2 = process.platform
+}) {
+  const resolvedPaths = getPersistentCommandResolutionPaths(getCommandResolutionPaths("ccstatusline", { platform: platform2 }));
+  return [
+    inspectPackageManager("npm", commandAvailability.npm, resolvedPaths, platform2),
+    inspectPackageManager("bun", commandAvailability.bun, resolvedPaths, platform2)
+  ];
+}
+function runGlobalPackageUninstall(packageManager, { platform: platform2 = process.platform } = {}) {
+  const executable = getPackageManagerExecutable(packageManager, platform2);
+  const args = packageManager === "npm" ? ["uninstall", "-g", "ccstatusline"] : ["remove", "-g", "ccstatusline"];
+  return new Promise((resolve5, reject2) => {
+    execFile(executable, args, { timeout: GLOBAL_PACKAGE_TIMEOUT_MS }, (error48) => {
+      if (error48) {
+        reject2(error48 instanceof Error ? error48 : new Error("Global uninstall command failed"));
+        return;
+      }
+      resolve5();
+    });
+  });
+}
+
 // src/utils/open-url.ts
 import { spawnSync } from "child_process";
 import * as os10 from "os";
@@ -68589,9 +69089,9 @@ function openExternalUrl(url2) {
 
 // src/utils/powerline.ts
 import { execSync as execSync5 } from "child_process";
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as os11 from "os";
-import * as path9 from "path";
+import * as path10 from "path";
 var fontsInstalledThisSession = false;
 function checkPowerlineFonts() {
   if (process.env.DEBUG_FONT_INSTALL === "1" && !fontsInstalledThisSession) {
@@ -68611,20 +69111,20 @@ function checkPowerlineFonts() {
     let fontPaths = [];
     if (platform4 === "darwin") {
       fontPaths = [
-        path9.join(os11.homedir(), "Library", "Fonts"),
+        path10.join(os11.homedir(), "Library", "Fonts"),
         "/Library/Fonts",
         "/System/Library/Fonts"
       ];
     } else if (platform4 === "linux") {
       fontPaths = [
-        path9.join(os11.homedir(), ".local", "share", "fonts"),
-        path9.join(os11.homedir(), ".fonts"),
+        path10.join(os11.homedir(), ".local", "share", "fonts"),
+        path10.join(os11.homedir(), ".fonts"),
         "/usr/share/fonts",
         "/usr/local/share/fonts"
       ];
     } else if (platform4 === "win32") {
       fontPaths = [
-        path9.join(os11.homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts"),
+        path10.join(os11.homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts"),
         "C:\\Windows\\Fonts"
       ];
     }
@@ -68640,9 +69140,9 @@ function checkPowerlineFonts() {
       /fira.*code.*nerd/i
     ];
     for (const fontPath of fontPaths) {
-      if (fs12.existsSync(fontPath)) {
+      if (fs13.existsSync(fontPath)) {
         try {
-          const files = fs12.readdirSync(fontPath);
+          const files = fs13.readdirSync(fontPath);
           for (const file2 of files) {
             for (const pattern of powerlineFontPatterns) {
               if (pattern.test(file2)) {
@@ -68703,33 +69203,33 @@ async function installPowerlineFonts() {
     const platform4 = os11.platform();
     let fontDir;
     if (platform4 === "darwin") {
-      fontDir = path9.join(os11.homedir(), "Library", "Fonts");
+      fontDir = path10.join(os11.homedir(), "Library", "Fonts");
     } else if (platform4 === "linux") {
-      fontDir = path9.join(os11.homedir(), ".local", "share", "fonts");
+      fontDir = path10.join(os11.homedir(), ".local", "share", "fonts");
     } else if (platform4 === "win32") {
-      fontDir = path9.join(os11.homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts");
+      fontDir = path10.join(os11.homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts");
     } else {
       return {
         success: false,
         message: "Unsupported platform for font installation"
       };
     }
-    if (!fs12.existsSync(fontDir)) {
-      fs12.mkdirSync(fontDir, { recursive: true });
+    if (!fs13.existsSync(fontDir)) {
+      fs13.mkdirSync(fontDir, { recursive: true });
     }
-    const tempDir = path9.join(os11.tmpdir(), `ccstatusline-powerline-fonts-${Date.now()}`);
+    const tempDir = path10.join(os11.tmpdir(), `ccstatusline-powerline-fonts-${Date.now()}`);
     try {
-      if (fs12.existsSync(tempDir)) {
-        fs12.rmSync(tempDir, { recursive: true, force: true });
+      if (fs13.existsSync(tempDir)) {
+        fs13.rmSync(tempDir, { recursive: true, force: true });
       }
       execSync5(`git clone --depth=1 https://github.com/powerline/fonts.git "${tempDir}"`, {
         stdio: "pipe",
         encoding: "utf8"
       });
       if (platform4 === "darwin" || platform4 === "linux") {
-        const installScript = path9.join(tempDir, "install.sh");
-        if (fs12.existsSync(installScript)) {
-          fs12.chmodSync(installScript, 493);
+        const installScript = path10.join(tempDir, "install.sh");
+        if (fs13.existsSync(installScript)) {
+          fs13.chmodSync(installScript, 493);
           execSync5(`cd "${tempDir}" && ./install.sh`, {
             stdio: "pipe",
             encoding: "utf8",
@@ -68755,10 +69255,10 @@ async function installPowerlineFonts() {
         }
       } else {
         let findFontFiles = function(dir) {
-          const files = fs12.readdirSync(dir);
+          const files = fs13.readdirSync(dir);
           for (const file2 of files) {
-            const filePath = path9.join(dir, file2);
-            const stat2 = fs12.statSync(filePath);
+            const filePath = path10.join(dir, file2);
+            const stat2 = fs13.statSync(filePath);
             if (stat2.isDirectory() && !file2.startsWith(".")) {
               findFontFiles(filePath);
             } else if (file2.endsWith(".ttf") || file2.endsWith(".otf")) {
@@ -68772,10 +69272,10 @@ async function installPowerlineFonts() {
         findFontFiles(tempDir);
         let installedCount = 0;
         for (const fontFile of fontFiles) {
-          const fileName = path9.basename(fontFile);
-          const destPath = path9.join(fontDir, fileName);
+          const fileName = path10.basename(fontFile);
+          const destPath = path10.join(fontDir, fileName);
           try {
-            fs12.copyFileSync(fontFile, destPath);
+            fs13.copyFileSync(fontFile, destPath);
             installedCount++;
           } catch {}
         }
@@ -68793,9 +69293,9 @@ async function installPowerlineFonts() {
         message: "Platform-specific installation not implemented"
       };
     } finally {
-      if (fs12.existsSync(tempDir)) {
+      if (fs13.existsSync(tempDir)) {
         try {
-          fs12.rmSync(tempDir, { recursive: true, force: true });
+          fs13.rmSync(tempDir, { recursive: true, force: true });
         } catch {}
       }
     }
@@ -68817,6 +69317,204 @@ async function installPowerlineFonts() {
 // src/tui/App.tsx
 init_terminal();
 
+// src/utils/update-checker.ts
+await init_claude_settings();
+import { execFile as execFile2 } from "child_process";
+import * as https2 from "https";
+var NPM_REGISTRY_LATEST_URL = "https://registry.npmjs.org/ccstatusline/latest";
+var DEFAULT_REGISTRY_TIMEOUT_MS = 5000;
+var GLOBAL_UPDATE_TIMEOUT_MS = 120000;
+function parseVersion(version2) {
+  return version2.split(/[.-]/).map((part) => {
+    const parsed = parseInt(part, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+  });
+}
+function compareVersions(left, right) {
+  const leftParts = parseVersion(left);
+  const rightParts = parseVersion(right);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let i = 0;i < length; i += 1) {
+    const leftPart = leftParts[i] ?? 0;
+    const rightPart = rightParts[i] ?? 0;
+    if (leftPart > rightPart) {
+      return 1;
+    }
+    if (leftPart < rightPart) {
+      return -1;
+    }
+  }
+  return 0;
+}
+function getGlobalUpdateAction(packageManager, latestVersion, commandAvailability) {
+  if (packageManager === "npm") {
+    return {
+      id: "npm-global",
+      packageManager,
+      command: PINNED_INSTALL_COMMANDS.NPM(latestVersion),
+      version: latestVersion,
+      available: commandAvailability.npm
+    };
+  }
+  return {
+    id: "bun-global",
+    packageManager,
+    command: PINNED_INSTALL_COMMANDS.BUN(latestVersion),
+    version: latestVersion,
+    available: commandAvailability.bun
+  };
+}
+function getAutoUpdateLaunchCommand(installation) {
+  if (installation.method !== "auto-update") {
+    return;
+  }
+  return installation.packageManager === "bun" ? buildStatusLineCommand("auto-bunx") : buildStatusLineCommand("auto-npx");
+}
+function getUpdateActions(installation, latestVersion, commandAvailability) {
+  if (installation.method === "auto-update") {
+    return [];
+  }
+  if (installation.method === "pinned" || installation.method === "self-managed") {
+    if (installation.packageManager === "npm") {
+      return [getGlobalUpdateAction("npm", latestVersion, commandAvailability)];
+    }
+    if (installation.packageManager === "bun") {
+      return [getGlobalUpdateAction("bun", latestVersion, commandAvailability)];
+    }
+  }
+  return [
+    getGlobalUpdateAction("npm", latestVersion, commandAvailability),
+    getGlobalUpdateAction("bun", latestVersion, commandAvailability)
+  ];
+}
+function getResolvedInstallation(installedCommand, installationMetadata) {
+  const installation = classifyInstallation(installedCommand, installationMetadata);
+  if (installation.method === "self-managed" && installationMetadata?.method === "self-managed") {
+    return {
+      ...installation,
+      packageManager: installationMetadata.packageManager
+    };
+  }
+  if (installation.method !== "pinned") {
+    return installation;
+  }
+  return {
+    ...installation,
+    packageManager: installationMetadata?.method === "pinned" && "packageManager" in installationMetadata ? installationMetadata.packageManager : "unknown"
+  };
+}
+function buildUpdateCheckResult({
+  currentVersion,
+  latestVersion,
+  installedCommand,
+  installationMetadata,
+  commandAvailability
+}) {
+  const installation = getResolvedInstallation(installedCommand, installationMetadata);
+  if (compareVersions(latestVersion, currentVersion) <= 0) {
+    return {
+      status: "up-to-date",
+      currentVersion,
+      latestVersion,
+      installation
+    };
+  }
+  return {
+    status: "update-available",
+    currentVersion,
+    latestVersion,
+    installation,
+    actions: getUpdateActions(installation, latestVersion, commandAvailability),
+    autoUpdateLaunchCommand: getAutoUpdateLaunchCommand(installation)
+  };
+}
+function getErrorMessage(error48) {
+  if (error48 instanceof Error && error48.message) {
+    return error48.message;
+  }
+  return "Unable to query npm registry";
+}
+async function checkForUpdates({
+  currentVersion,
+  installedCommand,
+  installationMetadata,
+  commandAvailability,
+  timeoutMs = DEFAULT_REGISTRY_TIMEOUT_MS,
+  latestVersionFetcher = fetchLatestNpmVersion
+}) {
+  try {
+    const latestVersion = await latestVersionFetcher(timeoutMs);
+    return buildUpdateCheckResult({
+      currentVersion,
+      latestVersion,
+      installedCommand,
+      installationMetadata,
+      commandAvailability
+    });
+  } catch (error48) {
+    return {
+      status: "registry-failure",
+      currentVersion,
+      installation: getResolvedInstallation(installedCommand, installationMetadata),
+      errorMessage: getErrorMessage(error48)
+    };
+  }
+}
+function fetchLatestNpmVersion(timeoutMs = DEFAULT_REGISTRY_TIMEOUT_MS) {
+  return new Promise((resolve5, reject2) => {
+    const request3 = https2.request(NPM_REGISTRY_LATEST_URL, {
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "ccstatusline"
+      }
+    }, (response) => {
+      if (!response.statusCode || response.statusCode < 200 || response.statusCode >= 300) {
+        response.resume();
+        reject2(new Error(`npm registry returned HTTP ${response.statusCode ?? "unknown"}`));
+        return;
+      }
+      response.setEncoding("utf8");
+      let body = "";
+      response.on("data", (chunk2) => {
+        body += chunk2;
+      });
+      response.on("end", () => {
+        try {
+          const parsed = JSON.parse(body);
+          if (typeof parsed.version !== "string" || parsed.version.trim() === "") {
+            reject2(new Error("npm registry response did not include a version"));
+            return;
+          }
+          resolve5(parsed.version);
+        } catch (error48) {
+          reject2(error48 instanceof Error ? error48 : new Error(String(error48)));
+        }
+      });
+    });
+    request3.setTimeout(timeoutMs, () => {
+      request3.destroy(new Error(`npm registry request timed out after ${timeoutMs}ms`));
+    });
+    request3.on("error", reject2);
+    request3.end();
+  });
+}
+function runGlobalPackageInstall(packageManager, version2, { platform: platform4 = process.platform } = {}) {
+  const executable = getPackageManagerExecutable(packageManager, platform4);
+  const args = packageManager === "npm" ? ["install", "-g", `ccstatusline@${version2}`] : ["add", "-g", `ccstatusline@${version2}`];
+  return new Promise((resolve5, reject2) => {
+    execFile2(executable, args, { timeout: GLOBAL_UPDATE_TIMEOUT_MS }, (error48) => {
+      if (error48) {
+        reject2(error48 instanceof Error ? error48 : new Error("Global update command failed"));
+        return;
+      }
+      resolve5();
+    });
+  });
+}
+function runGlobalUpdateAction(action) {
+  return runGlobalPackageInstall(action.packageManager, action.version);
+}
+
 // src/tui/claude-status.ts
 await init_claude_settings();
 async function loadClaudeStatusLineState() {
@@ -70440,47 +71138,102 @@ await __promiseAll([
   init_build2(),
   init_claude_settings()
 ]);
+var import_react41 = __toESM(require_react(), 1);
 var jsx_dev_runtime14 = __toESM(require_jsx_dev_runtime(), 1);
+var AUTO_UPDATE_DESCRIPTION = "Runs `@latest` through npx/bunx. Stays current automatically, with a small startup cost when the package runner checks or resolves the package. Because it follows the latest published package, pinned install is available if you prefer explicit updates.";
+function getPinnedDescription(currentVersion) {
+  return `Installs \`ccstatusline@${currentVersion}\` globally and Claude Code runs \`ccstatusline\`. Fast per-render and only changes when you update.`;
+}
+function getStyleItems(currentVersion) {
+  return [
+    {
+      label: "Auto-update",
+      value: "auto-update",
+      description: AUTO_UPDATE_DESCRIPTION
+    },
+    {
+      label: "Pinned global install",
+      value: "pinned",
+      description: getPinnedDescription(currentVersion)
+    }
+  ];
+}
+function getManagerItems(updateStyle, commandAvailability, currentVersion) {
+  if (updateStyle === "auto-update") {
+    return [
+      {
+        label: CCSTATUSLINE_COMMANDS.AUTO_NPX,
+        value: "npm",
+        disabled: !commandAvailability.npx,
+        sublabel: commandAvailability.npx ? undefined : "(npx not installed)"
+      },
+      {
+        label: CCSTATUSLINE_COMMANDS.AUTO_BUNX,
+        value: "bun",
+        disabled: !commandAvailability.bunx,
+        sublabel: commandAvailability.bunx ? undefined : "(bunx not installed)"
+      }
+    ];
+  }
+  return [
+    {
+      label: PINNED_INSTALL_COMMANDS.NPM(currentVersion),
+      value: "npm",
+      disabled: !commandAvailability.npm,
+      sublabel: commandAvailability.npm ? undefined : "(npm not installed)"
+    },
+    {
+      label: PINNED_INSTALL_COMMANDS.BUN(currentVersion),
+      value: "bun",
+      disabled: !commandAvailability.bun,
+      sublabel: commandAvailability.bun ? undefined : "(bun not installed)"
+    }
+  ];
+}
+function buildSelection(updateStyle, packageManager, currentVersion) {
+  if (updateStyle === "auto-update") {
+    return {
+      updateStyle,
+      packageManager,
+      commandMode: packageManager === "bun" ? "auto-bunx" : "auto-npx",
+      displayedCommand: packageManager === "bun" ? CCSTATUSLINE_COMMANDS.AUTO_BUNX : CCSTATUSLINE_COMMANDS.AUTO_NPX,
+      metadata: {
+        method: "auto-update",
+        packageManager
+      }
+    };
+  }
+  return {
+    updateStyle,
+    packageManager,
+    commandMode: "global",
+    displayedCommand: packageManager === "bun" ? PINNED_INSTALL_COMMANDS.BUN(currentVersion) : PINNED_INSTALL_COMMANDS.NPM(currentVersion),
+    globalInstallCommand: packageManager === "bun" ? PINNED_INSTALL_COMMANDS.BUN(currentVersion) : PINNED_INSTALL_COMMANDS.NPM(currentVersion),
+    metadata: {
+      method: "pinned",
+      installedVersion: currentVersion
+    }
+  };
+}
 var InstallMenu = ({
-  bunxAvailable,
+  commandAvailability,
+  currentVersion,
   existingStatusLine,
-  onSelectNpx,
-  onSelectBunx,
+  onSelect,
   onCancel,
-  initialSelection = 0
+  initialPackageSelection = 0
 }) => {
+  const [step, setStep] = import_react41.useState("style");
+  const [updateStyle, setUpdateStyle] = import_react41.useState("auto-update");
   use_input_default((_, key) => {
     if (key.escape) {
+      if (step === "manager") {
+        setStep("style");
+        return;
+      }
       onCancel();
     }
   });
-  function onSelect(value) {
-    switch (value) {
-      case "npx":
-        onSelectNpx();
-        break;
-      case "bunx":
-        if (bunxAvailable) {
-          onSelectBunx();
-        }
-        break;
-      case "back":
-        onCancel();
-        break;
-    }
-  }
-  const listItems = [
-    {
-      label: "npx - Node Package Execute",
-      value: "npx"
-    },
-    {
-      label: "bunx - Bun Package Execute",
-      sublabel: bunxAvailable ? undefined : "(not installed)",
-      value: "bunx",
-      disabled: !bunxAvailable
-    }
-  ];
   return /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
@@ -70499,26 +71252,55 @@ var InstallMenu = ({
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
-        children: /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text, {
-          dimColor: true,
-          children: "Select package manager to use:"
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(List, {
-        color: "blue",
-        marginTop: 1,
-        items: listItems,
-        onSelect: (line) => {
-          if (line === "back") {
-            onCancel();
-            return;
-          }
-          onSelect(line);
-        },
-        initialSelection,
-        showBackButton: true
-      }, undefined, false, undefined, this),
+      step === "style" && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(jsx_dev_runtime14.Fragment, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
+            children: /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text, {
+              dimColor: true,
+              children: "Select update style:"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(List, {
+            color: "blue",
+            marginTop: 1,
+            items: getStyleItems(currentVersion),
+            onSelect: (value) => {
+              if (value === "back") {
+                onCancel();
+                return;
+              }
+              setUpdateStyle(value);
+              setStep("manager");
+            },
+            initialSelection: 0,
+            showBackButton: true
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      step === "manager" && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(jsx_dev_runtime14.Fragment, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
+            children: /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text, {
+              dimColor: true,
+              children: "Select package manager:"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(List, {
+            color: "blue",
+            marginTop: 1,
+            items: getManagerItems(updateStyle, commandAvailability, currentVersion),
+            onSelect: (value) => {
+              if (value === "back") {
+                setStep("style");
+                return;
+              }
+              onSelect(buildSelection(updateStyle, value, currentVersion));
+            },
+            initialSelection: initialPackageSelection,
+            showBackButton: true
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
         marginTop: 2,
         children: /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text, {
@@ -70534,7 +71316,7 @@ var InstallMenu = ({
         marginTop: 1,
         children: /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text, {
           dimColor: true,
-          children: "Press Enter to select, ESC to cancel"
+          children: "Press Enter to select, ESC to go back"
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this)
     ]
@@ -70547,7 +71329,7 @@ await __promiseAll([
   init_build2(),
   init_widgets2()
 ]);
-var import_react41 = __toESM(require_react(), 1);
+var import_react42 = __toESM(require_react(), 1);
 
 // src/tui/components/items-editor/input-handlers.ts
 await init_widgets2();
@@ -70889,11 +71671,11 @@ function handleNormalInputMode({
 // src/tui/components/ItemsEditor.tsx
 var jsx_dev_runtime15 = __toESM(require_jsx_dev_runtime(), 1);
 var ItemsEditor = ({ widgets, onUpdate, onBack, lineNumber, settings }) => {
-  const [selectedIndex, setSelectedIndex] = import_react41.useState(0);
-  const [moveMode, setMoveMode] = import_react41.useState(false);
-  const [customEditorWidget, setCustomEditorWidget] = import_react41.useState(null);
-  const [widgetPicker, setWidgetPicker] = import_react41.useState(null);
-  const [showClearConfirm, setShowClearConfirm] = import_react41.useState(false);
+  const [selectedIndex, setSelectedIndex] = import_react42.useState(0);
+  const [moveMode, setMoveMode] = import_react42.useState(false);
+  const [customEditorWidget, setCustomEditorWidget] = import_react42.useState(null);
+  const [widgetPicker, setWidgetPicker] = import_react42.useState(null);
+  const [showClearConfirm, setShowClearConfirm] = import_react42.useState(false);
   const separatorChars = ["|", "-", ",", " "];
   const widgetCatalog = getWidgetCatalog(settings);
   const widgetCategories = ["All", ...getWidgetCatalogCategories(widgetCatalog)];
@@ -71444,7 +72226,7 @@ var ItemsEditor = ({ widgets, onUpdate, onBack, lineNumber, settings }) => {
 // src/tui/components/LineSelector.tsx
 await init_build2();
 var import_pluralize = __toESM(require_pluralize(), 1);
-var import_react42 = __toESM(require_react(), 1);
+var import_react43 = __toESM(require_react(), 1);
 var jsx_dev_runtime16 = __toESM(require_jsx_dev_runtime(), 1);
 var LineSelector = ({
   lines,
@@ -71457,17 +72239,17 @@ var LineSelector = ({
   settings,
   allowEditing = false
 }) => {
-  const [selectedIndex, setSelectedIndex] = import_react42.useState(initialSelection);
-  const [showDeleteDialog, setShowDeleteDialog] = import_react42.useState(false);
-  const [moveMode, setMoveMode] = import_react42.useState(false);
-  const [localLines, setLocalLines] = import_react42.useState(lines);
-  import_react42.useEffect(() => {
+  const [selectedIndex, setSelectedIndex] = import_react43.useState(initialSelection);
+  const [showDeleteDialog, setShowDeleteDialog] = import_react43.useState(false);
+  const [moveMode, setMoveMode] = import_react43.useState(false);
+  const [localLines, setLocalLines] = import_react43.useState(lines);
+  import_react43.useEffect(() => {
     setLocalLines(lines);
   }, [lines]);
-  import_react42.useEffect(() => {
+  import_react43.useEffect(() => {
     setSelectedIndex(initialSelection);
   }, [initialSelection]);
-  const selectedLine = import_react42.useMemo(() => localLines[selectedIndex], [localLines, selectedIndex]);
+  const selectedLine = import_react43.useMemo(() => localLines[selectedIndex], [localLines, selectedIndex]);
   const appendLine = () => {
     const newLines = [...localLines, []];
     setLocalLines(newLines);
@@ -71740,15 +72522,31 @@ var LineSelector = ({
 // src/tui/components/MainMenu.tsx
 await init_build2();
 var jsx_dev_runtime17 = __toESM(require_jsx_dev_runtime(), 1);
-var MainMenu = ({
-  onSelect,
-  isClaudeInstalled,
-  hasChanges,
-  initialSelection = 0,
-  powerlineFontStatus,
-  settings,
-  previewIsTruncated
-}) => {
+function usesManageInstallation(installation) {
+  return installation?.method === "pinned" || installation?.method === "self-managed";
+}
+function getInstallationMenuItem(isClaudeInstalled, installation) {
+  if (!isClaudeInstalled) {
+    return {
+      label: "\uD83D\uDCE6 Install to Claude Code",
+      value: "install",
+      description: "Add ccstatusline to your Claude Code settings for automatic status line rendering"
+    };
+  }
+  if (usesManageInstallation(installation)) {
+    return {
+      label: "\uD83E\uDDF0 Manage Installation",
+      value: "manageInstallation",
+      description: "Check pinned global package updates or uninstall ccstatusline"
+    };
+  }
+  return {
+    label: "\uD83D\uDD0C Uninstall from Claude Code",
+    value: "install",
+    description: "Remove ccstatusline from your Claude Code settings"
+  };
+}
+function buildMainMenuItems(isClaudeInstalled, hasChanges, installation) {
   const menuItems = [
     {
       label: "\uD83D\uDCDD Edit Lines",
@@ -71776,28 +72574,18 @@ var MainMenu = ({
       value: "globalOverrides",
       description: "Set global padding, separators, and color overrides that apply to all widgets"
     },
+    {
+      label: "\uD83D\uDD27 Configure Status Line",
+      sublabel: isClaudeInstalled ? undefined : "(install first)",
+      disabled: !isClaudeInstalled,
+      value: "configureStatusLine",
+      description: "Configure Claude Code status line settings like refresh interval"
+    },
     "-",
-    ...isClaudeInstalled ? [
-      {
-        label: "\uD83D\uDD27 Configure Status Line",
-        value: "configureStatusLine",
-        description: "Configure Claude Code status line settings like refresh interval"
-      },
-      {
-        label: "\uD83D\uDD0C Uninstall from Claude Code",
-        value: "install",
-        description: "Remove ccstatusline from your Claude Code settings"
-      }
-    ] : [
-      {
-        label: "\uD83D\uDCE6 Install to Claude Code",
-        value: "install",
-        description: "Add ccstatusline to your Claude Code settings for automatic status line rendering"
-      }
-    ]
+    getInstallationMenuItem(isClaudeInstalled, installation)
   ];
   if (hasChanges) {
-    menuItems.push({
+    menuItems.push("-", {
       label: "\uD83D\uDCBE Save & Exit",
       value: "save",
       description: "Save all changes and exit the configuration tool"
@@ -71811,7 +72599,7 @@ var MainMenu = ({
       description: "Open the ccstatusline GitHub repository in your browser so you can star the project"
     });
   } else {
-    menuItems.push({
+    menuItems.push("-", {
       label: "\uD83D\uDEAA Exit",
       value: "exit",
       description: "Exit the configuration tool"
@@ -71821,6 +72609,38 @@ var MainMenu = ({
       description: "Open the ccstatusline GitHub repository in your browser so you can star the project"
     });
   }
+  return menuItems;
+}
+function getMainMenuSelectionIndex(items, option) {
+  let selectionIndex = 0;
+  for (const item of items) {
+    if (item === "-") {
+      continue;
+    }
+    if (item.value === option) {
+      return selectionIndex;
+    }
+    if (!item.disabled) {
+      selectionIndex += 1;
+    }
+  }
+  return 0;
+}
+function getMainMenuInstallSelectionIndex(isClaudeInstalled, installation) {
+  const option = isClaudeInstalled && usesManageInstallation(installation) ? "manageInstallation" : "install";
+  return getMainMenuSelectionIndex(buildMainMenuItems(isClaudeInstalled, false, installation), option);
+}
+var MainMenu = ({
+  onSelect,
+  isClaudeInstalled,
+  hasChanges,
+  initialSelection = 0,
+  powerlineFontStatus,
+  settings,
+  installation,
+  previewIsTruncated
+}) => {
+  const menuItems = buildMainMenuItems(isClaudeInstalled, hasChanges, installation);
   const showTruncationWarning = previewIsTruncated && settings?.flexMode === "full-minus-40";
   return /* @__PURE__ */ jsx_dev_runtime17.jsxDEV(Box_default, {
     flexDirection: "column",
@@ -71850,9 +72670,184 @@ var MainMenu = ({
     ]
   }, undefined, true, undefined, this);
 };
+// src/tui/components/ManageInstallationMenu.tsx
+await init_build2();
+var jsx_dev_runtime18 = __toESM(require_jsx_dev_runtime(), 1);
+function getInstallationLabel(installation) {
+  if (installation.method === "pinned") {
+    const version2 = installation.installedVersion ? ` ${installation.installedVersion}` : "";
+    const manager = installation.packageManager === "unknown" ? "" : ` via ${installation.packageManager}`;
+    return `Pinned global install${manager}${version2}`;
+  }
+  if (installation.method === "self-managed") {
+    return "Self-managed/global install";
+  }
+  if (installation.method === "auto-update") {
+    return `Auto-update via ${installation.packageManager}`;
+  }
+  return "Unknown installation";
+}
+function getActiveCommandLabel(activeCommand) {
+  if (!activeCommand?.resolvedPath) {
+    return null;
+  }
+  if (activeCommand.packageManager === "unknown") {
+    return `Active PATH match: ${activeCommand.resolvedPath}`;
+  }
+  const version2 = activeCommand.version ? ` ${activeCommand.version}` : "";
+  return `Active PATH match: ${activeCommand.packageManager} global${version2} (${activeCommand.resolvedPath})`;
+}
+function buildManageInstallationItems() {
+  return [
+    {
+      label: "\uD83D\uDD04 Check for Updates",
+      value: "checkUpdates",
+      description: "Check npm for the latest ccstatusline version and update the pinned global package"
+    },
+    {
+      label: "\uD83D\uDD0C Uninstall",
+      value: "uninstall",
+      description: "Remove ccstatusline from Claude Code settings, optionally removing global npm/bun packages"
+    }
+  ];
+}
+function formatPackageManagers(packageManagers) {
+  return packageManagers.join(" + ");
+}
+function buildUninstallItems(installations) {
+  const removableManagers = installations.filter((installation) => installation.installed && installation.available).map((installation) => installation.packageManager);
+  const items = [
+    {
+      label: "Remove from Claude Code settings only",
+      value: { packageManagers: [] },
+      description: "Leaves any global npm or bun ccstatusline packages installed"
+    }
+  ];
+  for (const packageManager of removableManagers) {
+    items.push({
+      label: `Remove Claude settings and ${packageManager} global package`,
+      value: { packageManagers: [packageManager] },
+      description: `Runs ${packageManager === "npm" ? "npm uninstall -g ccstatusline" : "bun remove -g ccstatusline"} after removing Claude Code settings`
+    });
+  }
+  if (removableManagers.length > 1) {
+    items.push({
+      label: `Remove Claude settings and ${formatPackageManagers(removableManagers)} global packages`,
+      value: { packageManagers: removableManagers },
+      description: "Removes every detected global ccstatusline package after removing Claude Code settings"
+    });
+  }
+  return items;
+}
+var ManageInstallationMenu = ({
+  installation,
+  activeCommand,
+  onSelect,
+  onBack
+}) => {
+  const activeCommandLabel = getActiveCommandLabel(activeCommand);
+  use_input_default((_, key) => {
+    if (key.escape) {
+      onBack();
+    }
+  });
+  return /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+        bold: true,
+        children: "Manage Installation"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          children: [
+            "Current:",
+            " ",
+            getInstallationLabel(installation)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      activeCommandLabel && /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+        children: /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          dimColor: true,
+          children: activeCommandLabel
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      activeCommand?.warning && /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          color: "yellow",
+          wrap: "wrap",
+          children: activeCommand.warning
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(List, {
+        marginTop: 1,
+        items: buildManageInstallationItems(),
+        onSelect: (value) => {
+          if (value === "back") {
+            onBack();
+            return;
+          }
+          onSelect(value);
+        },
+        showBackButton: true
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
+var UninstallMenu = ({
+  installations,
+  onSelect,
+  onBack
+}) => {
+  const items = buildUninstallItems(installations);
+  const detectedManagers = installations.filter((installation) => installation.installed && installation.available).map((installation) => installation.packageManager);
+  use_input_default((_, key) => {
+    if (key.escape) {
+      onBack();
+    }
+  });
+  return /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+        bold: true,
+        children: "Uninstall ccstatusline"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          dimColor: true,
+          children: "Choose what to remove from this machine."
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      detectedManagers.length === 0 && /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          dimColor: true,
+          children: "No global npm or bun ccstatusline package was detected."
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(List, {
+        marginTop: 1,
+        items,
+        onSelect: (value) => {
+          if (value === "back") {
+            onBack();
+            return;
+          }
+          onSelect(value);
+        },
+        showBackButton: true
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
 // src/tui/components/PowerlineSetup.tsx
 await init_build2();
-var import_react45 = __toESM(require_react(), 1);
+var import_react46 = __toESM(require_react(), 1);
 import * as os12 from "os";
 
 // src/utils/powerline-settings.ts
@@ -71883,8 +72878,8 @@ function buildEnabledPowerlineSettings(settings, removeManualSeparators) {
 // src/tui/components/PowerlineSeparatorEditor.tsx
 init_input_guards();
 await init_build2();
-var import_react43 = __toESM(require_react(), 1);
-var jsx_dev_runtime18 = __toESM(require_jsx_dev_runtime(), 1);
+var import_react44 = __toESM(require_react(), 1);
+var jsx_dev_runtime19 = __toESM(require_jsx_dev_runtime(), 1);
 var PowerlineSeparatorEditor = ({
   settings,
   mode,
@@ -71904,10 +72899,10 @@ var PowerlineSeparatorEditor = ({
   };
   const separators = getItems();
   const invertBgs = mode === "separator" ? powerlineConfig.separatorInvertBackground : [];
-  const [selectedIndex, setSelectedIndex] = import_react43.useState(0);
-  const [hexInputMode, setHexInputMode] = import_react43.useState(false);
-  const [hexInput, setHexInput] = import_react43.useState("");
-  const [cursorPos, setCursorPos] = import_react43.useState(0);
+  const [selectedIndex, setSelectedIndex] = import_react44.useState(0);
+  const [hexInputMode, setHexInputMode] = import_react44.useState(false);
+  const [hexInput, setHexInput] = import_react44.useState("");
+  const [cursorPos, setCursorPos] = import_react44.useState(0);
   const getPresets = () => {
     if (mode === "separator") {
       return [
@@ -72099,18 +73094,18 @@ var PowerlineSeparatorEditor = ({
     }
   };
   const canDelete = mode !== "separator" || separators.length > 1;
-  return /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
         bold: true,
         children: getTitle()
       }, undefined, false, undefined, this),
-      hexInputMode ? /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+      hexInputMode ? /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
         marginTop: 2,
         flexDirection: "column",
         children: [
-          /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
             children: [
               "Enter hex code (4-6 digits) for",
               " ",
@@ -72119,51 +73114,51 @@ var PowerlineSeparatorEditor = ({
               ":"
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
             children: [
               "U+",
               hexInput.slice(0, cursorPos),
-              /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
                 backgroundColor: "gray",
                 color: "black",
                 children: hexInput[cursorPos] ?? "_"
               }, undefined, false, undefined, this),
               hexInput.slice(cursorPos + 1),
-              hexInput.length < 6 && hexInput.length === cursorPos && /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+              hexInput.length < 6 && hexInput.length === cursorPos && /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
                 dimColor: true,
                 children: "_".repeat(6 - hexInput.length - 1)
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
             dimColor: true,
             children: "Enter 4-6 hex digits (0-9, A-F) for a Unicode code point, then press Enter. ESC to cancel."
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
             dimColor: true,
             children: "Examples: E0B0 (powerline), 1F984 (\uD83E\uDD84), 2764 (❤)"
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(jsx_dev_runtime18.Fragment, {
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(jsx_dev_runtime19.Fragment, {
         children: [
-          /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
-            children: /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+            children: /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
               dimColor: true,
               children: `↑↓ select, ← → cycle, (a)dd, (i)nsert${canDelete ? ", (d)elete" : ""}, (c)lear, (h)ex${mode === "separator" ? ", (t)oggle invert" : ""}, ESC back`
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
             marginTop: 2,
             flexDirection: "column",
-            children: separators.length > 0 ? separators.map((sep2, index) => /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Box_default, {
-              children: /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+            children: separators.length > 0 ? separators.map((sep2, index) => /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+              children: /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
                 color: index === selectedIndex ? "green" : undefined,
                 children: [
                   index === selectedIndex ? "▶  " : "   ",
                   `${index + 1}: ${getSeparatorDisplay(sep2, index)}`
                 ]
               }, undefined, true, undefined, this)
-            }, index, false, undefined, this)) : /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+            }, index, false, undefined, this)) : /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
               dimColor: true,
               children: "(none configured - press 'a' to add)"
             }, undefined, false, undefined, this)
@@ -72178,8 +73173,8 @@ var PowerlineSeparatorEditor = ({
 init_ColorLevel();
 init_colors();
 await init_build2();
-var import_react44 = __toESM(require_react(), 1);
-var jsx_dev_runtime19 = __toESM(require_jsx_dev_runtime(), 1);
+var import_react45 = __toESM(require_react(), 1);
+var jsx_dev_runtime20 = __toESM(require_jsx_dev_runtime(), 1);
 function buildPowerlineThemeItems(themes, originalTheme) {
   return themes.map((themeName) => {
     const theme = getPowerlineTheme(themeName);
@@ -72232,20 +73227,20 @@ var PowerlineThemeSelector = ({
   onUpdate,
   onBack
 }) => {
-  const themes = import_react44.useMemo(() => getPowerlineThemes(), []);
+  const themes = import_react45.useMemo(() => getPowerlineThemes(), []);
   const currentTheme = settings.powerline.theme ?? "custom";
-  const [selectedIndex, setSelectedIndex] = import_react44.useState(Math.max(0, themes.indexOf(currentTheme)));
-  const [showCustomizeConfirm, setShowCustomizeConfirm] = import_react44.useState(false);
-  const originalThemeRef = import_react44.useRef(currentTheme);
-  const originalSettingsRef = import_react44.useRef(settings);
-  const latestSettingsRef = import_react44.useRef(settings);
-  const latestOnUpdateRef = import_react44.useRef(onUpdate);
-  const didHandleInitialSelectionRef = import_react44.useRef(false);
-  import_react44.useEffect(() => {
+  const [selectedIndex, setSelectedIndex] = import_react45.useState(Math.max(0, themes.indexOf(currentTheme)));
+  const [showCustomizeConfirm, setShowCustomizeConfirm] = import_react45.useState(false);
+  const originalThemeRef = import_react45.useRef(currentTheme);
+  const originalSettingsRef = import_react45.useRef(settings);
+  const latestSettingsRef = import_react45.useRef(settings);
+  const latestOnUpdateRef = import_react45.useRef(onUpdate);
+  const didHandleInitialSelectionRef = import_react45.useRef(false);
+  import_react45.useEffect(() => {
     latestSettingsRef.current = settings;
     latestOnUpdateRef.current = onUpdate;
   }, [settings, onUpdate]);
-  import_react44.useEffect(() => {
+  import_react45.useEffect(() => {
     const themeName = themes[selectedIndex];
     if (!themeName) {
       return;
@@ -72277,41 +73272,41 @@ var PowerlineThemeSelector = ({
     }
   });
   const selectedThemeName = themes[selectedIndex];
-  const themeItems = import_react44.useMemo(() => buildPowerlineThemeItems(themes, originalThemeRef.current), [themes]);
+  const themeItems = import_react45.useMemo(() => buildPowerlineThemeItems(themes, originalThemeRef.current), [themes]);
   if (showCustomizeConfirm) {
-    return /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
       flexDirection: "column",
       children: [
-        /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+        /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
           bold: true,
           color: "yellow",
           children: "⚠ Confirm Customization"
         }, undefined, false, undefined, this),
-        /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+        /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
           marginTop: 1,
           flexDirection: "column",
           children: [
-            /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+            /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
               children: "This will copy the current theme colors to your widgets"
             }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+            /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
               children: "and switch to Custom theme mode."
             }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+            /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
               color: "red",
               children: "This will overwrite any existing custom colors!"
             }, undefined, false, undefined, this)
           ]
         }, undefined, true, undefined, this),
-        /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+        /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
           marginTop: 2,
-          children: /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+          children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
             children: "Continue?"
           }, undefined, false, undefined, this)
         }, undefined, false, undefined, this),
-        /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+        /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
           marginTop: 1,
-          children: /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(ConfirmDialog, {
+          children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(ConfirmDialog, {
             inline: true,
             onConfirm: () => {
               if (selectedThemeName) {
@@ -72331,26 +73326,26 @@ var PowerlineThemeSelector = ({
       ]
     }, undefined, true, undefined, this);
   }
-  return /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
         bold: true,
         children: [
           `Powerline Theme Selection  |  `,
-          /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
             dimColor: true,
             children: `Original: ${originalThemeRef.current}`
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
-        children: /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+        children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
           dimColor: true,
           children: `↑↓ navigate, Enter apply${selectedThemeName && selectedThemeName !== "custom" ? ", (c)ustomize theme" : ""}, ESC cancel`
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(List, {
+      /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(List, {
         marginTop: 1,
         items: themeItems,
         onSelect: () => {
@@ -72364,16 +73359,16 @@ var PowerlineThemeSelector = ({
         },
         initialSelection: selectedIndex
       }, undefined, false, undefined, this),
-      selectedThemeName && selectedThemeName !== "custom" && /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+      selectedThemeName && selectedThemeName !== "custom" && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
         marginTop: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
           dimColor: true,
           children: "Press (c) to customize this theme - copies colors to widgets"
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
-      settings.colorLevel === 1 && /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Box_default, {
+      settings.colorLevel === 1 && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
         marginTop: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
           color: "yellow",
           children: "⚠ 16 color mode themes have a very limited palette, we recommend switching color level in Terminal Options"
         }, undefined, false, undefined, this)
@@ -72383,7 +73378,7 @@ var PowerlineThemeSelector = ({
 };
 
 // src/tui/components/PowerlineSetup.tsx
-var jsx_dev_runtime20 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime21 = __toESM(require_jsx_dev_runtime(), 1);
 var POWERLINE_MENU_LABEL_WIDTH = 11;
 function formatPowerlineMenuLabel(label) {
   return label.padEnd(POWERLINE_MENU_LABEL_WIDTH, " ");
@@ -72486,10 +73481,10 @@ var PowerlineSetup = ({
   onClearMessage
 }) => {
   const powerlineConfig = settings.powerline;
-  const [screen, setScreen] = import_react45.useState("menu");
-  const [selectedMenuItem, setSelectedMenuItem] = import_react45.useState(0);
-  const [confirmingEnable, setConfirmingEnable] = import_react45.useState(false);
-  const [confirmingFontInstall, setConfirmingFontInstall] = import_react45.useState(false);
+  const [screen, setScreen] = import_react46.useState("menu");
+  const [selectedMenuItem, setSelectedMenuItem] = import_react46.useState(0);
+  const [confirmingEnable, setConfirmingEnable] = import_react46.useState(false);
+  const [confirmingFontInstall, setConfirmingFontInstall] = import_react46.useState(false);
   const hasSeparatorItems = settings.lines.some((line) => line.some((item) => item.type === "separator" || item.type === "flex-separator"));
   use_input_default((input, key) => {
     if (fontInstallMessage || installingFonts) {
@@ -72542,7 +73537,7 @@ var PowerlineSetup = ({
     }
   });
   if (screen === "separator") {
-    return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(PowerlineSeparatorEditor, {
+    return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(PowerlineSeparatorEditor, {
       settings,
       mode: "separator",
       onUpdate,
@@ -72552,7 +73547,7 @@ var PowerlineSetup = ({
     }, undefined, false, undefined, this);
   }
   if (screen === "startCap") {
-    return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(PowerlineSeparatorEditor, {
+    return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(PowerlineSeparatorEditor, {
       settings,
       mode: "startCap",
       onUpdate,
@@ -72562,7 +73557,7 @@ var PowerlineSetup = ({
     }, undefined, false, undefined, this);
   }
   if (screen === "endCap") {
-    return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(PowerlineSeparatorEditor, {
+    return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(PowerlineSeparatorEditor, {
       settings,
       mode: "endCap",
       onUpdate,
@@ -72572,7 +73567,7 @@ var PowerlineSetup = ({
     }, undefined, false, undefined, this);
   }
   if (screen === "themes") {
-    return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(PowerlineThemeSelector, {
+    return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(PowerlineThemeSelector, {
       settings,
       onUpdate,
       onBack: () => {
@@ -72580,140 +73575,140 @@ var PowerlineSetup = ({
       }
     }, undefined, false, undefined, this);
   }
-  return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      !confirmingFontInstall && !installingFonts && !fontInstallMessage && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+      !confirmingFontInstall && !installingFonts && !fontInstallMessage && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
         bold: true,
         children: "Powerline Setup"
       }, undefined, false, undefined, this),
-      confirmingFontInstall ? /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+      confirmingFontInstall ? /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
         flexDirection: "column",
         children: [
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginBottom: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+            children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
               color: "cyan",
               bold: true,
               children: "Font Installation"
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginBottom: 1,
             flexDirection: "column",
             children: [
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 bold: true,
                 children: "What will happen:"
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 children: [
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "• Clone fonts from "
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     color: "blue",
                     children: "https://github.com/powerline/fonts"
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "darwin" && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(jsx_dev_runtime20.Fragment, {
+              os12.platform() === "darwin" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
                 children: [
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "• Run install.sh script which will:"
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "  - Copy all .ttf/.otf files to ~/Library/Fonts"
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "  - Register fonts with macOS"
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "linux" && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(jsx_dev_runtime20.Fragment, {
+              os12.platform() === "linux" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
                 children: [
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "• Run install.sh script which will:"
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "  - Copy all .ttf/.otf files to ~/.local/share/fonts"
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "  - Run fc-cache to update font cache"
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "win32" && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(jsx_dev_runtime20.Fragment, {
+              os12.platform() === "win32" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
                 children: [
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "• Copy Powerline .ttf/.otf files to:"
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "  AppData\\Local\\Microsoft\\Windows\\Fonts"
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 dimColor: true,
                 children: "• Clean up temporary files"
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginBottom: 1,
             children: [
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 color: "yellow",
                 bold: true,
                 children: "Requirements: "
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 dimColor: true,
                 children: "Git installed, Internet connection, Write permissions"
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginBottom: 1,
             flexDirection: "column",
             children: [
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 color: "green",
                 bold: true,
                 children: "After install:"
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 dimColor: true,
                 children: "• Restart terminal"
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 dimColor: true,
                 children: "• Select a Powerline font"
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 dimColor: true,
                 children: '  (e.g. "Meslo LG S for Powerline")'
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+            children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
               children: "Proceed? "
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(ConfirmDialog, {
+            children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(ConfirmDialog, {
               inline: true,
               onConfirm: () => {
                 setConfirmingFontInstall(false);
@@ -72725,36 +73720,36 @@ var PowerlineSetup = ({
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this) : confirmingEnable ? /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+      }, undefined, true, undefined, this) : confirmingEnable ? /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
         flexDirection: "column",
         marginTop: 1,
         children: [
-          hasSeparatorItems && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(jsx_dev_runtime20.Fragment, {
+          hasSeparatorItems && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
             children: [
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
-                children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
+                children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                   color: "yellow",
                   children: "⚠ Warning: Enabling Powerline mode will remove all existing separators and flex-separators from your status lines."
                 }, undefined, false, undefined, this)
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
                 marginBottom: 1,
-                children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                   dimColor: true,
                   children: "Powerline mode uses its own separator system and is incompatible with manual separators."
                 }, undefined, false, undefined, this)
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginTop: hasSeparatorItems ? 1 : 0,
-            children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+            children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
               children: "Do you want to continue? "
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(ConfirmDialog, {
+            children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(ConfirmDialog, {
               inline: true,
               onConfirm: () => {
                 onUpdate(buildEnabledPowerlineSettings(settings, true));
@@ -72766,51 +73761,51 @@ var PowerlineSetup = ({
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this) : installingFonts ? /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
-        children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+      }, undefined, true, undefined, this) : installingFonts ? /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
+        children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
           color: "yellow",
           children: "Installing Powerline fonts... This may take a moment."
         }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this) : fontInstallMessage ? /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+      }, undefined, false, undefined, this) : fontInstallMessage ? /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
         flexDirection: "column",
         children: [
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
             color: fontInstallMessage.includes("success") ? "green" : "red",
             children: fontInstallMessage
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+            children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
               dimColor: true,
               children: "Press any key to continue..."
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(jsx_dev_runtime20.Fragment, {
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
         children: [
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             flexDirection: "column",
-            children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+            children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
               children: [
                 "    Font Status: ",
-                powerlineFontStatus.installed ? /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(jsx_dev_runtime20.Fragment, {
+                powerlineFontStatus.installed ? /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
                   children: [
-                    /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                    /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                       color: "green",
                       children: "✓ Installed"
                     }, undefined, false, undefined, this),
-                    /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                    /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                       dimColor: true,
                       children: " - Ensure fonts are active in your terminal"
                     }, undefined, false, undefined, this)
                   ]
-                }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(jsx_dev_runtime20.Fragment, {
+                }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
                   children: [
-                    /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                    /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                       color: "yellow",
                       children: "✗ Not Installed"
                     }, undefined, false, undefined, this),
-                    /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                    /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                       dimColor: true,
                       children: " - Press (i) to install Powerline fonts"
                     }, undefined, false, undefined, this)
@@ -72819,62 +73814,62 @@ var PowerlineSetup = ({
               ]
             }, undefined, true, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             children: [
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 children: " Powerline Mode: "
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 color: powerlineConfig.enabled ? "green" : "red",
                 children: powerlineConfig.enabled ? "✓ Enabled  " : "✗ Disabled "
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                 dimColor: true,
                 children: " - Press (t) to toggle"
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          powerlineConfig.enabled && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(jsx_dev_runtime20.Fragment, {
+          powerlineConfig.enabled && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
             children: [
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
                 children: [
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     children: "  Align Widgets: "
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     color: powerlineConfig.autoAlign ? "green" : "red",
                     children: powerlineConfig.autoAlign ? "✓ Enabled  " : "✗ Disabled "
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: " - Press (a) to toggle"
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
                 children: [
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     children: " Continue Theme: "
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     color: powerlineConfig.continueThemeAcrossLines ? "green" : "red",
                     children: powerlineConfig.continueThemeAcrossLines ? "✓ Enabled  " : "✗ Disabled "
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: " - Press (c) to toggle"
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+              /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
                 flexDirection: "column",
                 marginTop: 1,
                 children: [
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "When enabled, global overrides are disabled and powerline separators are used"
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+                  /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
                     children: "Continue Theme keeps the Powerline color sequence running across lines"
                   }, undefined, false, undefined, this)
@@ -72882,14 +73877,14 @@ var PowerlineSetup = ({
               }, undefined, true, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          !powerlineConfig.enabled && /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Box_default, {
+          !powerlineConfig.enabled && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
             marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(Text, {
+            children: /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
               dimColor: true,
               children: "Enable Powerline mode to configure separators, caps, and themes."
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime20.jsxDEV(List, {
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(List, {
             marginTop: 1,
             items: buildPowerlineSetupMenuItems(powerlineConfig),
             onSelect: (value) => {
@@ -72913,8 +73908,8 @@ var PowerlineSetup = ({
 // src/tui/components/RefreshIntervalMenu.tsx
 init_input_guards();
 await init_build2();
-var import_react46 = __toESM(require_react(), 1);
-var jsx_dev_runtime21 = __toESM(require_jsx_dev_runtime(), 1);
+var import_react47 = __toESM(require_react(), 1);
+var jsx_dev_runtime22 = __toESM(require_jsx_dev_runtime(), 1);
 function getRefreshInputValue(interval) {
   return interval === null ? "" : String(interval);
 }
@@ -72960,9 +73955,9 @@ var RefreshIntervalMenu = ({
   onUpdate,
   onBack
 }) => {
-  const [editingRefreshInterval, setEditingRefreshInterval] = import_react46.useState(false);
-  const [refreshInput, setRefreshInput] = import_react46.useState(() => getRefreshInputValue(currentInterval));
-  const [validationError, setValidationError] = import_react46.useState(null);
+  const [editingRefreshInterval, setEditingRefreshInterval] = import_react47.useState(false);
+  const [refreshInput, setRefreshInput] = import_react47.useState(() => getRefreshInputValue(currentInterval));
+  const [validationError, setValidationError] = import_react47.useState(null);
   use_input_default((input, key) => {
     if (editingRefreshInterval) {
       if (key.return) {
@@ -73001,22 +73996,22 @@ var RefreshIntervalMenu = ({
       onBack();
     }
   });
-  return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
         bold: true,
         children: "Configure Status Line"
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
         color: "white",
         children: "Configure Claude Code status line settings"
       }, undefined, false, undefined, this),
-      editingRefreshInterval ? /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
+      editingRefreshInterval ? /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
         marginTop: 1,
         flexDirection: "column",
         children: [
-          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
             children: [
               "Enter refresh interval in seconds (1-60):",
               " ",
@@ -73024,15 +74019,15 @@ var RefreshIntervalMenu = ({
               refreshInput.length > 0 ? "s" : ""
             ]
           }, undefined, true, undefined, this),
-          validationError ? /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
+          validationError ? /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
             color: "red",
             children: validationError
-          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
             dimColor: true,
             children: "Press Enter to confirm, ESC to cancel. Leave empty to remove."
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(List, {
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(List, {
         marginTop: 1,
         items: buildConfigureStatusLineItems(currentInterval, supportsRefreshInterval),
         onSelect: (value) => {
@@ -73052,7 +74047,7 @@ var RefreshIntervalMenu = ({
 init_source();
 init_ansi();
 await init_build2();
-var import_react47 = __toESM(require_react(), 1);
+var import_react48 = __toESM(require_react(), 1);
 
 // src/utils/powerline-theme-index.ts
 function countPowerlineThemeSlots(entries) {
@@ -73086,7 +74081,7 @@ function advanceGlobalSeparatorIndex(currentIndex, widgets) {
 }
 
 // src/tui/components/StatusLinePreview.tsx
-var jsx_dev_runtime22 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime23 = __toESM(require_jsx_dev_runtime(), 1);
 var renderSingleLine = (widgets, terminalWidth, settings, lineIndex, globalSeparatorIndex, globalPowerlineThemeIndex, preRenderedWidgets, preCalculatedMaxWidths) => {
   const context = {
     terminalWidth,
@@ -73105,7 +74100,7 @@ function preparePreviewLineForTerminal(line, terminalWidth) {
   return truncateStyledText(printableLine, availableWidth, { ellipsis: true });
 }
 var StatusLinePreview = ({ lines, terminalWidth, settings, onTruncationChange }) => {
-  const { renderedLines, anyTruncated } = import_react47.default.useMemo(() => {
+  const { renderedLines, anyTruncated } = import_react48.default.useMemo(() => {
     if (!settings)
       return { renderedLines: [], anyTruncated: false };
     const preRenderedLines = preRenderAllWidgets(lines, settings, { terminalWidth, isPreview: true, minimalist: settings.minimalistMode });
@@ -73131,29 +74126,29 @@ var StatusLinePreview = ({ lines, terminalWidth, settings, onTruncationChange })
     }
     return { renderedLines: result2, anyTruncated: truncated };
   }, [lines, terminalWidth, settings]);
-  import_react47.default.useEffect(() => {
+  import_react48.default.useEffect(() => {
     onTruncationChange?.(anyTruncated);
   }, [anyTruncated, onTruncationChange]);
-  return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
         borderStyle: "round",
         borderColor: "gray",
         borderDimColor: true,
         width: "100%",
         paddingLeft: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
           children: [
             ">",
-            /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
               dimColor: true,
               children: " Preview  (ctrl+s to save configuration at any time)"
             }, undefined, false, undefined, this)
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      renderedLines.map((line, index) => /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+      renderedLines.map((line, index) => /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
         wrap: "truncate",
         children: [
           PREVIEW_LINE_INDENT,
@@ -73167,7 +74162,7 @@ var StatusLinePreview = ({ lines, terminalWidth, settings, onTruncationChange })
 // src/tui/components/TerminalOptionsMenu.tsx
 init_source();
 await init_build2();
-var import_react48 = __toESM(require_react(), 1);
+var import_react49 = __toESM(require_react(), 1);
 
 // src/utils/color-sanitize.ts
 await init_widgets2();
@@ -73222,7 +74217,7 @@ function sanitizeLinesForColorLevel(lines, nextLevel) {
 }
 
 // src/tui/components/TerminalOptionsMenu.tsx
-var jsx_dev_runtime23 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime24 = __toESM(require_jsx_dev_runtime(), 1);
 function getNextColorLevel(level) {
   return (level + 1) % 4;
 }
@@ -73256,8 +74251,8 @@ var TerminalOptionsMenu = ({
   onUpdate,
   onBack
 }) => {
-  const [showColorWarning, setShowColorWarning] = import_react48.useState(false);
-  const [pendingColorLevel, setPendingColorLevel] = import_react48.useState(null);
+  const [showColorWarning, setShowColorWarning] = import_react49.useState(false);
+  const [pendingColorLevel, setPendingColorLevel] = import_react49.useState(null);
   const handleSelect = (value) => {
     if (value === "back") {
       onBack();
@@ -73305,27 +74300,27 @@ var TerminalOptionsMenu = ({
       onBack();
     }
   });
-  return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
         bold: true,
         children: "Terminal Options"
       }, undefined, false, undefined, this),
-      showColorWarning ? /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+      showColorWarning ? /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
         flexDirection: "column",
         marginTop: 1,
         children: [
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
             color: "yellow",
             children: "⚠ Warning: Custom colors detected!"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
             children: "Switching color modes will reset custom ansi256 or hex colors to defaults."
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
             marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(ConfirmDialog, {
+            children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ConfirmDialog, {
               message: "Continue?",
               onConfirm: handleColorConfirm,
               onCancel: handleColorCancel,
@@ -73333,13 +74328,13 @@ var TerminalOptionsMenu = ({
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(jsx_dev_runtime23.Fragment, {
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(jsx_dev_runtime24.Fragment, {
         children: [
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
             color: "white",
             children: "Configure terminal-specific settings for optimal display"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(List, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(List, {
             marginTop: 1,
             items: buildTerminalOptionsItems(settings.colorLevel),
             onSelect: handleSelect,
@@ -73368,8 +74363,8 @@ var getColorLevelLabel = (level) => {
 // src/tui/components/TerminalWidthMenu.tsx
 init_input_guards();
 await init_build2();
-var import_react49 = __toESM(require_react(), 1);
-var jsx_dev_runtime24 = __toESM(require_jsx_dev_runtime(), 1);
+var import_react50 = __toESM(require_react(), 1);
+var jsx_dev_runtime25 = __toESM(require_jsx_dev_runtime(), 1);
 var TERMINAL_WIDTH_OPTIONS = ["full", "full-minus-40", "full-until-compact"];
 function getTerminalWidthSelectionIndex(selectedOption) {
   const selectedIndex = TERMINAL_WIDTH_OPTIONS.indexOf(selectedOption);
@@ -73416,11 +74411,11 @@ var TerminalWidthMenu = ({
   onUpdate,
   onBack
 }) => {
-  const [selectedOption, setSelectedOption] = import_react49.useState(settings.flexMode);
-  const [compactThreshold, setCompactThreshold] = import_react49.useState(settings.compactThreshold);
-  const [editingThreshold, setEditingThreshold] = import_react49.useState(false);
-  const [thresholdInput, setThresholdInput] = import_react49.useState(String(settings.compactThreshold));
-  const [validationError, setValidationError] = import_react49.useState(null);
+  const [selectedOption, setSelectedOption] = import_react50.useState(settings.flexMode);
+  const [compactThreshold, setCompactThreshold] = import_react50.useState(settings.compactThreshold);
+  const [editingThreshold, setEditingThreshold] = import_react50.useState(false);
+  const [thresholdInput, setThresholdInput] = import_react50.useState(String(settings.compactThreshold));
+  const [validationError, setValidationError] = import_react50.useState(null);
   use_input_default((input, key) => {
     if (editingThreshold) {
       if (key.return) {
@@ -73459,27 +74454,27 @@ var TerminalWidthMenu = ({
       onBack();
     }
   });
-  return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
         bold: true,
         children: "Terminal Width"
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
         color: "white",
         children: "These settings affect where long lines are truncated, and where right-alignment occurs when using flex separators"
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
         dimColor: true,
         wrap: "wrap",
         children: "Claude code does not currently provide an available width variable for the statusline and features like IDE integration, auto-compaction notices, etc all cause the statusline to wrap if we do not truncate it"
       }, undefined, false, undefined, this),
-      editingThreshold ? /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
+      editingThreshold ? /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
         marginTop: 1,
         flexDirection: "column",
         children: [
-          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
             children: [
               "Enter compact threshold (1-99):",
               " ",
@@ -73487,15 +74482,15 @@ var TerminalWidthMenu = ({
               "%"
             ]
           }, undefined, true, undefined, this),
-          validationError ? /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
+          validationError ? /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
             color: "red",
             children: validationError
-          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text, {
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
             dimColor: true,
             children: "Press Enter to confirm, ESC to cancel"
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(List, {
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(List, {
         marginTop: 1,
         items: buildTerminalWidthItems(selectedOption, compactThreshold),
         initialSelection: getTerminalWidthSelectionIndex(selectedOption),
@@ -73520,50 +74515,487 @@ var TerminalWidthMenu = ({
     ]
   }, undefined, true, undefined, this);
 };
+// src/tui/components/UpdateCheckerMenu.tsx
+await init_build2();
+var jsx_dev_runtime26 = __toESM(require_jsx_dev_runtime(), 1);
+function getInstallationLabel2(result2) {
+  const { installation } = result2;
+  if (installation.method === "auto-update") {
+    return `Auto-update via ${installation.packageManager}`;
+  }
+  if (installation.method === "pinned") {
+    const version2 = installation.installedVersion ? ` ${installation.installedVersion}` : "";
+    const manager = installation.packageManager === "unknown" ? "" : ` via ${installation.packageManager}`;
+    return `Pinned global install${manager}${version2}`;
+  }
+  if (installation.method === "self-managed") {
+    return "Self-managed/global install";
+  }
+  return "Unknown or not installed";
+}
+function getActionLabel(action) {
+  return `Run ${action.command}`;
+}
+function getActionSublabel(action) {
+  if (action.available) {
+    return;
+  }
+  return action.packageManager === "npm" ? "(npm not installed)" : "(bun not installed)";
+}
+function getActionItems(actions) {
+  return [
+    ...actions.map((action) => ({
+      label: getActionLabel(action),
+      value: action,
+      disabled: !action.available,
+      sublabel: getActionSublabel(action)
+    })),
+    {
+      label: "Check again",
+      value: "refresh"
+    }
+  ];
+}
+var UpdateCheckerMenu = ({
+  state,
+  onBack,
+  onRefresh,
+  onRunAction
+}) => {
+  use_input_default((_, key) => {
+    if (key.escape) {
+      onBack();
+    }
+  });
+  if (state.status === "checking") {
+    return /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Box_default, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+          bold: true,
+          children: "Check for Updates"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Box_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+            dimColor: true,
+            children: "Checking npm registry..."
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Box_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+        bold: true,
+        children: "Check for Updates"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Box_default, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+            children: [
+              "Current:",
+              " ",
+              state.currentVersion
+            ]
+          }, undefined, true, undefined, this),
+          state.status !== "registry-failure" && /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+            children: [
+              "Latest:",
+              " ",
+              state.latestVersion
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+            children: [
+              "Install:",
+              " ",
+              getInstallationLabel2(state)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      state.status === "registry-failure" && /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(jsx_dev_runtime26.Fragment, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Box_default, {
+            marginTop: 1,
+            children: /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+              color: "red",
+              children: [
+                "Registry check failed:",
+                " ",
+                state.errorMessage
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(List, {
+            marginTop: 1,
+            items: [{ label: "Check again", value: "refresh" }],
+            onSelect: (value) => {
+              if (value === "back") {
+                onBack();
+                return;
+              }
+              onRefresh();
+            },
+            showBackButton: true
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      state.status === "up-to-date" && /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(jsx_dev_runtime26.Fragment, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Box_default, {
+            marginTop: 1,
+            children: /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+              color: "green",
+              children: "ccstatusline is up to date."
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(List, {
+            marginTop: 1,
+            items: [{ label: "Check again", value: "refresh" }],
+            onSelect: (value) => {
+              if (value === "back") {
+                onBack();
+                return;
+              }
+              onRefresh();
+            },
+            showBackButton: true
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      state.status === "update-available" && /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(jsx_dev_runtime26.Fragment, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Box_default, {
+            marginTop: 1,
+            children: /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+              color: "yellow",
+              children: "An update is available."
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          state.installation.method === "auto-update" && /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Box_default, {
+            marginTop: 1,
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+                children: "No manual hook change is needed. Claude Code already runs @latest."
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+                children: "The next @latest invocation will resolve the latest package."
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(Text, {
+                children: [
+                  "Launch command for a fresh TUI:",
+                  " ",
+                  state.autoUpdateLaunchCommand
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          state.actions.length > 0 && /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(List, {
+            marginTop: 1,
+            items: getActionItems(state.actions),
+            onSelect: (value) => {
+              if (value === "back") {
+                onBack();
+                return;
+              }
+              if (value === "refresh") {
+                onRefresh();
+                return;
+              }
+              onRunAction(value);
+            },
+            showBackButton: true
+          }, undefined, false, undefined, this),
+          state.actions.length === 0 && /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(List, {
+            marginTop: 1,
+            items: [{ label: "Check again", value: "refresh" }],
+            onSelect: (value) => {
+              if (value === "back") {
+                onBack();
+                return;
+              }
+              onRefresh();
+            },
+            showBackButton: true
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
 // src/tui/App.tsx
-var jsx_dev_runtime25 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime27 = __toESM(require_jsx_dev_runtime(), 1);
 var GITHUB_REPO_URL = "https://github.com/sirmalloc/ccstatusline";
+var NOTICE_ITEMS = [
+  {
+    label: "Continue",
+    value: "continue"
+  }
+];
+var FlowNotice = ({
+  title,
+  message,
+  color,
+  onContinue
+}) => {
+  use_input_default((_, key) => {
+    if (key.escape) {
+      onContinue();
+    }
+  });
+  return /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+        bold: true,
+        children: title
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+          color,
+          wrap: "wrap",
+          children: message
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(List, {
+        marginTop: 1,
+        items: NOTICE_ITEMS,
+        onSelect: () => {
+          onContinue();
+        },
+        color: "cyan"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
+function getPinnedMismatchItems(mismatch, canRunPackageManager) {
+  const items = [];
+  if (mismatch.canUpdateToRunningVersion) {
+    items.push({
+      label: `Update ${mismatch.packageManager} global install to v${mismatch.runningVersion}`,
+      value: "update",
+      disabled: !canRunPackageManager,
+      sublabel: canRunPackageManager ? undefined : `(${mismatch.packageManager} not installed)`,
+      description: `Runs ${mismatch.packageManager === "npm" ? `npm install -g ccstatusline@${mismatch.runningVersion}` : `bun add -g ccstatusline@${mismatch.runningVersion}`}`
+    });
+  }
+  items.push({
+    label: "Exit",
+    value: "exit",
+    description: `Relaunch manually with ${mismatch.relaunchCommand}`
+  });
+  return items;
+}
+var PinnedVersionMismatchScreen = ({
+  mismatch,
+  canRunPackageManager,
+  onUpdate,
+  onExit
+}) => {
+  use_input_default((_, key) => {
+    if (key.escape) {
+      onExit();
+    }
+  });
+  return /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+        bold: true,
+        children: "Pinned Install Version Mismatch"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+            color: "yellow",
+            children: [
+              "Claude Code is pinned to ccstatusline v",
+              mismatch.installedVersion,
+              ", but this TUI is v",
+              mismatch.runningVersion,
+              "."
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+            dimColor: true,
+            wrap: "wrap",
+            children: "To avoid writing config that the pinned runtime may not support, update the pinned global install or exit and relaunch the pinned version."
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+          children: [
+            "Current pinned version:",
+            " ",
+            mismatch.relaunchCommand
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(List, {
+        marginTop: 1,
+        items: getPinnedMismatchItems(mismatch, canRunPackageManager),
+        onSelect: (value) => {
+          if (value === "back") {
+            return;
+          }
+          if (value === "update") {
+            onUpdate();
+            return;
+          }
+          onExit();
+        },
+        color: "cyan"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
+function getGlobalUninstallCommand(packageManager) {
+  return packageManager === "npm" ? "npm uninstall -g ccstatusline" : "bun remove -g ccstatusline";
+}
+function buildUninstallConfirmMessage(selection) {
+  if (selection.packageManagers.length === 0) {
+    return `This will remove ccstatusline from ${getClaudeSettingsPath()}. Continue?`;
+  }
+  const commands = selection.packageManagers.map((packageManager) => getGlobalUninstallCommand(packageManager)).join(`
+`);
+  return `This will remove ccstatusline from ${getClaudeSettingsPath()} and run:
+
+${commands}
+
+Continue?`;
+}
+function clearInstallationMetadata(settings) {
+  if (!settings) {
+    return settings;
+  }
+  const { installation, ...next } = settings;
+  return next;
+}
+function getCurrentInstallation(isClaudeInstalled, existingStatusLine, settings) {
+  return isClaudeInstalled && !existingStatusLine && settings.installation ? settings.installation : classifyInstallation(existingStatusLine, settings.installation);
+}
+function trimTrailingSeparators2(filePath) {
+  return filePath.replace(/[\\/]+$/, "");
+}
+function joinCommandPath(dir, command) {
+  const separator = dir.includes("\\") && !dir.includes("/") ? "\\" : "/";
+  return `${trimTrailingSeparators2(dir)}${separator}${command}`;
+}
+function getCommandFileName(globalBinDir, platform5) {
+  if (platform5 === "win32" || /^[a-z]:[\\/]/i.test(globalBinDir)) {
+    return "ccstatusline.cmd";
+  }
+  return "ccstatusline";
+}
+function getPinnedGlobalRelaunchCommand(packageManager) {
+  const resolution = inspectGlobalCommandResolution(packageManager);
+  if (resolution.firstResolvedPath && (!resolution.expectedBinDir || isPathInsideDir(resolution.firstResolvedPath, resolution.expectedBinDir))) {
+    return resolution.firstResolvedPath;
+  }
+  if (resolution.expectedBinDir) {
+    return joinCommandPath(resolution.expectedBinDir, getCommandFileName(resolution.expectedBinDir, process.platform));
+  }
+  return "ccstatusline";
+}
+function getPinnedVersionMismatch(installation, runningVersion, relaunchCommand) {
+  if (installation.method !== "pinned" || !installation.installedVersion || installation.packageManager === "unknown" || !runningVersion || installation.installedVersion === runningVersion) {
+    return null;
+  }
+  return {
+    packageManager: installation.packageManager,
+    installedVersion: installation.installedVersion,
+    runningVersion,
+    relaunchCommand,
+    canUpdateToRunningVersion: compareVersions(runningVersion, installation.installedVersion) > 0
+  };
+}
+function getPathInferredInstallation(installation, activeCommand) {
+  if (installation.method === "pinned") {
+    return {
+      ...installation,
+      packageManager: activeCommand?.packageManager ?? "unknown",
+      installedVersion: activeCommand?.version ?? installation.installedVersion
+    };
+  }
+  if (activeCommand && activeCommand.packageManager !== "unknown" && installation.method === "self-managed") {
+    return {
+      ...installation,
+      packageManager: activeCommand.packageManager
+    };
+  }
+  return installation;
+}
 function getConfirmCancelScreen(confirmDialog) {
   return confirmDialog?.cancelScreen ?? "main";
 }
 function clearInstallMenuSelection(menuSelections) {
-  if (menuSelections.install === undefined) {
+  if (menuSelections.install === undefined && menuSelections.installPackage === undefined) {
     return menuSelections;
   }
   const next = { ...menuSelections };
   delete next.install;
+  delete next.installPackage;
   return next;
 }
 var App2 = () => {
   const { exit } = use_app_default();
-  const [settings, setSettings] = import_react50.useState(null);
-  const [originalSettings, setOriginalSettings] = import_react50.useState(null);
-  const [hasChanges, setHasChanges] = import_react50.useState(false);
-  const [screen, setScreen] = import_react50.useState("main");
-  const [selectedLine, setSelectedLine] = import_react50.useState(0);
-  const [menuSelections, setMenuSelections] = import_react50.useState({});
-  const [confirmDialog, setConfirmDialog] = import_react50.useState(null);
-  const [isClaudeInstalled, setIsClaudeInstalled] = import_react50.useState(false);
-  const [terminalWidth, setTerminalWidth] = import_react50.useState(process.stdout.columns || 80);
-  const [powerlineFontStatus, setPowerlineFontStatus] = import_react50.useState({ installed: false });
-  const [installingFonts, setInstallingFonts] = import_react50.useState(false);
-  const [fontInstallMessage, setFontInstallMessage] = import_react50.useState(null);
-  const [existingStatusLine, setExistingStatusLine] = import_react50.useState(null);
-  const [flashMessage, setFlashMessage] = import_react50.useState(null);
-  const [previewIsTruncated, setPreviewIsTruncated] = import_react50.useState(false);
-  const [currentRefreshInterval, setCurrentRefreshInterval] = import_react50.useState(null);
-  const [supportsRefreshInterval] = import_react50.useState(() => isClaudeCodeVersionAtLeast("2.1.97"));
-  import_react50.useEffect(() => {
+  const [settings, setSettings] = import_react51.useState(null);
+  const [originalSettings, setOriginalSettings] = import_react51.useState(null);
+  const [hasChanges, setHasChanges] = import_react51.useState(false);
+  const [screen, setScreen] = import_react51.useState("main");
+  const [selectedLine, setSelectedLine] = import_react51.useState(0);
+  const [menuSelections, setMenuSelections] = import_react51.useState({});
+  const [confirmDialog, setConfirmDialog] = import_react51.useState(null);
+  const [isClaudeInstalled, setIsClaudeInstalled] = import_react51.useState(false);
+  const [terminalWidth, setTerminalWidth] = import_react51.useState(process.stdout.columns || 80);
+  const [powerlineFontStatus, setPowerlineFontStatus] = import_react51.useState({ installed: false });
+  const [installingFonts, setInstallingFonts] = import_react51.useState(false);
+  const [fontInstallMessage, setFontInstallMessage] = import_react51.useState(null);
+  const [existingStatusLine, setExistingStatusLine] = import_react51.useState(null);
+  const [flashMessage, setFlashMessage] = import_react51.useState(null);
+  const [previewIsTruncated, setPreviewIsTruncated] = import_react51.useState(false);
+  const [currentRefreshInterval, setCurrentRefreshInterval] = import_react51.useState(null);
+  const [supportsRefreshInterval] = import_react51.useState(() => isClaudeCodeVersionAtLeast("2.1.97"));
+  const [commandAvailability] = import_react51.useState(() => getPackageCommandAvailability());
+  const [updateCheckerState, setUpdateCheckerState] = import_react51.useState({ status: "checking" });
+  const [flowNotice, setFlowNotice] = import_react51.useState(null);
+  const [globalPackageInstallations, setGlobalPackageInstallations] = import_react51.useState([]);
+  const [updatesReturnScreen, setUpdatesReturnScreen] = import_react51.useState("main");
+  const [hasLoadedClaudeStatus, setHasLoadedClaudeStatus] = import_react51.useState(false);
+  const [hasLoadedInstalledState, setHasLoadedInstalledState] = import_react51.useState(false);
+  import_react51.useEffect(() => {
     loadClaudeStatusLineState().then((statusLineState) => {
       setExistingStatusLine(statusLineState.existingStatusLine);
       setCurrentRefreshInterval(statusLineState.refreshInterval);
+    }).catch(() => {
+      setExistingStatusLine(null);
+      setCurrentRefreshInterval(null);
+    }).finally(() => {
+      setHasLoadedClaudeStatus(true);
     });
     loadSettings().then((loadedSettings) => {
       source_default.level = loadedSettings.colorLevel;
       setSettings(loadedSettings);
       setOriginalSettings(cloneSettings(loadedSettings));
     });
-    isInstalled().then(setIsClaudeInstalled);
+    isInstalled().then(setIsClaudeInstalled).catch(() => {
+      setIsClaudeInstalled(false);
+    }).finally(() => {
+      setHasLoadedInstalledState(true);
+    });
     const fontStatus = checkPowerlineFonts();
     setPowerlineFontStatus(fontStatus);
     checkPowerlineFontsAsync().then((asyncStatus) => {
@@ -73577,13 +75009,13 @@ var App2 = () => {
       process.stdout.off("resize", handleResize);
     };
   }, []);
-  import_react50.useEffect(() => {
+  import_react51.useEffect(() => {
     if (originalSettings) {
       const hasAnyChanges = JSON.stringify(settings) !== JSON.stringify(originalSettings);
       setHasChanges(hasAnyChanges);
     }
   }, [settings, originalSettings]);
-  import_react50.useEffect(() => {
+  import_react51.useEffect(() => {
     if (flashMessage) {
       const timer = setTimeout(() => {
         setFlashMessage(null);
@@ -73598,6 +75030,13 @@ var App2 = () => {
       exit();
     }
     if (key.ctrl && input === "s" && settings) {
+      const installation = getCurrentInstallation(isClaudeInstalled, existingStatusLine, settings);
+      const activeCommand = installation.method === "pinned" || installation.method === "self-managed" ? inspectActiveGlobalCommand({ commandAvailability }) : null;
+      const effectiveInstallation2 = getPathInferredInstallation(installation, activeCommand);
+      const mismatch = getPinnedVersionMismatch(effectiveInstallation2, getPackageVersion(), "ccstatusline");
+      if (mismatch) {
+        return;
+      }
       (async () => {
         await saveSettings(settings);
         setOriginalSettings(cloneSettings(settings));
@@ -73609,73 +75048,276 @@ var App2 = () => {
       })();
     }
   });
-  const handleInstallSelection = import_react50.useCallback((command, displayName, useBunx) => {
+  const getGlobalResolutionWarning = import_react51.useCallback((packageManager) => inspectGlobalCommandResolution(packageManager).warning, []);
+  const handleInstallSelection = import_react51.useCallback((selection) => {
     getExistingStatusLine().then((existing) => {
       const isAlreadyInstalled = isKnownCommand(existing ?? "");
-      let message;
+      const finalCommand = buildStatusLineCommand(selection.commandMode);
+      const hookCommand = `${finalCommand} --hook`;
+      const sideEffects = [
+        `Claude settings path: ${getClaudeSettingsPath()}`,
+        ...selection.globalInstallCommand ? [`Global install command before settings write: ${selection.globalInstallCommand}`] : [],
+        `Final statusLine.command: ${finalCommand}`,
+        `Hook command behavior: hook-enabled widgets run ${hookCommand}`
+      ];
+      let message = sideEffects.join(`
+`);
       if (existing && !isAlreadyInstalled) {
-        message = `This will modify ${getClaudeSettingsPath()}
+        message = `A status line is already configured: "${existing}"
 
-A status line is already configured: "${existing}"
-Replace it with ${command}?`;
+${message}
+
+Replace it?`;
       } else if (isAlreadyInstalled) {
-        message = `ccstatusline is already installed in ${getClaudeSettingsPath()}
-Update it with ${command}?`;
+        message = `ccstatusline is already installed.
+
+${message}
+
+Update it?`;
       } else {
-        message = `This will modify ${getClaudeSettingsPath()} to add ccstatusline with ${displayName}.
+        message = `${message}
+
 Continue?`;
       }
       setConfirmDialog({
         message,
         cancelScreen: "install",
         action: async () => {
-          await installStatusLine(useBunx, supportsRefreshInterval);
-          const installedStatusLineState = await loadClaudeStatusLineState();
-          setIsClaudeInstalled(true);
-          setExistingStatusLine(installedStatusLineState.existingStatusLine ?? command);
-          setCurrentRefreshInterval(installedStatusLineState.refreshInterval);
-          setScreen("main");
+          try {
+            if (selection.globalInstallCommand) {
+              await runGlobalPackageInstall(selection.packageManager, getPackageVersion());
+            }
+            await installStatusLine({
+              commandMode: selection.commandMode,
+              supportsRefreshInterval,
+              installationMetadata: selection.metadata
+            });
+            const installedStatusLineState = await loadClaudeStatusLineState();
+            setIsClaudeInstalled(true);
+            setExistingStatusLine(installedStatusLineState.existingStatusLine ?? finalCommand);
+            setCurrentRefreshInterval(installedStatusLineState.refreshInterval);
+            setSettings((prev) => prev ? { ...prev, installation: selection.metadata } : prev);
+            setOriginalSettings((prev) => prev ? { ...prev, installation: selection.metadata } : prev);
+            setMenuSelections((prev) => ({
+              ...prev,
+              main: getMainMenuInstallSelectionIndex(true, selection.metadata)
+            }));
+            const resolutionWarning = selection.globalInstallCommand ? getGlobalResolutionWarning(selection.packageManager) : null;
+            if (resolutionWarning) {
+              setFlashMessage(null);
+              setFlowNotice({
+                title: "Install Complete",
+                message: `Installed to Claude Code.
+
+${resolutionWarning}`,
+                color: "yellow",
+                continueScreen: "main"
+              });
+              setScreen("flowNotice");
+            } else {
+              setScreen("main");
+              setFlashMessage({
+                text: "✓ Installed to Claude Code",
+                color: "green"
+              });
+            }
+          } catch {
+            setFlashMessage({
+              text: "✗ Install failed",
+              color: "red"
+            });
+            setScreen("install");
+          }
           setConfirmDialog(null);
         }
       });
       setScreen("confirm");
     });
-  }, [supportsRefreshInterval]);
-  const handleNpxInstall = import_react50.useCallback(() => {
-    setMenuSelections((prev) => ({ ...prev, install: 0 }));
-    handleInstallSelection(CCSTATUSLINE_COMMANDS.NPM, "npx", false);
-  }, [handleInstallSelection]);
-  const handleBunxInstall = import_react50.useCallback(() => {
-    setMenuSelections((prev) => ({ ...prev, install: 1 }));
-    handleInstallSelection(CCSTATUSLINE_COMMANDS.BUNX, "bunx", true);
-  }, [handleInstallSelection]);
-  const handleInstallMenuCancel = import_react50.useCallback(() => {
+  }, [getGlobalResolutionWarning, supportsRefreshInterval]);
+  const handleInstallMenuCancel = import_react51.useCallback(() => {
     setMenuSelections(clearInstallMenuSelection);
     setScreen("main");
   }, []);
-  if (!settings) {
-    return /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
+  const handleUpdateCheck = import_react51.useCallback(() => {
+    setUpdateCheckerState({ status: "checking" });
+    const installation = settings ? getCurrentInstallation(isClaudeInstalled, existingStatusLine, settings) : classifyInstallation(existingStatusLine, undefined);
+    const activeCommand = installation.method === "pinned" || installation.method === "self-managed" ? inspectActiveGlobalCommand({ commandAvailability }) : null;
+    const effectiveUpdateInstallation = getPathInferredInstallation(installation, activeCommand);
+    const currentUpdateVersion = effectiveUpdateInstallation.method === "pinned" && effectiveUpdateInstallation.installedVersion ? effectiveUpdateInstallation.installedVersion : getPackageVersion();
+    checkForUpdates({
+      currentVersion: currentUpdateVersion,
+      installedCommand: existingStatusLine,
+      installationMetadata: effectiveUpdateInstallation,
+      commandAvailability
+    }).then(setUpdateCheckerState);
+  }, [commandAvailability, existingStatusLine, isClaudeInstalled, settings]);
+  const handleRunUpdateAction = import_react51.useCallback((action) => {
+    setConfirmDialog({
+      message: `Run global update command?
+
+${action.command}
+
+Claude settings will not be changed.`,
+      cancelScreen: "updates",
+      action: async () => {
+        try {
+          await runGlobalUpdateAction(action);
+          const installation = {
+            method: "pinned",
+            installedVersion: action.version
+          };
+          await saveInstallationMetadata(installation);
+          setSettings((prev) => prev ? { ...prev, installation } : prev);
+          setOriginalSettings((prev) => prev ? { ...prev, installation } : prev);
+          const resolutionWarning = getGlobalResolutionWarning(action.packageManager);
+          if (resolutionWarning) {
+            setFlashMessage(null);
+            setFlowNotice({
+              title: "Update Complete",
+              message: `Global package updated.
+
+${resolutionWarning}`,
+              color: "yellow",
+              continueScreen: "updates"
+            });
+            setScreen("flowNotice");
+          } else {
+            setFlashMessage({
+              text: "✓ Global package updated",
+              color: "green"
+            });
+            setScreen("updates");
+          }
+        } catch {
+          setFlashMessage({
+            text: "✗ Global update failed",
+            color: "red"
+          });
+          setScreen("updates");
+        }
+        setConfirmDialog(null);
+      }
+    });
+    setScreen("confirm");
+  }, [getGlobalResolutionWarning]);
+  if (!settings || !hasLoadedClaudeStatus || !hasLoadedInstalledState) {
+    return /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
       children: "Loading settings..."
     }, undefined, false, undefined, this);
   }
-  const handleInstallUninstall = () => {
-    if (isClaudeInstalled) {
-      setConfirmDialog({
-        message: `This will remove ccstatusline from ${getClaudeSettingsPath()}. Continue?`,
-        action: async () => {
+  const runningVersion = getPackageVersion();
+  const currentInstallation = getCurrentInstallation(isClaudeInstalled, existingStatusLine, settings);
+  const activeGlobalCommand = currentInstallation.method === "pinned" || currentInstallation.method === "self-managed" ? inspectActiveGlobalCommand({ commandAvailability }) : null;
+  const effectiveInstallation = getPathInferredInstallation(currentInstallation, activeGlobalCommand);
+  const pinnedVersionMismatch = effectiveInstallation.method === "pinned" && effectiveInstallation.packageManager !== "unknown" ? getPinnedVersionMismatch(effectiveInstallation, runningVersion, getPinnedGlobalRelaunchCommand(effectiveInstallation.packageManager)) : null;
+  const handlePinnedVersionMismatchUpdate = async (mismatch) => {
+    try {
+      await runGlobalPackageInstall(mismatch.packageManager, mismatch.runningVersion);
+      const installation = {
+        method: "pinned",
+        installedVersion: mismatch.runningVersion
+      };
+      await saveInstallationMetadata(installation);
+      setSettings((prev) => prev ? { ...prev, installation } : prev);
+      setOriginalSettings((prev) => prev ? { ...prev, installation } : prev);
+      const resolutionWarning = getGlobalResolutionWarning(mismatch.packageManager);
+      if (resolutionWarning) {
+        setFlashMessage(null);
+        setFlowNotice({
+          title: "Update Complete",
+          message: `Global package updated.
+
+${resolutionWarning}`,
+          color: "yellow",
+          continueScreen: "main"
+        });
+        setScreen("flowNotice");
+      } else {
+        setFlashMessage({
+          text: "✓ Global package updated",
+          color: "green"
+        });
+        setScreen("main");
+      }
+    } catch {
+      setFlashMessage({
+        text: "✗ Global update failed",
+        color: "red"
+      });
+    }
+  };
+  const handleUninstallSelection = (selection, cancelScreen) => {
+    setConfirmDialog({
+      message: buildUninstallConfirmMessage(selection),
+      cancelScreen,
+      action: async () => {
+        let removedClaudeSettings = false;
+        try {
           await uninstallStatusLine();
+          removedClaudeSettings = true;
+          for (const packageManager of selection.packageManagers) {
+            await runGlobalPackageUninstall(packageManager);
+          }
           setIsClaudeInstalled(false);
           setExistingStatusLine(null);
           setCurrentRefreshInterval(null);
+          setSettings(clearInstallationMetadata);
+          setOriginalSettings(clearInstallationMetadata);
+          setMenuSelections((prev) => ({
+            ...prev,
+            main: getMainMenuInstallSelectionIndex(false)
+          }));
+          setFlashMessage({
+            text: selection.packageManagers.length > 0 ? "✓ Uninstalled from Claude Code and removed global package" : "✓ Uninstalled from Claude Code",
+            color: "green"
+          });
           setScreen("main");
-          setConfirmDialog(null);
+        } catch {
+          if (removedClaudeSettings) {
+            setIsClaudeInstalled(false);
+            setExistingStatusLine(null);
+            setCurrentRefreshInterval(null);
+            setSettings(clearInstallationMetadata);
+            setOriginalSettings(clearInstallationMetadata);
+            setMenuSelections((prev) => ({
+              ...prev,
+              main: getMainMenuInstallSelectionIndex(false)
+            }));
+            setFlashMessage({
+              text: "✗ Removed Claude settings, but global package removal failed",
+              color: "red"
+            });
+            setScreen("main");
+          } else {
+            setFlashMessage({
+              text: "✗ Uninstall failed",
+              color: "red"
+            });
+            setScreen(cancelScreen);
+          }
         }
-      });
-      setScreen("confirm");
+        setConfirmDialog(null);
+      }
+    });
+    setScreen("confirm");
+  };
+  const handleInstallUninstall = () => {
+    if (isClaudeInstalled) {
+      handleUninstallSelection({ packageManagers: [] }, "main");
     } else {
       setScreen("install");
     }
   };
+  const handleManageInstallationSelect = (action) => {
+    if (action === "checkUpdates") {
+      setUpdatesReturnScreen("manageInstallation");
+      setScreen("updates");
+      handleUpdateCheck();
+      return;
+    }
+    setGlobalPackageInstallations(inspectGlobalPackageInstallations({ commandAvailability }));
+    setScreen("uninstallOptions");
+  };
   const handleMainMenuSelect = async (value) => {
     switch (value) {
       case "lines":
@@ -73696,6 +75338,14 @@ Continue?`;
       case "install":
         handleInstallUninstall();
         break;
+      case "manageInstallation":
+        setScreen("manageInstallation");
+        break;
+      case "checkUpdates":
+        setUpdatesReturnScreen("main");
+        setScreen("updates");
+        handleUpdateCheck();
+        break;
       case "configureStatusLine":
         setScreen("refreshInterval");
         break;
@@ -73735,6 +75385,42 @@ ${GITHUB_REPO_URL}`,
         break;
     }
   };
+  if (pinnedVersionMismatch) {
+    return /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
+          marginBottom: 1,
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+              bold: true,
+              children: /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(dist_default5, {
+                name: "retro",
+                children: "CCStatusline Configuration"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+              bold: true,
+              children: ` | ${runningVersion && `v${runningVersion}`}`
+            }, undefined, false, undefined, this),
+            flashMessage && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
+              color: flashMessage.color,
+              bold: true,
+              children: `  ${flashMessage.text}`
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(PinnedVersionMismatchScreen, {
+          mismatch: pinnedVersionMismatch,
+          canRunPackageManager: commandAvailability[pinnedVersionMismatch.packageManager],
+          onUpdate: () => {
+            handlePinnedVersionMismatchUpdate(pinnedVersionMismatch);
+          },
+          onExit: exit
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
   const updateLine = (lineIndex, widgets) => {
     const newLines = [...settings.lines];
     newLines[lineIndex] = widgets;
@@ -73747,44 +75433,44 @@ ${GITHUB_REPO_URL}`,
     setSelectedLine(lineIndex);
     setScreen("items");
   };
-  return /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
         marginBottom: 1,
         children: [
-          /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
             bold: true,
-            children: /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(dist_default5, {
+            children: /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(dist_default5, {
               name: "retro",
               children: "CCStatusline Configuration"
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
             bold: true,
-            children: ` | ${getPackageVersion() && `v${getPackageVersion()}`}`
+            children: ` | ${runningVersion && `v${runningVersion}`}`
           }, undefined, false, undefined, this),
-          flashMessage && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
+          flashMessage && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
             color: flashMessage.color,
             bold: true,
             children: `  ${flashMessage.text}`
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      isCustomConfigPath() && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text, {
+      isCustomConfigPath() && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Text, {
         dimColor: true,
         children: `Config: ${getConfigPath()}`
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(StatusLinePreview, {
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(StatusLinePreview, {
         lines: settings.lines,
         terminalWidth,
         settings,
         onTruncationChange: setPreviewIsTruncated
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(Box_default, {
         marginTop: 1,
         children: [
-          screen === "main" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(MainMenu, {
+          screen === "main" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(MainMenu, {
             onSelect: (value, index) => {
               if (value !== "save" && value !== "exit") {
                 setMenuSelections((prev) => ({ ...prev, main: index }));
@@ -73796,9 +75482,10 @@ ${GITHUB_REPO_URL}`,
             initialSelection: menuSelections.main,
             powerlineFontStatus,
             settings,
+            installation: effectiveInstallation,
             previewIsTruncated
           }, undefined, false, undefined, this),
-          screen === "lines" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(LineSelector, {
+          screen === "lines" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(LineSelector, {
             lines: settings.lines,
             onSelect: (line) => {
               setMenuSelections((prev) => ({ ...prev, lines: line }));
@@ -73813,7 +75500,7 @@ ${GITHUB_REPO_URL}`,
             title: "Select Line to Edit Items",
             allowEditing: true
           }, undefined, false, undefined, this),
-          screen === "items" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(ItemsEditor, {
+          screen === "items" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(ItemsEditor, {
             widgets: settings.lines[selectedLine] ?? [],
             onUpdate: (widgets) => {
               updateLine(selectedLine, widgets);
@@ -73825,7 +75512,7 @@ ${GITHUB_REPO_URL}`,
             lineNumber: selectedLine + 1,
             settings
           }, undefined, false, undefined, this),
-          screen === "colorLines" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(LineSelector, {
+          screen === "colorLines" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(LineSelector, {
             lines: settings.lines,
             onLinesUpdate: updateLines,
             onSelect: (line) => {
@@ -73843,7 +75530,7 @@ ${GITHUB_REPO_URL}`,
             settings,
             allowEditing: false
           }, undefined, false, undefined, this),
-          screen === "colors" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(ColorMenu, {
+          screen === "colors" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(ColorMenu, {
             widgets: settings.lines[selectedLine] ?? [],
             lineIndex: selectedLine,
             settings,
@@ -73856,7 +75543,7 @@ ${GITHUB_REPO_URL}`,
               setScreen("colorLines");
             }
           }, undefined, false, undefined, this),
-          screen === "terminalConfig" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(TerminalOptionsMenu, {
+          screen === "terminalConfig" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(TerminalOptionsMenu, {
             settings,
             onUpdate: (updatedSettings) => {
               setSettings(updatedSettings);
@@ -73870,7 +75557,7 @@ ${GITHUB_REPO_URL}`,
               }
             }
           }, undefined, false, undefined, this),
-          screen === "terminalWidth" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(TerminalWidthMenu, {
+          screen === "terminalWidth" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(TerminalWidthMenu, {
             settings,
             onUpdate: (updatedSettings) => {
               setSettings(updatedSettings);
@@ -73879,7 +75566,7 @@ ${GITHUB_REPO_URL}`,
               setScreen("terminalConfig");
             }
           }, undefined, false, undefined, this),
-          screen === "globalOverrides" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(GlobalOverridesMenu, {
+          screen === "globalOverrides" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(GlobalOverridesMenu, {
             settings,
             onUpdate: (updatedSettings) => {
               setSettings(updatedSettings);
@@ -73889,7 +75576,7 @@ ${GITHUB_REPO_URL}`,
               setScreen("main");
             }
           }, undefined, false, undefined, this),
-          screen === "confirm" && confirmDialog && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(ConfirmDialog, {
+          screen === "confirm" && confirmDialog && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(ConfirmDialog, {
             message: confirmDialog.message,
             onConfirm: () => void confirmDialog.action(),
             onCancel: () => {
@@ -73897,15 +75584,57 @@ ${GITHUB_REPO_URL}`,
               setConfirmDialog(null);
             }
           }, undefined, false, undefined, this),
-          screen === "install" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(InstallMenu, {
-            bunxAvailable: isBunxAvailable(),
+          screen === "flowNotice" && flowNotice && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(FlowNotice, {
+            ...flowNotice,
+            onContinue: () => {
+              setScreen(flowNotice.continueScreen);
+              setFlowNotice(null);
+            }
+          }, undefined, false, undefined, this),
+          screen === "install" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(InstallMenu, {
+            commandAvailability,
+            currentVersion: getPackageVersion(),
             existingStatusLine,
-            onSelectNpx: handleNpxInstall,
-            onSelectBunx: handleBunxInstall,
+            onSelect: (selection) => {
+              setMenuSelections((prev) => ({
+                ...prev,
+                installPackage: selection.packageManager === "bun" ? 1 : 0
+              }));
+              handleInstallSelection(selection);
+            },
             onCancel: handleInstallMenuCancel,
-            initialSelection: menuSelections.install
+            initialPackageSelection: menuSelections.installPackage
           }, undefined, false, undefined, this),
-          screen === "refreshInterval" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(RefreshIntervalMenu, {
+          screen === "manageInstallation" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(ManageInstallationMenu, {
+            installation: effectiveInstallation,
+            activeCommand: activeGlobalCommand,
+            onSelect: handleManageInstallationSelect,
+            onBack: () => {
+              setMenuSelections((prev) => ({
+                ...prev,
+                main: getMainMenuInstallSelectionIndex(true, effectiveInstallation)
+              }));
+              setScreen("main");
+            }
+          }, undefined, false, undefined, this),
+          screen === "uninstallOptions" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(UninstallMenu, {
+            installations: globalPackageInstallations,
+            onSelect: (selection) => {
+              handleUninstallSelection(selection, "uninstallOptions");
+            },
+            onBack: () => {
+              setScreen("manageInstallation");
+            }
+          }, undefined, false, undefined, this),
+          screen === "updates" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(UpdateCheckerMenu, {
+            state: updateCheckerState,
+            onBack: () => {
+              setScreen(updatesReturnScreen);
+            },
+            onRefresh: handleUpdateCheck,
+            onRunAction: handleRunUpdateAction
+          }, undefined, false, undefined, this),
+          screen === "refreshInterval" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(RefreshIntervalMenu, {
             currentInterval: currentRefreshInterval,
             supportsRefreshInterval,
             onUpdate: (interval) => {
@@ -73929,7 +75658,7 @@ ${GITHUB_REPO_URL}`,
               setScreen("main");
             }
           }, undefined, false, undefined, this),
-          screen === "powerline" && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(PowerlineSetup, {
+          screen === "powerline" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(PowerlineSetup, {
             settings,
             powerlineFontStatus,
             onUpdate: (updatedSettings) => {
@@ -73963,7 +75692,7 @@ ${GITHUB_REPO_URL}`,
 };
 function runTUI() {
   process.stdout.write("\x1B[2J\x1B[H");
-  render_default(/* @__PURE__ */ jsx_dev_runtime25.jsxDEV(App2, {}, undefined, false, undefined, this));
+  render_default(/* @__PURE__ */ jsx_dev_runtime27.jsxDEV(App2, {}, undefined, false, undefined, this));
 }
 // src/types/StatusJSON.ts
 init_zod();
@@ -74047,9 +75776,9 @@ init_colors();
 // src/utils/compaction.ts
 init_zod();
 import * as crypto from "crypto";
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as os13 from "os";
-import * as path10 from "path";
+import * as path11 from "path";
 var DEFAULT_DROP_THRESHOLD = 2;
 var FRESH_PREV_CTX_PCT = -1;
 var MAX_CACHE_FILE_BYTES = 4096;
@@ -74094,7 +75823,7 @@ function detectCompaction(currentCtxPct, state, options = DEFAULT_DROP_THRESHOLD
   };
 }
 function getCacheDir2() {
-  return path10.join(os13.homedir(), ".cache", "ccstatusline", "compaction");
+  return path11.join(os13.homedir(), ".cache", "ccstatusline", "compaction");
 }
 function sanitizeSessionId(sessionId) {
   const sanitized = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -74104,18 +75833,18 @@ function sanitizeSessionId(sessionId) {
   return sanitized;
 }
 function getStatePath(sessionId) {
-  return path10.join(getCacheDir2(), `compaction-${sanitizeSessionId(sessionId)}.json`);
+  return path11.join(getCacheDir2(), `compaction-${sanitizeSessionId(sessionId)}.json`);
 }
 function loadCompactionState(sessionId) {
   const statePath = getStatePath(sessionId);
   let fd = null;
   try {
-    fd = fs13.openSync(statePath, fs13.constants.O_RDONLY | fs13.constants.O_NOFOLLOW);
-    const stats = fs13.fstatSync(fd);
+    fd = fs14.openSync(statePath, fs14.constants.O_RDONLY | fs14.constants.O_NOFOLLOW);
+    const stats = fs14.fstatSync(fd);
     if (!stats.isFile() || stats.size > MAX_CACHE_FILE_BYTES) {
       return FRESH;
     }
-    const raw = JSON.parse(fs13.readFileSync(fd, "utf-8"));
+    const raw = JSON.parse(fs14.readFileSync(fd, "utf-8"));
     const result2 = CompactionStateSchema.safeParse(raw);
     return result2.success ? result2.data : FRESH;
   } catch {
@@ -74123,7 +75852,7 @@ function loadCompactionState(sessionId) {
   } finally {
     if (fd !== null) {
       try {
-        fs13.closeSync(fd);
+        fs14.closeSync(fd);
       } catch {}
     }
   }
@@ -74132,19 +75861,19 @@ function saveCompactionState(sessionId, state) {
   let tmpPath = null;
   try {
     const dir = getCacheDir2();
-    if (!fs13.existsSync(dir)) {
-      fs13.mkdirSync(dir, { recursive: true });
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
     }
     const targetPath = getStatePath(sessionId);
     tmpPath = `${targetPath}.tmp.${process.pid}.${crypto.randomBytes(4).toString("hex")}`;
-    fs13.writeFileSync(tmpPath, JSON.stringify(state) + `
+    fs14.writeFileSync(tmpPath, JSON.stringify(state) + `
 `);
-    fs13.renameSync(tmpPath, targetPath);
+    fs14.renameSync(tmpPath, targetPath);
     tmpPath = null;
   } catch {
     if (tmpPath !== null) {
       try {
-        fs13.unlinkSync(tmpPath);
+        fs14.unlinkSync(tmpPath);
       } catch {}
     }
   }
@@ -74155,27 +75884,27 @@ init_context_percentage();
 await init_config();
 
 // src/utils/hook-handler.ts
-import * as fs15 from "fs";
-import * as path12 from "path";
+import * as fs16 from "fs";
+import * as path13 from "path";
 
 // src/utils/skills.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as os14 from "os";
-import * as path11 from "path";
+import * as path12 from "path";
 var EMPTY = { totalInvocations: 0, uniqueSkills: [], lastSkill: null };
 function getSkillsDir() {
-  return path11.join(os14.homedir(), ".cache", "ccstatusline", "skills");
+  return path12.join(os14.homedir(), ".cache", "ccstatusline", "skills");
 }
 function getSkillsFilePath(sessionId) {
-  return path11.join(getSkillsDir(), `skills-${sessionId}.jsonl`);
+  return path12.join(getSkillsDir(), `skills-${sessionId}.jsonl`);
 }
 function getSkillsMetrics(sessionId) {
   const filePath = getSkillsFilePath(sessionId);
-  if (!fs14.existsSync(filePath)) {
+  if (!fs15.existsSync(filePath)) {
     return EMPTY;
   }
   try {
-    const invocations = fs14.readFileSync(filePath, "utf-8").trim().split(`
+    const invocations = fs15.readFileSync(filePath, "utf-8").trim().split(`
 `).filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
@@ -74229,14 +75958,14 @@ function handleHookInput(input) {
       return;
     }
     const filePath = getSkillsFilePath(sessionId);
-    fs15.mkdirSync(path12.dirname(filePath), { recursive: true });
+    fs16.mkdirSync(path13.dirname(filePath), { recursive: true });
     const entry = JSON.stringify({
       timestamp: new Date().toISOString(),
       session_id: sessionId,
       skill: skillName,
       source: data.hook_event_name
     });
-    fs15.appendFileSync(filePath, entry + `
+    fs16.appendFileSync(filePath, entry + `
 `);
   } catch {}
 }
@@ -74379,8 +76108,8 @@ async function ensureWindowsUtf8CodePage() {
     return;
   }
   try {
-    const { execFileSync: execFileSync5 } = await import("child_process");
-    execFileSync5("chcp.com", ["65001"], { stdio: "ignore" });
+    const { execFileSync: execFileSync7 } = await import("child_process");
+    execFileSync7("chcp.com", ["65001"], { stdio: "ignore" });
   } catch {}
 }
 async function renderMultipleLines(data) {