magus-cli 7.13.0 → 7.14.0

package/src/services/market-ops-skill.ts

@@ -88,10 +88,17 @@ import {
 	filesUnder,
 	installLines,
 	installStep,
+	pluginViewAt,
 	readPlugin,
 	versionFiles,
 	versionLine,
 } from "./market-ops-content.js";
+import {
+	NEW_PLUGIN_VERSION,
+	newPluginLayout,
+	refreshStep,
+	writeNewPlugin,
+} from "./market-ops-plugin.js";
 
 // ─── skill add ───────────────────────────────────────────────────────────────
 
@@ -100,6 +107,13 @@ export interface SkillAddArgs {
 	plugin: string;
 	from: "project" | "global";
 	keepLocal: boolean;
+	/**
+	 * Create the plugin, in the same commit, when the marketplace has none of
+	 * that name. Without it a missing plugin is `not-found`.
+	 */
+	createPlugin?: boolean;
+	/** The new plugin's description; read only when it is created. */
+	description?: string;
 }
 
 export function skillFolder(
@@ -169,7 +183,34 @@ export async function planSkillAdd(
 				`${where} has no skill named ${args.skill}`,
 			);
 		}
-		const view = await readPlugin(args.plugin);
+		const ref = await resolvePluginRef(args.plugin);
+		const snapNow = await freshSnapshot(ref.m);
+		const manifestNow = await manifestAt(snapNow, ref.m.name);
+		const exists = pluginEntries(manifestNow).some(
+			(p) => p.name === ref.plugin,
+		);
+		if (!exists && !args.createPlugin) {
+			throw new MarketError(
+				"not-found",
+				`${ref.m.name} has no plugin named ${ref.plugin}`,
+				"`magus market list` shows its plugins; add --create-plugin to create it with this skill",
+			);
+		}
+		// A plugin created here starts at its first version: nothing to bump.
+		const layout = exists
+			? null
+			: newPluginLayout(ref.m, snapNow, manifestNow, ref.plugin);
+		const view: PluginView = layout
+			? {
+					m: ref.m,
+					snap: snapNow,
+					manifest: manifestNow,
+					plugin: ref.plugin,
+					dir: layout.dir,
+					pluginJsonPath: layout.pluginJsonPath,
+					pluginJson: null,
+				}
+			: await pluginViewAt(ref.m, snapNow, manifestNow, ref.plugin);
 		const { m, snap, plugin, dir } = view;
 		const skillDir = joinRel(dir, "skills", args.skill);
 		if (filesUnder(snap, skillDir).length > 0) {
@@ -179,7 +220,9 @@ export async function planSkillAdd(
 				"to send your edits to it, use `magus market publish`",
 			);
 		}
-		const { from, to } = bumpFrom(view);
+		const { from, to } = layout
+			? { from: null, to: NEW_PLUGIN_VERSION }
+			: bumpFrom(view);
 		const sets = await readSourceSets(folder, snap.dir, skillDir);
 		if (sets.published.length === 0) {
 			throw new MarketError(
@@ -213,15 +256,40 @@ export async function planSkillAdd(
 					reason: keepReason,
 				}
 			: { scope: copyScope, name: args.skill, action: "removed" };
+		const created = layout
+			? [
+					{ path: MANIFEST, change: "modified" as const },
+					{ path: layout.pluginJsonPath, change: "added" as const },
+				]
+			: versionFiles(view);
 		const files = [
 			...sets.published.map((f) => ({
 				path: joinRel(skillDir, f.path),
 				change: "added" as const,
 			})),
-			...versionFiles(view),
+			...created,
 		];
 		const state: ChangeSpec["state"] & { moved?: boolean } = {};
 		const steps: MarketStep[] = [
+			...(layout
+				? [
+						{
+							id: "edit",
+							label: `wrote ${plugin}`,
+							outside: false,
+							async run(ctx: Parameters<MarketStep["run"]>[0]) {
+								writeNewPlugin(
+									cloneOf(ctx),
+									m,
+									view.manifest,
+									layout,
+									args.description,
+								);
+								return undefined;
+							},
+						} satisfies MarketStep,
+					]
+				: []),
 			{
 				id: "copy",
 				label: `copied ${args.skill} into ${plugin}`,
@@ -246,20 +314,27 @@ export async function planSkillAdd(
 					return undefined;
 				},
 			},
-			bumpStep(view, to),
+			...(layout ? [] : [bumpStep(view, to)]),
 			...changeSteps({
 				label: m.name,
 				source: m.source,
 				branch: snap.branch,
 				target,
-				stage: [skillDir, ...versionFiles(view).map((f) => f.path)],
+				stage: layout
+					? [MANIFEST, dir]
+					: [skillDir, ...versionFiles(view).map((f) => f.path)],
 				files,
-				message: `${plugin}: add ${args.skill} skill (${to})`,
+				message: layout
+					? `${plugin}: create plugin with ${args.skill} skill (${to})`
+					: `${plugin}: add ${args.skill} skill (${to})`,
 				slug: `${plugin}-${to}`,
-				prBody: `Adds the skill \`${args.skill}\` to \`${plugin}\` and bumps it to ${to}.`,
-				verify: { dir: skillDir, files: sets.published },
+				prBody: layout
+					? `Creates the plugin \`${plugin}\` (${to}) in ${m.name} with the skill \`${args.skill}\`.`
+					: `Adds the skill \`${args.skill}\` to \`${plugin}\` and bumps it to ${to}.`,
+				verify: [{ dir: skillDir, files: sets.published }],
 				state,
 			}),
+			...(layout ? [refreshStep(m.name, state)] : []),
 			installStep(view, installs, to, state),
 			{
 				id: "local-copy",
@@ -296,8 +371,14 @@ export async function planSkillAdd(
 			},
 		];
 		const lines = [
-			`Adds the skill ${args.skill} from ${where} to ${pluginId}`,
-			versionLine(plugin, from, to),
+			...(layout
+				? [
+						`Creates the plugin ${plugin} (${to}) in ${m.name}, with the skill ${args.skill} from ${where}, in one commit`,
+					]
+				: [
+						`Adds the skill ${args.skill} from ${where} to ${pluginId}`,
+						versionLine(plugin, from, to),
+					]),
 			`Publishes ${sets.published.length} file${sets.published.length === 1 ? "" : "s"}: ${sets.published.map((f) => f.path).join(", ")}`,
 			...(sets.untrackedFolder
 				? [
@@ -324,6 +405,7 @@ export async function planSkillAdd(
 				from: args.from,
 				keepLocal: args.keepLocal,
 				plugin: pluginId,
+				createPlugin: layout ? { description: args.description ?? null } : null,
 				commit: snap.commit,
 				hash: sets.hash,
 				notPublished: sets.notPublished,
@@ -344,7 +426,7 @@ export async function planSkillAdd(
 			steps,
 			sync: { name: m.name, url: cloneUrl(m.source) },
 			lock: m.name,
-			replan: () => planSkillAdd(args, cwd),
+			replan: () => planSkillAdd({ ...args, plugin: pluginId }, cwd),
 			doneMessage: `${args.skill} is in ${pluginId} ${to}. Takes effect in new sessions, or after /reload-plugins.`,
 		};
 		return { kind: "plan", plan };

package/src/services/market-ops.ts

@@ -31,8 +31,10 @@ import {
 	pluginRelDir,
 	pluginRootOf,
 } from "./market-layout.js";
+import { localItems } from "./market-local.js";
 import {
 	type TrustedRegistration,
+	isGithubSource,
 	listCompanyMarketplaces,
 } from "./market-registry.js";
 import {
@@ -400,6 +402,28 @@ function readJsonFile(file: string): unknown {
 	}
 }
 
+/**
+ * The company a marketplace belongs to: its manifest's `owner.name`, else the
+ * GitHub owner of its source. Undefined for a non-GitHub source whose
+ * manifest names no owner.
+ */
+export function companyOf(
+	manifest: unknown,
+	source: string,
+): string | undefined {
+	const owner =
+		manifest && typeof manifest === "object" && !Array.isArray(manifest)
+			? (manifest as { owner?: unknown }).owner
+			: undefined;
+	const name =
+		owner && typeof owner === "object"
+			? (owner as { name?: unknown }).name
+			: undefined;
+	if (typeof name === "string" && name.trim()) return name.trim();
+	if (isGithubSource(source)) return source.split("/")[0] || undefined;
+	return undefined;
+}
+
 /** The plugins and skills of a marketplace as Claude Code's copy holds them. */
 function rowFor(m: TrustedRegistration): MarketplaceRow {
 	const row: MarketplaceRow = {
@@ -408,10 +432,14 @@ function rowFor(m: TrustedRegistration): MarketplaceRow {
 		scope: "user",
 		plugins: [],
 	};
+	const fallback = companyOf(null, m.source);
+	if (fallback) row.company = fallback;
 	if (!m.location) return row;
 	const manifest = readJsonFile(
 		path.join(m.location, ".claude-plugin", "marketplace.json"),
 	);
+	const company = companyOf(manifest, m.source);
+	if (company) row.company = company;
 	const root = pluginRootOf(manifest);
 	for (const entry of pluginEntries(manifest)) {
 		const dir = pluginDirFor(m.location, entry.source, root);
@@ -443,9 +471,35 @@ function rowFor(m: TrustedRegistration): MarketplaceRow {
 	return row;
 }
 
-/** `market list`: every company marketplace here with its plugins. Read-only. */
-export async function marketList(): Promise<MarketResult> {
+/** Every plugin name among `marketplaces`. */
+export function companyPluginNames(
+	marketplaces: ReadonlyArray<{ plugins: MarketplaceRow["plugins"] }>,
+): Set<string> {
+	return new Set(marketplaces.flatMap((m) => m.plugins.map((p) => p.name)));
+}
+
+/** Every skill name a company plugin among `marketplaces` holds. */
+export function companySkillNames(
+	marketplaces: ReadonlyArray<{ plugins: MarketplaceRow["plugins"] }>,
+): Set<string> {
+	return new Set(
+		marketplaces.flatMap((m) => m.plugins.flatMap((p) => p.skills)),
+	);
+}
+
+/**
+ * `market list`: every company marketplace here with its plugins, and the
+ * skills and plugin folders here that none of them holds. Read-only.
+ */
+export async function marketList(
+	cwd: string = process.cwd(),
+): Promise<MarketResult> {
 	const marketplaces = (await listCompanyMarketplaces()).map(rowFor);
+	const local = await localItems(
+		cwd,
+		companySkillNames(marketplaces),
+		companyPluginNames(marketplaces),
+	);
 	return {
 		command: "market list",
 		outcome: "ok",
@@ -454,6 +508,7 @@ export async function marketList(): Promise<MarketResult> {
 				? "No company marketplaces on this machine"
 				: `${marketplaces.length} company marketplace${marketplaces.length === 1 ? "" : "s"} on this machine`,
 		marketplaces,
+		local,
 		steps: [],
 	};
 }
@@ -480,15 +535,16 @@ export interface MarketOverviewEntry {
 	fix: string;
 	/** The commit the plugins were read at, when a local copy had one. */
 	commit: string | null;
+	/** The company it belongs to, as {@link companyOf} reads it. */
+	company?: string;
 	plugins: MarketplaceRow["plugins"];
 }
 
 /** The plugins of a marketplace snapshot, with their versions and skills. */
 async function pluginsAt(
 	snap: Snapshot,
-	label: string,
+	manifest: Record<string, unknown>,
 ): Promise<MarketplaceRow["plugins"]> {
-	const manifest = await manifestAt(snap, label);
 	const root = pluginRootOf(manifest);
 	const out: MarketplaceRow["plugins"] = [];
 	for (const entry of pluginEntries(manifest)) {
@@ -541,14 +597,22 @@ export async function marketOverview(): Promise<MarketOverviewEntry[]> {
 			commit: state.snapshot?.commit ?? null,
 			plugins: [],
 		};
+		let fromSnapshot = false;
 		if (state.snapshot) {
 			try {
-				entry.plugins = await pluginsAt(state.snapshot, m.name);
+				const manifest = await manifestAt(state.snapshot, m.name);
+				entry.plugins = await pluginsAt(state.snapshot, manifest);
+				const company = companyOf(manifest, m.source);
+				if (company) entry.company = company;
+				fromSnapshot = true;
 			} catch {
-				entry.plugins = rowFor(m).plugins;
+				fromSnapshot = false;
 			}
-		} else {
-			entry.plugins = rowFor(m).plugins;
+		}
+		if (!fromSnapshot) {
+			const row = rowFor(m);
+			entry.plugins = row.plugins;
+			if (row.company) entry.company = row.company;
 		}
 		out.push(entry);
 	}

package/src/services/market-publish.ts

@@ -87,12 +87,21 @@ export async function readSourceSets(
 	folder: string,
 	destRepo: string,
 	destDir: string,
+	/**
+	 * A top-level folder whose own dot-name does not exclude it: a plugin's
+	 * `.claude-plugin`. What lies inside it is judged by the usual rules.
+	 */
+	keepDotDir?: string,
 ): Promise<SourceSets> {
 	const items = inventory(folder);
 	const notPublished: SourceSets["notPublished"] = [];
 	const candidates: string[] = [];
 	for (const item of items) {
-		const shape = excludedByShape(item.path, item.symlink);
+		const judged =
+			keepDotDir && item.path.startsWith(`${keepDotDir}/`)
+				? item.path.slice(keepDotDir.length + 1)
+				: item.path;
+		const shape = excludedByShape(judged, item.symlink);
 		if (shape) notPublished.push({ path: item.path, reason: shape });
 		else candidates.push(item.path);
 	}

package/src/services/market-types.ts

@@ -60,10 +60,29 @@ export type InstallScope = "user" | "project" | "local";
 export interface MarketplaceRow {
 	name: string;
 	repo: string;
+	/**
+	 * The company it belongs to: the manifest's `owner.name`, else the GitHub
+	 * owner of its source. Absent when neither names one.
+	 */
+	company?: string;
 	scope: "user";
 	plugins: Array<{ name: string; version: string; skills: string[] }>;
 }
 
+/**
+ * A skill or plugin folder on this machine that is not part of any company
+ * marketplace: one of this project's or your USER skills, or a plugin folder
+ * among them (one holding `.claude-plugin/plugin.json`).
+ */
+export interface LocalItem {
+	kind: "skill" | "plugin";
+	/** The folder's name; for a plugin, its `plugin.json` name when it has one. */
+	name: string;
+	scope: "project" | "user";
+	/** The folder, absolute. */
+	path: string;
+}
+
 export interface SkillStatusRow {
 	skill: string;
 	from: "project" | "user";
@@ -128,7 +147,11 @@ export interface MarketResult {
 	installs?: InstallRow[];
 	otherProjects?: number;
 	localCopy?: LocalCopy;
+	/** A plugin-wide publish settles one local copy per published skill. */
+	localCopies?: LocalCopy[];
 	marketplaces?: MarketplaceRow[];
+	/** `market list`: skills and plugins on this machine that no marketplace holds. */
+	local?: LocalItem[];
 	skills?: SkillStatusRow[];
 	plan?: string[];
 	steps: StepRecord[];

package/src/tui-runtime.tsx

@@ -1,8 +1,8 @@
 /**
  * What every magus TUI shares before its first screen: the renderer, the one
  * shutdown owner, Ctrl+C, the OSC 52 copy of a mouse selection, and the light
- * or dark theme. `tui.tsx` (bare `magus`) and `market-tui.tsx` (bare
- * `magus market`) each hand `mountTui` the React tree they draw.
+ * or dark theme. `tui.tsx` (bare `magus`) and `market-tui.tsx` (`magus
+ * edit`) each hand `mountTui` the React tree they draw.
  *
  * Like those two, this module is only ever imported dynamically from
  * `main.tsx`, so nothing on a non-interactive path loads `@opentui/*`.

package/src/types/index.ts

@@ -55,6 +55,8 @@ export interface Marketplace {
 	 * marker and this machine trusts it. Listed above every other marketplace.
 	 */
 	company?: boolean;
+	/** `owner.name` from the marketplace's own manifest, when it names one. */
+	ownerName?: string;
 }
 
 export interface DiscoveredMarketplace {

package/src/ui/adapters/marketAdapter.ts

@@ -11,30 +11,146 @@ import type {
 } from "../../services/market-ops.js";
 import type {
 	InstallScope,
+	LocalItem,
 	MarketResult,
 	SkillStatusRow,
 } from "../../services/market-types.js";
 import type { FailureReport, FailureRow } from "../state/types.js";
+import { displayWidth, truncate } from "../text-width.js";
 import type { theme } from "../theme.js";
 
 // ─── Screen 1 ────────────────────────────────────────────────────────────────
 
 export type MarketplacesItem =
-	| { kind: "marketplace"; entry: MarketOverviewEntry }
+	| {
+			kind: "marketplace";
+			entry: MarketOverviewEntry;
+			/** Its plugins with skills edited here, ready to push. */
+			toPush: readonly string[];
+	  }
 	| { kind: "create" }
-	| { kind: "connect" };
+	| { kind: "connect" }
+	/** The heading over the local rows; never selected. */
+	| { kind: "local-heading"; count: number }
+	| { kind: "local"; item: LocalItem };
 
-/** The marketplaces, then the two rows that add one. */
+/**
+ * The marketplaces, the two rows that add one, then — when there are any —
+ * the skills and plugin folders here that no marketplace holds yet.
+ */
 export function marketplacesItems(
 	entries: readonly MarketOverviewEntry[],
+	status: readonly SkillStatusRow[] = [],
+	local: readonly LocalItem[] = [],
 ): MarketplacesItem[] {
 	return [
-		...entries.map((entry) => ({ kind: "marketplace" as const, entry })),
+		...entries.map((entry) => ({
+			kind: "marketplace" as const,
+			entry,
+			toPush: pluginsToPush(entry.name, status),
+		})),
 		{ kind: "create" },
 		{ kind: "connect" },
+		...(local.length > 0
+			? [
+					{ kind: "local-heading" as const, count: local.length },
+					...local.map((item) => ({ kind: "local" as const, item })),
+				]
+			: []),
 	];
 }
 
+/** Whether a row can hold the selection: every row but a heading. */
+export function selectable(item: MarketplacesItem | undefined): boolean {
+	return item !== undefined && item.kind !== "local-heading";
+}
+
+/**
+ * The next selectable index from `from` in direction `step` (±1), or `from`
+ * when there is none that way.
+ */
+export function nextSelectable(
+	items: readonly MarketplacesItem[],
+	from: number,
+	step: number,
+): number {
+	for (let i = from + step; i >= 0 && i < items.length; i += step) {
+		if (selectable(items[i])) return i;
+	}
+	return from;
+}
+
+/** The skill rows `edited` here, by the plugin `ref` that owns them. */
+export function editedSkills(
+	status: readonly SkillStatusRow[],
+	ref: string,
+): string[] {
+	return [
+		...new Set(
+			status
+				.filter((r) => r.state === "edited" && r.owner === ref)
+				.map((r) => r.skill),
+		),
+	].sort();
+}
+
+/** The plugins of `marketplace` with at least one skill edited here. */
+export function pluginsToPush(
+	marketplace: string,
+	status: readonly SkillStatusRow[],
+): string[] {
+	const suffix = `@${marketplace}`;
+	return [
+		...new Set(
+			status
+				.filter(
+					(r) => r.state === "edited" && r.owner?.endsWith(suffix) === true,
+				)
+				.map((r) => (r.owner as string).slice(0, -suffix.length)),
+		),
+	].sort();
+}
+
+/** What a local row is, in the user's words. */
+export function localKindWords(item: LocalItem): string {
+	return item.kind === "plugin" ? "plugin" : "skill";
+}
+
+/** The narrowest a cut secondary text is still worth showing. */
+const MIN_CUT = 4;
+
+/**
+ * Fit one list row into `width` columns without wrapping. The name and the
+ * parts of `fixed` columns (a scope badge, the gaps around it) always show:
+ * the name is cut with "…" to leave them room. The secondary texts follow in
+ * order while each fits whole after a gap of `gap`; the first that does not
+ * is cut to what is left (when that is at least a few columns), and the rest
+ * are dropped.
+ */
+export function fitRow<T extends { text: string }>(
+	width: number,
+	name: string,
+	fixed: number,
+	secondary: readonly T[],
+	gap = 2,
+): { name: string; secondary: T[] } {
+	const nameOut = truncate(name, Math.max(1, width - fixed));
+	let used = displayWidth(nameOut) + fixed;
+	const out: T[] = [];
+	for (const part of secondary) {
+		const need = gap + displayWidth(part.text);
+		if (used + need <= width) {
+			out.push(part);
+			used += need;
+			continue;
+		}
+		const room = width - used - gap;
+		if (room >= MIN_CUT) out.push({ ...part, text: truncate(part.text, room) });
+		break;
+	}
+	return { name: nameOut, secondary: out };
+}
+
 /** "1 plugin", "3 plugins". */
 export function plural(n: number, word: string): string {
 	return `${n} ${word}${n === 1 ? "" : "s"}`;
@@ -73,6 +189,8 @@ export type MarketplaceItem =
 			skills: readonly string[];
 			installs: ScopeVersions;
 			expanded: boolean;
+			/** Its skills edited here, which `p` pushes as one new version. */
+			edited: readonly string[];
 	  }
 	| {
 			kind: "skill";
@@ -119,6 +237,7 @@ export function marketplaceItems(
 			skills: p.skills,
 			installs: installs[ref] ?? NO_INSTALLS,
 			expanded: open,
+			edited: editedSkills(status, ref),
 		});
 		if (!open) continue;
 		for (const skill of p.skills) {

package/src/ui/adapters/pluginsAdapter.ts

@@ -15,6 +15,7 @@ import type {
 	FailureRow,
 	PluginContentsEntry,
 } from "../state/types.js";
+import { truncate } from "../text-width.js";
 import type { BadgeTone } from "../theme.js";
 import {
 	failureReport,
@@ -215,6 +216,12 @@ function pushPluginItems(
 	}
 }
 
+/**
+ * The widest company name a group header shows. The header keeps its badge
+ * whole and clips the title instead, so a long name is clipped here first.
+ */
+const COMPANY_BADGE_COLUMNS = 24;
+
 /**
  * Derives tone and badge for a category item based on marketplace identity.
  */
@@ -244,7 +251,13 @@ function categoryStyling(
 	// MadAppGang, and being this machine's company marketplace is the stronger
 	// fact.
 	if (mp.company) {
-		return { tone: "info", badge: "◆ Company" };
+		const company = companyName(mp);
+		return {
+			tone: "info",
+			badge: company
+				? `by ${truncate(company, COMPANY_BADGE_COLUMNS)}`
+				: "◆ Company",
+		};
 	}
 	if (isMadAppGang(mp)) {
 		return { tone: "byline", badge: "by MadAppGang" };
@@ -262,6 +275,17 @@ function isMadAppGang(mp: Marketplace): boolean {
 	return (mp.source.repo ?? "").toLowerCase().startsWith("madappgang/");
 }
 
+/**
+ * The name a company marketplace is shown by: the manifest's `owner.name`,
+ * else the GitHub owner of its repository.
+ */
+export function companyName(mp: Marketplace): string | undefined {
+	if (mp.ownerName) return mp.ownerName;
+	const repo = mp.source.repo ?? "";
+	const slash = repo.indexOf("/");
+	return slash > 0 ? repo.slice(0, slash) : undefined;
+}
+
 // ─── "It failed, and here is why" ────────────────────────────────────────────
 
 /** A version token — `v2.0.3`, `8.1.3`, `1.0.0-beta.2`. */

package/src/ui/components/primitives/ListCategoryRow.tsx

@@ -1,4 +1,5 @@
 import React from "react";
+import { displayWidth, truncate } from "../../text-width.js";
 import { type BadgeTone, theme } from "../../theme.js";
 import { SelectableRow, rowLead } from "./SelectableRow.js";
 
@@ -17,6 +18,12 @@ interface ListCategoryRowProps {
 	 * that is broken rather than as a section title.
 	 */
 	expandable?: boolean;
+	/**
+	 * Columns the row may use. When given, the title and count are cut with
+	 * "…" to fit one line (the badge goes first), so a narrow panel never
+	 * wraps the heading onto a second row.
+	 */
+	width?: number;
 }
 
 export function ListCategoryRow({
@@ -27,10 +34,21 @@ export function ListCategoryRow({
 	tone = "neutral",
 	selected,
 	expandable = true,
+	width,
 }: ListCategoryRowProps) {
 	const colors = theme.badge[tone];
 	const marker = expandable ? (expanded ? "▼ " : "▶ ") : "";
-	const label = `${marker}${title}${count !== undefined ? ` (${count})` : ""}`;
+	const full = `${marker}${title}${count !== undefined ? ` (${count})` : ""}`;
+	// The lead cell and the trailing space inside the chip take two columns.
+	const label =
+		width === undefined ? full : truncate(full, Math.max(1, width - 2));
+	const shownBadge =
+		width === undefined ||
+		(badge !== undefined &&
+			label === full &&
+			displayWidth(full) + 3 + displayWidth(badge) <= width)
+			? badge
+			: undefined;
 
 	// Both forms start with the row's lead cell — a blank inside the chip, the
 	// selection mark on the cursor — so the title never moves as it is selected.
@@ -50,7 +68,9 @@ export function ListCategoryRow({
 					{label}{" "}
 				</strong>
 			)}
-			{!selected && badge ? <span fg={colors.badgeFg}> {badge}</span> : null}
+			{!selected && shownBadge ? (
+				<span fg={colors.badgeFg}> {shownBadge}</span>
+			) : null}
 		</SelectableRow>
 	);
 }