buddy-agent-harness 0.4.1 → 0.6.0

package/dist/{init.command-c0fBv15T.mjs → init.command-zbntulIq.mjs}

@@ -2,7 +2,7 @@ import { command, z } from "clibuilder";
 import { homedir } from "node:os";
 import { dirname, join, posix, relative, sep } from "node:path";
 import { encode } from "@toon-format/toon";
-import { cpSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmSync, statSync, symlinkSync } from "node:fs";
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmSync, statSync, symlinkSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 //#region src/command-output/command-output.ts
 const formats = [
@@ -61,8 +61,18 @@ function binPath(home, executable) {
 //#endregion
 //#region src/harness-registry/harness-registry.ts
 /**
-* Codex, Cursor, Copilot CLI, and Devin Desktop read `.agents/skills` directly, so they need no
-* projection. Only Claude Code and Gemini CLI read solely their own directory.
+* 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
@@ -73,34 +83,56 @@ function binPath(home, executable) {
 const harnessRegistry = [
 	{
 		name: "claude-code",
-		detect: ".claude",
-		skillsDirectory: ".claude/skills"
+		project: {
+			detect: ".claude",
+			skillsDirectory: ".claude/skills",
+			instructionBridge: {
+				kind: "import",
+				path: "CLAUDE.md"
+			}
+		},
+		user: {
+			detect: ".claude",
+			skillsDirectory: ".claude/skills"
+		}
 	},
 	{
 		name: "cursor",
-		detect: ".cursor"
+		project: { detect: ".cursor" },
+		user: { detect: ".cursor" }
 	},
 	{
 		name: "codex",
-		detect: ".codex"
+		project: { detect: ".codex" },
+		user: { detect: ".codex" }
 	},
 	{
 		name: "copilot-cli",
-		detect: ".github/skills"
+		project: { detect: ".github/skills" },
+		user: { detect: ".copilot" }
 	},
 	{
 		name: "gemini-cli",
-		detect: ".gemini",
-		skillsDirectory: ".gemini/skills"
+		project: {
+			detect: ".gemini",
+			instructionBridge: {
+				kind: "settings-entry",
+				path: ".gemini/settings.json",
+				key: "context.fileName"
+			}
+		},
+		user: { detect: ".gemini" }
 	},
 	{
 		name: "devin-desktop",
-		detect: ".devin"
+		project: { detect: ".devin" }
 	},
 	{
 		name: "windsurf",
-		detect: ".windsurf",
-		skillsDirectory: ".windsurf/skills",
+		project: {
+			detect: ".windsurf",
+			skillsDirectory: ".windsurf/skills"
+		},
 		deprecated: "devin-desktop"
 	}
 ];
@@ -116,23 +148,37 @@ function directoryExists(path) {
 /** The default harnesses, plus the preferred ones, plus every harness whose directory is present. */
 function selectHarnesses(root, preferred) {
 	const enabled = /* @__PURE__ */ new Set([...defaultHarnesses, ...preferred]);
-	return harnessRegistry.filter((harness) => enabled.has(harness.name) || directoryExists(join(root, harness.detect)));
+	return harnessRegistry.filter((harness) => enabled.has(harness.name) || directoryExists(join(root, harness.project.detect)));
 }
 //#endregion
-//#region src/diagnose-bridges/directory-files.ts
+//#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 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.
+* 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 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 [];
-	}
+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/doctor-guidance.ts
@@ -163,7 +209,8 @@ const launcherFor = (subcommand) => `scripts/${subcommand}.mjs`;
 const launcherInvocation = (subcommand) => `node ${launcherFor(subcommand)}`;
 /** How the skill hands a repair back to `init`. */
 const initSkillInvocation = "/buddy-agent-harness:init";
-const doctorRepairs = [
+/** The skills bridges, reported in `bridges`. */
+const bridgeRepairs = [
 	{
 		problem: "no-canonical",
 		detail: "the canonical skill directory does not exist, so no bridge can resolve",
@@ -219,13 +266,47 @@ const doctorRepairs = [
 		skillRepair: (path) => `run \`git ls-files -z ${path} | xargs -0 git update-index --skip-worktree\``
 	}
 ];
+/**
+* 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 instructionRepairs = [
+	{
+		problem: "no-instructions",
+		detail: "no AGENTS.md at the repository root, so every instruction bridge points at nothing",
+		repair: () => initSkillInvocation,
+		skillRepair: () => `run \`${initSkillInvocation}\`, which derives AGENTS.md and the bridges to it`
+	},
+	{
+		problem: "instructions-missing",
+		detail: "no instruction bridge at this path — the harness reads none of AGENTS.md",
+		repair: () => initSkillInvocation,
+		skillRepair: () => `run \`${initSkillInvocation}\``
+	},
+	{
+		problem: "instructions-unbridged",
+		detail: "the file is present but names AGENTS.md nowhere — the harness reads none of it",
+		repair: () => initSkillInvocation,
+		skillRepair: () => `run \`${initSkillInvocation}\`, which adds the bridge without discarding what the file already says`
+	},
+	{
+		problem: "instructions-unreadable",
+		detail: "the settings file does not parse, so the harness reads none of it",
+		repair: () => initSkillInvocation,
+		skillRepair: () => `fix the JSON by hand, then run \`${initSkillInvocation}\``
+	}
+];
+/** Both sections, in the order `doctor` reports them. */
+const doctorRepairs = [...bridgeRepairs, ...instructionRepairs];
 const repairsByProblem = new Map(doctorRepairs.map((entry) => [entry.problem, entry]));
 function repairFor(problem) {
 	return repairsByProblem.get(problem);
 }
 const doctorSkill = {
 	name: "doctor",
-	description: "Use this skill when a repository loads no project skills, when skills are missing after a clone, or when checking whether the agent configuration bridges into .claude/skills and the other harness directories still resolve."
+	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. -->";
@@ -236,7 +317,7 @@ const generatedSkillWarning = "<!-- Generated from src/diagnose-bridges/doctor-g
 */
 function renderDoctorSkill(version) {
 	const cell = (value) => value.replaceAll("|", "\\|");
-	const rows = doctorRepairs.map((entry) => `| \`${entry.problem}\` | ${entry.detail} | ${cell(entry.skillRepair("<path>"))} |`).join("\n");
+	const rows = (repairs) => repairs.map((entry) => `| \`${entry.problem}\` | ${entry.detail} | ${cell(entry.skillRepair("<path>"))} |`).join("\n");
 	return `---
 name: ${doctorSkill.name}
 description: ${doctorSkill.description}
@@ -246,7 +327,7 @@ ${generatedSkillWarning}
 
 # Harness Doctor
 
-\`.agents/skills\` is the canonical skill directory. Harnesses that cannot read it — Claude Code and Gemini CLI — get a bridge pointing at it, normally a directory symlink. A bridge that stops resolving is silent: the harness finds nothing and loads zero project skills, with no warning anywhere.
+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:
 
@@ -260,22 +341,36 @@ The command is read-only. It never repairs anything, so it is safe to run at any
 
 ## Reading the report
 
-\`bridges\` lists every bridge \`init\` would create for this repository, each with a \`status\` of \`ok\`, \`missing\`, \`degraded\`, \`stale\`, or \`diverged\`. \`findings\` explains each problem and \`help\` names its repair. Apply the repair from the table below, then re-run \`doctor\`.
+\`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 from either section and \`help\` names its repair. Apply the repair from the tables below, then re-run \`doctor\`.
 
-\`help\` names the \`init\` command for a person at a shell. Do not run it yourself. Rebuilding a bridge can move skills a user wrote, and that judgment belongs to the \`init\` skill — hand the repair to \`${initSkillInvocation}\` instead.
+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. A \`help\` line naming that skill 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\`.
 
-## Findings and their repairs
+## Skills bridge findings
 
 | Finding | What it means | Repair |
 | --- | --- | --- |
-${rows}
+${rows(bridgeRepairs)}
 
 Substitute the reported bridge path for \`<path>\`.
 
+## Instruction bridge findings
+
+| Finding | What it means | Repair |
+| --- | --- | --- |
+${rows(instructionRepairs)}
+
+\`unbridged\` is the one to read carefully. The file is there and looks fine, and it names \`AGENTS.md\` nowhere — a \`CLAUDE.md\` someone overwrote with real content, or a \`.gemini/settings.json\` another tool rewrote without \`AGENTS.md\` in \`context.fileName\`. Never fix it by replacing the file: the content that displaced the bridge may be the only copy of something.
+
+An instruction bridge is reported per file, so a monorepo gets one row per \`AGENTS.md\` in the tree. Each nested \`AGENTS.md\` needs its own stub — an import bridges the file beside it and nothing deeper.
+
 ## The Windows case
 
 The common failure is \`degraded\`. Creating a symlink on Windows needs a privilege most accounts do not have, and Git for Windows gates it separately with \`core.symlinks\`, which its installer leaves off. With \`core.symlinks=false\` git does not error — it writes the symlink out as a regular file whose contents are the target path. \`${initSkillInvocation} --copy --force\` rebuilds the bridges as real directories on that machine.
@@ -287,9 +382,207 @@ A copy is a snapshot rather than a live projection, and an agent that edits a sk
 - 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.
+- 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-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-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,
+			detail,
+			repair: repair(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,
+				detail,
+				repair: repair(path, cli)
+			});
+		}
+	}
+	return {
+		instructions,
+		findings
+	};
+}
+//#endregion
+//#region src/diagnose-bridges/directory-files.ts
+/**
+* Every file below `directory`, as paths relative to it, POSIX-separated and sorted. A directory
+* that does not exist reads as empty: `doctor` never creates one to look at it.
+*/
+function filesUnder(directory) {
+	try {
+		return readdirSync(directory, {
+			recursive: true,
+			withFileTypes: true
+		}).filter((entry) => entry.isFile()).map((entry) => relative(directory, join(entry.parentPath, entry.name)).split(sep).join(posix.sep)).sort();
+	} catch {
+		return [];
+	}
+}
+//#endregion
 //#region src/diagnose-bridges/git-bridge-state.ts
 function git(root, args, input) {
 	try {
@@ -467,14 +760,18 @@ function inspect(target, path, canonical, git) {
 	}
 }
 /**
-* Reports whether every bridge `init` would create for this repository still resolves into
-* `.agents/skills`. Read-only: nothing is created, moved, or repaired, so the caller decides what
-* to run from the repair each finding carries.
+* 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 bridged = selectHarnesses(root, preferred).filter((harness) => Boolean(harness.skillsDirectory));
+	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 = [];
@@ -508,8 +805,11 @@ function diagnoseBridges({ root, harnesses: preferred = [], cli }) {
 			});
 		}
 	}
+	const instructions = diagnoseInstructions(root, selected, cli);
+	findings.push(...instructions.findings);
 	return {
 		bridges,
+		instructions: instructions.instructions,
 		divergence,
 		findings
 	};
@@ -522,16 +822,18 @@ function diagnoseBridges({ root, harnesses: preferred = [], cli }) {
 */
 function buildReport(bin, result) {
 	if (!result.findings.length) {
-		const count = result.bridges.length;
+		const count = result.bridges.length + result.instructions.length;
 		return {
 			bin,
 			bridges: result.bridges,
+			instructions: result.instructions,
 			findings: count === 1 ? "0 problems found — the 1 bridge resolves" : `0 problems found — all ${count} bridges resolve`
 		};
 	}
 	return {
 		bin,
 		bridges: result.bridges,
+		instructions: result.instructions,
 		...result.divergence.length ? { divergence: result.divergence } : {},
 		findings: result.findings.map(({ path, detail }) => ({
 			path,
@@ -542,7 +844,7 @@ function buildReport(bin, result) {
 }
 const doctorCommand = command({
 	name: "doctor",
-	description: "Report whether the harness skill bridges in this repository still resolve. Read-only.",
+	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.",
@@ -602,9 +904,9 @@ function countSkills(canonicalSkills) {
 * preferred; a platform that refuses the link falls back to a copy. Returns the projected harnesses.
 */
 function projectSkills({ root, canonicalSkills, harnesses, copy, force }) {
-	const projections = harnesses.filter((harness) => harness.skillsDirectory).map((harness) => ({
+	const projections = harnesses.filter((harness) => harness.project.skillsDirectory).map((harness) => ({
 		harness,
-		target: join(root, harness.skillsDirectory)
+		target: join(root, harness.project.skillsDirectory)
 	}));
 	const conflicts = projections.filter(({ target }) => pathOccupied(target) && !isCorrectLink(target, canonicalSkills)).map(({ target }) => target);
 	if (conflicts.length && !force) throw new Error(`Refusing to replace existing skill targets:\n${conflicts.map((target) => `- ${target}`).join("\n")}`);
@@ -644,7 +946,7 @@ function initializeHarnesses({ root, harnesses: preferred = [], copy = false, fo
 	return {
 		root,
 		harnesses: harnesses.map((harness) => harness.name),
-		native: harnesses.filter((harness) => !harness.skillsDirectory).map((harness) => harness.name),
+		native: harnesses.filter((harness) => !harness.project.skillsDirectory).map((harness) => harness.name),
 		linked,
 		deprecated: harnesses.filter((harness) => harness.deprecated).map((harness) => ({
 			name: harness.name,
@@ -709,6 +1011,6 @@ function activate({ addCommand }) {
 	addCommand(harnessCommand);
 }
 //#endregion
-export { doctorCommand as a, doctorSkill as c, initializeHarnesses as i, renderDoctorSkill as l, harnessCommand as n, diagnoseBridges as o, initCommand as r, doctorRepairs as s, activate as t, harnessRegistry as u };
+export { doctorCommand as a, bridgeRepairs as c, instructionRepairs as d, renderDoctorSkill as f, initializeHarnesses as i, doctorRepairs as l, harnessCommand as n, diagnoseBridges as o, harnessRegistry as p, initCommand as r, diagnoseInstructions as s, activate as t, doctorSkill as u };
 
-//# sourceMappingURL=init.command-c0fBv15T.mjs.map
+//# sourceMappingURL=init.command-zbntulIq.mjs.map