magus-cli 7.3.1 → 7.4.1

package/src/__tests__/blind/child-run.ts

@@ -0,0 +1,114 @@
+/**
+ * Run a contract call in a child `bun` process whose HOME is a temp dir.
+ *
+ * Why a child: under Bun, `os.homedir()` ignores a `process.env.HOME` change
+ * made at runtime, but honours HOME set when the process starts
+ * (architecture.md C2, correction of 2026-09-18). Anything that could resolve
+ * `~/.claude` therefore runs here, never in the test process.
+ *
+ * Safety, in order:
+ *  1. the child's env pins HOME, CLAUDE_CONFIG_DIR and XDG_CONFIG_HOME inside
+ *     the temp home, and its cwd is a temp dir;
+ *  2. before importing anything under test, the child checks that
+ *     `os.homedir()` IS the temp home, and stops if not ("guard" stage);
+ *  3. the child reports only a JSON summary chosen by the test (booleans,
+ *     names, URLs) on a marker line. Values read from files and error
+ *     messages are never printed, and the child's raw stdout/stderr is never
+ *     surfaced — so no test output can echo the contents of a user file.
+ */
+import path from "node:path";
+
+const MARK = "__BLIND_RESULT__";
+
+export type ChildResult = Record<string, unknown> & { stage: string };
+
+export interface ChildRun {
+	/** Temp HOME for the child. */
+	home: string;
+	/** Working directory for the child — always a temp dir. */
+	cwd: string;
+	/** Absolute path of the module under test, or undefined for none. */
+	module?: string;
+	/** Passed to the child as `job` (JSON). */
+	job?: Record<string, unknown>;
+	/** JS run BEFORE the module is imported (e.g. install a fetch mock). */
+	setup?: string;
+	/** JS run after import. Has `job`, `mod`, `out(summary)` in scope. */
+	body: string;
+	timeoutMs?: number;
+}
+
+function childScript(setup: string, body: string): string {
+	return `
+const MARK = ${JSON.stringify(MARK)};
+const out = async (o) => { await Bun.write(Bun.stdout, "\\n" + MARK + JSON.stringify(o) + "\\n"); };
+(async () => {
+	try {
+		const os = await import("node:os");
+		const job = JSON.parse(process.env.BLIND_JOB || "{}");
+		if (os.homedir() !== job.__home || process.env.HOME !== job.__home) {
+			await out({ stage: "guard", homeRedirected: false });
+			return;
+		}
+		${setup}
+		let mod = null;
+		if (job.__module) {
+			try {
+				mod = await import(job.__module);
+			} catch (e) {
+				await out({ stage: "import", error: String((e && e.message) || e).split("\\n")[0] });
+				return;
+			}
+		}
+		${body}
+	} catch (e) {
+		await out({ stage: "harness", name: (e && e.name) || typeof e });
+	}
+})().then(() => process.exit(0));
+`;
+}
+
+export function runInChild(run: ChildRun): ChildResult {
+	const job = {
+		...(run.job ?? {}),
+		__home: run.home,
+		__module: run.module ?? null,
+	};
+	const proc = Bun.spawnSync(
+		[
+			process.execPath,
+			"--no-env-file",
+			"-e",
+			childScript(run.setup ?? "", run.body),
+		],
+		{
+			cwd: run.cwd,
+			env: {
+				...process.env,
+				HOME: run.home,
+				CLAUDE_CONFIG_DIR: path.join(run.home, ".claude"),
+				XDG_CONFIG_HOME: path.join(run.home, ".config"),
+				BLIND_JOB: JSON.stringify(job),
+			},
+			stdout: "pipe",
+			stderr: "pipe",
+			timeout: run.timeoutMs ?? 25_000,
+		},
+	);
+	const line = proc.stdout
+		.toString()
+		.split("\n")
+		.reverse()
+		.find((l) => l.startsWith(MARK));
+	if (!line) {
+		// Withhold the child's output: it could echo a file's contents. A
+		// module-resolution line names paths only, so that one is safe to show.
+		const moduleLine = proc.stderr
+			.toString()
+			.match(/Cannot find module[^\n]*/)?.[0];
+		throw new Error(
+			`child bun produced no result (exit ${proc.exitCode}${moduleLine ? `; ${moduleLine}` : ""}); its raw output is withheld`,
+		);
+	}
+	return JSON.parse(line.slice(MARK.length)) as ChildResult;
+}

package/src/__tests__/cli-tools-adapter.test.ts

@@ -240,7 +240,7 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 });
 
 describe("cliToolStatusText — the row's words", () => {
-	test("unknown renders as ? <note>, the note verbatim", () => {
+	test("unknown renders as ? <short label>; the full note stays on the status", () => {
 		const tool = catalogue("crush");
 		const spec = specForCatalogTool(tool, null, {
 			primary: "npm",
@@ -250,7 +250,10 @@ describe("cliToolStatusText — the row's words", () => {
 		const row = buildToolRow(tool, spec, f);
 		const text = cliToolStatusText(row);
 		expect(text.tone).toBe("warning");
-		expect(text.suffix).toBe(` ? ${classifyTool(spec, f).note}`);
+		expect(text.suffix).toBe(" ? not managed by npm");
+		// The note (with its path) is for the detail pane's "Why", not the row.
+		expect(row.status?.note).toBe(classifyTool(spec, f).note);
+		expect(text.suffix).not.toContain("/");
 	});
 
 	test("upgrade names the target once, with one v", () => {

package/src/__tests__/component-badge.test.ts

@@ -1,8 +1,8 @@
 import { afterEach, describe, expect, it } from "bun:test";
 import {
-	COMPONENT_BADGE,
+	COMPONENT_CHIP,
 	CONTRAST_REFERENCE_KEYS,
-	componentBadge,
+	componentChip,
 	resetThemeMode,
 	setThemeMode,
 } from "../ui/theme-mode.js";
@@ -30,51 +30,44 @@ function contrast(a: string, b: string): number {
 	return (hi + 0.05) / (lo + 0.05);
 }
 
-const KINDS = ["skill", "command", "agent", "mcp"] as const;
-
-describe("componentBadge", () => {
+/**
+ * The chip behind a plugin component's type glyph. It used to be a wash in a
+ * different hue per kind; the glyph already says the kind, so it is now one
+ * neutral chip for all of them (see `COMPONENT_CHIP`).
+ */
+describe("componentChip", () => {
 	it("serves the dark pair before any resolution", () => {
 		// There is no unknown: dark is the stated default, so a chip is always a
 		// pair, never null, and the caller has no bare-glyph branch to keep.
-		for (const kind of KINDS) {
-			expect(componentBadge(kind)).toEqual(COMPONENT_BADGE[kind].dark);
-		}
+		expect(componentChip()).toEqual(COMPONENT_CHIP.dark);
 	});
 
 	it("serves the light pair on a light terminal", () => {
 		setThemeMode("light");
-
-		expect(componentBadge("skill")).toEqual(COMPONENT_BADGE.skill.light);
-		expect(componentBadge("mcp")).toEqual(COMPONENT_BADGE.mcp.light);
+		expect(componentChip()).toEqual(COMPONENT_CHIP.light);
 	});
 
 	it("serves the dark pair on a dark terminal", () => {
 		setThemeMode("dark");
-
-		expect(componentBadge("skill")).toEqual(COMPONENT_BADGE.skill.dark);
-		expect(componentBadge("mcp")).toEqual(COMPONENT_BADGE.mcp.dark);
+		expect(componentChip()).toEqual(COMPONENT_CHIP.dark);
 	});
 
-	it("keeps every glyph legible on its own chip", () => {
+	it("keeps the glyph legible on its own chip", () => {
 		// 3:1 is the floor the rest of the palette is measured to. A chip whose
 		// glyph disappears into its wash is worse than no chip at all.
-		for (const kind of KINDS) {
-			for (const mode of ["light", "dark"] as const) {
-				const { bg, fg } = COMPONENT_BADGE[kind][mode];
-				expect(contrast(bg, fg)).toBeGreaterThanOrEqual(3);
-			}
+		for (const mode of ["light", "dark"] as const) {
+			const { bg, fg } = COMPONENT_CHIP[mode];
+			expect(contrast(bg, fg)).toBeGreaterThanOrEqual(3);
 		}
 	});
 
-	it("keeps every chip quiet against the page it is drawn on", () => {
+	it("keeps the chip quiet against the page it is drawn on", () => {
 		// The wash must read as a tint of the page, not as a block on it. Above
 		// ~1.6 it stops being a chip and starts being a highlight bar.
-		for (const kind of KINDS) {
-			for (const mode of ["light", "dark"] as const) {
-				const { bg } = COMPONENT_BADGE[kind][mode];
-				const page = CONTRAST_REFERENCE_KEYS[mode];
-				expect(contrast(bg, page)).toBeLessThan(1.6);
-			}
+		for (const mode of ["light", "dark"] as const) {
+			const { bg } = COMPONENT_CHIP[mode];
+			const page = CONTRAST_REFERENCE_KEYS[mode];
+			expect(contrast(bg, page)).toBeLessThan(1.6);
 		}
 	});
 
@@ -86,13 +79,4 @@ describe("componentBadge", () => {
 		expect(CONTRAST_REFERENCE_KEYS.light).toBe(CONTRAST_REFERENCE.light);
 		expect(CONTRAST_REFERENCE_KEYS.dark).toBe(CONTRAST_REFERENCE.dark);
 	});
-
-	it("gives each kind a distinguishable hue", () => {
-		// Single-character colour carries no readable hue *shift*, only a readable
-		// hue *difference* — the same reason the scope squares are far apart.
-		for (const mode of ["light", "dark"] as const) {
-			const fills = KINDS.map((k) => COMPONENT_BADGE[k][mode].bg);
-			expect(new Set(fills).size).toBe(KINDS.length);
-		}
-	});
 });

package/src/__tests__/footer-hints.test.ts

@@ -7,7 +7,7 @@
  * does not exist.
  */
 import { describe, expect, test } from "bun:test";
-import { joinKeys } from "../ui/components/layout/FooterHints.js";
+import { joinKeys } from "../ui/keymap.js";
 
 describe("joinKeys", () => {
 	test("single-character keys butt together, the way an arrow pair is written", () => {

package/src/__tests__/manifest.test.ts

@@ -32,20 +32,6 @@ describe("migrateToV2", () => {
 		expect(v2.profiles.mine!.plugins).toEqual({ "dev@magus": true });
 	});
 
-	test("null/garbage input degrades to an empty manifest", () => {
-		expect(migrateToV2(null)).toEqual(emptyManifest());
-		expect(migrateToV2(42)).toEqual(emptyManifest());
-		expect(migrateToV2({})).toEqual(emptyManifest());
-	});
-
-	test("non-object profile entries are dropped", () => {
-		const v2 = migrateToV2({
-			version: 2,
-			profiles: { good: { name: "G" }, bad: 5 },
-		});
-		expect(Object.keys(v2.profiles)).toEqual(["good"]);
-	});
-
 	test("strictVersions is carried through as a boolean", () => {
 		expect(
 			migrateToV2({ version: 2, strictVersions: true, profiles: {} })
@@ -226,9 +212,9 @@ describe("mergeManifestSettings", () => {
 		);
 	});
 
-	// readManifest degrades a corrupt file to an empty manifest. Reusing it here
-	// would record nothing and report success, leaving the caller's live setting
-	// to be reverted by the next install with no way to learn why.
+	// A merge that quietly treated a corrupt file as empty would record nothing and
+	// report success, leaving the caller's live setting to be reverted by the next
+	// install with no way to learn why.
 	test("throws on an unreadable manifest instead of silently doing nothing", async () => {
 		await fs.outputFile(join(dir, ".claude", "profiles.json"), "{ not json");
 
@@ -278,4 +264,26 @@ describe("readManifest / writeManifest", () => {
 		expect(m.version).toBe(2);
 		expect(m.profiles.legacy!.name).toBe("L");
 	});
+
+	// These inputs used to degrade to an empty manifest (garbage) or lose the
+	// bad entry (non-object profile). "Empty" is the state that offers to save a
+	// first profile over the file, so both are now refusals.
+	test("null/garbage input is refused, not read as an empty manifest", async () => {
+		const file = join(dir, ".claude", "profiles.json");
+		for (const garbage of ["null", "42"]) {
+			await fs.outputFile(file, garbage);
+			await expect(readManifest(dir)).rejects.toThrow(file);
+		}
+		await fs.outputFile(file, "{}");
+		expect(await readManifest(dir)).toEqual(emptyManifest());
+	});
+
+	test("a non-object profile entry is refused, not dropped", async () => {
+		const file = join(dir, ".claude", "profiles.json");
+		await fs.outputJson(file, {
+			version: 2,
+			profiles: { good: { name: "G" }, bad: 5 },
+		});
+		await expect(readManifest(dir)).rejects.toThrow(file);
+	});
 });

package/src/__tests__/marketplace-badge.test.ts

@@ -52,8 +52,8 @@ function toneFor(marketplace: Marketplace): string | undefined {
 
 describe("marketplace category badge", () => {
 	test("the byline uses a low-key tone, not an attention-grabbing one", () => {
-		// It is a signature, not a status. Green reads as "action succeeded" and
-		// competes with the plugin rows for attention.
+		// It is a signature, not a status. The success role reads as "action
+		// succeeded" and competes with the plugin rows for attention.
 		expect(
 			toneFor(
 				mp({
@@ -63,7 +63,7 @@ describe("marketplace category badge", () => {
 			),
 		).toBe("byline");
 
-		// A third-party marketplace still uses the green "Added" status tone.
+		// A third-party marketplace still uses the "Added" status tone, by role.
 		expect(
 			toneFor(
 				mp({
@@ -71,7 +71,7 @@ describe("marketplace category badge", () => {
 					source: { source: "github", repo: "obra/superpowers-marketplace" },
 				}),
 			),
-		).toBe("green");
+		).toBe("success");
 	});
 
 	test("MadAppGang marketplaces carry the byline instead of a generic label", () => {

package/src/__tests__/models-screen-state.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, test } from "bun:test";
 import { join } from "node:path";
+import { parseKeypress } from "@opentui/core";
 import fs from "fs-extra";
 import { DEFAULT_PRESET, findPreset } from "../data/models-presets.js";
 import type { ModelsStatus } from "../services/models-core.js";
+import type { KeyPress } from "../ui/input/key-dispatch.js";
+import { SCREEN_BINDINGS, matchBinding } from "../ui/keymap.js";
 import { appReducer, initialState } from "../ui/state/reducer.js";
 import type { AppAction, AppState, ModelsSnapshot } from "../ui/state/types.js";
 import { asyncValue } from "../ui/state/types.js";
@@ -11,6 +14,18 @@ function run(actions: AppAction[], from: AppState = initialState): AppState {
 	return actions.reduce(appReducer, from);
 }
 
+/** A real parsed keypress, in the shape the keymap matches. */
+function press(raw: string): KeyPress {
+	const k = parseKeypress(raw);
+	return {
+		name: k?.name ?? "",
+		sequence: k?.sequence ?? "",
+		ctrl: k?.ctrl === true,
+		meta: k?.meta === true,
+		shift: k?.shift === true,
+	};
+}
+
 function status(over: Partial<ModelsStatus> = {}): ModelsStatus {
 	return { state: "off", preset: null, drift: [], warnings: [], ...over };
 }
@@ -268,23 +283,31 @@ const SCREEN = join(import.meta.dir, "..", "ui", "screens", "ModelsScreen.tsx");
 
 describe("ModelsScreen keybindings", () => {
 	test("a and Enter both apply, and c clears", async () => {
-		const src = await fs.readFile(SCREEN, "utf8");
-		expect(src).toContain('event.name === "a"');
-		expect(src).toContain('event.name === "c"');
-		expect(src).toContain('event.name === "r"');
-		expect(src).toContain('event.name === "/"');
+		const models = SCREEN_BINDINGS.models;
+		expect(matchBinding(models, press("a"))?.id).toBe("apply");
+		expect(matchBinding(models, press("c"))?.id).toBe("off");
+		expect(matchBinding(models, press("r"))?.id).toBe("reload");
+		expect(matchBinding(models, press("/"))?.id).toBe("search");
 		// Enter is the same action as `a`. There is nothing to "open" here, so
 		// binding the most obvious key to nothing would be the wrong lesson.
-		const enter = src.indexOf('event.name === "return"');
-		expect(enter).toBeGreaterThan(-1);
-		expect(src.slice(enter, enter + 400)).toContain("handleApply()");
+		expect(matchBinding(models, press("\r"))?.id).toBe("apply");
+		const src = await fs.readFile(SCREEN, "utf8");
+		const apply = src.indexOf("apply: () =>");
+		expect(apply).toBeGreaterThan(-1);
+		expect(src.slice(apply, apply + 120)).toContain("handleApply()");
 	});
 
-	test("digits are treated as navigation, so a message survives a tab round trip", async () => {
-		// Every digit now navigates, 0 included. Clearing the status line on the
-		// way OUT of the tab loses the message the state was changed to preserve.
-		const src = await fs.readFile(SCREEN, "utf8");
-		expect(src).toContain("/^[0-9]$/.test(event.name");
+	test("digits and Tab never reach the screen, so a message survives a tab round trip", () => {
+		// The status line is cleared only by this screen's own bindings. Every
+		// digit (0 included) and Tab navigate, and they belong to the global key
+		// layer: no Models binding may claim one, or the message would be wiped
+		// on the way OUT of the tab — the loss the state was moved to prevent.
+		for (const digit of "1234567890") {
+			expect(
+				matchBinding(SCREEN_BINDINGS.models, press(digit)),
+			).toBeUndefined();
+		}
+		expect(matchBinding(SCREEN_BINDINGS.models, press("\t"))).toBeUndefined();
 	});
 
 	test("no screen still treats 0 as a non-navigation key", async () => {

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

@@ -1,25 +1,16 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { 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";
+import { theme } from "../ui/theme.js";
 
 /**
- * The scope bar is three filled segments; only the fill says lit or unlit.
+ * The scope bar is three positional squares: user, project, local.
  *
- * 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.
+ * It used to be three FILLED blocks told apart only by fill colour — a scope
+ * hue when lit, a page-relative grey when not — so without colour (a
+ * monochrome terminal, a colour-blind reader, a theme drawing two hues alike)
+ * every state was the same shape. Now position names the scope and SHAPE says
+ * the state: `■` installed, `□` not. Colour only repeats what the shape says.
  */
 
 interface SpanLike {
@@ -35,129 +26,52 @@ 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");
+describe("shape says the state", () => {
+	test("installed is filled, not installed is hollow, by position", () => {
 		const el = ScopeSquares({ user: true, project: false, local: true });
-		expect(glyphs(el)).toEqual(["■", "■", "■"]);
+		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("the two states never share a glyph", () => {
+		const on = glyphs(ScopeSquares({ user: true, project: true, local: true }));
+		const off = glyphs(
+			ScopeSquares({ user: false, project: false, local: false }),
+		);
+		expect(new Set(on)).toEqual(new Set(["■"]));
+		expect(new Set(off)).toEqual(new Set(["□"]));
 	});
+});
 
-	test("a mixed bar shows lit and unlit fills side by side", () => {
-		setThemeMode("light");
+describe("colour repeats the shape", () => {
+	test("a filled square wears success, a hollow one muted", () => {
 		const el = ScopeSquares({ user: false, project: true, local: false });
 		expect(fills(el)).toEqual([
-			SCOPE_OFF_FILL.light,
-			theme.scopes.project,
-			SCOPE_OFF_FILL.light,
+			theme.colors.muted,
+			theme.colors.success,
+			theme.colors.muted,
 		]);
 	});
-
-	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");
+	test("filled squares take the selection ink, hollow ones its dim ink", () => {
 		const el = ScopeSquares({
 			user: true,
 			project: false,
 			local: true,
 			selected: true,
 		});
+		expect(glyphs(el)).toEqual(["■", "□", "■"]);
 		expect(fills(el)).toEqual([
 			theme.selection.fg,
-			theme.selection.bg,
+			theme.selection.dim,
 			theme.selection.fg,
 		]);
 	});