one-code-extension 0.1.4 → 0.3.1

package/extensions/plugins/index.ts

@@ -1,41 +1,89 @@
 /**
  * plugins extension — Claude Code plugin support.
  *
- * Reads `~/.claude/plugins/installed_plugins.json`, then publishes each
- * plugin's resources so the other extensions can use them:
+ * Two jobs:
  *
- *   agents/      → the subagent tool, as `<plugin>:<agent>`
- *   skills/      → the skill tool, as `<plugin>:<skill>`
- *   commands/    → slash commands, as `/<plugin>:<command>`
- *   .mcp.json    → the MCP client
+ *  1. Wire installed plugins' slash commands in (agents/skills/MCP/LSP/hooks
+ *     are consumed by their own extensions via discoverPlugins — module state
+ *     is not shared between extension files, so each re-derives).
+ *  2. The /plugins panel: a bounded tabbed manager (Discover / Installed /
+ *     Marketplaces / Errors) that docks below the transcript like Claude Code's
+ *     (see PANEL_MAX_HEIGHT), over the marketplace backend in ./marketplace and
+ *     ./install. All layout/key logic is pure in ./panel; this file owns
+ *     mutable state, async marketplace/install work, and repaints.
  *
- * Everything is namespaced the way Claude Code namespaces it, so two plugins can
- * both ship a `commit` command. This extension only owns the slash commands and
- * the `/plugins` listing; the other consumers call `discoverPlugins()` for
- * themselves, because module state is not shared between extension files.
+ * Every write goes to the One Code plugin root (lib/plugin-root.ts) —
+ * ~/.claude is read-only here, always.
  */
 
 import { execFile } from "node:child_process";
-import { readFileSync } from "node:fs";
-import os from "node:os";
+import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { discoverPlugins, type Plugin } from "../lib/plugins.ts";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { readFavorites, toggleFavorite } from "../lib/favorites.ts";
+import { MCP_STATUS_CHANNEL, MCP_STATUS_REQUEST_CHANNEL, type McpStatusEvent } from "../lib/mcp-status.ts";
+import { persistIfLarge, sessionResultsDir } from "../lib/persisted-output.ts";
+import { setOverride } from "../lib/plugin-overrides.ts";
+import { pathWithinBase, pluginRoot } from "../lib/plugin-root.ts";
+import {
+	defaultDiscoverRoots,
+	type DiscoveredPlugins,
+	discoverPlugins,
+	findPluginSkills,
+	invalidatePluginsCache,
+	type Plugin,
+	pluginResources,
+} from "../lib/plugins.ts";
+import { estimateSkillTokens } from "../lib/skill-scan.ts";
+import { readSkillStates, setSkillOverride } from "../lib/skill-overrides.ts";
+import { boundedDockHeight, safeThemeBold, safeThemeInverse, safeThemePaint, truncateLine } from "../lib/tui-render.ts";
+import { readUsage, recordUsage } from "../lib/usage-tracker.ts";
+import { fetchInstallCounts, readCachedCounts } from "./counts.ts";
+import { installPlugin, uninstallPlugin } from "./install/install.ts";
+import { setInstalledEnabled } from "./install/registry.ts";
+import {
+	ensureOfficialRegistered,
+	isStale,
+	OFFICIAL_MARKETPLACE_NAME,
+	OFFICIAL_MARKETPLACE_SOURCE,
+} from "./marketplace/official.ts";
+import { parseMarketplaceInput } from "./marketplace/parse.ts";
+import {
+	availableMarketplaceName,
+	readKnownMarketplaces,
+	removeKnownMarketplace,
+	writeKnownMarketplace,
+} from "./marketplace/registry.ts";
+import { installLocationFor, marketplaceCacheDir, type MarketplaceSnapshot, syncMarketplace } from "./marketplace/sync.ts";
+import type { KnownMarketplace } from "./marketplace/types.ts";
+import { decodePanelKey } from "./panel/keys.ts";
+import { type DiscoverDetail, renderPanel, type PanelPaint } from "./panel/render.ts";
+import { buildDiscoverRows, buildInstalledRows, buildMarketplaceRows, type DiscoverRow } from "./panel/rows.ts";
+import { applyPanelKey, initialPanelState, type PanelEffect, type PanelView } from "./panel/state.ts";
 import { findShellPlaceholders, replaceShellPlaceholders, substituteArguments } from "./template.ts";
+import { parseFrontmatterLoosely } from "../lib/frontmatter.ts";
+import { sessionAlive } from "../lib/session-lifecycle.ts";
 
 const run = promisify(execFile);
 const SHELL_TIMEOUT_MS = 30_000;
 
-async function expandTemplate(body: string, args: string, cwd: string): Promise<string> {
+// The panel is a bounded dock like Claude Code's /plugins, NOT a full-screen
+// takeover: it swaps the editor container and leaves the transcript visible
+// above it. Cap the height so the conversation stays on screen; smaller
+// terminals still shrink to fit. ~6 discover rows show at this cap.
+const PANEL_MAX_HEIGHT = 22;
+
+async function expandTemplate(body: string, args: string, cwd: string, persist?: { dir: string; name: string }): Promise<string> {
 	const withArgs = substituteArguments(body, args);
 	const commands = [...new Set(findShellPlaceholders(withArgs))];
 	if (commands.length === 0) return withArgs;
 
 	const outputs = new Map<string, string>();
 	await Promise.all(
-		commands.map(async (command) => {
+		commands.map(async (command, index) => {
+			let text: string;
 			try {
 				const { stdout, stderr } = await run(command, {
 					cwd,
@@ -43,40 +91,455 @@ async function expandTemplate(body: string, args: string, cwd: string): Promise<
 					timeout: SHELL_TIMEOUT_MS,
 					maxBuffer: 2 * 1024 * 1024,
 				});
-				outputs.set(command, (stdout || stderr || "").trim());
+				text = (stdout || stderr || "").trim();
 			} catch (error) {
 				const detail = error as { stdout?: string; stderr?: string; message?: string };
-				outputs.set(command, (detail.stdout || detail.stderr || detail.message || "command failed").trim());
+				text = (detail.stdout || detail.stderr || detail.message || "command failed").trim();
 			}
+			// A `!`command's output (a `git diff` of a large change) lands in the
+			// user turn bounded only by maxBuffer — persist it past the cap so the
+			// model gets a preview plus the path, never a wall of text (review L3).
+			outputs.set(command, persist ? persistIfLarge(text, { dir: persist.dir, id: `plugin-cmd-${persist.name}-${index}` }) : text);
 		}),
 	);
 	return replaceShellPlaceholders(withArgs, outputs);
 }
 
-export default function pluginsExtension(pi: ExtensionAPI) {
-	const claudeDir = join(os.homedir(), ".claude");
-	const discovered = discoverPlugins(claudeDir);
+/** An empty discovery result — the fallback when a scan throws. */
+function emptyDiscovered(): DiscoveredPlugins {
+	return {
+		plugins: [],
+		enabledPlugins: [],
+		agentDirs: [],
+		skills: [],
+		commands: [],
+		mcpConfigs: [],
+		mcpConfigPlugins: new Map(),
+		byPlugin: new Map(),
+	};
+}
 
-	for (const command of discovered.commands) {
-		const plugin = discovered.plugins.find((p) => p.name === command.plugin);
-		if (plugin) registerPluginCommand(pi, plugin, command.name, command.path);
+/**
+ * discoverPlugins can throw on a malformed installed plugin (a bad manifest, an
+ * unreadable file). This extension is the one that runs discovery at LOAD time,
+ * where a throw becomes "Failed to load extension" and aborts pi entirely — so
+ * it degrades to "no plugins" instead of taking the whole session down (review H2).
+ */
+function safeDiscover(roots: ReturnType<typeof defaultDiscoverRoots>): DiscoveredPlugins {
+	try {
+		return discoverPlugins(roots);
+	} catch (error) {
+		console.error(`One Code: plugin discovery failed, continuing without plugins: ${(error as Error).message}`);
+		return emptyDiscovered();
 	}
+}
+
+export default function pluginsExtension(pi: ExtensionAPI) {
+	// False once the session is replaced: a panel action still awaiting then
+	// throws on its first pi.* call, which is expected and not an error to show.
+	const alive = sessionAlive(pi);
+	const registeredCommands = new Set<string>();
+	// Load-time discovery has no ctx, so it runs on process.cwd(); session_start
+	// below re-discovers on the session's real cwd (they differ under `pi -C`
+	// and in RPC children) so project-scoped plugin settings are the right ones.
+	let discovered = safeDiscover(defaultDiscoverRoots(getAgentDir()));
+
+	const registerCommands = (plugins: DiscoveredPlugins) => {
+		for (const command of plugins.commands) {
+			if (registeredCommands.has(command.name)) continue;
+			// Two marketplaces may ship a plugin of the same name (they are keyed by
+			// `<name>@<marketplace>`); the command belongs to the ENABLED one.
+			const plugin =
+				plugins.plugins.find((p) => p.name === command.plugin && p.enabled) ??
+				plugins.plugins.find((p) => p.name === command.plugin);
+			if (!plugin) continue;
+			registeredCommands.add(command.name);
+			registerPluginCommand(pi, plugin, command.name, command.path);
+		}
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		if (ctx.cwd === process.cwd()) return;
+		invalidatePluginsCache();
+		discovered = safeDiscover(defaultDiscoverRoots(getAgentDir(), ctx.cwd));
+		registerCommands(discovered);
+	});
+	registerCommands(discovered);
+
+	// Latest MCP snapshot; the panel triggers a request on open (the bus does
+	// not replay, and this extension can't read the mcp extension's state).
+	let mcpStatus: McpStatusEvent | undefined;
+	let repaintPanel: (() => void) | undefined;
+	pi.events.on(MCP_STATUS_CHANNEL, (event) => {
+		mcpStatus = event as McpStatusEvent;
+		repaintPanel?.();
+	});
+
+	let panelOpen = false;
+
+	const openPanel = async (ctx: ExtensionContext): Promise<void> => {
+		if (panelOpen) return;
+		panelOpen = true;
+		let restartNotice = false;
+		try {
+			await ctx.ui.custom<null>((tui, theme, _keybindings, done) => {
+				const paint: PanelPaint = {
+					fg: safeThemePaint(theme),
+					bold: safeThemeBold(theme),
+					inverse: safeThemeInverse(theme),
+				};
+				const roots = defaultDiscoverRoots(getAgentDir(), ctx.cwd);
+				const oneCodeRoot = roots.oneCodeRoot;
+
+				const state = initialPanelState();
+				const snapshots = new Map<string, MarketplaceSnapshot>();
+				const loading = new Set<string>();
+				const actionErrors: string[] = [];
+				const busy = new Set<string>();
+				let counts = readCachedCounts(oneCodeRoot);
+				let known: Record<string, KnownMarketplace> = {};
+
+				// Two caches: rendered lines (per width, cleared on ANY repaint) and
+				// the view model (fs scans — cleared only when data actually changed,
+				// so a cursor move or ticker tick never re-reads the disk).
+				let cache: { width: number; lines: string[] } | undefined;
+				let viewCache: PanelView | undefined;
+				const repaint = () => {
+					cache = undefined;
+					tui.requestRender();
+				};
+				/** Data changed (effect ran, async work landed, search edited). */
+				const refresh = () => {
+					viewCache = undefined;
+					repaint();
+				};
+				repaintPanel = refresh;
+				// The ticker only animates in-flight async work; every real state
+				// change repaints explicitly.
+				const ticker = setInterval(() => {
+					if (loading.size > 0 || busy.size > 0) repaint();
+				}, 500);
+				ticker.unref?.();
+
+				const rediscover = () => {
+					invalidatePluginsCache();
+					discovered = discoverPlugins(roots);
+					registerCommands(discovered);
+					viewCache = undefined;
+				};
+
+				const track = async <T>(label: string, work: Promise<T>): Promise<T | undefined> => {
+					loading.add(label);
+					repaint();
+					try {
+						return await work;
+					} catch (error) {
+						actionErrors.push(`${label} failed: ${(error as Error).message}`);
+						return undefined;
+					} finally {
+						loading.delete(label);
+						refresh();
+					}
+				};
+
+				const syncOne = async (name: string, entry: KnownMarketplace, refreshContent: boolean) => {
+					const snapshot = await track(
+						`${refreshContent ? "updating" : "loading"} ${name}…`,
+						syncMarketplace(oneCodeRoot, name, entry, { refresh: refreshContent }),
+					);
+					if (snapshot) {
+						snapshots.set(name, snapshot);
+						known = { ...known, [name]: snapshot.known };
+					}
+				};
+
+				// Lazy startup work — on open only, never at session start: register
+				// the official marketplace, sync every known one (refresh official
+				// when stale), fetch install counts, ask mcp for a status snapshot.
+				const openTasks = async () => {
+					ensureOfficialRegistered(
+						oneCodeRoot,
+						installLocationFor(oneCodeRoot, OFFICIAL_MARKETPLACE_NAME, OFFICIAL_MARKETPLACE_SOURCE),
+					);
+					known = readKnownMarketplaces(oneCodeRoot);
+					// The counts fetch is independent of the marketplace syncs.
+					await Promise.all([
+						...Object.entries(known).map(([name, entry]) =>
+							syncOne(name, entry, name === OFFICIAL_MARKETPLACE_NAME && isStale(entry)),
+						),
+						track("fetching install counts…", fetchInstallCounts(oneCodeRoot)).then((fetched) => {
+							if (fetched) counts = fetched;
+						}),
+					]);
+				};
+				// void'ed panel work: a late throw (a pi.* call on a replaced session)
+				// must never surface as an unhandled rejection (LIFECYCLE-REVIEW L2);
+				// any other failure is shown in the panel's error list.
+				const guarded = (work: Promise<unknown>) =>
+					work.catch((error) => {
+						if (!alive()) return;
+						actionErrors.push((error as Error).message);
+						state.notice = (error as Error).message;
+						refresh();
+					});
+				void guarded(openTasks());
+				pi.events.emit(MCP_STATUS_REQUEST_CHANNEL, {});
+
+				const buildView = (): PanelView => {
+					const installedIds = new Set(discovered.plugins.map((p) => p.id));
+					const usage = readUsage(oneCodeRoot);
+					const favorites = readFavorites(oneCodeRoot);
+					const skillOverrides = readSkillStates(oneCodeRoot);
+					// /plugins manages plugin skills only; project/user skills (with their
+					// on/name-only/user-only/off nuance) belong to the /skills panel. Build
+					// the rows straight from the discovered plugin skills — no project/user
+					// dir scan whose results would only be filtered back out.
+					const skills = discovered.enabledPlugins
+						.flatMap((plugin) => {
+							const dir = pluginResources(plugin).skillsDir;
+							return dir ? findPluginSkills(plugin, dir) : [];
+						})
+						.map((skill) => ({
+							name: skill.name,
+							path: skill.path,
+							scope: "plugin" as const,
+							tokens: estimateSkillTokens(skill.path),
+						}));
+					return {
+						discover: buildDiscoverRows({
+							snapshots: [...snapshots.values()],
+							installedIds,
+							counts,
+							busy,
+							search: state.search.discover,
+						}),
+						installed: buildInstalledRows({
+							plugins: discovered.plugins,
+							mcpServers: mcpStatus?.servers,
+							skills,
+							usage,
+							skillOverrides,
+							favorites,
+							busy,
+							search: state.search.installed,
+						}),
+						marketplaces: buildMarketplaceRows({ known, snapshots, installedIds }),
+						errors: [...[...snapshots.values()].flatMap((s) => s.errors), ...actionErrors],
+					};
+				};
+
+				const currentView = (): PanelView => (viewCache ??= buildView());
+
+				const discoverDetails = (): Map<string, DiscoverDetail> => {
+					const details = new Map<string, DiscoverDetail>();
+					for (const snapshot of snapshots.values()) {
+						if (!snapshot.manifest) continue;
+						for (const entry of snapshot.manifest.plugins) {
+							const contributions: string[] = [];
+							const provides: Array<[string, string]> = [
+								["commands", "commands"],
+								["agents", "agents"],
+								["skills", "skills"],
+								["mcpServers", "MCP servers"],
+								["lspServers", "LSP servers"],
+								["hooks", "hooks"],
+							];
+							for (const [key, label] of provides) if (entry.raw[key] !== undefined) contributions.push(label);
+							if (typeof entry.source === "string") contributions.push(`files: ${entry.source}`);
+							details.set(`${entry.name}@${snapshot.name}`, {
+								version: entry.version,
+								author: entry.author?.name,
+								category: entry.category,
+								contributions,
+							});
+						}
+					}
+					return details;
+				};
+
+				const close = () => {
+					clearInterval(ticker);
+					repaintPanel = undefined;
+					restartNotice = state.restartNeeded;
+					done(null);
+				};
+
+				const installToggle = async (row: DiscoverRow) => {
+					const plugin = discovered.plugins.find((p) => p.id === row.id);
+					if (row.installed && plugin?.originRoot === "claude") {
+						state.notice = `${row.name} was installed by Claude Code — uninstall it there (files are read-only here).`;
+						return;
+					}
+					busy.add(row.id);
+					refresh();
+					try {
+						if (row.installed) {
+							uninstallPlugin(oneCodeRoot, row.id);
+						} else {
+							const snapshot = snapshots.get(row.marketplace);
+							const entry = snapshot?.manifest?.plugins.find((p) => p.name === row.name);
+							if (!snapshot || !entry) throw new Error(`${row.marketplace} has no entry named ${row.name}`);
+							await installPlugin(oneCodeRoot, row.marketplace, entry, snapshot.contentRoot);
+						}
+						state.restartNeeded = true;
+						rediscover();
+					} catch (error) {
+						actionErrors.push((error as Error).message);
+						state.notice = (error as Error).message;
+					} finally {
+						busy.delete(row.id);
+						refresh();
+					}
+				};
+
+				const runEffect = (effect: PanelEffect) => {
+					switch (effect.kind) {
+						case "close":
+							return close();
+						case "installToggle":
+							void guarded(installToggle(effect.row));
+							return;
+						case "setPluginEnabled": {
+							if (effect.origin === "one-code") setInstalledEnabled(oneCodeRoot, effect.id, effect.enabled);
+							else setOverride(oneCodeRoot, effect.id, effect.enabled);
+							state.restartNeeded = true;
+							rediscover();
+							return;
+						}
+						case "uninstall": {
+							uninstallPlugin(oneCodeRoot, effect.id);
+							state.detail = undefined;
+							state.restartNeeded = true;
+							rediscover();
+							return;
+						}
+						case "setSkillEnabled":
+							setSkillOverride(oneCodeRoot, effect.overrideKey, effect.enabled);
+							rediscover();
+							return;
+						case "toggleFavorite":
+							toggleFavorite(oneCodeRoot, effect.target === "plugin" ? "plugin" : "skill", effect.key);
+							return;
+						case "addMarketplace": {
+							const parsed = parseMarketplaceInput(effect.input, ctx.cwd);
+							if ("error" in parsed) {
+								state.notice = parsed.error;
+								return;
+							}
+							const name = availableMarketplaceName(oneCodeRoot, parsed.suggestedName);
+							const entry: KnownMarketplace = {
+								source: parsed.source,
+								installLocation: installLocationFor(oneCodeRoot, name, parsed.source),
+								lastUpdated: new Date(0).toISOString(),
+							};
+							writeKnownMarketplace(oneCodeRoot, name, entry);
+							known = { ...known, [name]: entry };
+							void guarded(syncOne(name, entry, false));
+							state.tab = "marketplaces";
+							return;
+						}
+						case "removeMarketplace": {
+							if (effect.name === OFFICIAL_MARKETPLACE_NAME) {
+								state.notice = "The official marketplace re-registers on next open; remove individual plugins instead.";
+							}
+							removeKnownMarketplace(oneCodeRoot, effect.name);
+							snapshots.delete(effect.name);
+							// Cached content lives under OUR marketplaces dir only — a
+							// file/directory source's user-owned path is never touched, and
+							// a name that would escape the cache dir deletes nothing.
+							const cacheBase = marketplaceCacheDir(oneCodeRoot);
+							if (pathWithinBase(cacheBase, effect.name)) {
+								rmSync(join(cacheBase, effect.name), { recursive: true, force: true });
+								rmSync(join(cacheBase, `${effect.name}.json`), { force: true });
+							}
+							const { [effect.name]: _removed, ...rest } = known;
+							known = rest;
+							return;
+						}
+						case "refreshMarketplace": {
+							const entry = known[effect.name];
+							if (entry) void guarded(syncOne(effect.name, entry, true));
+							return;
+						}
+					}
+				};
+
+				return {
+					render: (width: number) => {
+						if (cache?.width === width) return cache.lines;
+						const rows = (tui as { terminal: { rows: number } }).terminal.rows;
+						const height = boundedDockHeight(rows, PANEL_MAX_HEIGHT);
+						const lines = renderPanel(
+							{
+								state,
+								view: currentView(),
+								width,
+								height,
+								loading: [...loading],
+								discoverDetails: discoverDetails(),
+								restartNeeded: state.restartNeeded,
+							},
+							paint,
+						).map((line) => truncateLine(line, width));
+						cache = { width, lines };
+						return lines;
+					},
+					handleInput: (data: string) => {
+						const key = decodePanelKey(data);
+						if (!key) return;
+						const effect = applyPanelKey(state, key, currentView());
+						// Search edits change which rows exist; effects change the data
+						// underneath. Pure navigation keeps the cached view.
+						if (effect || key.kind === "text" || key.kind === "backspace" || key.kind === "back") {
+							viewCache = undefined;
+						}
+						if (effect) runEffect(effect);
+						repaint();
+					},
+					invalidate: () => {
+						cache = undefined;
+					},
+					// Covers dismissal paths that aren't esc (session end, another
+					// overlay) — without this the ticker outlives the component.
+					dispose: () => {
+						clearInterval(ticker);
+						repaintPanel = undefined;
+					},
+				};
+			});
+		} finally {
+			panelOpen = false;
+		}
+		if (restartNotice && ctx.hasUI) {
+			ctx.ui.notify(
+				"Plugin changes saved. Commands and the /plugins list update immediately; MCP servers, agents, and hooks apply on the next session restart.",
+				"info",
+			);
+		}
+	};
 
 	pi.registerCommand("plugins", {
-		description: "List installed Claude Code plugins and what they contribute",
+		description: "Browse, install, and manage Claude Code-compatible plugins and marketplaces",
 		handler: async (_args, ctx) => {
+			if (ctx.hasUI) {
+				await openPanel(ctx);
+				return;
+			}
+			// Non-interactive fallback: the old text listing.
 			if (discovered.plugins.length === 0) {
-				ctx.ui.notify("No Claude Code plugins installed (~/.claude/plugins/installed_plugins.json).", "info");
+				ctx.ui.notify("No plugins installed.", "info");
 				return;
 			}
 			const lines = discovered.plugins.map((plugin) => {
-				const summary = discovered.byPlugin.get(plugin.name);
+				const summary = discovered.byPlugin.get(plugin.id);
 				const parts: string[] = [];
 				if (summary?.agents) parts.push("agents");
 				if (summary?.skills) parts.push(`${summary.skills} skill${summary.skills === 1 ? "" : "s"}`);
 				if (summary?.commands) parts.push(`${summary.commands} command${summary.commands === 1 ? "" : "s"}`);
 				if (summary?.mcp) parts.push("mcp");
-				return `${plugin.name}${plugin.version && plugin.version !== "unknown" ? ` ${plugin.version}` : ""} — ${parts.join(", ") || "nothing usable"}`;
+				if (summary?.lsp) parts.push("lsp");
+				const state = plugin.enabled ? "" : " (disabled)";
+				return `${plugin.name}${plugin.version && plugin.version !== "unknown" ? ` ${plugin.version}` : ""}${state} — ${parts.join(", ") || "nothing usable"}`;
 			});
 			ctx.ui.notify(lines.join("\n"), "info");
 		},
@@ -87,7 +550,7 @@ function registerPluginCommand(pi: ExtensionAPI, plugin: Plugin, name: string, p
 	let description = `Command from the ${plugin.name} plugin`;
 	let argumentHint: string | undefined;
 	try {
-		const { frontmatter } = parseFrontmatter(readFileSync(path, "utf-8")) as {
+		const { frontmatter } = parseFrontmatterLoosely(readFileSync(path, "utf-8")) as {
 			frontmatter?: Record<string, unknown>;
 		};
 		if (typeof frontmatter?.description === "string") description = frontmatter.description;
@@ -101,13 +564,14 @@ function registerPluginCommand(pi: ExtensionAPI, plugin: Plugin, name: string, p
 		handler: async (args, ctx) => {
 			let body: string;
 			try {
-				const parsed = parseFrontmatter(readFileSync(path, "utf-8")) as { body: string };
+				const parsed = parseFrontmatterLoosely(readFileSync(path, "utf-8")) as { body: string };
 				body = parsed.body;
 			} catch (error) {
 				ctx.ui.notify(`Could not read ${path}: ${(error as Error).message}`, "error");
 				return;
 			}
-			const expanded = await expandTemplate(body, args, ctx.cwd);
+			const expanded = await expandTemplate(body, args, ctx.cwd, { dir: sessionResultsDir(ctx), name });
+			recordUsage(pluginRoot(getAgentDir()), "command", name);
 			// Deliver as a user turn, which is how Claude Code runs a command template.
 			pi.sendUserMessage(expanded);
 		},