buddy-agent-harness 0.5.0 → 0.6.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "buddy-agent-harness",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "Initialize standards-based agent configuration across agent harnesses",
 	"author": {
 		"name": "repobuddy"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "buddy-agent-harness",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "Initialize standards-based agent configuration across agent harnesses",
 	"author": {
 		"name": "repobuddy"

package/.cursor-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "buddy-agent-harness",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "Initialize standards-based agent configuration across agent harnesses",
 	"author": {
 		"name": "repobuddy"

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { a as doctorCommand, r as initCommand } from "./init.command-c0fBv15T.mjs";
+import { a as doctorCommand, r as initCommand } from "./init.command-zbntulIq.mjs";
 import { cli } from "clibuilder";
 //#region src/cli.ts
 async function main() {

package/dist/index.d.mts

@@ -1,20 +1,84 @@
 import { cli as cli$1 } from "clibuilder";
+//#region src/harness-registry/instruction-bridge.d.ts
+/**
+ * What a harness needs in order to read the repository's `AGENTS.md`.
+ *
+ * A skills projection is one shape — a directory pointing at `.agents/skills` — so the registry
+ * models it as a path. Instruction bridges are not one shape: Claude Code needs a Markdown file
+ * whose body imports `AGENTS.md`, and Gemini CLI needs `AGENTS.md` added to an array inside a JSON
+ * settings file. A second bare path field would describe the first and lie about the second, so the
+ * variant carries what its own check needs.
+ *
+ * The `init` command writes none of these. They are the `init` skill's work, which is why every
+ * finding against one names the skill rather than a flag.
+ */
+type InstructionBridge = {
+  /**
+   * A Markdown file whose body is an `@AGENTS.md` import, or a symlink to `AGENTS.md`. One is
+   * needed beside every `AGENTS.md` in the tree, not only the root file: an import bridges the
+   * one file next to it, so a nested `AGENTS.md` is invisible until it has its own.
+   */
+  kind: "import";
+  /** Repository-relative name, the same in every directory that holds an `AGENTS.md`. */
+  path: string;
+} | {
+  /** An `AGENTS.md` entry in an array inside a JSON settings file. */
+  kind: "settings-entry";
+  /** Repository-relative path of the settings file. */
+  path: string;
+  /** Dotted path to the array within it, as the harness documents it. */
+  key: string;
+};
+//#endregion
 //#region src/harness-registry/harness-registry.d.ts
 type HarnessName = "claude-code" | "cursor" | "codex" | "copilot-cli" | "gemini-cli" | "devin-desktop" | "windsurf";
+/** The two scopes a harness reads configuration at. Their roots differ; their shape does not. */
+type HarnessScopeName = "project" | "user";
 /**
- * `skillsDirectory` is the projection target a harness needs to see `.agents/skills`.
- * A harness that reads `.agents/skills` natively has none, and is never projected into.
+ * What one harness does at one scope. Paths are relative to that scope's root: the repository root
+ * at project scope, the user's home directory at user scope.
+ *
+ * `detect` is the directory whose presence means this harness is configured at this scope — a
+ * different question per scope, which is why it is recorded per scope rather than once.
+ *
+ * `skillsDirectory` is the projection target the harness needs to see `.agents/skills` at this
+ * scope. A harness that reads `.agents/skills` natively there has none, and is never projected into.
+ *
+ * `instructionBridge` is the same question for `AGENTS.md`: what the harness needs at this scope in
+ * order to read it. It belongs per scope for the same reason `skillsDirectory` does — the file
+ * differs. Unlike `skillsDirectory`, the `init` command does not write it; the `init` skill does. It
+ * is recorded here to be diagnosed and gated per harness, not to be projected.
  */
-type Harness = {
-  name: HarnessName;
+type HarnessScope = {
   detect: string;
   skillsDirectory?: string;
+  instructionBridge?: InstructionBridge;
+};
+type Harness = {
+  name: HarnessName;
+  /** What this harness does inside a repository. `init` and `doctor` act only here. */
+  project: HarnessScope;
+  /**
+   * What this harness does for the user, outside any repository. Absent when no user-scope path is
+   * primary-sourced — Devin documents none. Described and diagnosable; never written to.
+   */
+  user?: HarnessScope;
   /** Set when this name has been superseded; the value is the name that replaces it. */
   deprecated?: HarnessName;
 };
 /**
- * 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
@@ -24,6 +88,35 @@ type Harness = {
  */
 declare const harnessRegistry: readonly Harness[];
 //#endregion
+//#region src/diagnose-bridges/diagnose-instructions.d.ts
+/** What is on disk where an instruction bridge belongs. */
+type InstructionKind = "import" | "symlink" | "settings-entry" | "file" | "none";
+/**
+ * `unbridged` is the case a skills bridge has no equivalent of: the file is there, so nothing looks
+ * wrong, and it names `AGENTS.md` nowhere — a `CLAUDE.md` overwritten with real content, or a
+ * settings file another tool rewrote.
+ */
+type InstructionStatus = "ok" | "missing" | "unbridged" | "unreadable";
+type InstructionReport = {
+  harness: HarnessName;
+  /** Repository-relative path of the file that carries the bridge. */
+  path: string;
+  kind: InstructionKind;
+  status: InstructionStatus;
+};
+/**
+ * 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.
+ */
+declare function diagnoseInstructions(root: string, harnesses: readonly Harness[], cli: string): {
+  instructions: InstructionReport[];
+  findings: BridgeFinding[];
+};
+//#endregion
 //#region src/diagnose-bridges/git-bridge-state.d.ts
 /** Which side of a diverged bridge moved since the last commit where the two agreed. */
 type DivergenceDirection = "bridge" | "canonical" | "both" | "unknown";
@@ -56,13 +149,18 @@ type DiagnoseOptions = {
 };
 type DiagnoseResult = {
   bridges: BridgeReport[];
+  /**
+   * The instruction bridges into `AGENTS.md`, kept out of `bridges` on purpose: a different `kind`
+   * and `status` vocabulary, and a repair that is the `init` skill rather than a command.
+   */
+  instructions: InstructionReport[];
   divergence: DivergenceReport[];
   findings: BridgeFinding[];
 };
 /**
- * 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.
  */
 declare function diagnoseBridges({ root, harnesses: preferred, cli }: DiagnoseOptions): DiagnoseResult;
 //#endregion
@@ -75,10 +173,18 @@ declare const doctorCommand: cli$1.Command;
  * `findings` and `help` sections; `skills/doctor/SKILL.md` is generated from the same table by
  * `scripts/generate-skills.ts`, so the shipped skill cannot drift from what the command says.
  */
-/** Every way a bridge can fail, in the order `doctor` reports them. */
+/** Every way a skills bridge can fail, in the order `doctor` reports them. */
 type BridgeProblem = "no-canonical" | "missing" | "degraded" | "stale" | "diverged-bridge" | "diverged-canonical" | "diverged-both" | "diverged-unknown" | "unpinned-copy";
+/**
+ * Every way an instruction bridge can fail. Separate from `BridgeProblem` because the two share no
+ * repair: a skills bridge is rebuilt with `init` flags, and an instruction bridge is a file whose
+ * content is the user's, so every repair here goes back to the `init` skill.
+ */
+type InstructionProblem = "no-instructions" | "instructions-missing" | "instructions-unbridged" | "instructions-unreadable";
+/** Everything `doctor` can report against, across both sections. */
+type DoctorProblem = BridgeProblem | InstructionProblem;
 type Repair = {
-  problem: BridgeProblem;
+  problem: DoctorProblem;
   /** What `doctor` prints in the `findings` row for this problem. */
   detail: string;
   /**
@@ -93,10 +199,20 @@ type Repair = {
    */
   skillRepair(path: string): string;
 };
+/** The skills bridges, reported in `bridges`. */
+declare const bridgeRepairs: readonly Repair[];
+/**
+ * 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.
+ */
+declare const instructionRepairs: readonly Repair[];
+/** Both sections, in the order `doctor` reports them. */
 declare const doctorRepairs: readonly Repair[];
 declare const doctorSkill: {
   readonly name: "doctor";
-  readonly 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.";
+  readonly 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.";
 };
 /**
  * The shipped `doctor` skill, rendered from the same table the command prints. `version` is the
@@ -134,5 +250,5 @@ type InitializeResult = {
 };
 declare function initializeHarnesses({ root, harnesses: preferred, copy, force }: InitializeOptions): InitializeResult;
 //#endregion
-export { type BridgeFinding, type BridgeKind, type BridgeProblem, type BridgeReport, type BridgeStatus, type DiagnoseOptions, type DiagnoseResult, type DivergenceDirection, type DivergenceReport, type HarnessName, type InitializeOptions, type InitializeResult, type Repair, activate, diagnoseBridges, doctorCommand, doctorRepairs, doctorSkill, harnessCommand, harnessRegistry, initCommand, initializeHarnesses, renderDoctorSkill };
+export { type BridgeFinding, type BridgeKind, type BridgeProblem, type BridgeReport, type BridgeStatus, type DiagnoseOptions, type DiagnoseResult, type DivergenceDirection, type DivergenceReport, type DoctorProblem, type Harness, type HarnessName, type HarnessScope, type HarnessScopeName, type InitializeOptions, type InitializeResult, type InstructionBridge, type InstructionKind, type InstructionProblem, type InstructionReport, type InstructionStatus, type Repair, activate, bridgeRepairs, diagnoseBridges, diagnoseInstructions, doctorCommand, doctorRepairs, doctorSkill, harnessCommand, harnessRegistry, initCommand, initializeHarnesses, instructionRepairs, renderDoctorSkill };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/harness-registry/harness-registry.ts","../src/diagnose-bridges/git-bridge-state.ts","../src/diagnose-bridges/diagnose-bridges.ts","../src/diagnose-bridges/doctor.command.ts","../src/diagnose-bridges/doctor-guidance.ts","../src/initialize-harnesses/init.command.ts","../src/initialize-harnesses/initialize-harnesses.ts"],"mappings":";;KAGY;;;;;KAaA;EACX,MAAM;EACN;EACA;;EAEA,aAAa;;;;;;;;;;;;cAaD,0BAA0B;;;;KC7B3B;;;KCEA;KACA;KAEA;EACX,SAAS;;EAET;EACA,MAAM;EACN,QAAQ;;KAGG;EACX;EACA;;EAEA;;KAGW;EACX;EACA,WAAW;;KAGA;EACX;EACA,YAAY;;EAEZ;;KAGW;EACX,SAAS;EACT,YAAY;EACZ,UAAU;;;;;;;iBA8EK,kBAAkB,MAAM,WAAW,WAAgB,OAAO,kBAAkB;;;cC7E/E,eAAe,MAAI;;;;;;;;;KClCpB;KAWA;EACX,SAAS;;EAET;;;;;EAKA,OAAO,cAAc;;;;;;EAMrB,YAAY;;cAqDA,wBAAwB;cAmExB;WACZ;WACA;;;;;;;iBAae,kBAAkB;;;cChKrB,aAAa,MAAI;cA0DjB,gBAAgB,MAAI;iBAMjB,WAAW;EAAgB,WAAW,gBAAgB;;;;KCnE1D;EACX;EACA,YAAY;EACZ;EACA;;KAEW;EACX;EACA,WAAW;EACX,QAAQ;EACR,QAAQ;;EAER;IAAc,MAAM;IAAa,YAAY;;EAC7C;EACA;;iBAGe,sBACf,MACA,WAAW,WACX,MACA,SACE,oBAAoB"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/harness-registry/instruction-bridge.ts","../src/harness-registry/harness-registry.ts","../src/diagnose-bridges/diagnose-instructions.ts","../src/diagnose-bridges/git-bridge-state.ts","../src/diagnose-bridges/diagnose-bridges.ts","../src/diagnose-bridges/doctor.command.ts","../src/diagnose-bridges/doctor-guidance.ts","../src/initialize-harnesses/init.command.ts","../src/initialize-harnesses/initialize-harnesses.ts"],"mappings":";;;;;;;;;;;;;;KAYY;;;;;;EAOT;;EAEA;;;EAIA;;EAEA;;EAEA;;;;KCzBS;;KAUA;;;;;;;;;;;;;;;;KAiBA;EACX;EACA;EACA,oBAAoB;;KAGT;EACX,MAAM;;EAEN,SAAS;;;;;EAKT,OAAO;;EAEP,aAAa;;;;;;;;;;;;;;;;;;;;;;cAuBD,0BAA0B;;;;KC5D3B;;;;;;KAMA;KAEA;EACX,SAAS;;EAET;EACA,MAAM;EACN,QAAQ;;;;;;;;;;iBAkFO,qBACf,cACA,oBAAoB,WACpB;EACI,cAAc;EAAqB,UAAU;;;;;KCxGtC;;;KCGA;KACA;KAEA;EACX,SAAS;;EAET;EACA,MAAM;EACN,QAAQ;;KAGG;EACX;EACA;;EAEA;;KAGW;EACX;EACA,WAAW;;KAGA;EACX;EACA,YAAY;;EAEZ;;KAGW;EACX,SAAS;;;;;EAKT,cAAc;EACd,YAAY;EACZ,UAAU;;;;;;;iBA8EK,kBAAkB,MAAM,WAAW,WAAgB,OAAO,kBAAkB;;;cC9E/E,eAAe,MAAI;;;;;;;;;KCvCpB;;;;;;KAgBA;;KAOA,gBAAgB,gBAAgB;KAEhC;EACX,SAAS;;EAET;;;;;EAKA,OAAO,cAAc;;;;;;EAMrB,YAAY;;;cAsDA,wBAAwB;;;;;;;cAmExB,6BAA6B;;cA6B7B,wBAAwB;cAQxB;WACZ;WACA;;;;;;;iBAae,kBAAkB;;;cCpNrB,aAAa,MAAI;cA0DjB,gBAAgB,MAAI;iBAMjB,WAAW;EAAgB,WAAW,gBAAgB;;;;KCnE1D;EACX;EACA,YAAY;EACZ;EACA;;KAEW;EACX;EACA,WAAW;EACX,QAAQ;EACR,QAAQ;;EAER;IAAc,MAAM;IAAa,YAAY;;EAC7C;EACA;;iBAGe,sBACf,MACA,WAAW,WACX,MACA,SACE,oBAAoB"}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { a as doctorCommand, c as doctorSkill, i as initializeHarnesses, l as renderDoctorSkill, n as harnessCommand, o as diagnoseBridges, r as initCommand, s as doctorRepairs, t as activate, u as harnessRegistry } from "./init.command-c0fBv15T.mjs";
-export { activate, diagnoseBridges, doctorCommand, doctorRepairs, doctorSkill, harnessCommand, harnessRegistry, initCommand, initializeHarnesses, renderDoctorSkill };
+import { a as doctorCommand, c as bridgeRepairs, d as instructionRepairs, f as renderDoctorSkill, i as initializeHarnesses, l as doctorRepairs, n as harnessCommand, o as diagnoseBridges, p as harnessRegistry, r as initCommand, s as diagnoseInstructions, t as activate, u as doctorSkill } from "./init.command-zbntulIq.mjs";
+export { activate, bridgeRepairs, diagnoseBridges, diagnoseInstructions, doctorCommand, doctorRepairs, doctorSkill, harnessCommand, harnessRegistry, initCommand, initializeHarnesses, instructionRepairs, renderDoctorSkill };