claudeup 4.35.0 → 4.36.0

package/src/__tests__/uppercase-keybindings.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import { parseKeypress } from "@opentui/core";
+import fs from "fs-extra";
+
+/**
+ * A shifted key never arrives as an uppercase `name`.
+ *
+ * OpenTUI reports Shift+U as `{name: "u", shift: true, sequence: "U"}`, so
+ * `event.name === "U"` is unreachable. That is not merely dead code: in
+ * PluginsScreen the dead branch sat BELOW `event.name === "u"`, so pressing
+ * Shift+U — advertised in the footer as "update" — fell through to the plain "u"
+ * branch and installed the plugin at user scope instead. Reported from the real
+ * UI: "U instead of update install user scope".
+ *
+ * The same shape was in McpRegistryScreen (`"R"` for refresh), where nothing
+ * shadowed it, so refresh silently did nothing at all.
+ */
+
+const UI_DIR = path.join(import.meta.dir, "..", "ui");
+
+async function uiSourceFiles(dir: string): Promise<string[]> {
+	const out: string[] = [];
+	for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...(await uiSourceFiles(full)));
+		else if (/\.tsx?$/.test(entry.name)) out.push(full);
+	}
+	return out;
+}
+
+const isComment = (line: string) => {
+	const t = line.trim();
+	return t.startsWith("//") || t.startsWith("*") || t.startsWith("/*");
+};
+
+describe("shifted keys parse to a lowercase name plus a flag", () => {
+	// Pin the platform behaviour the rule depends on. If OpenTUI ever changed
+	// this, the guard below would be enforcing a rule that no longer holds.
+	test("Shift+letter keeps the unshifted name and sets shift", () => {
+		for (const [raw, name] of [
+			["U", "u"],
+			["A", "a"],
+			["R", "r"],
+		] as const) {
+			const k = parseKeypress(raw);
+			expect({ raw, name: k?.name, shift: k?.shift }).toEqual({
+				raw,
+				name,
+				shift: true,
+			});
+		}
+	});
+
+	test("an unshifted letter reports shift false", () => {
+		const k = parseKeypress("u");
+		expect({ name: k?.name, shift: k?.shift }).toEqual({
+			name: "u",
+			shift: false,
+		});
+	});
+});
+
+describe("no binding compares name to an uppercase letter", () => {
+	test("uppercase name comparisons are absent from the UI", async () => {
+		const files = await uiSourceFiles(UI_DIR);
+		expect(files.length).toBeGreaterThan(10); // guard: the walk found real files
+
+		const offenders: string[] = [];
+		for (const file of files) {
+			const text = await fs.readFile(file, "utf8");
+			text.split("\n").forEach((line, i) => {
+				if (isComment(line)) return;
+				if (/\bname\s*===\s*"[A-Z]"/.test(line)) {
+					offenders.push(
+						`${path.relative(UI_DIR, file)}:${i + 1}  ${line.trim()}`,
+					);
+				}
+			});
+		}
+		expect(offenders).toEqual([]);
+	});
+
+	test("an uppercase binding is reachable only via the shift flag", async () => {
+		// The positive half: Shift+U must actually route to update. Asserting only
+		// the absence of `=== "U"` would also pass if someone deleted the binding.
+		const src = await fs.readFile(
+			path.join(UI_DIR, "screens", "PluginsScreen.tsx"),
+			"utf8",
+		);
+		const update = src.indexOf('event.name === "u" && event.shift');
+		const userScope = src.indexOf(
+			'event.name === "u") handleScopeToggle("user")',
+		);
+		expect(update).toBeGreaterThan(-1);
+		expect(userScope).toBeGreaterThan(-1);
+		// Order matters: the shifted branch has to be tested first, or the plain
+		// "u" branch swallows it again — which is exactly the original bug.
+		expect(update).toBeLessThan(userScope);
+	});
+});

package/src/__tests__/worktree-registry-resolution.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import { pickRegistryEntry } from "../services/claude-settings.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+
+/**
+ * Regression cover for "a fresh git worktree reports every plugin as not installed".
+ *
+ * `installed_plugins.json` keys one entry per `projectPath`, and a new worktree is
+ * a project path nobody has ever installed into — measured on a real machine:
+ * 750 project-scope rows, zero of them for the worktree, and zero user-scope rows
+ * for any magus plugin. So `pickRegistryEntry` found nothing, `overlayRegistryVersions`
+ * deleted the version as an unbacked claim, and `isInstalledInScope` reported the
+ * plugin missing.
+ *
+ * Claude Code disagreed: it loaded all of them. Its loader is not gated on the
+ * current project — a worktree with no rows resolves `installPath` from another
+ * project's row and loads from cache (measured, `ai-docs/plugin-system-state-model.md`).
+ * So claudeup was offering to install plugins that were already working.
+ *
+ * A linked worktree is the same project as its main working tree, so the main
+ * tree's row is the honest answer for it.
+ */
+
+const entry = (
+	scope: InstalledPluginEntry["scope"],
+	version: string,
+	projectPath?: string,
+): InstalledPluginEntry => ({
+	scope,
+	version,
+	projectPath,
+	installPath: `/cache/${version}`,
+	installedAt: "2026-01-01T00:00:00.000Z",
+	lastUpdated: "2026-01-01T00:00:00.000Z",
+});
+
+const MAIN = "/repo";
+const TREE = "/repo/.claude/worktrees/feature";
+
+describe("pickRegistryEntry — worktree fallback", () => {
+	test("a worktree with no rows of its own resolves to the main working tree's row", () => {
+		const entries = [entry("project", "3.3.0", MAIN)];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"3.3.0",
+		);
+	});
+
+	test("the worktree's own row still wins over the main tree's row", () => {
+		const entries = [
+			entry("project", "3.3.0", MAIN),
+			entry("project", "4.0.0", TREE),
+		];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"4.0.0",
+		);
+	});
+
+	test("a local-scope row on the main tree satisfies a worktree project lookup", () => {
+		const entries = [entry("local", "5.0.0", MAIN)];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"5.0.0",
+		);
+	});
+
+	test("the main-tree row outranks a user-scope entry", () => {
+		// Same project beats "installed globally somewhere". The user entry is the
+		// looser fallback and stays available when the main tree has no row.
+		const entries = [entry("user", "1.0.0"), entry("project", "3.3.0", MAIN)];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"3.3.0",
+		);
+	});
+
+	test("the user-scope entry still applies when the main tree has no row either", () => {
+		const entries = [
+			entry("user", "2.1.2"),
+			entry("project", "9.9.9", "/elsewhere"),
+		];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"2.1.2",
+		);
+	});
+
+	test("an unrelated project's row is never inherited", () => {
+		// The loader may well resolve one of these, but claudeup must not claim a
+		// version it cannot attribute to this project.
+		const entries = [entry("project", "9.9.9", "/some/other/project")];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])).toBeUndefined();
+	});
+
+	test("fallback paths are compared resolved, not as raw strings", () => {
+		const entries = [entry("project", "4.2.0", "/repo/./sub/..")];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"4.2.0",
+		);
+	});
+
+	test("fallback paths are ignored for a user-scope lookup", () => {
+		const entries = [entry("project", "3.3.0", MAIN)];
+		expect(pickRegistryEntry(entries, "user", TREE, [MAIN])).toBeUndefined();
+	});
+
+	test("omitting fallback paths preserves the previous behaviour", () => {
+		const entries = [entry("project", "3.3.0", MAIN)];
+		expect(pickRegistryEntry(entries, "project", TREE)).toBeUndefined();
+	});
+});

package/src/main.tsx

@@ -1,12 +1,13 @@
 #!/usr/bin/env bun
 
-import { createCliRenderer } from "@opentui/core";
+import { RGBA, createCliRenderer } from "@opentui/core";
 import { createRoot } from "@opentui/react";
-import { App } from "./ui/App.js";
-import { route } from "./cli/router.js";
 // Static import so `bun build --compile` embeds package.json into the binary;
 // a dynamic require("../package.json") is not resolvable inside the bunfs root.
 import pkg from "../package.json";
+import { route } from "./cli/router.js";
+import { App } from "./ui/App.js";
+import { setThemeMode } from "./ui/theme-mode.js";
 
 export const VERSION = (pkg as { version: string }).version;
 
@@ -24,8 +25,23 @@ async function main(): Promise<void> {
 		process.exit(outcome.exitCode ?? 0);
 	}
 
-	// Create OpenTUI renderer (handles alternate screen buffer automatically)
-	const renderer = await createCliRenderer();
+	// Create OpenTUI renderer (handles alternate screen buffer automatically).
+	//
+	// The background is the terminal's own, not a colour of ours: painting an
+	// absolute fill would box the UI into whatever theme we guessed. OpenTUI's
+	// built-in default for unstyled cells is truecolor white, which is why every
+	// element now names an adaptive colour explicitly — see src/ui/theme.ts.
+	const renderer = await createCliRenderer({
+		backgroundColor: RGBA.defaultBackground(),
+	});
+
+	// Ask the terminal whether it is light or dark, once. Only the disabled-row
+	// tint needs this — see src/ui/theme-mode.ts for why that one case cannot be
+	// solved the way the rest of the palette is. Bounded wait: a terminal that
+	// ignores the OSC query must not delay first paint, and `null` simply means
+	// no tint.
+	setThemeMode(await renderer.waitForThemeMode(250).catch(() => null));
+
 	const root = createRoot(renderer);
 
 	// Cleanup function to restore terminal

package/src/opentui.d.ts

@@ -8,6 +8,15 @@
  */
 
 import type { ReactNode } from "react";
+import type { RGBA } from "@opentui/core";
+
+/**
+ * What OpenTUI actually accepts for a colour: a CSS string OR an RGBA, which is
+ * how adaptive colours are expressed (RGBA.defaultForeground(), RGBA.fromIndex()).
+ * These declarations previously said `string`, which made the terminal-resolved
+ * forms a type error and quietly pushed every call site towards absolute hex.
+ */
+type ColorProp = string | RGBA;
 
 declare global {
 	namespace JSX {
@@ -28,7 +37,7 @@ declare global {
 			u: { children?: ReactNode };
 			dim: { children?: ReactNode };
 			a: { href?: string; children?: ReactNode };
-			span: { fg?: string; bg?: string; children?: ReactNode };
+			span: { fg?: ColorProp; bg?: ColorProp; children?: ReactNode };
 		}
 	}
 }
@@ -37,12 +46,12 @@ interface BaseBoxProps {
 	// Borders
 	border?: boolean;
 	borderStyle?: "single" | "double" | "rounded" | "bold";
-	borderColor?: string;
+	borderColor?: ColorProp;
 	title?: string;
 	titleAlignment?: "left" | "center" | "right";
 
 	// Colors
-	backgroundColor?: string;
+	backgroundColor?: ColorProp;
 
 	// Layout (Flexbox)
 	flexDirection?: "row" | "column";
@@ -94,8 +103,8 @@ interface BoxProps extends BaseBoxProps {
 
 interface TextProps {
 	content?: string;
-	fg?: string;
-	bg?: string;
+	fg?: ColorProp;
+	bg?: ColorProp;
 	selectable?: boolean;
 	children?: ReactNode;
 }
@@ -108,10 +117,10 @@ interface InputProps {
 	placeholder?: string;
 	focused?: boolean;
 	width?: number;
-	backgroundColor?: string;
-	textColor?: string;
-	cursorColor?: string;
-	focusedBackgroundColor?: string;
+	backgroundColor?: ColorProp;
+	textColor?: ColorProp;
+	cursorColor?: ColorProp;
+	focusedBackgroundColor?: ColorProp;
 }
 
 interface SelectOption {
@@ -150,8 +159,8 @@ interface ScrollboxProps {
 		scrollbarOptions?: {
 			showArrows?: boolean;
 			trackOptions?: {
-				foregroundColor?: string;
-				backgroundColor?: string;
+				foregroundColor?: ColorProp;
+				backgroundColor?: ColorProp;
 			};
 		};
 	};
@@ -161,7 +170,7 @@ interface ScrollboxProps {
 interface AsciiFontProps {
 	text: string;
 	font?: "tiny" | "block" | "slick" | "shade";
-	color?: string;
+	color?: ColorProp;
 }
 
 interface CodeProps {

package/src/services/claude-settings.ts

@@ -12,6 +12,7 @@ import type {
 	InstalledPluginEntry,
 } from "../types/index.js";
 import { parsePluginId } from "../utils/string-utils.js";
+import { inheritablePaths } from "./git-worktree.js";
 
 const CLAUDE_DIR = ".claude";
 const SETTINGS_FILE = "settings.json";
@@ -261,27 +262,44 @@ export async function getLocalEnabledPlugins(
  * The registry is what Claude Code actually loaded, so it wins on conflict.
  *
  * Scope resolution mirrors Claude Code: for a project scope, prefer an entry
- * pinned to that exact projectPath (project or local), then fall back to the
- * user-scope entry, which is what a project without its own install resolves to.
+ * pinned to that exact projectPath (project or local), then any `fallbackPaths`
+ * that are the same repository (see git-worktree.ts), then the user-scope entry,
+ * which is what a project without its own install resolves to.
  */
 export function pickRegistryEntry(
 	entries: InstalledPluginEntry[] | undefined,
 	scope: "user" | "project" | "local",
 	projectPath?: string,
+	/**
+	 * Same-repository directories whose rows may be inherited, nearest first —
+	 * a linked worktree's main working tree, or the root of this checkout.
+	 *
+	 * A fresh worktree has no rows of its own, so without this every plugin read
+	 * as not installed while Claude Code was loading all of them quite happily.
+	 * These rank above the user-scope entry: "installed in this repository" is a
+	 * closer answer than "installed globally somewhere".
+	 */
+	fallbackPaths: string[] = [],
 ): InstalledPluginEntry | undefined {
 	if (!Array.isArray(entries) || entries.length === 0) return undefined;
 
 	if (scope === "user") return entries.find((e) => e.scope === "user");
 
-	const target = projectPath ? path.resolve(projectPath) : undefined;
-	if (target) {
-		const pinned = entries.find(
+	const pinnedTo = (target: string) =>
+		entries.find(
 			(e) =>
 				(e.scope === scope || e.scope === "local") &&
 				e.projectPath !== undefined &&
 				path.resolve(e.projectPath) === target,
 		);
-		if (pinned) return pinned;
+
+	if (projectPath) {
+		const own = pinnedTo(path.resolve(projectPath));
+		if (own) return own;
+	}
+	for (const fallback of fallbackPaths) {
+		const inherited = pinnedTo(path.resolve(fallback));
+		if (inherited) return inherited;
 	}
 	// A project with no install of its own resolves to the user-scope entry.
 	return entries.find((e) => e.scope === "user");
@@ -299,9 +317,21 @@ async function overlayRegistryVersions(
 		return base; // registry unreadable — settings-only is still better than nothing
 	}
 
+	// `readSettings(undefined)` already resolves to the current directory, so the
+	// registry lookup has to as well. While it did not, the base map described one
+	// project while the overlay refused to match any project's rows at all, and every
+	// version was deleted as unbacked — which is why the prerunner and the global
+	// plugin view, both of which pass no path, saw project-scope plugins as
+	// uninstalled everywhere, not only in a worktree.
+	const target = scope === "user" ? undefined : (projectPath ?? process.cwd());
+
+	// Resolved once, not per plugin: this shells out to git, and the loop runs
+	// across every key in the registry (76 on a well-used machine) for each scope.
+	const fallbackPaths = target ? await inheritablePaths(target) : [];
+
 	const merged = { ...base };
 	for (const [pluginId, entries] of Object.entries(registry.plugins ?? {})) {
-		const pick = pickRegistryEntry(entries, scope, projectPath);
+		const pick = pickRegistryEntry(entries, scope, target, fallbackPaths);
 		if (pick?.version) {
 			merged[pluginId] = pick.version;
 			continue;

package/src/services/git-worktree.ts

@@ -0,0 +1,129 @@
+/**
+ * git-worktree.ts — which other directories count as "the same project" as this one.
+ *
+ * `installed_plugins.json` keys one entry per `projectPath`, so a directory that
+ * nobody has run `claude plugin install` in has no rows at all. A freshly created
+ * git worktree is exactly that: measured on a real machine, 750 project-scope rows
+ * across 76 plugin keys and not one of them for the new worktree.
+ *
+ * Claude Code does not care. Its loader is not gated on the current project — a
+ * worktree with zero rows resolves `installPath` from another project's row and
+ * loads from cache (measured, `ai-docs/plugin-system-state-model.md`). claudeup
+ * mirrored the registry faithfully instead, so it reported every plugin as missing
+ * and offered to install things that were already working.
+ *
+ * The fix is to ask a narrower question than "does the loader find something
+ * somewhere": inherit rows only from directories that are the *same repository*.
+ * That covers both ways a project path can miss its own rows —
+ *
+ *   1. a linked worktree, whose main working tree holds the rows
+ *   2. a subdirectory of a checkout, where the rows sit at the repo root
+ *
+ * — under one rule, and never inherits from an unrelated project, which would be
+ * claiming a version we cannot attribute.
+ */
+
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+function git(
+	cwd: string,
+	args: string[],
+): Promise<{ code: number; out: string }> {
+	return new Promise((resolve) => {
+		const child = spawn("git", args, {
+			cwd,
+			stdio: ["ignore", "pipe", "ignore"],
+		});
+		let out = "";
+		child.stdout.on("data", (d) => {
+			out += String(d);
+		});
+		// Never let a wedged git block the UI.
+		const timer = setTimeout(() => {
+			child.kill();
+			resolve({ code: -1, out: "" });
+		}, 5000);
+		timer.unref?.();
+		const settle = (code: number, text: string) => {
+			clearTimeout(timer);
+			resolve({ code, out: text });
+		};
+		child.on("error", () => settle(-1, ""));
+		child.on("close", (code) => settle(code ?? -1, out.trim()));
+	});
+}
+
+/**
+ * Session cache. Keyed by resolved project path — the repository layout cannot
+ * change under a running claudeup in any way worth tracking, and the resolution
+ * runs once per plugin per scope otherwise (24+ plugins × 3 scopes of `git`).
+ */
+const cache = new Map<string, string[]>();
+
+export function clearWorktreeCache(): void {
+	cache.clear();
+}
+
+/**
+ * Directories whose registry rows this project may inherit, nearest first.
+ *
+ * Returns `[]` — never a guess — when the question cannot be answered honestly:
+ * git missing, not a repository, a bare repo with no working tree, or the path
+ * already being the repository root. Inheriting nothing restores the previous
+ * behaviour for that path, which is the safe direction: a false negative shows
+ * an "install" the user does not need, a false positive hides a real one.
+ */
+export async function inheritablePaths(projectPath: string): Promise<string[]> {
+	const key = path.resolve(projectPath);
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const { paths, answered } = await resolveInheritable(key);
+	// Only cache an answer git actually gave. A timeout or a transient spawn
+	// failure would otherwise pin an empty result for the rest of the session,
+	// turning one slow moment into a persistent wrong "not installed".
+	if (answered) cache.set(key, paths);
+	return paths;
+}
+
+async function resolveInheritable(
+	dir: string,
+): Promise<{ paths: string[]; answered: boolean }> {
+	const candidates: string[] = [];
+
+	// Independent queries, so run them together: sequentially, two wedged git calls
+	// would stall the first paint for the full 10s rather than 5.
+	const [top, list] = await Promise.all([
+		// The root of whichever working tree we are standing in. Covers a subdirectory
+		// of a checkout, and is the nearer answer when both apply.
+		git(dir, ["rev-parse", "--show-toplevel"]),
+		// The main working tree, which `git worktree list` always lists first. This is
+		// the row-bearing directory for a linked worktree.
+		git(dir, ["worktree", "list", "--porcelain"]),
+	]);
+
+	if (top.code === 0 && top.out) candidates.push(path.resolve(top.out));
+
+	if (list.code === 0 && list.out) {
+		const firstRecord = list.out.split("\n\n")[0].split("\n");
+		// A bare repo is listed with a `bare` line and has no working tree to inherit.
+		const isBare = firstRecord.some((l) => l.trim() === "bare");
+		const line = firstRecord.find((l) => l.startsWith("worktree "));
+		if (!isBare && line) {
+			candidates.push(path.resolve(line.slice("worktree ".length).trim()));
+		}
+	}
+
+	// "Not a repository" is a real answer worth caching; "git never replied" is not.
+	const answered = top.code !== -1 || list.code !== -1;
+
+	// Drop this project itself and any duplicate, preserving nearest-first order.
+	const seen = new Set<string>([dir]);
+	const inheritable: string[] = [];
+	for (const candidate of candidates) {
+		if (seen.has(candidate)) continue;
+		seen.add(candidate);
+		inheritable.push(candidate);
+	}
+	return { paths: inheritable, answered };
+}

package/src/services/plugin-manager.ts

@@ -18,6 +18,7 @@ import {
 	removeFromInstalledPluginsRegistry,
 } from "./claude-settings.js";
 import { hasContentDrift } from "./content-drift.js";
+import { inheritablePaths } from "./git-worktree.js";
 import { defaultMarketplaces } from "../data/marketplaces.js";
 import type {
 	InstalledPluginsRegistry,
@@ -616,6 +617,13 @@ async function annotateContentDrift(
 		return;
 	}
 
+	// Must match how the version itself was resolved. Without this a worktree
+	// inherits an installed version but never its `gitCommitSha`, so drift
+	// detection silently switches off for exactly the plugins that just started
+	// reporting as installed.
+	const target = scope === "user" ? undefined : (projectPath ?? process.cwd());
+	const fallbackPaths = target ? await inheritablePaths(target) : [];
+
 	await Promise.all(
 		plugins.map(async (plugin) => {
 			if (plugin.hasUpdate || plugin.isOrphaned) return;
@@ -625,7 +633,8 @@ async function annotateContentDrift(
 			const entry = pickRegistryEntry(
 				registry.plugins[plugin.id],
 				scope,
-				projectPath,
+				target,
+				fallbackPaths,
 			);
 			if (!entry?.gitCommitSha) return;
 

package/src/ui/App.tsx

@@ -49,6 +49,7 @@ import {
 } from "../services/version-check.js";
 import { useKeyboardHandler } from "./hooks/useKeyboardHandler.js";
 import { ProgressBar } from "./components/layout/ProgressBar.js";
+import { theme } from "./theme.js";
 
 export const VERSION = getCurrentVersion();
 
@@ -238,15 +239,15 @@ function UpdateBanner({ result }: { result: VersionCheckResult }) {
 
 	return (
 		<box paddingLeft={1} paddingRight={1}>
-			<text bg="yellow" fg="black">
+			<text bg={theme.colors.warning} fg={theme.hints.fg}>
 				<strong> UPDATE </strong>
 			</text>
-			<text fg="yellow">
+			<text fg={theme.colors.warning}>
 				{" "}
 				v{result.currentVersion} → v{result.latestVersion}
 			</text>
-			<text fg="gray"> Run: </text>
-			<text fg="cyan">claudeup update</text>
+			<text fg={theme.colors.muted}> Run: </text>
+			<text fg={theme.colors.info}>claudeup update</text>
 		</box>
 	);
 }
@@ -299,12 +300,12 @@ function AppContentInner({
 			{updateInfo?.updateAvailable && <UpdateBanner result={updateInfo} />}
 			{recoveryReport && (
 				<box paddingLeft={1} paddingRight={1}>
-					<text fg="green">✓ Fixed: {recoveryReport}</text>
+					<text fg={theme.colors.success}>✓ Fixed: {recoveryReport}</text>
 				</box>
 			)}
 			{showDebug && (
 				<box paddingLeft={1} paddingRight={1}>
-					<text fg="#888888">
+					<text fg={theme.colors.muted}>
 						DEBUG: {dimensions.terminalWidth}x{dimensions.terminalHeight} |
 						content={dimensions.contentHeight} | screen=
 						{state.currentRoute.screen}
@@ -340,7 +341,9 @@ function AppContent({ onExit }: AppContentProps) {
 	const [showDebug, setShowDebug] = useState(false);
 	const [updateInfo, setUpdateInfo] = useState<VersionCheckResult | null>(null);
 	const [recoveryReport, setRecoveryReport] = useState<string | null>(null);
-	const [mismatchData, setMismatchData] = useState<VersionMismatchInfo[] | null>(null);
+	const [mismatchData, setMismatchData] = useState<
+		VersionMismatchInfo[] | null
+	>(null);
 	const mismatchModal = useMismatchModal();
 	const [gitignoreData, setGitignoreData] = useState<{
 		violationCount: number;
@@ -472,8 +475,13 @@ function AppContent({ onExit }: AppContentProps) {
 				const result = await checkGitignore(process.cwd());
 				if (result.violationCount > 0) {
 					const s = await loadGitignoreState(process.cwd());
-					const safeCount = s.violations.filter((v) => v.severity === "safe").length;
-					setGitignoreData({ violationCount: result.violationCount, safeCount });
+					const safeCount = s.violations.filter(
+						(v) => v.severity === "safe",
+					).length;
+					setGitignoreData({
+						violationCount: result.violationCount,
+						safeCount,
+					});
 				}
 			} catch {
 				// non-fatal
@@ -491,8 +499,7 @@ function AppContent({ onExit }: AppContentProps) {
 	}, [dispatch]);
 
 	// Count transient banners for dimension calculation
-	const transientBannerCount =
-		recoveryReport ? 1 : 0;
+	const transientBannerCount = recoveryReport ? 1 : 0;
 
 	return (
 		<DimensionsProvider
@@ -507,7 +514,7 @@ function AppContent({ onExit }: AppContentProps) {
 				updateInfo={updateInfo}
 				onExit={onExit}
 				recoveryReport={recoveryReport}
-				/>
+			/>
 		</DimensionsProvider>
 	);
 }