claude-code-arcane 2.7.1 → 2.8.0

package/dist/cli.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // src/commands/install.ts
-import path11 from "path";
+import path12 from "path";
 import chalk2 from "chalk";
 
 // src/profiles.ts
@@ -374,8 +374,8 @@ function hint(description, max = 90) {
 }
 
 // src/installer.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 
 // src/utils.ts
 import { fileURLToPath } from "url";
@@ -434,11 +434,66 @@ function safeRemove(p2) {
   }
 }
 
-// src/manifest.ts
+// src/agent-entries.ts
+import fs4 from "fs";
 import path4 from "path";
+function parseAgentEntry(raw) {
+  const trimmed = raw.trim().replace(/\/+$/, "");
+  const slash = trimmed.indexOf("/");
+  if (slash < 0) return { raw: trimmed, division: trimmed };
+  return {
+    raw: trimmed,
+    division: trimmed.slice(0, slash),
+    agent: trimmed.slice(slash + 1)
+  };
+}
+function isGranular(raw) {
+  return parseAgentEntry(raw).agent !== void 0;
+}
+function agentSourcePath(root, raw) {
+  const { division, agent } = parseAgentEntry(raw);
+  const p2 = agent ? path4.join(root, "agents", division, `${agent}.md`) : path4.join(root, "agents", division);
+  return fs4.existsSync(p2) ? p2 : null;
+}
+function copyAgentEntry(root, claudeDir, raw) {
+  const src = agentSourcePath(root, raw);
+  if (!src) return null;
+  const { division, agent } = parseAgentEntry(raw);
+  const dstDir = path4.join(claudeDir, "agents", division);
+  if (agent) {
+    ensureDir(dstDir);
+    fs4.copyFileSync(src, path4.join(dstDir, `${agent}.md`));
+    return 1;
+  }
+  copyDirSync(src, dstDir);
+  return fs4.readdirSync(dstDir, { recursive: true }).filter((f) => String(f).endsWith(".md")).length;
+}
+function removeAgentEntry(claudeDir, raw) {
+  const { division, agent } = parseAgentEntry(raw);
+  const dstDir = path4.join(claudeDir, "agents", division);
+  if (!agent) {
+    if (!fs4.existsSync(dstDir)) return false;
+    fs4.rmSync(dstDir, { recursive: true, force: true });
+    return true;
+  }
+  const file = path4.join(dstDir, `${agent}.md`);
+  if (!fs4.existsSync(file)) return false;
+  safeRemove(file);
+  if (fs4.existsSync(dstDir) && fs4.readdirSync(dstDir).length === 0) {
+    fs4.rmSync(dstDir, { recursive: true, force: true });
+  }
+  return true;
+}
+function agentEntryLabel(raw) {
+  const { division, agent } = parseAgentEntry(raw);
+  return agent ? `agents/${division}/${agent}.md` : `agents/${division}/`;
+}
+
+// src/manifest.ts
+import path5 from "path";
 var MANIFEST_FILE = "arcane-manifest.json";
 function manifestPath(target) {
-  return path4.join(target, ".claude", MANIFEST_FILE);
+  return path5.join(target, ".claude", MANIFEST_FILE);
 }
 function readManifest(target) {
   const p2 = manifestPath(target);
@@ -492,8 +547,8 @@ function updateManifestFields(target, updates) {
 
 // src/worktree.ts
 import { execSync } from "child_process";
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 function getWorktreeInfo(target) {
   try {
     execSync("git rev-parse --is-inside-work-tree", {
@@ -514,10 +569,10 @@ function getWorktreeInfo(target) {
     encoding: "utf-8",
     stdio: "pipe"
   }).trim();
-  const resolvedCommon = path5.resolve(target, gitCommonDir);
-  const resolvedGit = path5.resolve(target, gitDir);
+  const resolvedCommon = path6.resolve(target, gitCommonDir);
+  const resolvedGit = path6.resolve(target, gitDir);
   const isWorktree = resolvedCommon !== resolvedGit;
-  const mainWorktreePath = isWorktree ? path5.resolve(resolvedCommon, "..") : target;
+  const mainWorktreePath = isWorktree ? path6.resolve(resolvedCommon, "..") : target;
   let currentBranch = "HEAD";
   try {
     currentBranch = execSync("git branch --show-current", {
@@ -532,7 +587,7 @@ function getWorktreeInfo(target) {
     isWorktree,
     mainWorktreePath,
     currentBranch,
-    worktreeId: path5.basename(target),
+    worktreeId: path6.basename(target),
     allWorktrees
   };
 }
@@ -568,17 +623,17 @@ function parseWorktreeList(cwd) {
   }
 }
 function findMainArcaneInstall(mainPath) {
-  return fs4.existsSync(
-    path5.join(mainPath, ".claude", "arcane-manifest.json")
+  return fs5.existsSync(
+    path6.join(mainPath, ".claude", "arcane-manifest.json")
   );
 }
 function linkOrCopyDir(src, dest, mode) {
   if (mode === "symlink") {
     try {
-      const parentDir = path5.dirname(dest);
-      fs4.mkdirSync(parentDir, { recursive: true });
+      const parentDir = path6.dirname(dest);
+      fs5.mkdirSync(parentDir, { recursive: true });
       const type = process.platform === "win32" ? "junction" : "dir";
-      fs4.symlinkSync(src, dest, type);
+      fs5.symlinkSync(src, dest, type);
       return "linked";
     } catch {
     }
@@ -590,9 +645,9 @@ function sanitizeBranchForPath(branch) {
   return branch.replace(/^(feat|fix|feature|hotfix)\//, "").replace(/\//g, "-").replace(/[^a-zA-Z0-9._-]/g, "-");
 }
 function defaultWorktreePath(repoRoot, branch) {
-  const repoName = path5.basename(repoRoot);
+  const repoName = path6.basename(repoRoot);
   const sanitized = sanitizeBranchForPath(branch);
-  return path5.resolve(repoRoot, "..", `${repoName}-${sanitized}`);
+  return path6.resolve(repoRoot, "..", `${repoName}-${sanitized}`);
 }
 function createGitWorktree(repoRoot, worktreePath, branch, base) {
   const branchExists = checkBranchExists(repoRoot, branch);
@@ -634,20 +689,20 @@ function detectPackageManager(dir) {
     { lockfile: "package-lock.json", command: "npm install" }
   ];
   for (const m of managers) {
-    if (fs4.existsSync(path5.join(dir, m.lockfile))) return m;
+    if (fs5.existsSync(path6.join(dir, m.lockfile))) return m;
   }
-  if (fs4.existsSync(path5.join(dir, "package.json"))) {
+  if (fs5.existsSync(path6.join(dir, "package.json"))) {
     return { lockfile: "package.json", command: "npm install" };
   }
   return null;
 }
 
 // src/content-hash.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import { createHash } from "crypto";
 function hashFile(filePath) {
-  const content = fs5.readFileSync(filePath);
+  const content = fs6.readFileSync(filePath);
   return createHash("sha256").update(content).digest("hex");
 }
 function hashDirectory(dirPath) {
@@ -656,10 +711,10 @@ function hashDirectory(dirPath) {
   return hashes;
 }
 function walkDir(base, current, hashes) {
-  for (const entry of fs5.readdirSync(current, { withFileTypes: true })) {
+  for (const entry of fs6.readdirSync(current, { withFileTypes: true })) {
     if (isBuildArtifact(entry.name)) continue;
-    const fullPath = path6.join(current, entry.name);
-    const relPath = path6.relative(base, fullPath).split(path6.sep).join("/");
+    const fullPath = path7.join(current, entry.name);
+    const relPath = path7.relative(base, fullPath).split(path7.sep).join("/");
     if (entry.isDirectory()) {
       walkDir(base, fullPath, hashes);
     } else {
@@ -674,39 +729,39 @@ function computeContentHashes(claudeDir) {
     agents: {},
     hooks: {}
   };
-  const skillsDir = path6.join(claudeDir, "skills");
-  if (fs5.existsSync(skillsDir)) {
-    for (const entry of fs5.readdirSync(skillsDir, { withFileTypes: true })) {
+  const skillsDir = path7.join(claudeDir, "skills");
+  if (fs6.existsSync(skillsDir)) {
+    for (const entry of fs6.readdirSync(skillsDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        const dirHash = hashDirectory(path6.join(skillsDir, entry.name));
+        const dirHash = hashDirectory(path7.join(skillsDir, entry.name));
         const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
         hashes.skills[entry.name] = combined;
       }
     }
   }
-  const rulesDir = path6.join(claudeDir, "rules");
-  if (fs5.existsSync(rulesDir)) {
-    for (const entry of fs5.readdirSync(rulesDir, { withFileTypes: true })) {
+  const rulesDir = path7.join(claudeDir, "rules");
+  if (fs6.existsSync(rulesDir)) {
+    for (const entry of fs6.readdirSync(rulesDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
-        hashes.rules[entry.name] = hashFile(path6.join(rulesDir, entry.name));
+        hashes.rules[entry.name] = hashFile(path7.join(rulesDir, entry.name));
       }
     }
   }
-  const agentsDir = path6.join(claudeDir, "agents");
-  if (fs5.existsSync(agentsDir)) {
-    for (const entry of fs5.readdirSync(agentsDir, { withFileTypes: true })) {
+  const agentsDir = path7.join(claudeDir, "agents");
+  if (fs6.existsSync(agentsDir)) {
+    for (const entry of fs6.readdirSync(agentsDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        const dirHash = hashDirectory(path6.join(agentsDir, entry.name));
+        const dirHash = hashDirectory(path7.join(agentsDir, entry.name));
         const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
         hashes.agents[entry.name] = combined;
       }
     }
   }
-  const hooksDir = path6.join(claudeDir, "hooks");
-  if (fs5.existsSync(hooksDir)) {
-    for (const entry of fs5.readdirSync(hooksDir, { withFileTypes: true })) {
+  const hooksDir = path7.join(claudeDir, "hooks");
+  if (fs6.existsSync(hooksDir)) {
+    for (const entry of fs6.readdirSync(hooksDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
-        hashes.hooks[entry.name] = hashFile(path6.join(hooksDir, entry.name));
+        hashes.hooks[entry.name] = hashFile(path7.join(hooksDir, entry.name));
       }
     }
   }
@@ -720,8 +775,8 @@ function computeSourceHashes(packageRoot, skills, rules, agents) {
     hooks: {}
   };
   for (const skill of skills) {
-    const skillDir = path6.join(packageRoot, "skills", skill);
-    if (fs5.existsSync(skillDir)) {
+    const skillDir = path7.join(packageRoot, "skills", skill);
+    if (fs6.existsSync(skillDir)) {
       const dirHash = hashDirectory(skillDir);
       const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
       hashes.skills[skill] = combined;
@@ -729,29 +784,29 @@ function computeSourceHashes(packageRoot, skills, rules, agents) {
   }
   for (const rule of rules) {
     const ruleName = rule.endsWith(".md") ? rule : `${rule}.md`;
-    const rulePath = path6.join(packageRoot, "rules", ruleName);
-    if (fs5.existsSync(rulePath)) {
+    const rulePath = path7.join(packageRoot, "rules", ruleName);
+    if (fs6.existsSync(rulePath)) {
       hashes.rules[ruleName] = hashFile(rulePath);
     } else {
-      const gamedevPath = path6.join(packageRoot, "rules", "gamedev", ruleName);
-      if (fs5.existsSync(gamedevPath)) {
+      const gamedevPath = path7.join(packageRoot, "rules", "gamedev", ruleName);
+      if (fs6.existsSync(gamedevPath)) {
         hashes.rules[ruleName] = hashFile(gamedevPath);
       }
     }
   }
   for (const agent of agents) {
-    const agentDir = path6.join(packageRoot, "agents", agent);
-    if (fs5.existsSync(agentDir)) {
+    const agentDir = path7.join(packageRoot, "agents", agent);
+    if (fs6.existsSync(agentDir)) {
       const dirHash = hashDirectory(agentDir);
       const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
       hashes.agents[agent] = combined;
     }
   }
-  const hooksDir = path6.join(packageRoot, "hooks");
-  if (fs5.existsSync(hooksDir)) {
-    for (const entry of fs5.readdirSync(hooksDir, { withFileTypes: true })) {
+  const hooksDir = path7.join(packageRoot, "hooks");
+  if (fs6.existsSync(hooksDir)) {
+    for (const entry of fs6.readdirSync(hooksDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
-        hashes.hooks[entry.name] = hashFile(path6.join(hooksDir, entry.name));
+        hashes.hooks[entry.name] = hashFile(path7.join(hooksDir, entry.name));
       }
     }
   }
@@ -920,7 +975,7 @@ var Installer = class {
   constructor(merged, opts) {
     this.root = opts.contentRoot ?? getPackageRoot();
     this.target = opts.target;
-    this.claudeDir = path7.join(opts.target, ".claude");
+    this.claudeDir = path8.join(opts.target, ".claude");
     this.merged = merged;
     this.dryRun = opts.dryRun;
     this.shareFrom = opts.shareFrom;
@@ -952,22 +1007,22 @@ var Installer = class {
     return this.logs;
   }
   backup() {
-    if (!fs6.existsSync(this.claudeDir)) return;
-    const backup = path7.join(this.target, ".claude.bak");
+    if (!fs7.existsSync(this.claudeDir)) return;
+    const backup = path8.join(this.target, ".claude.bak");
     if (this.dryRun) {
       this.log("  [dry-run] Would backup .claude/ -> .claude.bak/");
       return;
     }
-    if (fs6.existsSync(backup)) {
-      fs6.rmSync(backup, { recursive: true, force: true });
+    if (fs7.existsSync(backup)) {
+      fs7.rmSync(backup, { recursive: true, force: true });
     }
-    fs6.renameSync(this.claudeDir, backup);
+    fs7.renameSync(this.claudeDir, backup);
     this.log("  Backed up .claude/ -> .claude.bak/");
   }
   createDirs() {
     if (this.dryRun) return;
     for (const d of ["skills", "rules", "agents", "docs"]) {
-      ensureDir(path7.join(this.claudeDir, d));
+      ensureDir(path8.join(this.claudeDir, d));
     }
   }
   get hasStatusline() {
@@ -975,7 +1030,7 @@ var Installer = class {
   }
   copyHooks() {
     this.log("\nHooks:");
-    const hooksDir = path7.join(this.claudeDir, "hooks");
+    const hooksDir = path8.join(this.claudeDir, "hooks");
     if (this.dryRun) {
       if (this.shareFrom) {
         this.log("  [dry-run] hooks/ -> symlink from main worktree");
@@ -986,8 +1041,8 @@ var Installer = class {
       return;
     }
     if (this.shareFrom) {
-      const sharedHooks = path7.join(this.shareFrom, ".claude", "hooks");
-      if (fs6.existsSync(sharedHooks)) {
+      const sharedHooks = path8.join(this.shareFrom, ".claude", "hooks");
+      if (fs7.existsSync(sharedHooks)) {
         const result = linkOrCopyDir(sharedHooks, hooksDir, "symlink");
         if (result === "linked") {
           this.sharedDirs.push("hooks");
@@ -999,17 +1054,17 @@ var Installer = class {
         return;
       }
     }
-    const hooksSrc = path7.join(this.root, "hooks");
-    if (fs6.existsSync(hooksSrc)) {
+    const hooksSrc = path8.join(this.root, "hooks");
+    if (fs7.existsSync(hooksSrc)) {
       ensureDir(hooksDir);
-      for (const entry of fs6.readdirSync(hooksSrc, { withFileTypes: true })) {
+      for (const entry of fs7.readdirSync(hooksSrc, { withFileTypes: true })) {
         if (entry.name === "statusline.sh") continue;
-        const src = path7.join(hooksSrc, entry.name);
-        const dst = path7.join(hooksDir, entry.name);
+        const src = path8.join(hooksSrc, entry.name);
+        const dst = path8.join(hooksDir, entry.name);
         if (entry.isDirectory()) {
           copyDirSync(src, dst);
         } else {
-          fs6.copyFileSync(src, dst);
+          fs7.copyFileSync(src, dst);
         }
       }
       this.log("  [ok] hooks/");
@@ -1018,11 +1073,11 @@ var Installer = class {
   }
   copyStatusline() {
     if (!this.hasStatusline) return;
-    const statusline = path7.join(this.root, "hooks", "statusline.sh");
-    if (fs6.existsSync(statusline)) {
-      fs6.copyFileSync(
+    const statusline = path8.join(this.root, "hooks", "statusline.sh");
+    if (fs7.existsSync(statusline)) {
+      fs7.copyFileSync(
         statusline,
-        path7.join(this.claudeDir, "statusline.sh")
+        path8.join(this.claudeDir, "statusline.sh")
       );
       this.log("  [ok] statusline.sh (statusline profile)");
     }
@@ -1030,12 +1085,12 @@ var Installer = class {
   copySkills() {
     this.log("\nSkills:");
     for (const skill of this.merged.skills) {
-      const src = path7.join(this.root, "skills", skill);
-      if (!fs6.existsSync(src)) {
+      const src = path8.join(this.root, "skills", skill);
+      if (!fs7.existsSync(src)) {
         this.log(`  WARN: Skill '${skill}' not found in skills/`);
         continue;
       }
-      const dst = path7.join(this.claudeDir, "skills", skill);
+      const dst = path8.join(this.claudeDir, "skills", skill);
       if (this.dryRun) {
         this.log(`  [dry-run] ${skill}`);
       } else {
@@ -1045,9 +1100,9 @@ var Installer = class {
     }
     const hasGamedev = this.merged.rules.gamedev.length > 0;
     if (hasGamedev) {
-      const tplSrc = path7.join(this.root, "templates", "gamedev");
-      if (fs6.existsSync(tplSrc)) {
-        const tplDst = path7.join(this.claudeDir, "skills", "_templates");
+      const tplSrc = path8.join(this.root, "templates", "gamedev");
+      if (fs7.existsSync(tplSrc)) {
+        const tplDst = path8.join(this.claudeDir, "skills", "_templates");
         if (this.dryRun) {
           this.log("  [dry-run] _templates/");
         } else {
@@ -1060,33 +1115,33 @@ var Installer = class {
   copyRules() {
     this.log("\nRules:");
     for (const rule of this.merged.rules.universal) {
-      const src = path7.join(this.root, "rules", `${rule}.md`);
-      if (!fs6.existsSync(src)) {
+      const src = path8.join(this.root, "rules", `${rule}.md`);
+      if (!fs7.existsSync(src)) {
         this.log(`  WARN: Rule '${rule}.md' not found`);
         continue;
       }
       if (this.dryRun) {
         this.log(`  [dry-run] ${rule}.md`);
       } else {
-        fs6.copyFileSync(
+        fs7.copyFileSync(
           src,
-          path7.join(this.claudeDir, "rules", `${rule}.md`)
+          path8.join(this.claudeDir, "rules", `${rule}.md`)
         );
         this.log(`  [ok] ${rule}.md`);
       }
     }
     for (const rule of this.merged.rules.gamedev) {
-      const src = path7.join(this.root, "rules", "gamedev", `${rule}.md`);
-      if (!fs6.existsSync(src)) {
+      const src = path8.join(this.root, "rules", "gamedev", `${rule}.md`);
+      if (!fs7.existsSync(src)) {
         this.log(`  WARN: Rule '${rule}.md' not found`);
         continue;
       }
       if (this.dryRun) {
         this.log(`  [dry-run] ${rule}.md`);
       } else {
-        fs6.copyFileSync(
+        fs7.copyFileSync(
           src,
-          path7.join(this.claudeDir, "rules", `${rule}.md`)
+          path8.join(this.claudeDir, "rules", `${rule}.md`)
         );
         this.log(`  [ok] ${rule}.md`);
       }
@@ -1095,26 +1150,24 @@ var Installer = class {
   copyAgents() {
     if (this.merged.agents.length === 0) return;
     this.log("\nAgents:");
-    for (const agentDir of this.merged.agents) {
-      const src = path7.join(this.root, "agents", agentDir);
-      if (!fs6.existsSync(src)) {
-        this.log(`  WARN: Agent dir '${agentDir}' not found`);
+    for (const entry of this.merged.agents) {
+      const label = agentEntryLabel(entry);
+      if (!agentSourcePath(this.root, entry)) {
+        this.log(`  WARN: Agent entry '${entry}' not found`);
         continue;
       }
-      const dst = path7.join(this.claudeDir, "agents", agentDir);
       if (this.dryRun) {
-        this.log(`  [dry-run] agents/${agentDir}/`);
-      } else {
-        copyDirSync(src, dst);
-        const count = fs6.readdirSync(dst, { recursive: true }).filter((f) => String(f).endsWith(".md")).length;
-        this.log(`  [ok] agents/${agentDir}/ (${count} agents)`);
+        this.log(`  [dry-run] ${label}`);
+        continue;
       }
+      const count = copyAgentEntry(this.root, this.claudeDir, entry);
+      this.log(`  [ok] ${label}${count === 1 ? "" : ` (${count} agents)`}`);
     }
   }
   copyDocs() {
-    const docsDir = path7.join(this.claudeDir, "docs");
-    const docsSrc = path7.join(this.root, "docs");
-    if (!fs6.existsSync(docsSrc)) return;
+    const docsDir = path8.join(this.claudeDir, "docs");
+    const docsSrc = path8.join(this.root, "docs");
+    if (!fs7.existsSync(docsSrc)) return;
     this.log("\nDocs:");
     if (this.dryRun) {
       if (this.shareFrom) {
@@ -1125,8 +1178,8 @@ var Installer = class {
       return;
     }
     if (this.shareFrom) {
-      const sharedDocs = path7.join(this.shareFrom, ".claude", "docs");
-      if (fs6.existsSync(sharedDocs)) {
+      const sharedDocs = path8.join(this.shareFrom, ".claude", "docs");
+      if (fs7.existsSync(sharedDocs)) {
         const result = linkOrCopyDir(sharedDocs, docsDir, "symlink");
         if (result === "linked") {
           this.sharedDirs.push("docs");
@@ -1157,8 +1210,8 @@ var Installer = class {
       );
       return;
     }
-    const settingsPath = path7.join(this.claudeDir, "settings.json");
-    fs6.writeFileSync(
+    const settingsPath = path8.join(this.claudeDir, "settings.json");
+    fs7.writeFileSync(
       settingsPath,
       JSON.stringify(settings, null, 2) + "\n",
       "utf-8"
@@ -1167,15 +1220,15 @@ var Installer = class {
   }
 };
 function clean(target) {
-  const claudeDir = path7.join(target, ".claude");
-  const backup = path7.join(target, ".claude.bak");
-  if (!fs6.existsSync(claudeDir)) {
+  const claudeDir = path8.join(target, ".claude");
+  const backup = path8.join(target, ".claude.bak");
+  if (!fs7.existsSync(claudeDir)) {
     console.log(`No .claude/ found in ${target} \u2014 nothing to clean.`);
     return;
   }
-  const manifestFile = path7.join(claudeDir, "arcane-manifest.json");
-  if (fs6.existsSync(manifestFile)) {
-    const data = JSON.parse(fs6.readFileSync(manifestFile, "utf-8"));
+  const manifestFile = path8.join(claudeDir, "arcane-manifest.json");
+  if (fs7.existsSync(manifestFile)) {
+    const data = JSON.parse(fs7.readFileSync(manifestFile, "utf-8"));
     const profiles = (data.profiles ?? []).filter(
       (p2) => p2 !== "core"
     );
@@ -1183,49 +1236,49 @@ function clean(target) {
     console.log(`  Installed: ${data.installed_at ?? "unknown"}`);
     const shared = data.worktree?.shared_dirs ?? [];
     for (const dir of shared) {
-      const p2 = path7.join(claudeDir, dir);
+      const p2 = path8.join(claudeDir, dir);
       if (isSymlinkOrJunction(p2)) {
-        fs6.unlinkSync(p2);
+        fs7.unlinkSync(p2);
         console.log(`  [ok] Unlinked shared ${dir}/`);
       }
     }
   }
   for (const sub of ["hooks", "docs", "skills", "agents", "rules"]) {
-    const p2 = path7.join(claudeDir, sub);
+    const p2 = path8.join(claudeDir, sub);
     safeRemove(p2);
   }
-  const remaining = fs6.readdirSync(claudeDir);
+  const remaining = fs7.readdirSync(claudeDir);
   for (const f of remaining) {
-    const p2 = path7.join(claudeDir, f);
+    const p2 = path8.join(claudeDir, f);
     safeRemove(p2);
   }
-  if (fs6.existsSync(claudeDir)) {
-    fs6.rmSync(claudeDir, { recursive: true, force: true });
+  if (fs7.existsSync(claudeDir)) {
+    fs7.rmSync(claudeDir, { recursive: true, force: true });
   }
-  if (fs6.existsSync(backup)) {
-    fs6.rmSync(backup, { recursive: true, force: true });
+  if (fs7.existsSync(backup)) {
+    fs7.rmSync(backup, { recursive: true, force: true });
   }
   console.log(`
   [ok] Removed .claude/ from ${target}`);
 }
 
 // src/content-source.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 import os2 from "os";
 
 // src/cache.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import os from "os";
-var ARCANE_DIR = path8.join(os.homedir(), ".arcane");
-var CACHE_DIR = path8.join(ARCANE_DIR, "cache");
+var ARCANE_DIR = path9.join(os.homedir(), ".arcane");
+var CACHE_DIR = path9.join(ARCANE_DIR, "cache");
 function getCachePath(version) {
-  return path8.join(CACHE_DIR, version);
+  return path9.join(CACHE_DIR, version);
 }
 function isCached(version) {
   const versionDir = getCachePath(version);
-  return fs7.existsSync(versionDir) && fs7.existsSync(path8.join(versionDir, ".cache-meta.json"));
+  return fs8.existsSync(versionDir) && fs8.existsSync(path9.join(versionDir, ".cache-meta.json"));
 }
 function getCachedContentRoot(version) {
   if (!isCached(version)) return null;
@@ -1233,34 +1286,34 @@ function getCachedContentRoot(version) {
 }
 function storeInCache(version, contentDir) {
   const versionDir = getCachePath(version);
-  if (fs7.existsSync(versionDir)) {
-    fs7.rmSync(versionDir, { recursive: true, force: true });
+  if (fs8.existsSync(versionDir)) {
+    fs8.rmSync(versionDir, { recursive: true, force: true });
   }
-  fs7.mkdirSync(versionDir, { recursive: true });
+  fs8.mkdirSync(versionDir, { recursive: true });
   for (const dir of ["skills", "rules", "agents", "hooks", "profiles", "templates", "docs"]) {
-    const src = path8.join(contentDir, dir);
-    if (fs7.existsSync(src)) {
-      copyDirRecursive(src, path8.join(versionDir, dir));
+    const src = path9.join(contentDir, dir);
+    if (fs8.existsSync(src)) {
+      copyDirRecursive(src, path9.join(versionDir, dir));
     }
   }
   const meta = {
     version,
     cached_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs7.writeFileSync(
-    path8.join(versionDir, ".cache-meta.json"),
+  fs8.writeFileSync(
+    path9.join(versionDir, ".cache-meta.json"),
     JSON.stringify(meta, null, 2) + "\n"
   );
   return versionDir;
 }
 function pruneCache(keepCount = 3) {
-  if (!fs7.existsSync(CACHE_DIR)) return;
-  const entries = fs7.readdirSync(CACHE_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
-    const metaPath = path8.join(CACHE_DIR, e.name, ".cache-meta.json");
+  if (!fs8.existsSync(CACHE_DIR)) return;
+  const entries = fs8.readdirSync(CACHE_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
+    const metaPath = path9.join(CACHE_DIR, e.name, ".cache-meta.json");
     let cachedAt = 0;
-    if (fs7.existsSync(metaPath)) {
+    if (fs8.existsSync(metaPath)) {
       try {
-        const meta = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
+        const meta = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
         cachedAt = new Date(meta.cached_at).getTime();
       } catch {
         cachedAt = 0;
@@ -1269,18 +1322,18 @@ function pruneCache(keepCount = 3) {
     return { name: e.name, cachedAt };
   }).sort((a, b) => b.cachedAt - a.cachedAt);
   for (const entry of entries.slice(keepCount)) {
-    fs7.rmSync(path8.join(CACHE_DIR, entry.name), { recursive: true, force: true });
+    fs8.rmSync(path9.join(CACHE_DIR, entry.name), { recursive: true, force: true });
   }
 }
 function copyDirRecursive(src, dest) {
-  fs7.mkdirSync(dest, { recursive: true });
-  for (const entry of fs7.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path8.join(src, entry.name);
-    const destPath = path8.join(dest, entry.name);
+  fs8.mkdirSync(dest, { recursive: true });
+  for (const entry of fs8.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path9.join(src, entry.name);
+    const destPath = path9.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs7.copyFileSync(srcPath, destPath);
+      fs8.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -1296,7 +1349,7 @@ var BundledContentSource = class {
   }
   async isAvailable() {
     const root = getPackageRoot();
-    return fs8.existsSync(path9.join(root, "skills"));
+    return fs9.existsSync(path10.join(root, "skills"));
   }
   async getVersion() {
     return getPackageVersion();
@@ -1336,14 +1389,14 @@ var GitHubContentSource = class {
     if (isCached(version)) {
       return getCachedContentRoot(version);
     }
-    const tmpDir = fs8.mkdtempSync(path9.join(os2.tmpdir(), "arcane-github-"));
+    const tmpDir = fs9.mkdtempSync(path10.join(os2.tmpdir(), "arcane-github-"));
     try {
       await this.downloadAndExtract(tmpDir);
       const contentRoot = storeInCache(version, this.findExtractedRoot(tmpDir));
       pruneCache(3);
       return contentRoot;
     } finally {
-      fs8.rmSync(tmpDir, { recursive: true, force: true });
+      fs9.rmSync(tmpDir, { recursive: true, force: true });
     }
   }
   async isAvailable() {
@@ -1399,8 +1452,8 @@ var GitHubContentSource = class {
       throw new Error(`Failed to download tarball: ${response.status}`);
     }
     const tar = await import("tar");
-    const tarballPath = path9.join(destDir, "repo.tar.gz");
-    const fileStream = fs8.createWriteStream(tarballPath);
+    const tarballPath = path10.join(destDir, "repo.tar.gz");
+    const fileStream = fs9.createWriteStream(tarballPath);
     const reader = response.body.getReader();
     const writable = new WritableStream({
       write(chunk) {
@@ -1425,12 +1478,12 @@ var GitHubContentSource = class {
     });
   }
   findExtractedRoot(tmpDir) {
-    const entries = fs8.readdirSync(tmpDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(tmpDir, { withFileTypes: true });
     const dirs = entries.filter(
       (e) => e.isDirectory() && e.name !== "." && e.name !== ".."
     );
     if (dirs.length === 1) {
-      return path9.join(tmpDir, dirs[0].name);
+      return path10.join(tmpDir, dirs[0].name);
     }
     return tmpDir;
   }
@@ -1485,14 +1538,14 @@ async function resolveContentSourceForVersion(version, opts = {}) {
   return source;
 }
 function findLatestCache() {
-  const cacheDir = path9.join(os2.homedir(), ".arcane", "cache");
-  if (!fs8.existsSync(cacheDir)) return null;
-  const entries = fs8.readdirSync(cacheDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
-    const metaPath = path9.join(cacheDir, e.name, ".cache-meta.json");
+  const cacheDir = path10.join(os2.homedir(), ".arcane", "cache");
+  if (!fs9.existsSync(cacheDir)) return null;
+  const entries = fs9.readdirSync(cacheDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
+    const metaPath = path10.join(cacheDir, e.name, ".cache-meta.json");
     let cachedAt = 0;
-    if (fs8.existsSync(metaPath)) {
+    if (fs9.existsSync(metaPath)) {
       try {
-        const meta = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
+        const meta = JSON.parse(fs9.readFileSync(metaPath, "utf-8"));
         cachedAt = new Date(meta.cached_at).getTime();
       } catch {
         cachedAt = 0;
@@ -1504,14 +1557,14 @@ function findLatestCache() {
 }
 
 // src/registry.ts
-import path10 from "path";
+import path11 from "path";
 import os3 from "os";
 var REGISTRY_VERSION = 1;
 function arcaneHome() {
-  return process.env.ARCANE_HOME ?? path10.join(os3.homedir(), ".arcane");
+  return process.env.ARCANE_HOME ?? path11.join(os3.homedir(), ".arcane");
 }
 function registryPath() {
-  return path10.join(arcaneHome(), "installations.json");
+  return path11.join(arcaneHome(), "installations.json");
 }
 function readRegistryFile() {
   const p2 = registryPath();
@@ -1536,7 +1589,7 @@ function writeRegistryFile(registry) {
   }
 }
 function registerInstallation(target) {
-  const abs = path10.resolve(target);
+  const abs = path11.resolve(target);
   const registry = readRegistryFile();
   if (registry.installations.some((e) => e.path === abs)) {
     return;
@@ -1563,8 +1616,8 @@ async function installCommand(profileExpr, opts) {
     quiet: !profileExpr
   });
   const root = await source.getContentRoot();
-  const profilesDir = path11.join(root, "profiles");
-  const target = path11.resolve(opts.target ?? process.cwd());
+  const profilesDir = path12.join(root, "profiles");
+  const target = path12.resolve(opts.target ?? process.cwd());
   if (!profileExpr) {
     const profiles = listProfiles(profilesDir);
     if (process.stdin.isTTY && process.stdout.isTTY) {
@@ -1635,21 +1688,21 @@ Installing profile: ${chalk2.cyan(profileExpr)}`)
 }
 
 // src/commands/add.ts
-import fs10 from "fs";
-import path13 from "path";
+import fs11 from "fs";
+import path14 from "path";
 import chalk3 from "chalk";
 
 // src/skills-catalog.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path13 from "path";
 var FRONTMATTER_BYTES = 4096;
 function listSkills(skillsDir) {
-  if (!fs9.existsSync(skillsDir)) return [];
-  return fs9.readdirSync(skillsDir, { withFileTypes: true }).filter(
-    (d) => d.isDirectory() && !d.name.startsWith("_") && fs9.existsSync(path12.join(skillsDir, d.name, "SKILL.md"))
+  if (!fs10.existsSync(skillsDir)) return [];
+  return fs10.readdirSync(skillsDir, { withFileTypes: true }).filter(
+    (d) => d.isDirectory() && !d.name.startsWith("_") && fs10.existsSync(path13.join(skillsDir, d.name, "SKILL.md"))
   ).map((d) => ({
     name: d.name,
-    description: readDescription(path12.join(skillsDir, d.name, "SKILL.md"))
+    description: readDescription(path13.join(skillsDir, d.name, "SKILL.md"))
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
 function readDescription(skillFile) {
@@ -1670,13 +1723,13 @@ function readDescription(skillFile) {
   return inline.replace(/^["']|["']$/g, "").trim();
 }
 function readHead(file) {
-  const fd = fs9.openSync(file, "r");
+  const fd = fs10.openSync(file, "r");
   try {
     const buf = Buffer.alloc(FRONTMATTER_BYTES);
-    const read = fs9.readSync(fd, buf, 0, FRONTMATTER_BYTES, 0);
+    const read = fs10.readSync(fd, buf, 0, FRONTMATTER_BYTES, 0);
     return buf.subarray(0, read).toString("utf-8");
   } finally {
-    fs9.closeSync(fd);
+    fs10.closeSync(fd);
   }
 }
 
@@ -1700,15 +1753,15 @@ async function addCommand(items = []) {
       return;
     }
     const selected = await runAddWizard({
-      profiles: listProfiles(path13.join(root, "profiles")),
-      skills: listSkills(path13.join(root, "skills")),
+      profiles: listProfiles(path14.join(root, "profiles")),
+      skills: listSkills(path14.join(root, "skills")),
       installedProfiles: manifest.profiles,
       installedSkills: manifest.installed_skills
     });
     if (!selected) return;
     items = selected;
   }
-  const claudeDir = path13.join(target, ".claude");
+  const claudeDir = path14.join(target, ".claude");
   const added = [];
   const skipped = [];
   const notFound = [];
@@ -1718,8 +1771,8 @@ async function addCommand(items = []) {
   for (const item of items) {
     if (item.startsWith("+")) {
       const profileName = item.slice(1);
-      const profilePath = path13.join(root, "profiles", `${profileName}.yaml`);
-      if (!fs10.existsSync(profilePath)) {
+      const profilePath = path14.join(root, "profiles", `${profileName}.yaml`);
+      if (!fs11.existsSync(profilePath)) {
         console.error(chalk3.red(`  Profile '${profileName}' not found`));
         continue;
       }
@@ -1732,10 +1785,10 @@ async function addCommand(items = []) {
       }
       for (const rule of profile.rules.universal) {
         if (!manifest.installed_rules.includes(rule)) {
-          const src = path13.join(root, "rules", `${rule}.md`);
-          if (fs10.existsSync(src)) {
-            ensureDir(path13.join(claudeDir, "rules"));
-            fs10.copyFileSync(src, path13.join(claudeDir, "rules", `${rule}.md`));
+          const src = path14.join(root, "rules", `${rule}.md`);
+          if (fs11.existsSync(src)) {
+            ensureDir(path14.join(claudeDir, "rules"));
+            fs11.copyFileSync(src, path14.join(claudeDir, "rules", `${rule}.md`));
             manifest.installed_rules.push(rule);
             addedRules.push(rule);
           }
@@ -1743,30 +1796,28 @@ async function addCommand(items = []) {
       }
       for (const rule of profile.rules.gamedev) {
         if (!manifest.installed_rules.includes(rule)) {
-          const src = path13.join(root, "rules", "gamedev", `${rule}.md`);
-          if (fs10.existsSync(src)) {
-            ensureDir(path13.join(claudeDir, "rules"));
-            fs10.copyFileSync(src, path13.join(claudeDir, "rules", `${rule}.md`));
+          const src = path14.join(root, "rules", "gamedev", `${rule}.md`);
+          if (fs11.existsSync(src)) {
+            ensureDir(path14.join(claudeDir, "rules"));
+            fs11.copyFileSync(src, path14.join(claudeDir, "rules", `${rule}.md`));
             manifest.installed_rules.push(rule);
             addedRules.push(rule);
           }
         }
       }
-      for (const agentDir of profile.agents) {
-        if (!manifest.installed_agents.includes(agentDir)) {
-          const src = path13.join(root, "agents", agentDir);
-          if (fs10.existsSync(src)) {
-            const dst = path13.join(claudeDir, "agents", agentDir);
-            copyDirSync(src, dst);
-            manifest.installed_agents.push(agentDir);
-            addedAgents.push(agentDir);
-          }
+      for (const entry of profile.agents) {
+        const { division } = parseAgentEntry(entry);
+        if (manifest.installed_agents.includes(entry)) continue;
+        if (isGranular(entry) && manifest.installed_agents.includes(division)) continue;
+        if (copyAgentEntry(root, claudeDir, entry) !== null) {
+          manifest.installed_agents.push(entry);
+          addedAgents.push(entry);
         }
       }
       if (profileName === "statusline") {
-        const statuslineSrc = path13.join(root, "hooks", "statusline.sh");
-        if (fs10.existsSync(statuslineSrc)) {
-          fs10.copyFileSync(statuslineSrc, path13.join(claudeDir, "statusline.sh"));
+        const statuslineSrc = path14.join(root, "hooks", "statusline.sh");
+        if (fs11.existsSync(statuslineSrc)) {
+          fs11.copyFileSync(statuslineSrc, path14.join(claudeDir, "statusline.sh"));
           statuslineAdded = true;
         }
       }
@@ -1808,7 +1859,7 @@ Added ${totalAdded} items:`
   );
   for (const s of added) console.log(chalk3.green(`  [ok] skill: ${s}`));
   for (const r of addedRules) console.log(chalk3.green(`  [ok] rule: ${r}`));
-  for (const a of addedAgents) console.log(chalk3.green(`  [ok] agents: ${a}/`));
+  for (const a of addedAgents) console.log(chalk3.green(`  [ok] ${agentEntryLabel(a)}`));
   if (statuslineAdded) console.log(chalk3.green("  [ok] statusline.sh"));
   for (const s of skipped)
     console.log(chalk3.dim(`  [skip] ${s} (already installed)`));
@@ -1824,10 +1875,10 @@ Added ${totalAdded} items:`
   }
 }
 function printCatalog(root, installedProfiles, installedSkills) {
-  const profiles = listProfiles(path13.join(root, "profiles")).filter(
+  const profiles = listProfiles(path14.join(root, "profiles")).filter(
     (pr) => !installedProfiles.includes(pr.name)
   );
-  const skills = listSkills(path13.join(root, "skills")).filter(
+  const skills = listSkills(path14.join(root, "skills")).filter(
     (sk) => !installedSkills.includes(sk.name)
   );
   if (profiles.length === 0 && skills.length === 0) {
@@ -1853,15 +1904,15 @@ function printCatalog(root, installedProfiles, installedSkills) {
 }
 function addSkill(root, target, skill, installed) {
   if (installed.includes(skill)) return "skipped";
-  const src = path13.join(root, "skills", skill);
-  if (!fs10.existsSync(src)) return "not-found";
-  const dst = path13.join(target, ".claude", "skills", skill);
+  const src = path14.join(root, "skills", skill);
+  if (!fs11.existsSync(src)) return "not-found";
+  const dst = path14.join(target, ".claude", "skills", skill);
   copyDirSync(src, dst);
   return "added";
 }
 function mergePermissions(claudeDir, newPerms) {
-  const settingsPath = path13.join(claudeDir, "settings.json");
-  if (!fs10.existsSync(settingsPath)) return;
+  const settingsPath = path14.join(claudeDir, "settings.json");
+  if (!fs11.existsSync(settingsPath)) return;
   const settings = readJsonSync(settingsPath);
   const perms = settings.permissions ?? { allow: [], deny: [] };
   const allowSet = new Set(perms.allow);
@@ -1874,8 +1925,8 @@ function mergePermissions(claudeDir, newPerms) {
   writeJsonSync(settingsPath, settings);
 }
 function addStatuslineToSettings(claudeDir) {
-  const settingsPath = path13.join(claudeDir, "settings.json");
-  if (!fs10.existsSync(settingsPath)) return;
+  const settingsPath = path14.join(claudeDir, "settings.json");
+  if (!fs11.existsSync(settingsPath)) return;
   const settings = readJsonSync(settingsPath);
   if (settings.statusLine) return;
   settings.statusLine = {
@@ -1886,8 +1937,8 @@ function addStatuslineToSettings(claudeDir) {
 }
 
 // src/commands/remove.ts
-import fs11 from "fs";
-import path14 from "path";
+import fs12 from "fs";
+import path15 from "path";
 import chalk4 from "chalk";
 var CORE_SKILLS = [
   "commit",
@@ -1952,7 +2003,7 @@ async function removeCommand(items, opts = {}) {
   }
   manifest.total_skills = manifest.installed_skills.length;
   manifest.total_rules = manifest.installed_rules.length;
-  const mp = path14.join(target, ".claude", "arcane-manifest.json");
+  const mp = path15.join(target, ".claude", "arcane-manifest.json");
   writeJsonSync(mp, manifest);
   const totalRemoved = removedSkills.length + removedAgents.length + removedProfiles.length;
   console.log(chalk4.bold(`
@@ -1973,9 +2024,9 @@ function removeSkill(target, skill, manifest) {
     );
     return "skipped";
   }
-  const skillDir = path14.join(target, ".claude", "skills", skill);
-  if (!fs11.existsSync(skillDir)) return "skipped";
-  fs11.rmSync(skillDir, { recursive: true, force: true });
+  const skillDir = path15.join(target, ".claude", "skills", skill);
+  if (!fs12.existsSync(skillDir)) return "skipped";
+  fs12.rmSync(skillDir, { recursive: true, force: true });
   manifest.installed_skills = manifest.installed_skills.filter(
     (s) => s !== skill
   );
@@ -1994,8 +2045,8 @@ function removeProfile(root, target, profileName, manifest) {
     );
     return { removed: false, skills: [], agents: [] };
   }
-  const profilePath = path14.join(root, "profiles", `${profileName}.yaml`);
-  if (!fs11.existsSync(profilePath)) {
+  const profilePath = path15.join(root, "profiles", `${profileName}.yaml`);
+  if (!fs12.existsSync(profilePath)) {
     console.warn(
       chalk4.yellow(`  WARNING: Profile '${profileName}.yaml' not found.`)
     );
@@ -2009,8 +2060,8 @@ function removeProfile(root, target, profileName, manifest) {
   const sharedAgents = /* @__PURE__ */ new Set();
   const sharedRules = /* @__PURE__ */ new Set();
   for (const rp of remainingProfiles) {
-    const rpPath = path14.join(root, "profiles", `${rp}.yaml`);
-    if (!fs11.existsSync(rpPath)) continue;
+    const rpPath = path15.join(root, "profiles", `${rp}.yaml`);
+    if (!fs12.existsSync(rpPath)) continue;
     const rpDef = parseProfile(rpPath);
     rpDef.skills.forEach((s) => sharedSkills.add(s));
     rpDef.agents.forEach((a) => sharedAgents.add(a));
@@ -2021,9 +2072,9 @@ function removeProfile(root, target, profileName, manifest) {
   for (const skill of profile.skills) {
     if (sharedSkills.has(skill)) continue;
     if (CORE_SKILLS.includes(skill)) continue;
-    const skillDir = path14.join(target, ".claude", "skills", skill);
-    if (fs11.existsSync(skillDir)) {
-      fs11.rmSync(skillDir, { recursive: true, force: true });
+    const skillDir = path15.join(target, ".claude", "skills", skill);
+    if (fs12.existsSync(skillDir)) {
+      fs12.rmSync(skillDir, { recursive: true, force: true });
       removedSkills.push(skill);
     }
     manifest.installed_skills = manifest.installed_skills.filter(
@@ -2031,15 +2082,14 @@ function removeProfile(root, target, profileName, manifest) {
     );
   }
   const removedAgents = [];
-  for (const agent of profile.agents) {
-    if (sharedAgents.has(agent)) continue;
-    const agentDir = path14.join(target, ".claude", "agents", agent);
-    if (fs11.existsSync(agentDir)) {
-      fs11.rmSync(agentDir, { recursive: true, force: true });
-      removedAgents.push(agent);
-    }
+  const claudeDir = path15.join(target, ".claude");
+  for (const entry of profile.agents) {
+    if (sharedAgents.has(entry)) continue;
+    const { division } = parseAgentEntry(entry);
+    if (isGranular(entry) && sharedAgents.has(division)) continue;
+    if (removeAgentEntry(claudeDir, entry)) removedAgents.push(entry);
     manifest.installed_agents = manifest.installed_agents.filter(
-      (a) => a !== agent
+      (a) => a !== entry
     );
   }
   for (const rule of [
@@ -2047,44 +2097,44 @@ function removeProfile(root, target, profileName, manifest) {
     ...profile.rules.gamedev
   ]) {
     if (sharedRules.has(rule)) continue;
-    const ruleFile = path14.join(target, ".claude", "rules", `${rule}.md`);
-    if (fs11.existsSync(ruleFile)) {
-      fs11.rmSync(ruleFile);
+    const ruleFile = path15.join(target, ".claude", "rules", `${rule}.md`);
+    if (fs12.existsSync(ruleFile)) {
+      fs12.rmSync(ruleFile);
     }
     manifest.installed_rules = manifest.installed_rules.filter(
       (r) => r !== rule
     );
   }
   if (profileName === "statusline") {
-    const statuslineFile = path14.join(target, ".claude", "statusline.sh");
-    if (fs11.existsSync(statuslineFile)) {
-      fs11.rmSync(statuslineFile);
+    const statuslineFile = path15.join(target, ".claude", "statusline.sh");
+    if (fs12.existsSync(statuslineFile)) {
+      fs12.rmSync(statuslineFile);
     }
-    removeStatuslineFromSettings(path14.join(target, ".claude"));
+    removeStatuslineFromSettings(path15.join(target, ".claude"));
   }
   manifest.profiles = remainingProfiles;
   manifest.profile_command = remainingProfiles.filter((p2) => p2 !== "core").join("+");
   return { removed: true, skills: removedSkills, agents: removedAgents };
 }
 function removeStatuslineFromSettings(claudeDir) {
-  const settingsPath = path14.join(claudeDir, "settings.json");
-  if (!fs11.existsSync(settingsPath)) return;
-  const settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+  const settingsPath = path15.join(claudeDir, "settings.json");
+  if (!fs12.existsSync(settingsPath)) return;
+  const settings = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
   if (settings.statusLine) {
     delete settings.statusLine;
-    fs11.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   }
 }
 
 // src/commands/list.ts
-import fs12 from "fs";
-import path15 from "path";
+import fs13 from "fs";
+import path16 from "path";
 import chalk5 from "chalk";
 async function listCommand() {
   const source = await resolveContentSource({ quiet: true });
   const root = await source.getContentRoot();
-  const profilesDir = path15.join(root, "profiles");
-  const skillsDir = path15.join(root, "skills");
+  const profilesDir = path16.join(root, "profiles");
+  const skillsDir = path16.join(root, "skills");
   const target = process.cwd();
   const manifest = readManifest(target);
   const profiles = listProfiles(profilesDir);
@@ -2101,7 +2151,7 @@ async function listCommand() {
     }
     console.log();
   }
-  if (fs12.existsSync(skillsDir)) {
+  if (fs13.existsSync(skillsDir)) {
     const allSkills = listSkills(skillsDir).map((s) => s.name);
     console.log(chalk5.bold(`
 === Skills (${allSkills.length}) ===
@@ -2168,8 +2218,8 @@ async function statusCommand() {
 }
 
 // src/commands/update.ts
-import fs13 from "fs";
-import path16 from "path";
+import fs14 from "fs";
+import path17 from "path";
 import os4 from "os";
 import chalk7 from "chalk";
 
@@ -2245,12 +2295,12 @@ async function updateCommand(opts) {
     }
   }
   const cwd = process.cwd();
-  if (fs13.existsSync(manifestPath(cwd))) {
+  if (fs14.existsSync(manifestPath(cwd))) {
     registerInstallation(cwd);
   }
   const targets = pruneRegistry().map((e) => e.path);
   const globalTarget = os4.homedir();
-  if (!process.env.VITEST && fs13.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
+  if (!process.env.VITEST && fs14.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
     targets.push(globalTarget);
   }
   if (targets.length === 0) {
@@ -2326,11 +2376,11 @@ Update available: ${chalk7.red(installedVersion)} -> ${chalk7.green(currentVersi
     );
   }
   const profileNames = manifest.profile_command.split("+").filter(Boolean);
-  const profilesDir = path16.join(root, "profiles");
+  const profilesDir = path17.join(root, "profiles");
   const merged = mergeProfiles(profilesDir, profileNames);
   const allRules = [...merged.rules.universal, ...merged.rules.gamedev];
   const sourceHashes = computeSourceHashes(root, merged.skills, allRules, merged.agents);
-  const claudeDir = path16.join(target, ".claude");
+  const claudeDir = path17.join(target, ".claude");
   const installedHashes = computeContentHashes(claudeDir);
   const items = computeUpdatePlan(
     manifest.content_hashes ?? null,
@@ -2523,48 +2573,48 @@ function applyUpdates(items, root, claudeDir, merged, force) {
 function applyItem(item, root, claudeDir) {
   const src = getSourcePath(item, root);
   const dst = getInstalledPath(item, claudeDir);
-  if (!src || !fs13.existsSync(src)) return;
+  if (!src || !fs14.existsSync(src)) return;
   if (item.type === "skill" || item.type === "agent") {
-    if (fs13.existsSync(dst)) {
-      fs13.rmSync(dst, { recursive: true, force: true });
+    if (fs14.existsSync(dst)) {
+      fs14.rmSync(dst, { recursive: true, force: true });
     }
     copyDirSync(src, dst);
   } else {
-    const dir = path16.dirname(dst);
-    if (!fs13.existsSync(dir)) {
-      fs13.mkdirSync(dir, { recursive: true });
+    const dir = path17.dirname(dst);
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
     }
-    fs13.copyFileSync(src, dst);
+    fs14.copyFileSync(src, dst);
   }
 }
 function backupItem(item, claudeDir) {
   const installed = getInstalledPath(item, claudeDir);
-  if (!fs13.existsSync(installed)) return;
+  if (!fs14.existsSync(installed)) return;
   const backupPath = installed + ".bak";
-  if (fs13.existsSync(backupPath)) {
-    fs13.rmSync(backupPath, { recursive: true, force: true });
+  if (fs14.existsSync(backupPath)) {
+    fs14.rmSync(backupPath, { recursive: true, force: true });
   }
-  fs13.renameSync(installed, backupPath);
+  fs14.renameSync(installed, backupPath);
 }
 function removeItem(item, claudeDir) {
   const installed = getInstalledPath(item, claudeDir);
-  if (fs13.existsSync(installed)) {
-    fs13.rmSync(installed, { recursive: true, force: true });
+  if (fs14.existsSync(installed)) {
+    fs14.rmSync(installed, { recursive: true, force: true });
   }
 }
 function getSourcePath(item, root) {
   switch (item.type) {
     case "skill":
-      return path16.join(root, "skills", item.name);
+      return path17.join(root, "skills", item.name);
     case "rule": {
-      const direct = path16.join(root, "rules", item.name);
-      if (fs13.existsSync(direct)) return direct;
-      return path16.join(root, "rules", "gamedev", item.name);
+      const direct = path17.join(root, "rules", item.name);
+      if (fs14.existsSync(direct)) return direct;
+      return path17.join(root, "rules", "gamedev", item.name);
     }
     case "agent":
-      return path16.join(root, "agents", item.name);
+      return path17.join(root, "agents", item.name);
     case "hook":
-      return path16.join(root, "hooks", item.name);
+      return path17.join(root, "hooks", item.name);
     default:
       return null;
   }
@@ -2572,13 +2622,13 @@ function getSourcePath(item, root) {
 function getInstalledPath(item, claudeDir) {
   switch (item.type) {
     case "skill":
-      return path16.join(claudeDir, "skills", item.name);
+      return path17.join(claudeDir, "skills", item.name);
     case "rule":
-      return path16.join(claudeDir, "rules", item.name);
+      return path17.join(claudeDir, "rules", item.name);
     case "agent":
-      return path16.join(claudeDir, "agents", item.name);
+      return path17.join(claudeDir, "agents", item.name);
     case "hook":
-      return path16.join(claudeDir, "hooks", item.name);
+      return path17.join(claudeDir, "hooks", item.name);
   }
 }
 
@@ -2613,8 +2663,8 @@ async function cleanCommand(opts) {
 }
 
 // src/commands/worktree.ts
-import fs14 from "fs";
-import path17 from "path";
+import fs15 from "fs";
+import path18 from "path";
 import { execSync as execSync2 } from "child_process";
 import chalk9 from "chalk";
 async function worktreeCommand(branch, opts) {
@@ -2625,8 +2675,8 @@ async function worktreeCommand(branch, opts) {
     process.exit(1);
   }
   const repoRoot = wtInfo.isWorktree ? wtInfo.mainWorktreePath : cwd;
-  const worktreePath = opts.path ? path17.resolve(opts.path) : defaultWorktreePath(repoRoot, branch);
-  if (fs14.existsSync(worktreePath)) {
+  const worktreePath = opts.path ? path18.resolve(opts.path) : defaultWorktreePath(repoRoot, branch);
+  if (fs15.existsSync(worktreePath)) {
     console.error(
       chalk9.red(`Path already exists: ${worktreePath}`)
     );
@@ -2673,7 +2723,7 @@ async function worktreeCommand(branch, opts) {
   }
   console.log("  Installing Arcane...");
   const root = getPackageRoot();
-  const profilesDir = path17.join(root, "profiles");
+  const profilesDir = path18.join(root, "profiles");
   const profileNames = profileExpr.split("+").filter(Boolean);
   const merged = mergeProfiles(profilesDir, profileNames);
   const shareFrom = opts.share !== false ? cwd : void 0;
@@ -2709,13 +2759,13 @@ async function worktreeCommand(branch, opts) {
     }
   }
   if (opts.isolate) {
-    const isolateScript = path17.join(
+    const isolateScript = path18.join(
       worktreePath,
       ".claude",
       "skills",
       "worktree-isolation"
     );
-    if (fs14.existsSync(isolateScript)) {
+    if (fs15.existsSync(isolateScript)) {
       console.log("  Applying worktree isolation...");
       try {
         execSync2(
@@ -2750,13 +2800,13 @@ async function worktreeCommand(branch, opts) {
 }
 
 // src/commands/global.ts
-import fs15 from "fs";
-import path18 from "path";
+import fs16 from "fs";
+import path19 from "path";
 import os5 from "os";
 import chalk10 from "chalk";
-var CLAUDE_HOME = path18.join(os5.homedir(), ".claude");
-var SCRIPTS_DIR = path18.join(CLAUDE_HOME, "scripts", "worktree-isolation");
-var SETTINGS_PATH = path18.join(CLAUDE_HOME, "settings.json");
+var CLAUDE_HOME = path19.join(os5.homedir(), ".claude");
+var SCRIPTS_DIR = path19.join(CLAUDE_HOME, "scripts", "worktree-isolation");
+var SETTINGS_PATH = path19.join(CLAUDE_HOME, "settings.json");
 async function globalCommand(opts) {
   if (opts.status) {
     showStatus();
@@ -2770,8 +2820,8 @@ async function globalCommand(opts) {
 }
 function showStatus() {
   console.log(chalk10.bold("\n=== Arcane Global Status ===\n"));
-  const hasScripts = fs15.existsSync(
-    path18.join(SCRIPTS_DIR, "apply.py")
+  const hasScripts = fs16.existsSync(
+    path19.join(SCRIPTS_DIR, "apply.py")
   );
   console.log(
     `  Worktree scripts: ${hasScripts ? chalk10.green("installed") : chalk10.dim("not installed")}`
@@ -2789,32 +2839,32 @@ function showStatus() {
 function installGlobal() {
   console.log(chalk10.bold("\nInstalling Arcane global hooks...\n"));
   const root = getPackageRoot();
-  const scriptsSrc = path18.join(
+  const scriptsSrc = path19.join(
     root,
     "skills",
     "worktree-isolation",
     "scripts"
   );
-  if (!fs15.existsSync(scriptsSrc)) {
+  if (!fs16.existsSync(scriptsSrc)) {
     console.error(
       chalk10.red("  worktree-isolation scripts not found in package.")
     );
     process.exit(1);
   }
-  fs15.mkdirSync(SCRIPTS_DIR, { recursive: true });
+  fs16.mkdirSync(SCRIPTS_DIR, { recursive: true });
   for (const file of ["apply.py", "lib.py"]) {
-    const src = path18.join(scriptsSrc, file);
-    const dst = path18.join(SCRIPTS_DIR, file);
-    if (!fs15.existsSync(src)) {
+    const src = path19.join(scriptsSrc, file);
+    const dst = path19.join(SCRIPTS_DIR, file);
+    if (!fs16.existsSync(src)) {
       console.warn(chalk10.yellow(`  WARN: ${file} not found, skipping`));
       continue;
     }
-    if (fs15.existsSync(dst) && fs15.readFileSync(src).equals(fs15.readFileSync(dst))) {
+    if (fs16.existsSync(dst) && fs16.readFileSync(src).equals(fs16.readFileSync(dst))) {
       console.log(chalk10.dim(`  [skip] ${file} (already up-to-date)`));
     } else {
-      fs15.copyFileSync(src, dst);
+      fs16.copyFileSync(src, dst);
       if (process.platform !== "win32") {
-        fs15.chmodSync(dst, 493);
+        fs16.chmodSync(dst, 493);
       }
       console.log(chalk10.green(`  [ok] ${file} -> ${SCRIPTS_DIR}`));
     }
@@ -2838,8 +2888,8 @@ function installGlobal() {
 }
 function removeGlobal() {
   console.log(chalk10.bold("\nRemoving Arcane global hooks...\n"));
-  if (fs15.existsSync(SCRIPTS_DIR)) {
-    fs15.rmSync(SCRIPTS_DIR, { recursive: true, force: true });
+  if (fs16.existsSync(SCRIPTS_DIR)) {
+    fs16.rmSync(SCRIPTS_DIR, { recursive: true, force: true });
     console.log(chalk10.green("  [ok] Removed worktree-isolation scripts"));
   } else {
     console.log(chalk10.dim("  [skip] Scripts not found"));
@@ -2853,16 +2903,16 @@ function removeGlobal() {
   console.log(chalk10.bold.green("\n  Global hooks removed.\n"));
 }
 function readSettings() {
-  if (!fs15.existsSync(SETTINGS_PATH)) return {};
+  if (!fs16.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs15.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs16.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  fs15.mkdirSync(path18.dirname(SETTINGS_PATH), { recursive: true });
-  fs15.writeFileSync(
+  fs16.mkdirSync(path19.dirname(SETTINGS_PATH), { recursive: true });
+  fs16.writeFileSync(
     SETTINGS_PATH,
     JSON.stringify(settings, null, 2) + "\n",
     "utf-8"
@@ -2919,11 +2969,11 @@ function removeHookFromSettings() {
 }
 
 // src/update-check.ts
-import fs16 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path20 from "path";
 import os6 from "os";
 import chalk11 from "chalk";
-var CHECK_FILE = path19.join(os6.homedir(), ".arcane", "last-check.json");
+var CHECK_FILE = path20.join(os6.homedir(), ".arcane", "last-check.json");
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 var GITHUB_OWNER2 = "SebastianLuser";
 var GITHUB_REPO2 = "Claude-Code-Arcane";
@@ -3048,19 +3098,19 @@ async function getLatestNpmVersion() {
 }
 function readCachedCheck() {
   try {
-    if (!fs16.existsSync(CHECK_FILE)) return null;
-    return JSON.parse(fs16.readFileSync(CHECK_FILE, "utf-8"));
+    if (!fs17.existsSync(CHECK_FILE)) return null;
+    return JSON.parse(fs17.readFileSync(CHECK_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCachedCheck(result) {
   try {
-    const dir = path19.dirname(CHECK_FILE);
-    if (!fs16.existsSync(dir)) {
-      fs16.mkdirSync(dir, { recursive: true });
+    const dir = path20.dirname(CHECK_FILE);
+    if (!fs17.existsSync(dir)) {
+      fs17.mkdirSync(dir, { recursive: true });
     }
-    fs16.writeFileSync(CHECK_FILE, JSON.stringify(result, null, 2) + "\n");
+    fs17.writeFileSync(CHECK_FILE, JSON.stringify(result, null, 2) + "\n");
   } catch {
   }
 }