omniconductor 0.6.0 → 1.0.1

package/bin/omniconductor.js

@@ -7,13 +7,15 @@
  * Usage:
  *   omniconductor init --target=<tool> [target-dir] [--recipes=a,b] [--dry-run] [--no-prompt]
  *   omniconductor init --target=<tool> [target-dir] --uninstall [--force]
+ *   omniconductor doctor [target-dir] [--json]
  *   omniconductor list
  *   omniconductor --help | --version
  *
  * It does NOT reimplement any install logic. It locates this repo's
  * adapters/<tool>/transform.sh and runs it with `bash`, forwarding all flags
  * and inheriting stdio. The shell adapters remain the single source of truth
- * (ADR-018 / the bash adapters are the validated implementation).
+ * (ADR-002/023/025 — the bash adapters are the validated implementation).
+ * `doctor` (ADR-041) is read-only: it inspects an install, never changes it.
  */
 
 const path = require('path');
@@ -36,6 +38,7 @@ function usage() {
 
 Usage:
   omniconductor init --target=<tool> [target-dir] [options]   Install into target-dir (default: .)
+  omniconductor doctor [target-dir] [--json]                  Health-check an existing install (read-only)
   omniconductor list                                          List available tool adapters
   omniconductor --help | --version
 
@@ -43,6 +46,8 @@ Tools: ${TOOLS.join(', ')}
 
 Common options (forwarded to the adapter):
   --recipes=a,b,c     Opt-in recipes to install
+  --mode=<m>          Install preset: full (default) | minimal | strict |
+                      recipes-only | reflector-only (ADR-044)
   --dry-run           Preview only — write nothing
   --no-prompt         Skip interactive prompts (CI-safe)
   --uninstall         Revert a previous install (manifest-based)
@@ -52,6 +57,7 @@ Examples:
   omniconductor init --target=claude ./my-app --recipes=tdd,debugging
   omniconductor init --target=cursor ./my-app --dry-run
   omniconductor init --target=codex . --uninstall
+  omniconductor doctor ./my-app --json
 
 Run:  npx omniconductor init --target=<tool> <dir>`;
 }
@@ -85,8 +91,15 @@ function main(argv) {
     return 0;
   }
 
+  if (cmd === 'doctor') {
+    const rest = args.slice(1);
+    const jsonOut = rest.includes('--json');
+    const dir = rest.find((a) => !a.startsWith('-')) || '.';
+    return require('./doctor.js').run(dir, { json: jsonOut });
+  }
+
   if (cmd !== 'init') {
-    fail(`unknown command '${cmd}'. Expected 'init' or 'list'.`);
+    fail(`unknown command '${cmd}'. Expected 'init', 'doctor', or 'list'.`);
   }
 
   // Parse `init` args: extract --target, the positional target-dir, forward the rest.

package/core/anti-patterns/frequent-rule-file-edit.md

@@ -54,7 +54,7 @@ If the rule file is edited daily, every session starts with a fresh cache write
 ```bash
 # Edits per week to top-of-prefix files
 git log --since='1 week ago' --pretty=format:'%h %s' -- \
-  CLAUDE.md AGENT.md GEMINI.md .codex/codex.md \
+  CLAUDE.md AGENT.md AGENTS.md GEMINI.md \
   .claude/rules/*.md .cursor/rules/*.mdc 2>/dev/null | wc -l
 
 # Anything > 3 in a week is suspect

package/core/anti-patterns/single-monolithic-rule-file.md

@@ -52,7 +52,7 @@ Two corollaries:
 
 ```bash
 # Find oversized rule files
-wc -l CLAUDE.md AGENT.md GEMINI.md .codex/codex.md 2>/dev/null | \
+wc -l CLAUDE.md AGENT.md AGENTS.md GEMINI.md 2>/dev/null | \
   awk '$1 > 500 { print }'
 ```
 

package/core/recipes/README.md

@@ -44,7 +44,7 @@ Adapter `transform.sh` accepts a `--recipes=<comma-separated-list>` flag (or per
 | Cursor | `.cursor/rules/<recipe>.mdc` |
 | Copilot | `.github/instructions/<recipe>.instructions.md` |
 | Gemini | Section in `GEMINI.md` |
-| Codex | Section in `.codex/codex.md` |
-| Windsurf | `.windsurf/rules/<recipe>.md` |
+| Codex | Section in `AGENTS.md` |
+| Windsurf | `.devin/rules/<recipe>.md` (legacy `.windsurf/rules/` still read) |
 
 Recipes are layered on TOP of universal-rules. They never override; they extend.

package/core/universal-rules/README.md

@@ -52,11 +52,11 @@ Adapters do not strip these callouts. The honest acknowledgment of degraded enfo
 | Adapter | Output |
 |---|---|
 | Claude | One file per bundle under `.claude/rules/` with `paths:` frontmatter. Universal bundles also referenced from `CLAUDE.md`. |
-| Cursor | One `.mdc` per bundle under `.cursor/rules/` with `globs:` frontmatter. Bundles summarized in `.cursorrules`. |
-| Copilot | One `.instructions.md` per bundle under `.github/instructions/` with `applyTo:` frontmatter. |
+| Cursor | One `.mdc` per bundle under `.cursor/rules/` (`alwaysApply: true`; recipes get `globs:`). Optional legacy `.cursorrules` bundle via `--legacy-cursorrules`. |
+| Copilot | All bundles merged into `.github/copilot-instructions.md` (default) or one `.instructions.md` per bundle under `.github/instructions/` with `--per-rule`. |
 | Gemini | All bundles concatenated into `GEMINI.md`, sectioned. |
-| Codex | All bundles concatenated into `.codex/codex.md`. |
-| Windsurf | One file per bundle under `.windsurf/rules/`. |
+| Codex | All bundles concatenated into `AGENTS.md` (project root). |
+| Windsurf | One file per bundle under `.devin/rules/` (legacy `.windsurf/rules/` still read). |
 
 See `adapters/<tool>/transform-spec.md` for the exact transformation per adapter.
 

package/core/universal-rules/meta-discipline.md

@@ -48,7 +48,7 @@ The user's framework is their craft. Borrowing names dilutes provenance and crea
 - **dispatch brief** — the ≤2K-token instruction object passed at dispatch.
 - **stop condition** — explicit done-criteria for a dispatched task.
 - **flat-with-leader** — orchestration topology where roles never dispatch each other; only the orchestrator dispatches.
-- **Single-Agent Mode** — fallback for tools without native sub-agent support; orchestrator + helper collapse into one thread.
+- **Single-Agent Mode** — fallback when sub-agent dispatch isn't available or isn't emitted for the tool; orchestrator + helper collapse into one thread.
 - **AMB triggers** — the 7-item ambiguity catalog that forces ASK behavior.
 - **ACT-WITH-DECLARATION** — proceed-with-best-guess + surface the assumption.
 - **universal rule** vs **recipe** — universal rules apply to every adopter; recipes are opt-in.
@@ -322,7 +322,7 @@ On other tools, the rule text serves as the constraint.
 | Originality grep | Pre-commit script (orchestrator's responsibility) | Same | Same | Same | Same | Same |
 | AMB-1..7 trigger ASK | Rule text + LLM self-discipline | Same | Same | Same | Same | Same |
 | Token-economy Read discipline | Rule text + Stop-hook reminder when wasteful patterns spike | Rule text | Rule text | Rule text | Rule text | Rule text |
-| Model routing | PreToolUse hook validates explicit `model` | Composer picker manual | Account-level only | Single model | Single model | Single model |
-| Flat-with-leader | PreToolUse hook validates dispatcher | Single-Agent Mode (no sub-agents) | Same | Same | Same | Same |
+| Model routing | PreToolUse hook validates explicit `model` | Manual per-task pick (tool-native) | Same | Same | Same | Same |
+| Flat-with-leader | PreToolUse hook validates dispatcher | Rule text (tools have native sub-agents; role emission is a later adapter phase) | Same | Same | Same | Same |
 
-The honest summary: meta-discipline is enforced by rule text on every tool, with hook-based extras on Claude Code only.
+The honest summary: meta-discipline is enforced by rule text on every tool, with hook-based extras emitted on Claude Code only today — an emission gap, not a tool limitation (every listed tool ships hooks, sub-agents, and per-task model selection natively as of 2026).

package/core/universal-rules/spec-as-you-go.md

@@ -108,7 +108,7 @@ Per-tool transformations:
 
 - **Claude Code**: keep as-is in `docs/specs/<area>.md`. Stop-hook checks for stale frontmatter when source files in that area are touched.
 - **Cursor / Copilot / Windsurf**: same file path, frontmatter preserved. Tool-specific scoping (`globs:` / `applyTo:`) added by the relevant adapter when the file lives under `.cursor/rules/` or `.github/instructions/`.
-- **Gemini / Codex**: file is referenced by path inside the single GEMINI.md / codex.md.
+- **Gemini / Codex**: file is referenced by path inside the single GEMINI.md / AGENTS.md.
 
 ---
 

package/docs/ADAPTER-LIVE-VERIFICATION.md

@@ -0,0 +1,73 @@
+# Adapter Live-Verification Guide
+
+> What the automated checks DO and DON'T cover, and a manual checklist to close the gap.
+
+CONDUCTOR's CI + `tools/validate-adapter-output.sh` verify that each adapter **emits
+the correct files** (right paths, the 5 universal rules present, no unsubstituted
+placeholders, no reference-product leakage). They do **NOT** verify that the target
+tool actually *loads and follows* those files in a live session — that requires the
+tool installed and a real prompt. This guide is that last mile.
+
+Status legend: ✅ = automated (CI/validator) · 🧪 = needs a live session (this guide).
+
+<!-- generated:live-verification-table — edit adapters/*/metadata.json + run tools/generate-adapter-docs.js; do not hand-edit (ADR-042) -->
+| Adapter | File emission | Live rule-loading |
+|---|---|---|
+| Claude Code | ✅ | ✅ **live-verified 2026-07-09** — 2.1.205 (Claude Code) headless probe listed 5/5 rules + read-CURRENT_WORK-first |
+| Cursor | ✅ | 🧪 not yet run |
+| Copilot | ✅ | 🧪 per-IDE — see docs/IDE-SMOKE-TESTING.md |
+| Gemini CLI | ✅ | 🧪 not yet run |
+| Codex | ✅ | ✅ **live-verified 2026-07-09** — codex-cli 0.144.0 headless probe listed 4/5 rules + read-CURRENT_WORK-first |
+| Windsurf | ✅ | 🧪 not yet run |
+<!-- /generated:live-verification-table -->
+
+> This table is generated from `adapters/<tool>/metadata.json` (`live_verification`) —
+> `tools/live-verify.sh` updates the metadata after a successful live probe, and CI
+> fails if the table and metadata disagree.
+
+## Per-tool procedure
+
+For each tool: (1) install into a throwaway project, (2) open the tool there, (3) run
+the probe prompt, (4) record PASS/FAIL.
+
+### Common setup
+```bash
+mkdir /tmp/cdt-<tool> && cd /tmp/cdt-<tool> && git init -q
+bash <conductor>/adapters/<tool>/transform.sh . --no-prompt --recipes=coding-conventions
+# (or: node <conductor>/bin/omniconductor.js init --target=<tool> . --no-prompt --recipes=coding-conventions)
+```
+
+### Probe prompt (same for every tool)
+> "What workflow and rules are you operating under in this project? List the universal rules you can see, and tell me the first thing you must do before writing code."
+
+**PASS criteria** — the tool's answer references CONDUCTOR's rules: the Plan-first /
+spec-as-you-go / quality-gates discipline, and "read `docs/CURRENT_WORK.md` first" (or
+equivalent). A generic answer that ignores the installed file = FAIL (tool didn't load it).
+
+### Tool-specific load points
+| Tool | File the tool must auto-load | Check |
+|---|---|---|
+| Gemini CLI | `GEMINI.md` (project root) + `.gemini/styleguide.md` | Does Gemini cite GEMINI.md content? Does it apply the styleguide on a code task? |
+| Codex | `AGENTS.md` (project root) | Auto-probed by `tools/live-verify.sh` (`codex exec`) — current result in the status table above |
+| Windsurf / Devin Desktop | `.windsurfrules` + `.devin/rules/*.md` (legacy `.windsurf/rules/`) | Does Windsurf show the rules in its Rules panel? Does it follow them? |
+| Claude Code | `CLAUDE.md` + `.claude/rules/*.md` + agents/hooks | Rules panel + a Stop-hook fires on a stale-docs commit |
+| Cursor | `.cursor/rules/*.mdc` | Settings → Rules tab shows the 5 rules |
+| Copilot | `.github/copilot-instructions.md` (or `.github/instructions/*`) | Per-IDE — see `docs/IDE-SMOKE-TESTING.md` |
+
+### Recording results
+Record each tool's outcome in `docs/COMPATIBILITY-MATRIX.md` (a "Live-verified" column):
+`✅ verified <date>` / `⚠️ partial (note)` / `❌ tool ignored the file`.
+
+A tool that emits correctly (CI green) but FAILS live-loading is a **documentation /
+file-location** issue, not an emission bug — check the tool's current rules-file
+convention (they change), update the adapter's output path, re-run CI, then re-test.
+
+## Why this is separate from CI
+Running six AI coding tools headlessly in CI is impractical (each needs auth + a model).
+So CONDUCTOR's CI guarantees *correct output*; live consumption is verified **locally**
+by `tools/live-verify.sh` (ADR-043): it installs into a throwaway dir, probes the tool's
+headless CLI with the prompt above, grades deterministically (>=3 of 5 rule names +
+CURRENT_WORK — no LLM judge), and on PASS writes the result into
+`adapters/<tool>/metadata.json`, regenerating the status table above. Tools whose CLI
+is not installed are SKIPped honestly. Treat any 🧪 row as "emission-verified,
+live-pending" until a probe (or a manual session per this guide) is recorded.

package/docs/COMPARISON.md

@@ -0,0 +1,133 @@
+# COMPARISON — CONDUCTOR vs other tools
+
+Honest comparison of CONDUCTOR against the major existing options. Updated 2026-07-09 — CONDUCTOR version currency lives in [`CHANGELOG.md`](../CHANGELOG.md).
+
+## Headline matrix
+
+| | GSD (`get-shit-done`) | SpecKit | BMAD | Cursor Rules | Plain CLAUDE.md | **CONDUCTOR** |
+|---|---|---|---|---|---|---|
+| **Multi-tool target** | 14+ runtimes | A few | A few | Cursor only | Claude Code only | 6 tools, all with working adapters (Claude / Cursor / Copilot / Gemini / Codex / Windsurf) — npm-published (`npx omniconductor`) |
+| **Setup weight** | Heavy (60+ skills) | Heavy (phases, ceremonies) | Heavy (sprint-style) | Light (rules only) | Trivial | Light kernel (5 universal rules + 6 roles) + 13 opt-in recipes + 10 hook templates |
+| **Sub-agent orchestration** | Yes | Yes | Yes | No | Manual | Yes — emitted on Claude today; the other tools support sub-agents too (ADR-031) but adapter emission is Phase 2 (ADR-004) |
+| **Spec-as-you-go enforcement** | Soft (encouraged) | Yes (gates) | Yes (artifacts) | No | No | ABSOLUTE on Claude (Stop hook); rule reminder on others |
+| **Two-stage code review** | Yes | Yes | Yes | No | No | ABSOLUTE on Claude (specialized agents); rule reminder on others |
+| **Token economy rules** | Bonus | Bonus | Not specifically | No | No | Built-in from day 1; instruction-fidelity-first since 0.4.0 (ADR-035/036) |
+| **Self-improvement loop** | No | No | No | No | No | Opt-in `self-improvement` Reflector — propose-only, human-approved (ADR-030/032/033), emitted on all 6 tools |
+| **Agent-loop / git discipline** | No | No | No | No | No | Opt-in `loop-engineering` (bounded, externally-verified loops, ADR-038) + `git-hygiene` (shared-repo discipline, ADR-037) recipes |
+| **Memory pattern** | No | No | No | No | No | 4-type, documented universally; native directory on Claude only |
+| **Bilingual (한/영)** | Translations available | English-first | English-first | English-first | DIY | First-class (한/영, README + marketing) |
+| **Origin** | Single-author theory | Microsoft research roots | Indie author | IDE vendor | None | One year of production iteration at LFamily Labs |
+| **Maturity** | High (many skills) | High (well-documented) | High (community) | Medium | N/A | All 6 adapters working + CI-validated, npm-published; 1.0 shipped 2026-07 (current version in `CHANGELOG.md`) |
+| **License** | MIT (varies) | MIT | Commercial-friendly | Proprietary IDE | N/A | Apache 2.0 + CONDUCTOR-name trademark (ADR-029) |
+| **Telemetry** | Varies | None | None | Cursor opt-in | None | None ever (ADR-008) |
+| **Uninstall path** | Per-skill manual delete | Per-phase manual delete | Per-artifact manual delete | None (rules accumulate) | N/A | `transform.sh --uninstall` (manifest-tracked, restores backups) — ADR-020 |
+
+## When to pick which
+
+### Pick GSD / BMAD if:
+You want maximum depth, a large skill catalog, an existing community, and you don't mind heavy setup. GSD is the maximalist choice for users who want every workflow phase covered with a dedicated skill.
+
+### Pick SpecKit if:
+You want a Microsoft-pedigree, well-documented spec-driven workflow with clear phase gates. Strong for enterprise teams that already use Microsoft developer tooling.
+
+### Pick Cursor Rules if:
+You only use Cursor and don't anticipate switching tools. Cursor Rules give you what Cursor natively supports — no abstraction overhead. (You can later cross-port to CONDUCTOR if you adopt a second tool.)
+
+### Pick plain CLAUDE.md if:
+You only use Claude Code, want zero framework, and prefer to extend incrementally. CONDUCTOR's value mostly disappears for single-tool, single-rule-file users.
+
+### Pick CONDUCTOR if:
+- You use 2+ AI coding tools on the same project (or plan to).
+- You want production-shape orchestration with ABSOLUTE enforcement of the things that actually matter at solo / small-team scale.
+- You value bilingual (한/영) onboarding.
+- You want a small, opinionated kernel — not a maximalist superset.
+- You've shipped code and felt the pain of stale docs and merged regressions.
+
+## How CONDUCTOR is different from a "rules format converter"
+
+CONDUCTOR is NOT just a tool that translates rules between formats. It is opinionated content + workflow + memory pattern that happens to be portable.
+
+If you only want format conversion, you can write a 50-line script that reads `*.md` and re-emits them with different front-matter. CONDUCTOR's universal rules (operations / quality-gates / meta-discipline / spec-as-you-go / workflow) plus the 13 opt-in recipes are the value; the multi-tool transform is the delivery vehicle.
+
+## Honest weaknesses of CONDUCTOR
+
+- **No installer GUI.** Bash adapters + the `npx omniconductor` CLI only. Power-user tool. (A VSCode-extension launcher is Phase 2 — ADR-023/025.)
+- **Enforcement emission is still Claude-weighted.** All six tools now support hooks / sub-agents / model routing (ADR-031), but CONDUCTOR's adapters currently *emit* the full hook + agent set for Claude only; the other five get the rule/recipe text plus the opt-in Reflector loop. Full non-Claude emission is Phase 2.
+- **Live verification is not complete.** All 6 adapters are emit-verified in CI; live rule-loading is probed per tool by `tools/live-verify.sh`, and the current per-tool status lives in the generated table in `docs/ADAPTER-LIVE-VERIFICATION.md` (single-sourced from adapter metadata).
+- **No community yet.** No Discord, no Twitter/X presence. You're an early adopter.
+- **Tool fragmentation risk.** If 12 new tools launch in 2026, we cannot keep up. Mitigated by documented adapter contribution path (`docs/CONTRIBUTING.md`).
+- **Claude-Code bias.** The orchestrator-centric model maps naturally to Claude. On other tools the human carries more of the weight. This is documented honestly (ADR-004) but it is a real bias.
+- **Two-stage code review on Claude requires the `pr-review-toolkit` plugin.** Documented in the Claude adapter notes; fallback is manual prompt reuse.
+- **Mobile rule (project-specific) is React Native flavored.** If your stack is native iOS or native Android, that rule is mostly noise — but it's project-specific and lives in your adapted output, not in `core/`.
+
+## Honest strengths
+
+- **Production pedigree.** Every rule earned through a real shipping incident at LFamily Labs. Not theoretical.
+- **Honesty over feature inflation.** ADR-004 says we will NOT fake-polyfill sub-agents anywhere; ADR-031 documents per-tool capability vs what CONDUCTOR actually emits. Other multi-tool projects gloss over this.
+- **Bilingual moat.** Korean solo-dev community is meaningful and underserved.
+- **Apache 2.0, no telemetry, no paid tier — fully open and commercial-friendly.** Only the **CONDUCTOR** name is reserved (trademark), so nobody can pass off a modified copy as the original. Same permissive footing as MIT competitors, with brand protection (ADR-029).
+- **Small, opinionated kernel.** 5 universal rules (plus 13 strictly opt-in recipes and 10 hook templates) vs GSD's 60 skills. If our rules are wrong for you, you'll know quickly and can move on. No 6-month sunk cost.
+
+## Verdict
+
+If you only ship in Claude Code and you love opinionated tooling, CONDUCTOR is a strict upgrade over plain CLAUDE.md.
+
+If you ship in multiple tools, CONDUCTOR is the only option that treats portability as a first-class requirement rather than a future maybe.
+
+If you want a maximalist phase-gated SDLC tool with broad runtime support and an existing community, pick GSD or BMAD; CONDUCTOR is intentionally smaller and more opinionated.
+
+## Conflict resolution: Superpowers + CONDUCTOR on the same project
+
+> Added 2026-05-09 per ADR-019, finding from `docs/audits/competitive-analysis-2026-05-09.md` (P1c).
+
+Superpowers (a Claude Code plugin set offering brainstorming / planning / TDD / debugging skills) and CONDUCTOR overlap in workflow scope. Running both unmoderated double-loads guidance into every turn, hurts cache hit rate, and creates ambiguity about which workflow the orchestrator should follow.
+
+### Workflow overlap matrix
+
+| Workflow area | Superpowers | CONDUCTOR | Overlap risk |
+|---|---|---|---|
+| Brainstorming | `superpowers:brainstorming` skill | `core/universal-rules/workflow.md` Plan-first + AMB triggers | High — both frame the requirements stage, prompts compete |
+| Planning / writing plans | `superpowers:writing-plans` | `workflow.md` 7-step + `meta-discipline.md` ACT-WITH-DECLARATION | High — both produce `.plan.md`-style artifacts |
+| Plan execution | `superpowers:executing-plans` / `subagent-driven-development` | Centralized + Role-Specialized orchestration (ADR-010) | High — both manage sub-agent dispatch but with different guardrails |
+| TDD | `superpowers:test-driven-development` | `quality-gates.md` Q3 (test-coverage sync) | Medium — Superpowers prescribes red/green/refactor; CONDUCTOR prescribes coverage parity. Compatible if order is fixed. |
+| Debugging | `superpowers:systematic-debugging` | None — left to project judgement | Low — adopt Superpowers' debugging skill freely; no conflict. |
+| Code review | `superpowers:requesting-code-review` / `receiving-code-review` | `quality-gates.md` Q1 (pre-commit) + Q2 (pre-merge) two-stage | Medium — Superpowers covers etiquette; CONDUCTOR covers gate enforcement. Stack as etiquette-on-top-of-gates. |
+| Git worktrees | `superpowers:using-git-worktrees` | None | None — Superpowers complements, not conflicts. |
+| Verification before completion | `superpowers:verification-before-completion` | `quality-gates.md` Q1/Q4 | Low — same intent, different surface. Pick one; CONDUCTOR's hook-enforced version is stricter. |
+
+### Cache-hit impact
+
+ADR-014 sets a 95% cache-hit floor as CONDUCTOR's SLA. Loading both rule sets into the cacheable prefix doubles the volatile-content surface (Superpowers' SKILL.md descriptions update, CONDUCTOR's `core/universal-rules/*` update) — every change in either invalidates the cache. Empirically, projects that run both without reconciliation drop from 100% to 60-80% hit rate within two weeks. Run `tools/measure-tokens.sh --latest` after enabling both to baseline; if hit rate drops below 95%, follow option A or B below.
+
+### Recommended patterns
+
+**Option A — CONDUCTOR only (recommended for new projects)**
+
+Use CONDUCTOR's universal rules + roles + recipes. Skip Superpowers entirely. The 5-rule kernel covers planning, spec-as-you-go, quality gates, operations, and meta-discipline; the 6 roles cover orchestration. Add Superpowers later only if a specific skill (e.g. `using-git-worktrees`) is missing.
+
+**Option B — Superpowers as primary, CONDUCTOR recipes only (for projects already on Superpowers)**
+
+Keep Superpowers in charge of workflow. Cherry-pick CONDUCTOR recipes that don't overlap — `monorepo`, `i18n`, `coding-conventions`, `branch-strategy`, `auto-mock-data` — without installing the universal rules or roles. Procedure:
+
+```bash
+# Install only recipes (no universal-rules, no roles, no hooks):
+bash adapters/claude/transform.sh <target> --recipes=monorepo,i18n,coding-conventions --no-prompt
+# Then manually delete the universal-rules and agent files emitted by transform.sh:
+rm <target>/.claude/rules/{workflow,spec-as-you-go,quality-gates,operations,meta-discipline}.md
+rm <target>/.claude/agents/*.md
+```
+
+> Note: a future `--recipes-only` flag (separate dispatch) will streamline this. Until then, the manual deletion above is the supported procedure. The recently shipped `--uninstall` (ADR-020) reverts the entire install — including recipes — so a Superpowers-primary user can clean-slate via `transform.sh <target> --uninstall` and re-run with the recipes-only convention above when it lands.
+
+**Option C — Both (NOT recommended, requires manual reconciliation)**
+
+If you must run both:
+1. Disable overlapping Superpowers skills (`brainstorming`, `writing-plans`, `executing-plans`, `verification-before-completion`) by removing them from the active plugin set, or by adding a project-level rule that says "skill X disabled, see CONDUCTOR's `workflow.md` instead".
+2. Re-measure cache hit rate after one week. If below 95%, escalate to option A or B.
+3. Document the active reconciliation in `CLAUDE.md` so the orchestrator doesn't oscillate between guidance sources.
+
+### Cross-reference
+
+- Audit basis: `docs/audits/competitive-analysis-2026-05-09.md` — full Superpowers feature inventory and cache-hit rationale.
+- ADR-019 in `docs/DESIGN-DECISIONS.md` — decision record for the cleanup batch that produced this section.
+- ADR-014 in `docs/DESIGN-DECISIONS.md` — 95% cache-hit floor SLA.

package/docs/COMPATIBILITY-MATRIX.md

@@ -0,0 +1,126 @@
+# COMPATIBILITY MATRIX — CONDUCTOR per tool
+
+This matrix describes which CONDUCTOR features are supported by each target tool. ✅ = native support, ⚠️ = partial / requires manual work, ❌ = not supported.
+
+> **Status note (re-verified 2026-07-04)**: ratings are the *tool-capability* level, re-verified against **first-party sources** (official docs / changelogs / tool GitHub repos) on 2026-07-04. The prior matrix (dated 2026-05-03) marked hooks and several other features as Claude-only; that is now **out of date** — all six tools ship event hooks (see the Hooks row + footnotes).
+>
+> **Capability ≠ CONDUCTOR emission.** A ✅ here means the *tool* documents the feature, NOT that a CONDUCTOR adapter already compiles to it. **Update (2026-07-04, ADR-032):** the **self-improvement / Reflector loop is now emitted for all six adapters** (a session-end trajectory-log hook, a `/reflect` command, a reflector agent-or-rule, and the prune script — recipe-gated on `--recipes=self-improvement`), so for that one capability the emission gap is closed on every tool (Windsurf via `post_cascade_response_with_transcript`, which is per-response not per-session). **Update (2026-07-05, ADR-033):** weekly-run scheduling is now shipped too — every adapter emits `.conductor/reflect/run-weekly.sh` (auto-detects the tool's headless CLI) + `SCHEDULING.md` (per-tool cron/launchd + native-scheduler registration, with the cloud-scheduler-can't-see-local-trajectories caveat). **Still Phase 2:** emitting the *rest* of the hook set (agent-routing / commit / large-file guards) on the five non-Claude adapters (see `docs/specs/2026-07-03-multitool-parity-reverification-SPEC-B-handoff.md`). Cells corrected in this pass are limited to what a first-party source confirms; unverifiable claims are hedged in the footnotes rather than shipped as ✅.
+>
+> **Naming:** Windsurf was **rebranded to "Devin Desktop"** (June 2026, per its own changelog); the "Windsurf" column name is kept here for adopter familiarity. Its **rules** now live under `.devin/rules/` (legacy `.windsurf/rules/`); other config (workflows, memories) remains under `.windsurf/` and `~/.codeium/windsurf/` — see footnote 11.
+
+## Feature support matrix
+
+| Feature | Claude Code | Cursor | Copilot | Gemini CLI | Codex | Windsurf |
+|---|---|---|---|---|---|---|
+| **Sub-agent dispatch** (Plan → delegate → verify) | ✅ Agent tool | ✅¹ | ✅¹ | ✅¹ | ✅¹ | ✅¹ |
+| **Hooks** (PreToolUse / Stop / etc.) | ✅ | ✅² | ✅² | ✅² | ✅² | ⚠️² |
+| **Custom named agents** (own system prompt) | ✅ `.claude/agents/*.md` | ✅³ | ✅³ | ✅³ | ✅³ | ⚠️³ |
+| **Per-task model routing** (triage per call/agent) | ✅ per-call `model:` | ✅⁴ | ✅⁴ | ✅⁴ | ✅⁴ | ✅⁴ |
+| **Slash / custom commands** | ✅ | ✅⁵ | ✅⁵ | ✅⁵ | ✅⁵ | ✅⁵ |
+| **Built-in managed memory** | ✅ `~/.claude/projects/.../memory/` | ⚠️⁶ | ✅⁶ | ⚠️⁶ | ✅⁶ | ✅⁶ |
+| **Native scheduled agents/jobs** | ✅ Routines | ✅⁷ | ✅⁷ | ⚠️⁷ | ✅⁷ | ⚠️⁷ |
+| **Machine-readable transcripts** | ✅ JSONL | ✅⁸ | ⚠️⁸ | ✅⁸ | ✅⁸ | ✅⁸ |
+| **AGENTS.md context file** | ⚠️⁹ (CLAUDE.md) | ✅⁹ | ✅⁹ | ⚠️⁹ | ✅⁹ | ✅⁹ |
+| **Lazy-loaded rules** (glob on file-touch) | ✅ paths front-matter | ✅ `globs:` on `.mdc` | ✅ `applyTo:` | ⚠️¹⁰ | ⚠️¹⁰ | ⚠️ directory-based |
+| **Always-loaded baseline** | ✅ `CLAUDE.md` | ✅ `.cursor/rules/*.mdc` (`alwaysApply`; `.cursorrules` legacy) | ✅ `applyTo: '**'` | ✅ `GEMINI.md` | ✅ `AGENTS.md` | ✅ `.windsurf`/`.devin` rules¹¹ |
+| **Skill / plugin ecosystem** | ✅ | ✅ Skills⁵ | ⚠️ MCP + prompt files | ⚠️ tools + extensions | ✅ Skills⁵ | ⚠️ workflows/skills |
+| **Spec-as-you-go enforcement (auto-block)** | ✅ Stop hook | ✅¹² | ✅¹² | ✅¹² | ✅¹² | ⚠️¹² |
+| **Two-stage code review enforcement** | ✅ Stop hook | ✅¹² | ✅¹² (+ native PR review) | ✅¹² | ✅¹² | ⚠️¹² |
+| **In-repo doc templates work as-is** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| **Bilingual rule support (한/영)** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+
+**Footnotes (first-party sources, verified 2026-07-04).** ✅ = tool capability confirmed; it does NOT mean a CONDUCTOR adapter emits it yet (non-Claude emission is Phase 2 — see the status note).
+
+1. **Sub-agent dispatch** — Cursor 2.4+ (`cursor.com/docs/subagents`), Copilot VS Code (`code.visualstudio.com/docs/copilot/agents/subagents`), Gemini CLI (`enableAgents`, on by default), Codex (on by default, `max_depth` 1), Windsurf via **Devin Local**. All single-level nesting. CONDUCTOR keeps sub-agent *compilation* Claude-only by design (ADR-004); the ✅s mark native tool capability, a candidate to revisit — not current emission.
+2. **Hooks** — Cursor v1.7 (2025-09-29 beta), Gemini v0.26.0 (2026-01-28, default-on), Copilot CLI + cloud-agent + VS Code (Preview; Claude-Code hook *format*, with different tool names), Codex (default-on; intro date not pinnable first-party). Windsurf ⚠️: 12 hook events but **no session-start/end**, so Stop-style enforcement is unavailable.
+3. **Custom named agents** — Cursor `.cursor/agents/` (also reads `.claude/agents/`), Copilot `.github/agents/*.agent.md`, Gemini `.gemini/agents/*.md`, Codex `~/.codex/agents/*.toml` (`developer_instructions` + optional per-agent model). Windsurf ⚠️: documented for **Devin CLI** (`.devin/agents/{name}/AGENT.md`); Desktop confirmation implicit only.
+4. **Per-task model routing** — corrects the old "single model per session" claim. Cursor per-chat + per-subagent `model:`; Copilot per-request + per-agent `model:`; Gemini `--model`/`/model`/per-subagent; Codex per-invocation `-m` / `/model` / per-profile; Windsurf per-conversation dropdown + per-subagent defaults.
+5. **Slash / custom commands** — Cursor `.cursor/commands/*.md` (→ Skills in 2.4+), Copilot prompt files `.github/prompts/*.prompt.md`, Gemini `.gemini/commands/*.toml`, Codex Skills `.agents/skills` (`~/.codex/prompts/*.md` still work but deprecated), Windsurf workflows `.windsurf/workflows/*.md` (manual-only).
+6. **Built-in managed memory** — Copilot "Copilot Memory" (preview; on-by-default for Pro since 2026-03; 28-day expiry), Codex `~/.codex/memories/` (opt-in), Windsurf `~/.codeium/windsurf/memories/`. ⚠️ Cursor: Memories GA'd in 1.2 but the docs page now redirects to Rules — current 2.x/3.x status unverified. ⚠️ Gemini: managed memory exists (hierarchical `GEMINI.md` + experimental Auto Memory) but the old `save_memory`/`/memory add` mechanism is gone from current docs.
+7. **Native scheduled jobs** — Claude Routines, Cursor Automations (cloud-only, 2026-03), Copilot cloud-agent automations (2026-06-02) + CLI prompt scheduling, Codex Automations (cron; intro date not first-party). ⚠️ Gemini: no built-in scheduler — first-party path is the official GitHub Action on `schedule:`. ⚠️ Windsurf / Devin Desktop: no native desktop scheduler documented — external cron/launchd + Devin CLI is the only path.
+8. **Transcripts** — Claude JSONL `~/.claude/projects/`, Cursor hook `transcript_path` (local on-disk path is unofficial → omitted), Gemini `~/.gemini/tmp/<hash>/chats/`, Codex `~/.codex/sessions/`, Windsurf transcript hook `~/.windsurf/transcripts/`. ⚠️ Copilot: hook `transcriptPath` only; the coding agent has **no transcript API** (UI / VS Code-viewable only).
+9. **AGENTS.md** — Cursor/Copilot/Codex/Windsurf read it natively. ⚠️ Gemini: only via `context.fileName` config (default is `GEMINI.md`). Claude ⚠️: uses `CLAUDE.md` natively (Copilot/Codex also read `CLAUDE.md`).
+10. **Lazy rules** — Gemini/Codex offer nested `GEMINI.md`/`AGENTS.md` directory-hierarchy scoping, not glob-on-file-touch loading.
+11. **Windsurf paths** — rules are now `.devin/rules/` (legacy `.windsurf/rules/`). The CONDUCTOR Windsurf adapter **emits `.devin/rules/*.md`** (preferred) plus the always-loaded `.windsurfrules` baseline — target path already updated (as of v0.6).
+12. **Auto-block enforcement** — every non-Claude tool now has hooks that can block (exit-code-2 / deny), so spec-as-you-go and review enforcement are *capable* on Cursor/Copilot/Gemini/Codex. ⚠️ Windsurf: no Stop/session event → pre-tool blocking only. CONDUCTOR emits these hooks for Claude only today; non-Claude hook emission is Phase 2. Copilot review = native GitHub PR review (a different mechanism).
+
+## Tier assignment
+
+Tiers are re-defined for the 2026 reality. The old T3 definition ("sub-agents/hooks not available") is obsolete — every tool now has hooks + sub-agents + custom agents + per-task model routing + commands. Tiers now reflect **how completely CONDUCTOR can map the full workflow** (glob rule-scoping, Stop-style enforcement events, a native scheduler for the Reflector), and adapter-emission readiness.
+
+| Tier | Tools | Definition |
+|---|---|---|
+| **T1 — Full** | Claude Code, Cursor | Glob rule-scoping + hooks (incl. session/stop events) + sub-agents + per-task model + native scheduler (Cursor's is cloud-only) all present. Claude emits all of it today; Cursor is the richest non-Claude target for Phase 2 emission. |
+| **T2 — Good** | Copilot, Codex, Gemini CLI | Hooks + sub-agents + custom agents + per-task model + commands all present. Caveats: Copilot rule-scoping is glob (`applyTo:`) but the coding agent has no transcript API; Codex/Gemini scope by nested-file hierarchy, not glob; Gemini has no native scheduler (external Action). |
+| **T3 — Basic** | Windsurf / Devin Desktop | Has hooks (but **no session/stop events** → no Stop-style enforcement), sub-agents (Devin Local), commands, memory. No desktop scheduler; rules path moved to `.devin/rules/` (adapter emits it). |
+
+## Adapter outputs at a glance (generated)
+
+<!-- generated:adapter-outputs-table — edit adapters/*/metadata.json + run tools/generate-adapter-docs.js; do not hand-edit (ADR-042) -->
+| Tool | Tier | Emitted outputs | Legacy paths (still read) | Live-verified | Headless CLI | À la carte (`--mode`) |
+|---|---|---|---|---|---|---|
+| Claude Code | T1 | `CLAUDE.md` + `.claude/rules` + `.claude/agents` + `.claude/hooks` + `.claude/settings.json` + `docs/CURRENT_WORK.md` | — | ✅ 2026-07-09 | `claude -p` | per-file |
+| Cursor | T1 | `.cursor/rules` + `docs/CURRENT_WORK.md` | `.cursorrules` (legacy) | 🧪 pending | `cursor-agent -p` | per-file |
+| Copilot | T2 | `.github/copilot-instructions.md` + `.github/instructions` + `docs/CURRENT_WORK.md` | — | 🧪 pending | `copilot -p` | per-file |
+| Gemini CLI | T2 | `GEMINI.md` + `.gemini/styleguide.md` + `docs/CURRENT_WORK.md` | — | 🧪 pending | `gemini -p` | marked block |
+| Codex | T2 | `AGENTS.md` + `docs/CURRENT_WORK.md` | `.codex/codex.md` (legacy) | ✅ 2026-07-09 | `codex exec` | marked block |
+| Windsurf | T3 | `.windsurfrules` + `.devin/rules` + `docs/CURRENT_WORK.md` | `.windsurf/rules` (legacy) | 🧪 pending | `devin -p` | per-file |
+<!-- /generated:adapter-outputs-table -->
+
+Source of truth: `adapters/<tool>/metadata.json` (ADR-040) — CI regenerates and fails on drift.
+
+## Verdict — "If you need X, use Y"
+
+| Need | Recommended tool |
+|---|---|
+| Multi-file refactor with delegated sub-agents + auto-blocking on missing spec updates | **Claude Code** |
+| Fast in-IDE chat + completion + decent rule scoping | **Cursor** |
+| In-line completion + PR review automation tied to GitHub | **GitHub Copilot** |
+| Cheap large-context exploration over long files | **Gemini CLI** |
+| Shell-driven scripting tasks | **Codex** |
+| Cursor-like flow in a different IDE | **Windsurf** |
+
+CONDUCTOR's job is to make sure **whichever tool you pick, you get the same Plan → Architecture → Tasks → Implementation → Review → Spec workflow** — even if the enforcement mechanism degrades from "auto-blocked by hook" (Claude) to "rule reminder text" (everywhere else).
+
+## What you LOSE going from Claude → other tools
+
+This list used to be long. As of the 2026-07-04 re-verification it is **much shorter** — sub-agents, hooks, custom named agents, per-task model routing, and commands are now native across the ecosystem. Two real gaps remain:
+
+- **CONDUCTOR adapter emission** — the framework's non-Claude adapters do not *yet* compile to those native hooks / agents / scheduled jobs. Until Phase 2 lands (see the Spec B handoff), the enforcement on Cursor/Copilot/Gemini/Codex/Windsurf is still rule-reminder text even though the *tool* could enforce it. This is a CONDUCTOR gap, not a tool gap.
+- **Windsurf / Devin Desktop** — genuinely lacks session-start/stop hook events, so Stop-style "auto-block on missing spec update" cannot be built there regardless of adapter work; and it has no desktop scheduler for a Reflector job.
+
+Smaller residuals: Gemini/Codex scope rules by nested-file hierarchy rather than glob-on-file-touch; Gemini has no built-in scheduler (use the official GitHub Action); Copilot's coding agent exposes no transcript API.
+
+What you KEEP everywhere (unchanged):
+
+- All rule text (operations, coding-conventions, token-economy, spec-as-you-go, model-routing).
+- All doc templates (CURRENT_WORK, REMAINING_TASKS, PLANS, TASKS, INDEX, specs/_example).
+- The 4-type memory pattern (built-in managed memory now also exists on Copilot/Codex/Windsurf).
+- The Plan → Architecture → Tasks → Impl → Review → Spec phase definitions.
+
+The discipline is portable. The *enforcement* is now portable in principle too — CONDUCTOR just has to emit it (Phase 2).
+
+## Verification status
+
+| Adapter | Adapter spec written | Transform script written | Format validator | Per-IDE smoke (manual) | Real install verified | Quirks documented |
+|---|---|---|---|---|---|---|
+| Claude Code | ✅ (P0) | ✅ (SHIPPED v0.2 P1) | ✅ `validate-adapter-output.sh claude` PASS (2026-05-10) | n/a (Claude Code CLI itself is the runtime; covered by orchestrator harness) | ✅ (7 uninstall verification cases 2026-05-10, ADR-020) | ✅ (ADR-019, ADR-020, IDE-COMPATIBILITY-NOTES § Claude) |
+| Cursor | ✅ (P0) | ✅ (SHIPPED v0.2, ADR-021) | ✅ `validate-adapter-output.sh cursor` PASS (2026-05-10) | ⏳ pending (Cursor smoke — see IDE-SMOKE-TESTING § 1) | ⚠️ Synthetic-target smoke + format-validator PASS (4 cases 2026-05-10); real-IDE empirical verification deferred to adopter feedback | ✅ (ADR-021, IDE-COMPATIBILITY-NOTES § Cursor) |
+| Copilot | ✅ (P0) | ✅ (SHIPPED v0.2, ADR-022) | ✅ `validate-adapter-output.sh copilot` PASS (2026-05-10) | ⏳ pending per IDE: VS Code (§ 2), Cursor+Copilot (§ 3), Windsurf (§ 4), JetBrains (§ 5), Neovim (§ 6) | ⚠️ Synthetic-target smoke + format-validator PASS (3 cases 2026-05-10 — fresh / adopter / per-rule); per-IDE real smoke deferred to adopter feedback | ✅ (ADR-022, IDE-COMPATIBILITY-NOTES § Copilot) |
+| Gemini CLI | ✅ (P0) | ✅ (SHIPPED v0.2 — `adapters/gemini/transform.sh` → `GEMINI.md` + `.gemini/styleguide.md`) | ✅ `validate-adapter-output.sh gemini` PASS | n/a (CLI runtime) | ⚠️ Emit-verified (format-validator + synthetic-target smoke PASS); live runtime consumption by Gemini CLI still pending — see `docs/ADAPTER-LIVE-VERIFICATION.md` | ✅ (IDE-COMPATIBILITY-NOTES § Gemini) |
+| Codex | ✅ (P0) | ✅ (SHIPPED v0.2 — `adapters/codex/transform.sh` → `AGENTS.md`) | ✅ `validate-adapter-output.sh codex` PASS | n/a (CLI runtime) | ✅ **Live-verified** — auto-probed by `tools/live-verify.sh` (`codex exec` loaded `AGENTS.md` and listed the universal rules + read-CURRENT_WORK-first); current date/CLI in the generated "Adapter outputs at a glance" table above. Also emit-verified (format-validator PASS). | ✅ (IDE-COMPATIBILITY-NOTES § Codex) |
+| Windsurf | ✅ (P0) | ✅ (SHIPPED v0.2 — own `adapters/windsurf/transform.sh` → `.windsurfrules` + `.devin/rules/*.md` (legacy `.windsurf/rules/` still read) — see footnote 11) | ✅ `validate-adapter-output.sh windsurf` PASS | ⏳ adopter follow-up / live-pending (IDE-SMOKE-TESTING § 4) | ⚠️ Emit-verified (format-validator + synthetic-target smoke PASS); live runtime consumption still pending — see `docs/ADAPTER-LIVE-VERIFICATION.md` | ✅ (IDE-COMPATIBILITY-NOTES § Windsurf) |
+
+## Copilot adapter — IDE coverage
+
+The Copilot adapter is the strategic ROI win in P3: a single transform.sh produces files (`.github/copilot-instructions.md` + `.github/instructions/*.instructions.md`) that every IDE with a Copilot client reads natively. Adopters do not run the adapter once per IDE.
+
+| IDE | Copilot client | Reads `.github/copilot-instructions.md` | Reads `.github/instructions/*.instructions.md` | Empirical verification | Smoke checklist |
+|---|---|---|---|---|---|
+| VS Code | Built-in (Copilot extension) | ✅ documented | ✅ documented | ⏳ adopter follow-up | `IDE-SMOKE-TESTING.md` § 2 |
+| Cursor | Copilot extension (in addition to native `.cursor/rules/`) | ✅ documented | ⚠️ depends on extension version | ⏳ adopter follow-up | `IDE-SMOKE-TESTING.md` § 3 |
+| Windsurf | Copilot adapter | ✅ documented | ⚠️ depends on adapter version | ⏳ adopter follow-up | `IDE-SMOKE-TESTING.md` § 4 |
+| JetBrains family (IntelliJ, WebStorm, PyCharm, etc.) | Copilot plugin | ✅ documented | ✅ documented (2024.3+) | ⏳ adopter follow-up | `IDE-SMOKE-TESTING.md` § 5 |
+| Neovim | `copilot.vim` (or `copilot.lua`) | ⚠️ chat-only feature; completion side ignores | ⚠️ chat-only feature | ⏳ adopter follow-up | `IDE-SMOKE-TESTING.md` § 6 |
+
+The "documented" column reflects GitHub's official Copilot custom-instructions spec. Per-IDE empirical verification (open the IDE, confirm the rule shows in Copilot Chat references, edit a matching file, verify the per-file instruction loads) is now covered by the manual smoke checklists in `IDE-SMOKE-TESTING.md` (one section per IDE) — adopter-driven, results recorded back into the "Per-IDE smoke (manual)" column above. `transform.sh` is auto-validated by `tools/validate-adapter-output.sh` (format-level conformance) plus the original three temp-target install smoke runs against a synthetic Conductor source tree. Per-IDE quirks are inventoried in `docs/IDE-COMPATIBILITY-NOTES.md`.