claude-code-arcane 2.4.0 → 2.5.0

package/dist/cli.js

@@ -4,8 +4,8 @@
 import { Command } from "commander";
 
 // src/commands/install.ts
-import path10 from "path";
-import chalk from "chalk";
+import path11 from "path";
+import chalk2 from "chalk";
 
 // src/profiles.ts
 import fs from "fs";
@@ -18,7 +18,7 @@ function parseProfile(filePath) {
   return {
     name: String(raw.name ?? path.basename(filePath, ".yaml")),
     description: String(raw.description ?? ""),
-    type: raw.type ?? "addon",
+    category: String(raw.category ?? "other"),
     skills: raw.skills ?? [],
     rules: {
       universal: rules.universal ?? [],
@@ -32,6 +32,29 @@ function parseProfile(filePath) {
     }
   };
 }
+var CATEGORY_ORDER = [
+  { id: "backend", label: "Backend" },
+  { id: "frontend", label: "Frontend & Design" },
+  { id: "mobile", label: "Mobile" },
+  { id: "gamedev", label: "Gamedev" },
+  { id: "platform", label: "Platform & Quality" },
+  { id: "management", label: "Project Management" },
+  { id: "business", label: "Business" },
+  { id: "personal", label: "Personal" },
+  { id: "utilities", label: "Utilities" }
+];
+function groupByCategory(profiles) {
+  const known = new Set(CATEGORY_ORDER.map((c) => c.id));
+  const groups = CATEGORY_ORDER.map((c) => ({
+    ...c,
+    profiles: profiles.filter((p2) => p2.category === c.id)
+  }));
+  const rest = profiles.filter((p2) => !known.has(p2.category));
+  if (rest.length > 0) {
+    groups.push({ id: "other", label: "Other", profiles: rest });
+  }
+  return groups.filter((g) => g.profiles.length > 0);
+}
 function listProfiles(profilesDir) {
   if (!fs.existsSync(profilesDir)) return [];
   return fs.readdirSync(profilesDir).filter((f) => f.endsWith(".yaml") && f !== "core.yaml").map((f) => parseProfile(path.join(profilesDir, f))).sort((a, b) => a.name.localeCompare(b.name));
@@ -105,77 +128,215 @@ function mergeProfiles(profilesDir, profileNames) {
   };
 }
 
+// src/detect.ts
+import fs2 from "fs";
+import path2 from "path";
+function hasFile(dir, rel) {
+  return fs2.existsSync(path2.join(dir, rel));
+}
+function topLevelMatch(dir, suffix) {
+  try {
+    return fs2.readdirSync(dir).find((f) => f.endsWith(suffix));
+  } catch {
+    return void 0;
+  }
+}
+function readPackageDeps(dir) {
+  try {
+    const raw = JSON.parse(
+      fs2.readFileSync(path2.join(dir, "package.json"), "utf-8")
+    );
+    return {
+      ...raw.dependencies ?? {},
+      ...raw.devDependencies ?? {}
+    };
+  } catch {
+    return {};
+  }
+}
+function detectStack(dir) {
+  const out = [];
+  const isUnity = hasFile(dir, "ProjectSettings/ProjectVersion.txt");
+  if (isUnity) {
+    out.push({ profile: "unity-dev", reason: "ProjectSettings/ProjectVersion.txt" });
+  }
+  const uproject = topLevelMatch(dir, ".uproject");
+  if (uproject) {
+    out.push({ profile: "unreal-dev", reason: uproject });
+  }
+  const isFlutter = hasFile(dir, "pubspec.yaml");
+  if (isFlutter) {
+    out.push({ profile: "flutter", reason: "pubspec.yaml" });
+  }
+  if (hasFile(dir, "go.mod")) {
+    out.push({ profile: "backend-go", reason: "go.mod" });
+  }
+  let isReactNative = false;
+  if (hasFile(dir, "package.json")) {
+    const deps = readPackageDeps(dir);
+    if (deps["@nestjs/core"]) {
+      out.push({ profile: "backend-nestjs", reason: "package.json: @nestjs/core" });
+    } else if (deps["next"]) {
+      out.push({ profile: "backend-nextjs", reason: "package.json: next" });
+    } else if (deps["react-native"] || deps["expo"]) {
+      isReactNative = true;
+      out.push({ profile: "mobile", reason: "package.json: react-native/expo" });
+    } else if (deps["react"] || deps["vue"] || deps["svelte"]) {
+      out.push({ profile: "frontend", reason: "package.json: react/vue/svelte" });
+    } else if (deps["fastify"] || deps["express"] || deps["koa"] || deps["hono"]) {
+      out.push({ profile: "backend-ts", reason: "package.json: server framework" });
+    } else if (deps["typescript"]) {
+      out.push({ profile: "backend-ts", reason: "package.json: typescript" });
+    }
+  }
+  if (!isUnity) {
+    const dotnet = topLevelMatch(dir, ".sln") ?? topLevelMatch(dir, ".csproj");
+    if (dotnet) {
+      out.push({ profile: "backend-dotnet", reason: dotnet });
+    }
+  }
+  if (!isFlutter && !isReactNative) {
+    if ((hasFile(dir, "settings.gradle") || hasFile(dir, "settings.gradle.kts")) && hasFile(dir, "app")) {
+      out.push({ profile: "android-native", reason: "settings.gradle + app/" });
+    }
+    const ios = topLevelMatch(dir, ".xcodeproj") ?? topLevelMatch(dir, ".xcworkspace") ?? (hasFile(dir, "Podfile") ? "Podfile" : void 0);
+    if (ios) {
+      out.push({ profile: "ios-native", reason: ios });
+    }
+  }
+  return out;
+}
+
+// src/wizard.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+async function runInstallWizard(profiles, detections) {
+  p.intro(chalk.cyan("claude-code-arcane install"));
+  const available = new Set(profiles.map((pr) => pr.name));
+  const suggested = detections.filter((d) => available.has(d.profile));
+  if (suggested.length > 0) {
+    p.note(
+      suggested.map((d) => `${chalk.green(d.profile)}  ${chalk.dim(`(${d.reason})`)}`).join("\n"),
+      "Detected stack \u2014 pre-selected below"
+    );
+  } else {
+    p.note(
+      "No stack detected in this directory.\nPick whatever fits your work \u2014 profiles combine freely.",
+      "No suggestions"
+    );
+  }
+  const options = {};
+  for (const group of groupByCategory(profiles)) {
+    options[group.label] = group.profiles.map((pr) => ({
+      value: pr.name,
+      label: pr.name,
+      hint: pr.description
+    }));
+  }
+  const selected = await p.groupMultiselect({
+    message: "Select profiles (space to toggle, enter to confirm)",
+    options,
+    initialValues: suggested.map((d) => d.profile),
+    required: false
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Install cancelled.");
+    return null;
+  }
+  const names = selected;
+  if (names.length === 0) {
+    p.outro(
+      chalk.dim(
+        "Nothing selected. Run again, or install directly: npx claude-code-arcane install backend-ts+testing"
+      )
+    );
+    return null;
+  }
+  const expr = names.join("+");
+  const ok = await p.confirm({
+    message: `Install ${chalk.cyan(expr)} (plus core, always included)?`
+  });
+  if (p.isCancel(ok) || !ok) {
+    p.cancel("Install cancelled.");
+    return null;
+  }
+  p.outro(
+    chalk.dim(`Next time, skip the menu: npx claude-code-arcane install ${expr}`)
+  );
+  return names;
+}
+
 // src/installer.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 
 // src/utils.ts
 import { fileURLToPath } from "url";
-import path2 from "path";
-import fs2 from "fs";
+import path3 from "path";
+import fs3 from "fs";
 function getPackageRoot() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path2.resolve(path2.dirname(thisFile), "..");
+  return path3.resolve(path3.dirname(thisFile), "..");
 }
 var COPY_SKIP = /* @__PURE__ */ new Set(["__pycache__", ".pytest_cache"]);
 function isBuildArtifact(name) {
   return COPY_SKIP.has(name) || name.endsWith(".pyc");
 }
 function copyDirSync(src, dest) {
-  fs2.mkdirSync(dest, { recursive: true });
-  for (const entry of fs2.readdirSync(src, { withFileTypes: true })) {
+  fs3.mkdirSync(dest, { recursive: true });
+  for (const entry of fs3.readdirSync(src, { withFileTypes: true })) {
     if (isBuildArtifact(entry.name)) continue;
-    const srcPath = path2.join(src, entry.name);
-    const destPath = path2.join(dest, entry.name);
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync(srcPath, destPath);
     } else {
-      fs2.copyFileSync(srcPath, destPath);
+      fs3.copyFileSync(srcPath, destPath);
     }
   }
 }
 function ensureDir(dir) {
-  fs2.mkdirSync(dir, { recursive: true });
+  fs3.mkdirSync(dir, { recursive: true });
 }
-function fileExists(p) {
-  return fs2.existsSync(p);
+function fileExists(p2) {
+  return fs3.existsSync(p2);
 }
-function readJsonSync(p) {
-  return JSON.parse(fs2.readFileSync(p, "utf-8"));
+function readJsonSync(p2) {
+  return JSON.parse(fs3.readFileSync(p2, "utf-8"));
 }
-function writeJsonSync(p, data) {
-  fs2.writeFileSync(p, JSON.stringify(data, null, 2) + "\n", "utf-8");
+function writeJsonSync(p2, data) {
+  fs3.writeFileSync(p2, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
-function isSymlinkOrJunction(p) {
+function isSymlinkOrJunction(p2) {
   try {
-    return fs2.lstatSync(p).isSymbolicLink();
+    return fs3.lstatSync(p2).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function getPackageVersion() {
-  const pkgPath = path2.join(getPackageRoot(), "package.json");
+  const pkgPath = path3.join(getPackageRoot(), "package.json");
   const pkg = readJsonSync(pkgPath);
   return pkg.version;
 }
-function safeRemove(p) {
-  if (isSymlinkOrJunction(p)) {
-    fs2.unlinkSync(p);
-  } else if (fs2.existsSync(p)) {
-    fs2.rmSync(p, { recursive: true, force: true });
+function safeRemove(p2) {
+  if (isSymlinkOrJunction(p2)) {
+    fs3.unlinkSync(p2);
+  } else if (fs3.existsSync(p2)) {
+    fs3.rmSync(p2, { recursive: true, force: true });
   }
 }
 
 // src/manifest.ts
-import path3 from "path";
+import path4 from "path";
 var MANIFEST_FILE = "arcane-manifest.json";
 function manifestPath(target) {
-  return path3.join(target, ".claude", MANIFEST_FILE);
+  return path4.join(target, ".claude", MANIFEST_FILE);
 }
 function readManifest(target) {
-  const p = manifestPath(target);
-  if (!fileExists(p)) return null;
-  return readJsonSync(p);
+  const p2 = manifestPath(target);
+  if (!fileExists(p2)) return null;
+  return readJsonSync(p2);
 }
 function writeManifest(target, merged, profileCommand, packageRoot, worktreeOrOpts) {
   let opts = {};
@@ -224,8 +385,8 @@ function updateManifestFields(target, updates) {
 
 // src/worktree.ts
 import { execSync } from "child_process";
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 function getWorktreeInfo(target) {
   try {
     execSync("git rev-parse --is-inside-work-tree", {
@@ -246,10 +407,10 @@ function getWorktreeInfo(target) {
     encoding: "utf-8",
     stdio: "pipe"
   }).trim();
-  const resolvedCommon = path4.resolve(target, gitCommonDir);
-  const resolvedGit = path4.resolve(target, gitDir);
+  const resolvedCommon = path5.resolve(target, gitCommonDir);
+  const resolvedGit = path5.resolve(target, gitDir);
   const isWorktree = resolvedCommon !== resolvedGit;
-  const mainWorktreePath = isWorktree ? path4.resolve(resolvedCommon, "..") : target;
+  const mainWorktreePath = isWorktree ? path5.resolve(resolvedCommon, "..") : target;
   let currentBranch = "HEAD";
   try {
     currentBranch = execSync("git branch --show-current", {
@@ -264,7 +425,7 @@ function getWorktreeInfo(target) {
     isWorktree,
     mainWorktreePath,
     currentBranch,
-    worktreeId: path4.basename(target),
+    worktreeId: path5.basename(target),
     allWorktrees
   };
 }
@@ -300,17 +461,17 @@ function parseWorktreeList(cwd) {
   }
 }
 function findMainArcaneInstall(mainPath) {
-  return fs3.existsSync(
-    path4.join(mainPath, ".claude", "arcane-manifest.json")
+  return fs4.existsSync(
+    path5.join(mainPath, ".claude", "arcane-manifest.json")
   );
 }
 function linkOrCopyDir(src, dest, mode) {
   if (mode === "symlink") {
     try {
-      const parentDir = path4.dirname(dest);
-      fs3.mkdirSync(parentDir, { recursive: true });
+      const parentDir = path5.dirname(dest);
+      fs4.mkdirSync(parentDir, { recursive: true });
       const type = process.platform === "win32" ? "junction" : "dir";
-      fs3.symlinkSync(src, dest, type);
+      fs4.symlinkSync(src, dest, type);
       return "linked";
     } catch {
     }
@@ -322,9 +483,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 = path4.basename(repoRoot);
+  const repoName = path5.basename(repoRoot);
   const sanitized = sanitizeBranchForPath(branch);
-  return path4.resolve(repoRoot, "..", `${repoName}-${sanitized}`);
+  return path5.resolve(repoRoot, "..", `${repoName}-${sanitized}`);
 }
 function createGitWorktree(repoRoot, worktreePath, branch, base) {
   const branchExists = checkBranchExists(repoRoot, branch);
@@ -366,20 +527,20 @@ function detectPackageManager(dir) {
     { lockfile: "package-lock.json", command: "npm install" }
   ];
   for (const m of managers) {
-    if (fs3.existsSync(path4.join(dir, m.lockfile))) return m;
+    if (fs4.existsSync(path5.join(dir, m.lockfile))) return m;
   }
-  if (fs3.existsSync(path4.join(dir, "package.json"))) {
+  if (fs4.existsSync(path5.join(dir, "package.json"))) {
     return { lockfile: "package.json", command: "npm install" };
   }
   return null;
 }
 
 // src/content-hash.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 import { createHash } from "crypto";
 function hashFile(filePath) {
-  const content = fs4.readFileSync(filePath);
+  const content = fs5.readFileSync(filePath);
   return createHash("sha256").update(content).digest("hex");
 }
 function hashDirectory(dirPath) {
@@ -388,10 +549,10 @@ function hashDirectory(dirPath) {
   return hashes;
 }
 function walkDir(base, current, hashes) {
-  for (const entry of fs4.readdirSync(current, { withFileTypes: true })) {
+  for (const entry of fs5.readdirSync(current, { withFileTypes: true })) {
     if (isBuildArtifact(entry.name)) continue;
-    const fullPath = path5.join(current, entry.name);
-    const relPath = path5.relative(base, fullPath).split(path5.sep).join("/");
+    const fullPath = path6.join(current, entry.name);
+    const relPath = path6.relative(base, fullPath).split(path6.sep).join("/");
     if (entry.isDirectory()) {
       walkDir(base, fullPath, hashes);
     } else {
@@ -406,39 +567,39 @@ function computeContentHashes(claudeDir) {
     agents: {},
     hooks: {}
   };
-  const skillsDir = path5.join(claudeDir, "skills");
-  if (fs4.existsSync(skillsDir)) {
-    for (const entry of fs4.readdirSync(skillsDir, { withFileTypes: true })) {
+  const skillsDir = path6.join(claudeDir, "skills");
+  if (fs5.existsSync(skillsDir)) {
+    for (const entry of fs5.readdirSync(skillsDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        const dirHash = hashDirectory(path5.join(skillsDir, entry.name));
+        const dirHash = hashDirectory(path6.join(skillsDir, entry.name));
         const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
         hashes.skills[entry.name] = combined;
       }
     }
   }
-  const rulesDir = path5.join(claudeDir, "rules");
-  if (fs4.existsSync(rulesDir)) {
-    for (const entry of fs4.readdirSync(rulesDir, { withFileTypes: true })) {
+  const rulesDir = path6.join(claudeDir, "rules");
+  if (fs5.existsSync(rulesDir)) {
+    for (const entry of fs5.readdirSync(rulesDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
-        hashes.rules[entry.name] = hashFile(path5.join(rulesDir, entry.name));
+        hashes.rules[entry.name] = hashFile(path6.join(rulesDir, entry.name));
       }
     }
   }
-  const agentsDir = path5.join(claudeDir, "agents");
-  if (fs4.existsSync(agentsDir)) {
-    for (const entry of fs4.readdirSync(agentsDir, { withFileTypes: true })) {
+  const agentsDir = path6.join(claudeDir, "agents");
+  if (fs5.existsSync(agentsDir)) {
+    for (const entry of fs5.readdirSync(agentsDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        const dirHash = hashDirectory(path5.join(agentsDir, entry.name));
+        const dirHash = hashDirectory(path6.join(agentsDir, entry.name));
         const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
         hashes.agents[entry.name] = combined;
       }
     }
   }
-  const hooksDir = path5.join(claudeDir, "hooks");
-  if (fs4.existsSync(hooksDir)) {
-    for (const entry of fs4.readdirSync(hooksDir, { withFileTypes: true })) {
+  const hooksDir = path6.join(claudeDir, "hooks");
+  if (fs5.existsSync(hooksDir)) {
+    for (const entry of fs5.readdirSync(hooksDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
-        hashes.hooks[entry.name] = hashFile(path5.join(hooksDir, entry.name));
+        hashes.hooks[entry.name] = hashFile(path6.join(hooksDir, entry.name));
       }
     }
   }
@@ -452,8 +613,8 @@ function computeSourceHashes(packageRoot, skills, rules, agents) {
     hooks: {}
   };
   for (const skill of skills) {
-    const skillDir = path5.join(packageRoot, "skills", skill);
-    if (fs4.existsSync(skillDir)) {
+    const skillDir = path6.join(packageRoot, "skills", skill);
+    if (fs5.existsSync(skillDir)) {
       const dirHash = hashDirectory(skillDir);
       const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
       hashes.skills[skill] = combined;
@@ -461,29 +622,29 @@ function computeSourceHashes(packageRoot, skills, rules, agents) {
   }
   for (const rule of rules) {
     const ruleName = rule.endsWith(".md") ? rule : `${rule}.md`;
-    const rulePath = path5.join(packageRoot, "rules", ruleName);
-    if (fs4.existsSync(rulePath)) {
+    const rulePath = path6.join(packageRoot, "rules", ruleName);
+    if (fs5.existsSync(rulePath)) {
       hashes.rules[ruleName] = hashFile(rulePath);
     } else {
-      const gamedevPath = path5.join(packageRoot, "rules", "gamedev", ruleName);
-      if (fs4.existsSync(gamedevPath)) {
+      const gamedevPath = path6.join(packageRoot, "rules", "gamedev", ruleName);
+      if (fs5.existsSync(gamedevPath)) {
         hashes.rules[ruleName] = hashFile(gamedevPath);
       }
     }
   }
   for (const agent of agents) {
-    const agentDir = path5.join(packageRoot, "agents", agent);
-    if (fs4.existsSync(agentDir)) {
+    const agentDir = path6.join(packageRoot, "agents", agent);
+    if (fs5.existsSync(agentDir)) {
       const dirHash = hashDirectory(agentDir);
       const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
       hashes.agents[agent] = combined;
     }
   }
-  const hooksDir = path5.join(packageRoot, "hooks");
-  if (fs4.existsSync(hooksDir)) {
-    for (const entry of fs4.readdirSync(hooksDir, { withFileTypes: true })) {
+  const hooksDir = path6.join(packageRoot, "hooks");
+  if (fs5.existsSync(hooksDir)) {
+    for (const entry of fs5.readdirSync(hooksDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
-        hashes.hooks[entry.name] = hashFile(path5.join(hooksDir, entry.name));
+        hashes.hooks[entry.name] = hashFile(path6.join(hooksDir, entry.name));
       }
     }
   }
@@ -652,7 +813,7 @@ var Installer = class {
   constructor(merged, opts) {
     this.root = opts.contentRoot ?? getPackageRoot();
     this.target = opts.target;
-    this.claudeDir = path6.join(opts.target, ".claude");
+    this.claudeDir = path7.join(opts.target, ".claude");
     this.merged = merged;
     this.dryRun = opts.dryRun;
     this.shareFrom = opts.shareFrom;
@@ -684,22 +845,22 @@ var Installer = class {
     return this.logs;
   }
   backup() {
-    if (!fs5.existsSync(this.claudeDir)) return;
-    const backup = path6.join(this.target, ".claude.bak");
+    if (!fs6.existsSync(this.claudeDir)) return;
+    const backup = path7.join(this.target, ".claude.bak");
     if (this.dryRun) {
       this.log("  [dry-run] Would backup .claude/ -> .claude.bak/");
       return;
     }
-    if (fs5.existsSync(backup)) {
-      fs5.rmSync(backup, { recursive: true, force: true });
+    if (fs6.existsSync(backup)) {
+      fs6.rmSync(backup, { recursive: true, force: true });
     }
-    fs5.renameSync(this.claudeDir, backup);
+    fs6.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(path6.join(this.claudeDir, d));
+      ensureDir(path7.join(this.claudeDir, d));
     }
   }
   get hasStatusline() {
@@ -707,7 +868,7 @@ var Installer = class {
   }
   copyHooks() {
     this.log("\nHooks:");
-    const hooksDir = path6.join(this.claudeDir, "hooks");
+    const hooksDir = path7.join(this.claudeDir, "hooks");
     if (this.dryRun) {
       if (this.shareFrom) {
         this.log("  [dry-run] hooks/ -> symlink from main worktree");
@@ -718,8 +879,8 @@ var Installer = class {
       return;
     }
     if (this.shareFrom) {
-      const sharedHooks = path6.join(this.shareFrom, ".claude", "hooks");
-      if (fs5.existsSync(sharedHooks)) {
+      const sharedHooks = path7.join(this.shareFrom, ".claude", "hooks");
+      if (fs6.existsSync(sharedHooks)) {
         const result = linkOrCopyDir(sharedHooks, hooksDir, "symlink");
         if (result === "linked") {
           this.sharedDirs.push("hooks");
@@ -731,17 +892,17 @@ var Installer = class {
         return;
       }
     }
-    const hooksSrc = path6.join(this.root, "hooks");
-    if (fs5.existsSync(hooksSrc)) {
+    const hooksSrc = path7.join(this.root, "hooks");
+    if (fs6.existsSync(hooksSrc)) {
       ensureDir(hooksDir);
-      for (const entry of fs5.readdirSync(hooksSrc, { withFileTypes: true })) {
+      for (const entry of fs6.readdirSync(hooksSrc, { withFileTypes: true })) {
         if (entry.name === "statusline.sh") continue;
-        const src = path6.join(hooksSrc, entry.name);
-        const dst = path6.join(hooksDir, entry.name);
+        const src = path7.join(hooksSrc, entry.name);
+        const dst = path7.join(hooksDir, entry.name);
         if (entry.isDirectory()) {
           copyDirSync(src, dst);
         } else {
-          fs5.copyFileSync(src, dst);
+          fs6.copyFileSync(src, dst);
         }
       }
       this.log("  [ok] hooks/");
@@ -750,24 +911,24 @@ var Installer = class {
   }
   copyStatusline() {
     if (!this.hasStatusline) return;
-    const statusline = path6.join(this.root, "hooks", "statusline.sh");
-    if (fs5.existsSync(statusline)) {
-      fs5.copyFileSync(
+    const statusline = path7.join(this.root, "hooks", "statusline.sh");
+    if (fs6.existsSync(statusline)) {
+      fs6.copyFileSync(
         statusline,
-        path6.join(this.claudeDir, "statusline.sh")
+        path7.join(this.claudeDir, "statusline.sh")
       );
-      this.log("  [ok] statusline.sh (+statusline addon)");
+      this.log("  [ok] statusline.sh (statusline profile)");
     }
   }
   copySkills() {
     this.log("\nSkills:");
     for (const skill of this.merged.skills) {
-      const src = path6.join(this.root, "skills", skill);
-      if (!fs5.existsSync(src)) {
+      const src = path7.join(this.root, "skills", skill);
+      if (!fs6.existsSync(src)) {
         this.log(`  WARN: Skill '${skill}' not found in skills/`);
         continue;
       }
-      const dst = path6.join(this.claudeDir, "skills", skill);
+      const dst = path7.join(this.claudeDir, "skills", skill);
       if (this.dryRun) {
         this.log(`  [dry-run] ${skill}`);
       } else {
@@ -777,9 +938,9 @@ var Installer = class {
     }
     const hasGamedev = this.merged.rules.gamedev.length > 0;
     if (hasGamedev) {
-      const tplSrc = path6.join(this.root, "templates", "gamedev");
-      if (fs5.existsSync(tplSrc)) {
-        const tplDst = path6.join(this.claudeDir, "skills", "_templates");
+      const tplSrc = path7.join(this.root, "templates", "gamedev");
+      if (fs6.existsSync(tplSrc)) {
+        const tplDst = path7.join(this.claudeDir, "skills", "_templates");
         if (this.dryRun) {
           this.log("  [dry-run] _templates/");
         } else {
@@ -792,33 +953,33 @@ var Installer = class {
   copyRules() {
     this.log("\nRules:");
     for (const rule of this.merged.rules.universal) {
-      const src = path6.join(this.root, "rules", `${rule}.md`);
-      if (!fs5.existsSync(src)) {
+      const src = path7.join(this.root, "rules", `${rule}.md`);
+      if (!fs6.existsSync(src)) {
         this.log(`  WARN: Rule '${rule}.md' not found`);
         continue;
       }
       if (this.dryRun) {
         this.log(`  [dry-run] ${rule}.md`);
       } else {
-        fs5.copyFileSync(
+        fs6.copyFileSync(
           src,
-          path6.join(this.claudeDir, "rules", `${rule}.md`)
+          path7.join(this.claudeDir, "rules", `${rule}.md`)
         );
         this.log(`  [ok] ${rule}.md`);
       }
     }
     for (const rule of this.merged.rules.gamedev) {
-      const src = path6.join(this.root, "rules", "gamedev", `${rule}.md`);
-      if (!fs5.existsSync(src)) {
+      const src = path7.join(this.root, "rules", "gamedev", `${rule}.md`);
+      if (!fs6.existsSync(src)) {
         this.log(`  WARN: Rule '${rule}.md' not found`);
         continue;
       }
       if (this.dryRun) {
         this.log(`  [dry-run] ${rule}.md`);
       } else {
-        fs5.copyFileSync(
+        fs6.copyFileSync(
           src,
-          path6.join(this.claudeDir, "rules", `${rule}.md`)
+          path7.join(this.claudeDir, "rules", `${rule}.md`)
         );
         this.log(`  [ok] ${rule}.md`);
       }
@@ -828,25 +989,25 @@ var Installer = class {
     if (this.merged.agents.length === 0) return;
     this.log("\nAgents:");
     for (const agentDir of this.merged.agents) {
-      const src = path6.join(this.root, "agents", agentDir);
-      if (!fs5.existsSync(src)) {
+      const src = path7.join(this.root, "agents", agentDir);
+      if (!fs6.existsSync(src)) {
         this.log(`  WARN: Agent dir '${agentDir}' not found`);
         continue;
       }
-      const dst = path6.join(this.claudeDir, "agents", agentDir);
+      const dst = path7.join(this.claudeDir, "agents", agentDir);
       if (this.dryRun) {
         this.log(`  [dry-run] agents/${agentDir}/`);
       } else {
         copyDirSync(src, dst);
-        const count = fs5.readdirSync(dst, { recursive: true }).filter((f) => String(f).endsWith(".md")).length;
+        const count = fs6.readdirSync(dst, { recursive: true }).filter((f) => String(f).endsWith(".md")).length;
         this.log(`  [ok] agents/${agentDir}/ (${count} agents)`);
       }
     }
   }
   copyDocs() {
-    const docsDir = path6.join(this.claudeDir, "docs");
-    const docsSrc = path6.join(this.root, "docs");
-    if (!fs5.existsSync(docsSrc)) return;
+    const docsDir = path7.join(this.claudeDir, "docs");
+    const docsSrc = path7.join(this.root, "docs");
+    if (!fs6.existsSync(docsSrc)) return;
     this.log("\nDocs:");
     if (this.dryRun) {
       if (this.shareFrom) {
@@ -857,8 +1018,8 @@ var Installer = class {
       return;
     }
     if (this.shareFrom) {
-      const sharedDocs = path6.join(this.shareFrom, ".claude", "docs");
-      if (fs5.existsSync(sharedDocs)) {
+      const sharedDocs = path7.join(this.shareFrom, ".claude", "docs");
+      if (fs6.existsSync(sharedDocs)) {
         const result = linkOrCopyDir(sharedDocs, docsDir, "symlink");
         if (result === "linked") {
           this.sharedDirs.push("docs");
@@ -889,8 +1050,8 @@ var Installer = class {
       );
       return;
     }
-    const settingsPath = path6.join(this.claudeDir, "settings.json");
-    fs5.writeFileSync(
+    const settingsPath = path7.join(this.claudeDir, "settings.json");
+    fs6.writeFileSync(
       settingsPath,
       JSON.stringify(settings, null, 2) + "\n",
       "utf-8"
@@ -899,65 +1060,65 @@ var Installer = class {
   }
 };
 function clean(target) {
-  const claudeDir = path6.join(target, ".claude");
-  const backup = path6.join(target, ".claude.bak");
-  if (!fs5.existsSync(claudeDir)) {
+  const claudeDir = path7.join(target, ".claude");
+  const backup = path7.join(target, ".claude.bak");
+  if (!fs6.existsSync(claudeDir)) {
     console.log(`No .claude/ found in ${target} \u2014 nothing to clean.`);
     return;
   }
-  const manifestFile = path6.join(claudeDir, "arcane-manifest.json");
-  if (fs5.existsSync(manifestFile)) {
-    const data = JSON.parse(fs5.readFileSync(manifestFile, "utf-8"));
+  const manifestFile = path7.join(claudeDir, "arcane-manifest.json");
+  if (fs6.existsSync(manifestFile)) {
+    const data = JSON.parse(fs6.readFileSync(manifestFile, "utf-8"));
     const profiles = (data.profiles ?? []).filter(
-      (p) => p !== "core"
+      (p2) => p2 !== "core"
     );
     console.log(`  Current profile: ${profiles.join(" + ")}`);
     console.log(`  Installed: ${data.installed_at ?? "unknown"}`);
     const shared = data.worktree?.shared_dirs ?? [];
     for (const dir of shared) {
-      const p = path6.join(claudeDir, dir);
-      if (isSymlinkOrJunction(p)) {
-        fs5.unlinkSync(p);
+      const p2 = path7.join(claudeDir, dir);
+      if (isSymlinkOrJunction(p2)) {
+        fs6.unlinkSync(p2);
         console.log(`  [ok] Unlinked shared ${dir}/`);
       }
     }
   }
   for (const sub of ["hooks", "docs", "skills", "agents", "rules"]) {
-    const p = path6.join(claudeDir, sub);
-    safeRemove(p);
+    const p2 = path7.join(claudeDir, sub);
+    safeRemove(p2);
   }
-  const remaining = fs5.readdirSync(claudeDir);
+  const remaining = fs6.readdirSync(claudeDir);
   for (const f of remaining) {
-    const p = path6.join(claudeDir, f);
-    safeRemove(p);
+    const p2 = path7.join(claudeDir, f);
+    safeRemove(p2);
   }
-  if (fs5.existsSync(claudeDir)) {
-    fs5.rmSync(claudeDir, { recursive: true, force: true });
+  if (fs6.existsSync(claudeDir)) {
+    fs6.rmSync(claudeDir, { recursive: true, force: true });
   }
-  if (fs5.existsSync(backup)) {
-    fs5.rmSync(backup, { recursive: true, force: true });
+  if (fs6.existsSync(backup)) {
+    fs6.rmSync(backup, { recursive: true, force: true });
   }
   console.log(`
   [ok] Removed .claude/ from ${target}`);
 }
 
 // src/content-source.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import os2 from "os";
 
 // src/cache.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 import os from "os";
-var ARCANE_DIR = path7.join(os.homedir(), ".arcane");
-var CACHE_DIR = path7.join(ARCANE_DIR, "cache");
+var ARCANE_DIR = path8.join(os.homedir(), ".arcane");
+var CACHE_DIR = path8.join(ARCANE_DIR, "cache");
 function getCachePath(version) {
-  return path7.join(CACHE_DIR, version);
+  return path8.join(CACHE_DIR, version);
 }
 function isCached(version) {
   const versionDir = getCachePath(version);
-  return fs6.existsSync(versionDir) && fs6.existsSync(path7.join(versionDir, ".cache-meta.json"));
+  return fs7.existsSync(versionDir) && fs7.existsSync(path8.join(versionDir, ".cache-meta.json"));
 }
 function getCachedContentRoot(version) {
   if (!isCached(version)) return null;
@@ -965,34 +1126,34 @@ function getCachedContentRoot(version) {
 }
 function storeInCache(version, contentDir) {
   const versionDir = getCachePath(version);
-  if (fs6.existsSync(versionDir)) {
-    fs6.rmSync(versionDir, { recursive: true, force: true });
+  if (fs7.existsSync(versionDir)) {
+    fs7.rmSync(versionDir, { recursive: true, force: true });
   }
-  fs6.mkdirSync(versionDir, { recursive: true });
+  fs7.mkdirSync(versionDir, { recursive: true });
   for (const dir of ["skills", "rules", "agents", "hooks", "profiles", "templates", "docs"]) {
-    const src = path7.join(contentDir, dir);
-    if (fs6.existsSync(src)) {
-      copyDirRecursive(src, path7.join(versionDir, dir));
+    const src = path8.join(contentDir, dir);
+    if (fs7.existsSync(src)) {
+      copyDirRecursive(src, path8.join(versionDir, dir));
     }
   }
   const meta = {
     version,
     cached_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs6.writeFileSync(
-    path7.join(versionDir, ".cache-meta.json"),
+  fs7.writeFileSync(
+    path8.join(versionDir, ".cache-meta.json"),
     JSON.stringify(meta, null, 2) + "\n"
   );
   return versionDir;
 }
 function pruneCache(keepCount = 3) {
-  if (!fs6.existsSync(CACHE_DIR)) return;
-  const entries = fs6.readdirSync(CACHE_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
-    const metaPath = path7.join(CACHE_DIR, e.name, ".cache-meta.json");
+  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");
     let cachedAt = 0;
-    if (fs6.existsSync(metaPath)) {
+    if (fs7.existsSync(metaPath)) {
       try {
-        const meta = JSON.parse(fs6.readFileSync(metaPath, "utf-8"));
+        const meta = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
         cachedAt = new Date(meta.cached_at).getTime();
       } catch {
         cachedAt = 0;
@@ -1001,18 +1162,18 @@ function pruneCache(keepCount = 3) {
     return { name: e.name, cachedAt };
   }).sort((a, b) => b.cachedAt - a.cachedAt);
   for (const entry of entries.slice(keepCount)) {
-    fs6.rmSync(path7.join(CACHE_DIR, entry.name), { recursive: true, force: true });
+    fs7.rmSync(path8.join(CACHE_DIR, entry.name), { recursive: true, force: true });
   }
 }
 function copyDirRecursive(src, dest) {
-  fs6.mkdirSync(dest, { recursive: true });
-  for (const entry of fs6.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path7.join(src, entry.name);
-    const destPath = path7.join(dest, entry.name);
+  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);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs6.copyFileSync(srcPath, destPath);
+      fs7.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -1028,7 +1189,7 @@ var BundledContentSource = class {
   }
   async isAvailable() {
     const root = getPackageRoot();
-    return fs7.existsSync(path8.join(root, "skills"));
+    return fs8.existsSync(path9.join(root, "skills"));
   }
   async getVersion() {
     return getPackageVersion();
@@ -1068,14 +1229,14 @@ var GitHubContentSource = class {
     if (isCached(version)) {
       return getCachedContentRoot(version);
     }
-    const tmpDir = fs7.mkdtempSync(path8.join(os2.tmpdir(), "arcane-github-"));
+    const tmpDir = fs8.mkdtempSync(path9.join(os2.tmpdir(), "arcane-github-"));
     try {
       await this.downloadAndExtract(tmpDir);
       const contentRoot = storeInCache(version, this.findExtractedRoot(tmpDir));
       pruneCache(3);
       return contentRoot;
     } finally {
-      fs7.rmSync(tmpDir, { recursive: true, force: true });
+      fs8.rmSync(tmpDir, { recursive: true, force: true });
     }
   }
   async isAvailable() {
@@ -1131,8 +1292,8 @@ var GitHubContentSource = class {
       throw new Error(`Failed to download tarball: ${response.status}`);
     }
     const tar = await import("tar");
-    const tarballPath = path8.join(destDir, "repo.tar.gz");
-    const fileStream = fs7.createWriteStream(tarballPath);
+    const tarballPath = path9.join(destDir, "repo.tar.gz");
+    const fileStream = fs8.createWriteStream(tarballPath);
     const reader = response.body.getReader();
     const writable = new WritableStream({
       write(chunk) {
@@ -1157,12 +1318,12 @@ var GitHubContentSource = class {
     });
   }
   findExtractedRoot(tmpDir) {
-    const entries = fs7.readdirSync(tmpDir, { withFileTypes: true });
+    const entries = fs8.readdirSync(tmpDir, { withFileTypes: true });
     const dirs = entries.filter(
       (e) => e.isDirectory() && e.name !== "." && e.name !== ".."
     );
     if (dirs.length === 1) {
-      return path8.join(tmpDir, dirs[0].name);
+      return path9.join(tmpDir, dirs[0].name);
     }
     return tmpDir;
   }
@@ -1217,14 +1378,14 @@ async function resolveContentSourceForVersion(version, opts = {}) {
   return source;
 }
 function findLatestCache() {
-  const cacheDir = path8.join(os2.homedir(), ".arcane", "cache");
-  if (!fs7.existsSync(cacheDir)) return null;
-  const entries = fs7.readdirSync(cacheDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
-    const metaPath = path8.join(cacheDir, e.name, ".cache-meta.json");
+  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");
     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;
@@ -1236,22 +1397,22 @@ function findLatestCache() {
 }
 
 // src/registry.ts
-import path9 from "path";
+import path10 from "path";
 import os3 from "os";
 var REGISTRY_VERSION = 1;
 function arcaneHome() {
-  return process.env.ARCANE_HOME ?? path9.join(os3.homedir(), ".arcane");
+  return process.env.ARCANE_HOME ?? path10.join(os3.homedir(), ".arcane");
 }
 function registryPath() {
-  return path9.join(arcaneHome(), "installations.json");
+  return path10.join(arcaneHome(), "installations.json");
 }
 function readRegistryFile() {
-  const p = registryPath();
-  if (!fileExists(p)) {
+  const p2 = registryPath();
+  if (!fileExists(p2)) {
     return { version: REGISTRY_VERSION, installations: [] };
   }
   try {
-    const data = readJsonSync(p);
+    const data = readJsonSync(p2);
     return {
       version: REGISTRY_VERSION,
       installations: Array.isArray(data.installations) ? data.installations : []
@@ -1268,7 +1429,7 @@ function writeRegistryFile(registry) {
   }
 }
 function registerInstallation(target) {
-  const abs = path9.resolve(target);
+  const abs = path10.resolve(target);
   const registry = readRegistryFile();
   if (registry.installations.some((e) => e.path === abs)) {
     return;
@@ -1295,39 +1456,42 @@ async function installCommand(profileExpr, opts) {
     quiet: !profileExpr
   });
   const root = await source.getContentRoot();
-  const profilesDir = path10.join(root, "profiles");
-  const target = path10.resolve(opts.target ?? process.cwd());
+  const profilesDir = path11.join(root, "profiles");
+  const target = path11.resolve(opts.target ?? process.cwd());
   if (!profileExpr) {
     const profiles = listProfiles(profilesDir);
-    const bases = profiles.filter((p) => p.type === "base");
-    const addons = profiles.filter((p) => p.type === "addon");
-    console.log(chalk.bold("\nAvailable profiles:\n"));
-    console.log(chalk.cyan("  Base (pick one):"));
-    for (const p of bases) {
-      console.log(`    ${chalk.green(p.name.padEnd(20))} ${p.description}`);
-    }
-    console.log(chalk.cyan("\n  Addons (combine with +):"));
-    for (const p of addons) {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      const selected = await runInstallWizard(profiles, detectStack(target));
+      if (!selected) return;
+      profileExpr = selected.join("+");
+    } else {
+      console.log(chalk2.bold("\nAvailable profiles (combine freely with +):\n"));
+      for (const group of groupByCategory(profiles)) {
+        console.log(chalk2.cyan(`  ${group.label}:`));
+        for (const p2 of group.profiles) {
+          console.log(
+            `    ${chalk2.green(p2.name.padEnd(20))} ${p2.description}`
+          );
+        }
+        console.log();
+      }
       console.log(
-        `    ${chalk.green(("+" + p.name).padEnd(20))} ${p.description}`
+        chalk2.dim("  Usage: npx claude-code-arcane install backend-ts+agile+testing\n")
       );
+      return;
     }
-    console.log(
-      chalk.dim("\n  Usage: npx claude-code-arcane install backend-ts+agile+testing\n")
-    );
-    return;
   }
   const profileNames = profileExpr.split("+").filter(Boolean);
   console.log(
-    chalk.bold(`
-Installing profile: ${chalk.cyan(profileExpr)}`)
+    chalk2.bold(`
+Installing profile: ${chalk2.cyan(profileExpr)}`)
   );
   console.log(`  Target: ${target}`);
   const wtInfo = getWorktreeInfo(target);
   let shareFrom = opts.shareFrom;
   let worktreeMeta;
   if (wtInfo?.isWorktree) {
-    console.log(chalk.blue(`  Worktree: yes (main: ${wtInfo.mainWorktreePath})`));
+    console.log(chalk2.blue(`  Worktree: yes (main: ${wtInfo.mainWorktreePath})`));
     worktreeMeta = {
       is_worktree: true,
       main_worktree: wtInfo.mainWorktreePath
@@ -1335,13 +1499,13 @@ Installing profile: ${chalk.cyan(profileExpr)}`)
     if (!shareFrom && findMainArcaneInstall(wtInfo.mainWorktreePath)) {
       shareFrom = wtInfo.mainWorktreePath;
       console.log(
-        chalk.blue("  Sharing: hooks + docs from main worktree")
+        chalk2.blue("  Sharing: hooks + docs from main worktree")
       );
     }
   } else if (wtInfo) {
     worktreeMeta = { is_worktree: false, main_worktree: target };
   }
-  if (opts.dryRun) console.log(chalk.yellow("  Mode: dry-run\n"));
+  if (opts.dryRun) console.log(chalk2.yellow("  Mode: dry-run\n"));
   const merged = mergeProfiles(profilesDir, profileNames);
   console.log(`  Profiles loaded: ${merged.loaded.join(", ")}`);
   console.log(`  Skills: ${merged.skills.length}`);
@@ -1359,14 +1523,14 @@ Installing profile: ${chalk.cyan(profileExpr)}`)
   installer.run(profileExpr, worktreeMeta);
   if (!opts.dryRun) {
     registerInstallation(target);
-    console.log(chalk.green("\n  Installation complete."));
+    console.log(chalk2.green("\n  Installation complete."));
   }
 }
 
 // src/commands/add.ts
-import fs8 from "fs";
-import path11 from "path";
-import chalk2 from "chalk";
+import fs9 from "fs";
+import path12 from "path";
+import chalk3 from "chalk";
 async function addCommand(items) {
   const target = process.cwd();
   const source = await resolveContentSource({ quiet: true });
@@ -1374,13 +1538,13 @@ async function addCommand(items) {
   const manifest = readManifest(target);
   if (!manifest) {
     console.error(
-      chalk2.red(
+      chalk3.red(
         "No arcane-manifest.json found. Run `npx claude-code-arcane install` first."
       )
     );
     process.exit(1);
   }
-  const claudeDir = path11.join(target, ".claude");
+  const claudeDir = path12.join(target, ".claude");
   const added = [];
   const skipped = [];
   const notFound = [];
@@ -1390,9 +1554,9 @@ async function addCommand(items) {
   for (const item of items) {
     if (item.startsWith("+")) {
       const profileName = item.slice(1);
-      const profilePath = path11.join(root, "profiles", `${profileName}.yaml`);
-      if (!fs8.existsSync(profilePath)) {
-        console.error(chalk2.red(`  Profile '${profileName}' not found`));
+      const profilePath = path12.join(root, "profiles", `${profileName}.yaml`);
+      if (!fs9.existsSync(profilePath)) {
+        console.error(chalk3.red(`  Profile '${profileName}' not found`));
         continue;
       }
       const profile = parseProfile(profilePath);
@@ -1404,10 +1568,10 @@ async function addCommand(items) {
       }
       for (const rule of profile.rules.universal) {
         if (!manifest.installed_rules.includes(rule)) {
-          const src = path11.join(root, "rules", `${rule}.md`);
-          if (fs8.existsSync(src)) {
-            ensureDir(path11.join(claudeDir, "rules"));
-            fs8.copyFileSync(src, path11.join(claudeDir, "rules", `${rule}.md`));
+          const src = path12.join(root, "rules", `${rule}.md`);
+          if (fs9.existsSync(src)) {
+            ensureDir(path12.join(claudeDir, "rules"));
+            fs9.copyFileSync(src, path12.join(claudeDir, "rules", `${rule}.md`));
             manifest.installed_rules.push(rule);
             addedRules.push(rule);
           }
@@ -1415,10 +1579,10 @@ async function addCommand(items) {
       }
       for (const rule of profile.rules.gamedev) {
         if (!manifest.installed_rules.includes(rule)) {
-          const src = path11.join(root, "rules", "gamedev", `${rule}.md`);
-          if (fs8.existsSync(src)) {
-            ensureDir(path11.join(claudeDir, "rules"));
-            fs8.copyFileSync(src, path11.join(claudeDir, "rules", `${rule}.md`));
+          const src = path12.join(root, "rules", "gamedev", `${rule}.md`);
+          if (fs9.existsSync(src)) {
+            ensureDir(path12.join(claudeDir, "rules"));
+            fs9.copyFileSync(src, path12.join(claudeDir, "rules", `${rule}.md`));
             manifest.installed_rules.push(rule);
             addedRules.push(rule);
           }
@@ -1426,9 +1590,9 @@ async function addCommand(items) {
       }
       for (const agentDir of profile.agents) {
         if (!manifest.installed_agents.includes(agentDir)) {
-          const src = path11.join(root, "agents", agentDir);
-          if (fs8.existsSync(src)) {
-            const dst = path11.join(claudeDir, "agents", agentDir);
+          const src = path12.join(root, "agents", agentDir);
+          if (fs9.existsSync(src)) {
+            const dst = path12.join(claudeDir, "agents", agentDir);
             copyDirSync(src, dst);
             manifest.installed_agents.push(agentDir);
             addedAgents.push(agentDir);
@@ -1436,9 +1600,9 @@ async function addCommand(items) {
         }
       }
       if (profileName === "statusline") {
-        const statuslineSrc = path11.join(root, "hooks", "statusline.sh");
-        if (fs8.existsSync(statuslineSrc)) {
-          fs8.copyFileSync(statuslineSrc, path11.join(claudeDir, "statusline.sh"));
+        const statuslineSrc = path12.join(root, "hooks", "statusline.sh");
+        if (fs9.existsSync(statuslineSrc)) {
+          fs9.copyFileSync(statuslineSrc, path12.join(claudeDir, "statusline.sh"));
           statuslineAdded = true;
         }
       }
@@ -1447,7 +1611,7 @@ async function addCommand(items) {
       }
       if (!manifest.profiles.includes(profileName)) {
         manifest.profiles.push(profileName);
-        manifest.profile_command = manifest.profiles.filter((p) => p !== "core").join("+");
+        manifest.profile_command = manifest.profiles.filter((p2) => p2 !== "core").join("+");
       }
       if (statuslineAdded) {
         addStatuslineToSettings(claudeDir);
@@ -1472,28 +1636,28 @@ async function addCommand(items) {
   };
   writeManifest(target, merged, manifest.profile_command, root);
   const totalAdded = added.length + addedRules.length + addedAgents.length + (statuslineAdded ? 1 : 0);
-  console.log(chalk2.bold(`
+  console.log(chalk3.bold(`
 Added ${totalAdded} items:`));
-  for (const s of added) console.log(chalk2.green(`  [ok] skill: ${s}`));
-  for (const r of addedRules) console.log(chalk2.green(`  [ok] rule: ${r}`));
-  for (const a of addedAgents) console.log(chalk2.green(`  [ok] agents: ${a}/`));
-  if (statuslineAdded) console.log(chalk2.green("  [ok] statusline.sh"));
+  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}/`));
+  if (statuslineAdded) console.log(chalk3.green("  [ok] statusline.sh"));
   for (const s of skipped)
-    console.log(chalk2.dim(`  [skip] ${s} (already installed)`));
+    console.log(chalk3.dim(`  [skip] ${s} (already installed)`));
   for (const s of notFound)
-    console.log(chalk2.red(`  [miss] ${s} (not found in source)`));
+    console.log(chalk3.red(`  [miss] ${s} (not found in source)`));
 }
 function addSkill(root, target, skill, installed) {
   if (installed.includes(skill)) return "skipped";
-  const src = path11.join(root, "skills", skill);
-  if (!fs8.existsSync(src)) return "not-found";
-  const dst = path11.join(target, ".claude", "skills", skill);
+  const src = path12.join(root, "skills", skill);
+  if (!fs9.existsSync(src)) return "not-found";
+  const dst = path12.join(target, ".claude", "skills", skill);
   copyDirSync(src, dst);
   return "added";
 }
 function mergePermissions(claudeDir, newPerms) {
-  const settingsPath = path11.join(claudeDir, "settings.json");
-  if (!fs8.existsSync(settingsPath)) return;
+  const settingsPath = path12.join(claudeDir, "settings.json");
+  if (!fs9.existsSync(settingsPath)) return;
   const settings = readJsonSync(settingsPath);
   const perms = settings.permissions ?? { allow: [], deny: [] };
   const allowSet = new Set(perms.allow);
@@ -1506,8 +1670,8 @@ function mergePermissions(claudeDir, newPerms) {
   writeJsonSync(settingsPath, settings);
 }
 function addStatuslineToSettings(claudeDir) {
-  const settingsPath = path11.join(claudeDir, "settings.json");
-  if (!fs8.existsSync(settingsPath)) return;
+  const settingsPath = path12.join(claudeDir, "settings.json");
+  if (!fs9.existsSync(settingsPath)) return;
   const settings = readJsonSync(settingsPath);
   if (settings.statusLine) return;
   settings.statusLine = {
@@ -1518,9 +1682,9 @@ function addStatuslineToSettings(claudeDir) {
 }
 
 // src/commands/remove.ts
-import fs9 from "fs";
-import path12 from "path";
-import chalk3 from "chalk";
+import fs10 from "fs";
+import path13 from "path";
+import chalk4 from "chalk";
 var CORE_SKILLS = [
   "commit",
   "create-pr",
@@ -1549,7 +1713,7 @@ async function removeCommand(items, opts = {}) {
   const manifest = readManifest(target);
   if (!manifest) {
     console.error(
-      chalk3.red(
+      chalk4.red(
         "No arcane-manifest.json found. Run `npx claude-code-arcane install` first."
       )
     );
@@ -1584,30 +1748,30 @@ async function removeCommand(items, opts = {}) {
   }
   manifest.total_skills = manifest.installed_skills.length;
   manifest.total_rules = manifest.installed_rules.length;
-  const mp = path12.join(target, ".claude", "arcane-manifest.json");
+  const mp = path13.join(target, ".claude", "arcane-manifest.json");
   writeJsonSync(mp, manifest);
   const totalRemoved = removedSkills.length + removedAgents.length + removedProfiles.length;
-  console.log(chalk3.bold(`
+  console.log(chalk4.bold(`
 Removed ${totalRemoved} items:`));
-  for (const p of removedProfiles)
-    console.log(chalk3.magenta(`  [ok] +${p} (profile)`));
+  for (const p2 of removedProfiles)
+    console.log(chalk4.magenta(`  [ok] +${p2} (profile)`));
   for (const s of removedSkills)
-    console.log(chalk3.green(`  [ok] ${s} (skill)`));
+    console.log(chalk4.green(`  [ok] ${s} (skill)`));
   for (const a of removedAgents)
-    console.log(chalk3.cyan(`  [ok] ${a} (agent dir)`));
+    console.log(chalk4.cyan(`  [ok] ${a} (agent dir)`));
   for (const s of skipped)
-    console.log(chalk3.dim(`  [skip] ${s}`));
+    console.log(chalk4.dim(`  [skip] ${s}`));
 }
 function removeSkill(target, skill, manifest) {
   if (CORE_SKILLS.includes(skill)) {
     console.warn(
-      chalk3.yellow(`  WARNING: '${skill}' is a core skill. Skipping.`)
+      chalk4.yellow(`  WARNING: '${skill}' is a core skill. Skipping.`)
     );
     return "skipped";
   }
-  const skillDir = path12.join(target, ".claude", "skills", skill);
-  if (!fs9.existsSync(skillDir)) return "skipped";
-  fs9.rmSync(skillDir, { recursive: true, force: true });
+  const skillDir = path13.join(target, ".claude", "skills", skill);
+  if (!fs10.existsSync(skillDir)) return "skipped";
+  fs10.rmSync(skillDir, { recursive: true, force: true });
   manifest.installed_skills = manifest.installed_skills.filter(
     (s) => s !== skill
   );
@@ -1616,33 +1780,33 @@ function removeSkill(target, skill, manifest) {
 function removeProfile(root, target, profileName, manifest) {
   if (profileName === "core") {
     console.warn(
-      chalk3.yellow("  WARNING: Cannot remove core profile. Skipping.")
+      chalk4.yellow("  WARNING: Cannot remove core profile. Skipping.")
     );
     return { removed: false, skills: [], agents: [] };
   }
   if (!manifest.profiles.includes(profileName)) {
     console.warn(
-      chalk3.yellow(`  WARNING: Profile '${profileName}' is not installed.`)
+      chalk4.yellow(`  WARNING: Profile '${profileName}' is not installed.`)
     );
     return { removed: false, skills: [], agents: [] };
   }
-  const profilePath = path12.join(root, "profiles", `${profileName}.yaml`);
-  if (!fs9.existsSync(profilePath)) {
+  const profilePath = path13.join(root, "profiles", `${profileName}.yaml`);
+  if (!fs10.existsSync(profilePath)) {
     console.warn(
-      chalk3.yellow(`  WARNING: Profile '${profileName}.yaml' not found.`)
+      chalk4.yellow(`  WARNING: Profile '${profileName}.yaml' not found.`)
     );
     return { removed: false, skills: [], agents: [] };
   }
   const profile = parseProfile(profilePath);
   const remainingProfiles = manifest.profiles.filter(
-    (p) => p !== profileName
+    (p2) => p2 !== profileName
   );
   const sharedSkills = /* @__PURE__ */ new Set();
   const sharedAgents = /* @__PURE__ */ new Set();
   const sharedRules = /* @__PURE__ */ new Set();
   for (const rp of remainingProfiles) {
-    const rpPath = path12.join(root, "profiles", `${rp}.yaml`);
-    if (!fs9.existsSync(rpPath)) continue;
+    const rpPath = path13.join(root, "profiles", `${rp}.yaml`);
+    if (!fs10.existsSync(rpPath)) continue;
     const rpDef = parseProfile(rpPath);
     rpDef.skills.forEach((s) => sharedSkills.add(s));
     rpDef.agents.forEach((a) => sharedAgents.add(a));
@@ -1653,9 +1817,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 = path12.join(target, ".claude", "skills", skill);
-    if (fs9.existsSync(skillDir)) {
-      fs9.rmSync(skillDir, { recursive: true, force: true });
+    const skillDir = path13.join(target, ".claude", "skills", skill);
+    if (fs10.existsSync(skillDir)) {
+      fs10.rmSync(skillDir, { recursive: true, force: true });
       removedSkills.push(skill);
     }
     manifest.installed_skills = manifest.installed_skills.filter(
@@ -1665,9 +1829,9 @@ function removeProfile(root, target, profileName, manifest) {
   const removedAgents = [];
   for (const agent of profile.agents) {
     if (sharedAgents.has(agent)) continue;
-    const agentDir = path12.join(target, ".claude", "agents", agent);
-    if (fs9.existsSync(agentDir)) {
-      fs9.rmSync(agentDir, { recursive: true, force: true });
+    const agentDir = path13.join(target, ".claude", "agents", agent);
+    if (fs10.existsSync(agentDir)) {
+      fs10.rmSync(agentDir, { recursive: true, force: true });
       removedAgents.push(agent);
     }
     manifest.installed_agents = manifest.installed_agents.filter(
@@ -1679,138 +1843,133 @@ function removeProfile(root, target, profileName, manifest) {
     ...profile.rules.gamedev
   ]) {
     if (sharedRules.has(rule)) continue;
-    const ruleFile = path12.join(target, ".claude", "rules", `${rule}.md`);
-    if (fs9.existsSync(ruleFile)) {
-      fs9.rmSync(ruleFile);
+    const ruleFile = path13.join(target, ".claude", "rules", `${rule}.md`);
+    if (fs10.existsSync(ruleFile)) {
+      fs10.rmSync(ruleFile);
     }
     manifest.installed_rules = manifest.installed_rules.filter(
       (r) => r !== rule
     );
   }
   if (profileName === "statusline") {
-    const statuslineFile = path12.join(target, ".claude", "statusline.sh");
-    if (fs9.existsSync(statuslineFile)) {
-      fs9.rmSync(statuslineFile);
+    const statuslineFile = path13.join(target, ".claude", "statusline.sh");
+    if (fs10.existsSync(statuslineFile)) {
+      fs10.rmSync(statuslineFile);
     }
-    removeStatuslineFromSettings(path12.join(target, ".claude"));
+    removeStatuslineFromSettings(path13.join(target, ".claude"));
   }
   manifest.profiles = remainingProfiles;
-  manifest.profile_command = remainingProfiles.filter((p) => p !== "core").join("+");
+  manifest.profile_command = remainingProfiles.filter((p2) => p2 !== "core").join("+");
   return { removed: true, skills: removedSkills, agents: removedAgents };
 }
 function removeStatuslineFromSettings(claudeDir) {
-  const settingsPath = path12.join(claudeDir, "settings.json");
-  if (!fs9.existsSync(settingsPath)) return;
-  const settings = JSON.parse(fs9.readFileSync(settingsPath, "utf-8"));
+  const settingsPath = path13.join(claudeDir, "settings.json");
+  if (!fs10.existsSync(settingsPath)) return;
+  const settings = JSON.parse(fs10.readFileSync(settingsPath, "utf-8"));
   if (settings.statusLine) {
     delete settings.statusLine;
-    fs9.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    fs10.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   }
 }
 
 // src/commands/list.ts
-import fs10 from "fs";
-import path13 from "path";
-import chalk4 from "chalk";
+import fs11 from "fs";
+import path14 from "path";
+import chalk5 from "chalk";
 async function listCommand() {
   const source = await resolveContentSource({ quiet: true });
   const root = await source.getContentRoot();
-  const profilesDir = path13.join(root, "profiles");
-  const skillsDir = path13.join(root, "skills");
+  const profilesDir = path14.join(root, "profiles");
+  const skillsDir = path14.join(root, "skills");
   const target = process.cwd();
   const manifest = readManifest(target);
   const profiles = listProfiles(profilesDir);
-  const bases = profiles.filter((p) => p.type === "base");
-  const addons = profiles.filter((p) => p.type === "addon");
   const installedSkills = new Set(manifest?.installed_skills ?? []);
-  console.log(chalk4.bold("\n=== Available Profiles ===\n"));
-  console.log(chalk4.cyan("Base:"));
-  for (const p of bases) {
-    const tag = manifest?.profiles.includes(p.name) ? chalk4.green(" [installed]") : "";
-    console.log(
-      `  ${chalk4.green(p.name.padEnd(20))} ${p.description}${tag}`
-    );
-  }
-  console.log(chalk4.cyan("\nAddons:"));
-  for (const p of addons) {
-    const tag = manifest?.profiles.includes(p.name) ? chalk4.green(" [installed]") : "";
-    console.log(
-      `  ${chalk4.green(("+" + p.name).padEnd(20))} ${p.description}${tag}`
-    );
+  console.log(chalk5.bold("\n=== Available Profiles ===\n"));
+  console.log(chalk5.dim("Profiles combine freely: install a+b+c\n"));
+  for (const group of groupByCategory(profiles)) {
+    console.log(chalk5.cyan(`${group.label}:`));
+    for (const p2 of group.profiles) {
+      const tag = manifest?.profiles.includes(p2.name) ? chalk5.green(" [installed]") : "";
+      console.log(
+        `  ${chalk5.green(p2.name.padEnd(20))} ${p2.description}${tag}`
+      );
+    }
+    console.log();
   }
-  if (fs10.existsSync(skillsDir)) {
-    const allSkills = fs10.readdirSync(skillsDir, { withFileTypes: true }).filter(
-      (d) => d.isDirectory() && !d.name.startsWith("_") && fs10.existsSync(path13.join(skillsDir, d.name, "SKILL.md"))
+  if (fs11.existsSync(skillsDir)) {
+    const allSkills = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter(
+      (d) => d.isDirectory() && !d.name.startsWith("_") && fs11.existsSync(path14.join(skillsDir, d.name, "SKILL.md"))
     ).map((d) => d.name).sort();
-    console.log(chalk4.bold(`
+    console.log(chalk5.bold(`
 === Skills (${allSkills.length}) ===
 `));
     const cols = 3;
     for (let i = 0; i < allSkills.length; i += cols) {
       const row = allSkills.slice(i, i + cols).map((s) => {
-        const tag = installedSkills.has(s) ? chalk4.green("*") : " ";
+        const tag = installedSkills.has(s) ? chalk5.green("*") : " ";
         return `${tag} ${s.padEnd(30)}`;
       });
       console.log("  " + row.join(""));
     }
     if (manifest) {
-      console.log(chalk4.dim("\n  * = installed in current project"));
+      console.log(chalk5.dim("\n  * = installed in current project"));
     }
   }
 }
 
 // src/commands/status.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 async function statusCommand() {
   const target = process.cwd();
   const manifest = readManifest(target);
   if (!manifest) {
     console.log(
-      chalk5.yellow("No Arcane installation found in this project.")
+      chalk6.yellow("No Arcane installation found in this project.")
     );
-    console.log(chalk5.dim("Run `npx claude-code-arcane install <profile>` to install."));
+    console.log(chalk6.dim("Run `npx claude-code-arcane install <profile>` to install."));
     return;
   }
-  const profiles = manifest.profiles.filter((p) => p !== "core");
-  console.log(chalk5.bold("\n=== Arcane Status ===\n"));
-  console.log(`  Profiles:  ${chalk5.cyan(profiles.join(" + "))}`);
+  const profiles = manifest.profiles.filter((p2) => p2 !== "core");
+  console.log(chalk6.bold("\n=== Arcane Status ===\n"));
+  console.log(`  Profiles:  ${chalk6.cyan(profiles.join(" + "))}`);
   console.log(`  Installed: ${manifest.installed_at}`);
   console.log(`  Version:   ${manifest.arcane_version}`);
   console.log(`  CLI:       ${manifest.cli}`);
-  console.log(`  Source:    ${chalk5.dim(manifest.source)}`);
+  console.log(`  Source:    ${chalk6.dim(manifest.source)}`);
   if (manifest.worktree) {
     const wt = manifest.worktree;
     console.log(
-      `  Worktree:  ${wt.is_worktree ? chalk5.blue("yes") : "no"} (main: ${chalk5.dim(wt.main_worktree)})`
+      `  Worktree:  ${wt.is_worktree ? chalk6.blue("yes") : "no"} (main: ${chalk6.dim(wt.main_worktree)})`
     );
     if (wt.shared_dirs.length > 0) {
       console.log(
-        `  Shared:    ${chalk5.blue(wt.shared_dirs.join(", "))} (symlinked)`
+        `  Shared:    ${chalk6.blue(wt.shared_dirs.join(", "))} (symlinked)`
       );
     }
   }
-  console.log(chalk5.bold(`
+  console.log(chalk6.bold(`
   Skills (${manifest.total_skills}):`));
   const skills = manifest.installed_skills ?? [];
   for (let i = 0; i < skills.length; i += 5) {
     const row = skills.slice(i, i + 5).map((s) => s.padEnd(25)).join("");
     console.log(`    ${row}`);
   }
-  console.log(chalk5.bold(`
+  console.log(chalk6.bold(`
   Rules (${manifest.total_rules}):`));
   const rules = manifest.installed_rules ?? [];
   console.log(`    ${rules.join(", ")}`);
-  console.log(chalk5.bold("\n  Agents:"));
+  console.log(chalk6.bold("\n  Agents:"));
   const agents = manifest.installed_agents ?? [];
   console.log(`    ${agents.join(", ")}`);
   console.log();
 }
 
 // src/commands/update.ts
-import fs11 from "fs";
-import path14 from "path";
+import fs12 from "fs";
+import path15 from "path";
 import os4 from "os";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/self-update.ts
 import { spawnSync } from "child_process";
@@ -1872,45 +2031,45 @@ async function updateCommand(opts) {
   });
   if (!opts.quiet) {
     if (self.updated) {
-      console.log(chalk6.green("npm package updated to latest."));
+      console.log(chalk7.green("npm package updated to latest."));
     } else if (self.skipped && self.reason !== "dev/test environment") {
-      console.log(chalk6.dim(`npm self-update skipped (${self.reason}).`));
+      console.log(chalk7.dim(`npm self-update skipped (${self.reason}).`));
     } else if (!self.skipped) {
-      console.log(chalk6.yellow(`npm self-update failed: ${self.reason}`));
+      console.log(chalk7.yellow(`npm self-update failed: ${self.reason}`));
     }
   }
   const cwd = process.cwd();
-  if (fs11.existsSync(manifestPath(cwd))) {
+  if (fs12.existsSync(manifestPath(cwd))) {
     registerInstallation(cwd);
   }
   const targets = pruneRegistry().map((e) => e.path);
   const globalTarget = os4.homedir();
-  if (!process.env.VITEST && fs11.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
+  if (!process.env.VITEST && fs12.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
     targets.push(globalTarget);
   }
   if (targets.length === 0) {
     if (!opts.quiet) {
-      console.log(chalk6.red("\nNo Arcane installations found. Run 'arcane install' first."));
+      console.log(chalk7.red("\nNo Arcane installations found. Run 'arcane install' first."));
     }
     return;
   }
   if (!opts.quiet) {
     console.log(
-      chalk6.bold(`
+      chalk7.bold(`
 Updating ${targets.length} installation${targets.length === 1 ? "" : "s"}...`)
     );
   }
   const results = [];
   for (const target of targets) {
     if (!opts.quiet) {
-      console.log(chalk6.bold.cyan(`
+      console.log(chalk7.bold.cyan(`
 \u2022 ${target}`));
     }
     try {
       results.push(await updateTarget(target, opts));
     } catch (err) {
       if (!opts.quiet) {
-        console.log(chalk6.red(`  Update failed: ${err.message}`));
+        console.log(chalk7.red(`  Update failed: ${err.message}`));
       }
       results.push({
         target,
@@ -1929,7 +2088,7 @@ async function updateTarget(target, opts) {
   const manifest = readManifest(target);
   if (!manifest) {
     if (!opts.quiet) {
-      console.log(chalk6.red("No Arcane installation found. Run 'arcane install' first."));
+      console.log(chalk7.red("No Arcane installation found. Run 'arcane install' first."));
     }
     return { target, status: "no-manifest", updated: 0, skipped: 0, removed: 0 };
   }
@@ -1942,7 +2101,7 @@ async function updateTarget(target, opts) {
   const installedVersion = manifest.source_version ?? manifest.arcane_version;
   if (installedVersion === currentVersion && !opts.force) {
     if (!opts.quiet) {
-      console.log(chalk6.green(`Already up to date (v${currentVersion}).`));
+      console.log(chalk7.green(`Already up to date (v${currentVersion}).`));
     }
     return {
       target,
@@ -1956,16 +2115,16 @@ async function updateTarget(target, opts) {
   }
   if (!opts.quiet) {
     console.log(
-      chalk6.bold(`
-Update available: ${chalk6.red(installedVersion)} -> ${chalk6.green(currentVersion)}`)
+      chalk7.bold(`
+Update available: ${chalk7.red(installedVersion)} -> ${chalk7.green(currentVersion)}`)
     );
   }
   const profileNames = manifest.profile_command.split("+").filter(Boolean);
-  const profilesDir = path14.join(root, "profiles");
+  const profilesDir = path15.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 = path14.join(target, ".claude");
+  const claudeDir = path15.join(target, ".claude");
   const installedHashes = computeContentHashes(claudeDir);
   const items = computeUpdatePlan(
     manifest.content_hashes ?? null,
@@ -1993,7 +2152,7 @@ Update available: ${chalk6.red(installedVersion)} -> ${chalk6.green(currentVersi
       });
     }
     if (!opts.quiet) {
-      console.log(chalk6.green("\nNo changes to apply."));
+      console.log(chalk7.green("\nNo changes to apply."));
     }
     return {
       target,
@@ -2030,7 +2189,7 @@ Update available: ${chalk6.red(installedVersion)} -> ${chalk6.green(currentVersi
     total_rules: allRules.length
   });
   if (!opts.quiet) {
-    console.log(chalk6.green(`
+    console.log(chalk7.green(`
 Updated to v${currentVersion}.`));
     console.log(`  ${updates.length} updated, ${skipped.length} skipped, ${removed.length} removed`);
   }
@@ -2045,12 +2204,12 @@ Updated to v${currentVersion}.`));
   };
 }
 function printGeneralSummary(results, isDryRun) {
-  const prefix = isDryRun ? chalk6.yellow("[dry-run] ") : "";
+  const prefix = isDryRun ? chalk7.yellow("[dry-run] ") : "";
   const updated = results.filter((r) => r.status === "updated" || r.status === "dry-run").length;
   const unchanged = results.filter((r) => r.status === "up-to-date" || r.status === "no-changes").length;
-  console.log(chalk6.bold(`
+  console.log(chalk7.bold(`
 ${prefix}Done. ${results.length} installation${results.length === 1 ? "" : "s"} processed:`));
-  console.log(`  ${chalk6.green(updated)} ${isDryRun ? "would change" : "updated"}, ${chalk6.dim(unchanged + " unchanged")}`);
+  console.log(`  ${chalk7.green(updated)} ${isDryRun ? "would change" : "updated"}, ${chalk7.dim(unchanged + " unchanged")}`);
 }
 function computeUpdatePlan(manifestHashes, installedHashes, sourceHashes) {
   const items = [];
@@ -2091,7 +2250,7 @@ function resolveAction(manifestHash, installedHash, sourceHash) {
   return "conflict";
 }
 function printUpdateSummary(items, isDryRun) {
-  const prefix = isDryRun ? chalk6.yellow("[dry-run] ") : "";
+  const prefix = isDryRun ? chalk7.yellow("[dry-run] ") : "";
   const updates = items.filter((i) => i.action === "update");
   const adds = items.filter((i) => i.action === "add");
   const conflicts = items.filter((i) => i.action === "conflict");
@@ -2099,37 +2258,37 @@ function printUpdateSummary(items, isDryRun) {
   const removed = items.filter((i) => i.action === "remove");
   if (updates.length > 0) {
     console.log(`
-${prefix}${chalk6.cyan("Will update:")}`);
+${prefix}${chalk7.cyan("Will update:")}`);
     for (const item of updates) {
-      console.log(`  ${chalk6.green("~")} ${item.type}: ${item.name}`);
+      console.log(`  ${chalk7.green("~")} ${item.type}: ${item.name}`);
     }
   }
   if (adds.length > 0) {
     console.log(`
-${prefix}${chalk6.cyan("Will add:")}`);
+${prefix}${chalk7.cyan("Will add:")}`);
     for (const item of adds) {
-      console.log(`  ${chalk6.green("+")} ${item.type}: ${item.name}`);
+      console.log(`  ${chalk7.green("+")} ${item.type}: ${item.name}`);
     }
   }
   if (removed.length > 0) {
     console.log(`
-${prefix}${chalk6.cyan("Will remove:")}`);
+${prefix}${chalk7.cyan("Will remove:")}`);
     for (const item of removed) {
-      console.log(`  ${chalk6.red("-")} ${item.type}: ${item.name}`);
+      console.log(`  ${chalk7.red("-")} ${item.type}: ${item.name}`);
     }
   }
   if (conflicts.length > 0) {
     console.log(`
-${prefix}${chalk6.yellow("Conflicts (will backup + update):")}`);
+${prefix}${chalk7.yellow("Conflicts (will backup + update):")}`);
     for (const item of conflicts) {
-      console.log(`  ${chalk6.yellow("!")} ${item.type}: ${item.name}`);
+      console.log(`  ${chalk7.yellow("!")} ${item.type}: ${item.name}`);
     }
   }
   if (customized.length > 0) {
     console.log(`
-${prefix}${chalk6.dim("Skipped (locally customized):")}`);
+${prefix}${chalk7.dim("Skipped (locally customized):")}`);
     for (const item of customized) {
-      console.log(`  ${chalk6.dim("  " + item.type + ": " + item.name)}`);
+      console.log(`  ${chalk7.dim("  " + item.type + ": " + item.name)}`);
     }
   }
 }
@@ -2158,48 +2317,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 || !fs11.existsSync(src)) return;
+  if (!src || !fs12.existsSync(src)) return;
   if (item.type === "skill" || item.type === "agent") {
-    if (fs11.existsSync(dst)) {
-      fs11.rmSync(dst, { recursive: true, force: true });
+    if (fs12.existsSync(dst)) {
+      fs12.rmSync(dst, { recursive: true, force: true });
     }
     copyDirSync(src, dst);
   } else {
-    const dir = path14.dirname(dst);
-    if (!fs11.existsSync(dir)) {
-      fs11.mkdirSync(dir, { recursive: true });
+    const dir = path15.dirname(dst);
+    if (!fs12.existsSync(dir)) {
+      fs12.mkdirSync(dir, { recursive: true });
     }
-    fs11.copyFileSync(src, dst);
+    fs12.copyFileSync(src, dst);
   }
 }
 function backupItem(item, claudeDir) {
   const installed = getInstalledPath(item, claudeDir);
-  if (!fs11.existsSync(installed)) return;
+  if (!fs12.existsSync(installed)) return;
   const backupPath = installed + ".bak";
-  if (fs11.existsSync(backupPath)) {
-    fs11.rmSync(backupPath, { recursive: true, force: true });
+  if (fs12.existsSync(backupPath)) {
+    fs12.rmSync(backupPath, { recursive: true, force: true });
   }
-  fs11.renameSync(installed, backupPath);
+  fs12.renameSync(installed, backupPath);
 }
 function removeItem(item, claudeDir) {
   const installed = getInstalledPath(item, claudeDir);
-  if (fs11.existsSync(installed)) {
-    fs11.rmSync(installed, { recursive: true, force: true });
+  if (fs12.existsSync(installed)) {
+    fs12.rmSync(installed, { recursive: true, force: true });
   }
 }
 function getSourcePath(item, root) {
   switch (item.type) {
     case "skill":
-      return path14.join(root, "skills", item.name);
+      return path15.join(root, "skills", item.name);
     case "rule": {
-      const direct = path14.join(root, "rules", item.name);
-      if (fs11.existsSync(direct)) return direct;
-      return path14.join(root, "rules", "gamedev", item.name);
+      const direct = path15.join(root, "rules", item.name);
+      if (fs12.existsSync(direct)) return direct;
+      return path15.join(root, "rules", "gamedev", item.name);
     }
     case "agent":
-      return path14.join(root, "agents", item.name);
+      return path15.join(root, "agents", item.name);
     case "hook":
-      return path14.join(root, "hooks", item.name);
+      return path15.join(root, "hooks", item.name);
     default:
       return null;
   }
@@ -2207,26 +2366,26 @@ function getSourcePath(item, root) {
 function getInstalledPath(item, claudeDir) {
   switch (item.type) {
     case "skill":
-      return path14.join(claudeDir, "skills", item.name);
+      return path15.join(claudeDir, "skills", item.name);
     case "rule":
-      return path14.join(claudeDir, "rules", item.name);
+      return path15.join(claudeDir, "rules", item.name);
     case "agent":
-      return path14.join(claudeDir, "agents", item.name);
+      return path15.join(claudeDir, "agents", item.name);
     case "hook":
-      return path14.join(claudeDir, "hooks", item.name);
+      return path15.join(claudeDir, "hooks", item.name);
   }
 }
 
 // src/commands/clean.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 async function cleanCommand(opts) {
   const target = process.cwd();
   const manifest = readManifest(target);
   if (!manifest) {
-    console.log(chalk7.yellow("No Arcane installation found."));
+    console.log(chalk8.yellow("No Arcane installation found."));
     return;
   }
-  console.log(chalk7.bold("\nThis will remove:"));
+  console.log(chalk8.bold("\nThis will remove:"));
   console.log(`  - ${manifest.total_skills} skills in .claude/skills/`);
   console.log(`  - ${manifest.total_rules} rules in .claude/rules/`);
   console.log(
@@ -2237,33 +2396,33 @@ async function cleanCommand(opts) {
   console.log("  - arcane-manifest.json");
   if (!opts.force) {
     console.log(
-      chalk7.yellow("\n  Pass --force to confirm removal.\n")
+      chalk8.yellow("\n  Pass --force to confirm removal.\n")
     );
     return;
   }
   clean(target);
   console.log(
-    chalk7.green("\n  Run `npx claude-code-arcane install` to reinstall.\n")
+    chalk8.green("\n  Run `npx claude-code-arcane install` to reinstall.\n")
   );
 }
 
 // src/commands/worktree.ts
-import fs12 from "fs";
-import path15 from "path";
+import fs13 from "fs";
+import path16 from "path";
 import { execSync as execSync2 } from "child_process";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 async function worktreeCommand(branch, opts) {
   const cwd = process.cwd();
   const wtInfo = getWorktreeInfo(cwd);
   if (!wtInfo) {
-    console.error(chalk8.red("Not a git repository."));
+    console.error(chalk9.red("Not a git repository."));
     process.exit(1);
   }
   const repoRoot = wtInfo.isWorktree ? wtInfo.mainWorktreePath : cwd;
-  const worktreePath = opts.path ? path15.resolve(opts.path) : defaultWorktreePath(repoRoot, branch);
-  if (fs12.existsSync(worktreePath)) {
+  const worktreePath = opts.path ? path16.resolve(opts.path) : defaultWorktreePath(repoRoot, branch);
+  if (fs13.existsSync(worktreePath)) {
     console.error(
-      chalk8.red(`Path already exists: ${worktreePath}`)
+      chalk9.red(`Path already exists: ${worktreePath}`)
     );
     process.exit(1);
   }
@@ -2273,7 +2432,7 @@ async function worktreeCommand(branch, opts) {
     if (manifest) {
       profileExpr = manifest.profile_command;
       console.log(
-        chalk8.dim(
+        chalk9.dim(
           `  Inheriting profile from current installation: ${profileExpr}`
         )
       );
@@ -2281,34 +2440,34 @@ async function worktreeCommand(branch, opts) {
   }
   if (!profileExpr) {
     console.error(
-      chalk8.red(
+      chalk9.red(
         "No profile specified and no existing installation to inherit from.\nUse --profile to specify one: npx claude-code-arcane worktree feat/api --profile backend-ts+agile"
       )
     );
     process.exit(1);
   }
-  console.log(chalk8.bold("\nCreating worktree:"));
-  console.log(`  Branch:  ${chalk8.cyan(branch)}`);
+  console.log(chalk9.bold("\nCreating worktree:"));
+  console.log(`  Branch:  ${chalk9.cyan(branch)}`);
   console.log(`  Path:    ${worktreePath}`);
-  console.log(`  Profile: ${chalk8.green(profileExpr)}`);
+  console.log(`  Profile: ${chalk9.green(profileExpr)}`);
   if (opts.base) console.log(`  Base:    ${opts.base}`);
   if (opts.dryRun) {
-    console.log(chalk8.yellow("\n  [dry-run] Would create worktree and install Arcane."));
+    console.log(chalk9.yellow("\n  [dry-run] Would create worktree and install Arcane."));
     return;
   }
   console.log("\n  Creating git worktree...");
   try {
     createGitWorktree(repoRoot, worktreePath, branch, opts.base);
-    console.log(chalk8.green("  [ok] Git worktree created"));
+    console.log(chalk9.green("  [ok] Git worktree created"));
   } catch (err) {
     console.error(
-      chalk8.red(`  Failed to create worktree: ${err.message}`)
+      chalk9.red(`  Failed to create worktree: ${err.message}`)
     );
     process.exit(1);
   }
   console.log("  Installing Arcane...");
   const root = getPackageRoot();
-  const profilesDir = path15.join(root, "profiles");
+  const profilesDir = path16.join(root, "profiles");
   const profileNames = profileExpr.split("+").filter(Boolean);
   const merged = mergeProfiles(profilesDir, profileNames);
   const shareFrom = opts.share !== false ? cwd : void 0;
@@ -2323,7 +2482,7 @@ async function worktreeCommand(branch, opts) {
     main_worktree: repoRoot
   });
   registerInstallation(worktreePath);
-  console.log(chalk8.green("  [ok] Arcane installed"));
+  console.log(chalk9.green("  [ok] Arcane installed"));
   if (opts.installDeps) {
     const pm = detectPackageManager(worktreePath);
     if (pm) {
@@ -2335,22 +2494,22 @@ async function worktreeCommand(branch, opts) {
           stdio: "pipe",
           timeout: 12e4
         });
-        console.log(chalk8.green(`  [ok] Dependencies installed`));
+        console.log(chalk9.green(`  [ok] Dependencies installed`));
       } catch {
         console.warn(
-          chalk8.yellow("  WARN: Dependency install failed. Run manually.")
+          chalk9.yellow("  WARN: Dependency install failed. Run manually.")
         );
       }
     }
   }
   if (opts.isolate) {
-    const isolateScript = path15.join(
+    const isolateScript = path16.join(
       worktreePath,
       ".claude",
       "skills",
       "worktree-isolation"
     );
-    if (fs12.existsSync(isolateScript)) {
+    if (fs13.existsSync(isolateScript)) {
       console.log("  Applying worktree isolation...");
       try {
         execSync2(
@@ -2362,36 +2521,36 @@ async function worktreeCommand(branch, opts) {
             timeout: 3e4
           }
         );
-        console.log(chalk8.green("  [ok] Worktree isolation applied"));
+        console.log(chalk9.green("  [ok] Worktree isolation applied"));
       } catch {
         console.warn(
-          chalk8.yellow(
+          chalk9.yellow(
             "  WARN: Worktree isolation failed. Run /worktree-isolation manually."
           )
         );
       }
     } else {
       console.warn(
-        chalk8.yellow(
+        chalk9.yellow(
           "  WARN: worktree-isolation skill not installed. Add it with: npx claude-code-arcane add worktree-isolation"
         )
       );
     }
   }
-  console.log(chalk8.bold.green("\nWorktree ready:"));
-  console.log(`  ${chalk8.cyan(`cd ${worktreePath}`)}`);
-  console.log(`  ${chalk8.dim("claude")}
+  console.log(chalk9.bold.green("\nWorktree ready:"));
+  console.log(`  ${chalk9.cyan(`cd ${worktreePath}`)}`);
+  console.log(`  ${chalk9.dim("claude")}
 `);
 }
 
 // src/commands/global.ts
-import fs13 from "fs";
-import path16 from "path";
+import fs14 from "fs";
+import path17 from "path";
 import os5 from "os";
-import chalk9 from "chalk";
-var CLAUDE_HOME = path16.join(os5.homedir(), ".claude");
-var SCRIPTS_DIR = path16.join(CLAUDE_HOME, "scripts", "worktree-isolation");
-var SETTINGS_PATH = path16.join(CLAUDE_HOME, "settings.json");
+import chalk10 from "chalk";
+var CLAUDE_HOME = path17.join(os5.homedir(), ".claude");
+var SCRIPTS_DIR = path17.join(CLAUDE_HOME, "scripts", "worktree-isolation");
+var SETTINGS_PATH = path17.join(CLAUDE_HOME, "settings.json");
 async function globalCommand(opts) {
   if (opts.status) {
     showStatus();
@@ -2404,100 +2563,100 @@ async function globalCommand(opts) {
   installGlobal();
 }
 function showStatus() {
-  console.log(chalk9.bold("\n=== Arcane Global Status ===\n"));
-  const hasScripts = fs13.existsSync(
-    path16.join(SCRIPTS_DIR, "apply.py")
+  console.log(chalk10.bold("\n=== Arcane Global Status ===\n"));
+  const hasScripts = fs14.existsSync(
+    path17.join(SCRIPTS_DIR, "apply.py")
   );
   console.log(
-    `  Worktree scripts: ${hasScripts ? chalk9.green("installed") : chalk9.dim("not installed")}`
+    `  Worktree scripts: ${hasScripts ? chalk10.green("installed") : chalk10.dim("not installed")}`
   );
   if (hasScripts) {
-    console.log(`    ${chalk9.dim(SCRIPTS_DIR)}`);
+    console.log(`    ${chalk10.dim(SCRIPTS_DIR)}`);
   }
   const hookInstalled = isHookInstalled();
   console.log(
-    `  SessionStart hook: ${hookInstalled ? chalk9.green("active") : chalk9.dim("not configured")}`
+    `  SessionStart hook: ${hookInstalled ? chalk10.green("active") : chalk10.dim("not configured")}`
   );
-  console.log(`    ${chalk9.dim(SETTINGS_PATH)}`);
+  console.log(`    ${chalk10.dim(SETTINGS_PATH)}`);
   console.log();
 }
 function installGlobal() {
-  console.log(chalk9.bold("\nInstalling Arcane global hooks...\n"));
+  console.log(chalk10.bold("\nInstalling Arcane global hooks...\n"));
   const root = getPackageRoot();
-  const scriptsSrc = path16.join(
+  const scriptsSrc = path17.join(
     root,
     "skills",
     "worktree-isolation",
     "scripts"
   );
-  if (!fs13.existsSync(scriptsSrc)) {
+  if (!fs14.existsSync(scriptsSrc)) {
     console.error(
-      chalk9.red("  worktree-isolation scripts not found in package.")
+      chalk10.red("  worktree-isolation scripts not found in package.")
     );
     process.exit(1);
   }
-  fs13.mkdirSync(SCRIPTS_DIR, { recursive: true });
+  fs14.mkdirSync(SCRIPTS_DIR, { recursive: true });
   for (const file of ["apply.py", "lib.py"]) {
-    const src = path16.join(scriptsSrc, file);
-    const dst = path16.join(SCRIPTS_DIR, file);
-    if (!fs13.existsSync(src)) {
-      console.warn(chalk9.yellow(`  WARN: ${file} not found, skipping`));
+    const src = path17.join(scriptsSrc, file);
+    const dst = path17.join(SCRIPTS_DIR, file);
+    if (!fs14.existsSync(src)) {
+      console.warn(chalk10.yellow(`  WARN: ${file} not found, skipping`));
       continue;
     }
-    if (fs13.existsSync(dst) && fs13.readFileSync(src).equals(fs13.readFileSync(dst))) {
-      console.log(chalk9.dim(`  [skip] ${file} (already up-to-date)`));
+    if (fs14.existsSync(dst) && fs14.readFileSync(src).equals(fs14.readFileSync(dst))) {
+      console.log(chalk10.dim(`  [skip] ${file} (already up-to-date)`));
     } else {
-      fs13.copyFileSync(src, dst);
+      fs14.copyFileSync(src, dst);
       if (process.platform !== "win32") {
-        fs13.chmodSync(dst, 493);
+        fs14.chmodSync(dst, 493);
       }
-      console.log(chalk9.green(`  [ok] ${file} -> ${SCRIPTS_DIR}`));
+      console.log(chalk10.green(`  [ok] ${file} -> ${SCRIPTS_DIR}`));
     }
   }
   if (isHookInstalled()) {
     console.log(
-      chalk9.dim("  [skip] SessionStart hook (already configured)")
+      chalk10.dim("  [skip] SessionStart hook (already configured)")
     );
   } else {
     addHookToSettings();
     console.log(
-      chalk9.green("  [ok] SessionStart hook added to ~/.claude/settings.json")
+      chalk10.green("  [ok] SessionStart hook added to ~/.claude/settings.json")
     );
   }
-  console.log(chalk9.bold.green("\n  Global hooks installed."));
+  console.log(chalk10.bold.green("\n  Global hooks installed."));
   console.log(
-    chalk9.dim(
+    chalk10.dim(
       "  Worktree isolation will auto-apply on every new Claude Code session.\n"
     )
   );
 }
 function removeGlobal() {
-  console.log(chalk9.bold("\nRemoving Arcane global hooks...\n"));
-  if (fs13.existsSync(SCRIPTS_DIR)) {
-    fs13.rmSync(SCRIPTS_DIR, { recursive: true, force: true });
-    console.log(chalk9.green("  [ok] Removed worktree-isolation scripts"));
+  console.log(chalk10.bold("\nRemoving Arcane global hooks...\n"));
+  if (fs14.existsSync(SCRIPTS_DIR)) {
+    fs14.rmSync(SCRIPTS_DIR, { recursive: true, force: true });
+    console.log(chalk10.green("  [ok] Removed worktree-isolation scripts"));
   } else {
-    console.log(chalk9.dim("  [skip] Scripts not found"));
+    console.log(chalk10.dim("  [skip] Scripts not found"));
   }
   if (isHookInstalled()) {
     removeHookFromSettings();
-    console.log(chalk9.green("  [ok] Removed SessionStart hook"));
+    console.log(chalk10.green("  [ok] Removed SessionStart hook"));
   } else {
-    console.log(chalk9.dim("  [skip] Hook not configured"));
+    console.log(chalk10.dim("  [skip] Hook not configured"));
   }
-  console.log(chalk9.bold.green("\n  Global hooks removed.\n"));
+  console.log(chalk10.bold.green("\n  Global hooks removed.\n"));
 }
 function readSettings() {
-  if (!fs13.existsSync(SETTINGS_PATH)) return {};
+  if (!fs14.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs13.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs14.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  fs13.mkdirSync(path16.dirname(SETTINGS_PATH), { recursive: true });
-  fs13.writeFileSync(
+  fs14.mkdirSync(path17.dirname(SETTINGS_PATH), { recursive: true });
+  fs14.writeFileSync(
     SETTINGS_PATH,
     JSON.stringify(settings, null, 2) + "\n",
     "utf-8"
@@ -2554,11 +2713,11 @@ function removeHookFromSettings() {
 }
 
 // src/update-check.ts
-import fs14 from "fs";
-import path17 from "path";
+import fs15 from "fs";
+import path18 from "path";
 import os6 from "os";
-import chalk10 from "chalk";
-var CHECK_FILE = path17.join(os6.homedir(), ".arcane", "last-check.json");
+import chalk11 from "chalk";
+var CHECK_FILE = path18.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";
@@ -2598,11 +2757,11 @@ async function checkForUpdates(opts = {}) {
 }
 function printUpdateNotice(localVersion, remoteSha) {
   console.log(
-    chalk10.yellow(`
+    chalk11.yellow(`
   Arcane update available: ${localVersion} \u2192 ${remoteSha}`)
   );
   console.log(
-    chalk10.dim("  Run: arcane update (--dry-run to preview)\n")
+    chalk11.dim("  Run: arcane update (--dry-run to preview)\n")
   );
 }
 async function getLatestCommitSha() {
@@ -2626,19 +2785,19 @@ async function getLatestCommitSha() {
 }
 function readCachedCheck() {
   try {
-    if (!fs14.existsSync(CHECK_FILE)) return null;
-    return JSON.parse(fs14.readFileSync(CHECK_FILE, "utf-8"));
+    if (!fs15.existsSync(CHECK_FILE)) return null;
+    return JSON.parse(fs15.readFileSync(CHECK_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCachedCheck(result) {
   try {
-    const dir = path17.dirname(CHECK_FILE);
-    if (!fs14.existsSync(dir)) {
-      fs14.mkdirSync(dir, { recursive: true });
+    const dir = path18.dirname(CHECK_FILE);
+    if (!fs15.existsSync(dir)) {
+      fs15.mkdirSync(dir, { recursive: true });
     }
-    fs14.writeFileSync(CHECK_FILE, JSON.stringify(result, null, 2) + "\n");
+    fs15.writeFileSync(CHECK_FILE, JSON.stringify(result, null, 2) + "\n");
   } catch {
   }
 }
@@ -2649,7 +2808,7 @@ program.name("arcane").description(
   "Claude Code Arcane \u2014 Skills, agents, hooks and rules for Claude Code"
 ).version(getPackageVersion());
 program.command("install [profile]").description(
-  "Install a profile (e.g., backend-ts+agile). Without args, shows available profiles."
+  "Install profiles (e.g., backend-ts+agile). Without args, opens an interactive picker."
 ).option("-t, --target <dir>", "Target project directory", process.cwd()).option("-n, --dry-run", "Show what would be installed without changing files").option("-f, --force", "Overwrite without backup prompt").option(
   "-s, --share-from <dir>",
   "Share hooks/docs from an existing Arcane installation (e.g., main worktree)"