claude-code-arcane 1.0.0

package/dist/cli.js

@@ -0,0 +1,2352 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/install.ts
+import path9 from "path";
+import chalk from "chalk";
+
+// src/profiles.ts
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+function parseProfile(filePath) {
+  const raw = yaml.load(fs.readFileSync(filePath, "utf-8"));
+  const rules = raw.rules ?? {};
+  const perms = raw.permissions ?? {};
+  return {
+    name: String(raw.name ?? path.basename(filePath, ".yaml")),
+    description: String(raw.description ?? ""),
+    type: raw.type ?? "addon",
+    skills: raw.skills ?? [],
+    rules: {
+      universal: rules.universal ?? [],
+      gamedev: rules.gamedev ?? []
+    },
+    agents: raw.agents ?? [],
+    hooks: raw.hooks ?? [],
+    permissions: {
+      allow: perms.allow ?? [],
+      deny: perms.deny ?? []
+    }
+  };
+}
+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));
+}
+function mergeProfiles(profilesDir, profileNames) {
+  const namesToLoad = ["core", ...profileNames];
+  const loaded = [];
+  const seenSkills = /* @__PURE__ */ new Set();
+  const seenRulesUniv = /* @__PURE__ */ new Set();
+  const seenRulesGamedev = /* @__PURE__ */ new Set();
+  const seenAgents = /* @__PURE__ */ new Set();
+  const seenHooks = /* @__PURE__ */ new Set();
+  const allPermAllow = [];
+  const allPermDeny = [];
+  const skills = [];
+  const rulesUniv = [];
+  const rulesGamedev = [];
+  const agents = [];
+  const hooks = [];
+  for (const name of namesToLoad) {
+    const filePath = path.join(profilesDir, `${name}.yaml`);
+    if (!fs.existsSync(filePath)) {
+      console.warn(`  WARN: Profile '${name}.yaml' not found, skipping`);
+      continue;
+    }
+    const profile = parseProfile(filePath);
+    loaded.push(name);
+    for (const s of profile.skills) {
+      if (!seenSkills.has(s)) {
+        seenSkills.add(s);
+        skills.push(s);
+      }
+    }
+    for (const r of profile.rules.universal) {
+      if (!seenRulesUniv.has(r)) {
+        seenRulesUniv.add(r);
+        rulesUniv.push(r);
+      }
+    }
+    for (const r of profile.rules.gamedev) {
+      if (!seenRulesGamedev.has(r)) {
+        seenRulesGamedev.add(r);
+        rulesGamedev.push(r);
+      }
+    }
+    for (const a of profile.agents) {
+      if (!seenAgents.has(a)) {
+        seenAgents.add(a);
+        agents.push(a);
+      }
+    }
+    for (const h of profile.hooks) {
+      if (!seenHooks.has(h)) {
+        seenHooks.add(h);
+        hooks.push(h);
+      }
+    }
+    allPermAllow.push(...profile.permissions.allow);
+    allPermDeny.push(...profile.permissions.deny);
+  }
+  return {
+    loaded,
+    skills,
+    rules: { universal: rulesUniv, gamedev: rulesGamedev },
+    agents,
+    hooks,
+    permissions: {
+      allow: [...new Set(allPermAllow)],
+      deny: [...new Set(allPermDeny)]
+    }
+  };
+}
+
+// src/installer.ts
+import fs5 from "fs";
+import path6 from "path";
+
+// src/utils.ts
+import { fileURLToPath } from "url";
+import path2 from "path";
+import fs2 from "fs";
+function getPackageRoot() {
+  const thisFile = fileURLToPath(import.meta.url);
+  return path2.resolve(path2.dirname(thisFile), "..");
+}
+function copyDirSync(src, dest) {
+  fs2.mkdirSync(dest, { recursive: true });
+  for (const entry of fs2.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs2.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function ensureDir(dir) {
+  fs2.mkdirSync(dir, { recursive: true });
+}
+function fileExists(p) {
+  return fs2.existsSync(p);
+}
+function readJsonSync(p) {
+  return JSON.parse(fs2.readFileSync(p, "utf-8"));
+}
+function writeJsonSync(p, data) {
+  fs2.writeFileSync(p, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function isSymlinkOrJunction(p) {
+  try {
+    return fs2.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function getPackageVersion() {
+  const pkgPath = path2.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 });
+  }
+}
+
+// src/manifest.ts
+import path3 from "path";
+var MANIFEST_FILE = "arcane-manifest.json";
+function manifestPath(target) {
+  return path3.join(target, ".claude", MANIFEST_FILE);
+}
+function readManifest(target) {
+  const p = manifestPath(target);
+  if (!fileExists(p)) return null;
+  return readJsonSync(p);
+}
+function writeManifest(target, merged, profileCommand, packageRoot, worktreeOrOpts) {
+  let opts = {};
+  if (worktreeOrOpts) {
+    if ("is_worktree" in worktreeOrOpts) {
+      opts = { worktree: worktreeOrOpts };
+    } else {
+      opts = worktreeOrOpts;
+    }
+  }
+  const version = getPackageVersion();
+  const manifest = {
+    arcane_version: version,
+    cli: "npm",
+    profile_command: profileCommand,
+    profiles: merged.loaded,
+    installed_at: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+    total_skills: merged.skills.length,
+    total_rules: merged.rules.universal.length + merged.rules.gamedev.length,
+    installed_skills: merged.skills,
+    installed_rules: [
+      ...merged.rules.universal,
+      ...merged.rules.gamedev
+    ],
+    installed_agents: merged.agents,
+    source: packageRoot,
+    source_version: version
+  };
+  if (opts.worktree) {
+    manifest.worktree = opts.worktree;
+  }
+  if (opts.contentHashes) {
+    manifest.content_hashes = opts.contentHashes;
+  }
+  if (opts.sourceType) {
+    manifest.source_type = opts.sourceType;
+  }
+  writeJsonSync(manifestPath(target), manifest);
+}
+function updateManifestFields(target, updates) {
+  const manifest = readManifest(target);
+  if (!manifest) return;
+  Object.assign(manifest, updates);
+  writeJsonSync(manifestPath(target), manifest);
+}
+
+// src/worktree.ts
+import { execSync } from "child_process";
+import fs3 from "fs";
+import path4 from "path";
+function getWorktreeInfo(target) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      cwd: target,
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+  } catch {
+    return null;
+  }
+  const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+    cwd: target,
+    encoding: "utf-8",
+    stdio: "pipe"
+  }).trim();
+  const gitDir = execSync("git rev-parse --git-dir", {
+    cwd: target,
+    encoding: "utf-8",
+    stdio: "pipe"
+  }).trim();
+  const resolvedCommon = path4.resolve(target, gitCommonDir);
+  const resolvedGit = path4.resolve(target, gitDir);
+  const isWorktree = resolvedCommon !== resolvedGit;
+  const mainWorktreePath = isWorktree ? path4.resolve(resolvedCommon, "..") : target;
+  let currentBranch = "HEAD";
+  try {
+    currentBranch = execSync("git branch --show-current", {
+      cwd: target,
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+  } catch {
+  }
+  const allWorktrees = parseWorktreeList(target);
+  return {
+    isWorktree,
+    mainWorktreePath,
+    currentBranch,
+    worktreeId: path4.basename(target),
+    allWorktrees
+  };
+}
+function parseWorktreeList(cwd) {
+  try {
+    const raw = execSync("git worktree list --porcelain", {
+      cwd,
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    const entries = [];
+    let current = null;
+    for (const line of raw.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        if (current) entries.push(current);
+        current = {
+          path: line.slice("worktree ".length),
+          branch: "",
+          isMain: false
+        };
+      } else if (line.startsWith("branch ") && current) {
+        current.branch = line.slice("branch ".length).replace("refs/heads/", "");
+      } else if (line === "" && current) {
+        entries.push(current);
+        current = null;
+      }
+    }
+    if (current) entries.push(current);
+    if (entries.length > 0) entries[0].isMain = true;
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function findMainArcaneInstall(mainPath) {
+  return fs3.existsSync(
+    path4.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 type = process.platform === "win32" ? "junction" : "dir";
+      fs3.symlinkSync(src, dest, type);
+      return "linked";
+    } catch {
+    }
+  }
+  copyDirSync(src, dest);
+  return "copied";
+}
+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 sanitized = sanitizeBranchForPath(branch);
+  return path4.resolve(repoRoot, "..", `${repoName}-${sanitized}`);
+}
+function createGitWorktree(repoRoot, worktreePath, branch, base) {
+  const branchExists = checkBranchExists(repoRoot, branch);
+  if (branchExists) {
+    execSync(`git worktree add "${worktreePath}" "${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+  } else {
+    const baseBranch = base ?? "HEAD";
+    execSync(
+      `git worktree add -b "${branch}" "${worktreePath}" "${baseBranch}"`,
+      {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      }
+    );
+  }
+}
+function checkBranchExists(cwd, branch) {
+  try {
+    execSync(`git show-ref --verify refs/heads/${branch}`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager(dir) {
+  const managers = [
+    { lockfile: "pnpm-lock.yaml", command: "pnpm install" },
+    { lockfile: "bun.lockb", command: "bun install" },
+    { lockfile: "yarn.lock", command: "yarn install" },
+    { lockfile: "package-lock.json", command: "npm install" }
+  ];
+  for (const m of managers) {
+    if (fs3.existsSync(path4.join(dir, m.lockfile))) return m;
+  }
+  if (fs3.existsSync(path4.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 { createHash } from "crypto";
+function hashFile(filePath) {
+  const content = fs4.readFileSync(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+function hashDirectory(dirPath) {
+  const hashes = {};
+  walkDir(dirPath, dirPath, hashes);
+  return hashes;
+}
+function walkDir(base, current, hashes) {
+  for (const entry of fs4.readdirSync(current, { withFileTypes: true })) {
+    const fullPath = path5.join(current, entry.name);
+    const relPath = path5.relative(base, fullPath).split(path5.sep).join("/");
+    if (entry.isDirectory()) {
+      walkDir(base, fullPath, hashes);
+    } else {
+      hashes[relPath] = hashFile(fullPath);
+    }
+  }
+}
+function computeContentHashes(claudeDir) {
+  const hashes = {
+    skills: {},
+    rules: {},
+    agents: {},
+    hooks: {}
+  };
+  const skillsDir = path5.join(claudeDir, "skills");
+  if (fs4.existsSync(skillsDir)) {
+    for (const entry of fs4.readdirSync(skillsDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        const dirHash = hashDirectory(path5.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 })) {
+      if (!entry.isDirectory()) {
+        hashes.rules[entry.name] = hashFile(path5.join(rulesDir, entry.name));
+      }
+    }
+  }
+  const agentsDir = path5.join(claudeDir, "agents");
+  if (fs4.existsSync(agentsDir)) {
+    for (const entry of fs4.readdirSync(agentsDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        const dirHash = hashDirectory(path5.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 })) {
+      if (!entry.isDirectory()) {
+        hashes.hooks[entry.name] = hashFile(path5.join(hooksDir, entry.name));
+      }
+    }
+  }
+  return hashes;
+}
+function computeSourceHashes(packageRoot, skills, rules, agents) {
+  const hashes = {
+    skills: {},
+    rules: {},
+    agents: {},
+    hooks: {}
+  };
+  for (const skill of skills) {
+    const skillDir = path5.join(packageRoot, "skills", skill);
+    if (fs4.existsSync(skillDir)) {
+      const dirHash = hashDirectory(skillDir);
+      const combined = createHash("sha256").update(JSON.stringify(dirHash)).digest("hex");
+      hashes.skills[skill] = combined;
+    }
+  }
+  for (const rule of rules) {
+    const ruleName = rule.endsWith(".md") ? rule : `${rule}.md`;
+    const rulePath = path5.join(packageRoot, "rules", ruleName);
+    if (fs4.existsSync(rulePath)) {
+      hashes.rules[ruleName] = hashFile(rulePath);
+    } else {
+      const gamedevPath = path5.join(packageRoot, "rules", "gamedev", ruleName);
+      if (fs4.existsSync(gamedevPath)) {
+        hashes.rules[ruleName] = hashFile(gamedevPath);
+      }
+    }
+  }
+  for (const agent of agents) {
+    const agentDir = path5.join(packageRoot, "agents", agent);
+    if (fs4.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 })) {
+      if (!entry.isDirectory()) {
+        hashes.hooks[entry.name] = hashFile(path5.join(hooksDir, entry.name));
+      }
+    }
+  }
+  return hashes;
+}
+
+// src/installer.ts
+var SETTINGS_TEMPLATE = {
+  $schema: "https://json.schemastore.org/claude-code-settings.json",
+  permissions: { allow: [], deny: [] },
+  hooks: {
+    SessionStart: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/session-start.sh",
+            timeout: 10
+          },
+          {
+            type: "command",
+            command: "bash .claude/hooks/detect-division.sh",
+            timeout: 10
+          },
+          {
+            type: "command",
+            command: "bash .claude/hooks/detect-gaps.sh",
+            timeout: 10
+          },
+          {
+            type: "command",
+            command: "bash .claude/hooks/check-update.sh",
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    PreToolUse: [
+      {
+        matcher: "Bash",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/validate-commit.sh",
+            timeout: 15
+          },
+          {
+            type: "command",
+            command: "bash .claude/hooks/validate-push.sh",
+            timeout: 10
+          },
+          {
+            type: "command",
+            command: "bash .claude/hooks/validate-secrets.sh",
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    PostToolUse: [
+      {
+        matcher: "Write|Edit",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/validate-assets.sh",
+            timeout: 10
+          },
+          {
+            type: "command",
+            command: "bash .claude/hooks/validate-skill-change.sh",
+            timeout: 5
+          }
+        ]
+      }
+    ],
+    Notification: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/notify.sh",
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    PreCompact: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/pre-compact.sh",
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    PostCompact: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/post-compact.sh",
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    Stop: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/session-stop.sh",
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    SubagentStart: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/log-agent.sh",
+            timeout: 5
+          }
+        ]
+      }
+    ],
+    SubagentStop: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: "bash .claude/hooks/log-agent-stop.sh",
+            timeout: 5
+          }
+        ]
+      }
+    ]
+  }
+};
+var Installer = class {
+  root;
+  target;
+  claudeDir;
+  merged;
+  dryRun;
+  logs = [];
+  shareFrom;
+  sharedDirs = [];
+  constructor(merged, opts) {
+    this.root = opts.contentRoot ?? getPackageRoot();
+    this.target = opts.target;
+    this.claudeDir = path6.join(opts.target, ".claude");
+    this.merged = merged;
+    this.dryRun = opts.dryRun;
+    this.shareFrom = opts.shareFrom;
+  }
+  log(msg) {
+    this.logs.push(msg);
+    console.log(msg);
+  }
+  run(profileCommand, worktreeMeta) {
+    this.backup();
+    this.createDirs();
+    this.copyHooks();
+    this.copySkills();
+    this.copyRules();
+    this.copyAgents();
+    this.copyDocs();
+    this.generateSettings();
+    if (!this.dryRun) {
+      const wt = worktreeMeta && this.sharedDirs.length > 0 ? { ...worktreeMeta, shared_dirs: this.sharedDirs } : worktreeMeta ? { ...worktreeMeta, shared_dirs: [] } : void 0;
+      const contentHashes = computeContentHashes(this.claudeDir);
+      writeManifest(this.target, this.merged, profileCommand, this.root, {
+        worktree: wt,
+        contentHashes
+      });
+      this.log("  [ok] arcane-manifest.json");
+    } else {
+      this.log("  [dry-run] arcane-manifest.json");
+    }
+    return this.logs;
+  }
+  backup() {
+    if (!fs5.existsSync(this.claudeDir)) return;
+    const backup = path6.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 });
+    }
+    fs5.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));
+    }
+  }
+  get hasStatusline() {
+    return this.merged.loaded.includes("statusline");
+  }
+  copyHooks() {
+    this.log("\nHooks:");
+    const hooksDir = path6.join(this.claudeDir, "hooks");
+    if (this.dryRun) {
+      if (this.shareFrom) {
+        this.log("  [dry-run] hooks/ -> symlink from main worktree");
+      } else {
+        this.log("  [dry-run] hooks/ -> .claude/hooks/");
+      }
+      if (this.hasStatusline) this.log("  [dry-run] statusline.sh");
+      return;
+    }
+    if (this.shareFrom) {
+      const sharedHooks = path6.join(this.shareFrom, ".claude", "hooks");
+      if (fs5.existsSync(sharedHooks)) {
+        const result = linkOrCopyDir(sharedHooks, hooksDir, "symlink");
+        if (result === "linked") {
+          this.sharedDirs.push("hooks");
+          this.log("  [ok] hooks/ (shared via symlink)");
+        } else {
+          this.log("  [ok] hooks/ (copied \u2014 symlink failed)");
+        }
+        this.copyStatusline();
+        return;
+      }
+    }
+    const hooksSrc = path6.join(this.root, "hooks");
+    if (fs5.existsSync(hooksSrc)) {
+      ensureDir(hooksDir);
+      for (const entry of fs5.readdirSync(hooksSrc, { withFileTypes: true })) {
+        if (entry.name === "statusline.sh") continue;
+        const src = path6.join(hooksSrc, entry.name);
+        const dst = path6.join(hooksDir, entry.name);
+        if (entry.isDirectory()) {
+          copyDirSync(src, dst);
+        } else {
+          fs5.copyFileSync(src, dst);
+        }
+      }
+      this.log("  [ok] hooks/");
+    }
+    this.copyStatusline();
+  }
+  copyStatusline() {
+    if (!this.hasStatusline) return;
+    const statusline = path6.join(this.root, "hooks", "statusline.sh");
+    if (fs5.existsSync(statusline)) {
+      fs5.copyFileSync(
+        statusline,
+        path6.join(this.claudeDir, "statusline.sh")
+      );
+      this.log("  [ok] statusline.sh (+statusline addon)");
+    }
+  }
+  copySkills() {
+    this.log("\nSkills:");
+    for (const skill of this.merged.skills) {
+      const src = path6.join(this.root, "skills", skill);
+      if (!fs5.existsSync(src)) {
+        this.log(`  WARN: Skill '${skill}' not found in skills/`);
+        continue;
+      }
+      const dst = path6.join(this.claudeDir, "skills", skill);
+      if (this.dryRun) {
+        this.log(`  [dry-run] ${skill}`);
+      } else {
+        copyDirSync(src, dst);
+        this.log(`  [ok] ${skill}`);
+      }
+    }
+    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");
+        if (this.dryRun) {
+          this.log("  [dry-run] _templates/");
+        } else {
+          copyDirSync(tplSrc, tplDst);
+          this.log("  [ok] _templates/");
+        }
+      }
+    }
+  }
+  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)) {
+        this.log(`  WARN: Rule '${rule}.md' not found`);
+        continue;
+      }
+      if (this.dryRun) {
+        this.log(`  [dry-run] ${rule}.md`);
+      } else {
+        fs5.copyFileSync(
+          src,
+          path6.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)) {
+        this.log(`  WARN: Rule '${rule}.md' not found`);
+        continue;
+      }
+      if (this.dryRun) {
+        this.log(`  [dry-run] ${rule}.md`);
+      } else {
+        fs5.copyFileSync(
+          src,
+          path6.join(this.claudeDir, "rules", `${rule}.md`)
+        );
+        this.log(`  [ok] ${rule}.md`);
+      }
+    }
+  }
+  copyAgents() {
+    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)) {
+        this.log(`  WARN: Agent dir '${agentDir}' not found`);
+        continue;
+      }
+      const dst = path6.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;
+        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;
+    this.log("\nDocs:");
+    if (this.dryRun) {
+      if (this.shareFrom) {
+        this.log("  [dry-run] docs/ -> symlink from main worktree");
+      } else {
+        this.log("  [dry-run] docs/");
+      }
+      return;
+    }
+    if (this.shareFrom) {
+      const sharedDocs = path6.join(this.shareFrom, ".claude", "docs");
+      if (fs5.existsSync(sharedDocs)) {
+        const result = linkOrCopyDir(sharedDocs, docsDir, "symlink");
+        if (result === "linked") {
+          this.sharedDirs.push("docs");
+          this.log("  [ok] docs/ (shared via symlink)");
+        } else {
+          this.log("  [ok] docs/ (copied \u2014 symlink failed)");
+        }
+        return;
+      }
+    }
+    copyDirSync(docsSrc, docsDir);
+    this.log("  [ok] docs/");
+  }
+  generateSettings() {
+    this.log("\nConfig:");
+    const settings = JSON.parse(JSON.stringify(SETTINGS_TEMPLATE));
+    settings.permissions.allow = [...this.merged.permissions.allow];
+    settings.permissions.deny = [...this.merged.permissions.deny];
+    if (this.hasStatusline) {
+      settings.statusLine = {
+        type: "command",
+        command: "bash .claude/statusline.sh"
+      };
+    }
+    if (this.dryRun) {
+      this.log(
+        `  [dry-run] settings.json (${this.merged.permissions.allow.length} allow, ${this.merged.permissions.deny.length} deny)`
+      );
+      return;
+    }
+    const settingsPath = path6.join(this.claudeDir, "settings.json");
+    fs5.writeFileSync(
+      settingsPath,
+      JSON.stringify(settings, null, 2) + "\n",
+      "utf-8"
+    );
+    this.log("  [ok] settings.json");
+  }
+};
+function clean(target) {
+  const claudeDir = path6.join(target, ".claude");
+  const backup = path6.join(target, ".claude.bak");
+  if (!fs5.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 profiles = (data.profiles ?? []).filter(
+      (p) => p !== "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);
+        console.log(`  [ok] Unlinked shared ${dir}/`);
+      }
+    }
+  }
+  for (const sub of ["hooks", "docs", "skills", "agents", "rules"]) {
+    const p = path6.join(claudeDir, sub);
+    safeRemove(p);
+  }
+  const remaining = fs5.readdirSync(claudeDir);
+  for (const f of remaining) {
+    const p = path6.join(claudeDir, f);
+    safeRemove(p);
+  }
+  if (fs5.existsSync(claudeDir)) {
+    fs5.rmSync(claudeDir, { recursive: true, force: true });
+  }
+  if (fs5.existsSync(backup)) {
+    fs5.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 os2 from "os";
+
+// src/cache.ts
+import fs6 from "fs";
+import path7 from "path";
+import os from "os";
+var ARCANE_DIR = path7.join(os.homedir(), ".arcane");
+var CACHE_DIR = path7.join(ARCANE_DIR, "cache");
+function getCachePath(version) {
+  return path7.join(CACHE_DIR, version);
+}
+function isCached(version) {
+  const versionDir = getCachePath(version);
+  return fs6.existsSync(versionDir) && fs6.existsSync(path7.join(versionDir, ".cache-meta.json"));
+}
+function getCachedContentRoot(version) {
+  if (!isCached(version)) return null;
+  return getCachePath(version);
+}
+function storeInCache(version, contentDir) {
+  const versionDir = getCachePath(version);
+  if (fs6.existsSync(versionDir)) {
+    fs6.rmSync(versionDir, { recursive: true, force: true });
+  }
+  fs6.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 meta = {
+    version,
+    cached_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs6.writeFileSync(
+    path7.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");
+    let cachedAt = 0;
+    if (fs6.existsSync(metaPath)) {
+      try {
+        const meta = JSON.parse(fs6.readFileSync(metaPath, "utf-8"));
+        cachedAt = new Date(meta.cached_at).getTime();
+      } catch {
+        cachedAt = 0;
+      }
+    }
+    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 });
+  }
+}
+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);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs6.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/content-source.ts
+var GITHUB_OWNER = "SebastianLuser";
+var GITHUB_REPO = "Claude-Code-Arcane";
+var GITHUB_BRANCH = "main";
+var BundledContentSource = class {
+  type = "bundled";
+  async getContentRoot() {
+    return getPackageRoot();
+  }
+  async isAvailable() {
+    const root = getPackageRoot();
+    return fs7.existsSync(path8.join(root, "skills"));
+  }
+  async getVersion() {
+    return getPackageVersion();
+  }
+};
+var CachedContentSource = class {
+  type = "cache";
+  version;
+  constructor(version) {
+    this.version = version;
+  }
+  async getContentRoot() {
+    const cached = getCachedContentRoot(this.version);
+    if (!cached) throw new Error(`Cache miss for version ${this.version}`);
+    return cached;
+  }
+  async isAvailable() {
+    return isCached(this.version);
+  }
+  async getVersion() {
+    return this.version;
+  }
+};
+var GitHubContentSource = class {
+  type = "github";
+  owner;
+  repo;
+  branch;
+  resolvedVersion = null;
+  constructor(owner = GITHUB_OWNER, repo = GITHUB_REPO, branch = GITHUB_BRANCH) {
+    this.owner = owner;
+    this.repo = repo;
+    this.branch = branch;
+  }
+  async getContentRoot() {
+    const version = await this.getVersion();
+    if (isCached(version)) {
+      return getCachedContentRoot(version);
+    }
+    const tmpDir = fs7.mkdtempSync(path8.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 });
+    }
+  }
+  async isAvailable() {
+    try {
+      const response = await fetch(
+        `https://api.github.com/repos/${this.owner}/${this.repo}/commits/${this.branch}`,
+        {
+          method: "HEAD",
+          headers: { "User-Agent": "arcane-cli" },
+          signal: AbortSignal.timeout(5e3)
+        }
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getVersion() {
+    if (this.resolvedVersion) return this.resolvedVersion;
+    try {
+      const response = await fetch(
+        `https://api.github.com/repos/${this.owner}/${this.repo}/commits/${this.branch}`,
+        {
+          headers: {
+            "User-Agent": "arcane-cli",
+            Accept: "application/vnd.github.v3+json"
+          },
+          signal: AbortSignal.timeout(1e4)
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`GitHub API returned ${response.status}`);
+      }
+      const data = await response.json();
+      this.resolvedVersion = data.sha.substring(0, 12);
+      return this.resolvedVersion;
+    } catch {
+      this.resolvedVersion = `github-${Date.now()}`;
+      return this.resolvedVersion;
+    }
+  }
+  async downloadAndExtract(destDir) {
+    const tarballUrl = `https://api.github.com/repos/${this.owner}/${this.repo}/tarball/${this.branch}`;
+    const response = await fetch(tarballUrl, {
+      headers: {
+        "User-Agent": "arcane-cli",
+        Accept: "application/vnd.github.v3.tarball"
+      },
+      signal: AbortSignal.timeout(6e4),
+      redirect: "follow"
+    });
+    if (!response.ok || !response.body) {
+      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 reader = response.body.getReader();
+    const writable = new WritableStream({
+      write(chunk) {
+        fileStream.write(chunk);
+      },
+      close() {
+        fileStream.end();
+      }
+    });
+    await reader.read().then(async function process2({ done, value }) {
+      if (done) {
+        fileStream.end();
+        return;
+      }
+      fileStream.write(value);
+      return reader.read().then(process2);
+    });
+    await new Promise((resolve) => fileStream.on("finish", resolve));
+    await tar.extract({
+      file: tarballPath,
+      cwd: destDir
+    });
+  }
+  findExtractedRoot(tmpDir) {
+    const entries = fs7.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 tmpDir;
+  }
+};
+async function resolveContentSource(opts = {}) {
+  const envSource = process.env.ARCANE_SOURCE;
+  const preference = envSource ?? opts.source ?? "auto";
+  const log = opts.quiet ? () => {
+  } : console.log;
+  if (preference === "bundled") {
+    return new BundledContentSource();
+  }
+  if (preference === "github" || preference === "auto") {
+    const github = new GitHubContentSource();
+    if (await github.isAvailable()) {
+      const version = await github.getVersion();
+      if (isCached(version)) {
+        if (!opts.quiet) log(`  Source: cache (${version})`);
+        return new CachedContentSource(version);
+      }
+      if (!opts.quiet) log("  Source: github");
+      return github;
+    }
+    if (preference === "github") {
+      throw new Error("GitHub source requested but not available. Check your internet connection.");
+    }
+    const cached = findLatestCache();
+    if (cached) {
+      if (!opts.quiet) log(`  Source: cache (${cached}, offline fallback)`);
+      return new CachedContentSource(cached);
+    }
+    if (!opts.quiet) log("  Source: bundled (offline fallback)");
+    return new BundledContentSource();
+  }
+  return new BundledContentSource();
+}
+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");
+    let cachedAt = 0;
+    if (fs7.existsSync(metaPath)) {
+      try {
+        const meta = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
+        cachedAt = new Date(meta.cached_at).getTime();
+      } catch {
+        cachedAt = 0;
+      }
+    }
+    return { name: e.name, cachedAt };
+  }).sort((a, b) => b.cachedAt - a.cachedAt);
+  return entries.length > 0 ? entries[0].name : null;
+}
+
+// src/commands/install.ts
+async function installCommand(profileExpr, opts) {
+  const source = await resolveContentSource({
+    source: opts.source ?? "auto",
+    quiet: !profileExpr
+  });
+  const root = await source.getContentRoot();
+  const profilesDir = path9.join(root, "profiles");
+  const target = path9.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) {
+      console.log(
+        `    ${chalk.green(("+" + p.name).padEnd(20))} ${p.description}`
+      );
+    }
+    console.log(
+      chalk.dim("\n  Usage: npx arcane install backend-ts+agile+testing\n")
+    );
+    return;
+  }
+  const profileNames = profileExpr.split("+").filter(Boolean);
+  console.log(
+    chalk.bold(`
+Installing profile: ${chalk.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})`));
+    worktreeMeta = {
+      is_worktree: true,
+      main_worktree: wtInfo.mainWorktreePath
+    };
+    if (!shareFrom && findMainArcaneInstall(wtInfo.mainWorktreePath)) {
+      shareFrom = wtInfo.mainWorktreePath;
+      console.log(
+        chalk.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"));
+  const merged = mergeProfiles(profilesDir, profileNames);
+  console.log(`  Profiles loaded: ${merged.loaded.join(", ")}`);
+  console.log(`  Skills: ${merged.skills.length}`);
+  console.log(
+    `  Rules: ${merged.rules.universal.length + merged.rules.gamedev.length}`
+  );
+  console.log(`  Agents: ${merged.agents.length}`);
+  const installer = new Installer(merged, {
+    target,
+    dryRun: opts.dryRun ?? false,
+    force: opts.force ?? false,
+    shareFrom,
+    contentRoot: root
+  });
+  installer.run(profileExpr, worktreeMeta);
+  if (!opts.dryRun) {
+    console.log(chalk.green("\n  Installation complete."));
+  }
+}
+
+// src/commands/add.ts
+import fs8 from "fs";
+import path10 from "path";
+import chalk2 from "chalk";
+async function addCommand(items) {
+  const target = process.cwd();
+  const source = await resolveContentSource({ quiet: true });
+  const root = await source.getContentRoot();
+  const manifest = readManifest(target);
+  if (!manifest) {
+    console.error(
+      chalk2.red(
+        "No arcane-manifest.json found. Run `npx arcane install` first."
+      )
+    );
+    process.exit(1);
+  }
+  const added = [];
+  const skipped = [];
+  for (const item of items) {
+    if (item.startsWith("+")) {
+      const profileName = item.slice(1);
+      const profilePath = path10.join(root, "profiles", `${profileName}.yaml`);
+      if (!fs8.existsSync(profilePath)) {
+        console.error(chalk2.red(`  Profile '${profileName}' not found`));
+        continue;
+      }
+      const profile = parseProfile(profilePath);
+      for (const skill of profile.skills) {
+        const result = addSkill(root, target, skill, manifest.installed_skills);
+        if (result === "added") added.push(skill);
+        else skipped.push(skill);
+      }
+      if (!manifest.profiles.includes(profileName)) {
+        manifest.profiles.push(profileName);
+      }
+    } else {
+      const result = addSkill(root, target, item, manifest.installed_skills);
+      if (result === "added") added.push(item);
+      else skipped.push(item);
+    }
+  }
+  manifest.installed_skills.push(...added);
+  manifest.total_skills = manifest.installed_skills.length;
+  const merged = {
+    loaded: manifest.profiles,
+    skills: manifest.installed_skills,
+    rules: { universal: manifest.installed_rules, gamedev: [] },
+    agents: manifest.installed_agents,
+    hooks: [],
+    permissions: { allow: [], deny: [] }
+  };
+  writeManifest(target, merged, manifest.profile_command, root);
+  console.log(chalk2.bold(`
+Added ${added.length} skills:`));
+  for (const s of added) console.log(chalk2.green(`  [ok] ${s}`));
+  for (const s of skipped)
+    console.log(chalk2.dim(`  [skip] ${s} (already installed)`));
+}
+function addSkill(root, target, skill, installed) {
+  if (installed.includes(skill)) return "skipped";
+  const src = path10.join(root, "skills", skill);
+  if (!fs8.existsSync(src)) {
+    console.error(chalk2.red(`  Skill '${skill}' not found in skills/`));
+    return "skipped";
+  }
+  const dst = path10.join(target, ".claude", "skills", skill);
+  copyDirSync(src, dst);
+  return "added";
+}
+
+// src/commands/remove.ts
+import fs9 from "fs";
+import path11 from "path";
+import chalk3 from "chalk";
+var CORE_SKILLS = [
+  "commit",
+  "create-pr",
+  "changelog",
+  "check",
+  "code-review",
+  "context-prime",
+  "help",
+  "start",
+  "fix-issue",
+  "hotfix",
+  "brainstorm",
+  "scope-check",
+  "reverse-document",
+  "skill-improve",
+  "skill-test",
+  "tech-debt",
+  "arcane-status",
+  "arcane-list",
+  "arcane-add",
+  "arcane-remove",
+  "arcane-clean"
+];
+async function removeCommand(items) {
+  const target = process.cwd();
+  const source = await resolveContentSource({ quiet: true });
+  const root = await source.getContentRoot();
+  const manifest = readManifest(target);
+  if (!manifest) {
+    console.error(
+      chalk3.red(
+        "No arcane-manifest.json found. Run `npx arcane install` first."
+      )
+    );
+    process.exit(1);
+  }
+  const removedSkills = [];
+  const removedAgents = [];
+  const removedProfiles = [];
+  const skipped = [];
+  for (const item of items) {
+    if (item.startsWith("+")) {
+      const profileName = item.slice(1);
+      const result = removeProfile(
+        root,
+        target,
+        profileName,
+        manifest
+      );
+      removedSkills.push(...result.skills);
+      removedAgents.push(...result.agents);
+      if (result.removed) removedProfiles.push(profileName);
+      else skipped.push(item);
+    } else {
+      const result = removeSkill(target, item, manifest);
+      if (result === "removed") removedSkills.push(item);
+      else skipped.push(item);
+    }
+  }
+  manifest.total_skills = manifest.installed_skills.length;
+  manifest.total_rules = manifest.installed_rules.length;
+  const mp = path11.join(target, ".claude", "arcane-manifest.json");
+  writeJsonSync(mp, manifest);
+  const totalRemoved = removedSkills.length + removedAgents.length + removedProfiles.length;
+  console.log(chalk3.bold(`
+Removed ${totalRemoved} items:`));
+  for (const p of removedProfiles)
+    console.log(chalk3.magenta(`  [ok] +${p} (profile)`));
+  for (const s of removedSkills)
+    console.log(chalk3.green(`  [ok] ${s} (skill)`));
+  for (const a of removedAgents)
+    console.log(chalk3.cyan(`  [ok] ${a} (agent dir)`));
+  for (const s of skipped)
+    console.log(chalk3.dim(`  [skip] ${s}`));
+}
+function removeSkill(target, skill, manifest) {
+  if (CORE_SKILLS.includes(skill)) {
+    console.warn(
+      chalk3.yellow(`  WARNING: '${skill}' is a core skill. Skipping.`)
+    );
+    return "skipped";
+  }
+  const skillDir = path11.join(target, ".claude", "skills", skill);
+  if (!fs9.existsSync(skillDir)) return "skipped";
+  fs9.rmSync(skillDir, { recursive: true, force: true });
+  manifest.installed_skills = manifest.installed_skills.filter(
+    (s) => s !== skill
+  );
+  return "removed";
+}
+function removeProfile(root, target, profileName, manifest) {
+  if (profileName === "core") {
+    console.warn(
+      chalk3.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.`)
+    );
+    return { removed: false, skills: [], agents: [] };
+  }
+  const profilePath = path11.join(root, "profiles", `${profileName}.yaml`);
+  if (!fs9.existsSync(profilePath)) {
+    console.warn(
+      chalk3.yellow(`  WARNING: Profile '${profileName}.yaml' not found.`)
+    );
+    return { removed: false, skills: [], agents: [] };
+  }
+  const profile = parseProfile(profilePath);
+  const remainingProfiles = manifest.profiles.filter(
+    (p) => p !== profileName
+  );
+  const sharedSkills = /* @__PURE__ */ new Set();
+  const sharedAgents = /* @__PURE__ */ new Set();
+  const sharedRules = /* @__PURE__ */ new Set();
+  for (const rp of remainingProfiles) {
+    const rpPath = path11.join(root, "profiles", `${rp}.yaml`);
+    if (!fs9.existsSync(rpPath)) continue;
+    const rpDef = parseProfile(rpPath);
+    rpDef.skills.forEach((s) => sharedSkills.add(s));
+    rpDef.agents.forEach((a) => sharedAgents.add(a));
+    rpDef.rules.universal.forEach((r) => sharedRules.add(r));
+    rpDef.rules.gamedev.forEach((r) => sharedRules.add(r));
+  }
+  const removedSkills = [];
+  for (const skill of profile.skills) {
+    if (sharedSkills.has(skill)) continue;
+    if (CORE_SKILLS.includes(skill)) continue;
+    const skillDir = path11.join(target, ".claude", "skills", skill);
+    if (fs9.existsSync(skillDir)) {
+      fs9.rmSync(skillDir, { recursive: true, force: true });
+      removedSkills.push(skill);
+    }
+    manifest.installed_skills = manifest.installed_skills.filter(
+      (s) => s !== skill
+    );
+  }
+  const removedAgents = [];
+  for (const agent of profile.agents) {
+    if (sharedAgents.has(agent)) continue;
+    const agentDir = path11.join(target, ".claude", "agents", agent);
+    if (fs9.existsSync(agentDir)) {
+      fs9.rmSync(agentDir, { recursive: true, force: true });
+      removedAgents.push(agent);
+    }
+    manifest.installed_agents = manifest.installed_agents.filter(
+      (a) => a !== agent
+    );
+  }
+  for (const rule of [
+    ...profile.rules.universal,
+    ...profile.rules.gamedev
+  ]) {
+    if (sharedRules.has(rule)) continue;
+    const ruleFile = path11.join(target, ".claude", "rules", `${rule}.md`);
+    if (fs9.existsSync(ruleFile)) {
+      fs9.rmSync(ruleFile);
+    }
+    manifest.installed_rules = manifest.installed_rules.filter(
+      (r) => r !== rule
+    );
+  }
+  manifest.profiles = remainingProfiles;
+  manifest.profile_command = remainingProfiles.filter((p) => p !== "core").join("+");
+  return { removed: true, skills: removedSkills, agents: removedAgents };
+}
+
+// src/commands/list.ts
+import fs10 from "fs";
+import path12 from "path";
+import chalk4 from "chalk";
+async function listCommand() {
+  const source = await resolveContentSource({ quiet: true });
+  const root = await source.getContentRoot();
+  const profilesDir = path12.join(root, "profiles");
+  const skillsDir = path12.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}`
+    );
+  }
+  if (fs10.existsSync(skillsDir)) {
+    const allSkills = fs10.readdirSync(skillsDir, { withFileTypes: true }).filter(
+      (d) => d.isDirectory() && !d.name.startsWith("_") && fs10.existsSync(path12.join(skillsDir, d.name, "SKILL.md"))
+    ).map((d) => d.name).sort();
+    console.log(chalk4.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("*") : " ";
+        return `${tag} ${s.padEnd(30)}`;
+      });
+      console.log("  " + row.join(""));
+    }
+    if (manifest) {
+      console.log(chalk4.dim("\n  * = installed in current project"));
+    }
+  }
+}
+
+// src/commands/status.ts
+import chalk5 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.")
+    );
+    console.log(chalk5.dim("Run `npx 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(" + "))}`);
+  console.log(`  Installed: ${manifest.installed_at}`);
+  console.log(`  Version:   ${manifest.arcane_version}`);
+  console.log(`  CLI:       ${manifest.cli}`);
+  console.log(`  Source:    ${chalk5.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)})`
+    );
+    if (wt.shared_dirs.length > 0) {
+      console.log(
+        `  Shared:    ${chalk5.blue(wt.shared_dirs.join(", "))} (symlinked)`
+      );
+    }
+  }
+  console.log(chalk5.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(`
+  Rules (${manifest.total_rules}):`));
+  const rules = manifest.installed_rules ?? [];
+  console.log(`    ${rules.join(", ")}`);
+  console.log(chalk5.bold("\n  Agents:"));
+  const agents = manifest.installed_agents ?? [];
+  console.log(`    ${agents.join(", ")}`);
+  console.log();
+}
+
+// src/commands/update.ts
+import fs11 from "fs";
+import path13 from "path";
+import chalk6 from "chalk";
+async function updateCommand(opts) {
+  const target = process.cwd();
+  const manifest = readManifest(target);
+  if (!manifest) {
+    if (!opts.quiet) {
+      console.log(chalk6.red("No Arcane installation found. Run 'arcane install' first."));
+    }
+    return;
+  }
+  const contentSource = await resolveContentSource({
+    source: opts.source ?? "auto",
+    quiet: opts.quiet
+  });
+  const root = await contentSource.getContentRoot();
+  const currentVersion = await contentSource.getVersion();
+  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}).`));
+    }
+    return;
+  }
+  if (!opts.quiet) {
+    console.log(
+      chalk6.bold(`
+Update available: ${chalk6.red(installedVersion)} -> ${chalk6.green(currentVersion)}`)
+    );
+  }
+  const profileNames = manifest.profile_command.split("+").filter(Boolean);
+  const profilesDir = path13.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 = path13.join(target, ".claude");
+  const installedHashes = computeContentHashes(claudeDir);
+  const items = computeUpdatePlan(
+    manifest.content_hashes ?? null,
+    installedHashes,
+    sourceHashes
+  );
+  const updates = items.filter((i) => i.action === "update" || i.action === "add" || i.action === "conflict");
+  const skipped = items.filter((i) => i.action === "skip-customized" || i.action === "skip-unchanged");
+  const removed = items.filter((i) => i.action === "remove");
+  if (!opts.quiet) {
+    printUpdateSummary(items, opts.dryRun ?? false);
+  }
+  if (updates.length === 0 && removed.length === 0) {
+    if (!opts.quiet) {
+      console.log(chalk6.green("\nNo changes to apply."));
+    }
+    return;
+  }
+  if (opts.dryRun) {
+    return;
+  }
+  applyUpdates(items, root, claudeDir, merged, opts.force ?? false);
+  const newHashes = computeContentHashes(claudeDir);
+  updateManifestFields(target, {
+    arcane_version: currentVersion,
+    source_version: currentVersion,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+    content_hashes: newHashes,
+    installed_skills: merged.skills,
+    installed_rules: allRules,
+    installed_agents: merged.agents,
+    total_skills: merged.skills.length,
+    total_rules: allRules.length
+  });
+  if (!opts.quiet) {
+    console.log(chalk6.green(`
+Updated to v${currentVersion}.`));
+    console.log(`  ${updates.length} updated, ${skipped.length} skipped, ${removed.length} removed`);
+  }
+}
+function computeUpdatePlan(manifestHashes, installedHashes, sourceHashes) {
+  const items = [];
+  for (const contentType of ["skills", "rules", "agents", "hooks"]) {
+    const itemType = contentType === "skills" ? "skill" : contentType === "rules" ? "rule" : contentType === "agents" ? "agent" : "hook";
+    const manifest = manifestHashes?.[contentType] ?? {};
+    const installed = installedHashes[contentType];
+    const source = sourceHashes[contentType];
+    const allKeys = /* @__PURE__ */ new Set([
+      ...Object.keys(manifest),
+      ...Object.keys(installed),
+      ...Object.keys(source)
+    ]);
+    for (const key of allKeys) {
+      const mHash = manifest[key] ?? null;
+      const iHash = installed[key] ?? null;
+      const sHash = source[key] ?? null;
+      const action = resolveAction(mHash, iHash, sHash);
+      if (action) {
+        items.push({ type: itemType, name: key, action });
+      }
+    }
+  }
+  return items;
+}
+function resolveAction(manifestHash, installedHash, sourceHash) {
+  if (!sourceHash && !installedHash) return null;
+  if (sourceHash && !installedHash) return "add";
+  if (!sourceHash && installedHash) return "remove";
+  if (!manifestHash) {
+    if (installedHash === sourceHash) return "skip-unchanged";
+    return "update";
+  }
+  if (manifestHash === installedHash && installedHash === sourceHash) return "skip-unchanged";
+  if (manifestHash === installedHash && sourceHash !== installedHash) return "update";
+  if (manifestHash !== installedHash && manifestHash === sourceHash) return "skip-customized";
+  if (manifestHash !== installedHash && installedHash === sourceHash) return "skip-unchanged";
+  return "conflict";
+}
+function printUpdateSummary(items, isDryRun) {
+  const prefix = isDryRun ? chalk6.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");
+  const customized = items.filter((i) => i.action === "skip-customized");
+  const removed = items.filter((i) => i.action === "remove");
+  if (updates.length > 0) {
+    console.log(`
+${prefix}${chalk6.cyan("Will update:")}`);
+    for (const item of updates) {
+      console.log(`  ${chalk6.green("~")} ${item.type}: ${item.name}`);
+    }
+  }
+  if (adds.length > 0) {
+    console.log(`
+${prefix}${chalk6.cyan("Will add:")}`);
+    for (const item of adds) {
+      console.log(`  ${chalk6.green("+")} ${item.type}: ${item.name}`);
+    }
+  }
+  if (removed.length > 0) {
+    console.log(`
+${prefix}${chalk6.cyan("Will remove:")}`);
+    for (const item of removed) {
+      console.log(`  ${chalk6.red("-")} ${item.type}: ${item.name}`);
+    }
+  }
+  if (conflicts.length > 0) {
+    console.log(`
+${prefix}${chalk6.yellow("Conflicts (will backup + update):")}`);
+    for (const item of conflicts) {
+      console.log(`  ${chalk6.yellow("!")} ${item.type}: ${item.name}`);
+    }
+  }
+  if (customized.length > 0) {
+    console.log(`
+${prefix}${chalk6.dim("Skipped (locally customized):")}`);
+    for (const item of customized) {
+      console.log(`  ${chalk6.dim("  " + item.type + ": " + item.name)}`);
+    }
+  }
+}
+function applyUpdates(items, root, claudeDir, merged, force) {
+  for (const item of items) {
+    if (item.action === "skip-unchanged" || item.action === "skip-customized") {
+      if (item.action === "skip-customized" && force) {
+        applyItem(item, root, claudeDir);
+      }
+      continue;
+    }
+    if (item.action === "conflict") {
+      backupItem(item, claudeDir);
+      applyItem(item, root, claudeDir);
+      continue;
+    }
+    if (item.action === "update" || item.action === "add") {
+      applyItem(item, root, claudeDir);
+      continue;
+    }
+    if (item.action === "remove") {
+      removeItem(item, claudeDir);
+    }
+  }
+}
+function applyItem(item, root, claudeDir) {
+  const src = getSourcePath(item, root);
+  const dst = getInstalledPath(item, claudeDir);
+  if (!src || !fs11.existsSync(src)) return;
+  if (item.type === "skill" || item.type === "agent") {
+    if (fs11.existsSync(dst)) {
+      fs11.rmSync(dst, { recursive: true, force: true });
+    }
+    copyDirSync(src, dst);
+  } else {
+    const dir = path13.dirname(dst);
+    if (!fs11.existsSync(dir)) {
+      fs11.mkdirSync(dir, { recursive: true });
+    }
+    fs11.copyFileSync(src, dst);
+  }
+}
+function backupItem(item, claudeDir) {
+  const installed = getInstalledPath(item, claudeDir);
+  if (!fs11.existsSync(installed)) return;
+  const backupPath = installed + ".bak";
+  if (fs11.existsSync(backupPath)) {
+    fs11.rmSync(backupPath, { recursive: true, force: true });
+  }
+  fs11.renameSync(installed, backupPath);
+}
+function removeItem(item, claudeDir) {
+  const installed = getInstalledPath(item, claudeDir);
+  if (fs11.existsSync(installed)) {
+    fs11.rmSync(installed, { recursive: true, force: true });
+  }
+}
+function getSourcePath(item, root) {
+  switch (item.type) {
+    case "skill":
+      return path13.join(root, "skills", item.name);
+    case "rule": {
+      const direct = path13.join(root, "rules", item.name);
+      if (fs11.existsSync(direct)) return direct;
+      return path13.join(root, "rules", "gamedev", item.name);
+    }
+    case "agent":
+      return path13.join(root, "agents", item.name);
+    case "hook":
+      return path13.join(root, "hooks", item.name);
+    default:
+      return null;
+  }
+}
+function getInstalledPath(item, claudeDir) {
+  switch (item.type) {
+    case "skill":
+      return path13.join(claudeDir, "skills", item.name);
+    case "rule":
+      return path13.join(claudeDir, "rules", item.name);
+    case "agent":
+      return path13.join(claudeDir, "agents", item.name);
+    case "hook":
+      return path13.join(claudeDir, "hooks", item.name);
+  }
+}
+
+// src/commands/clean.ts
+import chalk7 from "chalk";
+async function cleanCommand(opts) {
+  const target = process.cwd();
+  const manifest = readManifest(target);
+  if (!manifest) {
+    console.log(chalk7.yellow("No Arcane installation found."));
+    return;
+  }
+  console.log(chalk7.bold("\nThis will remove:"));
+  console.log(`  - ${manifest.total_skills} skills in .claude/skills/`);
+  console.log(`  - ${manifest.total_rules} rules in .claude/rules/`);
+  console.log(
+    `  - ${manifest.installed_agents?.length ?? 0} agent dirs in .claude/agents/`
+  );
+  console.log("  - hooks/ directory");
+  console.log("  - settings.json");
+  console.log("  - arcane-manifest.json");
+  if (!opts.force) {
+    console.log(
+      chalk7.yellow("\n  Pass --force to confirm removal.\n")
+    );
+    return;
+  }
+  clean(target);
+  console.log(
+    chalk7.green("\n  Run `npx arcane install` to reinstall.\n")
+  );
+}
+
+// src/commands/worktree.ts
+import fs12 from "fs";
+import path14 from "path";
+import { execSync as execSync2 } from "child_process";
+import chalk8 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."));
+    process.exit(1);
+  }
+  const repoRoot = wtInfo.isWorktree ? wtInfo.mainWorktreePath : cwd;
+  const worktreePath = opts.path ? path14.resolve(opts.path) : defaultWorktreePath(repoRoot, branch);
+  if (fs12.existsSync(worktreePath)) {
+    console.error(
+      chalk8.red(`Path already exists: ${worktreePath}`)
+    );
+    process.exit(1);
+  }
+  let profileExpr = opts.profile;
+  if (!profileExpr) {
+    const manifest = readManifest(cwd);
+    if (manifest) {
+      profileExpr = manifest.profile_command;
+      console.log(
+        chalk8.dim(
+          `  Inheriting profile from current installation: ${profileExpr}`
+        )
+      );
+    }
+  }
+  if (!profileExpr) {
+    console.error(
+      chalk8.red(
+        "No profile specified and no existing installation to inherit from.\nUse --profile to specify one: npx 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(`  Path:    ${worktreePath}`);
+  console.log(`  Profile: ${chalk8.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."));
+    return;
+  }
+  console.log("\n  Creating git worktree...");
+  try {
+    createGitWorktree(repoRoot, worktreePath, branch, opts.base);
+    console.log(chalk8.green("  [ok] Git worktree created"));
+  } catch (err) {
+    console.error(
+      chalk8.red(`  Failed to create worktree: ${err.message}`)
+    );
+    process.exit(1);
+  }
+  console.log("  Installing Arcane...");
+  const root = getPackageRoot();
+  const profilesDir = path14.join(root, "profiles");
+  const profileNames = profileExpr.split("+").filter(Boolean);
+  const merged = mergeProfiles(profilesDir, profileNames);
+  const shareFrom = opts.share !== false ? cwd : void 0;
+  const installer = new Installer(merged, {
+    target: worktreePath,
+    dryRun: false,
+    force: true,
+    shareFrom
+  });
+  installer.run(profileExpr, {
+    is_worktree: true,
+    main_worktree: repoRoot
+  });
+  console.log(chalk8.green("  [ok] Arcane installed"));
+  if (opts.installDeps) {
+    const pm = detectPackageManager(worktreePath);
+    if (pm) {
+      console.log(`  Running ${pm.command}...`);
+      try {
+        execSync2(pm.command, {
+          cwd: worktreePath,
+          encoding: "utf-8",
+          stdio: "pipe",
+          timeout: 12e4
+        });
+        console.log(chalk8.green(`  [ok] Dependencies installed`));
+      } catch {
+        console.warn(
+          chalk8.yellow("  WARN: Dependency install failed. Run manually.")
+        );
+      }
+    }
+  }
+  if (opts.isolate) {
+    const isolateScript = path14.join(
+      worktreePath,
+      ".claude",
+      "skills",
+      "worktree-isolation"
+    );
+    if (fs12.existsSync(isolateScript)) {
+      console.log("  Applying worktree isolation...");
+      try {
+        execSync2(
+          "python3 scripts/apply.py --cwd . --verbose --force",
+          {
+            cwd: isolateScript,
+            encoding: "utf-8",
+            stdio: "pipe",
+            timeout: 3e4
+          }
+        );
+        console.log(chalk8.green("  [ok] Worktree isolation applied"));
+      } catch {
+        console.warn(
+          chalk8.yellow(
+            "  WARN: Worktree isolation failed. Run /worktree-isolation manually."
+          )
+        );
+      }
+    } else {
+      console.warn(
+        chalk8.yellow(
+          "  WARN: worktree-isolation skill not installed. Add it with: npx arcane add worktree-isolation"
+        )
+      );
+    }
+  }
+  console.log(chalk8.bold.green("\nWorktree ready:"));
+  console.log(`  ${chalk8.cyan(`cd ${worktreePath}`)}`);
+  console.log(`  ${chalk8.dim("claude")}
+`);
+}
+
+// src/commands/global.ts
+import fs13 from "fs";
+import path15 from "path";
+import os3 from "os";
+import chalk9 from "chalk";
+var CLAUDE_HOME = path15.join(os3.homedir(), ".claude");
+var SCRIPTS_DIR = path15.join(CLAUDE_HOME, "scripts", "worktree-isolation");
+var SETTINGS_PATH = path15.join(CLAUDE_HOME, "settings.json");
+async function globalCommand(opts) {
+  if (opts.status) {
+    showStatus();
+    return;
+  }
+  if (opts.remove) {
+    removeGlobal();
+    return;
+  }
+  installGlobal();
+}
+function showStatus() {
+  console.log(chalk9.bold("\n=== Arcane Global Status ===\n"));
+  const hasScripts = fs13.existsSync(
+    path15.join(SCRIPTS_DIR, "apply.py")
+  );
+  console.log(
+    `  Worktree scripts: ${hasScripts ? chalk9.green("installed") : chalk9.dim("not installed")}`
+  );
+  if (hasScripts) {
+    console.log(`    ${chalk9.dim(SCRIPTS_DIR)}`);
+  }
+  const hookInstalled = isHookInstalled();
+  console.log(
+    `  SessionStart hook: ${hookInstalled ? chalk9.green("active") : chalk9.dim("not configured")}`
+  );
+  console.log(`    ${chalk9.dim(SETTINGS_PATH)}`);
+  console.log();
+}
+function installGlobal() {
+  console.log(chalk9.bold("\nInstalling Arcane global hooks...\n"));
+  const root = getPackageRoot();
+  const scriptsSrc = path15.join(
+    root,
+    "skills",
+    "worktree-isolation",
+    "scripts"
+  );
+  if (!fs13.existsSync(scriptsSrc)) {
+    console.error(
+      chalk9.red("  worktree-isolation scripts not found in package.")
+    );
+    process.exit(1);
+  }
+  fs13.mkdirSync(SCRIPTS_DIR, { recursive: true });
+  for (const file of ["apply.py", "lib.py"]) {
+    const src = path15.join(scriptsSrc, file);
+    const dst = path15.join(SCRIPTS_DIR, file);
+    if (!fs13.existsSync(src)) {
+      console.warn(chalk9.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)`));
+    } else {
+      fs13.copyFileSync(src, dst);
+      if (process.platform !== "win32") {
+        fs13.chmodSync(dst, 493);
+      }
+      console.log(chalk9.green(`  [ok] ${file} -> ${SCRIPTS_DIR}`));
+    }
+  }
+  if (isHookInstalled()) {
+    console.log(
+      chalk9.dim("  [skip] SessionStart hook (already configured)")
+    );
+  } else {
+    addHookToSettings();
+    console.log(
+      chalk9.green("  [ok] SessionStart hook added to ~/.claude/settings.json")
+    );
+  }
+  console.log(chalk9.bold.green("\n  Global hooks installed."));
+  console.log(
+    chalk9.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"));
+  } else {
+    console.log(chalk9.dim("  [skip] Scripts not found"));
+  }
+  if (isHookInstalled()) {
+    removeHookFromSettings();
+    console.log(chalk9.green("  [ok] Removed SessionStart hook"));
+  } else {
+    console.log(chalk9.dim("  [skip] Hook not configured"));
+  }
+  console.log(chalk9.bold.green("\n  Global hooks removed.\n"));
+}
+function readSettings() {
+  if (!fs13.existsSync(SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(fs13.readFileSync(SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  fs13.mkdirSync(path15.dirname(SETTINGS_PATH), { recursive: true });
+  fs13.writeFileSync(
+    SETTINGS_PATH,
+    JSON.stringify(settings, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function isHookInstalled() {
+  const settings = readSettings();
+  const hooks = settings.hooks ?? {};
+  const sessionStart = hooks.SessionStart ?? [];
+  for (const entry of sessionStart) {
+    for (const hook of entry.hooks ?? []) {
+      if (hook.command?.includes("worktree-isolation/apply.py") && hook.command?.includes("--quiet")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function addHookToSettings() {
+  const settings = readSettings();
+  const hooks = settings.hooks ??= {};
+  const sessionStart = hooks.SessionStart ??= [];
+  const hookEntry = {
+    type: "command",
+    command: `${SCRIPTS_DIR.replace(/\\/g, "/")}/apply.py --quiet`
+  };
+  const existing = sessionStart.find(
+    (e) => (e.matcher ?? "") === ""
+  );
+  if (existing) {
+    (existing.hooks ??= []).push(hookEntry);
+  } else {
+    sessionStart.push({
+      matcher: "",
+      hooks: [hookEntry]
+    });
+  }
+  writeSettings(settings);
+}
+function removeHookFromSettings() {
+  const settings = readSettings();
+  const hooks = settings.hooks ?? {};
+  const sessionStart = hooks.SessionStart ?? [];
+  for (const entry of sessionStart) {
+    if (!entry.hooks) continue;
+    entry.hooks = entry.hooks.filter(
+      (h) => !(h.command?.includes("worktree-isolation/apply.py") && h.command?.includes("--quiet"))
+    );
+  }
+  hooks.SessionStart = sessionStart.filter(
+    (e) => (e.hooks?.length ?? 0) > 0
+  );
+  writeSettings(settings);
+}
+
+// src/update-check.ts
+import fs14 from "fs";
+import path16 from "path";
+import os4 from "os";
+import chalk10 from "chalk";
+var CHECK_FILE = path16.join(os4.homedir(), ".arcane", "last-check.json");
+var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
+var GITHUB_OWNER2 = "SebastianLuser";
+var GITHUB_REPO2 = "Claude-Code-Arcane";
+var GITHUB_BRANCH2 = "main";
+async function checkForUpdates(opts = {}) {
+  try {
+    const cached = readCachedCheck();
+    if (cached && !opts.force) {
+      const age = Date.now() - new Date(cached.checked_at).getTime();
+      if (age < CHECK_INTERVAL_MS) {
+        if (cached.update_available && !opts.quiet) {
+          printUpdateNotice(cached.local_version, cached.remote_sha);
+        }
+        return cached.update_available;
+      }
+    }
+    const manifest = readManifest(process.cwd());
+    const localVersion = manifest?.source_version ?? manifest?.arcane_version ?? "unknown";
+    const remoteSha = await getLatestCommitSha();
+    if (!remoteSha) return false;
+    const shortSha = remoteSha.substring(0, 12);
+    const updateAvailable = localVersion !== shortSha && !remoteSha.startsWith(localVersion);
+    const result = {
+      checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+      local_version: localVersion,
+      remote_sha: shortSha,
+      update_available: updateAvailable
+    };
+    writeCachedCheck(result);
+    if (updateAvailable && !opts.quiet) {
+      printUpdateNotice(localVersion, shortSha);
+    }
+    return updateAvailable;
+  } catch {
+    return false;
+  }
+}
+function printUpdateNotice(localVersion, remoteSha) {
+  console.log(
+    chalk10.yellow(`
+  Arcane update available: ${localVersion} \u2192 ${remoteSha}`)
+  );
+  console.log(
+    chalk10.dim("  Run: arcane update (--dry-run to preview)\n")
+  );
+}
+async function getLatestCommitSha() {
+  try {
+    const response = await fetch(
+      `https://api.github.com/repos/${GITHUB_OWNER2}/${GITHUB_REPO2}/commits/${GITHUB_BRANCH2}`,
+      {
+        headers: {
+          "User-Agent": "arcane-cli",
+          Accept: "application/vnd.github.v3+json"
+        },
+        signal: AbortSignal.timeout(5e3)
+      }
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.sha;
+  } catch {
+    return null;
+  }
+}
+function readCachedCheck() {
+  try {
+    if (!fs14.existsSync(CHECK_FILE)) return null;
+    return JSON.parse(fs14.readFileSync(CHECK_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCachedCheck(result) {
+  try {
+    const dir = path16.dirname(CHECK_FILE);
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
+    }
+    fs14.writeFileSync(CHECK_FILE, JSON.stringify(result, null, 2) + "\n");
+  } catch {
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+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."
+).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)"
+).option("--source <source>", "Content source: auto, github, or bundled", "auto").action(async (profile, opts) => {
+  await installCommand(profile, opts);
+});
+program.command("add <items...>").description(
+  "Add skills or profiles. Use +profileName for profiles, skillName for individual skills."
+).action(async (items) => {
+  await addCommand(items);
+});
+program.command("remove <items...>").description(
+  "Remove skills or profiles. Use +profileName for profiles, skillName for individual skills."
+).action(async (items) => {
+  await removeCommand(items);
+});
+program.command("list").description("List all available profiles and skills.").action(async () => {
+  await listCommand();
+});
+program.command("status").description("Show current Arcane installation status.").action(async () => {
+  await statusCommand();
+});
+program.command("update").description("Update installed Arcane content to latest version.").option("-q, --quiet", "Quiet mode for hook usage").option("-n, --dry-run", "Show what would change without applying").option("-f, --force", "Overwrite even locally modified files").option("--source <source>", "Content source: auto, github, or bundled", "auto").action(async (opts) => {
+  await updateCommand(opts);
+});
+program.command("clean").description("Remove Arcane installation from current project.").option("-f, --force", "Skip confirmation").action(async (opts) => {
+  await cleanCommand(opts);
+});
+program.command("worktree <branch>").description(
+  "Create a git worktree with Arcane pre-installed."
+).option(
+  "-p, --profile <profile>",
+  "Profile to install (inherits from current installation if omitted)"
+).option("--path <dir>", "Custom worktree directory path").option(
+  "-b, --base <branch>",
+  "Base branch for new branch (default: current HEAD)"
+).option("--install-deps", "Install dependencies after creation").option(
+  "--isolate",
+  "Apply worktree-isolation for Docker port deconfliction"
+).option("-n, --dry-run", "Show what would be done without making changes").option("--no-share", "Don't share hooks/docs from current installation").action(async (branch, opts) => {
+  await worktreeCommand(branch, opts);
+});
+program.command("global").description(
+  "Install or manage global hooks (worktree-isolation auto-apply on SessionStart)."
+).option("--remove", "Remove global hooks").option("--status", "Show global hooks status").action(async (opts) => {
+  await globalCommand(opts);
+});
+program.parse();
+if (!process.env.ARCANE_SOURCE && !process.env.VITEST) {
+  checkForUpdates({ quiet: false }).catch(() => {
+  });
+}