magus-cli 0.0.0-placeholder → 7.1.0

package/src/__tests__/scope-squares.test.tsx

@@ -0,0 +1,164 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type React from "react";
+import { ScopeSquares } from "../ui/components/primitives/ScopeSquares.js";
+import {
+	SCOPE_OFF_FILL,
+	resetThemeMode,
+	setThemeMode,
+} from "../ui/theme-mode.js";
+import { CONTRAST_REFERENCE, theme } from "../ui/theme.js";
+
+/**
+ * The scope bar is three filled segments; only the fill says lit or unlit.
+ *
+ * Its unlit fill was `theme.colors.muted` (#6B7280) — the same mid-dark grey as
+ * de-emphasised text. On a light page that is a *dark* block, so an unlit segment
+ * carried the same visual weight as a lit one and the bar read as three similar
+ * blobs: "non installed state is dark as well - confusing".
+ *
+ * An unlit segment has to recede toward the page, which is exactly what a fixed
+ * colour cannot do — a pale fill that sits quietly on cream is a bright block on
+ * near-black. So the fill follows the resolved mode, and these tests pin both
+ * that behaviour and the dark default that applies before resolution.
+ */
+
+interface SpanLike {
+	props: { fg: string; children: string };
+}
+
+function segments(el: React.ReactElement): SpanLike[] {
+	const children = (el.props as { children: unknown }).children;
+	return (Array.isArray(children) ? children : [children]) as SpanLike[];
+}
+
+const glyphs = (el: React.ReactElement) =>
+	segments(el).map((c) => c.props.children);
+const fills = (el: React.ReactElement) => segments(el).map((c) => c.props.fg);
+
+function relativeLuminance(hex: string): number {
+	const n = hex.replace("#", "");
+	const ch = [0, 2, 4].map((i) => Number.parseInt(n.slice(i, i + 2), 16) / 255);
+	const lin = ch.map((c) =>
+		c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4,
+	);
+	return 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2];
+}
+
+afterEach(() => resetThemeMode());
+
+describe("every segment is a filled block", () => {
+	test("lit and unlit alike use the filled glyph", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({ user: true, project: false, local: true });
+		expect(glyphs(el)).toEqual(["■", "■", "■"]);
+	});
+
+	test("local is omitted when the caller does not pass it", () => {
+		setThemeMode("light");
+		expect(glyphs(ScopeSquares({ user: true, project: false }))).toEqual([
+			"■",
+			"■",
+		]);
+	});
+});
+
+describe("fill distinguishes lit from unlit", () => {
+	test("each lit segment keeps its own scope hue", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({ user: true, project: true, local: true });
+		expect(fills(el)).toEqual([
+			theme.scopes.user,
+			theme.scopes.project,
+			theme.scopes.local,
+		]);
+	});
+
+	test("unlit segments take the page-relative off fill", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({ user: false, project: false, local: false });
+		expect(new Set(fills(el))).toEqual(new Set([SCOPE_OFF_FILL.light]));
+
+		setThemeMode("dark");
+		const dark = ScopeSquares({ user: false, project: false, local: false });
+		expect(new Set(fills(dark))).toEqual(new Set([SCOPE_OFF_FILL.dark]));
+	});
+
+	test("a mixed bar shows lit and unlit fills side by side", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({ user: false, project: true, local: false });
+		expect(fills(el)).toEqual([
+			SCOPE_OFF_FILL.light,
+			theme.scopes.project,
+			SCOPE_OFF_FILL.light,
+		]);
+	});
+
+	test("before resolution the fill is the dark pair", () => {
+		resetThemeMode();
+		const el = ScopeSquares({ user: false, project: false, local: false });
+		expect(new Set(fills(el))).toEqual(new Set([SCOPE_OFF_FILL.dark]));
+	});
+});
+
+describe("the unlit fill recedes toward the page it is on", () => {
+	/**
+	 * How far a fill sits from the page, relative to the NEAREST lit segment.
+	 *
+	 * The naive property — "unlit is closer to the page than a lit colour" — is
+	 * too weak, and measurably so: the old #6B7280 satisfied it on a light page
+	 * (0.766 vs 0.774) while still looking wrong. What made the bar read as three
+	 * similar blobs was that unlit sat **99% as far** from the page as a lit
+	 * segment: essentially the same visual weight. Ratio, not order, is the
+	 * property that captures the defect.
+	 */
+	const pageDistanceRatio = (fill: string, page: string) => {
+		const d = (hex: string) =>
+			Math.abs(relativeLuminance(hex) - relativeLuminance(page));
+		const nearestLit = Math.min(...Object.values(theme.scopes).map(d));
+		return d(fill) / nearestLit;
+	};
+
+	/** Unlit must be at most half as far from the page as the nearest lit segment. */
+	const MAX_RATIO = 0.5;
+
+	test("light page: unlit recedes (measured 0.32)", () => {
+		expect(
+			pageDistanceRatio(SCOPE_OFF_FILL.light, CONTRAST_REFERENCE.light),
+		).toBeLessThan(MAX_RATIO);
+	});
+
+	test("dark page: unlit recedes (measured 0.22)", () => {
+		expect(
+			pageDistanceRatio(SCOPE_OFF_FILL.dark, CONTRAST_REFERENCE.dark),
+		).toBeLessThan(MAX_RATIO);
+	});
+
+	test("the old mid-grey fails the property on BOTH pages", () => {
+		// Pins why the value changed, and guards against anyone reinstating it:
+		// 0.99 on cream and 1.10 on near-black — an unlit segment as heavy as a lit
+		// one, or heavier.
+		expect(
+			pageDistanceRatio("#6B7280", CONTRAST_REFERENCE.light),
+		).toBeGreaterThan(MAX_RATIO);
+		expect(
+			pageDistanceRatio("#6B7280", CONTRAST_REFERENCE.dark),
+		).toBeGreaterThan(MAX_RATIO);
+	});
+});
+
+describe("selected rows", () => {
+	test("unlit segments recede into the selection block, lit take its ink", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({
+			user: true,
+			project: false,
+			local: true,
+			selected: true,
+		});
+		expect(fills(el)).toEqual([
+			theme.selection.fg,
+			theme.selection.bg,
+			theme.selection.fg,
+		]);
+	});
+});

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

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+import { BoxRenderable, TextRenderable } from "@opentui/core";
+import { createTestRenderer } from "@opentui/core/testing";
+
+/**
+ * Pins the OpenTUI selection behaviour magus relies on after enabling the
+ * mouse outside tmux (src/main.tsx): a drag that stays inside one pane selects
+ * text from that pane only, because the renderer scopes the selection to the
+ * smallest ancestor covering the dragged-over renderables. Crossing the pane
+ * divider deliberately escalates the scope to the common ancestor — that is
+ * upstream's design, not a bug, and the second test documents it so a future
+ * re-pin that changes either half is caught here rather than by a user.
+ *
+ * The geometry mirrors ScreenLayout: two column boxes side by side under one
+ * row box, text rows inside each.
+ */
+async function twoPaneRenderer() {
+	const { renderer, mockMouse, renderOnce } = await createTestRenderer({
+		width: 80,
+		height: 10,
+		useMouse: true,
+	});
+
+	const row = new BoxRenderable(renderer, {
+		id: "row",
+		width: 80,
+		height: 10,
+		flexDirection: "row",
+	});
+	renderer.root.add(row);
+
+	const left = new BoxRenderable(renderer, {
+		id: "left",
+		width: 40,
+		height: 10,
+		flexDirection: "column",
+	});
+	const separator = new BoxRenderable(renderer, {
+		id: "separator",
+		width: 1,
+		height: 10,
+	});
+	const right = new BoxRenderable(renderer, {
+		id: "right",
+		width: 39,
+		height: 10,
+		flexDirection: "column",
+	});
+	row.add(left);
+	row.add(separator);
+	row.add(right);
+
+	for (const line of ["alpha one", "alpha two", "alpha three"]) {
+		left.add(new TextRenderable(renderer, { content: line }));
+	}
+	for (const line of ["omega one", "omega two", "omega three"]) {
+		right.add(new TextRenderable(renderer, { content: line }));
+	}
+
+	await renderOnce();
+	return { renderer, mockMouse };
+}
+
+describe("mouse selection scope across panes", () => {
+	test("a drag inside the left pane selects left-pane text only", async () => {
+		const { renderer, mockMouse } = await twoPaneRenderer();
+
+		await mockMouse.drag(1, 0, 20, 2);
+
+		const selected = renderer.getSelection()?.getSelectedText() ?? "";
+		expect(selected).toContain("alpha");
+		expect(selected).not.toContain("omega");
+
+		renderer.destroy();
+	});
+
+	test("a drag inside the right pane selects right-pane text only", async () => {
+		const { renderer, mockMouse } = await twoPaneRenderer();
+
+		await mockMouse.drag(45, 0, 70, 2);
+
+		const selected = renderer.getSelection()?.getSelectedText() ?? "";
+		expect(selected).toContain("omega");
+		expect(selected).not.toContain("alpha");
+
+		renderer.destroy();
+	});
+
+	test("a drag across the divider escalates to both panes — upstream's design", async () => {
+		const { renderer, mockMouse } = await twoPaneRenderer();
+
+		await mockMouse.drag(1, 0, 70, 2);
+
+		const selected = renderer.getSelection()?.getSelectedText() ?? "";
+		expect(selected).toContain("alpha");
+		expect(selected).toContain("omega");
+
+		renderer.destroy();
+	});
+});

package/src/__tests__/settings-file.test.ts

@@ -0,0 +1,179 @@
+/**
+ * `services/settings-file.ts` — the one place magus edits a settings.json.
+ *
+ * Every test here pins a failure mode that has cost, or would cost, a user
+ * their configuration:
+ *
+ *  - an unparseable file must be REFUSED, and left byte-for-byte alone;
+ *  - a symlinked settings.json must be written THROUGH the link, because that
+ *    is the shape an active profile leaves behind (`.claude/settings.json` →
+ *    `.claude/_profiles/<name>/settings.json`). Remove-then-create would
+ *    replace the link with a plain file and detach the project from its
+ *    profile, which nothing downstream would notice.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+	lstatSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	readSettingsFile,
+	updateSettingsFile,
+} from "../services/settings-file.js";
+
+const dirs: string[] = [];
+
+afterEach(() => {
+	for (const dir of dirs.splice(0))
+		rmSync(dir, { recursive: true, force: true });
+});
+
+function tempDir(): string {
+	const dir = mkdtempSync(path.join(os.tmpdir(), "magus-settings-file-"));
+	dirs.push(dir);
+	return dir;
+}
+
+describe("readSettingsFile", () => {
+	test("S-1: a missing file reads as an empty object", async () => {
+		const missing = path.join(tempDir(), "nested", "settings.json");
+		expect(await readSettingsFile(missing)).toEqual({});
+	});
+
+	test("S-1b: an empty file reads as an empty object", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(file, "   \n");
+		expect(await readSettingsFile(file)).toEqual({});
+	});
+
+	test("S-2: an unparseable file throws, naming the path and the refusal", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(file, "{ not json");
+
+		await expect(readSettingsFile(file)).rejects.toThrow(/not valid JSON/);
+		await expect(readSettingsFile(file)).rejects.toThrow(
+			/refusing to overwrite/,
+		);
+		await expect(readSettingsFile(file)).rejects.toThrow(file);
+	});
+});
+
+describe("updateSettingsFile", () => {
+	test("S-3: a missing file starts from {} and is created", async () => {
+		const file = path.join(tempDir(), "nested", "settings.json");
+
+		await updateSettingsFile(file, (settings) => {
+			settings.outputStyle = "composed";
+		});
+
+		expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({
+			outputStyle: "composed",
+		});
+	});
+
+	test("S-4: a valid file round-trips and unrelated keys survive", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(
+			file,
+			`${JSON.stringify(
+				{
+					enabledPlugins: { "dev@magus": true },
+					someOtherKey: 42,
+					outputStyle: "old",
+				},
+				null,
+				2,
+			)}\n`,
+		);
+
+		await updateSettingsFile(file, (settings) => {
+			settings.outputStyle = "new";
+		});
+
+		expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({
+			enabledPlugins: { "dev@magus": true },
+			someOtherKey: 42,
+			outputStyle: "new",
+		});
+	});
+
+	test("S-4b: the mutator may return a replacement object instead of mutating", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(file, `${JSON.stringify({ a: 1 }, null, 2)}\n`);
+
+		await updateSettingsFile(file, (settings) => ({ ...settings, b: 2 }));
+
+		expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({ a: 1, b: 2 });
+	});
+
+	test("S-4c: deleting a key removes it rather than serializing undefined", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(file, `${JSON.stringify({ a: 1, outputStyle: "x" })}\n`);
+
+		await updateSettingsFile(file, (settings) => {
+			// biome-ignore lint/performance/noDelete: removal is the intent
+			delete settings.outputStyle;
+		});
+
+		const raw = readFileSync(file, "utf8");
+		expect(raw).not.toContain("outputStyle");
+		expect(JSON.parse(raw)).toEqual({ a: 1 });
+	});
+
+	test("S-4d: the write is 2-space JSON with a trailing newline", async () => {
+		const file = path.join(tempDir(), "settings.json");
+
+		await updateSettingsFile(file, () => ({ a: { b: 1 } }));
+
+		expect(readFileSync(file, "utf8")).toBe(
+			'{\n  "a": {\n    "b": 1\n  }\n}\n',
+		);
+	});
+
+	test("S-5: an unparseable file throws and the bytes on disk are UNCHANGED", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		const original = '{ "half": tru\n// a human mid-edit\n';
+		writeFileSync(file, original);
+		let mutatorRan = false;
+
+		await expect(
+			updateSettingsFile(file, (settings) => {
+				mutatorRan = true;
+				settings.outputStyle = "composed";
+			}),
+		).rejects.toThrow(/not valid JSON, refusing to overwrite it/);
+
+		expect(mutatorRan).toBe(false);
+		expect(readFileSync(file, "utf8")).toBe(original);
+	});
+
+	test("S-6: a symlinked settings.json is written THROUGH the link — the profile case", async () => {
+		const dir = tempDir();
+		const target = path.join(dir, "profile-settings.json");
+		const link = path.join(dir, "settings.json");
+		writeFileSync(
+			target,
+			`${JSON.stringify({ enabledPlugins: { "dev@magus": true } }, null, 2)}\n`,
+		);
+		symlinkSync(target, link);
+
+		await updateSettingsFile(link, (settings) => {
+			settings.outputStyle = "composed";
+		});
+
+		// The profile's real file received the write …
+		expect(JSON.parse(readFileSync(target, "utf8"))).toEqual({
+			enabledPlugins: { "dev@magus": true },
+			outputStyle: "composed",
+		});
+		// … and the link is still a link, not a plain file that replaced it.
+		expect(lstatSync(link).isSymbolicLink()).toBe(true);
+	});
+});

package/src/__tests__/shell-script-callers.test.ts

@@ -0,0 +1,92 @@
+/**
+ * `runShellScript` has exactly one legitimate caller, and this pins it.
+ *
+ * The whole of item 3 is the split between two ways of running a child process:
+ * argv (`runCommand`), which no shell ever sees, and a script (`runShellScript`),
+ * which `/bin/sh` parses. Every installer command belongs to the first, because
+ * it is assembled from package names that arrive in `.claude/profiles.json` and
+ * plugin `requires.bin` — hand-authored, committed by teammates, fetched from
+ * marketplaces, validated by nothing. The second exists only for the two
+ * `TOOLCHAIN_BOOTSTRAP` values, which are constants in this repo copied from
+ * bun.sh and brew.sh and which genuinely contain a pipe and a command
+ * substitution.
+ *
+ * Nothing in the type system distinguishes them — both are strings — so after
+ * the commit lands, the design decision is enforced by this test or by nothing.
+ * A branded `ShellScript` type would enforce it at compile time and was
+ * considered; for one map, two entries and one call site it is more machinery
+ * than the rule is worth, and unlike a brand this is greppable.
+ *
+ * Source-scanning precedent in this suite: `uppercase-keybindings.test.ts`.
+ */
+
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+
+const SRC_DIR = path.join(import.meta.dir, "..");
+
+/** Files permitted to call `runShellScript`, relative to `src/`. */
+const ALLOWED = ["cli/install.ts"];
+
+/** The definition itself, plus this test, are not callers. */
+const NOT_CALLERS = ["utils/run.ts", "__tests__/shell-script-callers.test.ts"];
+
+async function sourceFiles(dir: string): Promise<string[]> {
+	const out: string[] = [];
+	for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...(await sourceFiles(full)));
+		else if (/\.tsx?$/.test(entry.name)) out.push(full);
+	}
+	return out;
+}
+
+const isComment = (line: string) => {
+	const t = line.trim();
+	return t.startsWith("//") || t.startsWith("*") || t.startsWith("/*");
+};
+
+async function callersOf(pattern: RegExp): Promise<string[]> {
+	const found = new Set<string>();
+	for (const file of await sourceFiles(SRC_DIR)) {
+		const rel = path.relative(SRC_DIR, file);
+		if (NOT_CALLERS.includes(rel)) continue;
+		const text = await fs.readFile(file, "utf8");
+		for (const line of text.split("\n")) {
+			if (isComment(line)) continue;
+			if (pattern.test(line)) found.add(rel);
+		}
+	}
+	return [...found].sort();
+}
+
+describe("only the toolchain bootstrap goes through a shell", () => {
+	test("runShellScript is called from exactly the allowed files", async () => {
+		expect(await callersOf(/\brunShellScript\(/)).toEqual(ALLOWED);
+	});
+
+	test("nothing spawns with a shell outside utils/run.ts", async () => {
+		// Catches someone reaching for `spawn`/`exec` directly rather than
+		// through the seam — a second shell path that never names
+		// `runShellScript`.
+		//
+		// Both spellings: `shell: true` and a named shell (`shell: "/bin/bash"`).
+		// The CLI Tools screen used the second for its version probe (`which -a`
+		// pipelines, a string-form `exec` of each check command); that probe now
+		// lives in services/tool-probe.ts and runs argv only. `shell: false` and
+		// the alias writer's `shell: ShellKind` values are not spawn options and
+		// do not match.
+		expect(await callersOf(/shell:\s*(true|["'`])/)).toEqual([]);
+	});
+
+	test("the scan can actually fail", async () => {
+		// Negative control. The two assertions above pass trivially if the walk
+		// finds nothing or the pattern never matches, and a check that cannot
+		// fail is not evidence. `runCommand(` is known to be called from several
+		// files, so a working scan must find them.
+		const runCommandCallers = await callersOf(/\brunCommand\(/);
+		expect(runCommandCallers.length).toBeGreaterThan(0);
+		expect(runCommandCallers).toContain("cli/install.ts");
+	});
+});

package/src/__tests__/skill-install-files.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import {
+	resolveSkillFilePath,
+	selectSkillFiles,
+} from "../services/skills-manager.js";
+
+/**
+ * Installing a skill used to write exactly one file, SKILL.md, and drop
+ * everything beside it. Measured against the real repos: audit-website lost
+ * `references/OUTPUT-FORMAT.md` while its SKILL.md still linked to it,
+ * systematic-debugging lost `find-polluter.sh` and 9 more, and
+ * remotion-best-practices lost 136 files. The installed skill looked fine and
+ * had dangling links.
+ *
+ * These cover the two pieces of that fix that are pure: choosing which files
+ * belong to a skill, and refusing to write outside its directory.
+ */
+
+const blob = (p: string) => ({ path: p, type: "blob" });
+const tree = (p: string) => ({ path: p, type: "tree" });
+
+describe("selectSkillFiles", () => {
+	test("returns paths relative to the skill directory", () => {
+		expect(
+			selectSkillFiles(
+				[
+					blob("skills/audit-website/SKILL.md"),
+					blob("skills/audit-website/references/OUTPUT-FORMAT.md"),
+					blob("skills/audit-website/assets/icon-small.svg"),
+				],
+				"skills/audit-website",
+			),
+		).toEqual([
+			"SKILL.md",
+			"references/OUTPUT-FORMAT.md",
+			"assets/icon-small.svg",
+		]);
+	});
+
+	test("REGRESSION: a sibling with a shared name prefix is excluded", () => {
+		// Without the trailing slash on the prefix, "skills/audit" also matches
+		// "skills/audit-website/..." and dumps a second skill's files into the
+		// first one's directory.
+		expect(
+			selectSkillFiles(
+				[
+					blob("skills/audit/SKILL.md"),
+					blob("skills/audit-website/SKILL.md"),
+					blob("skills/audit-website/references/OUTPUT-FORMAT.md"),
+				],
+				"skills/audit",
+			),
+		).toEqual(["SKILL.md"]);
+	});
+
+	test("tree entries are skipped — only blobs are downloadable", () => {
+		expect(
+			selectSkillFiles(
+				[
+					tree("skills/x/references"),
+					blob("skills/x/SKILL.md"),
+					blob("skills/x/references/a.md"),
+				],
+				"skills/x",
+			),
+		).toEqual(["SKILL.md", "references/a.md"]);
+	});
+
+	test("files outside the skill directory are excluded", () => {
+		expect(
+			selectSkillFiles(
+				[blob("README.md"), blob("other/SKILL.md"), blob("skills/x/SKILL.md")],
+				"skills/x",
+			),
+		).toEqual(["SKILL.md"]);
+	});
+
+	test("a trailing slash on the skill path does not break matching", () => {
+		expect(selectSkillFiles([blob("skills/x/SKILL.md")], "skills/x/")).toEqual([
+			"SKILL.md",
+		]);
+	});
+
+	test("a skill directory with no files yields nothing", () => {
+		expect(
+			selectSkillFiles([blob("skills/other/SKILL.md")], "skills/x"),
+		).toEqual([]);
+	});
+});
+
+describe("resolveSkillFilePath", () => {
+	const dir = path.join(path.sep, "tmp", "skills", "demo");
+
+	test("resolves a plain relative path inside the install directory", () => {
+		expect(resolveSkillFilePath(dir, "SKILL.md")).toBe(
+			path.join(dir, "SKILL.md"),
+		);
+	});
+
+	test("resolves a nested path", () => {
+		expect(resolveSkillFilePath(dir, "references/OUTPUT-FORMAT.md")).toBe(
+			path.join(dir, "references", "OUTPUT-FORMAT.md"),
+		);
+	});
+
+	test("SECURITY: rejects paths escaping via ..", () => {
+		// These paths come from a remote repository and are untrusted input to a
+		// filesystem write.
+		expect(resolveSkillFilePath(dir, "../evil.md")).toBeNull();
+		expect(resolveSkillFilePath(dir, "../../.bashrc")).toBeNull();
+		expect(resolveSkillFilePath(dir, "refs/../../../evil.md")).toBeNull();
+	});
+
+	test("SECURITY: rejects absolute paths", () => {
+		expect(
+			resolveSkillFilePath(dir, path.join(path.sep, "etc", "passwd")),
+		).toBeNull();
+	});
+
+	test("rejects an empty path", () => {
+		expect(resolveSkillFilePath(dir, "")).toBeNull();
+	});
+
+	test("a .. that stays inside the directory is allowed", () => {
+		expect(resolveSkillFilePath(dir, "refs/../SKILL.md")).toBe(
+			path.join(dir, "SKILL.md"),
+		);
+	});
+
+	test("REGRESSION: a sibling directory sharing the name prefix is rejected", () => {
+		// path.startsWith without a separator would accept /tmp/skills/demo-evil
+		// as being inside /tmp/skills/demo.
+		expect(resolveSkillFilePath(dir, "../demo-evil/x.md")).toBeNull();
+	});
+});