magus-cli 7.5.2 → 7.5.4

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

@@ -0,0 +1,329 @@
+/**
+ * Spec 7.5.4 v3 — REQ-8: the TUI and the CLI get the SAME startup state in a subfolder.
+ *
+ * Written blind: from the spec and the exported signatures and types only. The TUI's
+ * startup question is built from `detectProfileStartupNeed`, `describeNeed` and
+ * `buildProfileOptions`; the CLI's is printed by `ensureManifest`. In a subfolder of a
+ * project that already has profiles, both must say the same thing.
+ *
+ * Every call runs 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. The helper script
+ * is written to a mkdtemp dir at runtime and removed afterwards.
+ */
+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 { basename, dirname, join } from "node:path";
+import type {
+	ProfileStartupNeed,
+	ProfileStartupState,
+} from "../services/profile-startup.js";
+
+const SRC = join(import.meta.dir, "..");
+const MODULES = {
+	ansi: join(SRC, "cli", "ansi.ts"),
+	bootstrap: join(SRC, "cli", "bootstrap.ts"),
+	startup: join(SRC, "services", "profile-startup.ts"),
+};
+
+const CHILD_TIMEOUT_MS = 45_000;
+const CHILD_TEST_TIMEOUT_MS = 60_000;
+
+/**
+ * mode `nested`: the three TUI functions on the subfolder, then `ensureManifest` on it
+ * with its output captured. mode `root`: `detectProfileStartupNeed` on the root only.
+ */
+const STARTUP_CHILD = `
+import { writeFileSync } from "node:fs";
+import { format } from "node:util";
+
+const [mode, target, resultPath] = process.argv.slice(2);
+const ansi = await import(${JSON.stringify(MODULES.ansi)});
+const startup = await import(${JSON.stringify(MODULES.startup)});
+const bootstrap = await import(${JSON.stringify(MODULES.bootstrap)});
+
+ansi.setColorEnabled(false);
+for (const stream of [process.stdin, process.stdout, process.stderr]) {
+	Object.defineProperty(stream, "isTTY", { value: false, configurable: true });
+}
+
+const out = { need: null, described: null, options: null, ensureOutput: null, ensureResult: null, error: null };
+try {
+	const need = await startup.detectProfileStartupNeed(target);
+	out.need = { state: need.state, enclosing: need.enclosing ?? null };
+	if (mode === "nested") {
+		out.described = startup.describeNeed(need);
+		out.options = startup.buildProfileOptions(need);
+
+		const chunks = [];
+		const decode = (chunk) =>
+			typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+		const capture = (...args) => {
+			chunks.push(format(...args) + "\\n");
+		};
+		const saved = {
+			log: console.log, error: console.error, warn: console.warn, info: console.info,
+			out: process.stdout.write, err: process.stderr.write,
+		};
+		console.log = capture;
+		console.error = capture;
+		console.warn = capture;
+		console.info = capture;
+		const captureWrite = (chunk, ...rest) => {
+			chunks.push(decode(chunk));
+			const done = rest.find((arg) => typeof arg === "function");
+			if (done) done();
+			return true;
+		};
+		process.stdout.write = captureWrite;
+		process.stderr.write = captureWrite;
+		try {
+			const value = await bootstrap.ensureManifest(target, {});
+			out.ensureResult = value === undefined ? null : value;
+		} finally {
+			console.log = saved.log;
+			console.error = saved.error;
+			console.warn = saved.warn;
+			console.info = saved.info;
+			process.stdout.write = saved.out;
+			process.stderr.write = saved.err;
+		}
+		out.ensureOutput = chunks.join("");
+	}
+} catch (e) {
+	out.error = e instanceof Error ? (e.stack ?? e.message) : String(e);
+}
+writeFileSync(resultPath, JSON.stringify(out));
+process.exit(0);
+`;
+
+interface StartupRun {
+	need: {
+		state: ProfileStartupState;
+		enclosing: ProfileStartupNeed["enclosing"] | null;
+	} | null;
+	described: { title: string; message: string } | null;
+	options: Array<{ label: string; value: string; meta?: string }> | null;
+	ensureOutput: string | null;
+	ensureResult: 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;
+}
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+beforeAll(async () => {
+	helperDir = await tempRoot("psn-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 Tree {
+	base: string;
+	env: Record<string, string>;
+	root: string;
+	app: string;
+}
+
+/**
+ * `<root>/.git/`, `<root>/.claude/profiles.json` defining `team`, and `<root>/tools/app/`
+ * with its own `.claude/settings.json` enabling `dev@magus` and no profiles.json.
+ * HOME, CLAUDE_CONFIG_DIR (`<HOME>/.claude`) and XDG_* are temp dirs beside it.
+ */
+async function nestedTree(): Promise<Tree> {
+	const base = await tempRoot("psn-");
+	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 root = join(base, "acme-root");
+	await mkdir(join(root, ".git"), { recursive: true });
+	await writeJson(join(root, ".claude", "profiles.json"), {
+		version: 2,
+		profiles: { team: { name: "team", plugins: { "dev@magus": true } } },
+	});
+	const app = join(root, "tools", "app");
+	await writeJson(join(app, ".claude", "settings.json"), {
+		enabledPlugins: { "dev@magus": true },
+	});
+	return {
+		base,
+		root,
+		app,
+		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",
+		},
+	};
+}
+
+async function runStartup(
+	tree: Tree,
+	mode: "nested" | "root",
+): Promise<StartupRun> {
+	const target = mode === "nested" ? tree.app : tree.root;
+	const resultPath = join(tree.base, `result-${mode}.json`);
+	const proc = Bun.spawn({
+		cmd: [
+			process.execPath,
+			"--no-env-file",
+			join(helperDir, "startup-child.ts"),
+			mode,
+			target,
+			resultPath,
+		],
+		cwd: target,
+		env: tree.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;
+}
+
+function collapse(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
+describe("REQ-8 the TUI and the CLI get the same startup state in a subfolder", () => {
+	test(
+		'REQ-8a detectProfileStartupNeed("<root>/tools/app") is in state "nested"',
+		async () => {
+			const tree = await nestedTree();
+
+			const run = await runStartup(tree, "nested");
+
+			expect(run.error).toBeNull();
+			expect(run.need?.state).toBe("nested");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-8b buildProfileOptions offers exactly one option, Quit magus",
+		async () => {
+			const tree = await nestedTree();
+
+			const run = await runStartup(tree, "nested");
+
+			expect(run.error).toBeNull();
+			expect(run.options?.map((option) => option.label)).toEqual([
+				"Quit magus",
+			]);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-8c describeNeed titles it Inside another Claude Code project and names ../..  (<root basename>)",
+		async () => {
+			const tree = await nestedTree();
+
+			const run = await runStartup(tree, "nested");
+
+			expect(run.error).toBeNull();
+			expect(run.described?.title).toBe("Inside another Claude Code project");
+			const messageLines = (run.described?.message ?? "")
+				.split("\n")
+				.map((line) => line.trim());
+			expect(messageLines).toContain(`../..  (${basename(tree.root)})`);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-8d ensureManifest prints every non-empty line of describeNeed's message, in order",
+		async () => {
+			const tree = await nestedTree();
+
+			const run = await runStartup(tree, "nested");
+
+			expect(run.error).toBeNull();
+			const wanted = (run.described?.message ?? "")
+				.split("\n")
+				.map(collapse)
+				.filter((line) => line !== "");
+			expect(wanted.length).toBeGreaterThan(0);
+			const printed = collapse(run.ensureOutput ?? "");
+			let from = 0;
+			const found = wanted.map((line) => {
+				const at = printed.indexOf(line, from);
+				if (at !== -1) from = at + line.length;
+				return { line, printedInOrder: at !== -1 };
+			});
+			expect(found.filter((entry) => !entry.printedInOrder)).toEqual([]);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		'REQ-8e at <root> itself, which has profiles.json, the state is not "nested"',
+		async () => {
+			const tree = await nestedTree();
+
+			const run = await runStartup(tree, "root");
+
+			expect(run.error).toBeNull();
+			expect(run.need).not.toBeNull();
+			expect(run.need?.state).not.toBe("nested");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+});

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

@@ -0,0 +1,390 @@
+/**
+ * Spec 7.5.4 v3 — REQ-9: an old profile format is ONE question for the CLI and the TUI.
+ *
+ * Written blind: from the spec and the exported signatures, types and constant only.
+ * `prepareProfileStartup` is the TUI's startup entry and `profileGate` the CLI's (REQ-5);
+ * the TUI's question is built from `oldFormatNeed`, `describeNeed` and
+ * `buildProfileOptions`, and its title must be the line the CLI gate prints.
+ *
+ * Every call runs 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. Each test builds its own REAL git
+ * repository. The child's PATH carries only `bun` and `git`, so nothing here can reach a
+ * real `claude` CLI. The helper script is written to a mkdtemp dir at runtime.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, lstatSync, readlinkSync } from "node:fs";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	readdir,
+	realpath,
+	rm,
+	symlink,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, relative } from "node:path";
+import type { ProfileStartupState } 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;
+
+/**
+ * mode `old-need`: oldFormatNeed, then describeNeed / buildProfileOptions on its answer.
+ * mode `prepare`: prepareProfileStartup with no options. mode `convert`: with
+ * `{ convert: true }`.
+ */
+const OLD_FORMAT_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)});
+
+ansi.setColorEnabled(false);
+for (const stream of [process.stdin, process.stdout, process.stderr]) {
+	Object.defineProperty(stream, "isTTY", { value: false, configurable: true });
+}
+
+const out = {
+	need: null,
+	needWasNull: null,
+	described: null,
+	options: null,
+	updateFormatValue: startup.UPDATE_FORMAT_VALUE,
+	notices: null,
+	error: null,
+};
+try {
+	if (mode === "old-need") {
+		const need = await startup.oldFormatNeed(project);
+		out.needWasNull = need === null;
+		if (need) {
+			out.need = { state: need.state };
+			out.described = startup.describeNeed(need);
+			out.options = startup.buildProfileOptions(need);
+		}
+	} else {
+		const prepared = await startup.prepareProfileStartup(
+			project,
+			mode === "convert" ? { convert: true } : undefined,
+		);
+		out.need = { state: prepared.need.state };
+		out.notices = prepared.notices;
+	}
+} catch (e) {
+	out.error = e instanceof Error ? (e.stack ?? e.message) : String(e);
+}
+writeFileSync(resultPath, JSON.stringify(out));
+process.exit(0);
+`;
+
+interface OldFormatRun {
+	need: { state: ProfileStartupState } | null;
+	needWasNull: boolean | null;
+	described: { title: string; message: string } | null;
+	options: Array<{ label: string; value: string; meta?: string }> | null;
+	updateFormatValue: string;
+	notices: string[] | null;
+	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;
+}
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+beforeAll(async () => {
+	helperDir = await tempRoot("psof-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, "old-format-child.ts"), OLD_FORMAT_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>;
+}
+
+/**
+ * Which tree a test gets. All three have `.claude/profiles.json` defining `team`.
+ * - `leftover`: the REQ-5 minimal tree — `.claude/_profiles/team/settings.json` and no
+ *   symlink naming a profile (REQ-9a–9d, REQ-9f).
+ * - `symlinked`: a real magus 7.4.1 layout — the same, plus `.claude/settings.json` as a
+ *   symlink to the RELATIVE path `_profiles/team/settings.json` (REQ-9e).
+ * - `current`: no `.claude/_profiles/` at all.
+ */
+type Layout = "leftover" | "symlinked" | "current";
+
+/**
+ * A real git repository holding the chosen layout, everything committed. HOME,
+ * CLAUDE_CONFIG_DIR (`<HOME>/.claude`) and XDG_* are temp dirs beside it.
+ */
+async function repoProject(layout: Layout): Promise<Project> {
+	const base = await tempRoot("psof-");
+	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");
+	if (layout !== "current") {
+		await writeJson(
+			join(project, ".claude", "_profiles", "team", "settings.json"),
+			{ enabledPlugins: { "dev@magus": true } },
+		);
+	}
+	if (layout === "symlinked") {
+		await symlink(
+			"_profiles/team/settings.json",
+			join(project, ".claude", "settings.json"),
+		);
+	}
+	await writeJson(join(project, ".claude", "profiles.json"), {
+		version: 2,
+		profiles: { team: { name: "team", plugins: { "dev@magus": true } } },
+	});
+	git("add", "-A");
+	git("commit", "-q", "-m", "init");
+	return { base, project, env };
+}
+
+async function runChild(
+	proj: Project,
+	mode: "old-need" | "prepare" | "convert",
+): Promise<OldFormatRun> {
+	const resultPath = join(proj.base, `result-${mode}.json`);
+	const proc = Bun.spawn({
+		cmd: [
+			process.execPath,
+			"--no-env-file",
+			join(helperDir, "old-format-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(
+			`old-format child wrote no result (exit ${code}).\nstdout:\n${stdout}\nstderr:\n${stderr}`,
+		);
+	}
+	return JSON.parse(raw) as OldFormatRun;
+}
+
+/**
+ * Every directory and file of the working tree, with contents. `.git/` is left out:
+ * git rewrites its own index on a plain `git status`, which is not the project changing.
+ */
+async function snapshotWorkingTree(
+	root: string,
+): Promise<Record<string, string>> {
+	const out: Record<string, string> = {};
+	async function walk(dir: string): Promise<void> {
+		for (const entry of await readdir(dir, { withFileTypes: true })) {
+			const full = join(dir, entry.name);
+			const rel = relative(root, full);
+			if (rel === ".git") continue;
+			if (entry.isDirectory()) {
+				out[`${rel}/`] = "<dir>";
+				await walk(full);
+			} else {
+				out[rel] = (await readFile(full)).toString("base64");
+			}
+		}
+	}
+	await walk(root);
+	return out;
+}
+
+describe("REQ-9 an old profile format is one question for the CLI and the TUI", () => {
+	test(
+		'REQ-9a oldFormatNeed on an old-format project is in state "old-format"',
+		async () => {
+			const proj = await repoProject("leftover");
+
+			const run = await runChild(proj, "old-need");
+
+			expect(run.error).toBeNull();
+			expect(run.need?.state).toBe("old-format");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-9a oldFormatNeed on a project without .claude/_profiles/ is null",
+		async () => {
+			const proj = await repoProject("current");
+
+			const run = await runChild(proj, "old-need");
+
+			expect(run.error).toBeNull();
+			expect(run.needWasNull).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-9b the question offers exactly Update it now and Quit magus, and Update carries UPDATE_FORMAT_VALUE",
+		async () => {
+			const proj = await repoProject("leftover");
+
+			const run = await runChild(proj, "old-need");
+
+			expect(run.error).toBeNull();
+			expect(run.options?.map((option) => option.label)).toEqual([
+				"Update it now",
+				"Quit magus",
+			]);
+			expect(run.options?.[0]?.value).toBe(run.updateFormatValue);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-9c describeNeed titles it with the same line the CLI gate prints",
+		async () => {
+			const proj = await repoProject("leftover");
+
+			const run = await runChild(proj, "old-need");
+
+			expect(run.error).toBeNull();
+			expect(run.described?.title).toBe(
+				"This project uses an old magus profile format",
+			);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		'REQ-9d prepareProfileStartup without convert answers "old-format" and changes nothing',
+		async () => {
+			const proj = await repoProject("leftover");
+			const before = await snapshotWorkingTree(proj.project);
+
+			const run = await runChild(proj, "prepare");
+
+			expect(run.error).toBeNull();
+			expect(run.need?.state).toBe("old-format");
+			expect(await snapshotWorkingTree(proj.project)).toEqual(before);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-9e on a real symlinked old layout, convert removes .claude/_profiles/ and leaves settings.json a regular file",
+		async () => {
+			const proj = await repoProject("symlinked");
+			const oldDir = join(proj.project, ".claude", "_profiles");
+			const settings = join(proj.project, ".claude", "settings.json");
+			expect(existsSync(oldDir)).toBe(true);
+			expect(lstatSync(settings).isSymbolicLink()).toBe(true);
+			expect(readlinkSync(settings)).toBe("_profiles/team/settings.json");
+
+			const run = await runChild(proj, "convert");
+
+			expect(run.error).toBeNull();
+			expect(existsSync(oldDir)).toBe(false);
+			expect(existsSync(settings)).toBe(true);
+			const after = lstatSync(settings);
+			expect({
+				symlink: after.isSymbolicLink(),
+				regularFile: after.isFile(),
+			}).toEqual({ symlink: false, regularFile: true });
+			expect(run.need).not.toBeNull();
+			expect(run.need?.state).not.toBe("old-format");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		'REQ-9f on the leftover tree (no symlink naming a profile), convert asks which profile: "inactive", never "old-format"',
+		async () => {
+			const proj = await repoProject("leftover");
+
+			const run = await runChild(proj, "convert");
+
+			expect(run.error).toBeNull();
+			expect(run.need?.state).toBe("inactive");
+			expect(run.need?.state).not.toBe("old-format");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+});