buddy-agent-harness 0.8.0 → 0.9.0

package/dist/index.mjs

@@ -1,2 +1,2735 @@
-import { _ as harnessRegistry, a as initializeHarnesses, c as diagnoseBridges, d as goldenSetPath, f as bridgeRepairs, g as renderDoctorSkill, h as instructionRepairs, i as initCommand, l as diagnoseInstructions, m as doctorSkill, n as activate, o as buildDoctorReport, p as doctorRepairs, r as harnessCommand, s as doctorCommand, t as run, u as diagnoseMcp } from "./cli-4ekejn5W.mjs";
+import { createRequire } from "node:module";
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { cli, command, exitCodes, z } from "clibuilder";
+import { homedir, platform } from "node:os";
+import { dirname, join, posix, relative, resolve, sep } from "node:path";
+import { encode } from "@toon-format/toon";
+import { parse } from "smol-toml";
+import { execFileSync } from "node:child_process";
+//#region src/is-record/is-record.ts
+/**
+* Whether a value is a record: an object with named keys, and not an array.
+*
+* Everything this package reads is a file someone else wrote — a golden MCP set, a harness config,
+* a projection record — so every parse lands on `unknown` and every reader narrows it here before
+* asking for a key. Four modules had their own copy of the same three clauses; a predicate that
+* decides what counts as a parsed object is one fact, and a copy of it that drifts changes what a
+* file is read to say.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#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 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/dep-plugins/dep-plugins.ts
+/**
+* Marketplace names generic enough that two repositories are likely to pick the same one. The
+* collision is silent and costly: registering a second marketplace under a name already in use
+* replaces the first, and the install that follows reports "already installed" and does nothing —
+* so the repository silently runs the other one's plugin versions.
+*/
+const GENERIC_NAMES = /* @__PURE__ */ new Set([
+	"deps",
+	"dependencies",
+	"local",
+	"plugins",
+	"marketplace",
+	"plugin",
+	"default"
+]);
+function isGenericName(name) {
+	return GENERIC_NAMES.has(name.toLowerCase());
+}
+/**
+* A marketplace name derived from the consuming package's own name, so two repositories do not
+* collide by default. A scope is folded into the name rather than dropped (`@acme/web` → `acme-web`)
+* because the unscoped half is the part most likely to repeat across organizations.
+*/
+function marketplaceName(packageName) {
+	return packageName.replace(/^@/, "").replace(/\//g, "-").replace(/[^a-zA-Z0-9-_.]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "agent-plugins";
+}
+/**
+* Dependency names a repository declares, both runtime and development.
+*
+* Development dependencies are included on purpose: a plugin that supplies a project's testing or
+* release workflow is a development dependency, and excluding them would drop most of the cases this
+* exists for. Transitive dependencies are never included — see `resolve.ts`.
+*/
+function declaredDependencies(manifest) {
+	if (!manifest || typeof manifest !== "object") return [];
+	const record = manifest;
+	const names = /* @__PURE__ */ new Set();
+	for (const field of ["dependencies", "devDependencies"]) {
+		const group = record[field];
+		if (!group || typeof group !== "object") continue;
+		for (const name of Object.keys(group)) names.add(name);
+	}
+	return [...names].sort();
+}
+/**
+* The catalog is derived in full on every run and never merged into what is already on disk. That is
+* what makes the three cases a consumer cares about — a plugin added, a plugin removed, a version
+* moved — fall out of regeneration instead of needing reconciliation logic of their own.
+*
+* Entries are sorted by name so that a regeneration whose inputs did not change produces a
+* byte-identical file, which is what lets a check mode compare rather than interpret.
+*/
+function buildCatalog({ name, owner, plugins }) {
+	const entries = [...plugins].sort((a, b) => a.plugin.localeCompare(b.plugin)).map(({ plugin, package: pkg, version, description }) => {
+		const source = {
+			source: "npm",
+			package: pkg,
+			version
+		};
+		return description ? {
+			name: plugin,
+			source,
+			description
+		} : {
+			name: plugin,
+			source
+		};
+	});
+	return {
+		name,
+		owner: { name: owner },
+		description: "Plugins provided by this repository’s dependencies. Generated — do not edit.",
+		plugins: entries
+	};
+}
+/** Serialized the way the repository formats JSON, with the trailing newline a text file needs. */
+function serializeCatalog(catalog) {
+	return `${JSON.stringify(catalog, null, "	")}\n`;
+}
+//#endregion
+//#region src/dep-plugins/resolve.ts
+/**
+* Locating a declared dependency on disk, and reading the plugin manifest it may ship.
+*
+* Resolution rather than scanning. Walking `node_modules` finds transitive dependencies nobody
+* vetted, and a skill or plugin is instruction text that steers an agent — an unvetted transitive
+* dependency is a supply-chain surface, not a convenience. Asking the module resolver where a
+* *declared* dependency lives answers the question that was actually asked, and it is correct under
+* npm, pnpm, yarn with the node-modules linker, and bun alike, because all four put a real directory
+* on disk. Only Yarn PnP does not, and it is reported rather than guessed at.
+*/
+function readJson$1(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+/**
+* Every ancestor `node_modules/<pkg>` from `startDir` upward. The fallback path only — see
+* {@link packageDir}.
+*/
+function ancestorCandidates(startDir, pkg) {
+	const segments = pkg.split("/");
+	const candidates = [];
+	let dir = startDir;
+	for (;;) {
+		candidates.push(join(dir, "node_modules", ...segments));
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return candidates;
+}
+/**
+* The directory a declared dependency was installed into, or `undefined`.
+*
+* Two mechanisms, in order, because neither alone is sufficient:
+*
+* 1. **`require.resolve('<pkg>/package.json')`, anchored at the declaring manifest.** The anchor
+*    matters: under pnpm's isolated store only the package that declares a dependency can resolve it,
+*    so resolving from a workspace root would miss what a workspace member declared.
+* 2. **A walk up `node_modules`.** Roughly one package in seven declares an `exports` map without a
+*    `./package.json` entry, and those refuse the first mechanism with `ERR_PACKAGE_PATH_NOT_EXPORTED`
+*    however plainly they are installed. Resolving a deeper file instead is not an escape — the same
+*    map blocks that too.
+*/
+function packageDir(pkg, fromManifest) {
+	try {
+		const require = createRequire(fromManifest);
+		return dirname(require.resolve(`${pkg}/package.json`));
+	} catch {}
+	for (const candidate of ancestorCandidates(dirname(fromManifest), pkg)) if (existsSync(join(candidate, "package.json"))) return candidate;
+}
+/**
+* Reads the plugin a dependency ships, if it ships one.
+*
+* The version comes from the dependency's own `package.json` rather than from a lockfile. It is the
+* same number — the version actually installed — and reading it needs no knowledge of which of the
+* four lockfile formats this repository uses.
+*
+* A manifest at the package root is what the Agent Plugins Specification pins, and it is the form a
+* harness accepts as a marketplace source without any vendor-specific manifest alongside it.
+*/
+function readDepPlugin(pkg, fromManifest) {
+	const dir = packageDir(pkg, fromManifest);
+	if (!dir) return {
+		ok: false,
+		package: pkg,
+		reason: "unresolved"
+	};
+	const manifest = readJson$1(join(dir, "plugin.json"));
+	if (!manifest || typeof manifest !== "object") return {
+		ok: false,
+		package: pkg,
+		reason: "no-manifest"
+	};
+	const record = manifest;
+	const name = typeof record["name"] === "string" ? record["name"] : void 0;
+	if (!name) return {
+		ok: false,
+		package: pkg,
+		reason: "unnamed"
+	};
+	const installed = readJson$1(join(dir, "package.json"));
+	const version = typeof installed?.version === "string" ? installed.version : void 0;
+	if (!version) return {
+		ok: false,
+		package: pkg,
+		reason: "no-manifest"
+	};
+	const description = typeof record["description"] === "string" ? record["description"] : void 0;
+	return {
+		ok: true,
+		plugin: description ? {
+			package: pkg,
+			plugin: name,
+			version,
+			description
+		} : {
+			package: pkg,
+			plugin: name,
+			version
+		}
+	};
+}
+/**
+* True when the process is running under Yarn's Plug'n'Play resolver, where packages live inside zip
+* archives rather than as directories. A marketplace source must be a real directory and an npm
+* source must be installable, so a PnP project needs `nodeLinker: node-modules` or the affected
+* dependencies unplugged. Detected rather than worked around, so the report can say so.
+*/
+function isPnp() {
+	return Boolean(process.versions["pnp"]);
+}
+//#endregion
+//#region src/dep-plugins/generate.ts
+/**
+* Deriving a repository's dependency-plugin catalog, and deciding whether what is on disk matches.
+*/
+/**
+* The catalog's home, relative to the repository root.
+*
+* Under this tool's own directory, beside the other files it owns there — the same place as
+* `mcp.toml` and `mcp.projected.json`, and the same shape as `.agents/repobuddy/` and
+* `.agents/cyberlegion/`. A directory named for what it holds rather than for who writes it would be
+* a second convention in a tree that already has one.
+*
+* Not the repository root's `.claude-plugin/`, which is where a repository publishes its *own*
+* plugins for its *own* consumers. Merging the two would leak every dependency-provided plugin into
+* what a consumer sees on adding the published marketplace, and no harness has a notion of a private
+* catalog entry to prevent that. Being a separate directory also makes this one a marketplace root
+* in its own right, which is what lets its entries be resolved without reaching outside it.
+*/
+const CATALOG_DIR = join(".agents", "buddy-agent-harness");
+const CATALOG_PATH = join(CATALOG_DIR, ".claude-plugin", "marketplace.json");
+function readManifest(path) {
+	return JSON.parse(readFileSync(path, "utf8"));
+}
+/**
+* Derives the catalog from the repository's declared dependencies.
+*
+* Derived in full every time. A plugin newly added to `package.json` appears, one removed disappears,
+* and a version that moved follows — all three without a line of reconciliation logic, because there
+* is nothing to reconcile against. That is the same rule the vendor manifests already follow: the
+* artifact is derived, never authored.
+*/
+function deriveCatalog(root) {
+	const manifestPath = join(root, "package.json");
+	const manifest = readManifest(manifestPath);
+	const plugins = [];
+	const unresolved = [];
+	for (const pkg of declaredDependencies(manifest)) {
+		const outcome = readDepPlugin(pkg, manifestPath);
+		if (outcome.ok) plugins.push(outcome.plugin);
+		else if (outcome.reason === "unresolved") unresolved.push({
+			package: pkg,
+			reason: outcome.reason
+		});
+	}
+	const owner = typeof manifest["name"] === "string" ? manifest["name"] : "unknown";
+	const name = marketplaceName(owner);
+	return {
+		catalog: buildCatalog({
+			name,
+			owner,
+			plugins
+		}),
+		plugins,
+		unresolved,
+		genericName: isGenericName(name),
+		pnp: isPnp()
+	};
+}
+/**
+* What writing the catalog would do, without touching the disk.
+*
+* Comparing the serialized form rather than the parsed one is deliberate: a byte comparison is what
+* lets a check mode be a comparison instead of an interpretation, and `buildCatalog` sorts its
+* entries so that unchanged inputs serialize identically.
+*/
+function catalogStatus(root, catalog) {
+	let current;
+	try {
+		current = readFileSync(join(root, CATALOG_PATH), "utf8");
+	} catch {
+		current = void 0;
+	}
+	if (current === serializeCatalog(catalog)) return "unchanged";
+	return current === void 0 ? "created" : "updated";
+}
+/** Writes the catalog, reporting whether it moved. A write that would change nothing writes nothing. */
+function writeCatalog(root, catalog) {
+	const outcome = catalogStatus(root, catalog);
+	if (outcome === "unchanged") return outcome;
+	const path = join(root, CATALOG_PATH);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, serializeCatalog(catalog));
+	return outcome;
+}
+//#endregion
+//#region src/dep-plugins/harness-plugins.ts
+/**
+* What each harness does with a marketplace catalog, and how to read what it currently has.
+*
+* The runtimes diverge more than they look, and every difference below was established by running
+* the shipped CLI rather than by reading a document:
+*
+* - **Claude Code** refreshes with `plugin update`; re-running `plugin install` is a no-op that
+*   reports "already installed" and leaves the stale copy in place. Every verb defaults to user
+*   scope, so each one has to name `--scope project` explicitly.
+* - **Codex** has no update verb and no scope. Re-running `plugin add` re-reads the catalog and
+*   replaces the cached copy, so the same command installs and refreshes. It records no version in
+*   its config — the installed version is only in the cache directory's name.
+* - **Copilot CLI** accepts a path source but **rejects an `npm` source**, so it cannot consume this
+*   catalog at all. See {@link COPILOT_LIMITATION}.
+* - **Cursor** exposes no plugin subcommand from a terminal.
+*
+* A consumer should not have to know any of that, which is why it is here rather than in a document.
+*/
+/**
+* Why Copilot CLI is absent from the table. Recorded rather than dropped, so the reason travels with
+* the code: `copilot plugin marketplace add` rejects this catalog with
+* `Invalid marketplace.json: plugins.0.source: Invalid input`, while the same catalog with a
+* `./path` source is accepted. Supporting it needs a second, path-sourced catalog — and a path source
+* cannot escape its marketplace root, which is the constraint the `npm` source was chosen to avoid.
+*/
+const COPILOT_LIMITATION = "Copilot CLI rejects an npm marketplace source, so it cannot install from this catalog. It needs a path-sourced catalog, which cannot reach node_modules from a subdirectory.";
+function readJson(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+function directories(path) {
+	try {
+		return readdirSync(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	} catch {
+		return [];
+	}
+}
+/**
+* `CLAUDE_CONFIG_DIR` wins where set, which is also what keeps a test off a developer's real
+* configuration.
+*/
+function claudeConfigDir(home, env = process.env) {
+	return env["CLAUDE_CONFIG_DIR"] || join(home, ".claude");
+}
+/**
+* Reads what Claude Code has installed.
+*
+* The file keys each plugin by `<plugin>@<marketplace>` and holds an *array* per key, because the
+* same plugin can be installed at more than one scope and, at project scope, once per project.
+*/
+function readClaudeState(configDir) {
+	const installedFile = readJson(join(configDir, "plugins", "installed_plugins.json"));
+	const installed = [];
+	for (const [id, entries] of Object.entries(installedFile?.plugins ?? {})) {
+		if (!Array.isArray(entries)) continue;
+		for (const entry of entries) {
+			if (!entry || typeof entry !== "object") continue;
+			const record = entry;
+			const version = typeof record["version"] === "string" ? record["version"] : void 0;
+			const scope = typeof record["scope"] === "string" ? record["scope"] : void 0;
+			if (!version || !scope) continue;
+			const projectPath = typeof record["projectPath"] === "string" ? record["projectPath"] : void 0;
+			installed.push(projectPath ? {
+				id,
+				version,
+				scope,
+				projectPath
+			} : {
+				id,
+				version,
+				scope
+			});
+		}
+	}
+	const knownFile = readJson(join(configDir, "plugins", "known_marketplaces.json"));
+	const marketplaces = [];
+	for (const [name, value] of Object.entries(knownFile ?? {})) marketplaces.push({
+		name,
+		path: typeof value?.source?.path === "string" ? value.source.path : ""
+	});
+	return {
+		installed,
+		marketplaces
+	};
+}
+const claudeCode = {
+	name: "claude-code",
+	scoped: true,
+	present: (home, env = process.env) => existsSync(claudeConfigDir(home, env)),
+	state: (home, env = process.env) => readClaudeState(claudeConfigDir(home, env)),
+	register: (catalogDir) => `claude plugin marketplace add ./${catalogDir} --scope project`,
+	install: (id) => `claude plugin install ${id} --scope project`,
+	/**
+	* Not `install`: re-running that on an already-installed plugin changes nothing and says so, which
+	* reads as success. `--scope project` is required rather than cosmetic — every verb defaults to
+	* user scope, so an update omitting it fails with "not installed at scope user" against a plugin
+	* that is plainly installed.
+	*/
+	update: (id) => `claude plugin update ${id} --scope project`,
+	uninstall: (id) => `claude plugin uninstall ${id} --scope project`,
+	refreshMarketplace: (marketplace) => `claude plugin marketplace update ${marketplace}`
+};
+function codexHome(home, env = process.env) {
+	return env["CODEX_HOME"] || join(home, ".codex");
+}
+/**
+* Reads what Codex has installed.
+*
+* The installed version comes from the cache layout, `plugins/cache/<marketplace>/<plugin>/<version>`,
+* because Codex's `config.toml` records only that a plugin is enabled — never which version.
+*
+* Registered marketplaces are read from `config.toml` by scanning for its `[marketplaces.<name>]`
+* tables. A deliberately narrow read rather than a TOML parser: only two keys are needed, and the
+* cost of being wrong is a report that suggests re-registering, which is harmless to re-run.
+*/
+function readCodexState(home) {
+	const cacheRoot = join(home, "plugins", "cache");
+	const installed = [];
+	for (const marketplace of directories(cacheRoot)) for (const plugin of directories(join(cacheRoot, marketplace))) for (const version of directories(join(cacheRoot, marketplace, plugin))) installed.push({
+		id: `${plugin}@${marketplace}`,
+		version,
+		scope: "user"
+	});
+	const marketplaces = [];
+	let config = "";
+	try {
+		config = readFileSync(join(home, "config.toml"), "utf8");
+	} catch {
+		config = "";
+	}
+	let current;
+	for (const line of config.split("\n")) {
+		const header = /^\s*\[marketplaces\.(?:"([^"]+)"|([^\]]+))\]\s*$/.exec(line);
+		if (header) {
+			current = {
+				name: header[1] ?? header[2],
+				path: ""
+			};
+			marketplaces.push(current);
+			continue;
+		}
+		if (/^\s*\[/.test(line)) {
+			current = void 0;
+			continue;
+		}
+		const source = current ? /^\s*source\s*=\s*"([^"]*)"\s*$/.exec(line) : void 0;
+		if (source?.[1] && current) current.path = source[1];
+	}
+	return {
+		installed,
+		marketplaces
+	};
+}
+const runtimes = [claudeCode, {
+	name: "codex",
+	/**
+	* Codex installs into `CODEX_HOME` with no notion of scope, so one install is shared by every
+	* repository on the machine. Two repositories whose catalogs share a marketplace name cannot be
+	* told apart here, which is what makes the marketplace name derived from the package name matter.
+	*/
+	scoped: false,
+	present: (home, env = process.env) => existsSync(codexHome(home, env)),
+	state: (home, env = process.env) => readCodexState(codexHome(home, env)),
+	register: (catalogDir) => `codex plugin marketplace add ./${catalogDir}`,
+	install: (id) => `codex plugin add ${id}`,
+	/** No update verb: re-running `add` re-reads the catalog and replaces the cached copy. */
+	update: (id) => `codex plugin add ${id}`,
+	uninstall: (id) => `codex plugin remove ${id}`,
+	/** `marketplace upgrade` refreshes git snapshots only; `add` already re-reads a local catalog. */
+	refreshMarketplace: () => ""
+}];
+//#endregion
+//#region src/dep-plugins/reconcile.ts
+/**
+* Installs belonging to this repository and this catalog.
+*
+* On a scoped runtime a user-scoped install is deliberately excluded rather than counted: it is
+* shared with every other repository on the machine, so treating it as satisfying this repository's
+* catalog would let one project's pin silently stand in for another's.
+*/
+function ours(installed, marketplace, root, scoped) {
+	const suffix = `@${marketplace}`;
+	return installed.filter((entry) => entry.id.endsWith(suffix) && (!scoped || entry.projectPath === root));
+}
+function reconcile({ catalog, catalogDir, root, installed, marketplaces, scoped = true }) {
+	const registration = marketplaces.find((entry) => entry.name === catalog.name);
+	const actions = [];
+	const expected = catalogDir.split(/[\\/]/).filter(Boolean);
+	const pointsHere = registration ? expected.every((segment) => registration.path.includes(segment)) : false;
+	const collision = registration && !pointsHere ? registration.path : void 0;
+	if (!registration) actions.push({
+		kind: "register",
+		subject: catalog.name,
+		detail: "marketplace is not registered with this harness"
+	});
+	const mine = ours(installed, catalog.name, root, scoped);
+	const byId = new Map(mine.map((entry) => [entry.id, entry]));
+	for (const entry of catalog.plugins) {
+		const id = `${entry.name}@${catalog.name}`;
+		const current = byId.get(id);
+		if (!current) {
+			actions.push({
+				kind: "install",
+				subject: id,
+				detail: `not installed; catalog pins ${entry.source.version}`
+			});
+			continue;
+		}
+		if (current.version !== entry.source.version) actions.push({
+			kind: "update",
+			subject: id,
+			detail: `installed ${current.version}, catalog pins ${entry.source.version}`
+		});
+	}
+	const wanted = new Set(catalog.plugins.map((entry) => `${entry.name}@${catalog.name}`));
+	for (const entry of mine) if (!wanted.has(entry.id)) actions.push({
+		kind: "uninstall",
+		subject: entry.id,
+		detail: "installed but no longer in the catalog; it will report a load failure until removed"
+	});
+	return {
+		actions,
+		...collision ? { collision } : {},
+		unregistered: !registration
+	};
+}
+//#endregion
+//#region src/dep-plugins/dep-plugins.command.ts
+/** The command that performs one action, so a reader is not left to look the verb up per runtime. */
+function commandFor(runtime, action, marketplace) {
+	switch (action.kind) {
+		case "register": return runtime.register(CATALOG_DIR);
+		case "install": return runtime.install(action.subject);
+		case "update": {
+			const refresh = runtime.refreshMarketplace(marketplace);
+			const update = runtime.update(action.subject);
+			return refresh ? `${refresh} && ${update}` : update;
+		}
+		case "uninstall": return runtime.uninstall(action.subject);
+	}
+}
+/**
+* Notes name the conditions a caller cannot see from the entry list and would otherwise discover as a
+* failure later — a dependency that is declared but absent, a marketplace name two repositories are
+* likely to share, a resolver under which no dependency has a directory at all.
+*/
+function notesFor(derived) {
+	const notes = [];
+	if (derived.pnp) notes.push("Yarn Plug’n’Play is active: dependencies live inside zip archives, so no harness can install from them. Set nodeLinker: node-modules, or unplug the plugin dependencies.");
+	if (derived.genericName) notes.push(`Marketplace name "${derived.catalog.name}" is generic. Registering a second marketplace under a name already in use replaces the first silently, and the install that follows reports "already installed" — the repository then runs the other one's versions.`);
+	for (const { package: pkg } of derived.unresolved) notes.push(`Declared dependency "${pkg}" is not installed; install dependencies before generating.`);
+	return notes;
+}
+const depPluginsCommand = command({
+	name: "dep-plugins",
+	description: "Derive the marketplace catalog for plugins shipped by this repository’s dependencies, so a harness can install them. Writes the catalog; installing is the harness’s own job.",
+	options: {
+		root: {
+			description: "Repository directory. Defaults to the current directory.",
+			type: z.optional(z.string())
+		},
+		check: {
+			description: "Report whether the catalog is current without writing it. For CI and postinstall.",
+			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 root = args.root ?? process.cwd();
+			const derived = deriveCatalog(root);
+			const outcome = args.check ? catalogStatus(root, derived.catalog) === "unchanged" ? "current" : "would-change" : writeCatalog(root, derived.catalog);
+			const home = homedir();
+			const notes = notesFor(derived);
+			const detected = runtimes.filter((candidate) => candidate.present(home));
+			const harness = [];
+			const actions = [];
+			for (const runtime of detected) {
+				const state = runtime.state(home);
+				const delta = reconcile({
+					catalog: derived.catalog,
+					catalogDir: CATALOG_DIR,
+					root: resolve(root),
+					installed: state.installed,
+					marketplaces: state.marketplaces,
+					scoped: runtime.scoped
+				});
+				if (delta.collision) notes.push(`${runtime.name}: marketplace "${derived.catalog.name}" is already registered against ${delta.collision}. Registering over it replaces the other repository's silently, and the install that follows reports "already installed" — rename this repository's marketplace instead.`);
+				harness.push({
+					runtime: runtime.name,
+					status: delta.actions.length ? `${delta.actions.length} to apply` : "in sync"
+				});
+				for (const action of delta.actions) actions.push({
+					runtime: runtime.name,
+					do: commandFor(runtime, action, derived.catalog.name),
+					subject: action.subject,
+					why: action.detail
+				});
+			}
+			if (derived.plugins.length) notes.push(COPILOT_LIMITATION);
+			writeResult({
+				catalog: CATALOG_PATH,
+				marketplace: derived.catalog.name,
+				outcome,
+				plugins: derived.plugins.length ? derived.plugins.map(({ plugin, package: pkg, version }) => ({
+					name: plugin,
+					package: pkg,
+					version
+				})) : "0 dependencies ship a plugin — nothing to install",
+				harness: harness.length ? harness : "no supported harness detected on this machine",
+				actions: actions.length ? actions : "0 actions — every detected harness matches the catalog",
+				...notes.length ? { notes } : {}
+			}, format);
+			return outcome === "would-change" ? exitCodes.error : exitCodes.success;
+		} catch (error) {
+			process.stderr.write(`error: ${error instanceof Error ? error.message : "Catalog generation failed."}\n`);
+			return exitCodes.error;
+		}
+	}
+});
+//#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/harness-registry/harness-registry.ts
+/**
+* The two scopes disagree in general, and a single answer per harness could only record one of them:
+* Copilot CLI is `.github/skills` in a repository and `~/.copilot` for the user. Claude Code is the
+* only harness that needs a skills projection, and it needs one at both scopes. Codex, Cursor,
+* Copilot CLI, Gemini CLI, and Devin Desktop read `.agents/skills` themselves and are never
+* projected into.
+*
+* Gemini CLI carried a `.gemini/skills` projection until E-GEM-02: it reads the `.agents/skills`
+* alias at project scope too, where that alias takes precedence over `.gemini/skills`. It still
+* needs an instruction bridge, which is a separate axis and unaffected.
+*
+* Instruction bridges are recorded at project scope only. The user-scope equivalents exist, but
+* nothing writes or reads them yet: `init` works inside a repository, and so does `doctor`.
+*
+* `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",
+		project: {
+			detect: ".claude",
+			skillsDirectory: ".claude/skills",
+			instructionBridge: {
+				kind: "import",
+				path: "CLAUDE.md"
+			},
+			mcpConfig: {
+				path: ".mcp.json",
+				key: "mcpServers",
+				format: "json"
+			},
+			nonstandard: [
+				{
+					path: ".claude/commands",
+					shape: "directory",
+					kind: "command"
+				},
+				{
+					path: ".claude/rules",
+					shape: "directory",
+					kind: "rule"
+				},
+				{
+					path: ".claude/agents",
+					shape: "directory",
+					kind: "subagent"
+				}
+			]
+		},
+		user: {
+			detect: ".claude",
+			skillsDirectory: ".claude/skills"
+		}
+	},
+	{
+		name: "cursor",
+		project: {
+			detect: ".cursor",
+			mcpConfig: {
+				path: ".cursor/mcp.json",
+				key: "mcpServers",
+				format: "json"
+			},
+			nonstandard: [
+				{
+					path: ".cursorrules",
+					shape: "file",
+					kind: "instructions"
+				},
+				{
+					path: ".cursor/rules",
+					shape: "directory",
+					kind: "rule"
+				},
+				{
+					path: ".cursor/commands",
+					shape: "directory",
+					kind: "command"
+				},
+				{
+					path: ".cursor/skills",
+					shape: "directory",
+					kind: "skill"
+				}
+			]
+		},
+		user: { detect: ".cursor" }
+	},
+	{
+		name: "codex",
+		project: {
+			detect: ".codex",
+			mcpConfig: {
+				path: ".codex/config.toml",
+				key: "mcp_servers",
+				format: "toml"
+			},
+			nonstandard: [{
+				path: ".codex/skills",
+				shape: "directory",
+				kind: "skill"
+			}]
+		},
+		user: { detect: ".codex" }
+	},
+	{
+		name: "copilot-cli",
+		project: {
+			detect: ".github/skills",
+			nonstandard: [
+				{
+					path: ".github/copilot-instructions.md",
+					shape: "file",
+					kind: "instructions"
+				},
+				{
+					path: ".github/instructions",
+					shape: "directory",
+					kind: "instructions"
+				},
+				{
+					path: ".github/skills",
+					shape: "directory",
+					kind: "skill"
+				}
+			]
+		},
+		user: { detect: ".copilot" }
+	},
+	{
+		name: "gemini-cli",
+		project: {
+			detect: ".gemini",
+			instructionBridge: {
+				kind: "settings-entry",
+				path: ".gemini/settings.json",
+				key: "context.fileName"
+			},
+			mcpConfig: {
+				path: ".gemini/settings.json",
+				key: "mcpServers",
+				format: "json",
+				shared: true
+			},
+			nonstandard: [{
+				path: "GEMINI.md",
+				shape: "file",
+				kind: "instructions"
+			}, {
+				path: ".gemini/skills",
+				shape: "directory",
+				kind: "skill"
+			}]
+		},
+		user: { detect: ".gemini" }
+	},
+	{
+		name: "devin-desktop",
+		project: { detect: ".devin" }
+	},
+	{
+		name: "windsurf",
+		project: {
+			detect: ".windsurf",
+			skillsDirectory: ".windsurf/skills",
+			nonstandard: [{
+				path: ".windsurfrules",
+				shape: "file",
+				kind: "instructions"
+			}, {
+				path: ".windsurf/rules",
+				shape: "directory",
+				kind: "rule"
+			}]
+		},
+		deprecated: "devin-desktop"
+	}
+];
+const harnessNames = new Set(harnessRegistry.map((harness) => harness.name));
+function isHarnessName(value) {
+	return harnessNames.has(value);
+}
+/**
+* The `--harness` option, as names this registry knows. Both commands take the option and neither
+* owns what a name means, so the parse lives beside the list it validates against: a harness added
+* to the registry is accepted by both commands with nothing else to change, and the rejection reads
+* the same either way.
+*
+* An unknown name throws rather than being dropped. A caller that asked for a harness by name and
+* got a report about the two default ones has been told the wrong thing about their repository.
+*/
+function parseHarnesses(value) {
+	const requested = (value ?? "").split(",").map((name) => name.trim()).filter(Boolean);
+	const unsupported = requested.filter((name) => !isHarnessName(name));
+	if (unsupported.length) throw new Error(`Unsupported harness: ${unsupported.join(", ")}. Supported: ${harnessRegistry.map((harness) => harness.name).join(", ")}.`);
+	return requested.filter(isHarnessName);
+}
+/** 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.project.detect)));
+}
+//#endregion
+//#region src/diagnose-bridges/locator.ts
+/** The locator as one string: the finding's `path`, and what a repair names. */
+function locatorText({ file, server, field, position }) {
+	if (position) return `${file}#L${position.line}:${position.column}`;
+	if (server === void 0) return file;
+	return `${file}#servers.${server}${field === void 0 ? "" : `.${field}`}`;
+}
+//#endregion
+//#region src/diagnose-bridges/doctor-guidance.ts
+/**
+* A table as the list `doctor` reports, in the order it was written. The keys of a
+* `Record<P, RepairRow>` are `P` by construction, which is what the assertion says; nothing here
+* claims a row exists.
+*/
+function repairsOf(table) {
+	return Object.entries(table).map(([problem, row]) => ({
+		problem,
+		...row
+	}));
+}
+/** How the command names itself. */
+const commandInvocation = "buddy-agent-harness";
+/**
+* How a skill invokes the command. A skill may run without the binary on PATH, so it goes through
+* `npx`, pinned to the caret range of the version that generated the skill.
+*
+* The pin is what makes the shipped guidance honest. A skill states the findings and flags of the
+* version it was generated from, so an unpinned `npx` — which resolves whatever is latest — can
+* hand an agent a table that does not describe the CLI it just ran. The caret keeps patches
+* flowing and stops at the next breaking line.
+*/
+const skillInvocation = (version) => `npx -y ${commandInvocation}@^${version}`;
+/**
+* The launcher a skill ships, named for the subcommand it runs so a stack trace or a process list
+* says which one it was. One script per command, beside the `SKILL.md` that documents it.
+*/
+const launcherFor = (subcommand) => `scripts/${subcommand}.mjs`;
+/**
+* How a skill names its launcher: the path as the skill sees it, resolved by the agent against the
+* directory it read the `SKILL.md` from.
+*
+* `node` stays in front. The launcher ships without an executable bit, and its shebang does nothing
+* on Windows, so naming the file alone would not run it.
+*/
+const launcherInvocation = (subcommand) => `node ${launcherFor(subcommand)}`;
+/**
+* How the skill hands a repair to `repair`. Bridge and instruction repairs go to `init`, which
+* writes both kinds of bridge in the first place; configuration that is present and wrong goes
+* here, because no `init` flag corrects a file the user already wrote.
+*/
+const repairSkillInvocation = "/buddy-agent-harness:repair";
+/** How the skill hands a repair back to `init`. */
+const initSkillInvocation = "/buddy-agent-harness:init";
+/** Where the user authors the golden MCP server set, named in every MCP repair that points at it. */
+const goldenSet = ".agents/buddy-agent-harness/mcp.toml";
+/** The skills bridges, reported in `bridges`. */
+const bridgeTable = {
+	"no-canonical": {
+		detail: "the canonical skill directory does not exist, so no bridge can resolve",
+		repair: (_at, cli) => ({
+			command: `${cli} init`,
+			instruction: `run \`${cli} init\` to create .agents/skills and the bridges into it`
+		}),
+		skillRepair: () => `run \`${initSkillInvocation}\`, which creates \`.agents/skills\` and the bridges`
+	},
+	missing: {
+		detail: "no bridge at this path — the harness sees zero project skills",
+		repair: ({ file }, cli) => ({
+			command: `${cli} init`,
+			instruction: `run \`${cli} init\` to create the bridge at ${file}`
+		}),
+		skillRepair: () => `run \`${initSkillInvocation}\``
+	},
+	degraded: {
+		detail: "expected a directory but found a regular file — checkout without core.symlinks",
+		repair: ({ file }, cli) => ({
+			command: `${cli} init --copy --force ${file}`,
+			instruction: `run \`${cli} init --copy --force ${file}\` to rebuild ${file} as a real directory`
+		}),
+		skillRepair: ({ file }) => `run \`${initSkillInvocation} --copy --force ${file}\``
+	},
+	stale: {
+		detail: "symlink does not resolve to .agents/skills",
+		repair: ({ file }, cli) => ({
+			command: `${cli} init --force ${file}`,
+			instruction: `run \`${cli} init --force ${file}\` to repoint ${file} at .agents/skills`
+		}),
+		skillRepair: ({ file }) => `run \`${initSkillInvocation} --force ${file}\``
+	},
+	"diverged-bridge": {
+		detail: "only the bridge changed since the two last agreed — an agent wrote through the copy",
+		repair: ({ file }, cli) => ({
+			command: "",
+			instruction: `replace .agents/skills with ${file} to keep the newer edit, then run \`${cli} init --force ${file}\``
+		}),
+		skillRepair: ({ file }) => `replace .agents/skills with ${file} to keep the newer edit, then run \`${initSkillInvocation} --force ${file}\``
+	},
+	"diverged-canonical": {
+		detail: "only .agents/skills changed since the two last agreed — the copy is stale",
+		repair: ({ file }, cli) => ({
+			command: `${cli} init --copy --force ${file}`,
+			instruction: `run \`${cli} init --copy --force ${file}\` to rebuild ${file} from the newer .agents/skills`
+		}),
+		skillRepair: ({ file }) => `run \`${initSkillInvocation} --copy --force ${file}\``
+	},
+	"diverged-both": {
+		detail: "both sides changed since they last agreed — rebuilding would discard one of them",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `reconcile .agents/skills with ${file} by hand — rebuilding would discard one of them; \`git diff --no-index .agents/skills ${file}\` shows what differs`
+		}),
+		skillRepair: ({ file }) => `run \`git diff --no-index .agents/skills ${file}\` and reconcile by hand`
+	},
+	"diverged-unknown": {
+		detail: "contents differ and no commit where they agreed was found — which side moved is unknown",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `reconcile .agents/skills with ${file} by hand — which side moved is unknown; \`git diff --no-index .agents/skills ${file}\` shows what differs`
+		}),
+		skillRepair: ({ file }) => `run \`git diff --no-index .agents/skills ${file}\` and reconcile by hand`
+	},
+	"unpinned-copy": {
+		detail: "tracked copy without the skip-worktree bit — the tree is dirty with content that must not be committed",
+		repair: ({ file }) => ({
+			command: `git ls-files -z ${file} | xargs -0 git update-index --skip-worktree`,
+			instruction: `run \`git ls-files -z ${file} | xargs -0 git update-index --skip-worktree\` to restore the skip-worktree bit`
+		}),
+		skillRepair: ({ file }) => `run \`git ls-files -z ${file} | xargs -0 git update-index --skip-worktree\``
+	}
+};
+const bridgeRepairs = repairsOf(bridgeTable);
+/**
+* The instruction bridges, reported in `instructions`. Every repair is the `init` skill: these are
+* files a person wrote, or files carrying content beside the bridge, and deciding what to preserve
+* while restoring the bridge is judgment no flag carries. `repair` therefore names the skill in
+* both places rather than pretending a shell command exists.
+*/
+const instructionTable = {
+	"no-instructions": {
+		detail: "no AGENTS.md at the repository root, so every instruction bridge points at nothing",
+		repair: () => ({
+			command: "",
+			instruction: `hand this to \`${initSkillInvocation}\`, which derives AGENTS.md and the bridges to it`
+		}),
+		skillRepair: () => `run \`${initSkillInvocation}\`, which derives AGENTS.md and the bridges to it`
+	},
+	"instructions-missing": {
+		detail: "no instruction bridge at this path — the harness reads none of AGENTS.md",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `hand ${file} to \`${initSkillInvocation}\`, which writes the bridge into it`
+		}),
+		skillRepair: () => `run \`${initSkillInvocation}\``
+	},
+	"instructions-unbridged": {
+		detail: "the file is present but names AGENTS.md nowhere — the harness reads none of it",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `hand ${file} to \`${initSkillInvocation}\`, which adds the bridge without discarding what the file already says`
+		}),
+		skillRepair: () => `run \`${initSkillInvocation}\`, which adds the bridge without discarding what the file already says`
+	},
+	"instructions-unreadable": {
+		detail: "the settings file does not parse, so the harness reads none of it",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `fix the JSON in ${file} by hand, then hand it to \`${initSkillInvocation}\``
+		}),
+		skillRepair: () => `fix the JSON by hand, then run \`${initSkillInvocation}\``
+	}
+};
+const instructionRepairs = repairsOf(instructionTable);
+/**
+* Configuration that is present and wrong. Detected here like everything else, but repaired by the
+* `repair` skill rather than by `init` — which is why it is a section of its own.
+*/
+const configurationTable = {
+	"deprecated-harness": {
+		detail: "a projection under a harness name that has been superseded — the replacement reads .agents/skills natively and needs no projection at all",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `remove ${file} and enable the harness that replaced it — \`${repairSkillInvocation}\` offers the correction`
+		}),
+		skillRepair: () => `run \`${repairSkillInvocation}\``
+	},
+	"ignored-bridge": {
+		detail: "a .gitignore rule matches this bridge — an untracked bridge swallows a real edit silently",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `narrow or remove the .gitignore rule matching ${file} — \`${repairSkillInvocation}\` offers the correction`
+		}),
+		skillRepair: () => `run \`${repairSkillInvocation}\``
+	},
+	"unread-local-override": {
+		detail: "no harness reads this filename, so everything in it is invisible to every agent",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `move ${file} to CLAUDE.local.md, or consolidate it into AGENTS.md — \`${repairSkillInvocation}\` offers the correction`
+		}),
+		skillRepair: () => `run \`${repairSkillInvocation}\``
+	},
+	"unloadable-skill": {
+		detail: "frontmatter that does not parse, or no description — either one makes a harness skip the skill outright",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `quote the description in ${file}, or add one — \`${repairSkillInvocation}\` offers the correction`
+		}),
+		skillRepair: () => `run \`${repairSkillInvocation}\``
+	}
+};
+repairsOf(configurationTable);
+/**
+* The golden MCP server set against the harness copies of it.
+*
+* Every repair names a **locator** rather than a file — `.cursor/mcp.json#servers.linear.command` —
+* because a file holding twenty servers is not an address. The locator never carries a value: not
+* a whole one, and not a prefix. `doctor` is safe to run from a session-start hook, so a value it
+* echoes lands in agent context on every session and from there into transcripts, and `sk-ab…`
+* leaks into exactly the same place the whole string would.
+*/
+const mcpTable = {
+	"mcp-golden-unreadable": {
+		detail: "the golden MCP set does not parse — the locator gives the line and column, and nothing else can be said about it",
+		repair: (at) => ({
+			command: "",
+			instruction: `fix the TOML at ${locatorText(at)}`
+		}),
+		skillRepair: (at) => `fix the TOML at ${locatorText(at)} by hand — the reported line and column are all that can be quoted, because the parser's own message repeats the offending line and that line is the one holding the credential`
+	},
+	"mcp-target-unreadable": {
+		detail: "this harness config does not parse, so the harness starts none of its servers and nothing in it can be compared",
+		repair: (at) => ({
+			command: "",
+			instruction: `fix the syntax of ${locatorText(at)}`
+		}),
+		skillRepair: (at) => `fix the syntax of ${locatorText(at)} by hand`
+	},
+	"mcp-unprojected": {
+		detail: "the golden set declares this server and the harness config does not carry it",
+		repair: ({ file, server }) => ({
+			command: "",
+			instruction: `add the server ${server} to ${file}, or drop it from the golden set`
+		}),
+		skillRepair: (at) => `add the server at ${locatorText(at)} to that file from its golden entry, or drop it from the golden set`
+	},
+	"mcp-undeclared": {
+		detail: "the harness config carries this server and the golden set does not declare it",
+		repair: ({ file, server }) => ({
+			command: "",
+			instruction: `add the server ${server} to ${goldenSet}, or drop it from ${file}`
+		}),
+		skillRepair: (at) => `copy the server at ${locatorText(at)} into ${goldenSet}, refusing any literal credential it carries, or drop it from ${at.file}`
+	},
+	"mcp-diverged-target": {
+		detail: "only the harness config changed since the two last agreed — the edit was made through the copy",
+		repair: (at) => ({
+			command: "",
+			instruction: `reconcile the value at ${locatorText(at)} back into ${goldenSet}`
+		}),
+		skillRepair: (at) => `reconcile the value at ${locatorText(at)} back into ${goldenSet}, field by field`
+	},
+	"mcp-diverged-golden": {
+		detail: "only the golden set changed since the two last agreed — the harness copy is stale",
+		repair: (at) => ({
+			command: "",
+			instruction: `update ${locatorText(at)} from the golden entry`
+		}),
+		skillRepair: (at) => `update ${locatorText(at)} from the golden entry`
+	},
+	"mcp-diverged-both": {
+		detail: "both sides changed since they last agreed — merging either way would discard the other",
+		repair: (at) => ({
+			command: "",
+			instruction: `reconcile ${locatorText(at)} against ${goldenSet} by hand`
+		}),
+		skillRepair: (at) => `reconcile ${locatorText(at)} against ${goldenSet} by hand — never merge a three-way conflict automatically`
+	},
+	"mcp-diverged-unknown": {
+		detail: "the two disagree and no baseline says which side moved — neither history nor a last-projected record covers this server",
+		repair: (at) => ({
+			command: "",
+			instruction: `compare ${locatorText(at)} against ${goldenSet} by hand`
+		}),
+		skillRepair: (at) => `compare ${locatorText(at)} against ${goldenSet} by hand`
+	},
+	"mcp-literal-secret": {
+		detail: "a credential-bearing field holds a literal rather than a reference to an environment variable",
+		repair: (at) => ({
+			command: "",
+			instruction: `move the value at ${locatorText(at)} into an environment variable and reference it`
+		}),
+		skillRepair: (at) => `move the value at ${locatorText(at)} into an environment variable and reference it — read the value from the file, never from this report, and never repeat it back`
+	},
+	"mcp-committed-secret": {
+		detail: "a credential-bearing field holds a literal in a git-tracked file — the credential is committed, and moving it does not un-commit it",
+		repair: (at) => ({
+			command: "",
+			instruction: `rotate the credential behind ${locatorText(at)}, then reference it from an environment variable`
+		}),
+		skillRepair: (at) => `rotate the credential behind ${locatorText(at)} at its issuer, then reference it from an environment variable — it is in the repository's history, so moving it is not enough`
+	}
+};
+repairsOf(mcpTable);
+/**
+* Configuration only one harness can read. Every repair here is a **conversion**, and every one of
+* them is the `init` skill's: consolidating what a repository already has is exactly its remit, and
+* the content is the user's, so it is offered and never written on sight. `repair` owns none of
+* them — it corrects configuration that is wrong, and none of this is wrong.
+*
+* `nonstandard-subagent` is the exception that names no owner. There is no cross-harness subagent
+* format to convert to, so the honest report is that the gap exists, not a repair that cannot run.
+*/
+const nonstandardTable = {
+	"nonstandard-instructions": {
+		detail: "instruction content only one harness reads — AGENTS.md carries the same prose to all of them",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `consolidate ${file} into AGENTS.md and leave a generated bridge in its place — \`${initSkillInvocation}\` offers the consolidation`
+		}),
+		skillRepair: ({ file }) => `hand ${file} to \`${initSkillInvocation}\`, which consolidates it into AGENTS.md`
+	},
+	"nonstandard-rule": {
+		detail: "a path-scoped rule only one harness reads — a skill reaches every harness where the scoping is incidental",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `convert ${file} into a skill under .agents/skills where its guidance is not tied to the paths it names — \`${initSkillInvocation}\` offers the conversion; keep it where the path scoping is the point`
+		}),
+		skillRepair: ({ file }) => `hand ${file} to \`${initSkillInvocation}\` to convert into a skill, unless the path scoping is load-bearing`
+	},
+	"nonstandard-command": {
+		detail: "a harness command file — a skill is the portable form, and this harness reads skills too",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `move ${file} to .agents/skills/<name>/SKILL.md — \`${initSkillInvocation}\` offers the move`
+		}),
+		skillRepair: ({ file }) => `hand ${file} to \`${initSkillInvocation}\`, which moves it to .agents/skills`
+	},
+	"nonstandard-skill": {
+		detail: "a skill under a harness directory rather than the canonical one, where only that harness finds it",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `move ${file} to .agents/skills and project it back where the harness needs one — \`${initSkillInvocation}\` offers the move`
+		}),
+		skillRepair: ({ file }) => `hand ${file} to \`${initSkillInvocation}\`, which moves it to .agents/skills`
+	},
+	"nonstandard-subagent": {
+		detail: "a subagent definition with no cross-harness form — nothing outside this harness can read it, and no canonical form exists yet",
+		repair: ({ file }) => ({
+			command: "",
+			instruction: `leave ${file} where it is and record that it reaches one harness only — no portable form exists to convert it to`
+		}),
+		skillRepair: ({ file }) => `leave ${file} in place — no portable form exists yet, so this is work for a person rather than a skill`
+	}
+};
+repairsOf(nonstandardTable);
+/**
+* All five sections, in the order `doctor` reports them. Annotated over the whole union rather than
+* inferred, so a problem added to any of the four fails here too if its section was left alone.
+*/
+const doctorTable = {
+	...bridgeTable,
+	...instructionTable,
+	...configurationTable,
+	...mcpTable,
+	...nonstandardTable
+};
+const doctorRepairs = repairsOf(doctorTable);
+/** The repair for one problem. Total by construction: the table is keyed by the union. */
+function repairFor(problem) {
+	return {
+		problem,
+		...doctorTable[problem]
+	};
+}
+const doctorSkill = {
+	name: "doctor",
+	description: "Use this skill when a repository loads no project skills, when skills are missing after a clone, when a harness appears to be ignoring AGENTS.md, or when checking whether the agent configuration bridges into .claude/skills, CLAUDE.md, and the other harness files 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-skills.ts. Do not edit by hand. -->";
+/**
+* The shipped `doctor` skill, rendered from the same table the command prints. `version` is the
+* package version the skill ships with; it pins the `npx` invocation so the table and the CLI that
+* produced it stay on the same breaking line.
+*
+* The finding tables are NOT here. They live in the reference pages below, and this file carries
+* only what every reader needs: how to run it, how to read the report, and where to go next.
+*/
+function renderDoctorSkill(version) {
+	return `---
+name: ${doctorSkill.name}
+description: ${doctorSkill.description}
+---
+
+${generatedSkillWarning}
+
+# Harness Doctor
+
+A repository keeps one canonical configuration: \`.agents/skills\` for its skills and \`AGENTS.md\` for its instructions. Harnesses that cannot read those get bridges pointing at them: Claude Code needs both, and Gemini CLI needs the instruction bridge only — it reads \`.agents/skills\` itself. A bridge that stops resolving is silent: the harness finds nothing and loads zero project skills, with no warning anywhere. An instruction bridge fails the same way and costs more, because the harness then reads none of the repository's instructions at all.
+
+Diagnose it:
+
+\`\`\`sh
+${launcherInvocation("doctor")}
+\`\`\`
+
+That path is relative to this skill's own directory. The launcher runs the CLI that shipped beside it against the current working directory, so nothing is downloaded. Fall back to \`${skillInvocation(version)} doctor\` when the launcher cannot be resolved or run, which is the case when the plugin was installed from git rather than npm and its dependencies were never installed.
+
+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 skills bridge \`init\` would create for this repository, each with a \`status\` of \`ok\`, \`missing\`, \`degraded\`, \`stale\`, or \`diverged\`.
+
+\`instructions\` lists every instruction bridge into \`AGENTS.md\`, with a \`status\` of \`ok\`, \`missing\`, \`unbridged\`, or \`unreadable\`. They are a separate section because nothing about them is shared: a different \`kind\`, a different status vocabulary, and a repair that is never a command.
+
+\`findings\` explains each problem and carries more than the two sections above: the configuration, MCP, and non-standard findings have no section of their own, because they are about files rather than about bridges. \`help\` carries each repair, one row per distinct repair, with two columns:
+
+- \`command\` — a shell invocation that, run exactly as given, **completes** the repair.
+- \`instruction\` — the same repair in the imperative, always present and complete on its own.
+
+\`command\` is empty whenever no single invocation does the job, and that emptiness is the signal: act on \`instruction\` and do not assemble a command out of it. A runnable invocation quoted *inside* an \`instruction\` is not the repair either — \`diverged-both\` names \`git diff --no-index\` because the diff shows you what differs, not because running it reconciles anything. Apply the repair, then re-run \`doctor\`.
+
+Nothing in \`help\` is wrapped. An earlier version prefixed every repair with \`Run\`, which read as an instruction to paste prose into a shell.
+
+Do not run an \`init\` command yourself. Rebuilding a skills bridge can move skills a user wrote, and rewriting an instruction file touches prose a person authored — both are the \`init\` skill's judgment, so hand the repair to \`${initSkillInvocation}\` instead. Every such repair carries an empty \`command\`: a skill invocation has no shell equivalent at all.
+
+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\`.
+
+## Where the detail is
+
+Every \`problem\` name routes to exactly one page. Load the page for the finding in front of you and leave the rest unread — the tables are long, and reading four families to act on one is what this split exists to stop.
+
+| Page | Load it for |
+| --- | --- |
+| \`references/bridges.md\` | any \`bridges\` row that is not \`ok\` |
+| \`references/instructions.md\` | any \`instructions\` row that is not \`ok\` |
+| \`references/configuration.md\` | a finding about the configuration around the bridges rather than a bridge |
+| \`references/mcp.md\` | any finding whose path is an MCP locator — **always** before acting on a credential finding |
+| \`references/nonstandard.md\` | a finding about configuration only one harness can read |
+| \`references/harnesses/<name>.md\` | the paths and files one named harness uses |
+
+## 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.
+- Never repeat a value from a file an \`mcp-literal-secret\` or \`mcp-committed-secret\` finding points at. The report withheld it on purpose, and quoting it back puts it in the transcript anyway.
+- Write instructions in \`AGENTS.md\`, never in \`CLAUDE.md\`. A bridge file holds the import and any harness-specific notes; content written there reaches one harness and drifts from the canonical file.
+`;
+}
+//#endregion
+//#region src/diagnose-configuration/diagnose-configuration.ts
+const canonicalSkills = ".agents/skills";
+const localOverride = "AGENTS.local.md";
+/**
+* The two frontmatter faults that make a harness skip a skill outright, per
+* `skills/init/references/frontmatter.md`: YAML that does not parse, and a missing `description`.
+* A `name` that mismatches the directory is a warning and still loads, so it is not reported here.
+*
+* The unquoted colon is the documented cause of the first, and is checked directly rather than by
+* parsing YAML: the package ships no parser, and a targeted check names the actual fault.
+*/
+function frontmatterFault(body) {
+	const block = /^---\n([\s\S]*?)\n---/.exec(body);
+	if (!block) return "unparseable";
+	const value = /^description:[ \t]*(.*)$/m.exec(block[1])?.[1]?.trim();
+	if (!value) return "no-description";
+	if (!/^(['"]).*\1$/.test(value) && /:\s/.test(value)) return "unparseable";
+}
+/**
+* Unlike `diagnoseBridges`, this takes no harness preference. Every check here requires the
+* projection to exist on disk, and a projection cannot exist without its harness's detection
+* directory — which selects that harness anyway. A preference could therefore never add a finding,
+* so accepting one would be surface that does nothing.
+*/
+function diagnoseConfiguration({ root, git, cli }) {
+	const findings = [];
+	const add = (path, problem) => {
+		const { detail, repair } = repairFor(problem);
+		findings.push({
+			path,
+			problem,
+			detail,
+			repair: repair({ file: path }, cli)
+		});
+	};
+	const harnesses = selectHarnesses(root, []);
+	for (const harness of harnesses) {
+		const projection = harness.project.skillsDirectory;
+		if (harness.deprecated && projection && existsSync(join(root, projection))) add(projection, "deprecated-harness");
+	}
+	for (const harness of harnesses) {
+		const path = harness.project.skillsDirectory;
+		if (path && existsSync(join(root, path)) && git.isIgnored(path)) add(path, "ignored-bridge");
+	}
+	if (existsSync(join(root, localOverride))) add(localOverride, "unread-local-override");
+	for (const file of filesUnder(join(root, canonicalSkills)).filter((file) => file.endsWith("SKILL.md"))) if (frontmatterFault(readFileSync(join(root, canonicalSkills, file), "utf8"))) add(`${canonicalSkills}/${file}`, "unloadable-skill");
+	return findings;
+}
+//#endregion
+//#region src/diagnose-bridges/json-with-comments.ts
+/**
+* `.gemini/settings.json` may legally carry comments — the Gemini CLI loader strips them before
+* parsing. A plain `JSON.parse` of a valid settings file therefore throws, and `doctor` would report
+* a working bridge as unreadable. Comments are removed before parsing for that reason.
+*
+* Only comments. A trailing comma stays a parse error, because nothing documents it as accepted.
+*/
+function stripJsonComments(source) {
+	let output = "";
+	let index = 0;
+	let inString = false;
+	let escaped = false;
+	while (index < source.length) {
+		const character = source[index];
+		if (inString) {
+			output += character;
+			if (escaped) escaped = false;
+			else if (character === "\\") escaped = true;
+			else if (character === "\"") inString = false;
+			index += 1;
+			continue;
+		}
+		if (character === "\"") {
+			inString = true;
+			output += character;
+			index += 1;
+			continue;
+		}
+		if (character === "/" && source[index + 1] === "/") {
+			while (index < source.length && source[index] !== "\n") index += 1;
+			continue;
+		}
+		if (character === "/" && source[index + 1] === "*") {
+			index += 2;
+			while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) index += 1;
+			index += 2;
+			continue;
+		}
+		output += character;
+		index += 1;
+	}
+	return output;
+}
+/** The parsed value, or `undefined` when the file is not JSON even once its comments are gone. */
+function parseJsonWithComments(source) {
+	try {
+		return JSON.parse(stripJsonComments(source));
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/diagnose-mcp/mcp-model.ts
+/** Every field of the model, in the order a finding reports them. */
+const mcpFields = [
+	"transport",
+	"command",
+	"args",
+	"env",
+	"url",
+	"headers",
+	"description",
+	"enabled",
+	"timeout",
+	"source"
+];
+/** The two fields holding one value per name rather than a single value. */
+const mapFields = /* @__PURE__ */ new Set(["env", "headers"]);
+/**
+* Whether two values of the same field agree. Arrays are ordered — `args` is a command line, and
+* reordering it changes what runs. Maps are not, so they are compared by their sorted entries.
+*/
+function sameValue(field, left, right) {
+	if (mapFields.has(field) && isRecord(left) && isRecord(right)) {
+		const keys = Object.keys(left);
+		return keys.length === Object.keys(right).length && keys.every((key) => left[key] === right[key]);
+	}
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+/**
+* The fields on which a target disagrees with the golden set.
+*
+* Asymmetric by design, and this is the rule that keeps a golden set from accumulating noise. A
+* field the golden set leaves unset is never a difference, however the target fills it: a host
+* restating its own default and a user's deliberate edit are indistinguishable in that position,
+* and pulling both back would grow the golden set on every round-trip. The golden set speaks only
+* about what it says.
+*
+* `env` and `headers` are compared per name for the same reason — a variable only the target sets
+* is that target's business, and one the golden set names must match.
+*/
+function divergingFields(golden, target) {
+	return mcpFields.filter((field) => {
+		const declared = golden[field];
+		if (declared === void 0) return false;
+		if (mapFields.has(field) && isRecord(declared) && isRecord(target[field])) {
+			const observed = target[field];
+			return Object.keys(declared).some((key) => declared[key] !== observed[key]);
+		}
+		return !sameValue(field, declared, target[field]);
+	});
+}
+/** Whether one field of two models agrees, for naming the side that moved. */
+function sameField(field, left, right) {
+	return sameValue(field, left?.[field], right?.[field]);
+}
+//#endregion
+//#region src/diagnose-mcp/mcp-sources.ts
+/** Where the golden set lives, and why it is namespaced rather than sitting at `.agents/mcp.json`. */
+const goldenSetPath = ".agents/buddy-agent-harness/mcp.toml";
+/** The table the golden set keeps its servers under. */
+const goldenKey = "servers";
+function stringMap(value) {
+	if (!isRecord(value)) return void 0;
+	const entries = Object.entries(value).filter(([, item]) => typeof item === "string");
+	return entries.length ? Object.fromEntries(entries) : void 0;
+}
+const transports = /* @__PURE__ */ new Set([
+	"stdio",
+	"http",
+	"sse"
+]);
+/**
+* The transport a host entry describes. Hosts spell it `type` (Claude Code, VS Code) or
+* `transport`, and several state it nowhere and leave it implied by which of `url` and `command`
+* is present. Inferring it is what lets a `url` entry in one file compare equal to a `type: http`
+* entry in another.
+*/
+function transportOf(entry) {
+	const declared = entry["type"] ?? entry["transport"];
+	if (typeof declared === "string" && transports.has(declared)) return declared;
+	if (typeof entry["url"] === "string") return "http";
+	if (typeof entry["command"] === "string") return "stdio";
+}
+/**
+* One host entry, or one golden entry, in the canonical model. The two formats carry the same
+* field names — the divergence between hosts is the file, the top-level key, and the serialization,
+* not the entry — so one reader serves both directions of the comparison.
+*
+* A field whose value is the wrong type is dropped rather than carried through. A `timeout` that
+* is a string is not a timeout, and letting it into the model would report a divergence whose real
+* cause is a typo the finding does not name.
+*/
+function serverFrom(entry) {
+	const args = Array.isArray(entry["args"]) && entry["args"].every((item) => typeof item === "string");
+	const transport = transportOf(entry);
+	const env = stringMap(entry["env"]);
+	const headers = stringMap(entry["headers"]);
+	return {
+		...transport ? { transport } : {},
+		...typeof entry["command"] === "string" ? { command: entry["command"] } : {},
+		...args ? { args: entry["args"] } : {},
+		...env ? { env } : {},
+		...typeof entry["url"] === "string" ? { url: entry["url"] } : {},
+		...headers ? { headers } : {},
+		...typeof entry["description"] === "string" ? { description: entry["description"] } : {},
+		...typeof entry["enabled"] === "boolean" ? { enabled: entry["enabled"] } : {},
+		...typeof entry["timeout"] === "number" ? { timeout: entry["timeout"] } : {},
+		...typeof entry["source"] === "string" ? { source: entry["source"] } : {}
+	};
+}
+function serversUnder(document, key) {
+	const table = isRecord(document) ? document[key] : void 0;
+	if (!isRecord(table)) return /* @__PURE__ */ new Map();
+	return new Map(Object.entries(table).filter(([, entry]) => isRecord(entry)).map(([name, entry]) => [name, serverFrom(entry)]));
+}
+/**
+* The position out of a thrown parse error, and nothing else out of it.
+*
+* `smol-toml` reports `line` and `column` on the error alongside a `codeblock` quoting the source,
+* and its `message` embeds that same code block. Both are unusable: in a file of MCP configuration
+* the line a parser failed on is exactly the line holding the credential. Only the two numbers are
+* read, and anything thrown that does not carry them is reported without a position rather than by
+* reaching for its message.
+*
+* Exported because that restriction is the point of the function rather than an implementation
+* detail of it, and it is verified directly.
+*/
+function positionOf(error) {
+	if (!isRecord(error)) return void 0;
+	const { line, column } = error;
+	return typeof line === "number" && typeof column === "number" ? {
+		line,
+		column
+	} : void 0;
+}
+/** The golden set, parsed. Absent is the common case and is not a fault. */
+function parseGoldenSet(source) {
+	if (source === void 0) return { kind: "absent" };
+	try {
+		return {
+			kind: "servers",
+			servers: serversUnder(parse(source), goldenKey)
+		};
+	} catch (error) {
+		return {
+			kind: "unreadable",
+			position: positionOf(error)
+		};
+	}
+}
+/**
+* One harness's MCP configuration, parsed. The file is read for its own key and nothing else:
+* `.gemini/settings.json` also carries the instruction bridge, and a reader that treated the whole
+* file as MCP would report the rest of a user's settings as servers it does not recognize.
+*
+* JSON is parsed with comments stripped, because Gemini CLI's loader strips them too and a
+* settings file may legally carry them.
+*/
+function parseTarget(config, source) {
+	if (source === void 0) return { kind: "absent" };
+	if (config.format === "toml") try {
+		return {
+			kind: "servers",
+			servers: serversUnder(parse(source), config.key)
+		};
+	} catch {
+		return { kind: "unreadable" };
+	}
+	const document = parseJsonWithComments(source);
+	if (document === void 0) return { kind: "unreadable" };
+	return {
+		kind: "servers",
+		servers: serversUnder(document, config.key)
+	};
+}
+//#endregion
+//#region src/diagnose-mcp/mcp-baseline.ts
+/** Where the record of what was last written to each target lives, beside the golden set it came from. */
+const projectionRecordPath = ".agents/buddy-agent-harness/mcp.projected.json";
+/**
+* The last-projected record: per target path, per server name, the model that was written there.
+*
+* It exists because git can only answer for a file it can see. Harnesses write their MCP
+* configuration themselves, at user scope, into files that are often untracked or ignored outright,
+* and for those "which side moved since they last agreed" has no answer in history. A record
+* written at projection time has one, exactly, because it *is* what was projected.
+*
+* A malformed record answers nothing rather than throwing. It is a cache of an answer, not the
+* answer, and a diagnosis that dies because its cache is corrupt is worse than one that says
+* `unknown`.
+*/
+function parseProjectionRecord(source) {
+	const document = source === void 0 ? void 0 : parseJsonWithComments(source);
+	const targets = isRecord(document) ? document["targets"] : void 0;
+	if (!isRecord(targets)) return /* @__PURE__ */ new Map();
+	return new Map(Object.entries(targets).filter(([, servers]) => isRecord(servers)).map(([path, servers]) => [path, new Map(Object.entries(servers).filter(([, server]) => isRecord(server)).map(([name, server]) => [name, server]))]));
+}
+/**
+* Which side moved, for one server and one field.
+*
+* The record is asked first, because it records exactly what was written and therefore answers
+* exactly. Where it holds nothing, a **tracked** target falls back to git: the newest commit where
+* the golden set and the target agreed on that field, then which working tree still matches it.
+* Where neither can answer, the direction is `unknown` and the finding says so — naming a side on a
+* guess would send a reconcile at the wrong file.
+*/
+var McpBaseline = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* One parse per commit per file, and one commit walk per target.
+	*
+	* `lastAgreed` runs per (config, server, field) that diverges without a projection record, and
+	* every one of those walks reads the same two files at the same commits. Unmemoized, three
+	* targets against five servers with two diverged fields each over fifty commits of history is
+	* three thousand `git show` calls and as many parses — on the command the `doctor` skill says is
+	* cheap enough for a session-start hook. One instance serves one diagnosis, so the memo lives and
+	* dies with it and can never answer for a working tree that has moved on.
+	*/
+	parsed = /* @__PURE__ */ new Map();
+	walked = /* @__PURE__ */ new Map();
+	directionOf(config, name, field, golden, target) {
+		const base = this.baseFor(config, name, field);
+		if (base === void 0) return "unknown";
+		const goldenMoved = !sameField(field, golden, base);
+		const targetMoved = !sameField(field, target, base);
+		if (goldenMoved && targetMoved) return "both";
+		return targetMoved ? "target" : "golden";
+	}
+	baseFor(config, name, field) {
+		const recorded = this.options.record.get(config.path)?.get(name);
+		if (recorded) return recorded;
+		return this.lastAgreed(config, name, field);
+	}
+	/**
+	* The newest committed state where both files described this field the same way. Read at model
+	* granularity rather than by comparing blobs: the two files never share bytes, and a commit that
+	* reformatted one of them did not change what it says.
+	*/
+	lastAgreed(config, name, field) {
+		for (const commit of this.commitsTouching(config)) {
+			const golden = this.parseAt(commit, goldenSetPath, parseGoldenSet);
+			const target = this.parseAt(commit, config.path, (source) => parseTarget(config, source));
+			if (golden.kind !== "servers" || target.kind !== "servers") continue;
+			const left = golden.servers.get(name);
+			const right = target.servers.get(name);
+			if (left && right && sameField(field, left, right)) return left;
+		}
+	}
+	commitsTouching(config) {
+		const walked = this.walked.get(config.path);
+		if (walked) return walked;
+		const commits = this.options.git.commitsTouching([goldenSetPath, config.path]);
+		this.walked.set(config.path, commits);
+		return commits;
+	}
+	parseAt(commit, path, parse) {
+		const key = `${commit}\u0000${path}`;
+		const parsed = this.parsed.get(key);
+		if (parsed) return parsed;
+		const result = parse(this.options.git.contentAt(commit, path));
+		this.parsed.set(key, result);
+		return result;
+	}
+};
+//#endregion
+//#region src/diagnose-mcp/mcp-secrets.ts
+/**
+* Finding a literal credential in MCP configuration, without ever handling one.
+*
+* `doctor` is safe to run from a session-start hook, so its output lands in agent context on every
+* session and from there into transcripts. A value it echoes is amplified far past the file it came
+* from. Every function here answers **where**, never **what**: the return is a field path, and the
+* value never leaves this module.
+*
+* That is also why the redaction lives here rather than in a formatter. `doctor` renders three ways
+* — TOON, `--format text`, and `--format json` — and trusting each of them to mask is three chances
+* to drift. A value that never enters the finding cannot be printed by any of them.
+*/
+/**
+* Words that mark a field as credential-bearing wherever they appear in its name. Each is one that
+* effectively never turns up inside an innocent word, so a bare substring test is safe and catches
+* the run-together spellings a segment test would miss — `MYTOKEN`, `githubsecret`.
+*/
+const credentialWord = /token|secret|password|passwd|credential/i;
+/**
+* Words that mark a field only when they are a **segment** of its name. `key` and `auth` are the
+* two that matter, and both are common inside words that carry nothing — `MONKEY`, `AUTHOR`,
+* `KEYSTONE_URL`. Matching them as substrings reports those, and a scanner that cries wolf on a
+* hook-run command is one people stop reading.
+*/
+const credentialSegment = /* @__PURE__ */ new Set([
+	"key",
+	"apikey",
+	"auth",
+	"authorization",
+	"bearer"
+]);
+/** A field name split the two ways these are written: `API_KEY` and `apiKey` alike. */
+function segmentsOf(key) {
+	return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((segment) => segment.toLowerCase());
+}
+/**
+* A value that **names** a secret instead of holding one, in the forms the supported hosts
+* document: `${VAR}`, `$VAR`, and the `${env:VAR}` / `${input:id}` variants.
+*
+* Classification is by shape, not by content. An entropy test on the value would be a guess about
+* a string this module has already decided not to look at, and it would fail in both directions —
+* a short password is low-entropy and a base64 configuration blob is high.
+*/
+const reference = /\$\{[^}]+\}|\$[A-Za-z_][A-Za-z0-9_]*/;
+/**
+* A credential-bearing field passes when it carries a reference anywhere in it, because the common
+* legitimate form is a template rather than a bare variable — `Bearer ${LINEAR_TOKEN}` is the
+* documented way to write an authorization header, and requiring the whole value to be a reference
+* would report every correct one.
+*/
+function holdsLiteral(value) {
+	return !reference.test(value);
+}
+function credentialKey(key) {
+	return credentialWord.test(key) || segmentsOf(key).some((segment) => credentialSegment.has(segment));
+}
+/**
+* Whether a URL carries a credential in itself. Two shapes: a password in the userinfo component,
+* and a credential-named query parameter holding a literal. Neither value is read past the test.
+*
+* A URL that does not parse is not reported. It is malformed rather than leaky, and guessing at its
+* structure with a regular expression is how a scanner starts matching the thing it must not touch.
+*/
+function urlHoldsCredential(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return false;
+	}
+	if (url.password) return true;
+	for (const [key, parameter] of url.searchParams) if (credentialKey(key) && holdsLiteral(parameter)) return true;
+	return false;
+}
+function literalsIn(field, values) {
+	return Object.entries(values ?? {}).filter(([key, value]) => credentialKey(key) && holdsLiteral(value)).map(([key]) => `${field}.${key}`);
+}
+/**
+* Every field of one server holding a literal credential, as a path within that server.
+*
+* The path is the whole answer. It is never a truncated value: `sk-ab…` is a leak into the same
+* transcript and buys a reader nothing the field name does not already give them.
+*/
+function credentialFields(server) {
+	return [
+		...literalsIn("env", server.env),
+		...literalsIn("headers", server.headers),
+		...server.url && urlHoldsCredential(server.url) ? ["url"] : []
+	];
+}
+//#endregion
+//#region src/diagnose-mcp/diagnose-mcp.ts
+function read(root, path) {
+	const absolute = join(root, path);
+	return existsSync(absolute) ? readFileSync(absolute, "utf8") : void 0;
+}
+/**
+* The distinct MCP files the enabled harnesses read. Two harnesses may name the same file.
+*
+* No harness preference is accepted, for the same reason the configuration half accepts none: every
+* harness documenting an MCP file is already selected without one. Claude Code and Cursor are
+* selected unconditionally; Codex and Gemini CLI keep their file inside their own detection
+* directory, so it cannot exist without that directory selecting them. A preference could never add
+* a finding.
+*/
+function targetsOf(root) {
+	const seen = /* @__PURE__ */ new Set();
+	return selectHarnesses(root, []).map((harness) => harness.project.mcpConfig).filter((config) => config !== void 0).filter((config) => !seen.has(config.path) && seen.add(config.path));
+}
+const divergence = {
+	target: "mcp-diverged-target",
+	golden: "mcp-diverged-golden",
+	both: "mcp-diverged-both",
+	unknown: "mcp-diverged-unknown"
+};
+function diagnoseMcp({ root, git, cli }) {
+	const findings = [];
+	const add = (at, problem) => {
+		const { detail, repair } = repairFor(problem);
+		findings.push({
+			path: locatorText(at),
+			problem,
+			detail,
+			repair: repair(at, cli)
+		});
+	};
+	/**
+	* Credentials are reported for every file that holds servers, the golden set included — a user
+	* pastes a token into whichever file is open, and the golden set is a file. Severity splits on
+	* tracking, because a literal in a tracked file is already a committed credential and moving it
+	* to an environment variable does not un-commit it.
+	*/
+	const reportSecrets = (path, servers) => {
+		const committed = git.trackingOf(path) !== "untracked";
+		for (const [name, server] of servers) for (const field of credentialFields(server)) add({
+			file: path,
+			server: name,
+			field
+		}, committed ? "mcp-committed-secret" : "mcp-literal-secret");
+	};
+	const targets = /* @__PURE__ */ new Map();
+	const configs = [];
+	for (const config of targetsOf(root)) {
+		const parsed = parseTarget(config, read(root, config.path));
+		if (parsed.kind === "unreadable") {
+			add({ file: config.path }, "mcp-target-unreadable");
+			continue;
+		}
+		if (parsed.kind === "absent") continue;
+		reportSecrets(config.path, parsed.servers);
+		targets.set(config.path, parsed.servers);
+		configs.push(config);
+	}
+	const golden = parseGoldenSet(read(root, goldenSetPath));
+	if (golden.kind === "unreadable") {
+		add({
+			file: goldenSetPath,
+			position: golden.position
+		}, "mcp-golden-unreadable");
+		return findings;
+	}
+	if (golden.kind === "absent") return findings;
+	reportSecrets(goldenSetPath, golden.servers);
+	const baseline = new McpBaseline({
+		git,
+		record: parseProjectionRecord(read(root, projectionRecordPath))
+	});
+	for (const config of configs) {
+		const servers = targets.get(config.path);
+		for (const [name, declared] of golden.servers) {
+			const carried = servers.get(name);
+			if (!carried) {
+				add({
+					file: config.path,
+					server: name
+				}, "mcp-unprojected");
+				continue;
+			}
+			for (const field of divergingFields(declared, carried)) add({
+				file: config.path,
+				server: name,
+				field
+			}, divergence[baseline.directionOf(config, name, field, declared, carried)]);
+		}
+		for (const name of servers.keys()) if (!golden.servers.has(name)) add({
+			file: config.path,
+			server: name
+		}, "mcp-undeclared");
+	}
+	return findings;
+}
+//#endregion
+//#region src/diagnose-nonstandard/diagnose-nonstandard.ts
+const problemOf = {
+	instructions: "nonstandard-instructions",
+	rule: "nonstandard-rule",
+	command: "nonstandard-command",
+	skill: "nonstandard-skill",
+	subagent: "nonstandard-subagent"
+};
+/**
+* A `.mdc` rule splits on whether its scoping is load-bearing. `globs:` with a value binds the rule
+* to paths, and `AGENTS.md` has no equivalent — it scopes by directory nesting only — so that one
+* converts to a skill, or stays. Without it the rule is always-on prose, which `AGENTS.md` holds
+* verbatim. Read from frontmatter rather than assumed, because the two need different conversions
+* and guessing wrong sends prose to the wrong destination.
+*/
+function scopedByGlobs(body) {
+	const block = /^---\n([\s\S]*?)\n---/.exec(body);
+	if (!block) return false;
+	const value = /^globs:[ \t]*(.*)$/m.exec(block[1])?.[1]?.trim();
+	return value !== void 0 && value.length > 0 && value !== "[]";
+}
+/** Every skill directory below `directory`, named by its `SKILL.md`. */
+function skillFiles(directory) {
+	return filesUnder(directory).filter((file) => file.endsWith("SKILL.md"));
+}
+/**
+* A harness directory that is a symlink is a projection someone already made, not configuration
+* authored here — reporting it would tell a repository to convert what it already converted.
+*/
+function authoredHere(path) {
+	try {
+		return !lstatSync(path).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+function artifactFiles(root, artifact) {
+	const absolute = join(root, artifact.path);
+	if (!authoredHere(absolute)) return [];
+	if (artifact.shape === "file") return [artifact.path];
+	return (artifact.kind === "skill" ? skillFiles(absolute) : filesUnder(absolute)).map((file) => posix.join(artifact.path, file));
+}
+/**
+* Unlike the other detectors this takes no harness preference and no enabled set. An artifact is
+* reachable by one harness whether or not that harness is enabled here — a `.cursorrules` in a
+* repository nobody opens in Cursor is still instruction content `AGENTS.md` does not carry — so
+* filtering by the enabled set would hide exactly the drift worth converting.
+*/
+function diagnoseNonstandard({ root, cli }) {
+	const findings = [];
+	for (const harness of harnessRegistry) for (const artifact of harness.project.nonstandard ?? []) for (const path of artifactFiles(root, artifact)) {
+		const kind = artifact.kind === "rule" && path.endsWith(".mdc") && !scopedByGlobs(readFileSync(join(root, path), "utf8")) ? "instructions" : artifact.kind;
+		const problem = problemOf[kind];
+		const { detail, repair } = repairFor(problem);
+		findings.push({
+			path,
+			problem,
+			detail,
+			repair: repair({ file: path }, cli)
+		});
+	}
+	return findings.sort((left, right) => left.path.localeCompare(right.path));
+}
+//#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;
+	}
+}
+/**
+* Whether `target` is a symbolic link that resolves to `canonical`. Resolved paths are compared
+* rather than link text, so a link a user wrote as an absolute path, one this tool wrote as a
+* Windows junction, and one reached through a symbolic link in a parent directory all read as the
+* correct bridge. A link that no longer resolves is not.
+*/
+function linksTo(target, canonical) {
+	try {
+		if (!lstatSync(target).isSymbolicLink()) return false;
+		return realpathSync(target) === realpathSync(canonical);
+	} catch {
+		return false;
+	}
+}
+/** Creates the canonical directory when absent, so a fresh repository reports zero skills. */
+function countSkills(canonicalSkills) {
+	mkdirSync(canonicalSkills, { recursive: true });
+	return skillNames(canonicalSkills).length;
+}
+/**
+* A junction is the only link Windows grants an unprivileged process, and Node resolves a relative
+* junction target against the process directory rather than the link's own, so Windows is given the
+* absolute path. Every other platform keeps the link relative, so it survives the repository moving.
+*/
+function linkTarget(target, canonicalSkills) {
+	return platform() === "win32" ? resolve(canonicalSkills) : relative(dirname(target), canonicalSkills);
+}
+/**
+* Translates what the option parser hands back into a selection. A valueless `--force` arrives as
+* the literal string `true` — that is how the parser encodes a flag given no value — and means
+* every conflicting target, which is what keeps an existing `init --force` doing what it always did.
+* Anything else is a comma-separated list of targets.
+*/
+function parseForce(value) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	return value.split(",").map((target) => target.trim()).filter((target) => target.length > 0);
+}
+/**
+* Targets are matched against what the caller typed, resolved against the repository root, so the
+* repo-relative form the conflict message prints is the form that selects it back — and an absolute
+* path naming the same directory selects it too.
+*/
+function namesTarget(root, target, given) {
+	return resolve(root, given) === resolve(target);
+}
+/**
+* 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.
+*/
+function projectSkills({ root, canonicalSkills, harnesses, copy, force }) {
+	const projections = harnesses.filter((harness) => harness.project.skillsDirectory).map((harness) => ({
+		harness,
+		target: join(root, harness.project.skillsDirectory)
+	}));
+	const named = Array.isArray(force) ? force : [];
+	const unknown = named.filter((given) => !projections.some(({ target }) => namesTarget(root, target, given)));
+	if (unknown.length) throw new Error(`No skill target matches:\n${unknown.map((given) => `- ${given}`).join("\n")}\nTargets for the enabled harnesses:\n${projections.map(({ target }) => `- ${relative(root, target)}`).join("\n")}`);
+	const forces = (target) => force === true || named.some((given) => namesTarget(root, target, given));
+	const blocked = projections.filter(({ target }) => pathOccupied(target) && !linksTo(target, canonicalSkills)).filter(({ target }) => !forces(target));
+	if (blocked.length && named.length === 0) throw new Error(`Refusing to replace existing skill targets:\n${blocked.map(({ target }) => `- ${relative(root, target)}`).join("\n")}`);
+	const skipped = new Set(blocked.map(({ harness }) => harness.name));
+	for (const { harness, target } of projections) {
+		if (skipped.has(harness.name)) continue;
+		mkdirSync(dirname(target), { recursive: true });
+		if (linksTo(target, canonicalSkills)) continue;
+		if (pathOccupied(target)) rmSync(target, {
+			recursive: true,
+			force: true
+		});
+		if (copy) {
+			cpSync(canonicalSkills, target, { recursive: true });
+			continue;
+		}
+		try {
+			symlinkSync(linkTarget(target, canonicalSkills), target, platform() === "win32" ? "junction" : void 0);
+		} catch (error) {
+			if (pathOccupied(target)) throw error;
+			cpSync(canonicalSkills, target, { recursive: true });
+		}
+	}
+	return {
+		linked: projections.filter(({ harness }) => !skipped.has(harness.name)).map(({ harness }) => harness.name),
+		skipped: projections.filter(({ harness }) => skipped.has(harness.name)).map(({ harness }) => harness.name)
+	};
+}
+//#endregion
+//#region src/diagnose-bridges/agents-files.ts
+/** Directories that never hold instructions this repository is responsible for bridging. */
+const pruned = /* @__PURE__ */ new Set(["node_modules"]);
+/**
+* Every directory below `root` holding an `AGENTS.md`, repository-relative and POSIX-separated,
+* with the root itself as `''`. Sorted, root first.
+*
+* Dot-directories are pruned along with `node_modules`. That is not only a speed measure:
+* `.agents/AGENTS.md` is canonical shared instructions rather than a subtree-scoped file, and
+* bridging it would claim a scope it does not have.
+*/
+function agentsFileDirectories(root) {
+	const found = [];
+	const walk = (relative) => {
+		if (existsSync(join(root, relative, "AGENTS.md"))) found.push(relative);
+		let entries;
+		try {
+			entries = readdirSync(join(root, relative), { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || entry.name.startsWith(".") || pruned.has(entry.name)) continue;
+			walk(relative ? posix.join(relative, entry.name) : entry.name);
+		}
+	};
+	walk("");
+	return found.sort();
+}
+//#endregion
+//#region src/diagnose-bridges/diagnose-instructions.ts
+const canonicalInstructions = "AGENTS.md";
+/**
+* An import bridges the `AGENTS.md` beside it and nothing else, so the check is per directory
+* holding one rather than per harness. A line of its own is enough: the harness reference allows
+* Claude-specific notes below the import, and a file that carries the import plus notes still
+* bridges.
+*/
+function inspectImport(target) {
+	let stats;
+	try {
+		stats = lstatSync(target);
+	} catch {
+		return {
+			kind: "none",
+			status: "missing",
+			problem: "instructions-missing"
+		};
+	}
+	if (stats.isSymbolicLink()) return readlinkSync(target) === "AGENTS.md" ? {
+		kind: "symlink",
+		status: "ok"
+	} : {
+		kind: "symlink",
+		status: "unbridged",
+		problem: "instructions-unbridged"
+	};
+	return readFileSync(target, "utf8").split("\n").some((line) => line.trim() === `@AGENTS.md`) ? {
+		kind: "import",
+		status: "ok"
+	} : {
+		kind: "file",
+		status: "unbridged",
+		problem: "instructions-unbridged"
+	};
+}
+/** Reads a dotted key out of parsed JSON without asserting anything about the rest of the file. */
+function valueAt(settings, key) {
+	return key.split(".").reduce((value, segment) => {
+		if (typeof value !== "object" || value === null) return void 0;
+		return value[segment];
+	}, settings);
+}
+function inspectSettingsEntry(target, key) {
+	let source;
+	try {
+		source = readFileSync(target, "utf8");
+	} catch {
+		return {
+			kind: "none",
+			status: "missing",
+			problem: "instructions-missing"
+		};
+	}
+	const settings = parseJsonWithComments(source);
+	if (settings === void 0) return {
+		kind: "file",
+		status: "unreadable",
+		problem: "instructions-unreadable"
+	};
+	const entry = valueAt(settings, key);
+	return Array.isArray(entry) && entry.includes("AGENTS.md") ? {
+		kind: "settings-entry",
+		status: "ok"
+	} : {
+		kind: "file",
+		status: "unbridged",
+		problem: "instructions-unbridged"
+	};
+}
+/** Every path an instruction bridge of this kind belongs at, in report order. */
+function pathsFor(root, bridge) {
+	if (bridge.kind !== "import") return [bridge.path];
+	return agentsFileDirectories(root).map((directory) => directory ? posix.join(directory, bridge.path) : bridge.path);
+}
+function inspect$1(target, bridge) {
+	return bridge.kind === "import" ? inspectImport(target) : inspectSettingsEntry(target, bridge.key);
+}
+/**
+* Reports whether every enabled harness can still read `AGENTS.md`.
+*
+* Losing one of these is quieter than losing a skills bridge and costs more: a harness with no
+* instruction bridge reads none of the repository's instructions, and says nothing about it. The
+* checks are read-only, and no repair is a command — rewriting an instruction file is the `init`
+* skill's judgment.
+*/
+function diagnoseInstructions(root, harnesses, cli) {
+	const bridged = harnesses.map((harness) => ({
+		name: harness.name,
+		bridge: harness.project.instructionBridge
+	})).filter((harness) => Boolean(harness.bridge));
+	const instructions = [];
+	const findings = [];
+	if (!bridged.length) return {
+		instructions,
+		findings
+	};
+	if (!agentsFileDirectories(root).includes("")) {
+		const { detail, repair } = repairFor("no-instructions");
+		findings.push({
+			path: canonicalInstructions,
+			problem: "no-instructions",
+			detail,
+			repair: repair({ file: canonicalInstructions }, cli)
+		});
+	}
+	for (const { name, bridge } of bridged) for (const path of pathsFor(root, bridge)) {
+		const inspection = inspect$1(join(root, path), bridge);
+		instructions.push({
+			harness: name,
+			path,
+			kind: inspection.kind,
+			status: inspection.status
+		});
+		if (inspection.problem) {
+			const { detail, repair } = repairFor(inspection.problem);
+			findings.push({
+				path,
+				problem: inspection.problem,
+				detail,
+				repair: repair({ file: path }, cli)
+			});
+		}
+	}
+	return {
+		instructions,
+		findings
+	};
+}
+//#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";
+	}
+	/**
+	* Whether a `.gitignore` rule matches this path. Asked of git rather than matched against the
+	* file, so a rule on a parent directory — the common way a bridge gets ignored — is caught.
+	* Outside a repository nothing is ignored, which is the same "cannot tell" degradation the rest
+	* of this class uses.
+	*/
+	isIgnored(path) {
+		if (this.prefix === void 0) return false;
+		return git(this.root, [
+			"check-ignore",
+			"-q",
+			"--",
+			path
+		]) !== void 0;
+	}
+	/**
+	* The newest commits that touched any of these paths, newest first. Empty outside a repository,
+	* which is the same "cannot tell" degradation as everything else here.
+	*
+	* Bounded like `lastAgreedTree` is: a baseline that is not in the recent history of the two files
+	* is not a baseline anyone can act on, and walking a whole repository to prove its absence costs
+	* more than the answer is worth.
+	*/
+	commitsTouching(paths) {
+		if (this.prefix === void 0) return [];
+		return lines(git(this.root, [
+			"rev-list",
+			"-n",
+			"200",
+			"HEAD",
+			"--",
+			...paths
+		]));
+	}
+	/** One file's content at one commit, or `undefined` when it did not exist there. */
+	contentAt(commit, path) {
+		if (this.prefix === void 0) return void 0;
+		return git(this.root, ["show", `${commit}:${this.prefix}${path}`]);
+	}
+	/**
+	* 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;
+	}
+}
+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 linksTo(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 this repository needs still resolves: the skills bridges into
+* `.agents/skills`, and the instruction bridges into `AGENTS.md`. 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 selected = selectHarnesses(root, preferred);
+	const bridged = selected.map((harness) => ({
+		name: harness.name,
+		skillsDirectory: harness.project.skillsDirectory
+	})).filter((harness) => Boolean(harness.skillsDirectory));
+	const bridges = [];
+	const divergence = [];
+	const findings = [];
+	if (!isDirectory(canonical)) {
+		const { detail, repair } = repairFor("no-canonical");
+		findings.push({
+			path: canonicalPath,
+			problem: "no-canonical",
+			detail,
+			repair: repair({ file: 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,
+				problem: inspection.problem,
+				detail,
+				repair: repair({ file: path }, cli)
+			});
+		}
+	}
+	const instructions = diagnoseInstructions(root, selected, cli);
+	findings.push(...instructions.findings);
+	return {
+		bridges,
+		instructions: instructions.instructions,
+		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 buildDoctorReport(bin, result, configuration = []) {
+	const findings = [...result.findings, ...configuration];
+	if (!findings.length) {
+		const count = result.bridges.length + result.instructions.length;
+		const bridges = count === 1 ? "the 1 bridge resolves" : `all ${count} bridges resolve`;
+		return {
+			bin,
+			bridges: result.bridges,
+			instructions: result.instructions,
+			findings: `0 problems found — ${bridges} and the configuration around them is current`
+		};
+	}
+	return {
+		bin,
+		bridges: result.bridges,
+		instructions: result.instructions,
+		...result.divergence.length ? { divergence: result.divergence } : {},
+		findings: findings.map(({ path, problem, detail }) => ({
+			path,
+			problem,
+			detail
+		})),
+		help: [...new Map(findings.map((finding) => [`${finding.repair.command}\u0000${finding.repair.instruction}`, finding.repair])).values()]
+	};
+}
+const doctorCommand = command({
+	name: "doctor",
+	description: "Report whether this repository's harness bridges still resolve — skills into .agents/skills, instructions into AGENTS.md. 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 harnesses = parseHarnesses(args.harness);
+			const root = args.root ?? process.cwd();
+			const result = diagnoseBridges({
+				root,
+				...harnesses.length ? { harnesses } : {},
+				cli: commandInvocation
+			});
+			const git = new GitBridgeState(root);
+			const configuration = [
+				...diagnoseConfiguration({
+					root,
+					git,
+					cli: commandInvocation
+				}),
+				...diagnoseMcp({
+					root,
+					git,
+					cli: commandInvocation
+				}),
+				...diagnoseNonstandard({
+					root,
+					cli: commandInvocation
+				})
+			];
+			writeResult(buildDoctorReport(binPath(homedir(), process.argv[1]), result, configuration), format);
+			return exitCodes.success;
+		} catch (error) {
+			process.stderr.write(`error: ${error instanceof Error ? error.message : "Harness diagnosis failed."}\n`);
+			return exitCodes.error;
+		}
+	}
+});
+//#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, skipped } = projectSkills({
+		root,
+		canonicalSkills,
+		harnesses,
+		copy,
+		force
+	});
+	return {
+		root,
+		harnesses: harnesses.map((harness) => harness.name),
+		native: harnesses.filter((harness) => !harness.project.skillsDirectory).map((harness) => harness.name),
+		linked,
+		skipped,
+		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. Names the targets to replace, comma-separated (e.g. .claude/skills); given alone it replaces every conflicting target.",
+			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 harnesses = parseHarnesses(args.harness);
+			writeResult(initializeHarnesses({
+				root: args.root ?? process.cwd(),
+				...harnesses.length ? { harnesses } : {},
+				...args.copy === void 0 ? {} : { copy: args.copy },
+				...args.force === void 0 ? {} : { force: parseForce(args.force) }
+			}), format);
+			return exitCodes.success;
+		} catch (error) {
+			process.stderr.write(`error: ${error instanceof Error ? error.message : "Harness initialization failed."}\n`);
+			return exitCodes.error;
+		}
+	}
+});
+const harnessCommand = command({
+	name: "agent-harness",
+	description: "Commands for configuring agent harness compatibility.",
+	commands: [initCommand, doctorCommand]
+});
+function activate({ addCommand }) {
+	addCommand(harnessCommand);
+}
+//#endregion
+//#region src/cli.ts
+/**
+* Read from the manifest rather than restated here: a version written into this call is a second
+* home for a number that already has one, and it stayed at `0.1.0` for five minor releases.
+*
+* `../package.json` resolves from `src/cli.ts` and from the bundled `dist/cli.mjs` alike — both sit
+* one directory under the package root.
+*/
+const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+/**
+* A factory rather than a module-level constant: `cli()` builds state, and state built at import
+* time is shared by every later call in the process.
+*/
+function app() {
+	return cli({
+		name: "buddy-agent-harness",
+		version,
+		description: "Initialize agent harness skill compatibility in consumer repositories."
+	}).command(initCommand).command(doctorCommand).command(depPluginsCommand);
+}
+/**
+* The application boundary: argv in, exit code out, nothing read from or written to the process.
+*
+* The exit code is returned rather than written so that a caller which is not the process — a skill
+* launcher, a test — can run a command and learn how it went. `bin/buddy-agent-harness.mjs` is the
+* only place that turns the returned code back into a process outcome.
+*
+* One exit path this return cannot carry: `clibuilder` answers an unknown option or an unknown
+* command by printing help and writing `process.exitCode` itself, returning nothing. `run` reports
+* `0` there, which is why `bin` and the launchers apply the returned code only when it is non-zero.
+*/
+async function run(argv) {
+	try {
+		const code = await app().parse(argv);
+		return typeof code === "number" ? code : exitCodes.success;
+	} catch (error) {
+		process.stderr.write(`error: ${error instanceof Error ? error.message : "Invalid command."}\n`);
+		return exitCodes.usage;
+	}
+}
+//#endregion
 export { activate, bridgeRepairs, buildDoctorReport, diagnoseBridges, diagnoseInstructions, diagnoseMcp, doctorCommand, doctorRepairs, doctorSkill, goldenSetPath, harnessCommand, harnessRegistry, initCommand, initializeHarnesses, instructionRepairs, renderDoctorSkill, run };
+
+//# sourceMappingURL=index.mjs.map