@ericrisco/rsc 0.1.9 → 0.1.11

package/README.md

@@ -1,19 +1,24 @@
 <div align="center">
 
 ```
- ██████╗ ███████╗ ██████╗
- ██╔══██╗██╔════╝██╔════╝
- ██████╔╝███████╗██║     
- ██╔══██╗╚════██║██║     
- ██║  ██║███████║╚██████╗
- ╚═╝  ╚═╝╚══════╝ ╚═════╝
+  ████████    ███████    ███████ 
+  ██    ██   ██         ██    ██ 
+  ██    ██   ██         ██       
+  ██    ██   ██         ██       
+  ████████    ██████    ██       
+  ██  ██           ██   ██       
+  ██   ██          ██   ██       
+  ██    ██         ██   ██    ██ 
+  ██    ██   ███████     ███████ 
 ```
 
 # `rsc` — 231 agent skills, one CLI, zero bloat
 
-**A self-recommending skill catalog for Claude Code, Cursor, Codex & Gemini.**
+**A self-recommending skill catalog for 17 coding assistants** — Claude Code,
+Codex, GitHub Copilot, Cursor, Gemini, Windsurf, Cline, Antigravity, Zed and more.
 Describe what you want in plain language. It reads your repo, installs *only* the
-skills that fit — one at a time — and keeps your assistant equipped as you work.
+skills that fit — one at a time — into every assistant you pick, and keeps them
+equipped as you work.
 
 From *"document my company"* to *"ship a FastAPI service"* to *"grow my YouTube
 channel"* — **231 skills across 21 domains**, every one researched against live
@@ -70,9 +75,17 @@ git clone https://github.com/ericrisco/skills.git ~/rsc-skills
 cd ~/rsc-skills && npm install && npm link
 ```
 
-The first run installs the **floor** — `orient` + `rsc-suggest` (always-on) +
-`harness` + `init` — and, in Claude Code, wires a `SessionStart` hook so your
-assistant proposes new skills on its own from then on.
+The first run asks **which assistants** you want — Claude Code, Codex, Copilot,
+Cursor, Gemini, Windsurf, Cline and 11 more (pick any combination) — and installs
+the **floor**:
+`orient` + `rsc-suggest` (always-on) + `harness` + `init`. In Claude Code it
+also wires a `SessionStart` hook so your assistant proposes new skills on its
+own from then on.
+
+Everything stays **in the project**, and the real skill files are written
+**once** to `.rsc/skills/<id>/`. Each assistant you pick gets a lightweight
+symlink back to that shared base — no copy is duplicated across IDEs. (If the
+filesystem can't symlink, it falls back to a real copy automatically.)
 
 ---
 
@@ -102,18 +115,33 @@ Languages:                       ↑↓ move · space toggle · a all · enter c
   ◯ rust
 ```
 
-It auto-detects your IDE and stack, installs only what you chose, then prints the
-exact next steps for **Claude Code / Cursor / Codex / Gemini** — and from there
-keeps proposing the skills a task needs.
+Then it asks **which assistants** to install for — tick as many as you like:
+
+```
+Which assistants do you want to install for?   space toggle · a all · enter confirm
+❯ ◉ Claude Code      (.claude/skills/)   ⟵ detected here
+  ◉ Codex CLI        (AGENTS.md)
+  ◯ GitHub Copilot   (.github/copilot-instructions.md)
+  ◯ Cursor           (.cursor/rules/)
+  ◉ Windsurf         (.windsurf/rules/)
+  ◯ Cline            (.clinerules/)
+  …17 in total — Gemini, Antigravity, Zed, Continue, Roo, Amp, opencode, Jules, Junie, Kiro, Aider
+```
+
+It detects your stack, asks which assistants to install for (the one it found in
+your folder is pre-marked), installs only what you chose, then prints the exact
+next steps for **Claude Code / Codex / Cursor / Gemini / Antigravity** — and from
+there keeps proposing the skills a task needs.
 
 ---
 
 ## The CLI
 
 ```bash
-rsc                                  # plain-language wizard (recommended)
+rsc                                  # plain-language wizard (recommended) — pick skills AND assistants
 rsc add fastapi postgresdb           # install specific skills, by name
 rsc add youtube-api remotion-video   # …grow a channel, edit with Remotion
+rsc add fastapi --target claude,codex   # install into several assistants at once
 rsc install --profile minimal        # the floor: orient + suggest + harness + init
 rsc install --profile core           # floor + the full SDD workflow
 rsc install --profile full           # everything (all 231)
@@ -238,15 +266,33 @@ Each with a `02-DOCS` feedback loop that learns from your own results. `remotion
 
 ## Multi-target
 
-`skills/<name>/` is the source; the installer writes the right format for your
-IDE (auto-detected, or `--target`):
+`skills/<name>/` is the catalog source. On install the real files land **once**
+in the project at `.rsc/skills/<id>/`; each assistant you pick gets a symlink
+(or a converted file) back to that shared base — pick several and nothing is
+duplicated. The wizard asks which ones; `--target a,b` does it non-interactively.
 
-| Target | Destination | Always-on detector |
+| Target | Skill destination (→ `.rsc/skills/<id>/`) | Always-on detector |
 | --- | --- | --- |
-| `claude` | `~/.claude/skills/rsc/<id>/` | SessionStart hook in `settings.json` |
-| `cursor` | `.cursor/rules/<id>.mdc` | always-apply rule |
-| `codex` | `.codex/rsc/<id>/` + `AGENTS.md` | block in `AGENTS.md` |
-| `gemini` | `.gemini/rsc/<id>/` + `GEMINI.md` | block in `GEMINI.md` |
+| `claude` | `.claude/skills/rsc/<id>/` → symlink | SessionStart hook in `.claude/settings.json` |
+| `codex` | `.codex/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `copilot` | `.github/rsc/<id>/` → symlink | block in `.github/copilot-instructions.md` |
+| `cursor` | `.cursor/rules/<id>.mdc` (converted) | always-apply rule |
+| `gemini` | `.gemini/rsc/<id>/` → symlink | block in `GEMINI.md` |
+| `windsurf` | `.windsurf/rsc/<id>/` → symlink | rule in `.windsurf/rules/rsc-suggest.md` |
+| `cline` | `.clinerules/rsc/<id>/` → symlink | rule in `.clinerules/rsc-suggest.md` |
+| `antigravity` | `.antigravity/rsc/<id>/` → symlink | block in `.antigravity/AGENTS.md` |
+| `zed` | `.zed/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `continue` | `.continue/rsc/<id>/` → symlink | rule in `.continue/rules/rsc-suggest.md` |
+| `roo` | `.roo/rsc/<id>/` → symlink | rule in `.roo/rules/rsc-suggest.md` |
+| `amp` | `.amp/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `opencode` | `.opencode/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `jules` | `.jules/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `junie` | `.junie/rsc/<id>/` → symlink | block in `.junie/guidelines.md` |
+| `kiro` | `.kiro/rsc/<id>/` → symlink | doc in `.kiro/steering/rsc-suggest.md` |
+| `aider` | `.aider/rsc/<id>/` → symlink | block in `CONVENTIONS.md` |
+
+> `codex`, `zed`, `amp`, `opencode` and `jules` all share the one root
+> `AGENTS.md`; the block is idempotent, so picking several writes it once.
 
 ---
 

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.9",
+  "version": "0.1.11",
   "counts": {
     "skills": 231
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Eric Risco's agent-skills catalog as a granular, self-recommending CLI installer.",
   "type": "module",
   "bin": {
@@ -40,6 +40,7 @@
     "cursor",
     "codex",
     "gemini",
+    "antigravity",
     "cli",
     "skills",
     "ai"

package/scripts/doctor.js

@@ -3,8 +3,8 @@ import { targetPaths } from '../targets/index.js';
 import { readState } from './lib/state.js';
 import { loadManifest } from './lib/manifest.js';
 
-export function doctor({ target, home }) {
-  const paths = targetPaths(target, home);
+export function doctor({ target, home, cwd }) {
+  const paths = targetPaths(target, home, cwd);
   const state = readState(paths.stateFile);
   const manifest = loadManifest();
   const report = {

package/scripts/install-apply.js

@@ -1,36 +1,48 @@
 #!/usr/bin/env node
-import { rmSync, existsSync } from 'node:fs';
+import { rmSync, existsSync, cpSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { planInstall } from './install-plan.js';
-import { targetPaths, writeSkill, wireHook } from '../targets/index.js';
+import { targetPaths, writeSkill, wireHook, baseDir } from '../targets/index.js';
 import { readState, writeState } from './lib/state.js';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 
-export async function applyInstall({ skillIds, target, home }) {
-  const paths = targetPaths(target, home);
-  const plan = planInstall({ skillIds, target, home });
+// Materialize the real skill files into the project-local base exactly once.
+// Re-installs and other assistants reuse it instead of copying again.
+function ensureBase(id, cwd) {
+  const dest = baseDir(id, cwd);
+  if (!existsSync(dest)) {
+    mkdirSync(dirname(dest), { recursive: true });
+    cpSync(join(ROOT, 'skills', id), dest, { recursive: true });
+  }
+  return dest;
+}
+
+export async function applyInstall({ skillIds, target, home, cwd = process.cwd() }) {
+  const paths = targetPaths(target, home, cwd);
+  const plan = planInstall({ skillIds, target, home, cwd });
   const state = readState(paths.stateFile);
   for (const step of plan) {
     if (step.kind === 'skill') {
-      const files = await writeSkill(target, step.id, join(ROOT, step.from), step.to);
-      state.skills[step.id] = { files };
+      const base = ensureBase(step.id, cwd);
+      const files = await writeSkill(target, step.id, base, step.to);
+      state.skills[step.id] = { files, base };
     } else if (step.kind === 'hook') {
-      await wireHook(target, paths, join(ROOT, 'skills', 'suggest', 'SKILL.md'));
+      await wireHook(target, paths, join(ensureBase('suggest', cwd), 'SKILL.md'));
     }
   }
   writeState(paths.stateFile, state);
   return state;
 }
 
-export function listInstalled({ target, home }) {
-  const paths = targetPaths(target, home);
+export function listInstalled({ target, home, cwd = process.cwd() }) {
+  const paths = targetPaths(target, home, cwd);
   return Object.keys(readState(paths.stateFile).skills);
 }
 
-export async function uninstall({ skillIds, target, home, dryRun }) {
-  const paths = targetPaths(target, home);
+export async function uninstall({ skillIds, target, home, cwd = process.cwd(), dryRun }) {
+  const paths = targetPaths(target, home, cwd);
   const state = readState(paths.stateFile);
   const removed = [];
   for (const id of skillIds) {

package/scripts/install-plan.js

@@ -1,7 +1,7 @@
 import { targetPaths } from '../targets/index.js';
 
-export function planInstall({ skillIds, target, home }) {
-  const t = targetPaths(target, home);
+export function planInstall({ skillIds, target, home, cwd }) {
+  const t = targetPaths(target, home, cwd);
   const plan = [];
   for (const id of skillIds) {
     plan.push({ kind: 'skill', id, from: `skills/${id}`, to: t.skillDir(id) });

package/scripts/lib/ui.js

@@ -36,26 +36,42 @@ const C = {
   green: (s) => `\x1b[32m${s}\x1b[39m`,
 };
 
-const ART = [
-  ' ██████╗ ███████╗ ██████╗',
-  ' ██╔══██╗██╔════╝██╔════╝',
-  ' ██████╔╝███████╗██║     ',
-  ' ██╔══██╗╚════██║██║     ',
-  ' ██║  ██║███████║╚██████╗',
-  ' ╚═╝  ╚═╝╚══════╝ ╚═════╝',
-];
-
-// Vertical truecolor gradient (sky → violet), phase-shiftable for the wave.
-function gradientLine(text, row, phase) {
-  const a = [56, 189, 248]; const b = [167, 139, 250];
-  const t = ((row + phase) % ART.length) / (ART.length - 1);
-  const r = Math.round(a[0] + (b[0] - a[0]) * t);
-  const g = Math.round(a[1] + (b[1] - a[1]) * t);
-  const bl = Math.round(a[2] + (b[2] - a[2]) * t);
-  return `\x1b[38;2;${r};${g};${bl}m${text}\x1b[39m`;
+// Big block RSC wordmark, built from per-letter grids so rows always align.
+const _R = ['████████', '██    ██', '██    ██', '██    ██', '████████', '██  ██', '██   ██', '██    ██', '██    ██'];
+const _S = [' ███████', '██', '██', '██', ' ██████', '      ██', '      ██', '      ██', '███████'];
+const _C = [' ███████', '██    ██', '██', '██', '██', '██', '██', '██    ██', ' ███████'];
+const _padW = 9;
+const _pad = (s) => s + ' '.repeat(Math.max(0, _padW - [...s].length));
+const ART = _R.map((_, i) => `  ${_pad(_R[i])}  ${_pad(_S[i])}  ${_pad(_C[i])}`);
+
+// HSL → RGB (s=1, l=0.6) for a true rainbow.
+function hsl(h, s = 1, l = 0.6) {
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+  const m = l - c / 2;
+  let r = 0; let g = 0; let b = 0;
+  if (h < 60) { r = c; g = x; } else if (h < 120) { r = x; g = c; }
+  else if (h < 180) { g = c; b = x; } else if (h < 240) { g = x; b = c; }
+  else if (h < 300) { r = x; b = c; } else { r = c; b = x; }
+  return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255)];
 }
 
-// Animated ASCII wordmark — the "wooow". Static plain text when not a TTY.
+// One frame: rainbow per character, diagonal phase, revealed up to `cols`.
+function frame(phase, cols) {
+  return ART.map((line, r) => {
+    const chars = [...line];
+    let out = '';
+    for (let c = 0; c < chars.length && c < cols; c++) {
+      const ch = chars[c];
+      if (ch === ' ') { out += ' '; continue; }
+      const [rr, gg, bb] = hsl((c * 5 + r * 14 + phase * 20) % 360);
+      out += `\x1b[1;38;2;${rr};${gg};${bb}m${ch}`;
+    }
+    return `\x1b[2K${out}\x1b[0m`;
+  }).join('\n') + '\n';
+}
+
+// Animated ASCII wordmark — the exaggerated "WOW". Static plain text when not a TTY.
 export async function banner() {
   if (!stdout.isTTY) {
     say('');
@@ -63,23 +79,36 @@ export async function banner() {
     say('  231 skills · one CLI · zero bloat');
     return;
   }
-  const W = Math.max(...ART.map((l) => l.length));
+  const rows = ART.length;
+  const W = Math.max(...ART.map((l) => [...l].length));
   stdout.write('\x1b[?25l'); // hide cursor
   say('');
-  // 1) letters slide in left → right, column by column
+  // 1) letters slide in left → right
   let first = true;
-  for (let w = 1; w <= W; w++) {
-    if (!first) stdout.write(`\x1b[${ART.length}A`);
+  for (let cols = 2; cols <= W; cols += 2) {
+    if (!first) stdout.write(`\x1b[${rows}A`);
     first = false;
-    stdout.write(ART.map((l, i) => `\x1b[2K${gradientLine(l.slice(0, w), i, 0)}`).join('\n') + '\n');
-    await sleep(20);
+    stdout.write(frame(0, cols));
+    await sleep(12);
+  }
+  // 2) flowing rainbow diagonal sweeps
+  for (let phase = 1; phase <= 30; phase++) {
+    stdout.write(`\x1b[${rows}A`);
+    stdout.write(frame(phase, W));
+    await sleep(26);
   }
-  // 2) one flowing color wave to settle
-  for (let phase = 1; phase <= ART.length; phase++) {
-    stdout.write(`\x1b[${ART.length}A`);
-    stdout.write(ART.map((l, i) => `\x1b[2K${gradientLine(l, i, phase)}`).join('\n') + '\n');
-    await sleep(45);
+  // 3) double white flash — the pop
+  for (let f = 0; f < 2; f++) {
+    stdout.write(`\x1b[${rows}A`);
+    stdout.write(ART.map((l) => `\x1b[2K\x1b[1;97m${l}\x1b[0m`).join('\n') + '\n');
+    await sleep(60);
+    stdout.write(`\x1b[${rows}A`);
+    stdout.write(frame(15, W));
+    await sleep(60);
   }
+  // settle on a final rainbow snapshot
+  stdout.write(`\x1b[${rows}A`);
+  stdout.write(frame(15, W));
   say(C.dim('  231 skills · one CLI · zero bloat'));
   stdout.write('\x1b[?25h'); // show cursor
 }

package/scripts/rsc.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { loadManifest, skillsForProfile } from './lib/manifest.js';
-import { detectTarget } from '../targets/index.js';
+import { detectTarget, TARGETS } from '../targets/index.js';
 import { detectRepo } from './detect-repo.js';
 import { rank } from './consult.js';
 import { expandRecommends, toOutcomes, hasOutcome } from './lib/recommend.js';
@@ -45,18 +45,26 @@ async function manualSelect() {
   return [...chosen];
 }
 
+// Ask which assistants to install into. The detected one is pre-labelled but
+// nothing is auto-applied — the user always confirms the set (one or many).
+async function selectAgents() {
+  const detected = detectTarget();
+  const items = TARGETS.map((t) => ({
+    id: t.id,
+    label: `${t.label}  (${t.hint})${t.id === detected ? '   ⟵ detected here' : ''}`,
+  }));
+  const chosen = await pickFrom('Which assistants do you want to install for? (space to toggle, a = all)', items);
+  return chosen.length ? chosen : [detected];
+}
+
 // After installing, remind the user how to actually start — per IDE — and that
 // rsc keeps recommending skills as they work. The harness/SDD *init* runs INSIDE
 // the assistant (with the user present), never blindly from this CLI.
-function printNextSteps(target, ids) {
+function printNextSteps(targets, ids) {
   const hasHarness = ids.includes('harness');
   const hasSdd = ids.includes('sdd') || ids.includes('sdd-init');
-  const openLine = {
-    claude: 'Open **Claude Code** in this project folder.',
-    cursor: 'Open **Cursor** in this project folder.',
-    codex: 'Open **Codex CLI** (it reads AGENTS.md) in this project folder.',
-    gemini: 'Open **Gemini CLI** in this project folder.',
-  }[target] || 'Open your assistant in this project folder.';
+  const label = (id) => TARGETS.find((t) => t.id === id)?.label || id;
+  const openLine = `Open this project in: ${targets.map((t) => `**${label(t)}**`).join(' · ')}`;
 
   say('\n────────────────────────────────────────────────────────');
   say('👉 When you start working (these steps happen in your assistant, not here):');
@@ -82,7 +90,7 @@ function printNextSteps(target, ids) {
 async function wizard() {
   const m = loadManifest();
   await banner();
-  say('  the skill catalog for your assistant (Claude Code · Cursor · Codex · Gemini)\n');
+  say('  the skill catalog for your assistant (Claude Code · Codex · Cursor · Gemini · Antigravity)\n');
   const choice = await select('What do you want to do?', [
     { key: 'base', label: 'Base install — the essentials (orient + suggest + harness + init)' },
     { key: 'sdd', label: 'Base + Spec-Driven Development — the specify → plan → implement → ship flow' },
@@ -102,33 +110,50 @@ async function wizard() {
     return;
   }
 
-  const target = detectTarget();
-  say(`\nI'll install ${ids.length} skills into ${target}:`);
+  const targets = await selectAgents();
+  say(`\nI'll install ${ids.length} skills for: ${targets.join(', ')}`);
   say('   ' + ids.join(', '));
+  say('   (real files live once in .rsc/skills/ — each assistant just links to them)');
   if (!(await confirm('Install it?'))) {
     say('No problem. Anytime: npx @ericrisco/rsc');
     return;
   }
-  await applyInstall({ skillIds: ids, target });
-  say(`\n✅ Installed ${ids.length} skills into ${target}.`);
-  printNextSteps(target, ids);
+  for (const target of targets) {
+    await applyInstall({ skillIds: ids, target });
+    say(`   ✅ ${target}`);
+  }
+  say(`\n✅ Installed ${ids.length} skills for ${targets.length} assistant(s).`);
+  printNextSteps(targets, ids);
 }
 
 async function main() {
-  const target = flag('target') || detectTarget();
+  // --target accepts one id or a comma list (e.g. --target claude,codex). No flag → detect.
+  const f = flag('target');
+  const targets = typeof f === 'string'
+    ? f.split(',').map((s) => s.trim()).filter(Boolean)
+    : [detectTarget()];
+  const target = targets[0];
   switch (cmd) {
     case undefined:
       return wizard();
-    case 'add':
-      await applyInstall({ skillIds: [...new Set(['orient', 'suggest', ...argv.slice(1)])], target });
-      return void say(`✅ Installed: ${argv.slice(1).join(', ')}`);
+    case 'add': {
+      // Positional args = skill ids; skip flags and any flag value (the token after a --flag).
+      const requested = [];
+      for (let i = 1; i < argv.length; i++) {
+        if (argv[i].startsWith('--')) { i++; continue; }
+        requested.push(argv[i]);
+      }
+      const ids = [...new Set(['orient', 'suggest', ...requested])];
+      for (const t of targets) await applyInstall({ skillIds: ids, target: t });
+      return void say(`✅ Installed for ${targets.join(', ')}: ${requested.join(', ')}`);
+    }
     case 'install': {
       const profile = flag('profile') || 'minimal';
       const without = argv.filter((a, i) => argv[i - 1] === '--without');
       let ids = skillsForProfile(loadManifest(), profile);
       ids = [...new Set(['orient', 'suggest', ...ids])].filter((id) => !without.includes(id));
-      await applyInstall({ skillIds: ids, target });
-      return void say(`✅ Profile '${profile}' installed into ${target} (${ids.length} skills)`);
+      for (const t of targets) await applyInstall({ skillIds: ids, target: t });
+      return void say(`✅ Profile '${profile}' installed for ${targets.join(', ')} (${ids.length} skills)`);
     }
     case 'consult': {
       const ids = await recommendIds(argv.slice(1).join(' '));

package/targets/{codex.js → _md-block.js}

@@ -1,13 +1,17 @@
-import { cpSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { linkOrCopy } from './index.js';
 
+// Shared adapter for every assistant whose "always-on" surface is a plain
+// markdown instructions/rules file (AGENTS.md, copilot-instructions.md, a
+// .windsurf/.roo/.continue rule, …). Skills are symlinked to the shared base;
+// the suggest block is injected between idempotent markers so re-installs and
+// multiple assistants sharing one file never duplicate it.
 const MARK_START = '<!-- rsc-suggest:start -->';
 const MARK_END = '<!-- rsc-suggest:end -->';
 
 export function writeSkill(id, fromDir, toPath) {
-  mkdirSync(dirname(toPath), { recursive: true });
-  cpSync(fromDir, toPath, { recursive: true });
-  return [toPath];
+  return linkOrCopy(fromDir, toPath);
 }
 
 export function wireHook(paths, sourceMd) {

package/targets/claude.js

@@ -1,10 +1,9 @@
-import { cpSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { linkOrCopy } from './index.js';
 
 export function writeSkill(id, fromDir, toPath) {
-  mkdirSync(dirname(toPath), { recursive: true });
-  cpSync(fromDir, toPath, { recursive: true });
-  return [toPath];
+  return linkOrCopy(fromDir, toPath);
 }
 
 export function wireHook(paths) {

package/targets/index.js

@@ -1,55 +1,120 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, lstatSync, mkdirSync, rmSync, symlinkSync, cpSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
 import { homedir } from 'node:os';
+import * as claudeAdapter from './claude.js';
+import * as cursorAdapter from './cursor.js';
+import * as mdAdapter from './_md-block.js';
 
+// Project-local single source of truth. Real skill files live here exactly once;
+// every assistant gets a lightweight pointer (symlink) back to it — no duplication.
+export function baseDir(id, cwd = process.cwd()) {
+  return join(cwd, '.rsc', 'skills', id);
+}
+
+// Point an assistant's skill folder at the shared base via a relative symlink.
+// Falls back to a real copy when the filesystem rejects symlinks (e.g. Windows
+// without privileges). Idempotent: replaces any existing link/dir at toPath.
+export function linkOrCopy(fromDir, toPath) {
+  mkdirSync(dirname(toPath), { recursive: true });
+  try { lstatSync(toPath); rmSync(toPath, { recursive: true, force: true }); } catch { /* nothing there */ }
+  try {
+    symlinkSync(relative(dirname(toPath), fromDir), toPath, 'dir');
+  } catch {
+    cpSync(fromDir, toPath, { recursive: true });
+  }
+  return [toPath];
+}
+
+// One row per assistant. `root` is where its skill folder lives (relative to the
+// project), `hook` is the file that gets the always-on suggest block, `adapter`
+// picks how skills + hook are written. `skillExt` (cursor only) means each skill
+// is a single converted file, not a linked directory.
+const SPEC = {
+  // JSON-hook + linked skill dirs
+  claude: { root: '.claude/skills/rsc', hook: '.claude/settings.json', adapter: 'claude' },
+  // Converted .mdc rules
+  cursor: { root: '.cursor/rules', hook: '.cursor/rules/rsc-suggest.mdc', adapter: 'cursor', skillExt: '.mdc' },
+  // AGENTS.md family — all read the same root AGENTS.md
+  codex: { root: '.codex/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  opencode: { root: '.opencode/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  amp: { root: '.amp/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  jules: { root: '.jules/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  zed: { root: '.zed/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  // Own markdown instructions/rules file
+  gemini: { root: '.gemini/rsc', hook: 'GEMINI.md', adapter: 'md' },
+  antigravity: { root: '.antigravity/rsc', hook: '.antigravity/AGENTS.md', adapter: 'md' },
+  copilot: { root: '.github/rsc', hook: '.github/copilot-instructions.md', adapter: 'md' },
+  windsurf: { root: '.windsurf/rsc', hook: '.windsurf/rules/rsc-suggest.md', adapter: 'md' },
+  cline: { root: '.clinerules/rsc', hook: '.clinerules/rsc-suggest.md', adapter: 'md' },
+  roo: { root: '.roo/rsc', hook: '.roo/rules/rsc-suggest.md', adapter: 'md' },
+  continue: { root: '.continue/rsc', hook: '.continue/rules/rsc-suggest.md', adapter: 'md' },
+  junie: { root: '.junie/rsc', hook: '.junie/guidelines.md', adapter: 'md' },
+  kiro: { root: '.kiro/rsc', hook: '.kiro/steering/rsc-suggest.md', adapter: 'md' },
+  aider: { root: '.aider/rsc', hook: 'CONVENTIONS.md', adapter: 'md' },
+};
+
+const ADAPTER = { claude: claudeAdapter, cursor: cursorAdapter, md: mdAdapter };
+
+// Wizard multi-select list, in "most famous first" order. label/hint are display
+// only; detectTarget just pre-marks the one found in the folder.
+export const TARGETS = [
+  { id: 'claude', label: 'Claude Code', hint: '.claude/skills/' },
+  { id: 'codex', label: 'Codex CLI', hint: 'AGENTS.md' },
+  { id: 'copilot', label: 'GitHub Copilot', hint: '.github/copilot-instructions.md' },
+  { id: 'cursor', label: 'Cursor', hint: '.cursor/rules/' },
+  { id: 'gemini', label: 'Gemini CLI', hint: 'GEMINI.md' },
+  { id: 'windsurf', label: 'Windsurf', hint: '.windsurf/rules/' },
+  { id: 'cline', label: 'Cline', hint: '.clinerules/' },
+  { id: 'antigravity', label: 'Antigravity', hint: '.antigravity/' },
+  { id: 'zed', label: 'Zed', hint: 'AGENTS.md' },
+  { id: 'continue', label: 'Continue', hint: '.continue/rules/' },
+  { id: 'roo', label: 'Roo Code', hint: '.roo/rules/' },
+  { id: 'amp', label: 'Amp', hint: 'AGENTS.md' },
+  { id: 'opencode', label: 'opencode', hint: 'AGENTS.md' },
+  { id: 'jules', label: 'Jules', hint: 'AGENTS.md' },
+  { id: 'junie', label: 'JetBrains Junie', hint: '.junie/guidelines.md' },
+  { id: 'kiro', label: 'Kiro', hint: '.kiro/steering/' },
+  { id: 'aider', label: 'Aider', hint: 'CONVENTIONS.md' },
+];
+
+// Best-effort default for the wizard's pre-mark. Unique config dirs win; the
+// shared AGENTS.md / GEMINI.md fall through to codex / gemini.
 export function detectTarget(cwd = process.cwd()) {
-  if (existsSync(join(cwd, '.cursor'))) return 'cursor';
-  if (existsSync(join(cwd, '.codex')) || existsSync(join(cwd, 'AGENTS.md'))) return 'codex';
-  if (existsSync(join(cwd, '.gemini')) || existsSync(join(cwd, 'GEMINI.md'))) return 'gemini';
+  const dir = (d) => existsSync(join(cwd, d));
+  if (dir('.cursor')) return 'cursor';
+  if (dir('.windsurf')) return 'windsurf';
+  if (dir('.clinerules')) return 'cline';
+  if (dir('.roo')) return 'roo';
+  if (dir('.continue')) return 'continue';
+  if (dir('.junie')) return 'junie';
+  if (dir('.kiro')) return 'kiro';
+  if (dir('.zed')) return 'zed';
+  if (dir('.opencode')) return 'opencode';
+  if (dir('.amp')) return 'amp';
+  if (dir('.jules')) return 'jules';
+  if (dir('.antigravity')) return 'antigravity';
+  if (existsSync(join(cwd, '.github', 'copilot-instructions.md'))) return 'copilot';
+  if (dir('.codex') || dir('AGENTS.md')) return 'codex';
+  if (dir('.gemini') || dir('GEMINI.md')) return 'gemini';
   return 'claude';
 }
 
 export function targetPaths(target, home = homedir(), cwd = process.cwd()) {
-  switch (target) {
-    case 'claude':
-      return {
-        root: join(home, '.claude', 'skills', 'rsc'),
-        skillDir: (id) => join(home, '.claude', 'skills', 'rsc', id),
-        stateFile: join(home, '.claude', 'skills', 'rsc', '.rsc-state.json'),
-        hookTarget: join(home, '.claude', 'settings.json'),
-      };
-    case 'cursor':
-      return {
-        root: join(cwd, '.cursor', 'rules'),
-        skillDir: (id) => join(cwd, '.cursor', 'rules', `${id}.mdc`),
-        stateFile: join(cwd, '.cursor', 'rules', '.rsc-state.json'),
-        hookTarget: join(cwd, '.cursor', 'rules', 'rsc-suggest.mdc'),
-      };
-    case 'codex':
-      return {
-        root: join(cwd, '.codex', 'rsc'),
-        skillDir: (id) => join(cwd, '.codex', 'rsc', id),
-        stateFile: join(cwd, '.codex', 'rsc', '.rsc-state.json'),
-        hookTarget: join(cwd, 'AGENTS.md'),
-      };
-    case 'gemini':
-      return {
-        root: join(cwd, '.gemini', 'rsc'),
-        skillDir: (id) => join(cwd, '.gemini', 'rsc', id),
-        stateFile: join(cwd, '.gemini', 'rsc', '.rsc-state.json'),
-        hookTarget: join(cwd, 'GEMINI.md'),
-      };
-    default:
-      throw new Error(`unknown target ${target}`);
-  }
+  const s = SPEC[target];
+  if (!s) throw new Error(`unknown target ${target}`);
+  const rootAbs = join(cwd, ...s.root.split('/'));
+  return {
+    root: rootAbs,
+    skillDir: (id) => (s.skillExt ? join(rootAbs, `${id}${s.skillExt}`) : join(rootAbs, id)),
+    stateFile: join(rootAbs, '.rsc-state.json'),
+    hookTarget: join(cwd, ...s.hook.split('/')),
+  };
 }
 
-export async function writeSkill(target, id, fromDir, toPath) {
-  const { writeSkill: w } = await import(`./${target}.js`);
-  return w(id, fromDir, toPath);
+export function writeSkill(target, id, fromDir, toPath) {
+  return ADAPTER[SPEC[target].adapter].writeSkill(id, fromDir, toPath);
 }
 
-export async function wireHook(target, paths, sourceMd) {
-  const { wireHook: w } = await import(`./${target}.js`);
-  return w(paths, sourceMd);
+export function wireHook(target, paths, sourceMd) {
+  return ADAPTER[SPEC[target].adapter].wireHook(paths, sourceMd);
 }

package/targets/gemini.js

@@ -1,29 +0,0 @@
-import { cpSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-
-const MARK_START = '<!-- rsc-suggest:start -->';
-const MARK_END = '<!-- rsc-suggest:end -->';
-
-export function writeSkill(id, fromDir, toPath) {
-  mkdirSync(dirname(toPath), { recursive: true });
-  cpSync(fromDir, toPath, { recursive: true });
-  return [toPath];
-}
-
-export function wireHook(paths, sourceMd) {
-  const body = stripFrontmatter(readFileSync(sourceMd, 'utf8'));
-  const block = `${MARK_START}\n${body}\n${MARK_END}`;
-  let doc = existsSync(paths.hookTarget) ? readFileSync(paths.hookTarget, 'utf8') : '';
-  if (doc.includes(MARK_START)) {
-    doc = doc.replace(new RegExp(`${MARK_START}[\\s\\S]*?${MARK_END}`), block);
-  } else {
-    doc += `\n\n${block}\n`;
-  }
-  mkdirSync(dirname(paths.hookTarget), { recursive: true });
-  writeFileSync(paths.hookTarget, doc);
-  return [paths.hookTarget];
-}
-
-function stripFrontmatter(md) {
-  return md.replace(/^---\n[\s\S]*?\n---\n?/, '');
-}