squad-skills 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Harry Nguyen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# Squad Skills
+
+[![skills.sh](https://skills.sh/b/danh121097/squad-skills)](https://skills.sh/danh121097/squad-skills)
+
+Supports **OpenCode**, **Claude Code**, **Codex**, **Cursor**, and
+[**73 more**](https://www.npmjs.com/package/skills#supported-agents).
+
+Role-specialized engineering skills for AI coding agents. The collection covers
+product framing, design, frontend, backend, mobile, DevOps, QA, code review, bug
+fixing, and coordinated squad delivery while preserving clear ownership
+boundaries.
+
+The repository follows the open Agent Skills format and keeps each installable
+skill under `skills/<skill-name>/SKILL.md`.
+
+## Install
+
+Every path installs the same set of skills. They differ in how the matching
+subagents arrive.
+
+| Path               | Skills | Subagents        | Tools                               |
+| ------------------ | ------ | ---------------- | ----------------------------------- |
+| Claude Code plugin | ✅     | ✅ same step     | Claude Code                         |
+| npm CLI            | ✅     | ✅ same step     | Claude Code, Codex                  |
+| `npx skills add`   | ✅     | one more command | every agent the Skills CLI supports |
+
+### As a Claude Code plugin
+
+The plugin ships the skills and the subagents together, so one command installs
+both:
+
+```sh
+/plugin marketplace add danh121097/squad-skills
+/plugin install squad-skills@squad-skills
+```
+
+Each role then exists twice over: as a skill you invoke, and as a subagent you
+spawn by name.
+
+### From the npm package (recommended)
+
+Run without a permanent CLI installation:
+
+```sh
+npx squad-skills list
+npx squad-skills add --skill squads-team
+npx squad-skills add --skill squad-frontend --global --agent codex
+```
+
+Or install the command globally first:
+
+```sh
+npm install --global squad-skills
+squad-skills add --skill squads-team
+```
+
+The npm command delegates installation to the official `skills` package and
+defaults to copied files, so installed skills do not depend on an ephemeral
+`npx` package-cache path.
+
+### Each role as a subagent too
+
+`squad-skills add` also writes a subagent definition for every skill it
+installs, so a role can be spawned by name instead of only loaded as a skill.
+Claude Code reads `.claude/agents/<name>.md`; Codex reads
+`.codex/agents/<name>.toml` and loads it only once `config.toml` names the file,
+which the CLI registers after backing that config up. Each definition points at
+the `SKILL.md` just installed rather than copying it, so the skill stays the one
+source of truth.
+
+Use `--no-agents` to install skills alone. A catalog installed through
+`npx skills add` never runs this CLI, so generate the definitions afterwards:
+
+```sh
+npx squad-skills agents --global
+```
+
+`--model` and `--effort` write those fields into each Claude Code subagent file,
+so a spawned role runs on the model you picked and survives the next reinstall:
+
+```sh
+npx squad-skills agents --global --model opus --effort medium
+```
+
+No skill in this catalog names a model. Which one to run is a property of your
+machine, not of the role, so it lives in the command that writes your files.
+Codex takes no per-agent model; set `[agents] default_subagent_model` in
+`~/.codex/config.toml` instead, and the CLI says so rather than dropping the
+flag silently.
+
+See [the installation guide](docs/installation.md) for local-checkout commands,
+installation scope, copy versus symlink behavior, and publishing notes.
+
+### From GitHub or skills.sh
+
+List the available skills directly from the public repository:
+
+```sh
+npx skills add danh121097/squad-skills --list
+```
+
+Install the squad orchestrator globally for selected agents:
+
+```sh
+npx skills add danh121097/squad-skills \
+  --skill squads-team --global \
+  --agent codex --agent claude-code --agent cursor --agent opencode
+```
+
+Install a single role:
+
+```sh
+npx skills add danh121097/squad-skills \
+  --skill squad-frontend --global --agent codex
+```
+
+This route installs skills only. The upstream Skills CLI has no hook a source
+repository can use, so generate the subagent definitions after it:
+
+```sh
+npx squad-skills agents --global
+```
+
+## Develop
+
+Requires Node.js 22.20 or newer. The repository pins pnpm through `package.json`.
+
+```sh
+pnpm install
+pnpm test
+pnpm release:check
+```
+
+`pnpm test` runs TypeScript type checking, formatting verification, Vitest,
+skill-contract validation, knowledge-card validation, and catalog discovery
+through the pinned Skills CLI.
+
+Read [AGENTS.md](AGENTS.md) before contributing with a coding agent.
+Use [the publishing guide](docs/publishing.md) when the local repository and npm
+package are ready to be made public.
+
+## Contribute
+
+[CONTRIBUTING.md](CONTRIBUTING.md) is the contract: the contribution types that
+are accepted, the ones that are rejected and why, the provenance a knowledge
+card must carry, and the evidence a skill-content change must carry before it
+ships.
+
+Two things are worth knowing before you start. Knowledge enters through a
+reviewed card citing a dated first-party source, never through crawling or a
+pasted page. And a change to anything an agent reads at runtime ships on the
+full deterministic gate plus maintainer review — that gate shows the catalog is
+consistent, contract-bound and within its payload ceiling, which is not the same
+as showing the output got better, so a claim that it did needs its own evidence.
+[AGENTS.md](AGENTS.md) states the rule.
+
+If you used one of these skills on real work and its output got something wrong,
+open the [skill output problem](https://github.com/danh121097/squad-skills/issues/new?template=skill-feedback.yml)
+form. You do not need to know the fix.
+[`docs/feedback-and-weekly-improvement.md`](docs/feedback-and-weekly-improvement.md)
+is what happens to a report after that, and
+[`docs/skill-observations.md`](docs/skill-observations.md) is how one becomes a
+rule.
+
+## Skill format
+
+Each skill directory must contain a `SKILL.md` whose YAML `name` matches the
+directory name and whose `description` explains when the skill applies. Bundle
+supporting material inside that same skill directory so installations remain
+self-contained.
+
+The executable contract is owned by the TypeScript validator and tests. Run
+`pnpm validate` for a focused catalog check or `pnpm test` for the full gate.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Discovery
+
+After this repository is public, run the documented GitHub smoke install once.
+Public GitHub skills become eligible for skills.sh discovery through anonymous
+Skills CLI installation telemetry; the npm package remains an additional
+distribution path and does not replace the GitHub source.

package/bin/cli.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import module from 'node:module';
+
+if (module.enableCompileCache && !process.env.NODE_DISABLE_COMPILE_CACHE) {
+  try {
+    module.enableCompileCache();
+  } catch {
+    // Compile caching is an optional startup optimization.
+  }
+}
+
+await import('../dist/cli/cli.mjs');

package/dist/cli/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli/cli.mjs

@@ -0,0 +1,450 @@
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import path, { dirname, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+const agentsTablePattern = /^\s*\[agents\]\s*$/;
+const tableHeaderPattern = /^\s*\[([^\]]+)\]\s*$/;
+function registerCodexAgents(source, names) {
+	const added = [];
+	const alreadyRegistered = [];
+	const missing = [];
+	for (const name of names) if (hasAgentEntry(source, name)) alreadyRegistered.push(name);
+	else missing.push(name);
+	if (missing.length === 0) return {
+		added,
+		alreadyRegistered,
+		source
+	};
+	const entries = missing.flatMap((name) => [
+		`  [agents.${name}]`,
+		`    config_file = "agents/${name}.toml"`,
+		`    description = ${JSON.stringify(name)}`
+	]);
+	added.push(...missing);
+	return {
+		added,
+		alreadyRegistered,
+		source: insertIntoAgentsTable(source, entries)
+	};
+}
+function hasAgentEntry(source, name) {
+	return source.split(/\r?\n/).some((line) => tableHeaderPattern.exec(line)?.[1] === `agents.${name}`);
+}
+function insertIntoAgentsTable(source, entries) {
+	const lines = source.split("\n");
+	const tableStart = lines.findIndex((line) => agentsTablePattern.test(line));
+	if (tableStart === -1) return `${source}${source.length > 0 && !source.endsWith("\n") ? "\n" : ""}\n[agents]\n${entries.join("\n")}\n`;
+	let insertAt = lines.length;
+	for (let index = tableStart + 1; index < lines.length; index += 1) {
+		const header = tableHeaderPattern.exec(lines[index])?.[1];
+		if (header !== void 0 && !header.startsWith("agents.")) {
+			insertAt = index;
+			break;
+		}
+	}
+	while (insertAt > tableStart + 1 && lines[insertAt - 1].trim() === "") insertAt -= 1;
+	return [
+		...lines.slice(0, insertAt),
+		...entries,
+		...lines.slice(insertAt)
+	].join("\n");
+}
+const generatedMarker = "Generated by squad-skills";
+const frontmatterPattern = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+function readSkillAgentDefinition(source) {
+	const frontmatter = source.match(frontmatterPattern)?.[1];
+	if (frontmatter === void 0) return null;
+	const name = readScalar(frontmatter, "name");
+	const description = readScalar(frontmatter, "description");
+	if (name === null || description === null) return null;
+	return {
+		description,
+		name,
+		whenToUse: readScalar(frontmatter, "when_to_use") ?? ""
+	};
+}
+function renderAgentBody(definition, context) {
+	const description = [definition.description, definition.whenToUse].filter((part) => part.length > 0).join(" ");
+	return `---
+${[
+		`name: ${definition.name}`,
+		`description: ${JSON.stringify(description)}`,
+		...context.frontmatter ?? []
+	].join("\n")}
+---
+
+<!-- ${generatedMarker} from ${definition.name}/SKILL.md. ${context.origin} -->
+
+${context.instruction}
+
+That file, together with the references it routes to, is the authoritative
+definition of this role — its scope, its ownership boundaries, its handoff
+contract, and its completion checklist. Read it before acting, and follow its
+own routing rules to decide which of its references to open. Do not act on this
+summary alone, and do not substitute your own process for the one it states.
+
+If that file cannot be read, say so and stop rather than improvising the role.
+`;
+}
+function renderClaudeAgentFile(definition, installedSkillPath, preferences = {}) {
+	return renderAgentBody(definition, {
+		...installedSkillContext(installedSkillPath),
+		frontmatter: renderPreferenceLines(preferences)
+	});
+}
+function renderPreferenceLines(preferences) {
+	const lines = [];
+	if (preferences.model !== void 0 && preferences.model !== null) lines.push(`model: ${preferences.model}`);
+	if (preferences.effort !== void 0 && preferences.effort !== null) lines.push(`effort: ${preferences.effort}`);
+	return lines;
+}
+function installedSkillContext(installedSkillPath) {
+	return {
+		instruction: `Read \`${installedSkillPath}\` and follow it for this task.`,
+		origin: "Reinstalling regenerates it."
+	};
+}
+function renderCodexAgentFile(definition, installedSkillPath) {
+	const body = renderAgentBody(definition, installedSkillContext(installedSkillPath));
+	if (body.includes("'''")) throw new Error(`${definition.name}: agent body contains ''' and cannot be written as a TOML literal string.`);
+	return `# ${generatedMarker}. Reinstalling regenerates this file.
+[agents.${definition.name}]
+developer_instructions = '''
+${body}'''
+`;
+}
+function readScalar(frontmatter, key) {
+	const line = frontmatter.split(/\r?\n/).find((candidate) => candidate.startsWith(`${key}:`))?.slice(key.length + 1).trim();
+	if (line === void 0 || line.length === 0) return null;
+	if (line.startsWith("\"")) return JSON.parse(line);
+	if (line.startsWith("'")) return line.slice(1, -1).replaceAll("''", "'");
+	return line;
+}
+const supportedTools = /* @__PURE__ */ new Set(["claude-code", "codex"]);
+async function installAgentDefinitions(request) {
+	const messages = [];
+	const written = [];
+	const definitions = await readDefinitions(request, messages);
+	if (definitions.length === 0) return {
+		messages,
+		written
+	};
+	for (const tool of request.agents) {
+		if (!supportedTools.has(tool)) continue;
+		const target = resolveTarget(tool, request);
+		if (target === null) {
+			messages.push(`Skipped ${tool} agents: project scope is not a verified location for them; install with --global.`);
+			continue;
+		}
+		await mkdir(target.agentsDirectory, { recursive: true });
+		const preferences = {
+			effort: request.effort,
+			model: request.model
+		};
+		if ((preferences.model != null || preferences.effort != null) && !target.carriesPreferences) messages.push(`Ignored --model and --effort for ${tool}: this CLI writes them into Claude Code agent files only. Codex reads a subagent default from [agents] default_subagent_model and default_subagent_reasoning_effort in config.toml.`);
+		const registered = [];
+		for (const definition of definitions) {
+			const installedSkillFile = await findInstalledSkill(target.skillsRoots, definition.name);
+			if (installedSkillFile === null) {
+				messages.push(`Skipped ${tool}/${definition.name}: the skill is not installed there.`);
+				continue;
+			}
+			const agentFile = path.join(target.agentsDirectory, `${definition.name}${target.extension}`);
+			if (!request.force && await isForeignFile(agentFile)) {
+				messages.push(`Kept ${agentFile}: not generated by squad-skills. Use --force to replace.`);
+				continue;
+			}
+			await writeFile(agentFile, target.render(definition, installedSkillFile, target.carriesPreferences ? preferences : {}), "utf8");
+			written.push(agentFile);
+			registered.push(definition.name);
+		}
+		if (target.codexConfigFile !== void 0 && registered.length > 0) messages.push(...await registerInCodexConfig(target.codexConfigFile, registered));
+	}
+	return {
+		messages,
+		written
+	};
+}
+async function readDefinitions(request, messages) {
+	const skillsRoot = path.join(request.packageRoot, "skills");
+	const names = request.skills.length > 0 ? request.skills : await readSkillDirectories(skillsRoot, messages);
+	const definitions = [];
+	for (const name of names) {
+		let source;
+		try {
+			source = await readFile(path.join(skillsRoot, name, "SKILL.md"), "utf8");
+		} catch {
+			messages.push(`Skipped ${name}: no packaged SKILL.md.`);
+			continue;
+		}
+		const definition = readSkillAgentDefinition(source);
+		if (definition === null) {
+			messages.push(`Skipped ${name}: SKILL.md frontmatter is missing a name or description.`);
+			continue;
+		}
+		definitions.push(definition);
+	}
+	return definitions;
+}
+async function readSkillDirectories(skillsRoot, messages) {
+	try {
+		return (await readdir(skillsRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+	} catch {
+		messages.push(`Skipped every agent: ${skillsRoot} is unreadable.`);
+		return [];
+	}
+}
+function resolveTarget(tool, request) {
+	const root = request.scope === "global" ? request.homeDirectory : request.projectRoot;
+	if (tool === "claude-code") return {
+		agentsDirectory: path.join(root, ".claude", "agents"),
+		carriesPreferences: true,
+		extension: ".md",
+		render: renderClaudeAgentFile,
+		skillsRoots: [path.join(root, ".claude", "skills"), path.join(root, ".agents", "skills")],
+		tool
+	};
+	if (request.scope !== "global") return null;
+	return {
+		agentsDirectory: path.join(root, ".codex", "agents"),
+		carriesPreferences: false,
+		codexConfigFile: path.join(root, ".codex", "config.toml"),
+		extension: ".toml",
+		render: renderCodexAgentFile,
+		skillsRoots: [path.join(root, ".agents", "skills"), path.join(root, ".codex", "skills")],
+		tool
+	};
+}
+async function registerInCodexConfig(configFile, names) {
+	let source;
+	try {
+		source = await readFile(configFile, "utf8");
+	} catch {
+		source = "";
+	}
+	const result = registerCodexAgents(source, names);
+	if (result.added.length === 0) return [];
+	if (source.length > 0) await copyFile(configFile, `${configFile}.squad-skills-backup`);
+	else await mkdir(path.dirname(configFile), { recursive: true });
+	await writeFile(configFile, result.source, "utf8");
+	return [`Registered ${result.added.join(", ")} in ${configFile}.`];
+}
+async function findInstalledSkill(roots, name) {
+	for (const root of roots) {
+		const candidate = path.join(root, name, "SKILL.md");
+		try {
+			await readFile(candidate, "utf8");
+			return candidate;
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+async function isForeignFile(file) {
+	try {
+		return !(await readFile(file, "utf8")).includes(generatedMarker);
+	} catch {
+		return false;
+	}
+}
+const supportedAgentTools = ["claude-code", "codex"];
+const helpFlags = /* @__PURE__ */ new Set(["--help", "-h"]);
+const versionFlags = /* @__PURE__ */ new Set(["--version", "-v"]);
+const addCommands = /* @__PURE__ */ new Set([
+	"add",
+	"install",
+	"i"
+]);
+const noAgentsFlag = "--no-agents";
+const modelFlags = ["--model"];
+const effortFlags = ["--effort"];
+function createCliAction(arguments_, packageRoot, version) {
+	const [command, ...forwardedArguments] = arguments_;
+	if (command === void 0 || helpFlags.has(command)) return {
+		kind: "print",
+		message: createHelpText(),
+		exitCode: 0
+	};
+	if (versionFlags.has(command)) return {
+		kind: "print",
+		message: version,
+		exitCode: 0
+	};
+	const malformed = findMalformedScalarOption(forwardedArguments);
+	if (malformed !== null) return {
+		kind: "print",
+		message: `${malformed} needs a value.\n\n${createHelpText()}`,
+		exitCode: 1
+	};
+	if (addCommands.has(command)) {
+		const forwardable = dropPreferenceArguments(forwardedArguments.filter((argument) => argument !== noAgentsFlag));
+		return {
+			kind: "delegate",
+			agentPlan: forwardedArguments.includes(noAgentsFlag) ? null : createAgentPlan(forwardedArguments),
+			arguments: [
+				"add",
+				packageRoot,
+				...ensureCopyInstallation(forwardable)
+			]
+		};
+	}
+	if (command === "agents") return {
+		kind: "install-agents",
+		agentPlan: createAgentPlan(forwardedArguments)
+	};
+	if (command === "list" || command === "ls") return {
+		kind: "delegate",
+		agentPlan: null,
+		arguments: [
+			"add",
+			packageRoot,
+			"--list",
+			...forwardedArguments
+		]
+	};
+	return {
+		kind: "print",
+		message: `Unknown command: ${command}\n\n${createHelpText()}`,
+		exitCode: 1
+	};
+}
+function createAgentPlan(arguments_) {
+	return {
+		agents: readListOption(arguments_, ["--agent", "-a"], supportedAgentTools),
+		effort: readScalarOption(arguments_, effortFlags),
+		force: arguments_.includes("--force"),
+		model: readScalarOption(arguments_, modelFlags),
+		scope: arguments_.includes("--global") || arguments_.includes("-g") ? "global" : "project",
+		skills: readListOption(arguments_, ["--skill", "-s"], [])
+	};
+}
+function readScalarOption(arguments_, flags) {
+	for (const [index, argument] of arguments_.entries()) {
+		const inlineFlag = flags.find((flag) => argument.startsWith(`${flag}=`));
+		if (inlineFlag !== void 0) {
+			const value = argument.slice(inlineFlag.length + 1).trim();
+			if (value.length > 0) return value;
+			continue;
+		}
+		if (!flags.includes(argument)) continue;
+		const value = arguments_[index + 1]?.trim() ?? "";
+		if (value.length > 0 && !value.startsWith("-")) return value;
+	}
+	return null;
+}
+function findMalformedScalarOption(arguments_) {
+	for (const flags of [modelFlags, effortFlags]) if (arguments_.some((argument) => flags.includes(argument) || flags.some((flag) => argument.startsWith(`${flag}=`))) && readScalarOption(arguments_, flags) === null) return flags[0];
+	return null;
+}
+function dropPreferenceArguments(arguments_) {
+	const flags = [...modelFlags, ...effortFlags];
+	return arguments_.filter((argument, index) => {
+		if (flags.some((flag) => argument === flag || argument.startsWith(`${flag}=`))) return false;
+		return !flags.includes(arguments_[index - 1]);
+	});
+}
+function readListOption(arguments_, flags, wildcard) {
+	const values = [];
+	for (const [index, argument] of arguments_.entries()) {
+		const inlineFlag = flags.find((flag) => argument.startsWith(`${flag}=`));
+		if (inlineFlag !== void 0) values.push(argument.slice(inlineFlag.length + 1));
+		else if (flags.includes(argument)) values.push(arguments_[index + 1] ?? "");
+	}
+	const parsed = values.flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
+	return parsed.includes("*") || parsed.length === 0 ? wildcard : parsed;
+}
+function ensureCopyInstallation(arguments_) {
+	if (arguments_.includes("--copy")) return arguments_;
+	return [...arguments_, "--copy"];
+}
+function createHelpText() {
+	return `Squad Skills
+
+Install role-specialized engineering skills through the Skills CLI.
+
+Usage:
+  squad-skills add [skills options]
+  squad-skills list [skills options]
+  squad-skills agents [options]
+
+Commands:
+  add, install, i   Install skills from this package, then generate an agent
+                    definition for each installed skill
+  list, ls          List the packaged skills
+  agents            Generate agent definitions for skills already installed,
+                    for a catalog installed through \`npx skills add\`
+
+Agent options:
+  --no-agents       Install skills only (add)
+  --force           Replace an agent file this CLI did not generate
+  --global, -g      Read and write the user-level location
+  --agent, -a       Limit to ${supportedAgentTools.join(", ")}
+  --skill, -s       Limit to named skills
+  --model           Write this model into each Claude Code agent file
+  --effort          Write this reasoning effort into each Claude Code agent file
+
+Examples:
+  squad-skills list
+  squad-skills add --skill squads-team
+  squad-skills add --skill squad-frontend --global --agent codex
+  squad-skills agents --global
+  squad-skills agents --global --agent claude-code --model opus --effort medium
+
+Claude Code reads an agent from .claude/agents/<name>.md. Codex reads one from
+.codex/agents/<name>.toml and loads it only once config.toml names it, so this
+CLI registers it there and backs the file up first. Codex agents are written at
+global scope only, and carry no model field: Codex takes a subagent default from
+[agents] default_subagent_model in config.toml instead.
+
+--model and --effort are machine preferences, not catalog content. They are
+written only where the caller asks for them, so a reinstall keeps them.
+
+All other options after add or list are forwarded to the Skills CLI.`;
+}
+const require = createRequire(import.meta.url);
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const packageMetadata = require(resolve(packageRoot, "package.json"));
+const skillsPackagePath = require.resolve("skills/package.json");
+const skillsCliPath = resolve(dirname(skillsPackagePath), "bin/cli.mjs");
+const action = createCliAction(process.argv.slice(2), packageRoot, packageMetadata.version);
+if (action.kind === "print") {
+	console.log(action.message);
+	process.exitCode = action.exitCode;
+} else if (action.kind === "install-agents") await writeAgentDefinitions(action.agentPlan);
+else {
+	const exitCode = await runSkillsCli(skillsCliPath, action.arguments);
+	process.exitCode = exitCode;
+	if (exitCode === 0 && action.agentPlan !== null) await writeAgentDefinitions(action.agentPlan);
+}
+async function writeAgentDefinitions(agentPlan) {
+	const result = await installAgentDefinitions({
+		...agentPlan,
+		homeDirectory: homedir(),
+		packageRoot,
+		projectRoot: process.cwd()
+	});
+	for (const message of result.messages) console.log(message);
+	console.log(result.written.length === 0 ? "No agent definitions written." : `Wrote ${result.written.length} agent definition(s).`);
+}
+function runSkillsCli(cliPath, arguments_) {
+	return new Promise((resolveExitCode) => {
+		const child = spawn(process.execPath, [cliPath, ...arguments_], { stdio: "inherit" });
+		child.once("error", (error) => {
+			console.error(`Unable to start the Skills CLI: ${error.message}`);
+			resolveExitCode(1);
+		});
+		child.once("exit", (code, signal) => {
+			if (signal !== null) {
+				console.error(`Skills CLI stopped by signal ${signal}.`);
+				resolveExitCode(1);
+				return;
+			}
+			resolveExitCode(code ?? 1);
+		});
+	});
+}
+export {};