@zaganjade/pi-multi-skill 1.0.0 → 1.3.1

package/src/bmad-status.ts

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { bmadAutoHint, resolveBmadAutoSkills } from "./bmad-auto.ts";
+
+const STATUS_COMMANDS = new Set([
+	"/workflow-status",
+	"/status",
+	"/workflow-init",
+	"/init",
+]);
+
+function readText(path: string): string | null {
+	try {
+		return readFileSync(path, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
+function workflowStatus(content: string, key: string): string | null {
+	const patterns = [
+		new RegExp(`${key}:\\s*\\n[\\s\\S]*?status:\\s*([\\w-]+)`, "i"),
+		new RegExp(`${key}:[\\s\\S]*?status:\\s*([\\w\\s-]+)`, "i"),
+	];
+	for (const re of patterns) {
+		const match = content.match(re);
+		if (match) return match[1].trim();
+	}
+	return null;
+}
+
+function projectMeta(cwd: string): {
+	level: number;
+	name: string | null;
+	type: string | null;
+} {
+	const content = readText(join(cwd, "bmad", "config.yaml"));
+	if (!content) return { level: 1, name: null, type: null };
+	const level = content.match(/project_level:\s*(\d)/i);
+	const name = content.match(/project_name:\s*["']?([^"'\n]+)/i);
+	const type = content.match(/project_type:\s*["']?([^"'\n]+)/i);
+	return {
+		level: level ? Number.parseInt(level[1], 10) : 1,
+		name: name?.[1]?.trim() ?? null,
+		type: type?.[1]?.trim() ?? null,
+	};
+}
+
+const WORKFLOW_KEYS = [
+	"product-brief",
+	"brainstorm",
+	"research",
+	"prd",
+	"tech-spec",
+	"architecture",
+	"ux-design",
+	"sprint-planning",
+	"dev-story",
+	"create-story",
+];
+
+export function shouldInjectBmadStatus(options: {
+	embeddedCommand?: string;
+	auto?: boolean;
+}): boolean {
+	if (options.auto) return true;
+	if (!options.embeddedCommand) return false;
+	const cmd = options.embeddedCommand.split(/\s+/)[0] ?? "";
+	return STATUS_COMMANDS.has(cmd);
+}
+
+export function buildBmadStatusBlock(cwd: string): string | null {
+	const statusPath = join(cwd, "docs", "bmm-workflow-status.yaml");
+	const configPath = join(cwd, "bmad", "config.yaml");
+	const statusExists = existsSync(statusPath);
+	const configExists = existsSync(configPath);
+
+	if (!statusExists && !configExists) return null;
+
+	const hint = bmadAutoHint(cwd);
+	const phaseMatch = hint?.match(/phase:\s*(\w+)/);
+	const phase = phaseMatch?.[1] ?? "unknown";
+	const project = projectMeta(cwd);
+	const recommendedSkills = resolveBmadAutoSkills(cwd);
+
+	const lines: string[] = [
+		`<bmad_status phase="${phase}" project_level="${project.level}" status_file="${statusExists ? "docs/bmm-workflow-status.yaml" : "missing"}">`,
+	];
+
+	if (project.name) lines.push(`Project: ${project.name}`);
+	if (project.type) lines.push(`Type: ${project.type}`);
+	lines.push(`Detected phase: ${phase}`);
+	lines.push(`Recommended skills for this phase: ${recommendedSkills.join(", ")}`);
+
+	if (statusExists) {
+		const content = readText(statusPath) ?? "";
+		const incomplete: string[] = [];
+		const complete: string[] = [];
+		for (const key of WORKFLOW_KEYS) {
+			const status = workflowStatus(content, key);
+			if (!status) continue;
+			if (/complete|done|finished/i.test(status)) {
+				complete.push(`${key}: ${status}`);
+			} else {
+				incomplete.push(`${key}: ${status}`);
+			}
+		}
+		if (incomplete.length > 0) {
+			lines.push("", "Incomplete / in-progress workflows:");
+			for (const item of incomplete.slice(0, 8)) lines.push(`  • ${item}`);
+		}
+		if (complete.length > 0) {
+			lines.push("", "Completed workflows:");
+			for (const item of complete.slice(0, 5)) lines.push(`  • ${item}`);
+		}
+	} else {
+		lines.push("", "BMAD not initialized in this project.");
+		lines.push("Run /workflow-init or /skills bmad-master /workflow-init to set up.");
+	}
+
+	lines.push("", "Use this context when executing the embedded BMAD command.");
+	lines.push("</bmad_status>");
+
+	return lines.join("\n");
+}

package/src/build.ts

@@ -0,0 +1,270 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import type { BuildOptions, EnrichedSkillInfo, LoadMode } from "./types.ts";
+import { stripFrontmatter } from "./metadata.ts";
+import { buildParallelDispatchBlock } from "./subagents.ts";
+
+const SUBAGENT_STOP = "<SUBAGENT-STOP>";
+const SKILL_CHECK_MARKERS = [
+	"If you think there is even a 1% chance a skill might apply",
+	"Invoke relevant or requested skills BEFORE any response",
+];
+
+function getAgentDir(): string {
+	return join(homedir(), ".pi", "agent");
+}
+
+function readSkillFile(skill: EnrichedSkillInfo, cwd: string): string | null {
+	try {
+		return readFileSync(skill.filePath, "utf-8");
+	} catch {
+		// fall through
+	}
+
+	const dirs = [join(getAgentDir(), "skills"), join(cwd, ".pi", "skills")];
+	for (const dir of dirs) {
+		for (const candidate of [
+			join(dir, skill.name, "SKILL.md"),
+			join(dir, `${skill.name}.md`),
+		]) {
+			try {
+				return readFileSync(candidate, "utf-8");
+			} catch {
+				// continue
+			}
+		}
+	}
+	return null;
+}
+
+function extractCommandsSection(body: string): string {
+	const match = body.match(
+		/## Available Commands[\s\S]*?(?=\n## |\n# |$)/i,
+	);
+	return match ? match[0].trim() : "";
+}
+
+function formatMetaBlock(skill: EnrichedSkillInfo): string {
+	const commands = skill.metadata.commands.length
+		? `\n\nCommands: ${skill.metadata.commands.join(", ")}`
+		: "";
+	const commandsSection = extractCommandsSection(skill.body);
+	const sectionText = commandsSection ? `\n\n${commandsSection}` : "";
+
+	return `<skill name="${skill.name}" location="${skill.filePath}" mode="meta">
+${skill.metadata.description}${commands}${sectionText}
+</skill>`;
+}
+
+function formatLazyBlock(skill: EnrichedSkillInfo, body: string): string {
+	const baseDir = dirname(skill.filePath);
+	const intro = body
+		.split("\n")
+		.filter((l) => l.trim() && !l.startsWith("#"))
+		.slice(0, 8)
+		.join("\n");
+
+	return `<skill name="${skill.name}" location="${skill.filePath}" mode="lazy">
+References are relative to ${baseDir}. Load reference files with \`read\` only when the active workflow step requires them.
+
+${intro}
+
+${extractCommandsSection(body)}
+</skill>`;
+}
+
+function formatFullBlock(skill: EnrichedSkillInfo, body: string): string {
+	const baseDir = dirname(skill.filePath);
+	return `<skill name="${skill.name}" location="${skill.filePath}" mode="full">
+References are relative to ${baseDir}.
+
+${body}
+</skill>`;
+}
+
+function dedupeBody(name: string, body: string, seen: Set<string>): string {
+	let result = body;
+
+	if (body.includes(SUBAGENT_STOP)) {
+		if (seen.has(SUBAGENT_STOP)) {
+			result = result.replace(
+				new RegExp(`${SUBAGENT_STOP}[\\s\\S]*?${SUBAGENT_STOP}`, "g"),
+				"",
+			);
+		} else {
+			seen.add(SUBAGENT_STOP);
+		}
+	}
+
+	if (name !== "using-superpowers") {
+		for (const marker of SKILL_CHECK_MARKERS) {
+			if (result.includes(marker) && seen.has(marker)) {
+				result = result.replace(
+					new RegExp(`## Instruction Priority[\\s\\S]*?(?=\\n## |$)`, "i"),
+					"",
+				);
+			}
+			if (result.includes(marker)) seen.add(marker);
+		}
+	}
+
+	return result.trim();
+}
+
+function renderSkillBlock(
+	skill: EnrichedSkillInfo,
+	cwd: string,
+	mode: LoadMode,
+	seenDedup: Set<string>,
+): string | null {
+	const effectiveMode = skill.metadata.tokenBudget ?? mode;
+	const raw = readSkillFile(skill, cwd);
+	if (!raw) return null;
+
+	const body = dedupeBody(skill.name, stripFrontmatter(raw).trim(), seenDedup);
+	switch (effectiveMode) {
+		case "meta":
+			return formatMetaBlock(skill);
+		case "lazy":
+			return formatLazyBlock(skill, body);
+		default:
+			return formatFullBlock(skill, body);
+	}
+}
+
+export function buildCombinedMessage(
+	skills: EnrichedSkillInfo[],
+	cwd: string,
+	options: BuildOptions,
+): { message: string; notFound: string[]; skippedDuplicates: string[] } {
+	const expandedBlocks: string[] = [];
+	const notFound: string[] = [];
+	const seenDedup = new Set<string>();
+	const skippedDuplicates: string[] = [];
+
+	for (const skill of skills) {
+		const before = seenDedup.size;
+		const block = renderSkillBlock(skill, cwd, options.mode, seenDedup);
+		if (!block) {
+			notFound.push(skill.name);
+			continue;
+		}
+		if (seenDedup.size > before && before > 0) {
+			skippedDuplicates.push(`${skill.name} (deduplicated sections)`);
+		}
+		expandedBlocks.push(block);
+	}
+
+	const skillNames = skills.map((s) => s.name).join(", ");
+	const bundleAttr =
+		options.bundles && options.bundles.length > 0
+			? ` bundles="${options.bundles.map((b) => `@${b}`).join(",")}"`
+			: "";
+	const parts: string[] = [
+		`<manually_attached_skills count="${skills.length}"${bundleAttr}>`,
+		"The user activated multiple skills. Follow ALL of them before responding.",
+		"Priority: process skills → planning → implementation. User instructions override conflicts.",
+		`Skills: ${skillNames}`,
+		`Load mode: ${options.mode}`,
+	];
+
+	if (options.parallel) {
+		const tasks =
+			options.parallelTasks && options.parallelTasks.length > 0
+				? options.parallelTasks
+				: options.instructions
+					? [options.instructions]
+					: [];
+		parts.push(
+			buildParallelDispatchBlock({
+				tasks,
+				subagentAvailable: options.subagentAvailable ?? false,
+			}),
+		);
+	}
+
+	parts.push("");
+	parts.push(...expandedBlocks);
+
+	if (options.bmadStatusBlock) {
+		parts.push("");
+		parts.push(options.bmadStatusBlock);
+	}
+
+	if (options.embeddedCommand) {
+		parts.push("");
+		parts.push(
+			`<embedded_command>${options.embeddedCommand}</embedded_command>`,
+		);
+		parts.push(
+			"Execute the embedded command workflow as part of fulfilling the user request.",
+		);
+	}
+
+	if (options.instructions) {
+		parts.push("");
+		parts.push("<user_query>");
+		parts.push(options.instructions);
+		parts.push("</user_query>");
+	}
+
+	if (notFound.length > 0) {
+		parts.push("");
+		parts.push(`> ⚠️ Skills not found: ${notFound.join(", ")}`);
+	}
+
+	if (options.conflictWarnings?.length) {
+		parts.push("");
+		parts.push(`> ⚠️ Conflicts: ${options.conflictWarnings.join("; ")}`);
+	}
+
+	if (options.skippedDuplicates?.length) {
+		parts.push("");
+		parts.push(
+			`> ℹ️ Deduplicated: ${options.skippedDuplicates.join(", ")}`,
+		);
+	}
+
+	parts.push("</manually_attached_skills>");
+
+	return {
+		message: parts.join("\n"),
+		notFound,
+		skippedDuplicates,
+	};
+}
+
+export function resolveAndReadLegacySkill(
+	skillName: string,
+	filePath: string,
+	cwd: string,
+): string | null {
+	if (existsSync(filePath)) {
+		try {
+			const content = readFileSync(filePath, "utf-8");
+			const body = stripFrontmatter(content).trim();
+			const baseDir = dirname(filePath);
+			return `<skill name="${skillName}" location="${filePath}">\nReferences are relative to ${baseDir}.\n\n${body}\n</skill>`;
+		} catch {
+			// fall through
+		}
+	}
+
+	const dirs = [join(getAgentDir(), "skills"), join(cwd, ".pi", "skills")];
+	for (const dir of dirs) {
+		for (const candidate of [
+			join(dir, skillName, "SKILL.md"),
+			join(dir, `${skillName}.md`),
+		]) {
+			try {
+				const content = readFileSync(candidate, "utf-8");
+				const body = stripFrontmatter(content).trim();
+				return `<skill name="${skillName}" location="${candidate}">\nReferences are relative to ${dirname(candidate)}.\n\n${body}\n</skill>`;
+			} catch {
+				// continue
+			}
+		}
+	}
+	return null;
+}

package/src/bundle-status.ts

@@ -0,0 +1,178 @@
+import type { SkillBundle, SkillInfo } from "./types.ts";
+
+export interface BundleAvailability {
+	name: string;
+	bundle: SkillBundle;
+	available: string[];
+	missing: string[];
+	coverage: number;
+	ready: boolean;
+}
+
+const SKILL_INSTALL_HINTS: Record<string, string> = {
+	"bmad-master": "BMAD core — clone to ~/.claude/skills/bmad or add to pi settings \"skills\"",
+	analyst: "BMAD analyst — part of ~/.claude/skills/bmad/bmm/",
+	pm: "BMAD pm — part of ~/.claude/skills/bmad/bmm/",
+	architect: "BMAD architect — part of ~/.claude/skills/bmad/bmm/",
+	"ux-designer": "BMAD ux-designer — part of ~/.claude/skills/bmad/bmm/",
+	developer: "BMAD developer — part of ~/.claude/skills/bmad/bmm/",
+	"scrum-master": "BMAD scrum-master — part of ~/.claude/skills/bmad/bmm/",
+	"using-superpowers": "Superpowers — Claude Code plugin cache or ~/.pi/agent/skills",
+	brainstorming: "Superpowers — Claude Code plugin cache or ~/.pi/agent/skills",
+	"writing-plans": "Superpowers — Claude Code plugin cache or ~/.pi/agent/skills",
+	"test-driven-development": "Superpowers — Claude Code plugin cache or ~/.pi/agent/skills",
+	"requesting-code-review": "Superpowers — Claude Code plugin cache or ~/.pi/agent/skills",
+	"systematic-debugging": "Superpowers — Claude Code plugin cache or ~/.pi/agent/skills",
+};
+
+export function assessBundleAvailability(
+	name: string,
+	bundle: SkillBundle,
+	availableSkills: SkillInfo[],
+): BundleAvailability {
+	const availableNames = new Set(availableSkills.map((s) => s.name));
+	const available = bundle.skills.filter((s) => availableNames.has(s));
+	const missing = bundle.skills.filter((s) => !availableNames.has(s));
+	const coverage =
+		bundle.skills.length === 0
+			? 0
+			: Math.round((available.length / bundle.skills.length) * 100);
+
+	return {
+		name,
+		bundle,
+		available,
+		missing,
+		coverage,
+		ready: available.length > 0,
+	};
+}
+
+export function assessAllBundles(
+	bundles: Map<string, SkillBundle>,
+	availableSkills: SkillInfo[],
+): BundleAvailability[] {
+	return [...bundles.entries()]
+		.map(([name, bundle]) => assessBundleAvailability(name, bundle, availableSkills))
+		.sort((a, b) => b.coverage - a.coverage || a.name.localeCompare(b.name));
+}
+
+export function formatBundleCoverage(status: BundleAvailability): string {
+	if (status.coverage === 100) {
+		return `${status.available.length}/${status.bundle.skills.length} ready`;
+	}
+	if (status.coverage === 0) {
+		return `0/${status.bundle.skills.length} — install required`;
+	}
+	return `${status.available.length}/${status.bundle.skills.length} (${status.missing.length} missing)`;
+}
+
+export function formatBundleHelpLine(status: BundleAvailability): string {
+	const coverage = formatBundleCoverage(status);
+	const req = status.bundle.requires ? ` · ${status.bundle.requires}` : "";
+	return `  • @${status.name} — ${status.bundle.description} [${coverage}]${req}`;
+}
+
+export function formatMissingSkillHints(missing: string[]): string {
+	const lines = missing.map((name) => {
+		const hint = SKILL_INSTALL_HINTS[name];
+		return hint ? `  • ${name} — ${hint}` : `  • ${name}`;
+	});
+	return lines.join("\n");
+}
+
+export function formatBundleFailureGuide(
+	bundleNames: string[],
+	bundles: Map<string, SkillBundle>,
+	availableSkills: SkillInfo[],
+): string {
+	const lines: string[] = [
+		"Bundle skills not found on this machine.",
+		"",
+	];
+
+	for (const bundleName of bundleNames) {
+		const bundle = bundles.get(bundleName);
+		if (!bundle) continue;
+		const status = assessBundleAvailability(bundleName, bundle, availableSkills);
+		lines.push(`@${bundleName} — ${status.bundle.description}`);
+		if (status.bundle.install) {
+			lines.push(`  Install: ${status.bundle.install}`);
+		}
+		if (status.missing.length > 0) {
+			lines.push("  Missing skills:");
+			lines.push(formatMissingSkillHints(status.missing));
+		}
+		lines.push("");
+	}
+
+	lines.push(
+		"Options without installing presets:",
+		"  1. /skills skill1,skill2 — chain skills you already have",
+		"  2. Create ~/.pi/agent/skill-bundles.json with your own bundles",
+		"  3. /skills-setup — full install guide",
+	);
+
+	return lines.join("\n");
+}
+
+export function formatSetupReport(
+	bundles: Map<string, SkillBundle>,
+	availableSkills: SkillInfo[],
+): string {
+	const statuses = assessAllBundles(bundles, availableSkills);
+	const ready = statuses.filter((s) => s.coverage === 100);
+	const partial = statuses.filter((s) => s.ready && s.coverage < 100);
+	const unavailable = statuses.filter((s) => !s.ready);
+
+	const lines: string[] = [
+		"pi-multi-skill bundle setup",
+		"",
+		`Skills discovered: ${availableSkills.length}`,
+		`Bundles ready: ${ready.length}/${statuses.length}`,
+		"",
+	];
+
+	if (ready.length > 0) {
+		lines.push("Ready to use:");
+		for (const s of ready) {
+			lines.push(`  @${s.name} — ${formatBundleCoverage(s)}`);
+		}
+		lines.push("");
+	}
+
+	if (partial.length > 0) {
+		lines.push("Partial (loads available skills, warns about missing):");
+		for (const s of partial) {
+			lines.push(`  @${s.name} — ${formatBundleCoverage(s)}`);
+			lines.push(`    missing: ${s.missing.join(", ")}`);
+		}
+		lines.push("");
+	}
+
+	if (unavailable.length > 0) {
+		lines.push("Not available (install required):");
+		for (const s of unavailable) {
+			lines.push(`  @${s.name} — ${s.bundle.description}`);
+			if (s.bundle.install) lines.push(`    ${s.bundle.install}`);
+		}
+		lines.push("");
+	}
+
+	lines.push(
+		"Install BMAD (optional):",
+		"  git clone https://github.com/bmad-code-org/BMAD-METHOD ~/.claude/skills/bmad",
+		'  Add to ~/.pi/agent/settings.json → "skills": ["~/.claude/skills/bmad"]',
+		"  /reload",
+		"",
+		"Install Superpowers (optional):",
+		"  Use Claude Code Superpowers plugin, or copy skills to ~/.pi/agent/skills",
+		"  pi-multi-skill also discovers ~/.claude/plugins/cache/**/skills/",
+		"",
+		"Custom bundles (no BMAD/Superpowers needed):",
+		"  Copy skill-bundles.example.json → ~/.pi/agent/skill-bundles.json",
+		"  List only skills you have installed.",
+	);
+
+	return lines.join("\n");
+}

package/src/bundles.ts

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { SkillBundle } from "./types.ts";
+import { parseYamlBundles } from "./yaml-bundles.ts";
+
+export const DEFAULT_BUNDLES: Record<string, SkillBundle> = {
+	"bmad-planning": {
+		description: "BMAD Phase 1-2 — analysis & planning",
+		skills: ["bmad-master", "analyst", "pm"],
+		order: "process-first",
+		default_mode: "meta",
+		requires: "BMAD Method",
+		install:
+			"git clone BMAD-METHOD to ~/.claude/skills/bmad, add path in pi settings \"skills\"",
+	},
+	"bmad-solutioning": {
+		description: "BMAD Phase 3 — architecture & design",
+		skills: ["bmad-master", "architect", "ux-designer"],
+		order: "process-first",
+		default_mode: "meta",
+		requires: "BMAD Method",
+		install:
+			"git clone BMAD-METHOD to ~/.claude/skills/bmad, add path in pi settings \"skills\"",
+	},
+	"bmad-build": {
+		description: "BMAD Phase 4 — story implementation",
+		skills: ["bmad-master", "developer", "scrum-master"],
+		order: "process-first",
+		default_mode: "lazy",
+		requires: "BMAD Method",
+		install:
+			"git clone BMAD-METHOD to ~/.claude/skills/bmad, add path in pi settings \"skills\"",
+	},
+	"cc-feature": {
+		description: "Claude Code-style feature workflow",
+		skills: [
+			"using-superpowers",
+			"brainstorming",
+			"writing-plans",
+			"test-driven-development",
+			"requesting-code-review",
+		],
+		order: "process-first",
+		default_mode: "lazy",
+		requires: "Superpowers",
+		install:
+			"Install Claude Code Superpowers plugin, or copy skills to ~/.pi/agent/skills",
+	},
+	debug: {
+		description: "Systematic bug investigation",
+		skills: ["systematic-debugging", "test-driven-development"],
+		order: "process-first",
+		default_mode: "full",
+		requires: "Superpowers",
+		install:
+			"Install Claude Code Superpowers plugin, or copy skills to ~/.pi/agent/skills",
+	},
+};
+
+function getAgentDir(): string {
+	return join(homedir(), ".pi", "agent");
+}
+
+function mergeBundleFile(
+	target: Map<string, SkillBundle>,
+	path: string,
+): void {
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed =
+			path.endsWith(".yaml") || path.endsWith(".yml")
+				? { bundles: parseYamlBundles(raw) }
+				: (JSON.parse(raw) as { bundles?: Record<string, SkillBundle> });
+		if (!parsed.bundles) return;
+		for (const [name, bundle] of Object.entries(parsed.bundles)) {
+			if (Array.isArray(bundle.skills) && bundle.skills.length > 0) {
+				target.set(name, bundle);
+			}
+		}
+	} catch {
+		// Skip invalid bundle files
+	}
+}
+
+export function loadBundles(cwd: string): Map<string, SkillBundle> {
+	const bundles = new Map<string, SkillBundle>();
+	for (const [name, bundle] of Object.entries(DEFAULT_BUNDLES)) {
+		bundles.set(name, bundle);
+	}
+
+	const paths = [
+		join(getAgentDir(), "skill-bundles.json"),
+		join(getAgentDir(), "skill-bundles.yaml"),
+		join(getAgentDir(), "skill-bundles.yml"),
+		join(cwd, ".pi", "skill-bundles.json"),
+		join(cwd, ".pi", "skill-bundles.yaml"),
+		join(cwd, ".pi", "skill-bundles.yml"),
+	];
+	for (const path of paths) {
+		if (existsSync(path)) mergeBundleFile(bundles, path);
+	}
+
+	return bundles;
+}
+
+export function expandSkillNames(
+	names: string[],
+	bundles: Map<string, SkillBundle>,
+): { skills: string[]; modeHint?: SkillBundle["default_mode"] } {
+	const expanded: string[] = [];
+	let modeHint: SkillBundle["default_mode"] | undefined;
+
+	for (const name of names) {
+		const bundleName = name.startsWith("@") ? name.slice(1) : name;
+		const bundle = bundles.get(bundleName);
+		if (name.startsWith("@") && bundle) {
+			expanded.push(...bundle.skills);
+			modeHint = modeHint ?? bundle.default_mode;
+		} else {
+			expanded.push(name);
+		}
+	}
+
+	return { skills: [...new Set(expanded)], modeHint };
+}
+
+export function bundleOrderHint(
+	names: string[],
+	bundles: Map<string, SkillBundle>,
+): SkillBundle["order"] | undefined {
+	for (const name of names) {
+		if (!name.startsWith("@")) continue;
+		const bundle = bundles.get(name.slice(1));
+		if (bundle?.order) return bundle.order;
+	}
+	return undefined;
+}