claudeup 6.2.1 → 6.3.0

package/src/__tests__/version-snapshot.test.ts

@@ -3,11 +3,11 @@ import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import {
-  diffVersions,
-  isKnownVersion,
-  loadSeenVersions,
-  saveSeenVersions,
-  UNKNOWN_VERSION,
+	UNKNOWN_VERSION,
+	diffVersions,
+	isKnownVersion,
+	loadSeenVersions,
+	saveSeenVersions,
 } from "../services/version-snapshot.js";
 
 /**
@@ -18,179 +18,197 @@ import {
  */
 
 describe("isKnownVersion", () => {
-  test('"0.0.0" is not a usable version', () => {
-    // Claude Code records this for a plugin whose version it cannot determine.
-    expect(isKnownVersion(UNKNOWN_VERSION)).toBe(false);
-    expect(isKnownVersion(undefined)).toBe(false);
-    expect(isKnownVersion("")).toBe(false);
-    expect(isKnownVersion("1.0.0")).toBe(true);
-  });
+	test('"0.0.0" is not a usable version', () => {
+		// Claude Code records this for a plugin whose version it cannot determine.
+		expect(isKnownVersion(UNKNOWN_VERSION)).toBe(false);
+		expect(isKnownVersion(undefined)).toBe(false);
+		expect(isKnownVersion("")).toBe(false);
+		expect(isKnownVersion("1.0.0")).toBe(true);
+	});
 });
 
 describe("diffVersions — first run", () => {
-  test("no baseline reports nothing at all", () => {
-    // Without this, the first launch would flag every installed plugin as new,
-    // which is both wrong and the fastest way to train someone to ignore badges.
-    expect(
-      diffVersions(null, { "dev@magus": "2.12.1", "a@mp": UNKNOWN_VERSION }),
-    ).toEqual([]);
-  });
-
-  test("an empty baseline is NOT the same as no baseline", () => {
-    // A real snapshot that happens to be empty means we have looked before and
-    // saw nothing, so anything present now is genuinely new.
-    const changes = diffVersions({}, { "dev@magus": "2.12.1" });
-    expect(changes).toEqual([
-      { pluginId: "dev@magus", kind: "installed", to: "2.12.1" },
-    ]);
-  });
+	test("no baseline reports nothing at all", () => {
+		// Without this, the first launch would flag every installed plugin as new,
+		// which is both wrong and the fastest way to train someone to ignore badges.
+		expect(
+			diffVersions(null, { "dev@magus": "2.12.1", "a@mp": UNKNOWN_VERSION }),
+		).toEqual([]);
+	});
+
+	test("an empty baseline is NOT the same as no baseline", () => {
+		// A real snapshot that happens to be empty means we have looked before and
+		// saw nothing, so anything present now is genuinely new.
+		const changes = diffVersions({}, { "dev@magus": "2.12.1" });
+		expect(changes).toEqual([
+			{ pluginId: "dev@magus", kind: "installed", to: "2.12.1" },
+		]);
+	});
 });
 
 describe("diffVersions — installs", () => {
-  test("a plugin absent from the baseline is reported as installed, not updated", () => {
-    const changes = diffVersions({ "other@mp": "1.0.0" }, { "new@mp": "3.1.0" });
-    expect(changes).toEqual([
-      { pluginId: "new@mp", kind: "installed", to: "3.1.0" },
-    ]);
-  });
-
-  test("an install with an unknown version is still reported", () => {
-    // The version is unusable but the install is real — the UI shows "new"
-    // with no version rather than suppressing the plugin entirely.
-    const changes = diffVersions({}, { "a@mp": UNKNOWN_VERSION });
-    expect(changes).toEqual([
-      { pluginId: "a@mp", kind: "installed", to: UNKNOWN_VERSION },
-    ]);
-  });
+	test("a plugin absent from the baseline is reported as installed, not updated", () => {
+		const changes = diffVersions(
+			{ "other@mp": "1.0.0" },
+			{ "new@mp": "3.1.0" },
+		);
+		expect(changes).toEqual([
+			{ pluginId: "new@mp", kind: "installed", to: "3.1.0" },
+		]);
+	});
+
+	test("an install with an unknown version is still reported", () => {
+		// The version is unusable but the install is real — the UI shows "new"
+		// with no version rather than suppressing the plugin entirely.
+		const changes = diffVersions({}, { "a@mp": UNKNOWN_VERSION });
+		expect(changes).toEqual([
+			{ pluginId: "a@mp", kind: "installed", to: UNKNOWN_VERSION },
+		]);
+	});
 });
 
 describe("diffVersions — updates", () => {
-  test("reports a genuine version transition", () => {
-    expect(
-      diffVersions({ "dev@magus": "2.12.0" }, { "dev@magus": "2.12.1" }),
-    ).toEqual([
-      { pluginId: "dev@magus", kind: "updated", from: "2.12.0", to: "2.12.1" },
-    ]);
-  });
-
-  test("unchanged versions report nothing", () => {
-    expect(
-      diffVersions({ "dev@magus": "2.12.1" }, { "dev@magus": "2.12.1" }),
-    ).toEqual([]);
-  });
-
-  test("learning a previously unknown version is not an update", () => {
-    // This is exactly what v4.22.0's registry overlay caused: versions that
-    // could not be resolved suddenly could be. Reporting it would announce
-    // claudeup's own bugfix as if the user's plugins had changed.
-    expect(diffVersions({ "a@mp": UNKNOWN_VERSION }, { "a@mp": "5.3.0" })).toEqual([]);
-  });
-
-  test("losing a known version is not an update either", () => {
-    expect(diffVersions({ "a@mp": "5.3.0" }, { "a@mp": UNKNOWN_VERSION })).toEqual([]);
-  });
-
-  test("a downgrade IS reported", () => {
-    // Rolling back is a real change, arguably the most important to surface.
-    expect(diffVersions({ "a@mp": "2.0.0" }, { "a@mp": "1.0.0" })).toEqual([
-      { pluginId: "a@mp", kind: "updated", from: "2.0.0", to: "1.0.0" },
-    ]);
-  });
+	test("reports a genuine version transition", () => {
+		expect(
+			diffVersions({ "dev@magus": "2.12.0" }, { "dev@magus": "2.12.1" }),
+		).toEqual([
+			{ pluginId: "dev@magus", kind: "updated", from: "2.12.0", to: "2.12.1" },
+		]);
+	});
+
+	test("unchanged versions report nothing", () => {
+		expect(
+			diffVersions({ "dev@magus": "2.12.1" }, { "dev@magus": "2.12.1" }),
+		).toEqual([]);
+	});
+
+	test("learning a previously unknown version is not an update", () => {
+		// This is exactly what v4.22.0's registry overlay caused: versions that
+		// could not be resolved suddenly could be. Reporting it would announce
+		// claudeup's own bugfix as if the user's plugins had changed.
+		expect(
+			diffVersions({ "a@mp": UNKNOWN_VERSION }, { "a@mp": "5.3.0" }),
+		).toEqual([]);
+	});
+
+	test("losing a known version is not an update either", () => {
+		expect(
+			diffVersions({ "a@mp": "5.3.0" }, { "a@mp": UNKNOWN_VERSION }),
+		).toEqual([]);
+	});
+
+	test("a downgrade IS reported", () => {
+		// Rolling back is a real change, arguably the most important to surface.
+		expect(diffVersions({ "a@mp": "2.0.0" }, { "a@mp": "1.0.0" })).toEqual([
+			{ pluginId: "a@mp", kind: "updated", from: "2.0.0", to: "1.0.0" },
+		]);
+	});
 });
 
 describe("diffVersions — removals and mixed sets", () => {
-  test("a removed plugin is not reported", () => {
-    expect(diffVersions({ "gone@mp": "1.0.0" }, {})).toEqual([]);
-  });
-
-  test("classifies each plugin independently in one pass", () => {
-    const changes = diffVersions(
-      { same: "1.0.0", moved: "2.0.0", learned: UNKNOWN_VERSION },
-      { same: "1.0.0", moved: "2.1.0", learned: "9.0.0", fresh: "0.1.0" },
-    );
-    expect(changes).toEqual([
-      { pluginId: "moved", kind: "updated", from: "2.0.0", to: "2.1.0" },
-      { pluginId: "fresh", kind: "installed", to: "0.1.0" },
-    ]);
-  });
+	test("a removed plugin is not reported", () => {
+		expect(diffVersions({ "gone@mp": "1.0.0" }, {})).toEqual([]);
+	});
+
+	test("classifies each plugin independently in one pass", () => {
+		const changes = diffVersions(
+			{ same: "1.0.0", moved: "2.0.0", learned: UNKNOWN_VERSION },
+			{ same: "1.0.0", moved: "2.1.0", learned: "9.0.0", fresh: "0.1.0" },
+		);
+		expect(changes).toEqual([
+			{ pluginId: "moved", kind: "updated", from: "2.0.0", to: "2.1.0" },
+			{ pluginId: "fresh", kind: "installed", to: "0.1.0" },
+		]);
+	});
 });
 
 describe("per-project baselines", () => {
-  /**
-   * The baseline used to be one flat map for the whole machine, but the
-   * versions written into it are resolved per project. Two projects
-   * legitimately on different versions overwrote each other's baseline, so
-   * every differing plugin was reported as "updated" on the next render — a
-   * change that never happened.
-   *
-   * CLAUDE_CONFIG_DIR, not HOME: os.homedir() reads the passwd database on
-   * macOS and ignores $HOME, so a HOME-only override writes to the operator's
-   * real ~/.claude. That is not hypothetical — it happened while writing these.
-   */
-  const withSandbox = async (fn: () => Promise<void>): Promise<void> => {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "vsnap-"));
-    const prev = process.env.CLAUDE_CONFIG_DIR;
-    process.env.CLAUDE_CONFIG_DIR = dir;
-    try {
-      await fn();
-    } finally {
-      if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
-      else process.env.CLAUDE_CONFIG_DIR = prev;
-      await fs.rm(dir, { recursive: true, force: true });
-    }
-  };
-
-  test("a project with no baseline of its own reports nothing", async () => {
-    await withSandbox(async () => {
-      await saveSeenVersions("/proj/a", { "statusline@magus": "2.2.0" });
-      const baseline = await loadSeenVersions("/proj/b");
-      expect(baseline).toBeNull();
-      expect(diffVersions(baseline, { "statusline@magus": "2.5.0" })).toEqual([]);
-    });
-  });
-
-  test("saving one project preserves the others", async () => {
-    await withSandbox(async () => {
-      await saveSeenVersions("/proj/a", { "gtd@magus": "2.0.0" });
-      await saveSeenVersions("/proj/b", { "gtd@magus": "2.0.1" });
-      expect(await loadSeenVersions("/proj/a")).toEqual({ "gtd@magus": "2.0.0" });
-      expect(await loadSeenVersions("/proj/b")).toEqual({ "gtd@magus": "2.0.1" });
-    });
-  });
-
-  test("a real update inside one project is still reported", async () => {
-    await withSandbox(async () => {
-      await saveSeenVersions("/proj/a", { "dev@magus": "3.0.0" });
-      const previous = await loadSeenVersions("/proj/a");
-      expect(diffVersions(previous, { "dev@magus": "3.0.1" })).toEqual([
-        { pluginId: "dev@magus", kind: "updated", from: "3.0.0", to: "3.0.1" },
-      ]);
-    });
-  });
-
-  test("a pre-migration flat baseline is adopted once, then replaced", async () => {
-    await withSandbox(async () => {
-      const file = path.join(
-        process.env.CLAUDE_CONFIG_DIR as string,
-        "claudeup-version-snapshot.json",
-      );
-      await fs.writeFile(
-        file,
-        JSON.stringify({
-          seen: { "dev@magus": "3.0.0" },
-          seededAt: "2026-07-29T00:00:00.000Z",
-          updatedAt: "2026-07-29T00:00:00.000Z",
-        }),
-      );
-
-      // Legacy shape carries no project, so it stands in for whoever asks first
-      // rather than being thrown away.
-      expect(await loadSeenVersions("/proj/a")).toEqual({ "dev@magus": "3.0.0" });
-
-      await saveSeenVersions("/proj/a", { "dev@magus": "3.0.1" });
-      // Once per-project entries exist, the flat map is no longer consulted.
-      expect(await loadSeenVersions("/proj/b")).toBeNull();
-      expect(await loadSeenVersions("/proj/a")).toEqual({ "dev@magus": "3.0.1" });
-    });
-  });
+	/**
+	 * The baseline used to be one flat map for the whole machine, but the
+	 * versions written into it are resolved per project. Two projects
+	 * legitimately on different versions overwrote each other's baseline, so
+	 * every differing plugin was reported as "updated" on the next render — a
+	 * change that never happened.
+	 *
+	 * CLAUDE_CONFIG_DIR, not HOME: os.homedir() reads the passwd database on
+	 * macOS and ignores $HOME, so a HOME-only override writes to the operator's
+	 * real ~/.claude. That is not hypothetical — it happened while writing these.
+	 */
+	const withSandbox = async (fn: () => Promise<void>): Promise<void> => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "vsnap-"));
+		const prev = process.env.CLAUDE_CONFIG_DIR;
+		process.env.CLAUDE_CONFIG_DIR = dir;
+		try {
+			await fn();
+		} finally {
+			// biome-ignore lint/performance/noDelete: assigning undefined to process.env stores the string "undefined"; only delete unsets the variable
+			if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+			else process.env.CLAUDE_CONFIG_DIR = prev;
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	};
+
+	test("a project with no baseline of its own reports nothing", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "statusline@magus": "2.2.0" });
+			const baseline = await loadSeenVersions("/proj/b");
+			expect(baseline).toBeNull();
+			expect(diffVersions(baseline, { "statusline@magus": "2.5.0" })).toEqual(
+				[],
+			);
+		});
+	});
+
+	test("saving one project preserves the others", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "gtd@magus": "2.0.0" });
+			await saveSeenVersions("/proj/b", { "gtd@magus": "2.0.1" });
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"gtd@magus": "2.0.0",
+			});
+			expect(await loadSeenVersions("/proj/b")).toEqual({
+				"gtd@magus": "2.0.1",
+			});
+		});
+	});
+
+	test("a real update inside one project is still reported", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "dev@magus": "3.0.0" });
+			const previous = await loadSeenVersions("/proj/a");
+			expect(diffVersions(previous, { "dev@magus": "3.0.1" })).toEqual([
+				{ pluginId: "dev@magus", kind: "updated", from: "3.0.0", to: "3.0.1" },
+			]);
+		});
+	});
+
+	test("a pre-migration flat baseline is adopted once, then replaced", async () => {
+		await withSandbox(async () => {
+			const file = path.join(
+				process.env.CLAUDE_CONFIG_DIR as string,
+				"claudeup-version-snapshot.json",
+			);
+			await fs.writeFile(
+				file,
+				JSON.stringify({
+					seen: { "dev@magus": "3.0.0" },
+					seededAt: "2026-07-29T00:00:00.000Z",
+					updatedAt: "2026-07-29T00:00:00.000Z",
+				}),
+			);
+
+			// Legacy shape carries no project, so it stands in for whoever asks first
+			// rather than being thrown away.
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"dev@magus": "3.0.0",
+			});
+
+			await saveSeenVersions("/proj/a", { "dev@magus": "3.0.1" });
+			// Once per-project entries exist, the flat map is no longer consulted.
+			expect(await loadSeenVersions("/proj/b")).toBeNull();
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"dev@magus": "3.0.1",
+			});
+		});
+	});
 });

package/src/cli/ansi.ts

@@ -59,7 +59,7 @@ const clamp01 = (n: number): number =>
 /** `#rgb` and `#rrggbb`, hash optional. Anything else resolves to black. */
 function parseHex(hex: string): [number, number, number] {
 	let h = hex.trim().replace(/^#/, "");
-	if (h.length === 3) h = h[0]! + h[0]! + h[1]! + h[1]! + h[2]! + h[2]!;
+	if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
 	if (!/^[0-9a-fA-F]{6}$/.test(h)) return [0, 0, 0];
 	return [
 		Number.parseInt(h.slice(0, 2), 16),
@@ -110,19 +110,22 @@ export function mix(from: string, to: string, t: number): string {
 export function blend1D(steps: number, from: string, to: string): string[] {
 	if (!Number.isInteger(steps) || steps <= 0) return [];
 	if (steps === 1) return [toHex(parseHex(from))];
-	return Array.from({ length: steps }, (_, i) => mix(from, to, i / (steps - 1)));
+	return Array.from({ length: steps }, (_, i) =>
+		mix(from, to, i / (steps - 1)),
+	);
 }
 
 /** Multi-stop ramp: `steps` colours spread evenly across every stop, in order. */
 export function blendStops(steps: number, ...stops: string[]): string[] {
 	if (!Number.isInteger(steps) || steps <= 0 || stops.length === 0) return [];
-	if (stops.length === 1 || steps === 1)
-		return blend1D(steps, stops[0]!, stops.at(-1)!);
+	const first = stops[0];
+	const last = stops[stops.length - 1];
+	if (stops.length === 1 || steps === 1) return blend1D(steps, first, last);
 	const segs = stops.length - 1;
 	return Array.from({ length: steps }, (_, i) => {
 		const p = (i / (steps - 1)) * segs;
 		const s = Math.min(segs - 1, Math.floor(p));
-		return mix(stops[s]!, stops[s + 1]!, p - s);
+		return mix(stops[s], stops[s + 1], p - s);
 	});
 }
 
@@ -283,7 +286,7 @@ function charWidth(cp: number): number {
 /** Visible cell width, ignoring escape sequences. */
 export function width(text: string): number {
 	let w = 0;
-	for (const ch of stripAnsi(text)) w += charWidth(ch.codePointAt(0)!);
+	for (const ch of stripAnsi(text)) w += charWidth(ch.codePointAt(0) ?? 0);
 	return w;
 }
 
@@ -321,8 +324,10 @@ export function truncate(text: string, n: number): string {
 			i += m[0].length;
 			continue;
 		}
-		const ch = String.fromCodePoint(text.codePointAt(i)!);
-		const cw = charWidth(ch.codePointAt(0)!);
+		const cp = text.codePointAt(i);
+		if (cp === undefined) break;
+		const ch = String.fromCodePoint(cp);
+		const cw = charWidth(cp);
 		if (w + cw > n) break;
 		out += ch;
 		w += cw;
@@ -391,10 +396,13 @@ export function meter(
 	if (cells <= 0) return "";
 	const p = clamp01((Number.isFinite(pct) ? pct : 0) / 100);
 	const filled = Math.round(p * cells);
-	const cols = blendStops(cells, ...(stops.length > 0 ? stops : ramps.progress));
+	const cols = blendStops(
+		cells,
+		...(stops.length > 0 ? stops : ramps.progress),
+	);
 	let out = "";
 	for (let i = 0; i < cells; i++) {
-		out += i < filled ? fg(cols[i]!, FILL) : fg(TRACK_COLOR, TRACK);
+		out += i < filled ? fg(cols[i], FILL) : fg(TRACK_COLOR, TRACK);
 	}
 	return out;
 }
@@ -446,14 +454,14 @@ export function stackedBar(cells: number, segments: BarSegment[]): string {
 	while (drift !== 0) {
 		const i = widths.indexOf(Math.max(...widths));
 		if (drift > 0) {
-			widths[i]!++;
+			widths[i]++;
 			drift--;
-		} else if (widths[i]! > 1) {
-			widths[i]!--;
+		} else if (widths[i] > 1) {
+			widths[i]--;
 			drift++;
 		} else break;
 	}
-	return live.map((s, i) => fg(s.color, FILL.repeat(widths[i]!))).join("");
+	return live.map((s, i) => fg(s.color, FILL.repeat(widths[i]))).join("");
 }
 
 /**
@@ -498,7 +506,7 @@ export function badge(label: string, hex: string): string {
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
 
 export function spinner(tick: number): string {
-	return SPINNER[Math.abs(Math.trunc(tick)) % SPINNER.length]!;
+	return SPINNER[Math.abs(Math.trunc(tick)) % SPINNER.length];
 }
 
 /** Elapsed time sized to its magnitude: `340ms`, `1.4s`, `2m04s`. */

package/src/cli/doctor.ts

@@ -8,16 +8,13 @@
  *   3. Convention compliance — .gitignore + CLAUDE.md blocks (ported engine).
  */
 
-import fs from "fs-extra";
 import path from "node:path";
-import { readManifest } from "../services/manifest.js";
-import { resolveAllProfiles } from "../services/resolver.js";
+import fs from "fs-extra";
 import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
-import {
-	activeProfile,
-	profileDir,
-} from "../services/symlink-manager.js";
 import { checkProject, fixDoctorIssues } from "../services/doctor.js";
+import { readManifest } from "../services/manifest.js";
+import { resolveAllProfiles } from "../services/resolver.js";
+import { activeProfile, profileDir } from "../services/symlink-manager.js";
 
 export async function runDoctorCommand(args: string[]): Promise<number> {
 	const fix = args.includes("--fix");
@@ -42,7 +39,9 @@ export async function runDoctorCommand(args: string[]): Promise<number> {
 					problems++;
 				}
 			} else {
-				console.log(`✓ All ${closure.bins.length} binary dependencies present.`);
+				console.log(
+					`✓ All ${closure.bins.length} binary dependencies present.`,
+				);
 			}
 		}
 	}
@@ -70,7 +69,9 @@ export async function runDoctorCommand(args: string[]): Promise<number> {
 			if (actionable.length > 0) {
 				console.log("\nConventions:");
 				for (const check of actionable) {
-					console.log(`  ${check.status === "fail" ? "✗" : "•"} ${check.message}`);
+					console.log(
+						`  ${check.status === "fail" ? "✗" : "•"} ${check.message}`,
+					);
 				}
 				const fixable = actionable.filter((c) => c.fixable).length;
 				const failures = actionable.filter((c) => c.status === "fail").length;

package/src/cli/install.ts

@@ -48,9 +48,9 @@ import type {
 	SkillInfo,
 } from "../types/index.js";
 import { formatCommand, resolveExecutable } from "../utils/command-utils.js";
+import { runCommand, runShellScript } from "../utils/run.js";
 import { ensureManifest } from "./bootstrap.js";
 import { confirm, promptValue } from "./prompt.js";
-import { runCommand, runShellScript } from "../utils/run.js";
 
 interface InstallFlags {
 	check: boolean;
@@ -292,8 +292,8 @@ export async function runInstallCommand(
 				);
 				for (const c of drift) console.error(`  ${c.kind}: ${c.detail}`);
 				console.error(
-					`\nRun \`claudeup profile sync\` to promote them into .claude/profiles.json,\n` +
-						`or re-run with --force to discard them.`,
+					"\nRun `claudeup profile sync` to promote them into .claude/profiles.json,\n" +
+						"or re-run with --force to discard them.",
 				);
 				return 1;
 			}

package/src/cli/profile.ts

@@ -66,7 +66,7 @@ export async function initProfile(
 			`${getManifestPath(projectPath)} already defines: ${Object.keys(existing.profiles).join(", ")}`,
 		);
 		console.error(
-			`Use \`claudeup profile sync\` to promote local edits into it.`,
+			"Use `claudeup profile sync` to promote local edits into it.",
 		);
 		return 1;
 	}
@@ -85,7 +85,7 @@ export async function listProfiles(projectPath: string): Promise<number> {
 	const active = await activeProfile(projectPath);
 	console.log("Profiles:");
 	for (const id of ids) {
-		const entry = manifest.profiles[id]!;
+		const entry = manifest.profiles[id];
 		const marker = id === active ? "●" : " ";
 		const materialized = (await fs.pathExists(profileDir(id, projectPath)))
 			? ""
@@ -105,14 +105,15 @@ export async function showProfile(
 		return 1;
 	}
 	const manifest = await readManifest(projectPath);
-	if (!manifest.profiles[name]) {
+	const entry = manifest.profiles[name];
+	if (!entry) {
 		console.error(
 			`Profile "${name}" not found. Available: ${Object.keys(manifest.profiles).join(", ")}`,
 		);
 		return 1;
 	}
 	const closure = await resolveProfile(manifest, name);
-	console.log(`Profile: ${name} (${manifest.profiles[name]!.name})`);
+	console.log(`Profile: ${name} (${entry.name})`);
 	for (const line of summarizeClosure(closure)) console.log(`  ${line}`);
 	return 0;
 }

package/src/cli/prompt.ts

@@ -30,4 +30,3 @@ export async function promptValue(question: string): Promise<string> {
 		rl.close();
 	}
 }
-