magus-cli 7.3.0 → 7.4.0

package/src/__tests__/blind/c18-hook-shape.test.ts

@@ -0,0 +1,354 @@
+/**
+ * Blind tests — contract C18 (requirement R2.8.6), with C2 / C13 for the
+ * SettingsParseError class.
+ *
+ * Written from requirements.md and architecture.md only.
+ *
+ * R2.8.6: registering the agent-model hook refuses a user settings file whose
+ * `hooks` is present but not a JSON object, or whose `hooks.PreToolUse` is
+ * present but not an array — with a `SettingsParseError`-class error naming
+ * the file — and leaves it byte-identical. It never replaces them with empty
+ * ones (the user's own hooks live there). Well-shaped `hooks` keep every
+ * existing entry and gain the magus one.
+ *
+ * C18: `registerAgentModelHook({ configDir })` writes `<configDir>/settings.json`
+ * and resolves "registered" | "already". It adds
+ * `{ matcher: "Agent", hooks: [{ type: "command", command: AGENT_MODEL_HOOK_COMMAND, … }] }`
+ * under `hooks.PreToolUse`. AGENT_MODEL_HOOK_COMMAND is "magus hook agent-model".
+ *
+ * Isolation: the function's default target is user scope (under HOME), and a
+ * black-box test cannot rule out a fallback to it despite `configDir`. So every
+ * call runs in a child `bun` with a temp HOME and a temp cwd (architecture.md
+ * C2 correction; see ./child-run.ts), and one control checks that nothing
+ * appears under that HOME. The child reports booleans, class names and the
+ * contract's own return value — never an error message or a value read from a
+ * file. The settings files read back here are this test's own temp testdata.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+	existsSync,
+	mkdtempSync,
+	readFileSync,
+	realpathSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { type ChildResult, runInChild } from "./child-run.js";
+
+const SERVICES = path.resolve(import.meta.dir, "../../services");
+const HOOK_REGISTRATION = path.join(SERVICES, "hook-registration.ts");
+const SETTINGS_FILE = path.join(SERVICES, "settings-file.ts");
+const CLAUDE_SETTINGS = path.join(SERVICES, "claude-settings.ts");
+const T = 30_000; // per-test timeout: each child bun spawn gets up to 25s
+
+const AGENT_MODEL_HOOK_COMMAND = "magus hook agent-model";
+
+const dirs: string[] = [];
+afterEach(() => {
+	for (const dir of dirs.splice(0))
+		rmSync(dir, { recursive: true, force: true });
+});
+
+function tempDir(tag: string): string {
+	// realpath: on macOS tmpdir is /var/… → /private/var/…; one spelling only.
+	const dir = realpathSync(
+		mkdtempSync(path.join(os.tmpdir(), `magus-blind-c18-${tag}-`)),
+	);
+	dirs.push(dir);
+	return dir;
+}
+
+interface Case {
+	home: string;
+	cwd: string;
+	configDir: string;
+	/** <configDir>/settings.json — the only file the call may touch. */
+	file: string;
+}
+
+/** A fresh temp HOME, cwd and configDir; `content` null means no settings.json. */
+function newCase(content: string | null): Case {
+	const home = tempDir("home");
+	const cwd = tempDir("cwd");
+	const configDir = tempDir("cfg");
+	const file = path.join(configDir, "settings.json");
+	if (content !== null) writeFileSync(file, content);
+	return { home, cwd, configDir, file };
+}
+
+// ── the child call ──────────────────────────────────────────────────────────
+
+/**
+ * Child body: `await mod.registerAgentModelHook({ configDir: job.configDir })`.
+ * Success → `{ ok: true, result }`, where `result` is reported only when it is
+ * one of the contract's two strings. Failure → whether the error is a
+ * SettingsParseError (by name, by a constructor named SettingsParseError on
+ * its prototype chain — i.e. a subclass — or by instanceof an exported
+ * class), and whether its message names the settings file. The message itself
+ * is never reported.
+ */
+const REGISTER_BODY = `
+const fs = await import("node:fs");
+const real = (p) => { try { return fs.realpathSync(p); } catch { return null; } };
+const classes = [];
+for (const m of job.errorModules || []) {
+	try {
+		const x = await import(m);
+		if (typeof x.SettingsParseError === "function") classes.push(x.SettingsParseError);
+	} catch {}
+}
+const k = mod.AGENT_MODEL_HOOK_COMMAND;
+const commandConst = typeof k === "string" && k.length < 200 ? k : "<" + typeof k + ">";
+if (typeof mod.registerAgentModelHook !== "function") {
+	await out({ stage: "missing-export", commandConst });
+	return;
+}
+try {
+	const r = await mod.registerAgentModelHook({ configDir: job.configDir });
+	await out({
+		stage: "done",
+		ok: true,
+		result: r === "registered" || r === "already" ? r : "<" + typeof r + ">",
+		commandConst,
+	});
+} catch (e) {
+	const isErr = e instanceof Error;
+	const chain = [];
+	for (let p = e !== null && typeof e === "object" ? Object.getPrototypeOf(e) : null; p; p = Object.getPrototypeOf(p)) {
+		const c = Object.prototype.hasOwnProperty.call(p, "constructor") ? p.constructor : null;
+		if (c && typeof c.name === "string") chain.push(c.name);
+	}
+	const msg = isErr && typeof e.message === "string" ? e.message : "";
+	const want = real(job.file);
+	await out({
+		stage: "done",
+		ok: false,
+		isError: isErr,
+		errorName: isErr ? String(e.name) : typeof e,
+		nameIsSettingsParseError: isErr && e.name === "SettingsParseError",
+		chainHasSettingsParseError: chain.includes("SettingsParseError"),
+		instanceOfSettingsParseError: classes.some((C) => e instanceof C),
+		messageNamesFile: msg.includes(job.file) || (!!want && msg.includes(want)),
+		commandConst,
+	});
+}
+`;
+
+function register(c: Case): ChildResult {
+	return runInChild({
+		home: c.home,
+		cwd: c.cwd,
+		module: HOOK_REGISTRATION,
+		job: {
+			configDir: c.configDir,
+			file: c.file,
+			errorModules: [SETTINGS_FILE, CLAUDE_SETTINGS, HOOK_REGISTRATION],
+		},
+		body: REGISTER_BODY,
+	});
+}
+
+/** The refusal R2.8.6 asks for, reduced to what the tests assert on. */
+function refusal(r: ChildResult) {
+	return {
+		stage: r.stage,
+		ok: r.ok,
+		settingsParseError:
+			r.nameIsSettingsParseError === true ||
+			r.chainHasSettingsParseError === true ||
+			r.instanceOfSettingsParseError === true,
+		messageNamesFile: r.messageNamesFile,
+		// Diagnostic only (e.g. a raw TypeError, R2.8.4). Not asserted.
+		errorName: r.errorName,
+		result: r.result,
+	};
+}
+
+// ── wrong shapes: refused ───────────────────────────────────────────────────
+
+const USER_BASH_BLOCK = {
+	matcher: "Bash",
+	hooks: [{ type: "command", command: "my-guard.sh" }],
+};
+
+/** R2.8.6: `hooks` not an object, or `hooks.PreToolUse` not an array. */
+const WRONG_SHAPES: Record<string, string> = {
+	'hooks is an array {"hooks": []}': '{"hooks": []}\n',
+	'hooks is a string {"hooks": "x"}': '{"hooks": "x"}\n',
+	'hooks is a number {"hooks": 5}': '{"hooks": 5}\n',
+	"hooks.PreToolUse is one block object, not an array": `${JSON.stringify({
+		hooks: { PreToolUse: USER_BASH_BLOCK },
+	})}\n`,
+	'hooks.PreToolUse is a string {"hooks": {"PreToolUse": "x"}}':
+		'{"hooks": {"PreToolUse": "x"}}\n',
+};
+
+describe("C18 — registerAgentModelHook refuses a wrong-shape hooks in <configDir>/settings.json", () => {
+	for (const [shape, content] of Object.entries(WRONG_SHAPES)) {
+		test(
+			`R2.8.6 ${shape}: rejects with a SettingsParseError-class error and never resolves`,
+			() => {
+				const c = newCase(content);
+				expect(refusal(register(c))).toMatchObject({
+					stage: "done",
+					ok: false,
+					settingsParseError: true,
+				});
+			},
+			T,
+		);
+
+		test(
+			`R2.8.6 ${shape}: the error message names <configDir>/settings.json`,
+			() => {
+				const c = newCase(content);
+				expect(refusal(register(c))).toMatchObject({
+					stage: "done",
+					ok: false,
+					messageNamesFile: true,
+				});
+			},
+			T,
+		);
+
+		test(
+			`R2.8.6 ${shape}: settings.json stays byte-identical`,
+			() => {
+				const c = newCase(content);
+				const before = readFileSync(c.file);
+				const r = register(c);
+				expect(r.stage).toBe("done");
+				expect(readFileSync(c.file).equals(before)).toBe(true);
+			},
+			T,
+		);
+	}
+});
+
+// ── controls: absent or well-shaped hooks gain the magus Agent block ────────
+
+const CONTROLS: Record<string, string | null> = {
+	"no settings.json": null,
+	"{}": "{}\n",
+	'{"hooks": {}}': '{"hooks": {}}\n',
+	"a user Bash hook in PreToolUse and other: 1": `${JSON.stringify({
+		hooks: { PreToolUse: [USER_BASH_BLOCK] },
+		other: 1,
+	})}\n`,
+};
+
+function readBack(c: Case): Record<string, unknown> {
+	// This test's own temp testdata — safe to read.
+	return JSON.parse(readFileSync(c.file, "utf8")) as Record<string, unknown>;
+}
+
+function preToolUse(settings: Record<string, unknown>): unknown[] | null {
+	const hooks = settings.hooks as Record<string, unknown> | undefined;
+	const pre = hooks?.PreToolUse;
+	return Array.isArray(pre) ? pre : null;
+}
+
+/** Every hook entry of type "command" running the magus command in an Agent block. */
+function magusAgentHooks(settings: Record<string, unknown>): unknown[] {
+	const found: unknown[] = [];
+	for (const block of preToolUse(settings) ?? []) {
+		const b = block as { matcher?: unknown; hooks?: unknown };
+		if (b?.matcher !== "Agent" || !Array.isArray(b.hooks)) continue;
+		for (const h of b.hooks as { type?: unknown; command?: unknown }[]) {
+			if (h?.type === "command" && h.command === AGENT_MODEL_HOOK_COMMAND)
+				found.push(h);
+		}
+	}
+	return found;
+}
+
+describe("C18 — registerAgentModelHook controls (absent or well-shaped hooks)", () => {
+	test(
+		`R2.8.6 AGENT_MODEL_HOOK_COMMAND is "${AGENT_MODEL_HOOK_COMMAND}"`,
+		() => {
+			const c = newCase("{}\n");
+			expect(register(c).commandConst).toBe(AGENT_MODEL_HOOK_COMMAND);
+		},
+		T,
+	);
+
+	for (const [label, content] of Object.entries(CONTROLS)) {
+		test(
+			`R2.8.6 control (${label}): resolves "registered"`,
+			() => {
+				const c = newCase(content);
+				expect(refusal(register(c))).toMatchObject({
+					stage: "done",
+					ok: true,
+					result: "registered",
+				});
+			},
+			T,
+		);
+
+		test(
+			`R2.8.6 control (${label}): hooks.PreToolUse gains one Agent block running "${AGENT_MODEL_HOOK_COMMAND}"`,
+			() => {
+				const c = newCase(content);
+				expect(register(c)).toMatchObject({ stage: "done", ok: true });
+				const after = readBack(c);
+				expect(Array.isArray(preToolUse(after))).toBe(true);
+				expect(magusAgentHooks(after).length).toBe(1);
+			},
+			T,
+		);
+
+		test(
+			`R2.8.6 control (${label}): a second call resolves "already" and leaves settings.json byte-identical`,
+			() => {
+				const c = newCase(content);
+				expect(register(c)).toMatchObject({
+					stage: "done",
+					ok: true,
+					result: "registered",
+				});
+				const afterFirst = readFileSync(c.file);
+				// A fresh process: "already" must come from the file, not memory.
+				expect(refusal(register(c))).toMatchObject({
+					stage: "done",
+					ok: true,
+					result: "already",
+				});
+				expect(readFileSync(c.file).equals(afterFirst)).toBe(true);
+			},
+			2 * T,
+		);
+	}
+
+	test(
+		"R2.8.6 control (a user Bash hook in PreToolUse and other: 1): the user's my-guard.sh block and other: 1 are kept",
+		() => {
+			const c = newCase(
+				CONTROLS["a user Bash hook in PreToolUse and other: 1"] as string,
+			);
+			expect(register(c)).toMatchObject({ stage: "done", ok: true });
+			const after = readBack(c);
+			expect(after.other).toBe(1);
+			const pre = preToolUse(after) ?? [];
+			const bash = pre.filter(
+				(b) => (b as { matcher?: unknown })?.matcher === "Bash",
+			);
+			expect(bash).toEqual([USER_BASH_BLOCK]);
+			expect(magusAgentHooks(after).length).toBe(1);
+		},
+		T,
+	);
+
+	test(
+		"R2.8.6 control (no settings.json): configDir is the only target — nothing appears under HOME/.claude",
+		() => {
+			const c = newCase(null);
+			expect(register(c)).toMatchObject({ stage: "done", ok: true });
+			expect(existsSync(c.file)).toBe(true);
+			expect(existsSync(path.join(c.home, ".claude"))).toBe(false);
+		},
+		T,
+	);
+});

package/src/__tests__/blind/c2-settings-parse.test.ts

@@ -0,0 +1,350 @@
+/**
+ * Blind tests — contract C2 (requirements R2.1, R2.2, R2.3).
+ *
+ * Written from requirements.md and architecture.md only.
+ *
+ * NOTHING from claude-settings runs in this process. Under Bun, a runtime
+ * HOME change does not move `os.homedir()` (architecture.md C2 correction),
+ * and this module can resolve `~/.claude` — so every call runs in a child
+ * `bun` spawned with a temp HOME (see ./child-run.ts). The child reports only
+ * booleans and names: never a value read from a file, never an error
+ * message, so no failure can print a real user file.
+ *
+ * Valid-file cases write a per-test random token into the file; the child
+ * reports whether the value it read contains that token, which proves the
+ * temp file — and not some other file — was the one read.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import {
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { type ChildResult, runInChild } from "./child-run.js";
+
+const MODULE = path.resolve(
+	import.meta.dir,
+	"../../services/claude-settings.ts",
+);
+const T = 30_000; // per-test timeout: each test spawns one child bun
+
+const dirs: string[] = [];
+afterEach(() => {
+	for (const dir of dirs.splice(0))
+		rmSync(dir, { recursive: true, force: true });
+});
+
+function tempDir(tag: string): string {
+	const dir = mkdtempSync(path.join(os.tmpdir(), `magus-blind-c2-${tag}-`));
+	dirs.push(dir);
+	return dir;
+}
+
+function write(file: string, content: string): void {
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, content);
+}
+
+/** Three distinct ways a file can exist and not be JSON. */
+const INVALID: Record<string, string> = {
+	truncated: '{\n  "enabledPlugins": {\n    "a@b": true,\n',
+	"plain text": "this is not json at all\n",
+	"trailing comma": '{ "enabledPlugins": { "a@b": true, }, }\n',
+};
+
+/**
+ * Child body: call `mod[job.call](...job.args)` and report a summary.
+ * Reports whether a value is `{}` and whether it contains `job.expect`
+ * (subset match) — never the value itself. On a throw, reports the error's
+ * class and whether it carries/names `job.file` — never its message.
+ */
+const CALL_BODY = `
+const fs = await import("node:fs");
+const real = (p) => { try { return fs.realpathSync(p); } catch { return null; } };
+const subset = (a, e) => {
+	if (e === null || typeof e !== "object") return Object.is(a, e);
+	if (a === null || typeof a !== "object") return false;
+	if (Array.isArray(e)) return Array.isArray(a) && a.length === e.length && e.every((v, i) => subset(a[i], v));
+	return Object.keys(e).every((k) => subset(a[k], e[k]));
+};
+try {
+	const value = await mod[job.call](...job.args);
+	const isObj = value !== null && typeof value === "object" && !Array.isArray(value);
+	await out({
+		stage: "done",
+		ok: true,
+		isEmptyObject: isObj && Object.keys(value).length === 0,
+		matchesExpected: job.expect === undefined ? null : subset(value, job.expect),
+	});
+} catch (e) {
+	const isErr = e instanceof Error;
+	const P = mod.SettingsParseError;
+	const want = job.file ? real(job.file) : null;
+	const msg = isErr && typeof e.message === "string" ? e.message : "";
+	const p = e && typeof e.path === "string" ? e.path : null;
+	await out({
+		stage: "done",
+		ok: false,
+		isError: isErr,
+		name: isErr ? e.name : typeof e,
+		isSettingsParseError: typeof P === "function" && e instanceof P,
+		pathIsString: p !== null,
+		pathMatchesFile: !!want && p !== null && real(p) === want,
+		messageNamesFile: !!job.file && (msg.includes(job.file) || (!!want && msg.includes(want))),
+	});
+}
+`;
+
+interface Case {
+	home: string;
+	project: string;
+}
+
+function newCase(): Case {
+	return { home: tempDir("home"), project: tempDir("proj") };
+}
+
+function call(
+	c: Case,
+	fn: string,
+	args: unknown[],
+	extra: { file?: string; expect?: unknown } = {},
+): ChildResult {
+	return runInChild({
+		home: c.home,
+		cwd: c.project,
+		module: MODULE,
+		job: { call: fn, args, ...extra },
+		body: CALL_BODY,
+	});
+}
+
+interface Reader {
+	name: string;
+	call: string;
+	args: (c: Case) => unknown[];
+	file: (c: Case) => string;
+	/** Valid content carrying `token`, and the subset the reader must return. */
+	valid: (token: string) => Record<string, unknown>;
+}
+
+const READERS: Reader[] = [
+	{
+		name: "readSettings (<project>/.claude/settings.json)",
+		call: "readSettings",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".claude", "settings.json"),
+		valid: (t) => ({ enabledPlugins: { [`${t}@blind`]: true } }),
+	},
+	{
+		name: "readLocalSettings (<project>/.claude/settings.local.json)",
+		call: "readLocalSettings",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".claude", "settings.local.json"),
+		valid: (t) => ({ enabledPlugins: { [`${t}@blind`]: false } }),
+	},
+	{
+		name: "readMcpConfig (<project>/.mcp.json)",
+		call: "readMcpConfig",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".mcp.json"),
+		valid: (t) => ({ mcpServers: { [t]: { command: "echo", args: ["hi"] } } }),
+	},
+	{
+		name: "readGlobalSettings (<HOME>/.claude/settings.json, child process with temp HOME)",
+		call: "readGlobalSettings",
+		args: () => [],
+		file: (c) => path.join(c.home, ".claude", "settings.json"),
+		valid: (t) => ({ enabledPlugins: { [`${t}@global-blind`]: true } }),
+	},
+];
+
+describe("C2 — child-process harness", () => {
+	test(
+		"R2 control: the child's os.homedir() is the temp HOME",
+		() => {
+			const c = newCase();
+			const r = runInChild({
+				home: c.home,
+				cwd: c.project,
+				body: 'await out({ stage: "done", ok: true });',
+			});
+			expect(r).toEqual({ stage: "done", ok: true });
+		},
+		T,
+	);
+});
+
+for (const reader of READERS) {
+	describe(`C2 — ${reader.name}`, () => {
+		test(
+			"R2.1 a missing file reads as an empty object",
+			() => {
+				const c = newCase();
+				expect(call(c, reader.call, reader.args(c))).toEqual({
+					stage: "done",
+					ok: true,
+					isEmptyObject: true,
+					matchesExpected: null,
+				});
+			},
+			T,
+		);
+
+		test(
+			"R2.1 control: a valid file reads as its content (the temp file, identified by a random token)",
+			() => {
+				const c = newCase();
+				const content = reader.valid(`blind-${randomUUID()}`);
+				write(reader.file(c), JSON.stringify(content, null, 2));
+				expect(
+					call(c, reader.call, reader.args(c), { expect: content }),
+				).toMatchObject({
+					stage: "done",
+					ok: true,
+					matchesExpected: true,
+				});
+			},
+			T,
+		);
+
+		for (const [kind, content] of Object.entries(INVALID)) {
+			test(
+				`R2.2 an existing file that is not valid JSON (${kind}) throws SettingsParseError`,
+				() => {
+					const c = newCase();
+					write(reader.file(c), content);
+					expect(call(c, reader.call, reader.args(c))).toMatchObject({
+						stage: "done",
+						ok: false,
+						isError: true,
+						isSettingsParseError: true,
+					});
+				},
+				T,
+			);
+		}
+
+		test(
+			"R2.2 the SettingsParseError carries the path of the file that failed",
+			() => {
+				const c = newCase();
+				const file = reader.file(c);
+				write(file, INVALID.truncated as string);
+				// pathMatchesFile compares real paths: macOS tmpdir is /var -> /private/var.
+				expect(call(c, reader.call, reader.args(c), { file })).toMatchObject({
+					stage: "done",
+					ok: false,
+					isSettingsParseError: true,
+					pathIsString: true,
+					pathMatchesFile: true,
+				});
+			},
+			T,
+		);
+
+		test(
+			"R2.2 an existing unparseable file never reads as {}",
+			() => {
+				const c = newCase();
+				write(reader.file(c), INVALID["plain text"] as string);
+				const r = call(c, reader.call, reader.args(c));
+				expect(r.stage).toBe("done");
+				expect(r.ok).toBe(false);
+			},
+			T,
+		);
+	});
+}
+
+describe("C2 — enablePlugin read-modify-write", () => {
+	const PLUGIN = "demo@magus-blind";
+	const settingsFile = (c: Case) =>
+		path.join(c.project, ".claude", "settings.json");
+
+	test(
+		"R2.3 control: enablePlugin on a valid settings.json sets enabledPlugins[id] and keeps other keys",
+		() => {
+			const c = newCase();
+			const file = settingsFile(c);
+			write(
+				file,
+				JSON.stringify(
+					{
+						enabledPlugins: { "other@x": true },
+						permissions: { allow: ["Read"] },
+					},
+					null,
+					2,
+				),
+			);
+			expect(call(c, "enablePlugin", [PLUGIN, true, c.project])).toMatchObject({
+				stage: "done",
+				ok: true,
+			});
+			// The file is this test's temp testdata, so reading it here is safe.
+			const after = JSON.parse(readFileSync(file, "utf8"));
+			expect(after.enabledPlugins[PLUGIN]).toBe(true);
+			expect(after.enabledPlugins["other@x"]).toBe(true);
+			expect(after.permissions).toEqual({ allow: ["Read"] });
+		},
+		T,
+	);
+
+	for (const enabled of [true, false]) {
+		for (const [kind, content] of Object.entries(INVALID)) {
+			test(
+				`R2.3 enablePlugin(…, ${enabled}) fails on an unparseable settings.json (${kind})`,
+				() => {
+					const c = newCase();
+					write(settingsFile(c), content);
+					expect(
+						call(c, "enablePlugin", [PLUGIN, enabled, c.project]),
+					).toMatchObject({
+						stage: "done",
+						ok: false,
+						isError: true,
+					});
+				},
+				T,
+			);
+
+			test(
+				`R2.3 enablePlugin(…, ${enabled}) leaves an unparseable settings.json (${kind}) byte-for-byte unchanged`,
+				() => {
+					const c = newCase();
+					const file = settingsFile(c);
+					write(file, content);
+					const before = readFileSync(file);
+					const r = call(c, "enablePlugin", [PLUGIN, enabled, c.project]);
+					expect(r.stage).toBe("done");
+					expect(readFileSync(file).equals(before)).toBe(true);
+				},
+				T,
+			);
+		}
+	}
+
+	test(
+		"R2.3 the enablePlugin failure identifies the unparseable file",
+		() => {
+			// R2.4 needs the TUI to name the file, so the error that reaches it must
+			// carry the path: as a SettingsParseError, or in its message.
+			const c = newCase();
+			const file = settingsFile(c);
+			write(file, INVALID.truncated as string);
+			const r = call(c, "enablePlugin", [PLUGIN, true, c.project], { file });
+			expect(r).toMatchObject({ stage: "done", ok: false, isError: true });
+			const namesFile =
+				(r.isSettingsParseError === true && r.pathMatchesFile === true) ||
+				r.messageNamesFile === true;
+			expect(namesFile).toBe(true);
+		},
+		T,
+	);
+});