magus-cli 7.5.2 → 7.5.4

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();
+	});
+});

package/src/__tests__/select-restore.test.ts

@@ -0,0 +1,209 @@
+/**
+ * `selectOption` always puts the terminal back.
+ *
+ * It sets raw mode, attaches a keypress listener and hides the cursor, and only
+ * Enter, Esc and Ctrl+C undid them. A throw while drawing, a SIGTERM or a SIGHUP
+ * left the shell in raw mode with no cursor — typing blind until `reset`.
+ *
+ * `process.stdin` and `process.stdout` are swapped for fakes for the length of
+ * each case, so no real terminal is touched; `process.exit` is stubbed wherever
+ * a signal handler would call it.
+ */
+
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+import { EventEmitter } from "node:events";
+import { selectOption } from "../cli/select.js";
+
+const SHOW_CURSOR = "\x1b[?25h";
+const HIDE_CURSOR = "\x1b[?25l";
+/** Every frame row is written with this prefix; control sequences are not. */
+const FRAME_ROW = "\x1b[2K";
+
+class FakeStdin extends EventEmitter {
+	isTTY = true;
+	isRaw = false;
+	setRawMode(raw: boolean): this {
+		this.isRaw = raw;
+		return this;
+	}
+	resume(): this {
+		return this;
+	}
+	pause(): this {
+		return this;
+	}
+	key(name: string, extra: Record<string, unknown> = {}): void {
+		this.emit("keypress", "", { name, ...extra });
+	}
+}
+
+class FakeStdout {
+	isTTY = true;
+	writes: string[] = [];
+	frames = 0;
+	/** Throw on this frame (1-based): the first draw, or a redraw. */
+	constructor(private readonly throwOnFrame = 0) {}
+	write(chunk: string): boolean {
+		if (chunk.includes(FRAME_ROW) && ++this.frames === this.throwOnFrame) {
+			throw new Error("the terminal went away");
+		}
+		this.writes.push(chunk);
+		return true;
+	}
+}
+
+const WATCHED = ["exit", "SIGTERM", "SIGHUP"] as const;
+const listenerCounts = () =>
+	Object.fromEntries(WATCHED.map((e) => [e, process.listenerCount(e)]));
+
+const originals = {
+	stdin: Object.getOwnPropertyDescriptor(process, "stdin"),
+	stdout: Object.getOwnPropertyDescriptor(process, "stdout"),
+};
+
+function useFakes(stdout = new FakeStdout()) {
+	const stdin = new FakeStdin();
+	Object.defineProperty(process, "stdin", {
+		value: stdin,
+		configurable: true,
+		writable: true,
+	});
+	Object.defineProperty(process, "stdout", {
+		value: stdout,
+		configurable: true,
+		writable: true,
+	});
+	return { stdin, stdout };
+}
+
+let exitSpy: ReturnType<typeof spyOn> | null = null;
+
+afterEach(() => {
+	if (originals.stdin) Object.defineProperty(process, "stdin", originals.stdin);
+	if (originals.stdout)
+		Object.defineProperty(process, "stdout", originals.stdout);
+	exitSpy?.mockRestore();
+	exitSpy = null;
+});
+
+const ITEMS = [{ label: "One" }, { label: "Two" }, { label: "Three" }];
+
+/** Raw mode off, no keypress listener, the cursor shown after it was hidden. */
+function expectRestored(stdin: FakeStdin, stdout: FakeStdout): void {
+	expect(stdin.isRaw).toBe(false);
+	expect(stdin.listenerCount("keypress")).toBe(0);
+	const hidden = stdout.writes.lastIndexOf(HIDE_CURSOR);
+	expect(hidden).toBeGreaterThanOrEqual(0);
+	expect(stdout.writes.lastIndexOf(SHOW_CURSOR)).toBeGreaterThan(hidden);
+}
+
+describe("an answer still behaves as it did", () => {
+	test("Enter picks the current row, and the terminal is back", async () => {
+		const { stdin, stdout } = useFakes();
+		const baseline = listenerCounts();
+		const answer = selectOption("Pick", ITEMS);
+		stdin.key("down");
+		stdin.key("return");
+
+		expect(await answer).toBe(1);
+		expectRestored(stdin, stdout);
+		// The cursor is shown last, after the one-line answer.
+		expect(stdout.writes.at(-1)).toBe(SHOW_CURSOR);
+		expect(stdout.writes.at(-2)).toContain("Two");
+		expect(listenerCounts()).toEqual(baseline);
+	});
+
+	test("Esc and Ctrl+C cancel with null, and the terminal is back", async () => {
+		for (const key of [{ name: "escape" }, { name: "c", ctrl: true }]) {
+			const { stdin, stdout } = useFakes();
+			const answer = selectOption("Pick", ITEMS);
+			stdin.key(key.name, key);
+			expect(await answer).toBeNull();
+			expectRestored(stdin, stdout);
+		}
+	});
+
+	test("keys after the answer in the same read are not handled", async () => {
+		const { stdin, stdout } = useFakes();
+		const answer = selectOption("Pick", ITEMS);
+		stdin.key("return");
+		stdin.key("down");
+		stdin.key("return");
+		expect(await answer).toBe(0);
+		expect(stdout.writes.filter((w) => w.includes("One")).length).toBe(2);
+	});
+});
+
+describe("anything else that ends it puts the terminal back too", () => {
+	test("a throw on the first draw rejects, and the terminal is back", async () => {
+		const { stdin, stdout } = useFakes(new FakeStdout(1));
+		const baseline = listenerCounts();
+
+		await expect(selectOption("Pick", ITEMS)).rejects.toThrow(
+			"the terminal went away",
+		);
+		expectRestored(stdin, stdout);
+		expect(listenerCounts()).toEqual(baseline);
+	});
+
+	test("a throw redrawing after a key rejects instead of escaping the listener", async () => {
+		const { stdin, stdout } = useFakes(new FakeStdout(2));
+		const answer = selectOption("Pick", ITEMS);
+
+		expect(() => stdin.key("down")).not.toThrow();
+		await expect(answer).rejects.toThrow("the terminal went away");
+		expectRestored(stdin, stdout);
+	});
+
+	for (const [signal, code] of [
+		["SIGTERM", 143],
+		["SIGHUP", 129],
+	] as const) {
+		test(`${signal} puts the terminal back, then exits ${code}`, () => {
+			const { stdin, stdout } = useFakes();
+			const baseline = listenerCounts();
+			exitSpy = spyOn(process, "exit").mockImplementation(
+				(() => undefined) as never,
+			);
+			void selectOption("Pick", ITEMS);
+
+			process.emit(signal);
+
+			expectRestored(stdin, stdout);
+			expect(exitSpy).toHaveBeenCalledWith(code);
+			// One-shot, and the others went with it.
+			expect(listenerCounts()).toEqual(baseline);
+		});
+	}
+
+	test("the process exiting while it is open puts the terminal back", () => {
+		const { stdin, stdout } = useFakes();
+		const before = process.listeners("exit");
+		void selectOption("Pick", ITEMS);
+		const added = process.listeners("exit").filter((l) => !before.includes(l));
+
+		// Its own listener only: emitting "exit" would run everyone's.
+		expect(added).toHaveLength(1);
+		(added[0] as (code: number) => void)(0);
+
+		expectRestored(stdin, stdout);
+		expect(process.listeners("exit")).toEqual(before);
+	});
+});
+
+describe("the handlers live exactly as long as the list", () => {
+	test("one each while it is open, none after it answers", async () => {
+		const { stdin } = useFakes();
+		const baseline = listenerCounts();
+		const answer = selectOption("Pick", ITEMS);
+
+		expect(listenerCounts()).toEqual({
+			exit: baseline.exit + 1,
+			SIGTERM: baseline.SIGTERM + 1,
+			SIGHUP: baseline.SIGHUP + 1,
+		});
+		stdin.key("return");
+		await answer;
+		expect(listenerCounts()).toEqual(baseline);
+	});
+});

package/src/__tests__/stale-load-repair.test.ts

@@ -874,10 +874,9 @@ describe("the popup count equals the Plugins header count", () => {
 					description: "",
 					marketplace: id.split("@")[1] ?? "magus",
 					marketplaceDisplay: "",
-					enabled: true,
 					installedVersion: mine,
 					loadedVersion: loaded[id] ?? null,
-					projectScope: { enabled: true, version: mine },
+					projectScope: { installed: true, version: mine },
 				} as PluginInfo;
 			},
 		);

package/src/__tests__/update-apply.test.ts

@@ -177,7 +177,14 @@ describe("scope handling", () => {
 	test("a fresh install goes to project scope only", async () => {
 		const { deps, installed } = stubDeps("2.0.0");
 		await applyPlugins(
-			[item({ action: "install", installed: null, scopes: [] })],
+			[
+				item({
+					action: "install",
+					reason: "absent",
+					installed: null,
+					scopes: [],
+				}),
+			],
 			PROJECT,
 			deps,
 		);
@@ -228,7 +235,14 @@ describe("scope handling", () => {
 	test("a fresh install runs `install`, never `update`", async () => {
 		const { deps, installed, updated } = stubDeps("2.0.0");
 		await applyPlugins(
-			[item({ action: "install", installed: null, scopes: [] })],
+			[
+				item({
+					action: "install",
+					reason: "absent",
+					installed: null,
+					scopes: [],
+				}),
+			],
 			PROJECT,
 			deps,
 		);
@@ -715,6 +729,7 @@ describe("applyPlugins — read-back against beforeVersions", () => {
 			[
 				item({
 					action: "install",
+					reason: "absent",
 					installed: null,
 					scopes: [],
 					beforeVersions: {},
@@ -733,6 +748,7 @@ describe("applyPlugins — read-back against beforeVersions", () => {
 			[
 				item({
 					action: "install",
+					reason: "absent",
 					installed: null,
 					scopes: [],
 					beforeVersions: {},

package/src/__tests__/update-null-readback.test.ts

@@ -0,0 +1,300 @@
+/**
+ * Spec 7.5.4 re-review — REQ-11: an update that records no version is "no change",
+ * never "moved".
+ *
+ * Written blind: from the spec and the exported signatures of `applyPlugins`,
+ * `PluginApplyDeps`, `ApplyReporter`, `PluginApplyResult` and `PluginUpdateItem` only.
+ *
+ * magus judges an update by READ-BACK: after the installer runs it reads the version
+ * recorded at each scope it touched, and only a changed version counts as moved. These
+ * tests drive `applyPlugins` with a deps double whose installer always "succeeds" and whose
+ * `readInstalled` answers per case, and assert on the result and on what the reporter was
+ * told.
+ *
+ * `applyPlugins` runs in a CHILD process that starts with HOME, CLAUDE_CONFIG_DIR and XDG_*
+ * pointing at temp dirs (Bun's `os.homedir()` ignores a HOME changed at runtime), colours
+ * off, and a PATH holding only `bun` and `git` — so anything it might reach outside the
+ * injected deps cannot touch the real `~/.claude` or a real `claude` CLI. The deps double
+ * and the reporter live in the child, record every call, and the child writes the result,
+ * the `finish` records and the call log as JSON. The optional deps `loadedVersion`,
+ * `registryRows` and `inThisRepository` are left unset, as the spec requires.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	realpath,
+	rm,
+	symlink,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { PluginApplyResult } from "../services/update-engine.js";
+import type { PluginUpdateItem } from "../services/update-plan.js";
+
+const SRC = join(import.meta.dir, "..");
+const MODULES = {
+	ansi: join(SRC, "cli", "ansi.ts"),
+	engine: join(SRC, "services", "update-engine.ts"),
+};
+
+const CHILD_TIMEOUT_MS = 45_000;
+const CHILD_TEST_TIMEOUT_MS = 60_000;
+
+/** The one item every REQ-11 case applies, exactly as the spec states it. */
+const ITEM: PluginUpdateItem = {
+	pluginId: "p@m",
+	pinned: "latest",
+	installed: "1.0.0",
+	loaded: null,
+	available: "2.0.0",
+	target: "2.0.0",
+	action: "update",
+	reason: "behind",
+	scopes: ["project"],
+	beforeVersions: { project: "1.0.0" },
+};
+
+/**
+ * What the double's `readInstalled` resolves, for every call:
+ * - `null`: always `null` — the installer exited 0 and recorded nothing (REQ-11a).
+ * - `moves`: `"1.0.0"` until `deps.update` or `deps.install` has been called, `"2.0.0"`
+ *   after — a real move (REQ-11b).
+ * - `stays`: always `"1.0.0"` — the installer left the old version (REQ-11c).
+ */
+type Readback = "null" | "moves" | "stays";
+
+const APPLY_CHILD = `
+import { readFileSync, writeFileSync } from "node:fs";
+
+const [readback, itemPath, project, resultPath] = process.argv.slice(2);
+const ansi = await import(${JSON.stringify(MODULES.ansi)});
+const engine = await import(${JSON.stringify(MODULES.engine)});
+
+if (typeof ansi.setColorEnabled === "function") ansi.setColorEnabled(false);
+for (const stream of [process.stdin, process.stdout, process.stderr]) {
+	Object.defineProperty(stream, "isTTY", { value: false, configurable: true });
+}
+
+const item = JSON.parse(readFileSync(itemPath, "utf8"));
+const calls = [];
+const begins = [];
+const finishes = [];
+let installerRan = false;
+
+const deps = {
+	install: async (pluginId, scope) => {
+		calls.push(["install", pluginId, scope]);
+		installerRan = true;
+	},
+	update: async (pluginId, scope) => {
+		calls.push(["update", pluginId, scope]);
+		installerRan = true;
+	},
+	repair: async (pluginId, scope, projectPath) => {
+		calls.push(["repair", pluginId, scope, projectPath]);
+	},
+	readInstalled: async (pluginId, scope, projectPath) => {
+		let version;
+		if (readback === "null") version = null;
+		else if (readback === "stays") version = "1.0.0";
+		else version = installerRan ? "2.0.0" : "1.0.0";
+		calls.push(["readInstalled", pluginId, scope, projectPath, version]);
+		return version;
+	},
+	saveInstalled: async (pluginId, version, scope, projectPath) => {
+		calls.push(["saveInstalled", pluginId, version, scope, projectPath]);
+	},
+	repairStaleLoad: async (pluginId, target, projectPath) => {
+		calls.push(["repairStaleLoad", pluginId, target, projectPath]);
+		return { pluginId, target, rewritten: 0, backup: null, loaded: target, ok: true };
+	},
+};
+
+const report = {
+	begin: (name) => {
+		begins.push(name);
+	},
+	finish: (ok, name, detail, ms) => {
+		finishes.push({ ok, name, detail, ms });
+	},
+	detach: async (work) => work(),
+};
+
+const out = { result: null, begins, finishes, calls, error: null };
+try {
+	out.result = await engine.applyPlugins([item], project, deps, report);
+} catch (e) {
+	out.error = e instanceof Error ? (e.stack ?? e.message) : String(e);
+}
+writeFileSync(resultPath, JSON.stringify(out));
+process.exit(0);
+`;
+
+interface FinishRecord {
+	ok: boolean;
+	name: string;
+	detail: string;
+	ms: number;
+}
+
+interface ApplyRun {
+	result: PluginApplyResult | null;
+	begins: string[];
+	finishes: FinishRecord[];
+	calls: unknown[][];
+	error: string | null;
+}
+
+const scratch: string[] = [];
+let helperDir = "";
+let binDir = "";
+
+async function tempRoot(prefix: string): Promise<string> {
+	const dir = await realpath(await mkdtemp(join(tmpdir(), prefix)));
+	scratch.push(dir);
+	return dir;
+}
+
+beforeAll(async () => {
+	helperDir = await tempRoot("unrb-helpers-");
+	binDir = join(helperDir, "bin");
+	await mkdir(binDir);
+	await symlink(process.execPath, join(binDir, "bun"));
+	const git = Bun.which("git");
+	if (git) await symlink(git, join(binDir, "git"));
+	await writeFile(join(helperDir, "apply-child.ts"), APPLY_CHILD);
+});
+
+afterAll(async () => {
+	for (const dir of scratch) await rm(dir, { recursive: true, force: true });
+});
+
+/**
+ * Apply ITEM in a child with the given read-back behaviour. `projectPath` is a fresh
+ * temp dir; HOME, CLAUDE_CONFIG_DIR (`<HOME>/.claude`) and XDG_* are temp dirs beside it.
+ */
+async function runApply(readback: Readback): Promise<ApplyRun> {
+	const base = await tempRoot("unrb-");
+	const home = join(base, "home");
+	const xdg = join(base, "xdg");
+	await mkdir(join(home, ".claude"), { recursive: true });
+	for (const kind of ["config", "cache", "data", "state"]) {
+		await mkdir(join(xdg, kind), { recursive: true });
+	}
+	const project = join(base, "proj");
+	await mkdir(project, { recursive: true });
+	const itemPath = join(base, "item.json");
+	await writeFile(itemPath, JSON.stringify(ITEM));
+	const resultPath = join(base, `result-${readback}.json`);
+	const env = {
+		PATH: `${binDir}:/usr/bin:/bin`,
+		HOME: home,
+		CLAUDE_CONFIG_DIR: join(home, ".claude"),
+		XDG_CONFIG_HOME: join(xdg, "config"),
+		XDG_CACHE_HOME: join(xdg, "cache"),
+		XDG_DATA_HOME: join(xdg, "data"),
+		XDG_STATE_HOME: join(xdg, "state"),
+		TMPDIR: tmpdir(),
+		NO_COLOR: "1",
+		TERM: "dumb",
+		GIT_CONFIG_NOSYSTEM: "1",
+		GIT_CONFIG_GLOBAL: "/dev/null",
+	};
+	const proc = Bun.spawn({
+		cmd: [
+			process.execPath,
+			"--no-env-file",
+			join(helperDir, "apply-child.ts"),
+			readback,
+			itemPath,
+			project,
+			resultPath,
+		],
+		cwd: project,
+		env,
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const timer = setTimeout(() => proc.kill(), CHILD_TIMEOUT_MS);
+	const [stdout, stderr, code] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	clearTimeout(timer);
+	let raw: string;
+	try {
+		raw = await readFile(resultPath, "utf8");
+	} catch {
+		throw new Error(
+			`apply child wrote no result (exit ${code}).\nstdout:\n${stdout}\nstderr:\n${stderr}`,
+		);
+	}
+	return JSON.parse(raw) as ApplyRun;
+}
+
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+
+/**
+ * Every `finish` detail reported for `pluginId`, colour codes stripped, joined by
+ * newlines. Fails the test when nothing was reported for it.
+ */
+function finishDetail(run: ApplyRun, pluginId: string): string {
+	const mine = run.finishes.filter((f) => f.name.includes(pluginId));
+	expect(mine.length).toBeGreaterThan(0);
+	return mine.map((f) => f.detail.replace(ANSI, "")).join("\n");
+}
+
+describe("REQ-11 an update that records no version is no change, never moved", () => {
+	test(
+		"REQ-11a when read-back resolves null after the installer exits 0, the item is unchanged, not counted, and not reported as 2.0.0",
+		async () => {
+			const run = await runApply("null");
+
+			expect(run.error).toBeNull();
+			expect(run.result).not.toBeNull();
+			expect(run.result?.ok).toBe(0);
+			expect(run.result?.unchanged).toContain("p@m");
+			expect(run.result?.failed).toEqual([]);
+			const detail = finishDetail(run, "p@m");
+			expect(detail).toContain("no change");
+			expect(detail).not.toContain("2.0.0");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-11b negative control: when read-back moves from 1.0.0 to 2.0.0 after the installer, the item counts as changed and reports 2.0.0",
+		async () => {
+			const run = await runApply("moves");
+
+			expect(run.error).toBeNull();
+			expect(run.result).not.toBeNull();
+			expect(run.result?.ok).toBe(1);
+			expect(run.result?.unchanged).toEqual([]);
+			const detail = finishDetail(run, "p@m");
+			expect(detail).toContain("2.0.0");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-11c when the installer leaves 1.0.0 in place, the item is unchanged, not counted, and reported as no change at 1.0.0",
+		async () => {
+			const run = await runApply("stays");
+
+			expect(run.error).toBeNull();
+			expect(run.result).not.toBeNull();
+			expect(run.result?.ok).toBe(0);
+			expect(run.result?.unchanged).toContain("p@m");
+			const detail = finishDetail(run, "p@m");
+			expect(detail).toContain("no change");
+			expect(detail).toContain("1.0.0");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+});