claude-code-arcane 2.9.6 → 2.9.8

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.9.8](https://github.com/SebastianLuser/claude-code-arcane/compare/v2.9.7...v2.9.8) (2026-09-09)
+
+
+### Bug Fixes
+
+* **statusline:** point the global install at the script it owns ([1a8aada](https://github.com/SebastianLuser/claude-code-arcane/commit/1a8aada612e7f2bad2d60450306c0d51887f6b65))
+
+## [2.9.7](https://github.com/SebastianLuser/claude-code-arcane/compare/v2.9.6...v2.9.7) (2026-09-08)
+
+
+### Bug Fixes
+
+* make a first-time npx install survivable ([964ef8e](https://github.com/SebastianLuser/claude-code-arcane/commit/964ef8eef9d4ea6a1e593eac189bceb79650174d))
+
 ## [2.9.6](https://github.com/SebastianLuser/claude-code-arcane/compare/v2.9.5...v2.9.6) (2026-09-07)
 
 

package/README.md

@@ -6,6 +6,13 @@ A configuration harness installable via `npx`. Pick a **profile** that matches y
 
 ---
 
+## Requirements
+
+- **Node 20+** and **npm 7+** — `npx` needs npm 7 to resolve the package name to its `arcane` bin.
+- **Nothing to clone or download.** `npx` fetches what it needs. Run it inside **your own project**.
+
+---
+
 ## Quick Start
 
 ```bash
@@ -21,6 +28,19 @@ claude
 
 That's it. Your project now has skills, agents, hooks, rules, and permissions tailored for your stack.
 
+> **Do not install from a downloaded copy of this repo.** `install` targets the current directory, so
+> running it inside a `claude-code-arcane-*` folder from the Releases page deploys the whole profile
+> into that throwaway folder instead of your project.
+
+Every command in this README uses the `npx` form, which always works. Bare `arcane` is the *bin* name
+and only reaches your `PATH` after a global install — so if you prefer the shorter form, ask for it
+explicitly first:
+
+```bash
+npm install -g claude-code-arcane
+arcane install backend-ts+agile      # same as the npx line above
+```
+
 ---
 
 ## How It Works

package/dist/cli.js

@@ -4,8 +4,10 @@
 import { Command } from "commander";
 
 // src/commands/install.ts
+import fs10 from "fs";
 import path12 from "path";
 import chalk2 from "chalk";
+import * as p2 from "@clack/prompts";
 
 // src/profiles.ts
 import fs from "fs";
@@ -48,9 +50,9 @@ 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)
+    profiles: profiles.filter((p3) => p3.category === c.id)
   }));
-  const rest = profiles.filter((p2) => !known.has(p2.category));
+  const rest = profiles.filter((p3) => !known.has(p3.category));
   if (rest.length > 0) {
     groups.push({ id: "other", label: "Other", profiles: rest });
   }
@@ -395,6 +397,14 @@ import os from "os";
 function arcaneHome() {
   return process.env.ARCANE_HOME ?? path3.join(os.homedir(), ".arcane");
 }
+var RELATIVE_STATUSLINE_COMMAND = "bash .claude/statusline.sh";
+function statuslineCommand(target) {
+  if (path3.resolve(target) !== path3.resolve(os.homedir())) {
+    return RELATIVE_STATUSLINE_COMMAND;
+  }
+  const script = path3.join(target, ".claude", "statusline.sh").replace(/\\/g, "/");
+  return `bash "${script}"`;
+}
 function getPackageRoot() {
   const thisFile = fileURLToPath(import.meta.url);
   return path3.resolve(path3.dirname(thisFile), "..");
@@ -419,18 +429,18 @@ function copyDirSync(src, dest) {
 function ensureDir(dir) {
   fs3.mkdirSync(dir, { recursive: true });
 }
-function fileExists(p2) {
-  return fs3.existsSync(p2);
+function fileExists(p3) {
+  return fs3.existsSync(p3);
 }
-function readJsonSync(p2) {
-  return JSON.parse(fs3.readFileSync(p2, "utf-8"));
+function readJsonSync(p3) {
+  return JSON.parse(fs3.readFileSync(p3, "utf-8"));
 }
-function writeJsonSync(p2, data) {
-  fs3.writeFileSync(p2, JSON.stringify(data, null, 2) + "\n", "utf-8");
+function writeJsonSync(p3, data) {
+  fs3.writeFileSync(p3, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
-function isSymlinkOrJunction(p2) {
+function isSymlinkOrJunction(p3) {
   try {
-    return fs3.lstatSync(p2).isSymbolicLink();
+    return fs3.lstatSync(p3).isSymbolicLink();
   } catch {
     return false;
   }
@@ -440,11 +450,11 @@ function getPackageVersion() {
   const pkg = readJsonSync(pkgPath);
   return pkg.version;
 }
-function safeRemove(p2) {
-  if (isSymlinkOrJunction(p2)) {
-    fs3.unlinkSync(p2);
-  } else if (fs3.existsSync(p2)) {
-    fs3.rmSync(p2, { recursive: true, force: true });
+function safeRemove(p3) {
+  if (isSymlinkOrJunction(p3)) {
+    fs3.unlinkSync(p3);
+  } else if (fs3.existsSync(p3)) {
+    fs3.rmSync(p3, { recursive: true, force: true });
   }
 }
 
@@ -466,8 +476,8 @@ function isGranular(raw) {
 }
 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;
+  const p3 = agent ? path4.join(root, "agents", division, `${agent}.md`) : path4.join(root, "agents", division);
+  return fs4.existsSync(p3) ? p3 : null;
 }
 function copyAgentEntry(root, claudeDir, raw) {
   const src = agentSourcePath(root, raw);
@@ -510,9 +520,9 @@ function manifestPath(target) {
   return path5.join(target, ".claude", MANIFEST_FILE);
 }
 function readManifest(target) {
-  const p2 = manifestPath(target);
-  if (!fileExists(p2)) return null;
-  return readJsonSync(p2);
+  const p3 = manifestPath(target);
+  if (!fileExists(p3)) return null;
+  return readJsonSync(p3);
 }
 function writeManifest(target, merged, profileCommand, packageRoot, worktreeOrOpts) {
   let opts = {};
@@ -1241,7 +1251,7 @@ var Installer = class {
     if (this.hasStatusline) {
       settings.statusLine = {
         type: "command",
-        command: "bash .claude/statusline.sh"
+        command: statuslineCommand(this.target)
       };
     }
     const activeStyle = this.merged.output_styles[0];
@@ -1274,27 +1284,27 @@ function clean(target) {
   if (fs7.existsSync(manifestFile)) {
     const data = JSON.parse(fs7.readFileSync(manifestFile, "utf-8"));
     const profiles = (data.profiles ?? []).filter(
-      (p2) => p2 !== "core"
+      (p3) => p3 !== "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 p2 = path8.join(claudeDir, dir);
-      if (isSymlinkOrJunction(p2)) {
-        fs7.unlinkSync(p2);
+      const p3 = path8.join(claudeDir, dir);
+      if (isSymlinkOrJunction(p3)) {
+        fs7.unlinkSync(p3);
         console.log(`  [ok] Unlinked shared ${dir}/`);
       }
     }
   }
   for (const sub of ["hooks", "docs", "skills", "agents", "rules"]) {
-    const p2 = path8.join(claudeDir, sub);
-    safeRemove(p2);
+    const p3 = path8.join(claudeDir, sub);
+    safeRemove(p3);
   }
   const remaining = fs7.readdirSync(claudeDir);
   for (const f of remaining) {
-    const p2 = path8.join(claudeDir, f);
-    safeRemove(p2);
+    const p3 = path8.join(claudeDir, f);
+    safeRemove(p3);
   }
   if (fs7.existsSync(claudeDir)) {
     fs7.rmSync(claudeDir, { recursive: true, force: true });
@@ -1631,12 +1641,12 @@ function registryPath() {
   return path11.join(arcaneHome(), "installations.json");
 }
 function readRegistryFile() {
-  const p2 = registryPath();
-  if (!fileExists(p2)) {
+  const p3 = registryPath();
+  if (!fileExists(p3)) {
     return { version: REGISTRY_VERSION, installations: [] };
   }
   try {
-    const data = readJsonSync(p2);
+    const data = readJsonSync(p3);
     return {
       version: REGISTRY_VERSION,
       installations: Array.isArray(data.installations) ? data.installations : []
@@ -1674,6 +1684,36 @@ function pruneRegistry() {
 }
 
 // src/commands/install.ts
+var PACKAGE_NAME = "claude-code-arcane";
+function isArcaneSourceTree(dir) {
+  try {
+    const pkg = JSON.parse(
+      fs10.readFileSync(path12.join(dir, "package.json"), "utf-8")
+    );
+    return pkg.name === PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+async function refusesSelfInstall(target, profileExpr, opts) {
+  if (!isArcaneSourceTree(target)) return false;
+  console.log(
+    chalk2.yellow("\n  This directory is Arcane's own source tree, not a project.")
+  );
+  console.log(chalk2.dim(`  Target: ${target}`));
+  if (opts.force || opts.dryRun) return false;
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const proceed = interactive ? await p2.confirm({ message: "Install here anyway?", initialValue: false }) : false;
+  if (!p2.isCancel(proceed) && proceed) return false;
+  console.log(
+    chalk2.dim(
+      `
+  cd to your project first, then: npx ${PACKAGE_NAME} install ${profileExpr ?? "<profile>"}`
+    )
+  );
+  console.log(chalk2.dim("  Or pass --force to install here on purpose.\n"));
+  return true;
+}
 async function installCommand(profileExpr, opts) {
   const source = await resolveContentSource({
     source: opts.source ?? "auto",
@@ -1682,6 +1722,7 @@ async function installCommand(profileExpr, opts) {
   const root = await source.getContentRoot();
   const profilesDir = path12.join(root, "profiles");
   const target = path12.resolve(opts.target ?? process.cwd());
+  if (await refusesSelfInstall(target, profileExpr, opts)) return;
   if (!profileExpr) {
     const profiles = listProfiles(profilesDir);
     if (process.stdin.isTTY && process.stdout.isTTY) {
@@ -1692,9 +1733,9 @@ async function installCommand(profileExpr, opts) {
       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) {
+        for (const p3 of group.profiles) {
           console.log(
-            `    ${chalk2.green(p2.name.padEnd(20))} ${p2.description}`
+            `    ${chalk2.green(p3.name.padEnd(20))} ${p3.description}`
           );
         }
         console.log();
@@ -1752,18 +1793,18 @@ Installing profile: ${chalk2.cyan(profileExpr)}`)
 }
 
 // src/commands/add.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path14 from "path";
 import chalk3 from "chalk";
 
 // src/skills-catalog.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path13 from "path";
 var FRONTMATTER_BYTES = 4096;
 function listSkills(skillsDir) {
-  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"))
+  if (!fs11.existsSync(skillsDir)) return [];
+  return fs11.readdirSync(skillsDir, { withFileTypes: true }).filter(
+    (d) => d.isDirectory() && !d.name.startsWith("_") && fs11.existsSync(path13.join(skillsDir, d.name, "SKILL.md"))
   ).map((d) => ({
     name: d.name,
     description: readDescription(path13.join(skillsDir, d.name, "SKILL.md"))
@@ -1787,13 +1828,13 @@ function readDescription(skillFile) {
   return inline.replace(/^["']|["']$/g, "").trim();
 }
 function readHead(file) {
-  const fd = fs10.openSync(file, "r");
+  const fd = fs11.openSync(file, "r");
   try {
     const buf = Buffer.alloc(FRONTMATTER_BYTES);
-    const read = fs10.readSync(fd, buf, 0, FRONTMATTER_BYTES, 0);
+    const read = fs11.readSync(fd, buf, 0, FRONTMATTER_BYTES, 0);
     return buf.subarray(0, read).toString("utf-8");
   } finally {
-    fs10.closeSync(fd);
+    fs11.closeSync(fd);
   }
 }
 
@@ -1836,7 +1877,7 @@ async function addCommand(items = []) {
     if (item.startsWith("+")) {
       const profileName = item.slice(1);
       const profilePath = path14.join(root, "profiles", `${profileName}.yaml`);
-      if (!fs11.existsSync(profilePath)) {
+      if (!fs12.existsSync(profilePath)) {
         console.error(chalk3.red(`  Profile '${profileName}' not found`));
         continue;
       }
@@ -1850,9 +1891,9 @@ async function addCommand(items = []) {
       for (const rule of profile.rules.universal) {
         if (!manifest.installed_rules.includes(rule)) {
           const src = path14.join(root, "rules", `${rule}.md`);
-          if (fs11.existsSync(src)) {
+          if (fs12.existsSync(src)) {
             ensureDir(path14.join(claudeDir, "rules"));
-            fs11.copyFileSync(src, path14.join(claudeDir, "rules", `${rule}.md`));
+            fs12.copyFileSync(src, path14.join(claudeDir, "rules", `${rule}.md`));
             manifest.installed_rules.push(rule);
             addedRules.push(rule);
           }
@@ -1861,9 +1902,9 @@ async function addCommand(items = []) {
       for (const rule of profile.rules.gamedev) {
         if (!manifest.installed_rules.includes(rule)) {
           const src = path14.join(root, "rules", "gamedev", `${rule}.md`);
-          if (fs11.existsSync(src)) {
+          if (fs12.existsSync(src)) {
             ensureDir(path14.join(claudeDir, "rules"));
-            fs11.copyFileSync(src, path14.join(claudeDir, "rules", `${rule}.md`));
+            fs12.copyFileSync(src, path14.join(claudeDir, "rules", `${rule}.md`));
             manifest.installed_rules.push(rule);
             addedRules.push(rule);
           }
@@ -1880,8 +1921,8 @@ async function addCommand(items = []) {
       }
       if (profileName === "statusline") {
         const statuslineSrc = path14.join(root, "hooks", "statusline.sh");
-        if (fs11.existsSync(statuslineSrc)) {
-          fs11.copyFileSync(statuslineSrc, path14.join(claudeDir, "statusline.sh"));
+        if (fs12.existsSync(statuslineSrc)) {
+          fs12.copyFileSync(statuslineSrc, path14.join(claudeDir, "statusline.sh"));
           statuslineAdded = true;
         }
       }
@@ -1890,10 +1931,10 @@ async function addCommand(items = []) {
       }
       if (!manifest.profiles.includes(profileName)) {
         manifest.profiles.push(profileName);
-        manifest.profile_command = manifest.profiles.filter((p2) => p2 !== "core").join("+");
+        manifest.profile_command = manifest.profiles.filter((p3) => p3 !== "core").join("+");
       }
       if (statuslineAdded) {
-        addStatuslineToSettings(claudeDir);
+        addStatuslineToSettings(target, claudeDir);
       }
     } else {
       const result = addSkill(root, target, item, manifest.installed_skills);
@@ -1994,14 +2035,14 @@ function printCatalog(root, installedProfiles, installedSkills) {
 function addSkill(root, target, skill, installed) {
   if (installed.includes(skill)) return "skipped";
   const src = path14.join(root, "skills", skill);
-  if (!fs11.existsSync(src)) return "not-found";
+  if (!fs12.existsSync(src)) return "not-found";
   const dst = path14.join(target, ".claude", "skills", skill);
   copyDirSync(src, dst);
   return "added";
 }
 function mergePermissions(claudeDir, newPerms) {
   const settingsPath = path14.join(claudeDir, "settings.json");
-  if (!fs11.existsSync(settingsPath)) return;
+  if (!fs12.existsSync(settingsPath)) return;
   const settings = readJsonSync(settingsPath);
   const perms = settings.permissions ?? { allow: [], deny: [] };
   const allowSet = new Set(perms.allow);
@@ -2013,20 +2054,20 @@ function mergePermissions(claudeDir, newPerms) {
   settings.permissions = perms;
   writeJsonSync(settingsPath, settings);
 }
-function addStatuslineToSettings(claudeDir) {
+function addStatuslineToSettings(target, claudeDir) {
   const settingsPath = path14.join(claudeDir, "settings.json");
-  if (!fs11.existsSync(settingsPath)) return;
+  if (!fs12.existsSync(settingsPath)) return;
   const settings = readJsonSync(settingsPath);
   if (settings.statusLine) return;
   settings.statusLine = {
     type: "command",
-    command: "bash .claude/statusline.sh"
+    command: statuslineCommand(target)
   };
   writeJsonSync(settingsPath, settings);
 }
 
 // src/commands/remove.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import path15 from "path";
 import chalk4 from "chalk";
 var CORE_SKILLS = [
@@ -2097,8 +2138,8 @@ async function removeCommand(items, opts = {}) {
   const totalRemoved = removedSkills.length + removedAgents.length + removedProfiles.length;
   console.log(chalk4.bold(`
 Removed ${totalRemoved} items:`));
-  for (const p2 of removedProfiles)
-    console.log(chalk4.magenta(`  [ok] +${p2} (profile)`));
+  for (const p3 of removedProfiles)
+    console.log(chalk4.magenta(`  [ok] +${p3} (profile)`));
   for (const s of removedSkills)
     console.log(chalk4.green(`  [ok] ${s} (skill)`));
   for (const a of removedAgents)
@@ -2114,8 +2155,8 @@ function removeSkill(target, skill, manifest) {
     return "skipped";
   }
   const skillDir = path15.join(target, ".claude", "skills", skill);
-  if (!fs12.existsSync(skillDir)) return "skipped";
-  fs12.rmSync(skillDir, { recursive: true, force: true });
+  if (!fs13.existsSync(skillDir)) return "skipped";
+  fs13.rmSync(skillDir, { recursive: true, force: true });
   manifest.installed_skills = manifest.installed_skills.filter(
     (s) => s !== skill
   );
@@ -2135,7 +2176,7 @@ function removeProfile(root, target, profileName, manifest) {
     return { removed: false, skills: [], agents: [] };
   }
   const profilePath = path15.join(root, "profiles", `${profileName}.yaml`);
-  if (!fs12.existsSync(profilePath)) {
+  if (!fs13.existsSync(profilePath)) {
     console.warn(
       chalk4.yellow(`  WARNING: Profile '${profileName}.yaml' not found.`)
     );
@@ -2143,14 +2184,14 @@ function removeProfile(root, target, profileName, manifest) {
   }
   const profile = parseProfile(profilePath);
   const remainingProfiles = manifest.profiles.filter(
-    (p2) => p2 !== profileName
+    (p3) => p3 !== profileName
   );
   const sharedSkills = /* @__PURE__ */ new Set();
   const sharedAgents = /* @__PURE__ */ new Set();
   const sharedRules = /* @__PURE__ */ new Set();
   for (const rp of remainingProfiles) {
     const rpPath = path15.join(root, "profiles", `${rp}.yaml`);
-    if (!fs12.existsSync(rpPath)) continue;
+    if (!fs13.existsSync(rpPath)) continue;
     const rpDef = parseProfile(rpPath);
     rpDef.skills.forEach((s) => sharedSkills.add(s));
     rpDef.agents.forEach((a) => sharedAgents.add(a));
@@ -2162,8 +2203,8 @@ function removeProfile(root, target, profileName, manifest) {
     if (sharedSkills.has(skill)) continue;
     if (CORE_SKILLS.includes(skill)) continue;
     const skillDir = path15.join(target, ".claude", "skills", skill);
-    if (fs12.existsSync(skillDir)) {
-      fs12.rmSync(skillDir, { recursive: true, force: true });
+    if (fs13.existsSync(skillDir)) {
+      fs13.rmSync(skillDir, { recursive: true, force: true });
       removedSkills.push(skill);
     }
     manifest.installed_skills = manifest.installed_skills.filter(
@@ -2187,8 +2228,8 @@ function removeProfile(root, target, profileName, manifest) {
   ]) {
     if (sharedRules.has(rule)) continue;
     const ruleFile = path15.join(target, ".claude", "rules", `${rule}.md`);
-    if (fs12.existsSync(ruleFile)) {
-      fs12.rmSync(ruleFile);
+    if (fs13.existsSync(ruleFile)) {
+      fs13.rmSync(ruleFile);
     }
     manifest.installed_rules = manifest.installed_rules.filter(
       (r) => r !== rule
@@ -2196,27 +2237,27 @@ function removeProfile(root, target, profileName, manifest) {
   }
   if (profileName === "statusline") {
     const statuslineFile = path15.join(target, ".claude", "statusline.sh");
-    if (fs12.existsSync(statuslineFile)) {
-      fs12.rmSync(statuslineFile);
+    if (fs13.existsSync(statuslineFile)) {
+      fs13.rmSync(statuslineFile);
     }
     removeStatuslineFromSettings(path15.join(target, ".claude"));
   }
   manifest.profiles = remainingProfiles;
-  manifest.profile_command = remainingProfiles.filter((p2) => p2 !== "core").join("+");
+  manifest.profile_command = remainingProfiles.filter((p3) => p3 !== "core").join("+");
   return { removed: true, skills: removedSkills, agents: removedAgents };
 }
 function removeStatuslineFromSettings(claudeDir) {
   const settingsPath = path15.join(claudeDir, "settings.json");
-  if (!fs12.existsSync(settingsPath)) return;
-  const settings = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
+  if (!fs13.existsSync(settingsPath)) return;
+  const settings = JSON.parse(fs13.readFileSync(settingsPath, "utf-8"));
   if (settings.statusLine) {
     delete settings.statusLine;
-    fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    fs13.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   }
 }
 
 // src/commands/list.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import path16 from "path";
 import chalk5 from "chalk";
 async function listCommand() {
@@ -2232,15 +2273,15 @@ async function listCommand() {
   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]") : "";
+    for (const p3 of group.profiles) {
+      const tag = manifest?.profiles.includes(p3.name) ? chalk5.green(" [installed]") : "";
       console.log(
-        `  ${chalk5.green(p2.name.padEnd(20))} ${p2.description}${tag}`
+        `  ${chalk5.green(p3.name.padEnd(20))} ${p3.description}${tag}`
       );
     }
     console.log();
   }
-  if (fs13.existsSync(skillsDir)) {
+  if (fs14.existsSync(skillsDir)) {
     const allSkills = listSkills(skillsDir).map((s) => s.name);
     console.log(chalk5.bold(`
 === Skills (${allSkills.length}) ===
@@ -2271,7 +2312,7 @@ async function statusCommand() {
     console.log(chalk6.dim("Run `npx claude-code-arcane install <profile>` to install."));
     return;
   }
-  const profiles = manifest.profiles.filter((p2) => p2 !== "core");
+  const profiles = manifest.profiles.filter((p3) => p3 !== "core");
   console.log(chalk6.bold("\n=== Arcane Status ===\n"));
   console.log(`  Profiles:  ${chalk6.cyan(profiles.join(" + "))}`);
   console.log(`  Installed: ${manifest.installed_at}`);
@@ -2307,20 +2348,23 @@ async function statusCommand() {
 }
 
 // src/commands/update.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import path17 from "path";
 import os3 from "os";
 import chalk7 from "chalk";
 
 // src/self-update.ts
 import { spawnSync } from "child_process";
-var PACKAGE_NAME = "claude-code-arcane";
+var PACKAGE_NAME2 = "claude-code-arcane";
 function isGloballyInstalled() {
   const root = getPackageRoot().replace(/\\/g, "/");
   if (root.includes("/_npx/")) return false;
   if (!root.includes("/node_modules/")) return false;
   return true;
 }
+function cliInvocation() {
+  return isGloballyInstalled() ? "arcane" : `npx ${PACKAGE_NAME2}`;
+}
 async function selfUpdateNpm(opts = {}) {
   const fromVersion = safeVersion();
   if (opts.selfUpdate === false) {
@@ -2349,7 +2393,7 @@ async function selfUpdateNpm(opts = {}) {
   return { updated: false, skipped: false, reason, fromVersion };
 }
 function npmInstallCommand(platform = process.platform) {
-  const args = ["install", "-g", `${PACKAGE_NAME}@latest`];
+  const args = ["install", "-g", `${PACKAGE_NAME2}@latest`];
   if (platform === "win32") {
     return { command: ["npm", ...args].join(" "), args: [], shell: true };
   }
@@ -2385,17 +2429,22 @@ async function updateCommand(opts) {
     }
   }
   const cwd = process.cwd();
-  if (fs14.existsSync(manifestPath(cwd))) {
+  if (fs15.existsSync(manifestPath(cwd))) {
     registerInstallation(cwd);
   }
   const targets = pruneRegistry().map((e) => e.path);
   const globalTarget = os3.homedir();
-  if (!process.env.VITEST && fs14.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
+  if (!process.env.VITEST && fs15.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
     targets.push(globalTarget);
   }
   if (targets.length === 0) {
     if (!opts.quiet) {
-      console.log(chalk7.red("\nNo Arcane installations found. Run 'arcane install' first."));
+      console.log(
+        chalk7.red(
+          `
+No Arcane installations found. Run \`${cliInvocation()} install\` first.`
+        )
+      );
     }
     return;
   }
@@ -2438,7 +2487,11 @@ async function updateTarget(target, opts, sharedSource) {
   const manifest = readManifest(target);
   if (!manifest) {
     if (!opts.quiet) {
-      console.log(chalk7.red("No Arcane installation found. Run 'arcane install' first."));
+      console.log(
+        chalk7.red(
+          `No Arcane installation found. Run \`${cliInvocation()} install\` first.`
+        )
+      );
     }
     return { target, status: "no-manifest", updated: 0, skipped: 0, removed: 0 };
   }
@@ -2770,7 +2823,7 @@ function applyUpdates(items, root, claudeDir, merged, force) {
 function syncUnhashedFiles(root, claudeDir, merged, dryRun) {
   const targets = [];
   const statuslineDst = path17.join(claudeDir, "statusline.sh");
-  if (merged.loaded.includes("statusline") || fs14.existsSync(statuslineDst)) {
+  if (merged.loaded.includes("statusline") || fs15.existsSync(statuslineDst)) {
     targets.push({
       src: path17.join(root, "hooks", "statusline.sh"),
       dst: statuslineDst,
@@ -2795,10 +2848,10 @@ function syncUnhashedFiles(root, claudeDir, merged, dryRun) {
   }
   if (merged.rules.gamedev.length > 0) {
     const templatesSrc = path17.join(root, "templates", "gamedev");
-    if (fs14.existsSync(templatesSrc)) {
-      for (const rel of fs14.readdirSync(templatesSrc, { recursive: true })) {
+    if (fs15.existsSync(templatesSrc)) {
+      for (const rel of fs15.readdirSync(templatesSrc, { recursive: true })) {
         const src = path17.join(templatesSrc, rel);
-        if (!fs14.statSync(src).isFile()) continue;
+        if (!fs15.statSync(src).isFile()) continue;
         targets.push({
           src,
           dst: path17.join(claudeDir, "skills", "_templates", rel),
@@ -2809,35 +2862,42 @@ function syncUnhashedFiles(root, claudeDir, merged, dryRun) {
   }
   const changed = [];
   for (const t of targets) {
-    if (!fs14.existsSync(t.src)) continue;
-    const src = fs14.readFileSync(t.src);
-    if (fs14.existsSync(t.dst) && src.equals(fs14.readFileSync(t.dst))) continue;
+    if (!fs15.existsSync(t.src)) continue;
+    const src = fs15.readFileSync(t.src);
+    if (fs15.existsSync(t.dst) && src.equals(fs15.readFileSync(t.dst))) continue;
     changed.push(t.label);
     if (dryRun) continue;
-    if (fs14.existsSync(t.dst)) {
+    if (fs15.existsSync(t.dst)) {
       const bak = `${t.dst}.bak`;
-      if (fs14.existsSync(bak)) fs14.rmSync(bak, { force: true });
-      fs14.renameSync(t.dst, bak);
+      if (fs15.existsSync(bak)) fs15.rmSync(bak, { force: true });
+      fs15.renameSync(t.dst, bak);
     }
-    fs14.mkdirSync(path17.dirname(t.dst), { recursive: true });
-    fs14.copyFileSync(t.src, t.dst);
+    fs15.mkdirSync(path17.dirname(t.dst), { recursive: true });
+    fs15.copyFileSync(t.src, t.dst);
   }
-  const activeStyle = merged.output_styles[0];
-  if (activeStyle) {
-    const settingsPath = path17.join(claudeDir, "settings.json");
-    if (fs14.existsSync(settingsPath)) {
-      try {
-        const settings = JSON.parse(fs14.readFileSync(settingsPath, "utf-8"));
-        if (settings.outputStyle !== activeStyle) {
-          changed.push(`settings.json (outputStyle: ${activeStyle})`);
-          if (!dryRun) {
-            settings.outputStyle = activeStyle;
-            fs14.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  const settingsPath = path17.join(claudeDir, "settings.json");
+  if (fs15.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs15.readFileSync(settingsPath, "utf-8"));
+      let dirty = false;
+      const activeStyle = merged.output_styles[0];
+      if (activeStyle && settings.outputStyle !== activeStyle) {
+        changed.push(`settings.json (outputStyle: ${activeStyle})`);
+        settings.outputStyle = activeStyle;
+        dirty = true;
+      }
+      const wanted = statuslineCommand(path17.dirname(claudeDir));
+      const current = settings.statusLine;
+      if (wanted !== RELATIVE_STATUSLINE_COMMAND && current && current.command !== wanted) {
+        changed.push("settings.json (statusLine path)");
+        settings.statusLine = { ...current, command: wanted };
+        dirty = true;
+      }
+      if (dirty && !dryRun) {
+        fs15.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
-          }
-        }
-      } catch {
       }
+    } catch {
     }
   }
   return changed;
@@ -2845,29 +2905,29 @@ function syncUnhashedFiles(root, claudeDir, merged, dryRun) {
 function applyItem(item, root, claudeDir) {
   const src = getSourcePath(item, root);
   const dst = getInstalledPath(item, claudeDir);
-  if (!src || !fs14.existsSync(src)) return;
+  if (!src || !fs15.existsSync(src)) return;
   if (item.type === "skill" || item.type === "agent") {
-    if (fs14.existsSync(dst)) {
-      fs14.rmSync(dst, { recursive: true, force: true });
+    if (fs15.existsSync(dst)) {
+      fs15.rmSync(dst, { recursive: true, force: true });
     }
     copyDirSync(src, dst);
   } else {
     const dir = path17.dirname(dst);
-    if (!fs14.existsSync(dir)) {
-      fs14.mkdirSync(dir, { recursive: true });
+    if (!fs15.existsSync(dir)) {
+      fs15.mkdirSync(dir, { recursive: true });
     }
-    fs14.copyFileSync(src, dst);
+    fs15.copyFileSync(src, dst);
   }
 }
 function quarantineItem(item, claudeDir) {
   const installed = getInstalledPath(item, claudeDir);
-  if (!fs14.existsSync(installed)) return;
+  if (!fs15.existsSync(installed)) return;
   const quarantine = path17.join(claudeDir, TRASH_DIR, `${item.type}s`, item.name);
   ensureDir(path17.dirname(quarantine));
-  if (fs14.existsSync(quarantine)) {
-    fs14.rmSync(quarantine, { recursive: true, force: true });
+  if (fs15.existsSync(quarantine)) {
+    fs15.rmSync(quarantine, { recursive: true, force: true });
   }
-  fs14.renameSync(installed, quarantine);
+  fs15.renameSync(installed, quarantine);
 }
 function getSourcePath(item, root) {
   switch (item.type) {
@@ -2875,7 +2935,7 @@ function getSourcePath(item, root) {
       return path17.join(root, "skills", item.name);
     case "rule": {
       const direct = path17.join(root, "rules", item.name);
-      if (fs14.existsSync(direct)) return direct;
+      if (fs15.existsSync(direct)) return direct;
       return path17.join(root, "rules", "gamedev", item.name);
     }
     case "agent":
@@ -2930,7 +2990,7 @@ async function cleanCommand(opts) {
 }
 
 // src/commands/worktree.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import path18 from "path";
 import { execSync as execSync2 } from "child_process";
 import chalk9 from "chalk";
@@ -2943,7 +3003,7 @@ async function worktreeCommand(branch, opts) {
   }
   const repoRoot = wtInfo.isWorktree ? wtInfo.mainWorktreePath : cwd;
   const worktreePath = opts.path ? path18.resolve(opts.path) : defaultWorktreePath(repoRoot, branch);
-  if (fs15.existsSync(worktreePath)) {
+  if (fs16.existsSync(worktreePath)) {
     console.error(
       chalk9.red(`Path already exists: ${worktreePath}`)
     );
@@ -3032,7 +3092,7 @@ async function worktreeCommand(branch, opts) {
       "skills",
       "worktree-isolation"
     );
-    if (fs15.existsSync(isolateScript)) {
+    if (fs16.existsSync(isolateScript)) {
       console.log("  Applying worktree isolation...");
       try {
         execSync2(
@@ -3067,7 +3127,7 @@ async function worktreeCommand(branch, opts) {
 }
 
 // src/commands/global.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import path19 from "path";
 import os4 from "os";
 import chalk10 from "chalk";
@@ -3087,7 +3147,7 @@ async function globalCommand(opts) {
 }
 function showStatus() {
   console.log(chalk10.bold("\n=== Arcane Global Status ===\n"));
-  const hasScripts = fs16.existsSync(
+  const hasScripts = fs17.existsSync(
     path19.join(SCRIPTS_DIR, "apply.py")
   );
   console.log(
@@ -3112,26 +3172,26 @@ function installGlobal() {
     "worktree-isolation",
     "scripts"
   );
-  if (!fs16.existsSync(scriptsSrc)) {
+  if (!fs17.existsSync(scriptsSrc)) {
     console.error(
       chalk10.red("  worktree-isolation scripts not found in package.")
     );
     process.exit(1);
   }
-  fs16.mkdirSync(SCRIPTS_DIR, { recursive: true });
+  fs17.mkdirSync(SCRIPTS_DIR, { recursive: true });
   for (const file of ["apply.py", "lib.py"]) {
     const src = path19.join(scriptsSrc, file);
     const dst = path19.join(SCRIPTS_DIR, file);
-    if (!fs16.existsSync(src)) {
+    if (!fs17.existsSync(src)) {
       console.warn(chalk10.yellow(`  WARN: ${file} not found, skipping`));
       continue;
     }
-    if (fs16.existsSync(dst) && fs16.readFileSync(src).equals(fs16.readFileSync(dst))) {
+    if (fs17.existsSync(dst) && fs17.readFileSync(src).equals(fs17.readFileSync(dst))) {
       console.log(chalk10.dim(`  [skip] ${file} (already up-to-date)`));
     } else {
-      fs16.copyFileSync(src, dst);
+      fs17.copyFileSync(src, dst);
       if (process.platform !== "win32") {
-        fs16.chmodSync(dst, 493);
+        fs17.chmodSync(dst, 493);
       }
       console.log(chalk10.green(`  [ok] ${file} -> ${SCRIPTS_DIR}`));
     }
@@ -3155,8 +3215,8 @@ function installGlobal() {
 }
 function removeGlobal() {
   console.log(chalk10.bold("\nRemoving Arcane global hooks...\n"));
-  if (fs16.existsSync(SCRIPTS_DIR)) {
-    fs16.rmSync(SCRIPTS_DIR, { recursive: true, force: true });
+  if (fs17.existsSync(SCRIPTS_DIR)) {
+    fs17.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"));
@@ -3170,16 +3230,16 @@ function removeGlobal() {
   console.log(chalk10.bold.green("\n  Global hooks removed.\n"));
 }
 function readSettings() {
-  if (!fs16.existsSync(SETTINGS_PATH)) return {};
+  if (!fs17.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs16.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs17.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  fs16.mkdirSync(path19.dirname(SETTINGS_PATH), { recursive: true });
-  fs16.writeFileSync(
+  fs17.mkdirSync(path19.dirname(SETTINGS_PATH), { recursive: true });
+  fs17.writeFileSync(
     SETTINGS_PATH,
     JSON.stringify(settings, null, 2) + "\n",
     "utf-8"
@@ -3236,7 +3296,7 @@ function removeHookFromSettings() {
 }
 
 // src/update-check.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import path20 from "path";
 import chalk11 from "chalk";
 function checkFile() {
@@ -3246,7 +3306,7 @@ var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 var GITHUB_OWNER2 = "SebastianLuser";
 var GITHUB_REPO2 = "Claude-Code-Arcane";
 var GITHUB_BRANCH2 = "main";
-var PACKAGE_NAME2 = "claude-code-arcane";
+var PACKAGE_NAME3 = "claude-code-arcane";
 var SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
 function compareSemver(a, b) {
   const release = (v) => v.trim().replace(/^v/, "").split(/[-+]/)[0];
@@ -3315,7 +3375,7 @@ function printUpdateNotice(result) {
   Arcane CLI update: ${result.cli_version} \u2192 ${result.latest_cli_version}`
       )
     );
-    const how = isGloballyInstalled() ? `  Run: npm install -g ${PACKAGE_NAME2}@latest` : `  You are on an older CLI. Latest: ${PACKAGE_NAME2}@${result.latest_cli_version}`;
+    const how = isGloballyInstalled() ? `  Run: npm install -g ${PACKAGE_NAME3}@latest` : `  You are on an older CLI. Latest: ${PACKAGE_NAME3}@${result.latest_cli_version}`;
     console.log(chalk11.dim(how));
   }
   if (result.content_update_available ?? true) {
@@ -3325,7 +3385,9 @@ function printUpdateNotice(result) {
   Arcane content update: ${result.local_version} \u2192 ${result.remote_sha}`
       )
     );
-    console.log(chalk11.dim("  Run: arcane update (--dry-run to preview)"));
+    console.log(
+      chalk11.dim(`  Run: ${cliInvocation()} update (--dry-run to preview)`)
+    );
   }
   console.log("");
 }
@@ -3351,7 +3413,7 @@ async function getLatestCommitSha() {
 async function getLatestNpmVersion() {
   try {
     const response = await fetch(
-      `https://registry.npmjs.org/${PACKAGE_NAME2}/latest`,
+      `https://registry.npmjs.org/${PACKAGE_NAME3}/latest`,
       {
         headers: { "User-Agent": "arcane-cli", Accept: "application/json" },
         signal: AbortSignal.timeout(5e3)
@@ -3367,8 +3429,8 @@ async function getLatestNpmVersion() {
 function readCachedCheck() {
   try {
     const file = checkFile();
-    if (!fs17.existsSync(file)) return null;
-    return JSON.parse(fs17.readFileSync(file, "utf-8"));
+    if (!fs18.existsSync(file)) return null;
+    return JSON.parse(fs18.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
@@ -3377,10 +3439,10 @@ function writeCachedCheck(result) {
   try {
     const file = checkFile();
     const dir = path20.dirname(file);
-    if (!fs17.existsSync(dir)) {
-      fs17.mkdirSync(dir, { recursive: true });
+    if (!fs18.existsSync(dir)) {
+      fs18.mkdirSync(dir, { recursive: true });
     }
-    fs17.writeFileSync(file, JSON.stringify(result, null, 2) + "\n");
+    fs18.writeFileSync(file, JSON.stringify(result, null, 2) + "\n");
   } catch {
   }
 }

package/hooks/check-update.sh

@@ -7,6 +7,16 @@ CHECK_FILE="$HOME/.arcane/last-check.json"
 CHECK_INTERVAL=14400  # 4 hours in seconds
 GITHUB_API="https://api.github.com/repos/SebastianLuser/Claude-Code-Arcane/commits/main"
 
+# `arcane` is the bin name, so it only exists on PATH after `npm i -g`. The
+# README installs with npx, so most projects running this hook have no `arcane`
+# to run: printing it hands them "'arcane' is not recognized" instead of an
+# update. Unlike the CLI, a hook can test the real thing rather than infer it.
+if command -v arcane &>/dev/null; then
+  ARCANE_CMD="arcane"
+else
+  ARCANE_CMD="npx claude-code-arcane"
+fi
+
 main() {
   if [ ! -f ".claude/arcane-manifest.json" ]; then
     exit 0
@@ -34,7 +44,7 @@ except:
 
       case "$LAST_CHECK" in
         UPDATE_AVAILABLE)
-          echo "Arcane update available. Run: arcane update"
+          echo "Arcane update available. Run: $ARCANE_CMD update"
           exit 0
           ;;
         UP_TO_DATE)
@@ -61,10 +71,18 @@ except:
     print('unknown')
 " 2>/dev/null)
 
+  # Parity with isContentUpdateAvailable() in src/update-check.ts: the remote content
+  # identity is a commit SHA, so only a SHA-shaped local version can be compared against
+  # it. A bundled install — which is every `npx claude-code-arcane install` — records a
+  # semver instead, and "2.9.6" never equals a SHA. The CLI got this guard; the hook did
+  # not, so it announced an update on every single session no matter how current the
+  # install was, and pointed at a command npx users do not have.
   UPDATE_AVAILABLE="false"
-  if [ "$LOCAL_VERSION" != "$REMOTE_SHA" ] && ! echo "$REMOTE_SHA" | grep -q "^$LOCAL_VERSION"; then
+  if ! echo "$LOCAL_VERSION" | grep -qiE '^[0-9a-f]{7,40}$'; then
+    UPDATE_AVAILABLE="false"
+  elif [ "$LOCAL_VERSION" != "$REMOTE_SHA" ] && ! echo "$REMOTE_SHA" | grep -q "^$LOCAL_VERSION"; then
     UPDATE_AVAILABLE="true"
-    echo "Arcane update available: $LOCAL_VERSION → $REMOTE_SHA. Run: arcane update"
+    echo "Arcane update available: $LOCAL_VERSION → $REMOTE_SHA. Run: $ARCANE_CMD update"
   fi
 
   mkdir -p "$HOME/.arcane" 2>/dev/null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-arcane",
-  "version": "2.9.6",
+  "version": "2.9.8",
   "description": "Skills, agents, hooks and rules for Claude Code — installable via npx claude-code-arcane",
   "type": "module",
   "bin": {

package/profiles/core.yaml

@@ -57,7 +57,6 @@ hooks:
   - session-stop.sh
   - log-agent.sh
   - log-agent-stop.sh
-  - statusline.sh
 
 permissions:
   allow:

package/skills/arcane-add/SKILL.md

@@ -40,7 +40,7 @@ The CLI does the same thing interactively: `arcane add` with no args opens the w
 ## Steps
 
 1. Read `.claude/arcane-manifest.json` to find the `source` path
-2. If no manifest, error: "Run `arcane install` first"
+2. If no manifest, error: "Run `npx claude-code-arcane install` first"
 3. For each argument:
    - If it starts with `+`, it's a profile name:
      - Read `profiles/<name>.yaml` from source

package/skills/arcane-clean/SKILL.md

@@ -36,10 +36,33 @@ This will remove:
    - Delete `.claude/docs/` directory
    - Delete `.claude/statusline.sh`
    - Delete `.claude/arcane-manifest.json`
-6. Report: "Arcane removed from project. Run `arcane install` to reinstall."
+6. Report what went, what stayed, and how to come back:
+
+```
+Removed Arcane from project:
+  [ok] 94 skills
+  [ok] 8 rules
+  [ok] 4 agent dirs
+  [ok] hooks/, settings.json, arcane-manifest.json
+
+Preserved (not installed by Arcane):
+  CLAUDE.md, settings.local.json
+
+Run `npx claude-code-arcane install <profile>` to reinstall.
+COMPLETE
+```
 
 ## Safety
 
 - ALWAYS ask for confirmation before deleting
 - If `.claude/` contains files NOT from Arcane (e.g., CLAUDE.md, user configs), preserve them
 - Only delete directories and files that Arcane created (listed in manifest or known paths)
+
+## Next step
+
+This removes **everything**. If the goal was narrower, one of these is the right tool instead:
+
+- `/arcane-remove +profile` — drop one profile and only the assets exclusive to it
+- `/arcane-remove <skill>` — drop individual skills
+- `/arcane-status` — check what is installed before deciding
+- `npx claude-code-arcane install <profile>` — reinstall with a different combination