buddy-agent-harness 0.2.0 → 0.3.1

package/dist/init.command-BN_w5DRZ.mjs

@@ -0,0 +1,686 @@
+import { command, z } from "clibuilder";
+import { homedir } from "node:os";
+import { dirname, join, posix, relative, sep } from "node:path";
+import { encode } from "@toon-format/toon";
+import { cpSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmSync, statSync, symlinkSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+//#region src/command-output/command-output.ts
+const formats = [
+	"toon",
+	"json",
+	"text"
+];
+/** Rejects anything but the supported formats so an unknown value never falls back silently. */
+function parseFormat(value) {
+	if (!formats.includes(value)) throw new Error("--format must be toon, json, or text.");
+	return value;
+}
+/** The single stdout boundary: internal logic stays on plain objects, encoding happens here. */
+function writeResult(value, format) {
+	process.stdout.write(`${encodeResult(value, format)}\n`);
+}
+function encodeResult(value, format) {
+	if (format === "json") return JSON.stringify(value);
+	return format === "text" ? renderText(value) : encode(value);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cell(value) {
+	return value === void 0 ? "" : String(value);
+}
+/** A header row plus one row per record, every column padded to its widest cell. */
+function table(rows) {
+	const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+	const widths = columns.map((column) => Math.max(column.length, ...rows.map((row) => cell(row[column]).length)));
+	const line = (values) => `  ${values.map((value, index) => value.padEnd(widths[index])).join("  ")}`.trimEnd();
+	return [line(columns), ...rows.map((row) => line(columns.map((column) => cell(row[column]))))];
+}
+/**
+* The same result rendered for a person rather than for an agent: scalars as `key: value`, records
+* as an aligned table, and everything else as a bulleted list. TOON stays the default because it is
+* what an agent parses; this is for reading over someone's shoulder.
+*/
+function renderText(value) {
+	const blocks = Object.entries(value).map(([key, item]) => {
+		if (!Array.isArray(item)) return [`${key}: ${isRecord(item) ? JSON.stringify(item) : String(item)}`];
+		if (!item.length) return [`${key}: (none)`];
+		const body = item.every(isRecord) ? table(item) : item.map((entry) => `  - ${String(entry)}`);
+		return [`${key}:`, ...body];
+	});
+	return blocks.flatMap((block, index) => {
+		const previous = blocks[index - 1];
+		return previous && (previous.length > 1 || block.length > 1) ? ["", ...block] : block;
+	}).join("\n");
+}
+/** AXI §10: the executable's absolute path, with the user's home directory collapsed to `~`. */
+function binPath(home, executable) {
+	if (!executable) return "buddy-agent-harness";
+	return home && executable.startsWith(home + sep) ? `~${executable.slice(home.length)}` : executable;
+}
+//#endregion
+//#region src/harness-registry/harness-registry.ts
+/**
+* Codex, Cursor, Copilot CLI, and Devin Desktop read `.agents/skills` directly, so they need no
+* projection. Only Claude Code and Gemini CLI read solely their own directory.
+*
+* `windsurf` is the former name of Devin Desktop, rebranded 2026-06-02. It is retained as a
+* deprecated alias: Devin still scans the legacy `.windsurf/skills` path, so its projection keeps
+* working, but new repositories should enable `devin-desktop` and have nothing written for them.
+*
+* See `.research/agentic-configuration-standards/` for the per-harness sources.
+*/
+const harnessRegistry = [
+	{
+		name: "claude-code",
+		detect: ".claude",
+		skillsDirectory: ".claude/skills"
+	},
+	{
+		name: "cursor",
+		detect: ".cursor"
+	},
+	{
+		name: "codex",
+		detect: ".codex"
+	},
+	{
+		name: "copilot-cli",
+		detect: ".github/skills"
+	},
+	{
+		name: "gemini-cli",
+		detect: ".gemini",
+		skillsDirectory: ".gemini/skills"
+	},
+	{
+		name: "devin-desktop",
+		detect: ".devin"
+	},
+	{
+		name: "windsurf",
+		detect: ".windsurf",
+		skillsDirectory: ".windsurf/skills",
+		deprecated: "devin-desktop"
+	}
+];
+/** Enabled whether or not the repository already contains their directories. */
+const defaultHarnesses = ["claude-code", "cursor"];
+function directoryExists(path) {
+	try {
+		return lstatSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/** The default harnesses, plus the preferred ones, plus every harness whose directory is present. */
+function selectHarnesses(root, preferred) {
+	const enabled = /* @__PURE__ */ new Set([...defaultHarnesses, ...preferred]);
+	return harnessRegistry.filter((harness) => enabled.has(harness.name) || directoryExists(join(root, harness.detect)));
+}
+//#endregion
+//#region src/diagnose-bridges/directory-files.ts
+/**
+* Every file below `directory`, as paths relative to it, POSIX-separated and sorted. A directory
+* that does not exist reads as empty: `doctor` never creates one to look at it.
+*/
+function filesUnder(directory) {
+	try {
+		return readdirSync(directory, {
+			recursive: true,
+			withFileTypes: true
+		}).filter((entry) => entry.isFile()).map((entry) => relative(directory, join(entry.parentPath, entry.name)).split(sep).join(posix.sep)).sort();
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/diagnose-bridges/doctor-guidance.ts
+/** How the command names itself. A skill may run without the binary on PATH, so it uses `npx`. */
+const commandInvocation = "buddy-agent-harness";
+const skillInvocation = "npx -y buddy-agent-harness";
+/** How the skill hands a repair back to `init`. */
+const initSkillInvocation = "/buddy-agent-harness:init";
+const doctorRepairs = [
+	{
+		problem: "no-canonical",
+		detail: "the canonical skill directory does not exist, so no bridge can resolve",
+		repair: (_path, cli) => `${cli} init`,
+		skillRepair: () => `run \`${initSkillInvocation}\`, which creates \`.agents/skills\` and the bridges`
+	},
+	{
+		problem: "missing",
+		detail: "no bridge at this path — the harness sees zero project skills",
+		repair: (_path, cli) => `${cli} init`,
+		skillRepair: () => `run \`${initSkillInvocation}\``
+	},
+	{
+		problem: "degraded",
+		detail: "expected a directory but found a regular file — checkout without core.symlinks",
+		repair: (_path, cli) => `${cli} init --copy --force`,
+		skillRepair: () => `run \`${initSkillInvocation} --copy --force\``
+	},
+	{
+		problem: "stale",
+		detail: "symlink does not resolve to .agents/skills",
+		repair: (_path, cli) => `${cli} init --force`,
+		skillRepair: () => `run \`${initSkillInvocation} --force\``
+	},
+	{
+		problem: "diverged-bridge",
+		detail: "only the bridge changed since the two last agreed — an agent wrote through the copy",
+		repair: (path, cli) => `replace .agents/skills with ${path} to keep the newer edit and then run ${cli} init --force`,
+		skillRepair: (path) => `replace .agents/skills with ${path} to keep the newer edit, then run \`${initSkillInvocation} --force\``
+	},
+	{
+		problem: "diverged-canonical",
+		detail: "only .agents/skills changed since the two last agreed — the copy is stale",
+		repair: (_path, cli) => `${cli} init --copy --force`,
+		skillRepair: () => `run \`${initSkillInvocation} --copy --force\``
+	},
+	{
+		problem: "diverged-both",
+		detail: "both sides changed since they last agreed — rebuilding would discard one of them",
+		repair: (path) => `git diff --no-index .agents/skills ${path} and reconcile by hand`,
+		skillRepair: (path) => `run \`git diff --no-index .agents/skills ${path}\` and reconcile by hand`
+	},
+	{
+		problem: "diverged-unknown",
+		detail: "contents differ and no commit where they agreed was found — which side moved is unknown",
+		repair: (path) => `git diff --no-index .agents/skills ${path} and reconcile by hand`,
+		skillRepair: (path) => `run \`git diff --no-index .agents/skills ${path}\` and reconcile by hand`
+	},
+	{
+		problem: "unpinned-copy",
+		detail: "tracked copy without the skip-worktree bit — the tree is dirty with content that must not be committed",
+		repair: (path) => `git ls-files -z ${path} | xargs -0 git update-index --skip-worktree`,
+		skillRepair: (path) => `run \`git ls-files -z ${path} | xargs -0 git update-index --skip-worktree\``
+	}
+];
+const repairsByProblem = new Map(doctorRepairs.map((entry) => [entry.problem, entry]));
+function repairFor(problem) {
+	return repairsByProblem.get(problem);
+}
+const doctorSkill = {
+	name: "doctor",
+	description: "Use this skill when a repository loads no project skills, when skills are missing after a clone, or when checking whether the agent configuration bridges into .claude/skills and the other harness directories still resolve."
+};
+/** Written into the generated skill so a reader knows not to edit it in place. */
+const generatedSkillWarning = "<!-- Generated from src/diagnose-bridges/doctor-guidance.ts by scripts/generate-doctor-skill.ts. Do not edit by hand. -->";
+/** The shipped `doctor` skill, rendered from the same table the command prints. */
+function renderDoctorSkill() {
+	const cell = (value) => value.replaceAll("|", "\\|");
+	const rows = doctorRepairs.map((entry) => `| \`${entry.problem}\` | ${entry.detail} | ${cell(entry.skillRepair("<path>"))} |`).join("\n");
+	return `---
+name: ${doctorSkill.name}
+description: ${doctorSkill.description}
+---
+
+${generatedSkillWarning}
+
+# Harness Doctor
+
+\`.agents/skills\` is the canonical skill directory. Harnesses that cannot read it — Claude Code and Gemini CLI — get a bridge pointing at it, normally a directory symlink. A bridge that stops resolving is silent: the harness finds nothing and loads zero project skills, with no warning anywhere.
+
+Diagnose it:
+
+\`\`\`sh
+${skillInvocation} doctor
+\`\`\`
+
+The command is read-only. It never repairs anything, so it is safe to run at any point, including from a session-start hook.
+
+## Reading the report
+
+\`bridges\` lists every bridge \`init\` would create for this repository, each with a \`status\` of \`ok\`, \`missing\`, \`degraded\`, \`stale\`, or \`diverged\`. \`findings\` explains each problem and \`help\` names its repair. Apply the repair from the table below, then re-run \`doctor\`.
+
+\`help\` names the \`init\` command for a person at a shell. Do not run it yourself. Rebuilding a bridge can move skills a user wrote, and that judgment belongs to the \`init\` skill — hand the repair to \`${initSkillInvocation}\` instead.
+
+When every bridge resolves, \`findings\` says so outright rather than being empty.
+
+The default output is TOON, which is what you parse. Add \`--format text\` when you need to show the same report to a person, or \`--format json\`.
+
+## Findings and their repairs
+
+| Finding | What it means | Repair |
+| --- | --- | --- |
+${rows}
+
+Substitute the reported bridge path for \`<path>\`.
+
+## The Windows case
+
+The common failure is \`degraded\`. Creating a symlink on Windows needs a privilege most accounts do not have, and Git for Windows gates it separately with \`core.symlinks\`, which its installer leaves off. With \`core.symlinks=false\` git does not error — it writes the symlink out as a regular file whose contents are the target path. \`${initSkillInvocation} --copy --force\` rebuilds the bridges as real directories on that machine.
+
+A copy is a snapshot rather than a live projection, and an agent that edits a skill through it writes into the copy instead of into \`.agents/skills\`. That is what the \`diverged\` findings catch.
+
+## Rules
+
+- Never repair a \`diverged-both\` or \`diverged-unknown\` bridge by re-running \`init\`. Rebuilding overwrites whichever side holds the newer edit. Reconcile the two directories first.
+- Edit skills at \`.agents/skills/<name>/SKILL.md\`. Editing through a bridge is only safe when that bridge is a symlink.
+- Do not add bridges to \`.gitignore\`. An untracked bridge swallows a real edit silently.
+`;
+}
+//#endregion
+//#region src/diagnose-bridges/git-bridge-state.ts
+function git(root, args, input) {
+	try {
+		return execFileSync("git", args, {
+			cwd: root,
+			encoding: "utf8",
+			...input === void 0 ? {} : { input },
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+	} catch {
+		return;
+	}
+}
+function lines(output) {
+	return (output ?? "").split("\n").filter(Boolean);
+}
+/**
+* Reads git state for the two sides of a bridge. Every method degrades to "cannot tell" rather than
+* throwing, so `doctor` still reports on a tarball, a worktree without git, or a repository with no
+* commits.
+*/
+var GitBridgeState = class {
+	root;
+	/** Path of `root` relative to the repository root, `''` at the top, `undefined` outside a repository. */
+	prefix;
+	constructor(root) {
+		this.root = root;
+		this.prefix = git(root, ["rev-parse", "--show-prefix"])?.trim();
+	}
+	/**
+	* `init --copy` marks a bridge skip-worktree so a machine-local copy over a tracked symlink stops
+	* showing as a pending change. The bit is a hint that some checkouts clear, so it is verified
+	* rather than assumed.
+	*/
+	trackingOf(path) {
+		if (this.prefix === void 0) return "untracked";
+		const entries = lines(git(this.root, [
+			"ls-files",
+			"-v",
+			"--",
+			path
+		]));
+		if (!entries.length) return "untracked";
+		return entries.every((entry) => entry.startsWith("S")) ? "skip-worktree" : "tracked";
+	}
+	/**
+	* Names the side that moved by finding the newest commit whose two trees agreed, then asking which
+	* of the working directories still matches it.
+	*/
+	directionOf(bridge, canonical) {
+		if (this.prefix === void 0) return "unknown";
+		const base = this.lastAgreedTree(bridge, canonical);
+		if (base === void 0) return "unknown";
+		const bridgeMoved = !this.matchesTree(bridge, base);
+		const canonicalMoved = !this.matchesTree(canonical, base);
+		if (bridgeMoved && canonicalMoved) return "both";
+		if (bridgeMoved) return "bridge";
+		return "canonical";
+	}
+	/** The tree of the newest commit where both paths held identical content. */
+	lastAgreedTree(bridge, canonical) {
+		for (const commit of lines(git(this.root, [
+			"rev-list",
+			"-n",
+			"200",
+			"HEAD",
+			"--",
+			bridge,
+			canonical
+		]))) {
+			const bridgeObject = git(this.root, [
+				"rev-parse",
+				"-q",
+				"--verify",
+				`${commit}:${this.prefix}${bridge}`
+			])?.trim();
+			if (!bridgeObject) continue;
+			if (bridgeObject === git(this.root, [
+				"rev-parse",
+				"-q",
+				"--verify",
+				`${commit}:${this.prefix}${canonical}`
+			])?.trim()) return bridgeObject;
+		}
+	}
+	/**
+	* Compares a working directory against a git tree by object id. `hash-object` is used rather than
+	* hashing in-process so the comparison follows whatever object format the repository uses.
+	*/
+	matchesTree(directory, tree) {
+		const expected = new Map(lines(git(this.root, [
+			"ls-tree",
+			"-r",
+			tree
+		])).map((entry) => {
+			const [meta, path] = entry.split("	");
+			return [path, meta.split(" ")[2]];
+		}));
+		const files = filesUnder(join(this.root, directory));
+		if (files.length !== expected.size || files.some((file) => !expected.has(file))) return false;
+		const hashed = lines(git(this.root, ["hash-object", "--stdin-paths"], files.map((file) => join(directory, file)).join("\n")));
+		return hashed.length === files.length && files.every((file, index) => expected.get(file) === hashed[index]);
+	}
+};
+//#endregion
+//#region src/diagnose-bridges/diagnose-bridges.ts
+const canonicalPath = ".agents/skills";
+function pathState(target) {
+	try {
+		const stats = lstatSync(target);
+		if (stats.isSymbolicLink()) return "symlink";
+		return stats.isDirectory() ? "directory" : "file";
+	} catch {
+		return "missing";
+	}
+}
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/** The same test `init` uses to decide a projection is already correct, plus that it still resolves. */
+function resolvesToCanonical(target, canonical) {
+	return readlinkSync(target) === relative(dirname(target), canonical) && isDirectory(target);
+}
+function sameContent(left, right) {
+	const leftFiles = filesUnder(left);
+	const rightFiles = filesUnder(right);
+	return leftFiles.length === rightFiles.length && leftFiles.every((file, index) => rightFiles[index] === file && readFileSync(join(left, file)).equals(readFileSync(join(right, file))));
+}
+function inspect(target, path, canonical, git) {
+	switch (pathState(target)) {
+		case "missing": return {
+			kind: "none",
+			status: "missing",
+			problem: "missing"
+		};
+		case "file": return {
+			kind: "file",
+			status: "degraded",
+			problem: "degraded"
+		};
+		case "symlink": return resolvesToCanonical(target, canonical) ? {
+			kind: "symlink",
+			status: "ok"
+		} : {
+			kind: "symlink",
+			status: "stale",
+			problem: "stale"
+		};
+		default:
+			if (!sameContent(target, canonical)) {
+				const direction = git.directionOf(path, canonicalPath);
+				return {
+					kind: "copy",
+					status: "diverged",
+					problem: `diverged-${direction}`,
+					direction
+				};
+			}
+			return git.trackingOf(path) === "tracked" ? {
+				kind: "copy",
+				status: "ok",
+				problem: "unpinned-copy"
+			} : {
+				kind: "copy",
+				status: "ok"
+			};
+	}
+}
+/**
+* Reports whether every bridge `init` would create for this repository still resolves into
+* `.agents/skills`. Read-only: nothing is created, moved, or repaired, so the caller decides what
+* to run from the repair each finding carries.
+*/
+function diagnoseBridges({ root, harnesses: preferred = [], cli }) {
+	const canonical = join(root, ".agents", "skills");
+	const git = new GitBridgeState(root);
+	const bridged = selectHarnesses(root, preferred).filter((harness) => Boolean(harness.skillsDirectory));
+	const bridges = [];
+	const divergence = [];
+	const findings = [];
+	if (!isDirectory(canonical)) {
+		const { detail, repair } = repairFor("no-canonical");
+		findings.push({
+			path: canonicalPath,
+			detail,
+			repair: repair(canonicalPath, cli)
+		});
+	}
+	for (const harness of bridged) {
+		const path = harness.skillsDirectory;
+		const inspection = inspect(join(root, path), path, canonical, git);
+		bridges.push({
+			harness: harness.name,
+			path,
+			kind: inspection.kind,
+			status: inspection.status
+		});
+		if (inspection.direction) divergence.push({
+			path,
+			direction: inspection.direction
+		});
+		if (inspection.problem) {
+			const { detail, repair } = repairFor(inspection.problem);
+			findings.push({
+				path,
+				detail,
+				repair: repair(path, cli)
+			});
+		}
+	}
+	return {
+		bridges,
+		divergence,
+		findings
+	};
+}
+//#endregion
+//#region src/diagnose-bridges/doctor.command.ts
+/**
+* AXI §5: the healthy answer states the zero with context, so an agent does not re-run with other
+* flags to confirm that an empty section really meant "nothing wrong".
+*/
+function buildReport(bin, result) {
+	if (!result.findings.length) {
+		const count = result.bridges.length;
+		return {
+			bin,
+			bridges: result.bridges,
+			findings: count === 1 ? "0 problems found — the 1 bridge resolves" : `0 problems found — all ${count} bridges resolve`
+		};
+	}
+	return {
+		bin,
+		bridges: result.bridges,
+		...result.divergence.length ? { divergence: result.divergence } : {},
+		findings: result.findings.map(({ path, detail }) => ({
+			path,
+			detail
+		})),
+		help: [...new Set(result.findings.map((finding) => `Run \`${finding.repair}\``))]
+	};
+}
+const doctorCommand = command({
+	name: "doctor",
+	description: "Report whether the harness skill bridges in this repository still resolve. Read-only.",
+	options: {
+		root: {
+			description: "Repository or package directory. Defaults to the current directory.",
+			type: z.optional(z.string())
+		},
+		harness: {
+			description: "Comma-separated harnesses to check in addition to Claude Code and Cursor, e.g. codex,gemini-cli.",
+			type: z.optional(z.string())
+		},
+		format: {
+			description: "Output format: toon (default), json, or text for a human-readable report.",
+			type: z.optional(z.string()),
+			default: "toon"
+		}
+	},
+	run(args) {
+		try {
+			const format = parseFormat(args.format);
+			const requested = args.harness?.split(",").map((name) => name.trim()).filter(Boolean);
+			const unsupported = requested?.filter((name) => !harnessRegistry.some((harness) => harness.name === name));
+			if (unsupported?.length) throw new Error(`Unsupported harness: ${unsupported.join(", ")}. Supported: ${harnessRegistry.map((harness) => harness.name).join(", ")}.`);
+			const result = diagnoseBridges({
+				root: args.root ?? process.cwd(),
+				...requested?.length ? { harnesses: requested } : {},
+				cli: commandInvocation
+			});
+			writeResult(buildReport(binPath(homedir(), process.argv[1]), result), format);
+		} catch (error) {
+			process.stderr.write(`error: ${error instanceof Error ? error.message : "Harness diagnosis failed."}\n`);
+			process.exitCode = 1;
+		}
+	}
+});
+//#endregion
+//#region src/skill-projection/skill-projection.ts
+function skillNames(skillsDirectory) {
+	return readdirSync(skillsDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+function pathOccupied(path) {
+	try {
+		lstatSync(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isCorrectLink(target, source) {
+	return lstatSync(target).isSymbolicLink() && readlinkSync(target) === relative(dirname(target), source);
+}
+/** Creates the canonical directory when absent, so a fresh repository reports zero skills. */
+function countSkills(canonicalSkills) {
+	mkdirSync(canonicalSkills, { recursive: true });
+	return skillNames(canonicalSkills).length;
+}
+/**
+* Points every harness that cannot read `.agents/skills` at the canonical directory. Symlinking is
+* preferred; a platform that refuses the link falls back to a copy. Returns the projected harnesses.
+*/
+function projectSkills({ root, canonicalSkills, harnesses, copy, force }) {
+	const projections = harnesses.filter((harness) => harness.skillsDirectory).map((harness) => ({
+		harness,
+		target: join(root, harness.skillsDirectory)
+	}));
+	const conflicts = projections.filter(({ target }) => pathOccupied(target) && !isCorrectLink(target, canonicalSkills)).map(({ target }) => target);
+	if (conflicts.length && !force) throw new Error(`Refusing to replace existing skill targets:\n${conflicts.map((target) => `- ${target}`).join("\n")}`);
+	for (const { target } of projections) {
+		mkdirSync(dirname(target), { recursive: true });
+		if (pathOccupied(target) && isCorrectLink(target, canonicalSkills)) continue;
+		if (pathOccupied(target)) rmSync(target, {
+			recursive: true,
+			force: true
+		});
+		if (copy) {
+			cpSync(canonicalSkills, target, { recursive: true });
+			continue;
+		}
+		try {
+			symlinkSync(relative(dirname(target), canonicalSkills), target, "junction");
+		} catch (error) {
+			if (pathOccupied(target)) throw error;
+			cpSync(canonicalSkills, target, { recursive: true });
+		}
+	}
+	return projections.map(({ harness }) => harness.name);
+}
+//#endregion
+//#region src/initialize-harnesses/initialize-harnesses.ts
+function initializeHarnesses({ root, harnesses: preferred = [], copy = false, force = false }) {
+	const canonicalSkills = join(root, ".agents", "skills");
+	const skills = countSkills(canonicalSkills);
+	const harnesses = selectHarnesses(root, preferred);
+	const linked = projectSkills({
+		root,
+		canonicalSkills,
+		harnesses,
+		copy,
+		force
+	});
+	return {
+		root,
+		harnesses: harnesses.map((harness) => harness.name),
+		native: harnesses.filter((harness) => !harness.skillsDirectory).map((harness) => harness.name),
+		linked,
+		deprecated: harnesses.filter((harness) => harness.deprecated).map((harness) => ({
+			name: harness.name,
+			replacedBy: harness.deprecated
+		})),
+		skills,
+		copied: copy
+	};
+}
+//#endregion
+//#region src/initialize-harnesses/init.command.ts
+const initCommand = command({
+	name: "init",
+	description: "Set up canonical agent skills for the harnesses already enabled in a repository.",
+	options: {
+		root: {
+			description: "Repository or package directory. Defaults to the current directory.",
+			type: z.optional(z.string())
+		},
+		harness: {
+			description: "Comma-separated harnesses to enable in addition to Claude Code and Cursor, e.g. codex,gemini-cli.",
+			type: z.optional(z.string())
+		},
+		copy: {
+			description: "Copy skills instead of linking them.",
+			type: z.optional(z.boolean())
+		},
+		force: {
+			description: "Replace conflicting target skill directories.",
+			type: z.optional(z.boolean())
+		},
+		format: {
+			description: "Output format: toon (default), json, or text for a human-readable report.",
+			type: z.optional(z.string()),
+			default: "toon"
+		}
+	},
+	run(args) {
+		try {
+			const format = parseFormat(args.format);
+			const requested = args.harness?.split(",").map((name) => name.trim()).filter(Boolean);
+			const unsupported = requested?.filter((name) => !harnessRegistry.some((harness) => harness.name === name));
+			if (unsupported?.length) throw new Error(`Unsupported harness: ${unsupported.join(", ")}. Supported: ${harnessRegistry.map((harness) => harness.name).join(", ")}.`);
+			writeResult(initializeHarnesses({
+				root: args.root ?? process.cwd(),
+				...requested?.length ? { harnesses: requested } : {},
+				...args.copy === void 0 ? {} : { copy: args.copy },
+				...args.force === void 0 ? {} : { force: args.force }
+			}), format);
+		} catch (error) {
+			process.stderr.write(`error: ${error instanceof Error ? error.message : "Harness initialization failed."}\n`);
+			process.exitCode = 1;
+		}
+	}
+});
+const harnessCommand = command({
+	name: "agent-harness",
+	description: "Commands for configuring agent harness compatibility.",
+	commands: [initCommand, doctorCommand]
+});
+function activate({ addCommand }) {
+	addCommand(harnessCommand);
+}
+//#endregion
+export { doctorCommand as a, doctorSkill as c, initializeHarnesses as i, renderDoctorSkill as l, harnessCommand as n, diagnoseBridges as o, initCommand as r, doctorRepairs as s, activate as t, harnessRegistry as u };
+
+//# sourceMappingURL=init.command-BN_w5DRZ.mjs.map