claudeup 4.35.0 → 4.35.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.35.0",
+  "version": "4.35.1",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "4.35.0",
-    "claudeup-darwin-x64": "4.35.0",
-    "claudeup-linux-x64": "4.35.0"
+    "claudeup-darwin-arm64": "4.35.1",
+    "claudeup-darwin-x64": "4.35.1",
+    "claudeup-linux-x64": "4.35.1"
   }
 }

package/src/__tests__/git-worktree.test.ts

@@ -0,0 +1,108 @@
+import {
+	afterAll,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	test,
+} from "bun:test";
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import {
+	clearWorktreeCache,
+	inheritablePaths,
+} from "../services/git-worktree.js";
+
+/**
+ * Exercised against real repositories rather than a mocked `git`, because the
+ * whole point of the function is agreeing with git about what a worktree is.
+ * A stub would have happily confirmed a wrong parse of `worktree list`.
+ */
+
+// Isolate from the operator's git config: a global `core.excludesFile`,
+// `init.defaultBranch`, or commit signing would otherwise leak into these repos.
+const GIT_CFG = [
+	"-c",
+	"user.name=test",
+	"-c",
+	"user.email=test@example.com",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+
+const git = (cwd: string, ...args: string[]) =>
+	execFileSync("git", [...GIT_CFG, ...args], { cwd, encoding: "utf8" }).trim();
+
+let base: string;
+let mainTree: string;
+let linked: string;
+
+beforeAll(async () => {
+	// realpath: on macOS os.tmpdir() is a symlink, and git reports real paths.
+	base = await fs.realpath(
+		await fs.mkdtemp(path.join(os.tmpdir(), "claudeup-worktree-")),
+	);
+	mainTree = path.join(base, "repo");
+	linked = path.join(base, "linked");
+
+	await fs.ensureDir(mainTree);
+	git(mainTree, "init", "-q");
+	await fs.writeFile(path.join(mainTree, "README.md"), "hello\n");
+	git(mainTree, "add", "-A");
+	git(mainTree, "commit", "-qm", "initial");
+	git(mainTree, "worktree", "add", "-q", "-b", "feature", linked);
+});
+
+afterAll(async () => {
+	if (base) await fs.remove(base);
+});
+
+beforeEach(() => {
+	clearWorktreeCache();
+});
+
+describe("inheritablePaths", () => {
+	test("a linked worktree inherits from the main working tree", async () => {
+		expect(await inheritablePaths(linked)).toEqual([mainTree]);
+	});
+
+	test("the main working tree inherits nothing — it holds its own rows", async () => {
+		expect(await inheritablePaths(mainTree)).toEqual([]);
+	});
+
+	test("a subdirectory of a checkout inherits from the repository root", async () => {
+		const sub = path.join(mainTree, "packages", "app");
+		await fs.ensureDir(sub);
+		expect(await inheritablePaths(sub)).toEqual([mainTree]);
+	});
+
+	test("a subdirectory of a linked worktree inherits both roots, nearest first", async () => {
+		const sub = path.join(linked, "packages", "app");
+		await fs.ensureDir(sub);
+		expect(await inheritablePaths(sub)).toEqual([linked, mainTree]);
+	});
+
+	test("a directory outside any repository inherits nothing", async () => {
+		const loose = path.join(base, "not-a-repo");
+		await fs.ensureDir(loose);
+		// Guard: a stray repo above the temp dir would silently invalidate this.
+		const out = await inheritablePaths(loose);
+		expect(out.every((p) => !p.startsWith(base))).toBe(true);
+	});
+
+	test("a missing directory yields nothing rather than throwing", async () => {
+		expect(await inheritablePaths(path.join(base, "gone"))).toEqual([]);
+	});
+
+	test("results are cached per path and cleared on demand", async () => {
+		const first = await inheritablePaths(linked);
+		expect(await inheritablePaths(linked)).toBe(first); // same array identity
+		clearWorktreeCache();
+		expect(await inheritablePaths(linked)).not.toBe(first);
+		expect(await inheritablePaths(linked)).toEqual([mainTree]);
+	});
+});

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/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;