@every-env/compound-plugin 0.8.0 → 0.12.0

package/.claude-plugin/marketplace.json

@@ -1,5 +1,5 @@
 {
-  "name": "every-marketplace",
+  "name": "compound-engineering-plugin",
   "owner": {
     "name": "Kieran Klaassen",
     "url": "https://github.com/kieranklaassen"
@@ -11,8 +11,8 @@
   "plugins": [
     {
       "name": "compound-engineering",
-      "description": "AI-powered development tools that get smarter with every use. Make each unit of engineering work easier than the last. Includes 29 specialized agents, 22 commands, and 19 skills.",
-      "version": "2.34.0",
+      "description": "AI-powered development tools that get smarter with every use. Make each unit of engineering work easier than the last. Includes 29 specialized agents, 22 commands, and 20 skills.",
+      "version": "2.38.0",
       "author": {
         "name": "Kieran Klaassen",
         "url": "https://github.com/kieranklaassen",

package/AGENTS.md

@@ -7,7 +7,7 @@ This repository contains a Bun/TypeScript CLI that converts Claude Code plugins
 - **Branching:** Create a feature branch for any non-trivial change. If already on the correct branch for the task, keep using it; do not create additional branches or worktrees unless explicitly requested.
 - **Safety:** Do not delete or overwrite user data. Avoid destructive commands.
 - **Testing:** Run `bun test` after changes that affect parsing, conversion, or output.
-- **Output Paths:** Keep OpenCode output at `opencode.json` and `.opencode/{agents,skills,plugins}`.
+- **Output Paths:** Keep OpenCode output at `opencode.json` and `.opencode/{agents,skills,plugins}`. For OpenCode, command go to `~/.config/opencode/commands/<name>.md`; `opencode.json` is deep-merged (never overwritten wholesale).
 - **ASCII-first:** Use ASCII unless the file already contains Unicode.
 
 ## Adding a New Target Provider (e.g., Codex)
@@ -46,3 +46,7 @@ Add a new provider when at least one of these is true:
 - You can write fixtures + tests that validate the mapping.
 
 Avoid adding a provider if the target spec is unstable or undocumented.
+
+## Repository Docs Convention
+
+- **Plans** live in `docs/plans/` and track implementation progress.

package/CHANGELOG.md

@@ -5,6 +5,56 @@ All notable changes to the `@every-env/compound-plugin` CLI tool will be documen
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.12.0] - 2026-03-01
+
+### Added
+
+- **Auto-detect install targets** — `install --to all` and `convert --to all` auto-detect installed AI coding tools and install to all of them in one command
+- **Gemini sync** — `sync --target gemini` symlinks personal skills to `.gemini/skills/` and merges MCP servers into `.gemini/settings.json`
+- **Sync all targets** — `sync --target all` syncs personal config to all detected tools
+- **Tool detection utility** — Checks config directories for OpenCode, Codex, Droid, Cursor, Pi, and Gemini
+
+---
+
+## [0.11.0] - 2026-03-01
+
+### Added
+
+- **OpenClaw target** — `--to openclaw` converts plugins to OpenClaw format. Agents become `.md` files, commands become `.md` files, pass-through skills copy unchanged, and MCP servers are written to `openclaw-extension.json`. Output goes to `~/.openclaw/extensions/<plugin-name>/` by default. Use `--openclaw-home` to override. ([#217](https://github.com/EveryInc/compound-engineering-plugin/pull/217)) — thanks [@TrendpilotAI](https://github.com/TrendpilotAI)!
+- **Qwen Code target** — `--to qwen` converts plugins to Qwen Code extension format. Agents become `.yaml` files with Qwen-compatible fields, commands become `.md` files, MCP servers write to `qwen-extension.json`, and a `QWEN.md` context file is generated. Output goes to `~/.qwen/extensions/<plugin-name>/` by default. Use `--qwen-home` to override. ([#220](https://github.com/EveryInc/compound-engineering-plugin/pull/220)) — thanks [@rlam3](https://github.com/rlam3)!
+- **Windsurf target** — `--to windsurf` converts plugins to Windsurf format. Claude agents become Windsurf skills (`skills/{name}/SKILL.md`), commands become flat workflows (`global_workflows/{name}.md` for global scope, `workflows/{name}.md` for workspace), and pass-through skills copy unchanged. MCP servers write to `mcp_config.json` (machine-readable, merged with existing config). ([#202](https://github.com/EveryInc/compound-engineering-plugin/pull/202)) — thanks [@rburnham52](https://github.com/rburnham52)!
+- **Global scope support** — New `--scope global|workspace` flag (generic, Windsurf as first adopter). `--to windsurf` defaults to global scope (`~/.codeium/windsurf/`), making installed skills, workflows, and MCP servers available across all projects. Use `--scope workspace` for project-level `.windsurf/` output.
+- **`mcp_config.json` integration** — Windsurf converter writes proper machine-readable MCP config supporting stdio, Streamable HTTP, and SSE transports. Merges with existing config (user entries preserved, plugin entries take precedence). Written with `0o600` permissions.
+- **Shared utilities** — Extracted `resolveTargetOutputRoot` to `src/utils/resolve-output.ts` and `hasPotentialSecrets` to `src/utils/secrets.ts` to eliminate duplication.
+
+### Fixed
+
+- **OpenClaw code injection** — `generateEntryPoint` now uses `JSON.stringify()` for all string interpolation (was escaping only `"`, leaving `\n`/`\\` unguarded).
+- **Qwen `plugin.manifest.name`** — context file header was `# undefined` due to using `plugin.name` (which doesn't exist on `ClaudePlugin`); fixed to `plugin.manifest.name`.
+- **Qwen remote MCP servers** — curl fallback removed; HTTP/SSE servers are now skipped with a warning (Qwen only supports stdio transport).
+- **`--openclaw-home` / `--qwen-home` CLI flags** — wired through to `resolveTargetOutputRoot` so custom home directories are respected.
+
+---
+
+## [0.9.1] - 2026-02-20
+
+### Changed
+
+- **Remove docs/reports and docs/decisions directories** — only `docs/plans/` is retained as living documents that track implementation progress
+- **OpenCode commands as Markdown** — commands are now `.md` files with deep-merged config, permissions default to none ([#201](https://github.com/EveryInc/compound-engineering-plugin/pull/201)) — thanks [@0ut5ider](https://github.com/0ut5ider)!
+- **Fix changelog GitHub link** ([#215](https://github.com/EveryInc/compound-engineering-plugin/pull/215)) — thanks [@XSAM](https://github.com/XSAM)!
+- **Update Claude Code install command in README** ([#218](https://github.com/EveryInc/compound-engineering-plugin/pull/218)) — thanks [@ianguelman](https://github.com/ianguelman)!
+
+---
+
+## [0.9.0] - 2026-02-17
+
+### Added
+
+- **Kiro CLI target** — `--to kiro` converts plugins to `.kiro/` format with custom agent JSON configs, prompt files, skills, steering files, and `mcp.json`. Only stdio MCP servers are supported ([#196](https://github.com/EveryInc/compound-engineering-plugin/pull/196)) — thanks [@krthr](https://github.com/krthr)!
+
+---
+
 ## [0.8.0] - 2026-02-17
 
 ### Added

package/CLAUDE.md

@@ -1,11 +1,11 @@
-# Every Marketplace - Claude Code Plugin Marketplace
+# compound-engineering-plugin - Claude Code Plugin Marketplace
 
 This repository is a Claude Code plugin marketplace that distributes the `compound-engineering` plugin to developers building with AI-powered tools.
 
 ## Repository Structure
 
 ```
-every-marketplace/
+compound-engineering-plugin/
 ├── .claude-plugin/
 │   └── marketplace.json          # Marketplace catalog (lists available plugins)
 ├── docs/                         # Documentation site (GitHub Pages)
@@ -261,7 +261,7 @@ python -m http.server 8000
 1. Install the marketplace locally:
 
    ```bash
-   claude /plugin marketplace add /Users/yourusername/every-marketplace
+   claude /plugin marketplace add /Users/yourusername/compound-engineering-plugin
    ```
 
 2. Install the plugin:

package/README.md

@@ -8,7 +8,7 @@ A Claude Code plugin marketplace featuring the **Compound Engineering Plugin**
 ## Claude Code Install
 
 ```bash
-/plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin
+/plugin marketplace add EveryInc/compound-engineering-plugin
 /plugin install compound-engineering
 ```
 
@@ -18,9 +18,9 @@ A Claude Code plugin marketplace featuring the **Compound Engineering Plugin**
 /add-plugin compound-engineering
 ```
 
-## OpenCode, Codex, Droid, Pi, Gemini & GitHub Copilot (experimental) Install
+## OpenCode, Codex, Droid, Pi, Gemini, Copilot, Kiro, Windsurf, OpenClaw & Qwen (experimental) Install
 
-This repo includes a Bun/TypeScript CLI that converts Claude Code plugins to OpenCode, Codex, Factory Droid, Pi, Gemini CLI and GitHub Copilot.
+This repo includes a Bun/TypeScript CLI that converts Claude Code plugins to OpenCode, Codex, Factory Droid, Pi, Gemini CLI, GitHub Copilot, Kiro CLI, Windsurf, OpenClaw, and Qwen Code.
 
 ```bash
 # convert the compound-engineering plugin into OpenCode format
@@ -40,6 +40,24 @@ bunx @every-env/compound-plugin install compound-engineering --to gemini
 
 # convert to GitHub Copilot format
 bunx @every-env/compound-plugin install compound-engineering --to copilot
+
+# convert to Kiro CLI format
+bunx @every-env/compound-plugin install compound-engineering --to kiro
+
+# convert to OpenClaw format
+bunx @every-env/compound-plugin install compound-engineering --to openclaw
+
+# convert to Windsurf format (global scope by default)
+bunx @every-env/compound-plugin install compound-engineering --to windsurf
+
+# convert to Windsurf workspace scope
+bunx @every-env/compound-plugin install compound-engineering --to windsurf --scope workspace
+
+# convert to Qwen Code format
+bunx @every-env/compound-plugin install compound-engineering --to qwen
+
+# auto-detect installed tools and install to all
+bunx @every-env/compound-plugin install compound-engineering --to all
 ```
 
 Local dev:
@@ -48,20 +66,34 @@ Local dev:
 bun run src/index.ts install ./plugins/compound-engineering --to opencode
 ```
 
-OpenCode output is written to `~/.config/opencode` by default, with `opencode.json` at the root and `agents/`, `skills/`, and `plugins/` alongside it.
-Codex output is written to `~/.codex/prompts` and `~/.codex/skills`, with each Claude command converted into both a prompt and a skill (the prompt instructs Codex to load the corresponding skill). Generated Codex skill descriptions are truncated to 1024 characters (Codex limit).
-Droid output is written to `~/.factory/` with commands, droids (agents), and skills. Claude tool names are mapped to Factory equivalents (`Bash` → `Execute`, `Write` → `Create`, etc.) and namespace prefixes are stripped from commands.
-Pi output is written to `~/.pi/agent/` by default with prompts, skills, extensions, and `compound-engineering/mcporter.json` for MCPorter interoperability.
-Gemini output is written to `.gemini/` with skills (from agents), commands (`.toml`), and `settings.json` (MCP servers). Namespaced commands create directory structure (`workflows:plan` → `commands/workflows/plan.toml`). Skills use the identical SKILL.md standard and pass through unchanged.
-Copilot output is written to `.github/` with agents (`.agent.md`), skills (`SKILL.md`), and `copilot-mcp-config.json`. Agents get Copilot frontmatter (`description`, `tools: ["*"]`, `infer: true`), commands are converted to agent skills, and MCP server env vars are prefixed with `COPILOT_MCP_`.
+<details>
+<summary>Output format details per target</summary>
+
+| Target | Output path | Notes |
+|--------|------------|-------|
+| `opencode` | `~/.config/opencode/` | Commands as `.md` files; `opencode.json` MCP config deep-merged; backups made before overwriting |
+| `codex` | `~/.codex/prompts` + `~/.codex/skills` | Each command becomes a prompt + skill pair; descriptions truncated to 1024 chars |
+| `droid` | `~/.factory/` | Tool names mapped (`Bash`→`Execute`, `Write`→`Create`); namespace prefixes stripped |
+| `pi` | `~/.pi/agent/` | Prompts, skills, extensions, and `mcporter.json` for MCPorter interoperability |
+| `gemini` | `.gemini/` | Skills from agents; commands as `.toml`; namespaced commands become directories (`workflows:plan` → `commands/workflows/plan.toml`) |
+| `copilot` | `.github/` | Agents as `.agent.md` with Copilot frontmatter; MCP env vars prefixed with `COPILOT_MCP_` |
+| `kiro` | `.kiro/` | Agents as JSON configs + prompt `.md` files; only stdio MCP servers supported |
+| `openclaw` | `~/.openclaw/extensions/<plugin>/` | Entry-point TypeScript skill file; `openclaw-extension.json` for MCP servers |
+| `windsurf` | `~/.codeium/windsurf/` (global) or `.windsurf/` (workspace) | Agents become skills; commands become flat workflows; `mcp_config.json` merged |
+| `qwen` | `~/.qwen/extensions/<plugin>/` | Agents as `.yaml`; env vars with placeholders extracted as settings; colon separator for nested commands |
 
 All provider targets are experimental and may change as the formats evolve.
 
+</details>
+
 ## Sync Personal Config
 
-Sync your personal Claude Code config (`~/.claude/`) to other AI coding tools:
+Sync your personal Claude Code config (`~/.claude/`) to other AI coding tools. Omit `--target` to sync to all detected tools automatically:
 
 ```bash
+# Sync to all detected tools (default)
+bunx @every-env/compound-plugin sync
+
 # Sync skills and MCP servers to OpenCode
 bunx @every-env/compound-plugin sync --target opencode
 
@@ -76,6 +108,12 @@ bunx @every-env/compound-plugin sync --target droid
 
 # Sync to GitHub Copilot (skills + MCP servers)
 bunx @every-env/compound-plugin sync --target copilot
+
+# Sync to Gemini (skills + MCP servers)
+bunx @every-env/compound-plugin sync --target gemini
+
+# Sync to all detected tools
+bunx @every-env/compound-plugin sync --target all
 ```
 
 This syncs:
@@ -92,10 +130,10 @@ Plan → Work → Review → Compound → Repeat
 
 | Command | Purpose |
 |---------|---------|
-| `/workflows:plan` | Turn feature ideas into detailed implementation plans |
-| `/workflows:work` | Execute plans with worktrees and task tracking |
-| `/workflows:review` | Multi-agent code review before merging |
-| `/workflows:compound` | Document learnings to make future work easier |
+| `/ce:plan` | Turn feature ideas into detailed implementation plans |
+| `/ce:work` | Execute plans with worktrees and task tracking |
+| `/ce:review` | Multi-agent code review before merging |
+| `/ce:compound` | Document learnings to make future work easier |
 
 Each cycle compounds: plans inform future plans, reviews catch more issues, patterns get documented.
 

package/docs/plans/2026-02-14-feat-auto-detect-install-and-gemini-sync-plan.md

@@ -0,0 +1,360 @@
+---
+title: Auto-detect install targets and add Gemini sync
+type: feat
+status: completed
+date: 2026-02-14
+completed_date: 2026-02-14
+completed_by: "Claude Opus 4.6"
+actual_effort: "Completed in one session"
+---
+
+# Auto-detect Install Targets and Add Gemini Sync
+
+## Overview
+
+Two related improvements to the converter CLI:
+
+1. **`install --to all`** — Auto-detect which AI coding tools are installed and convert to all of them in one command
+2. **`sync --target gemini`** — Add Gemini CLI as a sync target (currently missing), then add `sync --target all` to sync personal config to every detected tool
+
+## Problem Statement
+
+Users currently must run 6 separate commands to install to all targets:
+
+```bash
+bunx @every-env/compound-plugin install compound-engineering --to opencode
+bunx @every-env/compound-plugin install compound-engineering --to codex
+bunx @every-env/compound-plugin install compound-engineering --to droid
+bunx @every-env/compound-plugin install compound-engineering --to cursor
+bunx @every-env/compound-plugin install compound-engineering --to pi
+bunx @every-env/compound-plugin install compound-engineering --to gemini
+```
+
+Similarly, sync requires separate commands per target. And Gemini sync doesn't exist yet.
+
+## Acceptance Criteria
+
+### Auto-detect install
+
+- [x]`install --to all` detects installed tools and installs to each
+- [x]Detection checks config directories and/or binaries for each tool
+- [x]Prints which tools were detected and which were skipped
+- [x]Tools with no detection signal are skipped (not errored)
+- [x]`convert --to all` also works (same detection logic)
+- [x]Existing `--to <target>` behavior unchanged
+- [x]Tests for detection logic and `all` target handling
+
+### Gemini sync
+
+- [x]`sync --target gemini` symlinks skills and writes MCP servers to `.gemini/settings.json`
+- [x]MCP servers merged into existing `settings.json` (same pattern as writer)
+- [x]`gemini` added to `validTargets` in `sync.ts`
+- [x]Tests for Gemini sync
+
+### Sync all
+
+- [x]`sync --target all` syncs to all detected tools
+- [x]Reuses same detection logic as install
+- [x]Prints summary of what was synced where
+
+## Implementation
+
+### Phase 1: Tool Detection Utility
+
+**Create `src/utils/detect-tools.ts`**
+
+```typescript
+import os from "os"
+import path from "path"
+import { pathExists } from "./files"
+
+export type DetectedTool = {
+  name: string
+  detected: boolean
+  reason: string // e.g. "found ~/.codex/" or "not found"
+}
+
+export async function detectInstalledTools(): Promise<DetectedTool[]> {
+  const home = os.homedir()
+  const cwd = process.cwd()
+
+  const checks: Array<{ name: string; paths: string[] }> = [
+    { name: "opencode", paths: [path.join(home, ".config", "opencode"), path.join(cwd, ".opencode")] },
+    { name: "codex", paths: [path.join(home, ".codex")] },
+    { name: "droid", paths: [path.join(home, ".factory")] },
+    { name: "cursor", paths: [path.join(cwd, ".cursor"), path.join(home, ".cursor")] },
+    { name: "pi", paths: [path.join(home, ".pi")] },
+    { name: "gemini", paths: [path.join(cwd, ".gemini"), path.join(home, ".gemini")] },
+  ]
+
+  const results: DetectedTool[] = []
+  for (const check of checks) {
+    let detected = false
+    let reason = "not found"
+    for (const p of check.paths) {
+      if (await pathExists(p)) {
+        detected = true
+        reason = `found ${p}`
+        break
+      }
+    }
+    results.push({ name: check.name, detected, reason })
+  }
+  return results
+}
+
+export async function getDetectedTargetNames(): Promise<string[]> {
+  const tools = await detectInstalledTools()
+  return tools.filter((t) => t.detected).map((t) => t.name)
+}
+```
+
+**Detection heuristics:**
+
+| Tool | Check paths | Notes |
+|------|------------|-------|
+| OpenCode | `~/.config/opencode/`, `.opencode/` | XDG config or project-local |
+| Codex | `~/.codex/` | Global only |
+| Droid | `~/.factory/` | Global only |
+| Cursor | `.cursor/`, `~/.cursor/` | Project-local or global |
+| Pi | `~/.pi/` | Global only |
+| Gemini | `.gemini/`, `~/.gemini/` | Project-local or global |
+
+### Phase 2: Gemini Sync
+
+**Create `src/sync/gemini.ts`**
+
+Follow the Cursor sync pattern (`src/sync/cursor.ts`) since both use JSON config with `mcpServers` key:
+
+```typescript
+import path from "path"
+import { symlinkSkills } from "../utils/symlink"
+import { backupFile, pathExists, readJson, writeJson } from "../utils/files"
+import type { ClaudeMcpServer } from "../types/claude"
+
+export async function syncToGemini(
+  skills: { name: string; sourceDir: string }[],
+  mcpServers: Record<string, ClaudeMcpServer>,
+  outputRoot: string,
+): Promise<void> {
+  const geminiDir = path.join(outputRoot, ".gemini")
+
+  // Symlink skills
+  if (skills.length > 0) {
+    const skillsDir = path.join(geminiDir, "skills")
+    await symlinkSkills(skills, skillsDir)
+  }
+
+  // Merge MCP servers into settings.json
+  if (Object.keys(mcpServers).length > 0) {
+    const settingsPath = path.join(geminiDir, "settings.json")
+    let existing: Record<string, unknown> = {}
+    if (await pathExists(settingsPath)) {
+      await backupFile(settingsPath)
+      try {
+        existing = await readJson<Record<string, unknown>>(settingsPath)
+      } catch {
+        console.warn("Warning: existing settings.json could not be parsed and will be replaced.")
+      }
+    }
+
+    const existingMcp = (existing.mcpServers && typeof existing.mcpServers === "object")
+      ? existing.mcpServers as Record<string, unknown>
+      : {}
+
+    const merged = { ...existing, mcpServers: { ...existingMcp, ...convertMcpServers(mcpServers) } }
+    await writeJson(settingsPath, merged)
+  }
+}
+
+function convertMcpServers(servers: Record<string, ClaudeMcpServer>) {
+  const result: Record<string, Record<string, unknown>> = {}
+  for (const [name, server] of Object.entries(servers)) {
+    const entry: Record<string, unknown> = {}
+    if (server.command) {
+      entry.command = server.command
+      if (server.args?.length) entry.args = server.args
+      if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
+    } else if (server.url) {
+      entry.url = server.url
+      if (server.headers && Object.keys(server.headers).length > 0) entry.headers = server.headers
+    }
+    result[name] = entry
+  }
+  return result
+}
+```
+
+**Update `src/commands/sync.ts`:**
+
+- Add `"gemini"` to `validTargets` array
+- Import `syncToGemini` from `../sync/gemini`
+- Add case in switch for `"gemini"` calling `syncToGemini(skills, mcpServers, outputRoot)`
+
+### Phase 3: Wire `--to all` into Install and Convert
+
+**Modify `src/commands/install.ts`:**
+
+```typescript
+import { detectInstalledTools } from "../utils/detect-tools"
+
+// In args definition, update --to description:
+to: {
+  type: "string",
+  default: "opencode",
+  description: "Target format (opencode | codex | droid | cursor | pi | gemini | all)",
+},
+
+// In run(), before the existing target lookup:
+if (targetName === "all") {
+  const detected = await detectInstalledTools()
+  const activeTargets = detected.filter((t) => t.detected)
+
+  if (activeTargets.length === 0) {
+    console.log("No AI coding tools detected. Install at least one tool first.")
+    return
+  }
+
+  console.log(`Detected ${activeTargets.length} tools:`)
+  for (const tool of detected) {
+    console.log(`  ${tool.detected ? "✓" : "✗"} ${tool.name} — ${tool.reason}`)
+  }
+
+  // Install to each detected target
+  for (const tool of activeTargets) {
+    const handler = targets[tool.name]
+    const bundle = handler.convert(plugin, options)
+    if (!bundle) continue
+    const root = resolveTargetOutputRoot(tool.name, outputRoot, codexHome, piHome, hasExplicitOutput)
+    await handler.write(root, bundle)
+    console.log(`Installed ${plugin.manifest.name} to ${tool.name} at ${root}`)
+  }
+
+  // Codex post-processing
+  if (activeTargets.some((t) => t.name === "codex")) {
+    await ensureCodexAgentsFile(codexHome)
+  }
+  return
+}
+```
+
+**Same change in `src/commands/convert.ts`** with its version of `resolveTargetOutputRoot`.
+
+### Phase 4: Wire `--target all` into Sync
+
+**Modify `src/commands/sync.ts`:**
+
+```typescript
+import { detectInstalledTools } from "../utils/detect-tools"
+
+// Update validTargets:
+const validTargets = ["opencode", "codex", "pi", "droid", "cursor", "gemini", "all"] as const
+
+// In run(), handle "all":
+if (targetName === "all") {
+  const detected = await detectInstalledTools()
+  const activeTargets = detected.filter((t) => t.detected).map((t) => t.name)
+
+  if (activeTargets.length === 0) {
+    console.log("No AI coding tools detected.")
+    return
+  }
+
+  console.log(`Syncing to ${activeTargets.length} detected tools...`)
+  for (const name of activeTargets) {
+    // call existing sync logic for each target
+  }
+  return
+}
+```
+
+### Phase 5: Tests
+
+**Create `tests/detect-tools.test.ts`**
+
+- Test detection with mocked directories (create temp dirs, check detection)
+- Test `getDetectedTargetNames` returns only detected tools
+- Test empty detection returns empty array
+
+**Create `tests/gemini-sync.test.ts`**
+
+Follow `tests/sync-cursor.test.ts` pattern:
+
+- Test skills are symlinked to `.gemini/skills/`
+- Test MCP servers merged into `settings.json`
+- Test existing `settings.json` is backed up
+- Test empty skills/servers produce no output
+
+**Update `tests/cli.test.ts`**
+
+- Test `--to all` flag is accepted
+- Test `sync --target all` is accepted
+- Test `sync --target gemini` is accepted
+
+### Phase 6: Documentation
+
+**Update `README.md`:**
+
+Add to install section:
+```bash
+# auto-detect installed tools and install to all
+bunx @every-env/compound-plugin install compound-engineering --to all
+```
+
+Add to sync section:
+```bash
+# Sync to Gemini
+bunx @every-env/compound-plugin sync --target gemini
+
+# Sync to all detected tools
+bunx @every-env/compound-plugin sync --target all
+```
+
+## What We're NOT Doing
+
+- Not adding binary detection (`which cursor`, `which gemini`) — directory checks are sufficient and don't require shell execution
+- Not adding interactive prompts ("Install to Cursor? y/n") — auto-detect is fire-and-forget
+- Not adding `--exclude` flag for skipping specific targets — can use `--to X --also Y` for manual selection
+- Not adding Gemini to the `sync` symlink watcher (no watcher exists for any target)
+
+## Complexity Assessment
+
+**Low-medium change.** All patterns are established:
+- Detection utility is new but simple (pathExists checks)
+- Gemini sync follows cursor sync pattern exactly
+- `--to all` is plumbing — iterate detected tools through existing handlers
+- No new dependencies needed
+
+## References
+
+- Cursor sync (reference pattern): `src/sync/cursor.ts`
+- Gemini writer (merge pattern): `src/targets/gemini.ts`
+- Install command: `src/commands/install.ts`
+- Sync command: `src/commands/sync.ts`
+- File utilities: `src/utils/files.ts`
+- Symlink utilities: `src/utils/symlink.ts`
+
+## Completion Summary
+
+### What Was Delivered
+- Tool detection utility (`src/utils/detect-tools.ts`) with `detectInstalledTools()` and `getDetectedTargetNames()`
+- Gemini sync (`src/sync/gemini.ts`) following cursor sync pattern — symlinks skills, merges MCP servers into `settings.json`
+- `install --to all` and `convert --to all` auto-detect and install to all detected tools
+- `sync --target gemini` added to sync command
+- `sync --target all` syncs to all detected tools with summary output
+- 8 new tests across 2 test files (detect-tools + sync-gemini)
+
+### Implementation Statistics
+- 4 new files, 3 modified files
+- 139 tests passing (8 new + 131 existing)
+- No new dependencies
+
+### Git Commits
+- `e4d730d` feat: add detect-tools utility and Gemini sync with tests
+- `bc655f7` feat: wire --to all into install/convert and --target all/gemini into sync
+- `877e265` docs: add auto-detect and Gemini sync to README, bump to 0.8.0
+
+### Completion Details
+- **Completed By:** Claude Opus 4.6
+- **Date:** 2026-02-14
+- **Session:** Single session, TDD approach