@eric0117/agentforge 0.1.0

package/dist/list-skills.js

@@ -0,0 +1,120 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readMasterDir } from "./agents/io.js";
+import { AGENTS } from "./agents/index.js";
+import { masterDir, requireWorkspace } from "./agentforge-config.js";
+import { SKILLS } from "./skills-data.js";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+const AGENT_SKILL_PATHS = {
+    claude: (root, id) => join(root, ".claude/skills", id, "SKILL.md"),
+    cursor: (root, id) => join(root, ".cursor/rules", `${id}.mdc`),
+    codex: (root, id) => join(root, ".agents/skills", `${id}.md`),
+};
+const AGENT_SKILL_DIRS = {
+    claude: (root) => join(root, ".claude/skills"),
+    cursor: (root) => join(root, ".cursor/rules"),
+    codex: (root) => join(root, ".agents/skills"),
+};
+export async function runListSkills(opts) {
+    const root = resolve(opts.pathArg ?? process.cwd());
+    const cfg = requireWorkspace(root);
+    if (!existsSync(masterDir(root))) {
+        process.stderr.write(`\n${YELLOW}⚠${RESET} No master skills directory at ${DIM}${masterDir(root)}${RESET}\n\n` +
+            `  Run ${CYAN}agentforge init${RESET} here first to set up the workspace.\n\n`);
+        process.exit(1);
+    }
+    const { skills, skipped, warnings } = readMasterDir(masterDir(root));
+    const stdSet = new Set(SKILLS.map((s) => s.id));
+    console.log(`${BOLD}Skills in${RESET} ${CYAN}${root}${RESET}  ${DIM}(lang: ${cfg.lang}, agents: ${cfg.agents.join(", ")})${RESET}`);
+    console.log("");
+    // header
+    console.log(`  ${DIM}${"id".padEnd(34)}  ${"kind".padEnd(8)}  ${cfg.agents
+        .map((id) => (AGENTS.find((a) => a.id === id)?.label ?? id).padEnd(18))
+        .join("")}description${RESET}`);
+    console.log(`  ${DIM}${"-".repeat(34)}  ${"-".repeat(8)}  ${cfg.agents
+        .map(() => "-".repeat(18))
+        .join("")}${"-".repeat(40)}${RESET}`);
+    // body — track drift while we go
+    let driftCount = 0;
+    for (const s of skills) {
+        const kindLabel = stdSet.has(s.id)
+            ? `${DIM}standard${RESET}`
+            : `${GREEN}custom${RESET}  `;
+        const desc = (s.frontmatter["description"] ?? "")
+            .replace(/\s+/g, " ")
+            .slice(0, 80);
+        const cells = cfg.agents.map((id) => {
+            const present = existsSync(AGENT_SKILL_PATHS[id](root, s.id));
+            if (!present)
+                driftCount++;
+            return (present ? `${GREEN}✓${RESET}` : `${YELLOW}·${RESET}`).padEnd(18 + 9);
+        });
+        console.log(`  ${s.id.padEnd(34)}  ${kindLabel}  ${cells.join("")}${desc}`);
+    }
+    // drift hint
+    if (driftCount > 0) {
+        console.log("");
+        console.log(`${YELLOW}⚠${RESET} ${driftCount} skill cell(s) not yet propagated — run ${CYAN}agentforge sync-skills${RESET} to bring all agents in sync.`);
+    }
+    // warnings on master files (e.g. name/filename mismatch, placeholder body)
+    if (warnings.length > 0) {
+        console.log("");
+        console.log(`${YELLOW}⚠ master file warnings:${RESET}`);
+        for (const w of warnings) {
+            console.log(`  ${DIM}-${RESET} ${w.file}: ${w.warning}`);
+        }
+    }
+    // skipped master files (couldn't load)
+    if (skipped.length > 0) {
+        console.log("");
+        console.log(`${RED}✗ invalid master files (skipped — not propagated):${RESET}`);
+        for (const sk of skipped) {
+            console.log(`  ${DIM}-${RESET} ${sk.file}: ${sk.reason}`);
+        }
+    }
+    // orphan detection — adapter files without a backing master.
+    const orphans = detectOrphans(root, cfg.agents, new Set(skills.map((s) => s.id)));
+    if (orphans.length > 0) {
+        console.log("");
+        console.log(`${YELLOW}⚠ orphan adapter files (no matching master skill):${RESET}`);
+        for (const o of orphans) {
+            console.log(`  ${DIM}-${RESET} ${o.agent}: ${o.id}  ${DIM}(${o.path})${RESET}`);
+        }
+        console.log(`  ${DIM}→ create a master file at agentforge/skills/<id>.md, or remove via \`agentforge remove-skill <id>\`.${RESET}`);
+    }
+    console.log("");
+}
+function detectOrphans(root, agents, masterIds) {
+    const out = [];
+    for (const agent of agents) {
+        const dir = AGENT_SKILL_DIRS[agent](root);
+        if (!existsSync(dir))
+            continue;
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const e of entries) {
+            let id = null;
+            if (agent === "claude" && e.isDirectory())
+                id = e.name;
+            else if (agent === "cursor" && e.isFile() && e.name.endsWith(".mdc"))
+                id = e.name.slice(0, -4);
+            else if (agent === "codex" && e.isFile() && e.name.endsWith(".md"))
+                id = e.name.slice(0, -3);
+            if (!id)
+                continue;
+            if (!masterIds.has(id)) {
+                out.push({
+                    agent,
+                    id,
+                    path: `${dir.slice(root.length + 1)}/${e.name}`,
+                });
+            }
+        }
+    }
+    return out;
+}

package/dist/logo.js

@@ -0,0 +1,181 @@
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const ITALIC = "\x1b[3m";
+// cyan gradient for the letters — center-bright
+const GRADIENT = [
+    "\x1b[38;5;30m",
+    "\x1b[38;5;37m",
+    "\x1b[38;5;44m",
+    "\x1b[38;5;50m",
+    "\x1b[38;5;44m",
+    "\x1b[38;5;37m",
+];
+// Everything below is in the same cyan / teal family as the letters.
+const SPARK = "\x1b[38;5;87m"; // light cyan sparkles above
+const ICE = "\x1b[38;5;87m"; // top of anvil — brightest
+const BRIGHT_CYAN = "\x1b[38;5;51m"; // upper body
+const MID_CYAN = "\x1b[38;5;44m"; // mid (matches letter mid-tone)
+const TEAL = "\x1b[38;5;37m"; // lower body
+const DEEP_TEAL = "\x1b[38;5;30m"; // base
+const SHADOW = "\x1b[38;5;24m"; // deepest shadow at the bottom
+const ACCENT = "\x1b[38;5;51m"; // hammer accents on the tagline
+const SUB = "\x1b[38;5;245m";
+const LOGO_LINES = [
+    "   █████╗  ██████╗ ███████╗███╗   ██╗████████╗███████╗ ██████╗ ██████╗  ██████╗ ███████╗",
+    "  ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝",
+    "  ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║   █████╗  ██║   ██║██████╔╝██║  ███╗█████╗",
+    "  ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝",
+    "  ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗",
+    "  ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝",
+];
+// LEFT: gap = spaces *before* the anvil's first visible character.
+//       smaller = closer to the anvil.
+const LEFT_SPARKS = [
+    [2, "⋆"],
+    [-1, ""],
+    [3, "·"],
+    [2, "✦"],
+    [-1, ""],
+    [4, "·"],
+    [2, "⋆"],
+    [-1, ""],
+    [3, "✧"],
+    [5, "·"],
+    [-1, ""],
+    [2, "⋆"],
+    [4, "✦"],
+];
+// RIGHT: gap = spaces *after* the anvil row's last character.
+const RIGHT_SPARKS = [
+    [3, "·"],
+    [-1, ""],
+    [5, "⋆"],
+    [2, "✦"],
+    [-1, ""],
+    [4, "·"],
+    [-1, ""],
+    [3, "⋆"],
+    [6, "·"],
+    [-1, ""],
+    [2, "✧"],
+    [5, "·"],
+    [-1, ""],
+];
+// anvil + hammer ASCII art — used verbatim as supplied
+const ANVIL_ART = [
+    "                =++++++:.::-:-===+=++*=+***##.",
+    "         .:...:--=+#*=@*---========++++*###%#",
+    "      =*#%#*=-..  .=@=@*:------=====++=",
+    "         :=+++++===#@=@*:-----====+=",
+    "              :+%@@@%+@+::-==--===:",
+    "                   .+#@%*++++=+++",
+    "                    =#%@@%==-====",
+    "                    ++++++====++=",
+    "                  :*#@@@@@---=-===-",
+    "               -##*#%%%@@@+==*%%@@*+==",
+    "            =##%%#%%%@%%%%=+++%@@@@@@++++",
+    "            ####*#**++*+**+=--: :+###*==.",
+    "                    .:===+*+=-",
+];
+const PAD = "                  ";
+// cyan gradient matching the AGENTFORGE letters above:
+// brightest at the top (light catches the hammer face) → deeper teal/blue
+// at the bottom (heavy base in shadow).
+function anvilColor(rowIndex, total) {
+    const r = rowIndex / total;
+    if (r < 0.17)
+        return ICE;
+    if (r < 0.34)
+        return BRIGHT_CYAN;
+    if (r < 0.55)
+        return MID_CYAN;
+    if (r < 0.72)
+        return TEAL;
+    if (r < 0.90)
+        return DEEP_TEAL;
+    return SHADOW;
+}
+// build one anvil row with sparkles hugging the silhouette on either side.
+// the anvil rows have variable leading whitespace; we treat ANVIL_INDENT plus
+// each row's own leading spaces as the "left margin" the sparkle lives in.
+function buildAnvilLine(i, total) {
+    const ANVIL_INDENT_COLS = 18; // shifts anvil under the AGENTFORGE letters
+    const row = ANVIL_ART[i];
+    const trimmed = row.trimStart();
+    const rowLead = row.length - trimmed.length;
+    const totalLead = ANVIL_INDENT_COLS + rowLead; // columns until the anvil draws
+    const [lgap, lchar] = LEFT_SPARKS[i] ?? [-1, ""];
+    const [rgap, rchar] = RIGHT_SPARKS[i] ?? [-1, ""];
+    // left margin: spaces + optional sparkle `lgap` columns before the anvil
+    let leftSegment;
+    if (lgap >= 0 && lchar && lgap < totalLead) {
+        const sparkleCol = totalLead - lgap;
+        leftSegment =
+            " ".repeat(sparkleCol) +
+                `${SPARK}${lchar}${RESET}` +
+                " ".repeat(Math.max(0, totalLead - sparkleCol - 1));
+    }
+    else {
+        leftSegment = " ".repeat(totalLead);
+    }
+    // anvil — only the visible part (we already accounted for leading spaces)
+    const anvilSegment = `${anvilColor(i, total)}${shaded(trimmed)}${RESET}`;
+    // right margin: `rgap` spaces from anvil's last character, then sparkle
+    const rightSegment = rgap >= 0 && rchar
+        ? `${" ".repeat(rgap)}${SPARK}${rchar}${RESET}`
+        : "";
+    return leftSegment + anvilSegment + rightSegment;
+}
+// re-shade the source ASCII (which uses + # @ = * : - .) into block characters
+// so the result reads as a metal silhouette instead of typed text.
+//   @         → █  (full block)
+//   # %       → ▓  (dark shade)
+//   + * =     → ▒  (medium shade)
+//   : - .     → ░  (light shade)
+function shaded(line) {
+    let out = "";
+    for (const ch of line) {
+        switch (ch) {
+            case "@":
+                out += "█";
+                break;
+            case "#":
+            case "%":
+                out += "▓";
+                break;
+            case "+":
+            case "*":
+            case "=":
+                out += "▒";
+                break;
+            case ":":
+            case "-":
+            case ".":
+                out += "░";
+                break;
+            default:
+                out += ch; // spaces and anything else pass through
+        }
+    }
+    return out;
+}
+export function printLogo() {
+    const lines = [""];
+    // 1–6. letters with cyan gradient (no sparks above — sparkles live around
+    // the anvil now).
+    for (let i = 0; i < LOGO_LINES.length; i++) {
+        lines.push(`${BOLD}${GRADIENT[i]}${LOGO_LINES[i]}${RESET}`);
+    }
+    // 7+. anvil ASCII, centered under the letters, with floating sparkles
+    // flanking it on the left and right (per-row pattern in LEFT/RIGHT_SPARKS).
+    for (let i = 0; i < ANVIL_ART.length; i++) {
+        lines.push(buildAnvilLine(i, ANVIL_ART.length));
+    }
+    lines.push("");
+    // tagline + subtitle, hammer-flanked
+    lines.push(`${PAD}${ACCENT}${BOLD}⚒${RESET}  ${SUB}${ITALIC}forge your Claude Code workspace${RESET}  ${ACCENT}${BOLD}⚒${RESET}`);
+    lines.push(`${PAD}${DIM}bootstrap multi-repo · multi-worktree · multi-feature${RESET}`);
+    lines.push("");
+    process.stdout.write(lines.join("\n") + "\n");
+}

package/dist/path-prompt.js

@@ -0,0 +1,148 @@
+import { readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import * as readline from "node:readline/promises";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+function expandTilde(p) {
+    if (p === "~")
+        return homedir();
+    if (p.startsWith("~/"))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+/** Suffix that should appear after the current buffer as a ghost-text hint. */
+function findSuggestion(buffer) {
+    if (buffer.length === 0)
+        return "";
+    const expanded = expandTilde(buffer);
+    let dir;
+    let prefix;
+    if (expanded.endsWith("/")) {
+        dir = expanded;
+        prefix = "";
+    }
+    else {
+        const d = dirname(expanded);
+        dir = d === "" ? "." : d;
+        prefix = basename(expanded);
+    }
+    let names = [];
+    try {
+        names = readdirSync(dir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() &&
+            e.name.toLowerCase().startsWith(prefix.toLowerCase()))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return "";
+    }
+    if (names.length === 0)
+        return "";
+    if (expanded.endsWith("/")) {
+        return `${names[0]}/`;
+    }
+    const first = names[0];
+    if (first.toLowerCase() === prefix.toLowerCase()) {
+        return "/";
+    }
+    return `${first.slice(prefix.length)}/`;
+}
+async function promptPathTTY(message, initial) {
+    process.stdout.write(`${CYAN}?${RESET} ${BOLD}${message}${RESET} ${DIM}(→ or Tab to accept · Enter to confirm)${RESET}\n`);
+    const PROMPT = `${DIM}›${RESET} `;
+    let buffer = initial;
+    const render = () => {
+        const suggestion = findSuggestion(buffer);
+        process.stdout.write(`\r\x1b[K${PROMPT}${buffer}${DIM}${suggestion}${RESET}`);
+        if (suggestion.length > 0) {
+            process.stdout.write(`\x1b[${suggestion.length}D`);
+        }
+    };
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        const cleanup = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+        };
+        const acceptSuggestion = () => {
+            const sug = findSuggestion(buffer);
+            if (sug)
+                buffer += sug;
+        };
+        const onData = (chunk) => {
+            // Whole-chunk escape sequences (arrow keys, function keys, etc.)
+            if (chunk === "\x1b[C") {
+                acceptSuggestion();
+                render();
+                return;
+            }
+            if (chunk.startsWith("\x1b")) {
+                // ignore other escapes (left/up/down arrows, etc.)
+                return;
+            }
+            for (const ch of chunk) {
+                if (ch === "\x03") {
+                    // Ctrl+C
+                    cleanup();
+                    process.stdout.write(`\n${DIM}aborted.${RESET}\n`);
+                    process.exit(130);
+                }
+                if (ch === "\r" || ch === "\n") {
+                    cleanup();
+                    // commit final line with no ghost text
+                    process.stdout.write(`\r\x1b[K${PROMPT}${buffer}\n`);
+                    const val = buffer.trim();
+                    const final = val === "" ? initial : val;
+                    const resolved = expandTilde(final);
+                    process.stdout.write(`  ${GREEN}✔${RESET} ${DIM}${resolved}${RESET}\n`);
+                    resolve(resolved);
+                    return;
+                }
+                if (ch === "\t") {
+                    acceptSuggestion();
+                    render();
+                    continue;
+                }
+                if (ch === "\x7f" || ch === "\x08") {
+                    // Backspace / Delete
+                    buffer = buffer.slice(0, -1);
+                    render();
+                    continue;
+                }
+                if (ch >= " ") {
+                    buffer += ch;
+                    render();
+                    continue;
+                }
+                // ignore other control chars
+            }
+        };
+        stdin.on("data", onData);
+        render();
+    });
+}
+async function promptPathFallback(message, initial) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ans = await rl.question(`${BOLD}${message}${RESET} `);
+    rl.close();
+    const v = ans.trim();
+    return expandTilde(v === "" ? initial : v);
+}
+export async function promptPath(message, initial) {
+    if (!process.stdin.isTTY) {
+        return promptPathFallback(message, initial);
+    }
+    return promptPathTTY(message, initial);
+}

package/dist/remove-agent.js

@@ -0,0 +1,63 @@
+import { existsSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { AGENTS } from "./agents/index.js";
+import { masterDir, requireWorkspace, setAgents, } from "./agentforge-config.js";
+import { confirm } from "./confirm.js";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+/** files / directories owned by each agent at workspace root */
+const AGENT_ARTIFACTS = {
+    claude: [".claude/skills", "CLAUDE.md"],
+    cursor: [".cursor/rules", ".cursorrules"],
+    codex: [".agents/skills", "AGENTS.md"],
+};
+export async function runRemoveAgent(opts) {
+    const root = resolve(opts.pathArg ?? process.cwd());
+    const cfg = requireWorkspace(root);
+    const adapter = AGENTS.find((a) => a.id === opts.agent);
+    if (!adapter) {
+        const valid = AGENTS.map((a) => a.id).join(", ");
+        process.stderr.write(`\n${RED}✗${RESET} Unknown agent: "${opts.agent}"\n\n  Valid options: ${CYAN}${valid}${RESET}\n\n`);
+        process.exit(1);
+    }
+    // master is preserved — only this agent's per-agent files are removed.
+    const paths = AGENT_ARTIFACTS[opts.agent]
+        .map((rel) => ({ rel, abs: join(root, rel) }))
+        .filter((p) => existsSync(p.abs));
+    if (paths.length === 0) {
+        console.log(`${YELLOW}${adapter.label} has no artifacts in ${root} — nothing to remove.${RESET}`);
+        // still update config in case it's listed
+        if (cfg.agents.includes(opts.agent)) {
+            setAgents(root, cfg.agents.filter((id) => id !== opts.agent));
+            console.log(`${DIM}  config.agents updated.${RESET}`);
+        }
+        return;
+    }
+    console.log(`${BOLD}Removing ${adapter.label}${RESET} from ${CYAN}${root}${RESET}`);
+    console.log(`  ${DIM}files to delete:${RESET}`);
+    for (const p of paths)
+        console.log(`    - ${p.rel}`);
+    console.log("");
+    console.log(`  ${DIM}master skills (agentforge/skills/) are kept.${RESET}`);
+    console.log("");
+    const ok = opts.yes || (await confirm(`Proceed?`, false));
+    if (!ok) {
+        console.log(`${YELLOW}aborted.${RESET}`);
+        return;
+    }
+    for (const p of paths) {
+        rmSync(p.abs, { recursive: true, force: true });
+        console.log(`${GREEN}-${RESET} removed: ${p.rel}`);
+    }
+    setAgents(root, cfg.agents.filter((id) => id !== opts.agent));
+    console.log(`${DIM}  config.agents updated.${RESET}`);
+    // dummy reference to silence "masterDir unused" if it ever becomes so
+    void masterDir;
+    console.log("");
+    console.log(`${BOLD}${GREEN}✓${RESET} ${adapter.label} removed.`);
+}

package/dist/remove-skill.js

@@ -0,0 +1,88 @@
+import { existsSync, rmSync, unlinkSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readMasterDir } from "./agents/io.js";
+import { getAgent } from "./agents/index.js";
+import { masterDir, requireWorkspace } from "./agentforge-config.js";
+import { confirm } from "./confirm.js";
+import { SKILLS } from "./skills-data.js";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+const AGENT_SKILL_TARGETS = {
+    claude: (root, id) => ({
+        path: join(root, ".claude/skills", id),
+        isDir: true,
+    }),
+    cursor: (root, id) => ({
+        path: join(root, ".cursor/rules", `${id}.mdc`),
+        isDir: false,
+    }),
+    codex: (root, id) => ({
+        path: join(root, ".agents/skills", `${id}.md`),
+        isDir: false,
+    }),
+};
+export async function runRemoveSkill(opts) {
+    const root = resolve(opts.pathArg ?? process.cwd());
+    const cfg = requireWorkspace(root);
+    const masterPath = join(masterDir(root), `${opts.name}.md`);
+    if (!existsSync(masterPath)) {
+        process.stderr.write(`\n${RED}✗${RESET} No master skill named "${opts.name}".\n  ${DIM}${masterPath}${RESET}\n\n` +
+            `  Run ${CYAN}agentforge list-skills${RESET} to see what's available.\n\n`);
+        process.exit(1);
+    }
+    // collect agent artifacts to remove
+    const targets = [];
+    for (const id of cfg.agents) {
+        const t = AGENT_SKILL_TARGETS[id](root, opts.name);
+        if (existsSync(t.path)) {
+            targets.push({ rel: t.path.slice(root.length + 1), abs: t.path, isDir: t.isDir });
+        }
+    }
+    const isStandard = SKILLS.some((s) => s.id === opts.name);
+    console.log(`${BOLD}Removing skill${RESET} ${CYAN}${opts.name}${RESET} from ${CYAN}${root}${RESET}`);
+    if (isStandard) {
+        console.log(`  ${YELLOW}note:${RESET} this is a standard agentforge skill. Re-init or \`add-skill --from\` will restore it.`);
+    }
+    console.log(`  ${DIM}files to delete:${RESET}`);
+    console.log(`    - agentforge/skills/${opts.name}.md  ${DIM}(master)${RESET}`);
+    for (const t of targets)
+        console.log(`    - ${t.rel}`);
+    console.log("");
+    const ok = opts.yes || (await confirm("Proceed?", false));
+    if (!ok) {
+        console.log(`${YELLOW}aborted.${RESET}`);
+        return;
+    }
+    // delete master first; then re-sync per-agent index files (AGENTS.md) by
+    // re-running the install for each agent on the remaining master skills.
+    unlinkSync(masterPath);
+    console.log(`${GREEN}-${RESET} removed: agentforge/skills/${opts.name}.md`);
+    for (const t of targets) {
+        if (t.isDir)
+            rmSync(t.abs, { recursive: true, force: true });
+        else
+            unlinkSync(t.abs);
+        console.log(`${GREEN}-${RESET} removed: ${t.rel}`);
+    }
+    // Re-run each agent's install with the remaining master skills so that
+    // index sections (e.g. AGENTS.md Skills) reflect the deletion.
+    const { skills: remaining } = readMasterDir(masterDir(root));
+    for (const id of cfg.agents) {
+        const adapter = getAgent(id);
+        adapter.install({
+            root,
+            masterSkills: remaining,
+            skillCatalog: SKILLS.slice(),
+            lang: cfg.lang,
+            forceSkills: true,
+            forceClaude: true, // re-emit root guides to refresh indexes
+        });
+    }
+    console.log("");
+    console.log(`${BOLD}${GREEN}✓${RESET} removed skill: ${opts.name}`);
+}