magus-cli 7.5.3 → 7.6.0

package/src/__tests__/profile-startup.test.ts

@@ -373,7 +373,7 @@ describe("what the user is offered", () => {
 		// "Create <id> from this project" described the mechanism. The reason to
 		// pick this row is that it is the only one that keeps what is turned on.
 		expect(buildProfileOptions(inactive)[0]?.label).toBe(
-			'Save what you have as "default"',
+			"Save what you have as a new profile",
 		);
 	});
 

package/src/__tests__/profile-state.test.ts

@@ -145,7 +145,7 @@ describe("strict active-profile check", () => {
 			profile: "other",
 			restored: false,
 		});
-		expect(prep.lines[0]).toContain('matches profile "other" exactly');
+		expect(prep.lines[0]).toContain('Using profile "other"');
 		expect((await readActiveMarker(project))?.profile).toBe("other");
 		expect(await activeProfile(project)).toBe("other");
 	});
@@ -224,11 +224,11 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 
 		expect(prep.problems).toEqual([]);
 		expect(prep.lines).toContain(
-			'Changes Claude Code made under the older layout were added to profile "team"',
+			'Changes Claude Code made were added to profile "team"',
 		);
 		expect(prep.lines).toContain('Added code-search@magus to profile "team"');
 		expect(prep.lines).toContain(
-			'Converted profile "team" from the older layout to real files',
+			'Updated profile "team" to the current profile format',
 		);
 		// In profiles.json...
 		const team = (await readManifest(project)).profiles.team;
@@ -265,9 +265,8 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 			enabledPlugins: { "dev@magus": true, "code-search@magus": true },
 			permissions: { allow: ["Bash(bun test:*)"] },
 		});
-		expect(prep.lines.join("\n")).toContain(
-			`was kept at .claude/.magus-backups/${kept[0]}/`,
-		);
+		// Said in the user's terms; where the backup went is checked on disk above.
+		expect(prep.lines).toContain("A backup of the old profile format was kept");
 		expect(await readdir(join(project, ".claude", "profiles"))).toEqual([
 			"active.json",
 		]);
@@ -316,7 +315,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		// stands, the key is named, and the older copy is in the backup.
 		expect(team?.models?.agents).toEqual({ "dev:architect": "smart" });
 		expect(prep.lines).toContain(
-			'Profile "team": models differs between the older layout and profiles.json — kept profiles.json\'s value; the older copy is in the -layout backup under .claude/.magus-backups/',
+			'Profile "team": models differs between the old profile format and profiles.json — kept profiles.json\'s value (the old one is backed up)',
 		);
 		const live = await fs.readJson(settingsPath());
 		expect(live.enabledPlugins["code-search@magus"]).toBe(true);
@@ -426,7 +425,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		// Removals are not applied, and the run says so, once.
 		expect(
 			prep.lines.filter((l) =>
-				l.includes("a removal made under the older layout is not applied"),
+				l.includes("a removal made in the old format is not applied"),
 			),
 		).toHaveLength(1);
 		const live = await fs.readJson(settingsPath());
@@ -478,7 +477,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 			"mcpServers.db",
 		]) {
 			expect(prep.lines).toContain(
-				`Profile "team": ${at} differs between the older layout and profiles.json — kept profiles.json's value; the older copy is in the -layout backup under .claude/.magus-backups/`,
+				`Profile "team": ${at} differs between the old profile format and profiles.json — kept profiles.json's value (the old one is backed up)`,
 			);
 		}
 		// The older copy really is in the backup.
@@ -577,7 +576,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		const prep = await prepareProfileState(project);
 
 		expect(prep.problems).toHaveLength(1);
-		expect(prep.problems[0]).toContain("did not convert it");
+		expect(prep.problems[0]).toContain("did not update the old profile format");
 		expect(
 			(await lstat(join(project, ".claude", "settings.json"))).isSymbolicLink(),
 		).toBe(true);
@@ -623,7 +622,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		}
 
 		expect(await snapshot()).toEqual(before);
-		expect(printed()).toContain("is on an older magus layout");
+		expect(printed()).toContain("uses an old magus profile format");
 		expect(await fs.pathExists(activeMarkerPath(project))).toBe(false);
 	});
 
@@ -637,11 +636,9 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		const counts = await reportProfileState(project, false);
 
 		const out = printed();
-		expect(out).toContain(
-			'No active-profile marker, but the live config matches profile "other" exactly',
-		);
+		expect(out).toContain('This project\'s plugins match profile "other"');
 		// The contradicting line is gone, and so is the failure.
-		expect(out).not.toContain("matches no single profile");
+		expect(out).not.toContain("match none of the profiles");
 		expect(counts).toEqual({ fixable: 0, unfixable: 0 });
 		// Report only: the marker is not restored.
 		expect(await readActiveMarker(project)).toBeNull();
@@ -699,8 +696,14 @@ describe("generated files git still tracks: written, and warned about", () => {
 	const nothingStaged = () =>
 		expect(git(project, "diff", "--cached", "--name-only").stdout).toBe("");
 
-	const WARNING =
-		".claude/settings.json is generated from .claude/profiles.json but tracked by git — run `git rm --cached .claude/settings.json`, then commit";
+	// The notice is short lines: the problem, then the command on its own line.
+	const PROBLEM = "git tracks .claude/settings.json, but magus rewrites it";
+	const FIX = "git rm --cached .claude/settings.json, then commit";
+	/** Both lines, each printed exactly once. */
+	const warnedOnce = (out: string) => {
+		expect(out.split(PROBLEM).length - 1).toBe(1);
+		expect(out.split(FIX).length - 1).toBe(1);
+	};
 
 	test("B7: activating over a tracked settings.json writes it and names the fix", async () => {
 		await commitTrackedSettings();
@@ -710,7 +713,8 @@ describe("generated files git still tracks: written, and warned about", () => {
 		});
 
 		expect(result.tracked).toEqual([".claude/settings.json"]);
-		expect(activationNotes(result)).toContain(WARNING);
+		expect(activationNotes(result)).toContain(PROBLEM);
+		expect(activationNotes(result)).toContain(FIX);
 		expect((await fs.readJson(settingsPath())).enabledPlugins).toEqual({
 			"dev@magus": true,
 			"terminal@magus": false,
@@ -761,7 +765,7 @@ describe("generated files git still tracks: written, and warned about", () => {
 			process.chdir(cwd);
 		}
 		expect(outcome.exitCode).toBe(0);
-		expect(printed().split(WARNING).length - 1).toBe(1);
+		warnedOnce(printed());
 		expect((await readActiveMarker(project))?.profile).toBe("other");
 		nothingStaged();
 	});
@@ -772,7 +776,7 @@ describe("generated files git still tracks: written, and warned about", () => {
 		// A named profile that does not exist: the command stops right after the
 		// warning, before anything reaches the network.
 		expect(await runUpdateCommand(["no-such-profile"], project)).toBe(1);
-		expect(printed().split(WARNING).length - 1).toBe(1);
+		warnedOnce(printed());
 		nothingStaged();
 	});
 
@@ -824,7 +828,7 @@ describe("generated files git still tracks: written, and warned about", () => {
 		expect(await activeProfile(project)).toBe(
 			Object.keys(manifest.profiles)[0],
 		);
-		expect(printed()).toContain(WARNING);
+		warnedOnce(printed());
 		nothingStaged();
 	});
 
@@ -833,7 +837,8 @@ describe("generated files git still tracks: written, and warned about", () => {
 		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		const counts = await reportProfileState(project, false);
 		expect(counts.unfixable).toBe(0);
-		expect(printed()).toContain(`• ${WARNING}`);
+		expect(printed()).toContain(`• ${PROBLEM}`);
+		expect(printed()).toContain(FIX);
 	});
 
 	test("B7: writeSettings and writeMcpConfig write a tracked live file", async () => {

package/src/__tests__/prompt-eof.test.ts

@@ -0,0 +1,245 @@
+/**
+ * CLI prompts at end of input.
+ *
+ * Written blind — from the spec and the export signatures of src/cli/prompt.ts
+ * only. `promptValue(question)` and `askYesNo(question)` take no stream, so they
+ * read the process's own stdin: each case runs them in a CHILD `bun` process
+ * whose stdin is a pipe this test writes to and then closes. The child writes
+ * its outcome to a result file; the prompt text it prints is ignored.
+ *
+ * REQ-B1  stdin ends before a line is answered → promptValue rejects with
+ *         PromptAborted (instanceof, and isPromptAborted(err) is true),
+ *         instead of waiting forever.
+ * REQ-B2  same for askYesNo.
+ * REQ-B3  stdin that stays open a while and THEN ends still rejects.
+ * REQ-B4  a line followed by a newline is still returned; promptValue trims it.
+ * REQ-B5  askYesNo still answers a line followed by a newline.
+ *
+ * Each child has HOME, XDG_* and the cwd inside a temp dir and runs with
+ * `--no-env-file`, so nothing here reads or writes the real home or a project.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	realpath,
+	rm,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const PROMPT_MODULE = join(import.meta.dir, "..", "cli", "prompt.ts");
+
+/** Bounded wait for a child. A hang past this is the "waits forever" bug. */
+const CHILD_TIMEOUT_MS = 8_000;
+
+const CHILD = `
+const [fn, question, out] = process.argv.slice(2);
+const mod = await import(${JSON.stringify(PROMPT_MODULE)});
+let result;
+try {
+	const value = await mod[fn](question);
+	result = { outcome: "resolved", value };
+} catch (err) {
+	result = {
+		outcome: "rejected",
+		name: err?.name ?? null,
+		isPromptAbortedClass: err instanceof mod.PromptAborted,
+		isPromptAborted: mod.isPromptAborted(err),
+		message: String(err?.message ?? err),
+	};
+}
+await Bun.write(out, JSON.stringify(result));
+process.exit(0);
+`;
+
+type Outcome =
+	| { outcome: "resolved"; value: unknown }
+	| {
+			outcome: "rejected";
+			name: string | null;
+			isPromptAbortedClass: boolean;
+			isPromptAborted: boolean;
+			message: string;
+	  };
+
+interface ChildRun {
+	result: Outcome | null;
+	timedOut: boolean;
+	exitCode: number | null;
+	stderr: string;
+}
+
+let root: string;
+let childScript: string;
+let runs = 0;
+
+beforeAll(async () => {
+	root = await realpath(await mkdtemp(join(tmpdir(), "prompt-eof-")));
+	childScript = join(root, "child.ts");
+	await writeFile(childScript, CHILD);
+});
+
+afterAll(async () => {
+	await rm(root, { recursive: true, force: true });
+});
+
+async function runPrompt(
+	fn: "promptValue" | "askYesNo",
+	input: string,
+	opts: { holdOpenMs?: number } = {},
+): Promise<ChildRun> {
+	const dir = join(root, `run-${++runs}`);
+	const home = join(dir, "home");
+	await mkdir(home, { recursive: true });
+	const out = join(dir, "result.json");
+
+	const proc = Bun.spawn(
+		[process.execPath, "--no-env-file", childScript, fn, "Question? ", out],
+		{
+			cwd: dir,
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: "pipe",
+			env: {
+				PATH: process.env.PATH ?? "/usr/bin:/bin",
+				HOME: home,
+				XDG_CONFIG_HOME: join(dir, "xdg-config"),
+				XDG_CACHE_HOME: join(dir, "xdg-cache"),
+				XDG_DATA_HOME: join(dir, "xdg-data"),
+				XDG_STATE_HOME: join(dir, "xdg-state"),
+				TMPDIR: tmpdir(),
+				NO_COLOR: "1",
+				TERM: "dumb",
+			},
+		},
+	);
+
+	if (input.length > 0) proc.stdin.write(input);
+	await proc.stdin.flush();
+	if (opts.holdOpenMs) await Bun.sleep(opts.holdOpenMs);
+	await proc.stdin.end();
+
+	let timedOut = false;
+	const timer = setTimeout(() => {
+		timedOut = true;
+		proc.kill();
+	}, CHILD_TIMEOUT_MS);
+	const exitCode = await proc.exited;
+	clearTimeout(timer);
+	const stderr = await new Response(proc.stderr).text();
+
+	let result: Outcome | null = null;
+	try {
+		result = JSON.parse(await readFile(out, "utf8")) as Outcome;
+	} catch {
+		result = null;
+	}
+	return { result, timedOut, exitCode, stderr };
+}
+
+function expectAborted(run: ChildRun): void {
+	expect({
+		timedOut: run.timedOut,
+		stderr: run.timedOut ? run.stderr : "",
+	}).toEqual({
+		timedOut: false,
+		stderr: "",
+	});
+	if (run.result === null) {
+		throw new Error(
+			`child produced no result (exit ${run.exitCode}):\n${run.stderr}`,
+		);
+	}
+	expect(run.result.outcome).toBe("rejected");
+	if (run.result.outcome !== "rejected") return;
+	expect(run.result.name).toBe("PromptAborted");
+	expect(run.result.isPromptAbortedClass).toBe(true);
+	expect(run.result.isPromptAborted).toBe(true);
+}
+
+function expectResolved(run: ChildRun, value: unknown): void {
+	expect(run.timedOut).toBe(false);
+	if (run.result === null) {
+		throw new Error(
+			`child produced no result (exit ${run.exitCode}):\n${run.stderr}`,
+		);
+	}
+	expect(run.result).toEqual({ outcome: "resolved", value });
+}
+
+describe("promptValue at end of input", () => {
+	test(
+		"REQ-B1 rejects with PromptAborted when stdin closes with nothing on it",
+		async () => {
+			expectAborted(await runPrompt("promptValue", ""));
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		"REQ-B3 rejects with PromptAborted when stdin stays open, then closes unanswered",
+		async () => {
+			expectAborted(await runPrompt("promptValue", "", { holdOpenMs: 300 }));
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		"REQ-B4 returns a newline-terminated line, trimmed",
+		async () => {
+			expectResolved(
+				await runPrompt("promptValue", "  team-profile  \n"),
+				"team-profile",
+			);
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		"REQ-B4 returns the first line when stdin then ends",
+		async () => {
+			expectResolved(
+				await runPrompt("promptValue", "hello\n", { holdOpenMs: 100 }),
+				"hello",
+			);
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+});
+
+describe("askYesNo at end of input", () => {
+	test(
+		"REQ-B2 rejects with PromptAborted when stdin closes with nothing on it",
+		async () => {
+			expectAborted(await runPrompt("askYesNo", ""));
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		"REQ-B3 rejects with PromptAborted when stdin stays open, then closes unanswered",
+		async () => {
+			expectAborted(await runPrompt("askYesNo", "", { holdOpenMs: 300 }));
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		'REQ-B5 answers "y" + newline with true',
+		async () => {
+			expectResolved(await runPrompt("askYesNo", "y\n"), true);
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		'REQ-B5 answers "n" + newline with false',
+		async () => {
+			expectResolved(await runPrompt("askYesNo", "n\n"), false);
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+});

package/src/__tests__/scope-action.test.ts

@@ -8,41 +8,37 @@ import { planPluginUpdates, scopeIsBehind } from "../services/update-plan.js";
 
 /**
  * The scope keys (u / p / l) and the Enter scope picker both decide between
- * install, update and uninstall. That decision used to read `scope.enabled` —
- * the `enabledPlugins` flag from a settings file — and ignore `scope.version`,
- * which is the registry-backed answer to "did Claude Code actually install
- * this".
+ * install, update and uninstall. That decision used to read the settings flag
+ * alone and ignore `scope.version`.
  *
- * Those two disagree in a real, common state: a plugin listed in
+ * The two disagree in a real, common state: a plugin listed in
  * `enabledPlugins` with no entry in `installed_plugins.json` for the current
- * project path. The list row renders it "not installed" (isEnabledButNotInstalled),
- * and pressing its scope key ran `claude plugin uninstall`. The user asked to
- * install the thing the UI told them was missing, and it was removed instead.
+ * project path — installed, with its files missing (hasMissingFiles). Pressing
+ * its scope key ran `claude plugin uninstall`. The user asked to repair the
+ * thing the UI told them was broken, and it was removed instead.
  */
 
 describe("isInstalledInScope", () => {
-	test("enabled with a registry version is installed", () => {
-		expect(isInstalledInScope({ enabled: true, version: "3.0.2" })).toBe(true);
+	test("installed with a registry version is installed", () => {
+		expect(isInstalledInScope({ installed: true, version: "3.0.2" })).toBe(
+			true,
+		);
 	});
 
-	test("enabled with NO version is not installed — the broken state", () => {
+	test("installed with NO version is still installed — files missing", () => {
 		// dev@magus, measured: `.claude/settings.json` had "dev@magus": true while
 		// installed_plugins.json had no entry resolving for the project path.
-		expect(isInstalledInScope({ enabled: true })).toBe(false);
+		// Installed is the settings fact; the missing version is the broken
+		// sub-state, and the scope key still resolves it to `install` (below).
+		expect(isInstalledInScope({ installed: true })).toBe(true);
 	});
 
-	test("a registry version with the flag off IS installed", () => {
-		// Installation and enablement are separate facts. This asserted `false`
-		// until it was measured against the other direction: a plugin with a real
-		// registry row that the user had simply switched off reported "not
-		// installed", so its row offered to install what was already on disk, and
-		// the header counted it out.
-		//
-		// The hazard the sibling test above guards — pressing a scope key on
-		// enabled-with-no-version and having it run `uninstall` — is untouched:
-		// that case has no version, so it is still not installed, and still
-		// resolves to `install`.
-		expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(true);
+	test("a registry version with the settings flag off is NOT installed", () => {
+		// A registry row alone never makes Claude Code load a plugin, and it can
+		// be inherited from another checkout of the same repository.
+		expect(isInstalledInScope({ installed: false, version: "3.0.2" })).toBe(
+			false,
+		);
 	});
 
 	test("an absent scope is not installed", () => {
@@ -50,7 +46,9 @@ describe("isInstalledInScope", () => {
 	});
 
 	test('"0.0.0" counts as installed — Anthropic official plugins record it', () => {
-		expect(isInstalledInScope({ enabled: true, version: "0.0.0" })).toBe(true);
+		expect(isInstalledInScope({ installed: true, version: "0.0.0" })).toBe(
+			true,
+		);
 	});
 });
 
@@ -59,34 +57,34 @@ describe("resolveScopeAction", () => {
 	// takes from the classifier (`scopeIsBehind`). It used to be the catalog
 	// version, compared here with raw string inequality — a fourth rule.
 
-	test("REGRESSION: enabled but not installed resolves to install, never uninstall", () => {
+	test("REGRESSION: files missing resolves to install, never uninstall", () => {
 		// This is the reported bug. Before the fix this returned "uninstall".
-		expect(resolveScopeAction({ enabled: true }, false)).toBe("install");
+		expect(resolveScopeAction({ installed: true }, false)).toBe("install");
 		// Whatever the classifier says: the safety branch comes first.
-		expect(resolveScopeAction({ enabled: true }, true)).toBe("install");
+		expect(resolveScopeAction({ installed: true }, true)).toBe("install");
 	});
 
-	test("a scope that was never enabled resolves to install", () => {
+	test("a scope that was never installed resolves to install", () => {
 		expect(resolveScopeAction(undefined, false)).toBe("install");
-		expect(resolveScopeAction({ enabled: false }, false)).toBe("install");
+		expect(resolveScopeAction({ installed: false }, false)).toBe("install");
 	});
 
 	test("a healthy install at the latest version resolves to uninstall (toggle off)", () => {
-		expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, false)).toBe(
-			"uninstall",
-		);
+		expect(
+			resolveScopeAction({ installed: true, version: "3.0.2" }, false),
+		).toBe("uninstall");
 	});
 
 	test("a healthy install behind the catalog resolves to update", () => {
-		expect(resolveScopeAction({ enabled: true, version: "2.9.0" }, true)).toBe(
-			"update",
-		);
+		expect(
+			resolveScopeAction({ installed: true, version: "2.9.0" }, true),
+		).toBe("update");
 	});
 });
 
 /** The screen's path: classify, then ask `scopeIsBehind` for the pressed scope. */
 function keyFor(installed: string, catalogVersion: string | null) {
-	const scope = { enabled: true, version: installed };
+	const scope = { installed: true, version: installed };
 	const [status] = planPluginUpdates(
 		{ "x@magus": "latest" },
 		new Map([
@@ -99,7 +97,6 @@ function keyFor(installed: string, catalogVersion: string | null) {
 					description: "",
 					marketplace: "magus",
 					marketplaceDisplay: "Magus",
-					enabled: true,
 					projectScope: scope,
 				} as PluginInfo,
 			],

package/src/__tests__/scope-row-lookup.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Which registry row a question reads — the pure halves of two fixes whose
+ * end-to-end cases are in installed-version-scope.test.tsx.
+ *
+ * - `ownRegistryEntry`: "does THIS project hold a row at this scope?" — the
+ *   apply engine's guard before `update`. It used to be answered by the lookup
+ *   that falls back to inherited rows and then the user row.
+ * - `contentDriftEntry`: the row whose commit a content-drift check compares.
+ *   It used to be the project lookup for every plugin, installed there or not.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { ownRegistryEntry } from "../services/claude-settings.js";
+import {
+	type PluginInfo,
+	contentDriftEntry,
+} from "../services/plugin-manager.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+
+const REPO = "/work/repo";
+const HERE = "/work/repo/sub";
+
+const row = (over: Partial<InstalledPluginEntry>): InstalledPluginEntry => ({
+	scope: "user",
+	installPath: "/cache",
+	version: "1.0.0",
+	installedAt: "",
+	lastUpdated: "",
+	...over,
+});
+
+describe("ownRegistryEntry — this project's own row, exactly", () => {
+	test("never falls back to the user row for project or local scope", () => {
+		const rows = [row({ scope: "user" })];
+		expect(ownRegistryEntry(rows, "project", HERE)).toBeUndefined();
+		expect(ownRegistryEntry(rows, "local", HERE)).toBeUndefined();
+		expect(ownRegistryEntry(rows, "user", HERE)?.scope).toBe("user");
+	});
+
+	test("never takes a row inherited from the repository root", () => {
+		const rows = [row({ scope: "project", projectPath: REPO })];
+		expect(ownRegistryEntry(rows, "project", HERE)).toBeUndefined();
+	});
+
+	test("matches scope and path exactly — a local row is not a project row", () => {
+		const local = row({ scope: "local", projectPath: HERE, version: "3.0.0" });
+		const project = row({
+			scope: "project",
+			projectPath: `${HERE}/`,
+			version: "2.0.0",
+		});
+		expect(ownRegistryEntry([local], "project", HERE)).toBeUndefined();
+		expect(ownRegistryEntry([local, project], "project", HERE)?.version).toBe(
+			"2.0.0",
+		);
+		expect(ownRegistryEntry([local, project], "local", HERE)?.version).toBe(
+			"3.0.0",
+		);
+	});
+});
+
+describe("contentDriftEntry — the row behind an installed scope", () => {
+	const USER = row({ scope: "user", version: "0.9.0", gitCommitSha: "user" });
+	const INHERITED = row({
+		scope: "project",
+		projectPath: REPO,
+		version: "0.8.1",
+		gitCommitSha: "inherited",
+	});
+	const OWN = row({
+		scope: "project",
+		projectPath: HERE,
+		version: "0.9.0",
+		gitCommitSha: "own",
+	});
+	const plugin = (over: Partial<PluginInfo>): PluginInfo => ({
+		id: "probe@magus",
+		name: "probe",
+		version: "0.9.0",
+		description: "",
+		marketplace: "magus",
+		marketplaceDisplay: "Magus",
+		installedVersion: "0.9.0",
+		...over,
+	});
+
+	test("installed at user, beside an inherited project row of another version: the user row", () => {
+		const entry = contentDriftEntry(
+			plugin({
+				userScope: { installed: true, version: "0.9.0" },
+				projectScope: { installed: false, version: "0.8.1" },
+			}),
+			[USER, INHERITED],
+			HERE,
+			[REPO],
+		);
+		expect(entry?.gitCommitSha).toBe("user");
+	});
+
+	test("installed at both at the same version: this directory's row first", () => {
+		const entry = contentDriftEntry(
+			plugin({
+				userScope: { installed: true, version: "0.9.0" },
+				projectScope: { installed: true, version: "0.9.0" },
+			}),
+			[USER, OWN],
+			HERE,
+			[REPO],
+		);
+		expect(entry?.gitCommitSha).toBe("own");
+	});
+
+	test("no installed scope with a version: no row", () => {
+		const entry = contentDriftEntry(
+			plugin({
+				installedVersion: undefined,
+				userScope: { installed: true },
+				projectScope: { installed: false, version: "0.8.1" },
+			}),
+			[INHERITED],
+			HERE,
+			[REPO],
+		);
+		expect(entry).toBeUndefined();
+	});
+});