magus-cli 7.5.2 → 7.5.4

package/src/__tests__/format-update-outcome.test.ts

@@ -0,0 +1,367 @@
+/**
+ * Spec 7.5.4 re-review — REQ-12: a refused format update is a failure in the TUI, as in
+ * the CLI.
+ *
+ * Written blind: from the spec and the exported signatures of `prepareProfileStartup`,
+ * `ProfileStartup`, `ProfileStartupNeed`, `formatUpdateOutcome` and `FormatUpdateOutcome`
+ * only. `formatUpdateOutcome` is what the TUI shows after "Update it now"; `problems` is
+ * what the gate refused — the lines the CLI stops on.
+ *
+ * REQ-12a–12d call the pure `formatUpdateOutcome` in-process on hand-built results.
+ *
+ * REQ-12e–12g run `prepareProfileStartup` on a real git repository holding the old
+ * layout, in a CHILD process that starts with HOME, CLAUDE_CONFIG_DIR and XDG_* already
+ * pointing at temp dirs (Bun's `os.homedir()` ignores a HOME changed at runtime), with
+ * stdin/stdout forced non-TTY and colours off. The child's PATH carries only `bun` and
+ * `git`, so nothing here can reach a real `claude` CLI or the real `~/.claude`. The child
+ * also computes `formatUpdateOutcome` on the result and writes everything as JSON.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync } from "node:fs";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	realpath,
+	rm,
+	symlink,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+	type ProfileStartup,
+	type ProfileStartupNeed,
+	type ProfileStartupState,
+	formatUpdateOutcome,
+} from "../services/profile-startup.js";
+
+const SRC = join(import.meta.dir, "..");
+const MODULES = {
+	ansi: join(SRC, "cli", "ansi.ts"),
+	startup: join(SRC, "services", "profile-startup.ts"),
+};
+
+const CHILD_TIMEOUT_MS = 45_000;
+const CHILD_TEST_TIMEOUT_MS = 60_000;
+
+// ---------------------------------------------------------------------------
+// Pure cases
+// ---------------------------------------------------------------------------
+
+function needIn(state: ProfileStartupState): ProfileStartupNeed {
+	return {
+		state,
+		adopt: null,
+		activate: [],
+		declaredDefault: null,
+		autoActivate: false,
+		manifest: { version: 2, profiles: {} },
+	};
+}
+
+describe("REQ-12 formatUpdateOutcome: what the TUI shows after Update it now", () => {
+	test('REQ-12a a problem makes the outcome "failed" with the fixed title and the problem in the message, even when the state reads ok', () => {
+		const result: ProfileStartup = {
+			need: needIn("ok"),
+			notices: [],
+			problems: ["boom"],
+		};
+
+		const outcome = formatUpdateOutcome(result);
+
+		expect(outcome).toEqual({
+			kind: "failed",
+			title: "Could not update the profile format",
+			message: expect.stringContaining("boom"),
+		});
+	});
+
+	test('REQ-12b no problems and a need still to answer gives "ask" carrying the same need object', () => {
+		const need = needIn("inactive");
+		const result: ProfileStartup = { need, notices: [], problems: [] };
+
+		const outcome = formatUpdateOutcome(result);
+
+		expect(outcome.kind).toBe("ask");
+		expect((outcome as { need?: unknown }).need).toBe(need);
+	});
+
+	test('REQ-12c no problems, state ok and a notice gives "updated" titled Profile format updated with the notice in the message', () => {
+		const result: ProfileStartup = {
+			need: needIn("ok"),
+			notices: ["absorbed 1 edit"],
+			problems: [],
+		};
+
+		const outcome = formatUpdateOutcome(result);
+
+		expect(outcome).toEqual({
+			kind: "updated",
+			title: "Profile format updated",
+			message: expect.stringContaining("absorbed 1 edit"),
+		});
+	});
+
+	test('REQ-12d no problems, state ok and no notices gives "updated" with the fixed current-format message', () => {
+		const result: ProfileStartup = {
+			need: needIn("ok"),
+			notices: [],
+			problems: [],
+		};
+
+		const outcome = formatUpdateOutcome(result);
+
+		expect(outcome).toEqual({
+			kind: "updated",
+			title: expect.any(String),
+			message: "This project now uses the current profile format.",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Real-tree cases
+// ---------------------------------------------------------------------------
+
+/** mode `prepare`: prepareProfileStartup with NO options. mode `convert`: `{ convert: true }`. */
+const STARTUP_CHILD = `
+import { writeFileSync } from "node:fs";
+
+const [mode, project, resultPath] = process.argv.slice(2);
+const ansi = await import(${JSON.stringify(MODULES.ansi)});
+const startup = await import(${JSON.stringify(MODULES.startup)});
+
+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 out = {
+	state: null,
+	notices: null,
+	problems: null,
+	outcome: null,
+	error: null,
+};
+try {
+	const prepared =
+		mode === "convert"
+			? await startup.prepareProfileStartup(project, { convert: true })
+			: await startup.prepareProfileStartup(project);
+	out.state = prepared.need.state;
+	out.notices = prepared.notices;
+	out.problems = Array.isArray(prepared.problems) ? prepared.problems : null;
+	const outcome = startup.formatUpdateOutcome(prepared);
+	out.outcome =
+		outcome.kind === "ask"
+			? { kind: "ask", needState: outcome.need.state }
+			: { kind: outcome.kind, title: outcome.title, message: outcome.message };
+} catch (e) {
+	out.error = e instanceof Error ? (e.stack ?? e.message) : String(e);
+}
+writeFileSync(resultPath, JSON.stringify(out));
+process.exit(0);
+`;
+
+interface StartupRun {
+	state: ProfileStartupState | null;
+	notices: string[] | null;
+	/** Null when the result carried no `problems` array at all. */
+	problems: string[] | null;
+	outcome:
+		| { kind: "ask"; needState: ProfileStartupState }
+		| { kind: "updated" | "failed"; title: string; message: string }
+		| null;
+	error: string | null;
+}
+
+/** The target file the settings symlink names, when it does NOT parse (REQ-12e). */
+const UNPARSEABLE_TARGET = '{"enabledPlugins": {"dev@magus": true,},}\n';
+/** The same file when it parses (REQ-12f). */
+const PARSEABLE_TARGET = '{"enabledPlugins":{"dev@magus":true}}\n';
+const PROFILES_JSON =
+	'{"version":2,"profiles":{"team":{"name":"team","plugins":{"dev@magus":true}}}}\n';
+
+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("fuo-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, "startup-child.ts"), STARTUP_CHILD);
+});
+
+afterAll(async () => {
+	for (const dir of scratch) await rm(dir, { recursive: true, force: true });
+});
+
+interface Project {
+	base: string;
+	project: string;
+	env: Record<string, string>;
+}
+
+/**
+ * A real git repository holding the old layout, everything committed:
+ * `.claude/profiles.json` defining `team`, `.claude/_profiles/team/settings.json` with
+ * `targetContent`, and `.claude/settings.json` a SYMLINK to the RELATIVE path
+ * `_profiles/team/settings.json`. HOME, CLAUDE_CONFIG_DIR (`<HOME>/.claude`) and XDG_*
+ * are temp dirs beside it.
+ */
+async function oldLayoutProject(targetContent: string): Promise<Project> {
+	const base = await tempRoot("fuo-");
+	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 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 project = join(base, "proj");
+	await mkdir(project, { recursive: true });
+	const git = (...args: string[]): void => {
+		const r = Bun.spawnSync({
+			cmd: [
+				"git",
+				"-c",
+				"user.email=t@t",
+				"-c",
+				"user.name=t",
+				"-c",
+				"commit.gpgsign=false",
+				...args,
+			],
+			cwd: project,
+			env,
+		});
+		if (r.exitCode !== 0) {
+			throw new Error(`git ${args.join(" ")} failed: ${r.stderr.toString()}`);
+		}
+	};
+	git("init", "-q");
+	const target = join(project, ".claude", "_profiles", "team", "settings.json");
+	await mkdir(dirname(target), { recursive: true });
+	await writeFile(target, targetContent);
+	await symlink(
+		"_profiles/team/settings.json",
+		join(project, ".claude", "settings.json"),
+	);
+	await writeFile(join(project, ".claude", "profiles.json"), PROFILES_JSON);
+	git("add", "-A");
+	git("commit", "-q", "-m", "init");
+	return { base, project, env };
+}
+
+async function runStartup(
+	proj: Project,
+	mode: "prepare" | "convert",
+): Promise<StartupRun> {
+	const resultPath = join(proj.base, `result-${mode}.json`);
+	const proc = Bun.spawn({
+		cmd: [
+			process.execPath,
+			"--no-env-file",
+			join(helperDir, "startup-child.ts"),
+			mode,
+			proj.project,
+			resultPath,
+		],
+		cwd: proj.project,
+		env: proj.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(
+			`startup child wrote no result (exit ${code}).\nstdout:\n${stdout}\nstderr:\n${stderr}`,
+		);
+	}
+	return JSON.parse(raw) as StartupRun;
+}
+
+describe("REQ-12 a refused format update is a failure in the TUI, as in the CLI", () => {
+	test(
+		'REQ-12e converting an old layout whose settings target does not parse returns a problem, a "failed" outcome, and leaves .claude/_profiles/ in place',
+		async () => {
+			const proj = await oldLayoutProject(UNPARSEABLE_TARGET);
+			const oldDir = join(proj.project, ".claude", "_profiles");
+			expect(existsSync(oldDir)).toBe(true);
+
+			const run = await runStartup(proj, "convert");
+
+			expect(run.error).toBeNull();
+			expect(run.problems).not.toBeNull();
+			expect(run.problems?.length ?? 0).toBeGreaterThan(0);
+			expect(run.outcome?.kind).toBe("failed");
+			expect(existsSync(oldDir)).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		'REQ-12f negative control: converting an old layout whose settings target parses returns no problems and an outcome that is not "failed"',
+		async () => {
+			const proj = await oldLayoutProject(PARSEABLE_TARGET);
+
+			const run = await runStartup(proj, "convert");
+
+			expect(run.error).toBeNull();
+			expect(run.problems).toEqual([]);
+			expect(run.outcome).not.toBeNull();
+			expect(run.outcome?.kind).not.toBe("failed");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		'REQ-12g without options, the unparseable old layout is asked about as "old-format", refuses nothing and converts nothing',
+		async () => {
+			const proj = await oldLayoutProject(UNPARSEABLE_TARGET);
+			const oldDir = join(proj.project, ".claude", "_profiles");
+
+			const run = await runStartup(proj, "prepare");
+
+			expect(run.error).toBeNull();
+			expect(run.state).toBe("old-format");
+			expect(run.problems).toEqual([]);
+			expect(existsSync(oldDir)).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+});

package/src/__tests__/gitignore-check.test.ts

@@ -1,19 +1,16 @@
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import { spawnSync } from "node:child_process";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults.js";
-import {
-	checkGitignore,
-	formatGitignoreWarning,
-} from "../services/gitignore-check";
+import { startupGitignoreNeed } from "../services/gitignore-check";
 
 function git(cwd: string, ...args: string[]): void {
 	spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], { cwd });
 }
 
-describe("checkGitignore", () => {
+describe("startupGitignoreNeed", () => {
 	let projectDir: string;
 
 	beforeEach(async () => {
@@ -24,20 +21,21 @@ describe("checkGitignore", () => {
 		await rm(projectDir, { recursive: true, force: true });
 	});
 
-	it("returns 0 violations for non-git directory", async () => {
-		const r = await checkGitignore(projectDir);
-		expect(r.violationCount).toBe(0);
+	it("asks nothing in a non-git directory", async () => {
+		expect(await startupGitignoreNeed(projectDir)).toBeNull();
 	});
 
 	it("flags missing built-in patterns inside a fresh git repo", async () => {
 		git(projectDir, "init", "-q");
-		const r = await checkGitignore(projectDir);
+		const need = await startupGitignoreNeed(projectDir);
 		// BUILTIN_DEFAULTS includes ".mnemex/" etc. — none are tracked, none in
 		// .gitignore, so each one becomes "missing-from-gitignore".
-		expect(r.violationCount).toBeGreaterThan(0);
+		expect(need?.violationCount).toBeGreaterThan(0);
+		expect(need?.safeCount).toBeGreaterThan(0);
+		expect(need?.generated).toEqual([]);
 	});
 
-	it("returns 0 when .gitignore covers all built-in patterns and tracked files match track rules", async () => {
+	it("asks nothing when .gitignore covers all built-in patterns and tracked files match track rules", async () => {
 		git(projectDir, "init", "-q");
 		git(projectDir, "config", "user.email", "t@t");
 		git(projectDir, "config", "user.name", "t");
@@ -50,22 +48,6 @@ describe("checkGitignore", () => {
 			`${BUILTIN_DEFAULTS.ignore.join("\n")}\n`,
 		);
 		// Tracked files don't have to exist for the absent-track-path case to be ignored
-		const r = await checkGitignore(projectDir);
-		expect(r.violationCount).toBe(0);
-	});
-});
-
-describe("formatGitignoreWarning", () => {
-	it("returns null when no violations", () => {
-		expect(
-			formatGitignoreWarning({ violationCount: 0, warnings: [] }),
-		).toBeNull();
-	});
-
-	it("returns a warning string when violations exist", () => {
-		const w = formatGitignoreWarning({ violationCount: 3, warnings: [] });
-		expect(w).not.toBeNull();
-		expect(w).toContain("3 git state");
-		expect(w).toContain("Git State tab");
+		expect(await startupGitignoreNeed(projectDir)).toBeNull();
 	});
 });

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

@@ -0,0 +1,248 @@
+/**
+ * B7 — in a project with profiles, a generated file git tracks is a question
+ * asked on every TUI open, fixed in place when the user says so.
+ *
+ * The files magus generates from `.claude/profiles.json` are expected to be
+ * gitignored. The gitignore manager's `profile` tier says so, so a committed
+ * copy is reported as "tracked but should be ignored" — and the startup fix
+ * untracks exactly those files, leaving every other violation for the tab.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { startupGitignoreNeed } from "../services/gitignore-check.js";
+import {
+	applyStartupFixes,
+	describeStartupFix,
+	loadGitignoreState,
+} from "../services/gitignore-service.js";
+import { writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
+import {
+	folderHash,
+	readActiveMarker,
+	writeActiveMarker,
+} from "../services/profile-live.js";
+import {
+	applyProfileChoice,
+	prepareProfileState,
+} from "../services/profile-state.js";
+import type { ProfileManifest } from "../types/index.js";
+import { buildGitignoreModal } from "../ui/hooks/useGitignoreModal.js";
+
+const MANIFEST: ProfileManifest = {
+	version: 2,
+	profiles: { team: { name: "Team", plugins: { "dev@magus": "latest" } } },
+};
+
+let project: string;
+let log: ReturnType<typeof spyOn>;
+
+function git(...args: string[]) {
+	return spawnSync(
+		"git",
+		[
+			"-c",
+			"user.email=test@example.com",
+			"-c",
+			"user.name=test",
+			"-c",
+			"commit.gpgsign=false",
+			"-c",
+			"core.excludesFile=/dev/null",
+			...args,
+		],
+		{ cwd: project, encoding: "utf8" },
+	);
+}
+
+/** A repo that commits `.claude/settings.json` (and, optionally, profiles.json). */
+async function commitSettings(withProfiles: boolean): Promise<void> {
+	expect(git("init", "-q").status).toBe(0);
+	await fs.outputJson(join(project, ".claude", "settings.json"), {
+		enabledPlugins: { "dev@magus": true },
+	});
+	if (withProfiles) await writeManifest(MANIFEST, project);
+	expect(git("add", "-A").status).toBe(0);
+	expect(git("commit", "-q", "-m", "init").status).toBe(0);
+}
+
+beforeEach(async () => {
+	project = await fs.realpath(await mkdtemp(join(tmpdir(), "gitig-prof-")));
+	log = spyOn(console, "log").mockImplementation(() => {});
+});
+afterEach(async () => {
+	log.mockRestore();
+	await rm(project, { recursive: true, force: true });
+});
+
+describe("the startup question names tracked generated files", () => {
+	test("B7: in a project with profiles, a committed settings.json is tracked-but-should-ignore", async () => {
+		await commitSettings(true);
+
+		const need = await startupGitignoreNeed(project);
+
+		expect(need?.generated).toEqual([".claude/settings.json"]);
+		const { violations } = await loadGitignoreState(project);
+		expect(violations).toContainEqual({
+			kind: "tracked-but-should-ignore",
+			path: ".claude/settings.json",
+			source: "profile",
+			severity: "destructive",
+		});
+	});
+
+	test("B7: without profiles, a committed settings.json is the team's file — nothing generated to ask about", async () => {
+		await commitSettings(false);
+		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
+	});
+
+	test("B7: nothing is remembered — dismissing leaves the question for the next open", async () => {
+		await commitSettings(true);
+		// Two opens, the first dismissed (dismiss changes nothing).
+		const first = await startupGitignoreNeed(project);
+		const second = await startupGitignoreNeed(project);
+		expect(first?.generated).toEqual([".claude/settings.json"]);
+		expect(second).toEqual(first);
+	});
+
+	test("B7: after a first adoption in the same session, the re-check asks about the file adoption made generated", async () => {
+		await commitSettings(false);
+		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
+
+		// The profile modal's "Save what you have".
+		await applyProfileChoice(
+			{ kind: "adopt", id: "default" },
+			{ version: 2, profiles: {} },
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect((await startupGitignoreNeed(project))?.generated).toEqual([
+			".claude/settings.json",
+		]);
+	});
+});
+
+describe("the startup fix untracks generated files in place", () => {
+	test("B7: only generated files are untracked; other violations stay; the removal is staged", async () => {
+		await commitSettings(true);
+		// Another violation magus does not own: a committed personal settings file.
+		await fs.outputJson(join(project, ".claude", "settings.local.json"), {});
+		expect(git("add", "-f", ".claude/settings.local.json").status).toBe(0);
+		expect(git("commit", "-q", "-m", "local").status).toBe(0);
+
+		const result = await applyStartupFixes(project);
+
+		expect(result.untracked).toEqual([".claude/settings.json"]);
+		expect(result.failed).toEqual([]);
+		const status = git("status", "--porcelain").stdout;
+		expect(status).toContain("D  .claude/settings.json");
+		expect(status).not.toContain("settings.local.json");
+		expect(git("ls-files", ".claude/settings.local.json").stdout.trim()).toBe(
+			".claude/settings.local.json",
+		);
+		// The file itself is kept, and now ignored.
+		expect(await fs.pathExists(join(project, ".claude", "settings.json"))).toBe(
+			true,
+		);
+		expect(await fs.readFile(join(project, ".gitignore"), "utf8")).toContain(
+			".claude/settings.json",
+		);
+		expect(describeStartupFix(result)).toContain(
+			"Stopped tracking (the removal is staged — commit it):",
+		);
+		// Asked again on the next open: nothing generated is tracked any more.
+		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
+	});
+
+	test("B7: the modal offers the in-place fix and names the files", async () => {
+		const modal = buildGitignoreModal({
+			violationCount: 3,
+			safeCount: 2,
+			generated: [".claude/settings.json"],
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.options.map((o) => o.value)).toEqual([
+			"fix-safe",
+			"open-tab",
+			"dismiss",
+		]);
+		expect(modal.options[0]?.label).toBe(
+			"Stop tracking 1 generated file and add 2 missing .gitignore entries",
+		);
+		expect(modal.message).toContain("  .claude/settings.json");
+		expect(modal.message).toContain("expected to be gitignored");
+	});
+});
+
+describe("review: what the profile tier must never claim", () => {
+	test("B7 review M: a committed skill an old marker records as magus's is never flagged, never untracked, and handed back", async () => {
+		expect(git("init", "-q").status).toBe(0);
+		await fs.outputFile(
+			join(project, ".claude", "skills", "review", "SKILL.md"),
+			"---\nname: review\n---\nteam skill\n",
+		);
+		expect(git("add", "-A").status).toBe(0);
+		expect(git("commit", "-q", "-m", "team skill").status).toBe(0);
+		await writeManifest(MANIFEST, project);
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+		// What 7.5.0's conversion wrote: the committed folder recorded as installed.
+		const marker = await readActiveMarker(project);
+		if (!marker) throw new Error("no marker");
+		await writeActiveMarker(
+			{
+				...marker,
+				skills: {
+					review: (await folderHash(
+						join(project, ".claude", "skills", "review"),
+					)) as string,
+				},
+			},
+			project,
+		);
+
+		expect(
+			(await startupGitignoreNeed(project))?.generated ?? [],
+		).not.toContain(".claude/skills/review/SKILL.md");
+		const fixed = await applyStartupFixes(project);
+		expect(fixed.untracked).not.toContain(".claude/skills/review/SKILL.md");
+		expect(git("diff", "--cached", "--name-only").stdout).toBe("");
+
+		// The next marker write drops it, and says so once.
+		const prep = await prepareProfileState(project);
+		expect(prep.lines).toContain(
+			"Skill review is committed by the team — magus no longer manages it",
+		);
+		expect((await readActiveMarker(project))?.skills).toEqual({});
+		expect(
+			await fs.pathExists(
+				join(project, ".claude", "skills", "review", "SKILL.md"),
+			),
+		).toBe(true);
+		expect((await prepareProfileState(project)).lines.join("\n")).not.toContain(
+			"committed by the team",
+		);
+	});
+
+	test("B7 review L2: a left-over marker in a repo that dropped profiles.json is not profiled", async () => {
+		expect(git("init", "-q").status).toBe(0);
+		await writeManifest(MANIFEST, project);
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+		await fs.remove(join(project, ".claude", "profiles.json"));
+		expect(git("add", "-f", ".claude/settings.json").status).toBe(0);
+		expect(
+			git("commit", "-q", "-m", "team commits settings again").status,
+		).toBe(0);
+
+		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
+		expect((await applyStartupFixes(project)).untracked).toEqual([]);
+	});
+});