arcane-cli 0.14.0

package/dist/index.js

@@ -0,0 +1,2313 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+
+// src/index.ts
+import { Command } from "commander";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath } from "url";
+import { dirname as dirname3, join as join10 } from "path";
+
+// src/commands/init.ts
+import { select as select2, confirm } from "@inquirer/prompts";
+import { join as join4 } from "path";
+import chalk2 from "chalk";
+
+// src/modules/copier.ts
+import {
+  mkdir,
+  copyFile as fsCopyFile,
+  access,
+  readdir
+} from "fs/promises";
+import path from "path";
+function validateTargetPath(targetDir, relativePath) {
+  const resolvedBase = path.resolve(targetDir);
+  const resolvedFull = path.resolve(targetDir, relativePath);
+  if (resolvedFull !== resolvedBase && !resolvedFull.startsWith(resolvedBase + path.sep)) {
+    throw new Error(
+      `Path traversal detected: "${relativePath}" escapes target directory "${targetDir}"`
+    );
+  }
+}
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyFile(srcPath, targetDir, relativePath, opts = {}) {
+  validateTargetPath(targetDir, relativePath);
+  const destPath = path.resolve(targetDir, relativePath);
+  await ensureDir(path.dirname(destPath));
+  if (!opts.force && await fileExists(destPath)) {
+    throw new Error(
+      `Destination already exists: "${relativePath}". Use --force to overwrite.`
+    );
+  }
+  await fsCopyFile(srcPath, destPath);
+}
+async function copyDirectory(srcDir, targetDir, relativeDir, opts = {}) {
+  validateTargetPath(targetDir, relativeDir);
+  const copiedFiles = [];
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcEntryPath = path.join(srcDir, entry.name);
+    const relEntryPath = `${relativeDir}/${entry.name}`;
+    if (entry.isDirectory()) {
+      const subFiles = await copyDirectory(srcEntryPath, targetDir, relEntryPath, opts);
+      copiedFiles.push(...subFiles);
+    } else {
+      await copyFile(srcEntryPath, targetDir, relEntryPath, opts);
+      copiedFiles.push(relEntryPath);
+    }
+  }
+  return copiedFiles;
+}
+
+// src/modules/manifest.ts
+import { readFile, writeFile } from "fs/promises";
+import path2 from "path";
+var ManifestNotFoundError = class extends Error {
+  constructor(manifestPath2) {
+    super(`Manifest not found at "${manifestPath2}". Run "spell init" first.`);
+    this.name = "ManifestNotFoundError";
+  }
+};
+var ManifestCorruptError = class extends Error {
+  constructor(manifestPath2) {
+    super(
+      `Manifest at "${manifestPath2}" contains invalid JSON. It may be corrupted.`
+    );
+    this.name = "ManifestCorruptError";
+  }
+};
+var MANIFEST_FILE = ".arcane.json";
+function manifestPath(targetDir) {
+  return path2.join(targetDir, MANIFEST_FILE);
+}
+async function readManifest(targetDir) {
+  const filePath = manifestPath(targetDir);
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new ManifestNotFoundError(filePath);
+    }
+    throw err;
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new ManifestCorruptError(filePath);
+  }
+}
+async function writeManifest(targetDir, manifest) {
+  const filePath = manifestPath(targetDir);
+  await writeFile(filePath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+function addComponent(manifest, component) {
+  return {
+    ...manifest,
+    components: [...manifest.components, component]
+  };
+}
+function hasComponent(manifest, name) {
+  return manifest.components.some((c) => c.name === name);
+}
+
+// src/config/profiles.ts
+var PROFILE_CONFIGS = [
+  {
+    id: "full",
+    displayName: "Full Suite",
+    description: "All components \u2014 spells, governance, agents, templates",
+    components: "*"
+  },
+  {
+    id: "lite",
+    displayName: "Essentials",
+    description: "Spells + core governance \u2014 fast start",
+    components: ["spell-prompts", "claude-commands", "agent-output-instructions", "git-conventions", "testing-standards", "session-continuity"]
+  },
+  {
+    id: "methodology",
+    displayName: "Methodology Suite",
+    description: "Spells + governance \u2014 full methodology without security/infra docs",
+    components: [
+      "spell-prompts",
+      "claude-commands",
+      "agent-output-instructions",
+      "git-conventions",
+      "testing-standards",
+      "session-continuity",
+      "decision-documentation-standard",
+      "agent-work-queue-model",
+      "development-methodology",
+      "spell-authoring-standards"
+    ]
+  },
+  {
+    id: "governance-only",
+    displayName: "Governance Only",
+    description: "Standards docs only \u2014 no spells or agents",
+    components: [
+      "agent-output-instructions",
+      "git-conventions",
+      "testing-standards",
+      "decision-documentation-standard",
+      "agent-work-queue-model",
+      "naming-conventions",
+      "agent-policies",
+      "threat-model",
+      "hardening-checklist",
+      "authentication-strategy",
+      "new-business-setup",
+      "agent-approved-paths",
+      "portable-bootstrap",
+      "development-methodology",
+      "cicd-standards",
+      "poc-management-pattern",
+      "product-excellence-standards",
+      "rca-process-standard",
+      "universal-agent-rules",
+      "spell-authoring-standards"
+    ]
+  }
+];
+
+// src/modules/registry.ts
+var ComponentNotFoundError = class extends Error {
+  constructor(name, available) {
+    super(
+      `Component "${name}" not found. Available components: ${available.join(", ")}`
+    );
+    this.name = "ComponentNotFoundError";
+  }
+};
+var COMPONENTS = [
+  // Governance
+  {
+    name: "git-conventions",
+    description: "Git branching, commit message, and PR conventions",
+    files: [".arcane/governance/git-conventions.md"]
+  },
+  {
+    name: "testing-standards",
+    description: "Testing framework selection, coverage thresholds, and CI gates",
+    files: [".arcane/governance/testing-standards.md"]
+  },
+  {
+    name: "decision-documentation-standard",
+    description: "ADR format and decision-logging conventions",
+    files: [".arcane/governance/decision-documentation-standard.md"]
+  },
+  {
+    name: "agent-work-queue-model",
+    description: "Work queue model for AI agent task assignment and tracking",
+    files: [".arcane/governance/agent-work-queue-model.md"]
+  },
+  {
+    name: "naming-conventions",
+    description: "Machine, agent, and service naming rules (three-tier model)",
+    files: [".arcane/governance/naming-conventions.md"]
+  },
+  {
+    name: "agent-policies",
+    description: "Agent autonomy levels, power levels, and operational constraints",
+    files: [".arcane/governance/agent-policies.md"]
+  },
+  {
+    name: "threat-model",
+    description: "Security threat model covering STRIDE categories and mitigations",
+    files: [".arcane/governance/threat-model.md"]
+  },
+  {
+    name: "hardening-checklist",
+    description: "Production hardening checklist for infrastructure and agents",
+    files: [".arcane/governance/hardening-checklist.md"]
+  },
+  {
+    name: "authentication-strategy",
+    description: "Authentication patterns, token management, and identity strategy",
+    files: [".arcane/governance/authentication-strategy.md"]
+  },
+  {
+    name: "new-business-setup",
+    description: "Step-by-step playbook for bootstrapping a new business unit",
+    files: [".arcane/governance/new-business-setup.md"]
+  },
+  {
+    name: "agent-approved-paths",
+    description: "Approved repository paths and access boundaries for agents",
+    files: [".arcane/governance/agent-approved-paths.md"]
+  },
+  {
+    name: "portable-bootstrap",
+    description: "Portable AI context bootstrap for onboarding new AI clients",
+    files: [".arcane/governance/portable-bootstrap.md"]
+  },
+  // Governance — methodology
+  {
+    name: "development-methodology",
+    description: "Spell Loop development methodology",
+    files: [".arcane/governance/development-methodology.md"]
+  },
+  {
+    name: "cicd-standards",
+    description: "CI/CD pipeline standards and quality gates",
+    files: [".arcane/governance/cicd-standards.md"]
+  },
+  {
+    name: "poc-management-pattern",
+    description: "POC lifecycle management pattern",
+    files: [".arcane/governance/poc-management-pattern.md"]
+  },
+  {
+    name: "product-excellence-standards",
+    description: "Product quality gate standards and spell-enchant requirements",
+    files: [".arcane/governance/product-excellence-standards.md"]
+  },
+  {
+    name: "spell-authoring-standards",
+    description: "Spell Quality Rubric \u2014 the authoring bar for spell prompts (8 dimensions)",
+    files: [".arcane/governance/spell-authoring-standards.md"]
+  },
+  {
+    name: "rca-process-standard",
+    description: "Root cause analysis process standard",
+    files: [".arcane/governance/rca-process-standard.md"]
+  },
+  {
+    name: "universal-agent-rules",
+    description: "Universal rules for all AI agents operating in any Arcane-managed repo",
+    files: [".arcane/governance/universal-agent-rules.md"]
+  },
+  // VS Code Copilot instructions — installed to .github/instructions/
+  {
+    name: "agent-output-instructions",
+    description: "Copilot enforcement rules: PR link format, merge strategy, and branch naming",
+    files: [".github/instructions/agent-output.instructions.md"]
+  },
+  // Spell prompts — installed to .github/prompts/ (VS Code Copilot convention)
+  {
+    name: "spell-prompts",
+    description: "Full Arcane spell prompt library (33 spells)",
+    files: [
+      ".github/prompts/spell-arcane-version.prompt.md",
+      ".github/prompts/spell-architect.prompt.md",
+      ".github/prompts/spell-brainstorm.prompt.md",
+      ".github/prompts/spell-scope.prompt.md",
+      ".github/prompts/spell-bootstrap-business.prompt.md",
+      ".github/prompts/spell-bug.prompt.md",
+      ".github/prompts/spell-bump.prompt.md",
+      ".github/prompts/spell-check-drift.prompt.md",
+      ".github/prompts/spell-close-session.prompt.md",
+      ".github/prompts/spell-commit-work.prompt.md",
+      ".github/prompts/spell-dotnet-expert.prompt.md",
+      ".github/prompts/spell-enchant.prompt.md",
+      ".github/prompts/spell-explain-concept.prompt.md",
+      ".github/prompts/spell-full-cycle.prompt.md",
+      ".github/prompts/spell-generate-bot-icons.prompt.md",
+      ".github/prompts/spell-implement.prompt.md",
+      ".github/prompts/spell-open-session.prompt.md",
+      ".github/prompts/spell-plan.prompt.md",
+      ".github/prompts/spell-present-arcane.prompt.md",
+      ".github/prompts/spell-product-review.prompt.md",
+      ".github/prompts/spell-review.prompt.md",
+      ".github/prompts/spell-security-review.prompt.md",
+      ".github/prompts/spell-ship.prompt.md",
+      ".github/prompts/spell-suggest-feature.prompt.md",
+      ".github/prompts/spell-test.prompt.md",
+      ".github/prompts/spell-todo.prompt.md",
+      // Workflow spell additions — PR lifecycle, status, capture, feedback
+      ".github/prompts/spell-address-review.prompt.md",
+      ".github/prompts/spell-create-pull-request.prompt.md",
+      ".github/prompts/spell-document.prompt.md",
+      ".github/prompts/spell-feedback.prompt.md",
+      ".github/prompts/spell-save-idea.prompt.md",
+      ".github/prompts/spell-status.prompt.md",
+      ".github/prompts/spell-review-batch.prompt.md"
+    ]
+  },
+  // Templates
+  {
+    name: "venture-template",
+    description: "Starter template for a new business venture folder",
+    files: [".arcane/templates/venture-template/overview.md"]
+  },
+  // Session continuity — files required for spell-close-session / spell-open-session
+  {
+    name: "session-continuity",
+    description: "Session lifecycle files (TODO.md, DECISIONS.md, ai-context/, journal/) for close/open session spells",
+    skipExisting: true,
+    files: [
+      "TODO.md",
+      "DECISIONS.md",
+      "ai-context/system-prompt-context.md",
+      "journal/.gitkeep"
+    ]
+  },
+  // Agent definitions
+  // NOTE: the full portable agent system is managed by `spell agents init` / sync / list.
+  // This component only installs the policy reference template for governance-only setups.
+  {
+    name: "agent-definitions",
+    description: "Agent policy reference template (for governance-only setups \u2014 use `spell agents init` for the full agent system)",
+    files: [".arcane/agents/agent-policies-template.md"]
+  },
+  // NOTE: the static `agent-files` component was retired — `.github/agents/*.agent.md`
+  // files are generated per-roster by `spell agents init` / `spell agents sync`, so
+  // installing a fixed-name set via `spell init` shipped stale names and collided
+  // with the generated output.
+  // Claude commands
+  {
+    name: "claude-commands",
+    description: "Claude Code slash command wrappers for all 33 Arcane spells",
+    files: [
+      ".claude/commands/spell-arcane-version.md",
+      ".claude/commands/spell-architect.md",
+      ".claude/commands/spell-brainstorm.md",
+      ".claude/commands/spell-scope.md",
+      ".claude/commands/spell-bootstrap-business.md",
+      ".claude/commands/spell-bug.md",
+      ".claude/commands/spell-bump.md",
+      ".claude/commands/spell-check-drift.md",
+      ".claude/commands/spell-close-session.md",
+      ".claude/commands/spell-commit-work.md",
+      ".claude/commands/spell-dotnet-expert.md",
+      ".claude/commands/spell-enchant.md",
+      ".claude/commands/spell-explain-concept.md",
+      ".claude/commands/spell-full-cycle.md",
+      ".claude/commands/spell-generate-bot-icons.md",
+      ".claude/commands/spell-implement.md",
+      ".claude/commands/spell-open-session.md",
+      ".claude/commands/spell-plan.md",
+      ".claude/commands/spell-present-arcane.md",
+      ".claude/commands/spell-product-review.md",
+      ".claude/commands/spell-review.md",
+      ".claude/commands/spell-security-review.md",
+      ".claude/commands/spell-ship.md",
+      ".claude/commands/spell-suggest-feature.md",
+      ".claude/commands/spell-test.md",
+      ".claude/commands/spell-todo.md",
+      // Workflow spell additions — PR lifecycle, status, capture, feedback
+      ".claude/commands/spell-address-review.md",
+      ".claude/commands/spell-create-pull-request.md",
+      ".claude/commands/spell-document.md",
+      ".claude/commands/spell-feedback.md",
+      ".claude/commands/spell-save-idea.md",
+      ".claude/commands/spell-status.md",
+      ".claude/commands/spell-review-batch.md"
+    ]
+  }
+];
+function buildProfileMap() {
+  const allNames = COMPONENTS.map((c) => c.name);
+  const map = {};
+  for (const config of PROFILE_CONFIGS) {
+    map[config.id] = config.components === "*" ? allNames : config.components;
+  }
+  return map;
+}
+var PROFILE_MAP = buildProfileMap();
+var componentIndex = new Map(COMPONENTS.map((c) => [c.name, c]));
+function getComponent(name) {
+  const component = componentIndex.get(name);
+  if (!component) {
+    throw new ComponentNotFoundError(name, Array.from(componentIndex.keys()));
+  }
+  return component;
+}
+function getProfile(profile) {
+  return PROFILE_MAP[profile].map((name) => getComponent(name));
+}
+function listProfiles() {
+  const allNames = COMPONENTS.map((c) => c.name);
+  return PROFILE_CONFIGS.map((config) => ({
+    id: config.id,
+    displayName: config.displayName,
+    description: config.description,
+    components: config.components === "*" ? [...allNames] : [...config.components]
+  }));
+}
+
+// src/modules/banner.ts
+import chalk from "chalk";
+import gradient from "gradient-string";
+var TAGLINE = "Cast spells to ship software";
+var STEEL = "#6f9fd8";
+var STEEL_DEEP = "#3a6ea5";
+var STEEL_DIM = "#5d6f93";
+var INK_LABEL = "#c7d2ee";
+var FAINT = "#2c3658";
+var STOPS = ["#2a4d7d", "#4a7bb5", "#6f9fd8", "#a9c8ec"];
+var arcaneGradient = gradient(STOPS);
+var WORDMARK = [
+  " \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+  "\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+var INDENT = "  ";
+var LOCKUP_WIDTH = INDENT.length + Math.max(...WORDMARK.map((l) => l.length));
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAnimatable() {
+  return !!process.stdout.isTTY && process.env["TERM"] !== "dumb" && process.env["CI"] !== "true" && process.env["ARCANE_DISABLE_ANIMATION"] !== "true" && (process.stdout.columns ?? 80) >= LOCKUP_WIDTH;
+}
+function scale(hex, f) {
+  const v = (i) => Math.max(0, Math.min(255, Math.round(parseInt(hex.slice(i, i + 2), 16) * f)));
+  return "#" + [v(1), v(3), v(5)].map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+function lockupLines(f = 1) {
+  const g = f >= 1 ? arcaneGradient : gradient(STOPS.map((c) => scale(c, f)));
+  return WORDMARK.map((line) => INDENT + g(line));
+}
+function printFooter(version) {
+  const taglineText = `  ${TAGLINE} \xB7 agent-native SDLC \xB7 v${version}`;
+  const width = Math.max(LOCKUP_WIDTH, taglineText.length);
+  const border = chalk.hex(STEEL_DEEP)("\u2500".repeat(width));
+  console.log(border);
+  console.log(
+    chalk.hex(STEEL)(`  ${TAGLINE}`),
+    chalk.hex(STEEL_DIM)(`\xB7 agent-native SDLC \xB7 v${version}`)
+  );
+  console.log(border);
+}
+function installSummary(components) {
+  const files = components.flatMap(
+    (c) => c.files.map((f) => f.replace(/\\/g, "/"))
+  );
+  const spells = new Set(
+    files.filter((f) => /\/(prompts|commands)\/spell-.+\.md$/.test(f)).map((f) => f.split("/").pop().replace(/\.prompt\.md$|\.md$/, ""))
+  ).size;
+  const agents = files.filter((f) => /\/agents\/[^/]+\.agent\.md$/.test(f)).length;
+  const standards = files.filter(
+    (f) => /\/governance\/[^/]+\.md$/.test(f)
+  ).length;
+  const parts = [];
+  if (spells) parts.push(`${spells} spell${spells === 1 ? "" : "s"}`);
+  if (agents) parts.push(`${agents} agent${agents === 1 ? "" : "s"}`);
+  if (standards) parts.push(`${standards} standard${standards === 1 ? "" : "s"}`);
+  return parts;
+}
+async function printWelcome(version, cwd) {
+  console.log();
+  if (isAnimatable()) {
+    const draw = (lines, redraw) => {
+      if (redraw) process.stdout.write(`\x1B[${lines.length}A`);
+      for (const line of lines) process.stdout.write(`\r\x1B[2K${line}
+`);
+    };
+    const fade = [0.1, 0.22, 0.36, 0.52, 0.68, 0.84, 1];
+    for (let i = 0; i < fade.length; i++) {
+      draw(lockupLines(fade[i]), i > 0);
+      await sleep(90);
+    }
+    const pulse = [1, 0.9, 0.82, 0.9, 1];
+    for (let i = 0; i < pulse.length; i++) {
+      draw(lockupLines(pulse[i]), true);
+      await sleep(140);
+    }
+  } else {
+    for (const line of lockupLines()) console.log(line);
+  }
+  printFooter(version);
+  console.log();
+  const label = (s) => chalk.hex(STEEL_DIM)(s.padEnd(11));
+  const dot = chalk.hex(FAINT)("\xB7");
+  let repoLine;
+  try {
+    const manifest = await readManifest(cwd);
+    const parts = installSummary(manifest.components);
+    const summary = parts.length ? parts : [`${manifest.components.length} components`];
+    repoLine = `${chalk.hex(STEEL)("\u2713")} Arcane ${chalk.hex(INK_LABEL)(`\xAB${manifest.profile}\xBB`)} ${dot} ` + summary.map((p) => chalk.hex(INK_LABEL)(p)).join(` ${dot} `) + ` ${dot} ${chalk.hex(STEEL_DIM)(`v${manifest.version}`)}`;
+  } catch {
+    repoLine = `${chalk.hex(STEEL_DIM)("\u25CB")} not initialized ${chalk.hex(FAINT)("\u2014")} run ${chalk.hex(STEEL).inverse(" spell init ")} ${chalk.hex(STEEL_DIM)("to scaffold")}`;
+  }
+  console.log(`  ${label("This repo")}${repoLine}`);
+  const phases = ["plan", "architect", "implement", "test", "review", "ship"].join(
+    chalk.hex(STEEL_DEEP)(" \u2192 ")
+  );
+  console.log(`  ${label("Spell Loop")}${chalk.hex("#dbe3f7")(phases)}`);
+  const flat = ["plan", "architect", "implement", "test", "review", "ship"].join(" \u2192 ");
+  const loopStart = 13 + flat.indexOf("implement");
+  const loopEnd = 13 + flat.indexOf("review") + 5;
+  const inner = loopEnd - loopStart - 1;
+  const lp = Math.floor((inner - 19) / 2);
+  const rp = inner - 19 - lp;
+  const dash = (n) => chalk.hex(STEEL_DEEP)("\u2500".repeat(Math.max(0, n)));
+  console.log(
+    " ".repeat(loopStart) + chalk.hex(STEEL_DEEP)("\u2570") + dash(lp) + chalk.hex(STEEL)(" \u21BA ") + chalk.hex(STEEL_DIM)("until it passes") + " " + dash(rp) + chalk.hex(STEEL_DEEP)("\u256F")
+  );
+  console.log();
+}
+function printSuccess(message) {
+  console.log(`
+${chalk.hex(STEEL)("\u2726")} ${chalk.bold(message)}`);
+}
+function printStep(message) {
+  console.log(`  ${chalk.hex(STEEL_DEEP)("\u25B8")} ${message}`);
+}
+function printDryRun(message) {
+  console.log(`  ${chalk.yellow("\u25CC")} ${chalk.dim(message)}`);
+}
+function printSection(title) {
+  console.log(`
+${chalk.hex(STEEL)("\u2500")} ${chalk.bold(title)}`);
+}
+function printInfo(message) {
+  console.log(`  ${chalk.dim(message)}`);
+}
+function printNextStep(step, message) {
+  console.log(`  ${chalk.hex(STEEL_DEEP)(`${step}.`)} ${message}`);
+}
+function printWarning(message) {
+  console.log(`  ${chalk.yellow("\u26A0")}  ${chalk.yellow(message)}`);
+}
+
+// src/modules/agents.ts
+import { select, checkbox, Separator } from "@inquirer/prompts";
+import { mkdir as mkdir3, writeFile as writeFile4, copyFile as copyFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { stringify } from "yaml";
+
+// src/config/agent-roles.ts
+var AGENT_ROLES = [
+  {
+    id: "orchestrator",
+    role: "Product Operations Manager",
+    category: "operations"
+  },
+  {
+    id: "architecture-lead",
+    role: "CTO / Architecture Lead",
+    category: "engineering"
+  },
+  {
+    id: "fullstack-dev",
+    role: "Full-Stack Developer",
+    category: "engineering"
+  },
+  {
+    id: "qa-lead",
+    role: "QA Lead",
+    category: "quality"
+  },
+  {
+    id: "devops",
+    role: "DevOps / CI/CD Engineer",
+    category: "engineering"
+  },
+  {
+    id: "frontend-dev",
+    role: "Frontend Developer",
+    category: "engineering"
+  },
+  {
+    id: "mobile-dev",
+    role: "Mobile Developer",
+    category: "engineering"
+  },
+  {
+    id: "research-analyst",
+    role: "Research & Backlog Analyst",
+    category: "research"
+  },
+  {
+    id: "marketing-strategist",
+    role: "Marketing Strategist",
+    category: "operations"
+  },
+  {
+    id: "operations-comms",
+    role: "Operations Communications",
+    category: "operations"
+  },
+  {
+    id: "collaborator",
+    role: "External Collaboration Lead",
+    category: "operations"
+  },
+  {
+    id: "security-ops",
+    role: "Security Operations",
+    category: "quality"
+  }
+];
+function getAgentRole(id) {
+  return AGENT_ROLES.find((r) => r.id === id);
+}
+
+// src/config/agent-profiles.ts
+var AGENT_PROFILE_CONFIGS = [
+  {
+    id: "base",
+    displayName: "Base",
+    description: "Core team: orchestrator, architecture-lead, fullstack-dev, qa-lead",
+    roles: ["orchestrator", "architecture-lead", "fullstack-dev", "qa-lead"]
+  },
+  {
+    id: "full",
+    displayName: "Full",
+    description: "Complete roster \u2014 all 12 roles",
+    roles: [
+      "orchestrator",
+      "architecture-lead",
+      "fullstack-dev",
+      "qa-lead",
+      "devops",
+      "frontend-dev",
+      "mobile-dev",
+      "research-analyst",
+      "marketing-strategist",
+      "operations-comms",
+      "collaborator",
+      "security-ops"
+    ]
+  },
+  {
+    id: "custom",
+    displayName: "Custom",
+    description: "Select roles interactively",
+    roles: []
+    // populated at runtime via checkbox prompt
+  }
+];
+function getAgentProfileConfig(id) {
+  const config = AGENT_PROFILE_CONFIGS.find((p) => p.id === id);
+  if (!config) throw new Error(`Unknown agent profile: "${id}"`);
+  return config;
+}
+
+// src/modules/naming.ts
+import { input } from "@inquirer/prompts";
+var GENERIC_NAME_MAP = {
+  "orchestrator": "Orchestrator",
+  "architecture-lead": "Architect",
+  "fullstack-dev": "Developer",
+  "qa-lead": "QA Lead",
+  "devops": "DevOps",
+  "frontend-dev": "Frontend",
+  "mobile-dev": "Mobile",
+  "research-analyst": "Researcher",
+  "marketing-strategist": "Marketer",
+  "operations-comms": "Comms",
+  "collaborator": "Collaborator",
+  "security-ops": "Security"
+};
+var ARCANOS_NAME_MAP = {
+  "orchestrator": "Kellar",
+  "architecture-lead": "Merlin",
+  "fullstack-dev": "Lafayette",
+  "qa-lead": "Lince",
+  "devops": "Prospero",
+  "frontend-dev": "Adelaide",
+  "mobile-dev": "Mercurio",
+  "research-analyst": "Alexander",
+  "marketing-strategist": "Circe",
+  "operations-comms": "Bess",
+  "collaborator": "Iris",
+  "security-ops": "Custodio"
+};
+var RANDOM_NAME_POOL = [
+  "Aiden",
+  "Blake",
+  "Casey",
+  "Dana",
+  "Ellis",
+  "Finley",
+  "Gray",
+  "Harper",
+  "Indigo",
+  "Jordan",
+  "Kai",
+  "Lane",
+  "Morgan",
+  "Nova",
+  "Owen",
+  "Parker",
+  "Quinn",
+  "River",
+  "Sage",
+  "Taylor",
+  "Uma",
+  "Vale",
+  "Wren",
+  "Xander",
+  "Yael",
+  "Zara",
+  "Avery",
+  "Brett",
+  "Charlie",
+  "Devon"
+];
+function applyGenericNames(roleIds) {
+  return roleIds.map((id) => ({
+    definition: id,
+    name: GENERIC_NAME_MAP[id] ?? id
+  }));
+}
+function applyArcanosNames(roleIds) {
+  return roleIds.map((id) => ({
+    definition: id,
+    name: ARCANOS_NAME_MAP[id] ?? GENERIC_NAME_MAP[id] ?? id
+  }));
+}
+function applyRandomNames(roleIds) {
+  const shuffled = [...RANDOM_NAME_POOL].sort(() => Math.random() - 0.5);
+  return roleIds.map((id, i) => ({
+    definition: id,
+    name: shuffled[i % shuffled.length]
+  }));
+}
+async function promptCustomNames(roleIds) {
+  const results = [];
+  for (const id of roleIds) {
+    const role = getAgentRole(id);
+    const defaultName = GENERIC_NAME_MAP[id] ?? id;
+    const name = await input({
+      message: `Name for ${role?.role ?? id}:`,
+      default: defaultName,
+      validate: (v) => v.trim().length > 0 ? true : "Name cannot be empty"
+    });
+    results.push({ definition: id, name: name.trim() });
+  }
+  return results;
+}
+async function applyNamingStrategy(strategy, roleIds) {
+  switch (strategy) {
+    case "arcanos":
+      return applyArcanosNames(roleIds);
+    case "generic":
+      return applyGenericNames(roleIds);
+    case "random":
+      return applyRandomNames(roleIds);
+    case "custom":
+      return promptCustomNames(roleIds);
+  }
+}
+
+// src/modules/agent-loader.ts
+import { readFile as readFile2, readdir as readdir2, access as access2 } from "fs/promises";
+import { join } from "path";
+import { parse } from "yaml";
+var AgentDefinitionNotFoundError = class extends Error {
+  constructor(id, searchDir) {
+    super(
+      `Agent definition "${id}" not found in "${searchDir}". Check that ${id}.yaml exists or run "spell agents add ${id}".`
+    );
+    this.name = "AgentDefinitionNotFoundError";
+  }
+};
+var AgentRosterNotFoundError = class extends Error {
+  constructor() {
+    super(
+      'No agent roster found at .arcane/agents.yaml. Run "spell agents init" to create one.'
+    );
+    this.name = "AgentRosterNotFoundError";
+  }
+};
+async function loadAgentDefinition(agentsDir, id) {
+  const filePath = join(agentsDir, `${id}.yaml`);
+  let content;
+  try {
+    content = await readFile2(filePath, "utf8");
+  } catch {
+    throw new AgentDefinitionNotFoundError(id, agentsDir);
+  }
+  return parse(content);
+}
+async function loadRoster(targetDir) {
+  const rosterPath = join(targetDir, ".arcane", "agents.yaml");
+  let content;
+  try {
+    content = await readFile2(rosterPath, "utf8");
+  } catch {
+    throw new AgentRosterNotFoundError();
+  }
+  return parse(content);
+}
+async function rosterExists(targetDir) {
+  try {
+    await access2(join(targetDir, ".arcane", "agents.yaml"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function projectAgentsDir(targetDir) {
+  return join(targetDir, ".arcane", "agents");
+}
+
+// src/modules/agent-generator.ts
+import { writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir } from "os";
+
+// src/modules/merger.ts
+import { readFile as readFile3, writeFile as writeFile2, rm } from "fs/promises";
+import path3 from "path";
+var MARKER_START = "<!-- arcane:start -->";
+var MARKER_END = "<!-- arcane:end -->";
+var MalformedMarkersError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MalformedMarkersError";
+  }
+};
+async function mergeIntoFile(targetDir, relativePath, content, opts = {}) {
+  validateTargetPath(targetDir, relativePath);
+  const destPath = path3.resolve(targetDir, relativePath);
+  let existing;
+  try {
+    existing = await readFile3(destPath, "utf8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      existing = null;
+    } else {
+      throw err;
+    }
+  }
+  if (existing === null) {
+    if (!opts.force) return false;
+    const newContent = `${MARKER_START}
+${content}
+${MARKER_END}
+`;
+    if (!opts.dryRun) {
+      await writeFile2(destPath, newContent, "utf8");
+    }
+    return true;
+  }
+  const startIdx = existing.indexOf(MARKER_START);
+  const endIdx = existing.indexOf(MARKER_END);
+  const hasStart = startIdx !== -1;
+  const hasEnd = endIdx !== -1;
+  if (hasStart !== hasEnd) {
+    throw new MalformedMarkersError(
+      `File "${relativePath}" has mismatched arcane markers: ${hasStart ? "start found" : "start missing"}, ${hasEnd ? "end found" : "end missing"}.`
+    );
+  }
+  if (hasStart && hasEnd) {
+    if (startIdx > endIdx) {
+      throw new MalformedMarkersError(
+        `File "${relativePath}" has arcane markers in wrong order (end before start).`
+      );
+    }
+    const beforeMarker = existing.slice(0, startIdx + MARKER_START.length);
+    const afterMarker = existing.slice(endIdx);
+    const updated = `${beforeMarker}
+${content}
+${afterMarker}`;
+    if (!opts.dryRun) {
+      await writeFile2(destPath, updated, "utf8");
+    }
+    return true;
+  }
+  if (!opts.force) return false;
+  const appended = `${existing}${existing.endsWith("\n") ? "" : "\n"}${MARKER_START}
+${content}
+${MARKER_END}
+`;
+  if (!opts.dryRun) {
+    await writeFile2(destPath, appended, "utf8");
+  }
+  return true;
+}
+async function stripMarkerSection(targetDir, relativePath, opts = {}) {
+  const destPath = path3.resolve(targetDir, relativePath);
+  let existing;
+  try {
+    existing = await readFile3(destPath, "utf8");
+  } catch {
+    return false;
+  }
+  const startIdx = existing.indexOf(MARKER_START);
+  const endIdx = existing.indexOf(MARKER_END);
+  if (startIdx === -1 || endIdx === -1) return false;
+  const before = existing.slice(0, startIdx);
+  const after = existing.slice(endIdx + MARKER_END.length);
+  const stripped = (before + after).replace(/\n{3,}/g, "\n\n").trim();
+  if (!opts.dryRun) {
+    if (stripped.length === 0) {
+      await rm(destPath, { force: true });
+    } else {
+      await writeFile2(destPath, stripped + "\n", "utf8");
+    }
+  }
+  return true;
+}
+
+// src/modules/agent-generator.ts
+function renderIdentity(def, name) {
+  const mottosLine = def.persona.catchphrases && def.persona.catchphrases.length > 0 ? `
+## Mottos
+
+${def.persona.catchphrases.map((c) => `- "${c}"`).join("\n")}
+` : "";
+  return `# ${name} \u2014 ${def.role}
+
+## Role
+
+${def.persona.description.trim()}
+
+## Category
+
+${def.category}
+${mottosLine}`;
+}
+function renderSoul(def, name) {
+  const rules = def.persona.behavioral_rules.map((r) => `- ${r}`).join("\n");
+  return `# ${name} \u2014 Behavioral Directives
+
+## Rules
+
+${rules}
+
+## Autonomy
+
+- **Default Power Level:** ${def.autonomy.default_power_level}
+- **Exec Allowed:** ${def.autonomy.exec_allowed ? "Yes" : "No"}
+`;
+}
+function renderTools(def, name) {
+  const allowed = def.tools.allowed.map((t) => `- \`${t}\``).join("\n");
+  const denied = def.tools.denied.map((t) => `- \`${t}\``).join("\n");
+  return `# ${name} \u2014 Tool Capabilities
+
+## Allowed
+
+${allowed}
+
+## Denied
+
+${denied}
+`;
+}
+function renderCopilotAgent(def, name) {
+  const firstLine = def.persona.description.split("\n")[0]?.trim() ?? def.role;
+  const rules = def.persona.behavioral_rules.map((r) => `- ${r}`).join("\n");
+  const personalityBlock = def.persona.personality ? `
+## Personality
+
+${def.persona.personality.trim()}
+` : "";
+  const voiceBlock = def.persona.voice ? `
+## Voice
+
+${def.persona.voice.trim()}
+` : "";
+  const mottosBlock = def.persona.catchphrases && def.persona.catchphrases.length > 0 ? `
+## Mottos
+
+${def.persona.catchphrases.map((c) => `- "${c}"`).join("\n")}
+` : "";
+  return `---
+name: ${name}
+description: ${def.role} \u2014 ${firstLine}
+---
+${mottosBlock}
+## Role
+
+${def.persona.description.trim()}
+${personalityBlock}${voiceBlock}
+## Behavioral Rules
+
+${rules}
+
+## Tools
+
+**Allowed:** ${def.tools.allowed.join(", ")}
+**Denied:** ${def.tools.denied.join(", ")}
+`;
+}
+function renderAgentRosterSection(entries) {
+  const rows = entries.map(
+    ({ def, displayName }) => `| **${displayName}** | ${def.role} | ${def.category} |`
+  ).join("\n");
+  return `## Agent Roster
+
+| Agent | Role | Category |
+|-------|------|----------|
+${rows}
+`;
+}
+async function syncAgents(targetDir, assetsDir, roster, options = {}) {
+  const synced = [];
+  const skipped = [];
+  const projectDefs = projectAgentsDir(targetDir);
+  const bundledDefs = join2(assetsDir, "agents");
+  const resolved = [];
+  for (const entry of roster.roster) {
+    let def;
+    try {
+      def = await loadAgentDefinition(projectDefs, entry.definition);
+    } catch {
+      try {
+        def = await loadAgentDefinition(bundledDefs, entry.definition);
+      } catch {
+        skipped.push(`${entry.definition} (definition not found)`);
+        continue;
+      }
+    }
+    resolved.push({
+      entry,
+      def,
+      displayName: entry.name ?? entry.definition
+    });
+  }
+  if (roster.openclaw.enabled && options.openclaw !== false) {
+    const openclawRoot = roster.openclaw.workspace_root.replace(
+      /^~/,
+      homedir()
+    );
+    for (const { entry, def, displayName } of resolved) {
+      if (!def.clients.openclaw) continue;
+      const workspaceName = entry.id === "main" ? "workspace" : `workspace-${entry.id}`;
+      const workspaceDir = join2(openclawRoot, workspaceName);
+      try {
+        if (!options.dryRun) {
+          await mkdir2(workspaceDir, { recursive: true });
+          await writeFile3(
+            join2(workspaceDir, "IDENTITY.md"),
+            renderIdentity(def, displayName),
+            "utf8"
+          );
+          await writeFile3(
+            join2(workspaceDir, "SOUL.md"),
+            renderSoul(def, displayName),
+            "utf8"
+          );
+          await writeFile3(
+            join2(workspaceDir, "TOOLS.md"),
+            renderTools(def, displayName),
+            "utf8"
+          );
+        } else {
+          console.log(`  [dry-run] Would write: ${workspaceDir}/IDENTITY.md`);
+          console.log(`  [dry-run] Would write: ${workspaceDir}/SOUL.md`);
+          console.log(`  [dry-run] Would write: ${workspaceDir}/TOOLS.md`);
+        }
+        synced.push(`openclaw:${entry.id}:IDENTITY+SOUL+TOOLS`);
+      } catch {
+        skipped.push(`openclaw:${entry.id} (workspace not accessible)`);
+      }
+    }
+    const patch = {
+      $comment: "Apply this to your openclaw.json agents section. Do not edit manually \u2014 regenerated by `spell agents sync`.",
+      agents: resolved.map(({ entry, def }) => ({
+        id: entry.id,
+        identity: {
+          name: entry.name ?? entry.definition,
+          role: def.role
+        }
+      }))
+    };
+    const generatedDir = join2(targetDir, ".arcane", "generated");
+    if (!options.dryRun) {
+      await mkdir2(generatedDir, { recursive: true });
+      await writeFile3(
+        join2(generatedDir, "openclaw-roster.json"),
+        JSON.stringify(patch, null, 2) + "\n",
+        "utf8"
+      );
+    } else {
+      console.log(
+        "  [dry-run] Would write: .arcane/generated/openclaw-roster.json"
+      );
+    }
+    synced.push("openclaw-roster.json");
+  }
+  if (options.copilot !== false) {
+    const agentsDir = join2(targetDir, ".github", "agents");
+    if (!options.dryRun) {
+      await mkdir2(agentsDir, { recursive: true });
+    }
+    for (const { def, displayName } of resolved) {
+      if (!def.clients.copilot?.agent_file) continue;
+      const slug = displayName.toLowerCase().replace(/\s+/g, "-");
+      const fileName = `${slug}.agent.md`;
+      if (!options.dryRun) {
+        await writeFile3(
+          join2(agentsDir, fileName),
+          renderCopilotAgent(def, displayName),
+          "utf8"
+        );
+      } else {
+        console.log(`  [dry-run] Would write: .github/agents/${fileName}`);
+      }
+      synced.push(`.github/agents/${fileName}`);
+    }
+    const rosterSection = renderAgentRosterSection(resolved);
+    const copilotMerged = await mergeIntoFile(
+      targetDir,
+      ".github/copilot-instructions.md",
+      rosterSection,
+      { force: true, dryRun: options.dryRun }
+    );
+    if (copilotMerged)
+      synced.push(".github/copilot-instructions.md (agents section)");
+  }
+  if (options.claude !== false) {
+    const rosterSection = renderAgentRosterSection(resolved);
+    const claudeMerged = await mergeIntoFile(
+      targetDir,
+      "CLAUDE.md",
+      rosterSection,
+      { force: true, dryRun: options.dryRun }
+    );
+    if (claudeMerged) synced.push("CLAUDE.md (agents section)");
+  }
+  if (options.codex !== false) {
+    const rosterSection = renderAgentRosterSection(resolved);
+    const codexMerged = await mergeIntoFile(
+      targetDir,
+      "AGENTS.md",
+      rosterSection,
+      { force: true, dryRun: options.dryRun }
+    );
+    if (codexMerged) synced.push("AGENTS.md (agents section)");
+  }
+  return { synced, skipped };
+}
+
+// src/modules/agents.ts
+async function runAgentsInit(options, targetDir, assetsDir) {
+  if (!options.force && await rosterExists(targetDir)) {
+    console.log(
+      'Agent roster already exists at .arcane/agents.yaml. Run "spell agents sync" to regenerate outputs, or use --force to reinitialize.'
+    );
+    return;
+  }
+  console.log();
+  let profileId = options.profile ?? "full";
+  if (!options.profile) {
+    const baseRoles = getAgentProfileConfig("base").roles;
+    const baseRoleNames = baseRoles.map((id) => {
+      const role = AGENT_ROLES.find((r) => r.id === id);
+      return role ? role.role : id;
+    });
+    const allCategories = [...new Set(AGENT_ROLES.map((r) => r.category))];
+    profileId = await select({
+      message: "Select an agent profile:",
+      choices: AGENT_PROFILE_CONFIGS.map((p) => ({
+        value: p.id,
+        name: `${p.id === "base" ? "\u{1F3AF}" : p.id === "full" ? "\u{1F9D9}" : "\u{1F3A8}"}  ${p.displayName}`,
+        description: p.id === "base" ? `
+4 core roles: ${baseRoleNames.join(", ")}` : p.id === "full" ? `
+All 12 roles across ${allCategories.join(", ")}` : "\nPick individual roles from the full roster"
+      }))
+    });
+  }
+  let selectedRoleIds;
+  if (profileId === "custom") {
+    const categories = [...new Set(AGENT_ROLES.map((r) => r.category))];
+    const choicesWithSeparators = [];
+    for (const cat of categories) {
+      choicesWithSeparators.push(new Separator(`\u2500\u2500 ${cat.charAt(0).toUpperCase() + cat.slice(1)} \u2500\u2500`));
+      for (const r of AGENT_ROLES.filter((r2) => r2.category === cat)) {
+        choicesWithSeparators.push({
+          value: r.id,
+          name: `${r.id} \u2014 ${r.role}`,
+          checked: true
+        });
+      }
+    }
+    console.log();
+    selectedRoleIds = await checkbox({
+      message: "Select roles to install:",
+      choices: choicesWithSeparators,
+      validate: (choices) => choices.length > 0 ? true : "Select at least one role"
+    });
+  } else {
+    selectedRoleIds = getAgentProfileConfig(profileId).roles;
+  }
+  let namingStrategy = options.naming ?? "arcanos";
+  if (!options.naming) {
+    console.log();
+    namingStrategy = await select({
+      message: "Choose a naming strategy for your agents:",
+      choices: [
+        {
+          value: "arcanos",
+          name: "\u{1F0CF}  Arcanos",
+          description: "\nPersona names: Kellar, Merlin, Lafayette, Lince, Prospero..."
+        },
+        {
+          value: "generic",
+          name: "\u{1F3F7}\uFE0F  Generic",
+          description: "\nRole-derived labels: Orchestrator, Architect, Developer, QA Lead..."
+        },
+        {
+          value: "random",
+          name: "\u{1F3B2}  Random",
+          description: "\nCommon first names shuffled randomly: Blake, Morgan, Casey..."
+        },
+        {
+          value: "custom",
+          name: "\u270F\uFE0F  Custom",
+          description: "\nType a unique name for each role interactively"
+        }
+      ]
+    });
+  }
+  printStep("Assigning names...");
+  const named = await applyNamingStrategy(namingStrategy, selectedRoleIds);
+  const rosterEntries = named.map(({ definition, name }) => {
+    const id = definition === "orchestrator" ? "main" : name.toLowerCase().replace(/\s+/g, "-");
+    return { definition, name, id };
+  });
+  const roster = {
+    schema_version: 2,
+    naming_strategy: namingStrategy,
+    agent_profile: profileId,
+    openclaw: {
+      enabled: true,
+      workspace_root: "~/.openclaw"
+    },
+    roster: rosterEntries
+  };
+  const arcaneDir = join3(targetDir, ".arcane", "agents");
+  if (!options.dryRun) {
+    await mkdir3(arcaneDir, { recursive: true });
+    await writeFile4(
+      join3(targetDir, ".arcane", "agents.yaml"),
+      stringify(roster),
+      "utf8"
+    );
+  } else {
+    console.log("  [dry-run] Would write: .arcane/agents.yaml");
+  }
+  for (const roleId of selectedRoleIds) {
+    const src = join3(assetsDir, "agents", `${roleId}.yaml`);
+    const dest = join3(arcaneDir, `${roleId}.yaml`);
+    if (!options.dryRun) {
+      try {
+        await copyFile2(src, dest);
+      } catch {
+        console.warn(`  ! Could not copy definition for "${roleId}" \u2014 skipping`);
+      }
+    } else {
+      console.log(`  [dry-run] Would copy: .arcane/agents/${roleId}.yaml`);
+    }
+  }
+  if (options.dryRun) {
+    console.log(
+      `
+  [dry-run] Would initialize roster with ${selectedRoleIds.length} agents`
+    );
+    return;
+  }
+  printStep("Syncing agent definitions to all clients...");
+  const { synced, skipped } = await syncAgents(
+    targetDir,
+    assetsDir,
+    roster,
+    { dryRun: false }
+  );
+  printSuccess("Agent roster initialized");
+  console.log(`    \u{1F4CB} Profile: ${profileId} \xB7 Naming: ${namingStrategy} \xB7 Agents: ${rosterEntries.length}`);
+  console.log(`    \u{1F504} Synced: ${synced.length} outputs (Copilot, Claude, Codex, OpenClaw)`);
+  if (skipped.length > 0) {
+    console.log(`    \u26A0\uFE0F  Skipped: ${skipped.length} (${skipped.join(", ")})`);
+  }
+  console.log();
+  console.log(`    \u{1F4A1} Customize: edit .arcane/agents.yaml \u2192 spell agents sync`);
+  console.log();
+}
+async function runAgentsSync(options, targetDir, assetsDir) {
+  let roster;
+  try {
+    roster = await loadRoster(targetDir);
+  } catch (err) {
+    if (err instanceof AgentRosterNotFoundError) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+  if (options.dryRun) {
+    console.log("\n  [dry-run] Would sync agents from roster:\n");
+  } else {
+    console.log("\n  Syncing agents...\n");
+  }
+  const { synced, skipped } = await syncAgents(
+    targetDir,
+    assetsDir,
+    roster,
+    options
+  );
+  if (options.dryRun) {
+    console.log(`
+  [dry-run] ${synced.length} outputs would be generated`);
+    return;
+  }
+  console.log(`
+  \u2713 Synced ${synced.length} outputs`);
+  for (const item of synced) {
+    console.log(`    + ${item}`);
+  }
+  if (skipped.length > 0) {
+    console.log(`
+  ! Skipped ${skipped.length}:`);
+    for (const item of skipped) {
+      console.log(`    - ${item}`);
+    }
+  }
+  console.log();
+}
+async function runAgentsList(targetDir) {
+  let roster;
+  try {
+    roster = await loadRoster(targetDir);
+  } catch (err) {
+    if (err instanceof AgentRosterNotFoundError) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+  const nameWidth = Math.max(
+    "Name".length,
+    ...roster.roster.map((e) => (e.name ?? e.definition).length)
+  );
+  const defWidth = Math.max(
+    "Role ID".length,
+    ...roster.roster.map((e) => e.definition.length)
+  );
+  const idWidth = Math.max(
+    "OpenClaw ID".length,
+    ...roster.roster.map((e) => e.id.length)
+  );
+  const pad = (s, n) => s.padEnd(n);
+  console.log(
+    `
+  Profile: ${roster.agent_profile}  |  Naming: ${roster.naming_strategy}  |  Agents: ${roster.roster.length}
+`
+  );
+  console.log(
+    `  ${pad("Name", nameWidth)}  ${pad("Role ID", defWidth)}  ${pad("OpenClaw ID", idWidth)}`
+  );
+  console.log(
+    `  ${"-".repeat(nameWidth)}  ${"-".repeat(defWidth)}  ${"-".repeat(idWidth)}`
+  );
+  for (const entry of roster.roster) {
+    console.log(
+      `  ${pad(entry.name ?? "(unnamed)", nameWidth)}  ${pad(entry.definition, defWidth)}  ${pad(entry.id, idWidth)}`
+    );
+  }
+  console.log();
+}
+
+// src/modules/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function countUncommittedChanges(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["status", "--porcelain", "-uall"], { cwd });
+    const lines = stdout.trim();
+    return lines.length === 0 ? 0 : lines.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+
+// src/commands/init.ts
+var VALID_PROFILES = ["full", "lite", "governance-only", "methodology"];
+function categorizeComponents(components) {
+  const groups = [];
+  const prompts = components.find((c) => c.name === "spell-prompts");
+  if (prompts) {
+    groups.push({
+      icon: "\u2728",
+      label: "Copilot Spells",
+      count: prompts.files.length
+    });
+  }
+  const claude = components.find((c) => c.name === "claude-commands");
+  if (claude) {
+    groups.push({
+      icon: "\u26A1",
+      label: "Claude Spells",
+      count: claude.files.length
+    });
+  }
+  const governance = components.filter(
+    (c) => c.name !== "spell-prompts" && c.name !== "claude-commands" && c.name !== "venture-template" && c.name !== "agent-definitions" && c.files.some((f) => f.startsWith(".arcane/governance/"))
+  );
+  if (governance.length > 0) {
+    groups.push({
+      icon: "\u{1F4CB}",
+      label: "Governance Docs",
+      count: governance.reduce((n, c) => n + c.files.length, 0)
+    });
+  }
+  const agentDef = components.find((c) => c.name === "agent-definitions");
+  if (agentDef) {
+    groups.push({
+      icon: "\u{1F6E1}\uFE0F",
+      label: "Agent Policies",
+      count: agentDef.files.length
+    });
+  }
+  const templates = components.find((c) => c.name === "venture-template");
+  if (templates) {
+    groups.push({
+      icon: "\u{1F4C4}",
+      label: "Templates",
+      count: templates.files.length
+    });
+  }
+  return groups;
+}
+function buildProfileDescription(components, profile) {
+  const groups = categorizeComponents(components);
+  const parts = groups.map((g) => `${g.icon} ${g.count} ${g.label}`);
+  if (profile === "full" || profile === "lite") {
+    const govIndex = groups.findIndex((g) => g.label === "Governance Docs");
+    parts.splice(govIndex >= 0 ? govIndex : parts.length, 0, "\u{1F916} 12 Agent Roles");
+  }
+  return "\n" + parts.join("\n");
+}
+async function runInit(options, targetDir, assetsDir, packageVersion) {
+  if (options.profile && !VALID_PROFILES.includes(options.profile)) {
+    throw new Error(
+      `Invalid profile "${options.profile}". Valid options: ${VALID_PROFILES.join(", ")}`
+    );
+  }
+  try {
+    await readManifest(targetDir);
+    console.log(chalk2.hex("#a855f7")(`
+  \u2726 Arcane v${packageVersion}
+`));
+    console.log('Already initialized. Run "spell update" to update existing files.');
+    return;
+  } catch (err) {
+    if (!(err instanceof ManifestNotFoundError)) throw err;
+  }
+  console.log(chalk2.hex("#a855f7")(`
+  \u2726 Arcane v${packageVersion}
+`));
+  if (!options.dryRun) {
+    const dirtyCount = await countUncommittedChanges(targetDir);
+    if (dirtyCount > 0) {
+      printWarning(`This repo has ${dirtyCount} uncommitted change${dirtyCount === 1 ? "" : "s"}.`);
+      printInfo("Running spell init will add new files to your working tree.");
+      console.log();
+      const continueAnyway = await confirm({
+        message: "Continue anyway?",
+        default: true
+      });
+      if (!continueAnyway) {
+        console.log("\nCancelled. Commit or stash your changes first.");
+        return;
+      }
+      console.log();
+    }
+  }
+  let profile = options.profile;
+  if (!profile) {
+    const profiles = listProfiles();
+    profile = await select2({
+      message: "Select an installation profile:\n",
+      choices: profiles.map((p) => {
+        const profileComponents = getProfile(p.id);
+        return {
+          value: p.id,
+          name: `${p.id === "full" ? "\u{1F9D9}" : p.id === "lite" ? "\u26A1" : "\u{1F4CB}"}  ${p.displayName} \u2014 ${p.description}`,
+          description: buildProfileDescription(profileComponents, p.id)
+        };
+      })
+    });
+  }
+  const components = getProfile(profile);
+  const groups = categorizeComponents(components);
+  console.log();
+  printSection(`\u{1F4E6} Profile: ${profile}`);
+  console.log();
+  const hasAgents = profile === "full" || profile === "lite";
+  const previewParts = groups.map((g) => `${g.icon} ${g.count} ${g.label}`);
+  if (hasAgents) {
+    const govIndex = groups.findIndex((g) => g.label === "Governance Docs");
+    previewParts.splice(govIndex >= 0 ? govIndex : previewParts.length, 0, "\u{1F916} 12 Agent Roles");
+  }
+  console.log(`  ${previewParts.join(" \xB7 ")}`);
+  console.log();
+  if (!options.dryRun && !options.profile) {
+    const proceed = await confirm({
+      message: "Proceed with installation?",
+      default: true
+    });
+    if (!proceed) {
+      console.log("\nCancelled.");
+      return;
+    }
+  }
+  const installedComponents = [];
+  let fileCount = 0;
+  for (const component of components) {
+    const installedFiles = [];
+    for (const file of component.files) {
+      const srcPath = join4(assetsDir, file);
+      if (options.dryRun) {
+        printDryRun(`Would copy: ${file}`);
+      } else {
+        try {
+          await copyFile(srcPath, targetDir, file, { force: options.force });
+        } catch (err) {
+          if (component.skipExisting && err instanceof Error && err.message.includes("already exists")) {
+            continue;
+          }
+          throw err;
+        }
+      }
+      installedFiles.push(file);
+      fileCount++;
+    }
+    for (const dir of component.directories ?? []) {
+      const srcDirPath = join4(assetsDir, dir);
+      if (options.dryRun) {
+        printDryRun(`Would copy directory: ${dir}/`);
+      } else {
+        const copied = await copyDirectory(srcDirPath, targetDir, dir, { force: options.force });
+        installedFiles.push(...copied);
+        fileCount += copied.length;
+      }
+    }
+    if (!options.dryRun) {
+      installedComponents.push({
+        name: component.name,
+        files: installedFiles,
+        installedVersion: packageVersion
+      });
+    }
+  }
+  if (!options.dryRun) {
+    for (const group of groups) {
+      printStep(`${group.icon} ${group.count} ${group.label}`);
+    }
+  }
+  if (options.dryRun) {
+    if (hasAgents) {
+      const agentFiles = await import("fs").then(
+        (fsModule) => fsModule.promises.readdir(join4(assetsDir, "agents"))
+      );
+      const yamlFiles = agentFiles.filter((f) => f.endsWith(".yaml")).sort();
+      printDryRun("Would run agent setup (interactive):");
+      printDryRun("Would write: .arcane/agents.yaml");
+      for (const f of yamlFiles) {
+        printDryRun(`Would copy: .arcane/agents/${f}`);
+      }
+    }
+    printDryRun(`Would initialize with profile "${profile}" \u2014 ${fileCount} files`);
+    return;
+  }
+  const manifest = {
+    version: packageVersion,
+    profile,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    components: installedComponents
+  };
+  await writeManifest(targetDir, manifest);
+  printSuccess(`Initialized with profile "${profile}" \u2014 ${fileCount} files installed`);
+  let agentsConfigured = false;
+  if (hasAgents && !options.profile) {
+    console.log();
+    const setupAgents = await confirm({
+      message: "\u{1F916} Set up your agent team? (names, roles, AI tool configs)",
+      default: true
+    });
+    if (setupAgents) {
+      await runAgentsInit({}, targetDir, assetsDir);
+      agentsConfigured = true;
+    }
+  }
+  console.log();
+  printSection("\u{1F680} Next steps");
+  console.log();
+  let step = 1;
+  if (!agentsConfigured && profile !== "governance-only") {
+    printNextStep(step++, "Run `spell agents init` to set up your agent team");
+  }
+  if (agentsConfigured) {
+    printNextStep(
+      step++,
+      "Edit .arcane/agents.yaml to customize roles \u2192 `spell agents sync` to regenerate AI tool configs"
+    );
+  }
+  if (profile !== "governance-only") {
+    printNextStep(
+      step++,
+      "Review .arcane/governance/ docs and customize for your project"
+    );
+  }
+  printNextStep(
+    step++,
+    "Commit the new files: git add .arcane .github .claude AGENTS.md CLAUDE.md .arcane.json"
+  );
+  console.log();
+}
+
+// src/commands/add.ts
+import { join as join5 } from "path";
+async function runAdd(name, options, targetDir, assetsDir, packageVersion) {
+  let manifest;
+  try {
+    manifest = await readManifest(targetDir);
+  } catch (err) {
+    if (err instanceof ManifestNotFoundError) {
+      console.error(
+        'Not initialized. Run "spell init" first before adding components.'
+      );
+      process.exit(1);
+      return;
+    }
+    throw err;
+  }
+  let component;
+  try {
+    component = getComponent(name);
+  } catch (err) {
+    if (err instanceof ComponentNotFoundError) {
+      console.error(err.message);
+      process.exit(1);
+      return;
+    }
+    throw err;
+  }
+  if (hasComponent(manifest, name)) {
+    console.log(
+      `Component "${name}" is already installed. Use "spell update" to update it.`
+    );
+    return;
+  }
+  let fileCount = 0;
+  const installedFiles = [];
+  for (const file of component.files) {
+    const srcPath = join5(assetsDir, file);
+    if (options.dryRun) {
+      console.log(`  [dry-run] Would copy: ${file}`);
+    } else {
+      await copyFile(srcPath, targetDir, file, { force: options.force });
+    }
+    installedFiles.push(file);
+    fileCount++;
+  }
+  for (const dir of component.directories ?? []) {
+    const srcDirPath = join5(assetsDir, dir);
+    if (options.dryRun) {
+      console.log(`  [dry-run] Would copy directory: ${dir}/`);
+    } else {
+      const copied = await copyDirectory(srcDirPath, targetDir, dir, { force: options.force });
+      installedFiles.push(...copied);
+      fileCount += copied.length;
+    }
+  }
+  if (options.dryRun) {
+    console.log(
+      `
+[dry-run] Would add component "${name}" \u2014 ${fileCount} files`
+    );
+    return;
+  }
+  const newComponent = {
+    name,
+    files: installedFiles,
+    installedVersion: packageVersion
+  };
+  const updated = addComponent(manifest, newComponent);
+  await writeManifest(targetDir, updated);
+  console.log(
+    `
+\u2713 Added component "${name}" \u2014 ${fileCount} files copied`
+  );
+}
+
+// src/commands/update.ts
+import { join as join6 } from "path";
+async function runUpdate(options, targetDir, assetsDir, packageVersion) {
+  let manifest;
+  try {
+    manifest = await readManifest(targetDir);
+  } catch (err) {
+    if (err instanceof ManifestNotFoundError) {
+      console.error(
+        'Not initialized. Run "spell init" first before updating.'
+      );
+      process.exit(1);
+      return;
+    }
+    throw err;
+  }
+  if (manifest.version === packageVersion && manifest.components.length > 0) {
+    console.log("Already up to date.");
+    return;
+  }
+  if (manifest.components.length === 0) {
+    console.log("No components installed. Nothing to update.");
+    return;
+  }
+  let fileCount = 0;
+  const updatedComponents = [];
+  for (const installed of manifest.components) {
+    let component;
+    try {
+      component = getComponent(installed.name);
+    } catch (err) {
+      if (err instanceof ComponentNotFoundError) {
+        console.log(`  ! ${installed.name} not in registry \u2014 skipping.`);
+        updatedComponents.push(installed);
+        continue;
+      }
+      throw err;
+    }
+    const updatedFiles = [];
+    for (const file of component.files) {
+      const srcPath = join6(assetsDir, file);
+      if (options.dryRun) {
+        console.log(`  [dry-run] Would update: ${file}`);
+      } else {
+        await copyFile(srcPath, targetDir, file, { force: true });
+      }
+      updatedFiles.push(file);
+      fileCount++;
+    }
+    for (const dir of component.directories ?? []) {
+      const srcDirPath = join6(assetsDir, dir);
+      if (options.dryRun) {
+        console.log(`  [dry-run] Would update directory: ${dir}/`);
+      } else {
+        const copied = await copyDirectory(srcDirPath, targetDir, dir, { force: true });
+        updatedFiles.push(...copied);
+        fileCount += copied.length;
+      }
+    }
+    updatedComponents.push({
+      ...installed,
+      files: updatedFiles,
+      installedVersion: packageVersion
+    });
+  }
+  if (options.dryRun) {
+    console.log(
+      `
+[dry-run] Would update ${fileCount} files.`
+    );
+    return;
+  }
+  const updated = { ...manifest, version: packageVersion, components: updatedComponents };
+  await writeManifest(targetDir, updated);
+  console.log(
+    `
+\u2713 Updated ${fileCount} files.`
+  );
+}
+
+// src/modules/version-check.ts
+import { readFile as readFile4, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
+import { dirname, join as join7 } from "path";
+import { homedir as homedir2 } from "os";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function getFeedUrl() {
+  const pkg2 = require2("../../package.json");
+  const url = pkg2.publishConfig?.registry;
+  if (!url) {
+    throw new Error(
+      "publishConfig.registry is not set in package.json. Cannot resolve npm feed URL."
+    );
+  }
+  return url;
+}
+var DEFAULT_CACHE_PATH = join7(homedir2(), ".arcane", "version-cache.json");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+async function readCache(cachePath) {
+  try {
+    const content = await readFile4(cachePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.latest !== "string" || typeof parsed.checkedAt !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cachePath, latest) {
+  await mkdir4(dirname(cachePath), { recursive: true });
+  const entry = { latest, checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeFile5(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+}
+async function getLatestVersion(feedUrl) {
+  const normalizedBase = feedUrl.endsWith("/") ? feedUrl : feedUrl + "/";
+  const url = `${normalizedBase}arcane-cli`;
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) return null;
+    const body = await response.json();
+    return body["dist-tags"]?.latest ?? null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate(currentVersion, feedUrl, cachePath = DEFAULT_CACHE_PATH) {
+  try {
+    let latest = null;
+    const cached = await readCache(cachePath);
+    if (cached) {
+      const age = Date.now() - new Date(cached.checkedAt).getTime();
+      if (age < CACHE_TTL_MS) {
+        latest = cached.latest;
+      }
+    }
+    if (latest === null) {
+      latest = await getLatestVersion(feedUrl);
+      if (latest !== null) {
+        try {
+          await writeCache(cachePath, latest);
+        } catch {
+        }
+      }
+    }
+    return {
+      current: currentVersion,
+      latest,
+      updateAvailable: latest !== null && latest !== currentVersion
+    };
+  } catch (err) {
+    return {
+      current: currentVersion,
+      latest: null,
+      updateAvailable: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/commands/status.ts
+async function runStatus(targetDir, packageVersion) {
+  let manifest;
+  try {
+    manifest = await readManifest(targetDir);
+  } catch (err) {
+    if (err instanceof ManifestNotFoundError) {
+      console.error(
+        'Not initialized. Run "spell init" first.'
+      );
+      process.exit(1);
+      return;
+    }
+    throw err;
+  }
+  if (manifest.components.length === 0) {
+    console.log("No components installed.");
+    return;
+  }
+  let feedUrl;
+  try {
+    feedUrl = getFeedUrl();
+  } catch {
+    feedUrl = "";
+  }
+  const versionResult = feedUrl ? await checkForUpdate(packageVersion, feedUrl) : { current: packageVersion, latest: null, updateAvailable: false, error: "Feed URL unavailable" };
+  const nameWidth = Math.max(
+    "Component".length,
+    ...manifest.components.map((c) => c.name.length)
+  );
+  const filesWidth = "Files".length;
+  const versionWidth = Math.max(
+    "Version".length,
+    ...manifest.components.map((c) => c.installedVersion.length)
+  );
+  const pad = (s, n) => s.padEnd(n);
+  const rpad = (s, n) => s.padStart(n);
+  console.log(
+    `  ${pad("Component", nameWidth)}  ${rpad("Files", filesWidth)}  ${pad("Version", versionWidth)}`
+  );
+  console.log(
+    `  ${"-".repeat(nameWidth)}  ${"-".repeat(filesWidth)}  ${"-".repeat(versionWidth)}`
+  );
+  for (const component of manifest.components) {
+    const label = component.name;
+    const fileCount = component.files.length.toString();
+    const displayVersion = component.installedVersion;
+    console.log(
+      `  ${pad(label, nameWidth)}  ${rpad(fileCount, filesWidth)}  ${displayVersion}`
+    );
+  }
+  console.log("");
+  const latestStr = versionResult.error ? "unable to check" : versionResult.latest ?? manifest.version;
+  let footer = `  Installed: ${packageVersion}  Latest: ${latestStr}`;
+  if (versionResult.updateAvailable) {
+    footer += "  (spell update available)";
+  }
+  console.log(footer);
+}
+
+// src/commands/uninstall.ts
+import { rm as rm2 } from "fs/promises";
+import { join as join8 } from "path";
+import { confirm as confirm2 } from "@inquirer/prompts";
+async function runUninstall(options, targetDir) {
+  let manifest;
+  try {
+    manifest = await readManifest(targetDir);
+  } catch (err) {
+    if (err instanceof ManifestNotFoundError) {
+      console.error('Not initialized. Run "spell init" first.');
+      process.exit(1);
+      return;
+    }
+    throw err;
+  }
+  const allFiles = manifest.components.flatMap((c) => c.files);
+  const totalFiles = allFiles.length;
+  if (options.dryRun) {
+    for (const file of allFiles) {
+      console.log(`[dry-run] Would remove: ${file}`);
+    }
+    console.log(`[dry-run] Would remove: .arcane.json`);
+    console.log(`[dry-run] Would remove: .github/agents/ (directory)`);
+    console.log(`[dry-run] Would remove: .arcane/agents/ (directory)`);
+    console.log(`[dry-run] Would remove: .arcane/generated/ (directory)`);
+    console.log(`[dry-run] Would remove: .arcane/agents.yaml`);
+    console.log(`[dry-run] Would strip arcane sections from: CLAUDE.md, AGENTS.md, copilot-instructions.md`);
+    console.log(`
+[dry-run] ${totalFiles} file(s) + manifest + agent outputs would be removed.`);
+    return;
+  }
+  if (!options.yes) {
+    const confirmed = await confirm2({
+      message: `This will remove ${totalFiles} files and .arcane.json. Continue?`,
+      default: false
+    });
+    if (!confirmed) {
+      console.log("Uninstall cancelled.");
+      return;
+    }
+  }
+  let removed = 0;
+  for (const component of manifest.components) {
+    for (const file of component.files) {
+      const filePath = join8(targetDir, file);
+      try {
+        await rm2(filePath, { force: true });
+        removed++;
+      } catch {
+      }
+    }
+  }
+  await rm2(join8(targetDir, ".arcane.json"), { force: true });
+  const agentDirs = [
+    ".github/agents",
+    ".arcane/agents",
+    ".arcane/generated"
+  ];
+  for (const dir of agentDirs) {
+    await rm2(join8(targetDir, dir), { recursive: true, force: true });
+  }
+  await rm2(join8(targetDir, ".arcane/agents.yaml"), { force: true });
+  const markerFiles = [
+    "CLAUDE.md",
+    "AGENTS.md",
+    ".github/copilot-instructions.md"
+  ];
+  for (const file of markerFiles) {
+    await stripMarkerSection(targetDir, file, { dryRun: false });
+  }
+  console.log(`
+\u2713 Uninstalled \u2014 ${removed} files removed.`);
+}
+
+// src/commands/doctor.ts
+import { access as access3, readFile as readFile5, mkdir as mkdir5, copyFile as fsCopyFile2 } from "fs/promises";
+import { join as join9, dirname as dirname2 } from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function checkNodeVersion() {
+  const name = "Node.js version";
+  const raw = process.version;
+  const major = parseInt(raw.replace(/^v/, "").split(".")[0] ?? "0", 10);
+  if (major >= 18) {
+    return { name, passed: true, message: `${raw} (>=18 required)` };
+  }
+  return {
+    name,
+    passed: false,
+    message: `${raw} \u2014 Node.js 18 or later is required`
+  };
+}
+async function checkVSCodeExtension(id, label) {
+  const name = `VS Code extension: ${label}`;
+  const home = process.env["HOME"] ?? "";
+  const extDirs = [
+    join9(home, ".vscode", "extensions"),
+    join9(home, ".vscode-insiders", "extensions")
+  ];
+  for (const dir of extDirs) {
+    try {
+      const { readdir: readdir3 } = await import("fs/promises");
+      const entries = await readdir3(dir);
+      const prefix = id.toLowerCase() + "-";
+      const found = entries.some(
+        (e) => e.toLowerCase() === id.toLowerCase() || e.toLowerCase().startsWith(prefix)
+      );
+      if (found) {
+        return { name, passed: true, message: `${id} is installed` };
+      }
+    } catch {
+    }
+  }
+  let installBin = "code";
+  for (const bin of ["code", "code-insiders"]) {
+    try {
+      await execFileAsync2(bin, ["--version"]);
+      installBin = bin;
+      break;
+    } catch {
+    }
+  }
+  return {
+    name,
+    passed: false,
+    message: `${id} not found. Install via: ${installBin} --install-extension ${id}`,
+    blocking: false
+  };
+}
+async function checkArcaneManifest(targetDir) {
+  const name = "Arcane manifest (.arcane.json)";
+  const manifestPath2 = join9(targetDir, ".arcane.json");
+  try {
+    await access3(manifestPath2);
+    const raw = await readFile5(manifestPath2, "utf8");
+    const manifest = JSON.parse(raw);
+    if (!manifest.version || !Array.isArray(manifest.components)) {
+      return {
+        name,
+        passed: false,
+        message: ".arcane.json is present but missing required fields (version, components). Re-run `spell init`."
+      };
+    }
+    return {
+      name,
+      passed: true,
+      message: `v${manifest.version} \u2014 ${manifest.components.length} component(s) installed`
+    };
+  } catch {
+    return {
+      name,
+      passed: false,
+      message: "No .arcane.json found. Run `spell init` to initialize Arcane in this project.",
+      blocking: false
+    };
+  }
+}
+var SESSION_CONTINUITY_FILES = [
+  "TODO.md",
+  "DECISIONS.md",
+  "ai-context/system-prompt-context.md",
+  "journal/.gitkeep"
+];
+async function checkSessionContinuity(targetDir) {
+  const results = [];
+  for (const file of SESSION_CONTINUITY_FILES) {
+    const name = `Session file: ${file}`;
+    const filePath = join9(targetDir, file);
+    try {
+      await access3(filePath);
+      results.push({ name, passed: true, message: "present" });
+    } catch {
+      results.push({
+        name,
+        passed: false,
+        message: `Missing. Required for spell-close-session. Run \`spell doctor --fix\` to create it.`,
+        blocking: false
+      });
+    }
+  }
+  return results;
+}
+async function fixSessionContinuity(targetDir, assetsDir) {
+  const created = [];
+  for (const file of SESSION_CONTINUITY_FILES) {
+    const destPath = join9(targetDir, file);
+    try {
+      await access3(destPath);
+    } catch {
+      const srcPath = join9(assetsDir, file);
+      await mkdir5(dirname2(destPath), { recursive: true });
+      await fsCopyFile2(srcPath, destPath);
+      created.push(file);
+    }
+  }
+  return created;
+}
+async function runDoctor(targetDir, options = {}, assetsDir) {
+  console.log("\nspell doctor \u2014 checking your Arcane environment\n");
+  const results = await Promise.all([
+    checkNodeVersion(),
+    checkVSCodeExtension("GitHub.copilot-chat", "GitHub Copilot (Chat)"),
+    checkArcaneManifest(targetDir)
+  ]);
+  const sessionResults = await checkSessionContinuity(targetDir);
+  results.push(...sessionResults);
+  let allPassed = true;
+  for (const result of results) {
+    const icon = result.passed ? "\u2713" : result.blocking === false ? "\u26A0" : "\u2717";
+    const label = result.passed ? "pass" : result.blocking === false ? "warn" : "FAIL";
+    console.log(`  ${icon} [${label}] ${result.name}`);
+    if (!result.passed) {
+      console.log(`         ${result.message}`);
+    }
+    if (!result.passed && result.blocking !== false) {
+      allPassed = false;
+    }
+  }
+  console.log();
+  if (allPassed) {
+    console.log("  All checks passed. Your environment is ready.\n");
+  } else {
+    console.log("  One or more checks failed. Fix the issues above before proceeding.\n");
+    const hasMissingSession = sessionResults.some((r) => !r.passed);
+    if (options.fix && hasMissingSession && assetsDir) {
+      console.log("  \u{1F527} Fixing missing session continuity files...\n");
+      const created = await fixSessionContinuity(targetDir, assetsDir);
+      if (created.length > 0) {
+        for (const file of created) {
+          console.log(`    \u2713 Created: ${file}`);
+        }
+        console.log(`
+  ${created.length} file(s) created. Repo is now close-session-ready.
+`);
+      } else {
+        console.log("    No files needed creation (all present).\n");
+      }
+    } else if (hasMissingSession && !options.fix) {
+      console.log("  \u{1F4A1} Run `spell doctor --fix` to create missing session files.\n");
+    }
+    if (!allPassed) {
+      process.exitCode = 1;
+    }
+  }
+}
+
+// src/index.ts
+import { realpathSync } from "fs";
+var require3 = createRequire2(import.meta.url);
+var pkg = require3("../package.json");
+var ASSETS_DIR = process.env["ARCANE_ASSETS_DIR"] ?? join10(dirname3(fileURLToPath(import.meta.url)), "assets");
+var program = new Command();
+program.name("spell").description("Arcane framework CLI \u2014 scaffold and manage governance files").version(pkg.version).action(async () => {
+  await printWelcome(pkg.version, process.cwd());
+  program.outputHelp();
+});
+program.command("init").description("Scaffold Arcane framework files into the current repository").option("--profile <profile>", "Profile: full | lite | methodology | governance-only").option("--force", "Overwrite existing files without error").option("--dry-run", "Preview what would be installed without making changes").action(
+  async (opts) => {
+    await runInit(
+      {
+        profile: opts.profile,
+        force: opts.force,
+        dryRun: opts.dryRun
+      },
+      process.cwd(),
+      ASSETS_DIR,
+      pkg.version
+    );
+  }
+);
+program.command("add <component>").description("Add a component to an existing Arcane installation").option("--force", "Overwrite existing files without error").option("--dry-run", "Preview what would be added without making changes").action(
+  async (component, opts) => {
+    await runAdd(
+      component,
+      { force: opts.force, dryRun: opts.dryRun },
+      process.cwd(),
+      ASSETS_DIR,
+      pkg.version
+    );
+  }
+);
+program.command("update").description("Update installed components to the current package version").option("--dry-run", "Preview what would be updated without making changes").action(async (opts) => {
+  await runUpdate(
+    { dryRun: opts.dryRun },
+    process.cwd(),
+    ASSETS_DIR,
+    pkg.version
+  );
+});
+program.command("status").description("Show installed components and check for updates").action(async () => {
+  await runStatus(process.cwd(), pkg.version);
+});
+program.command("uninstall").description("Remove all installed Arcane framework files").option("--yes", "Skip confirmation prompt").option("--dry-run", "Preview what would be removed without deleting files").action(async (opts) => {
+  await runUninstall({ yes: opts.yes, dryRun: opts.dryRun }, process.cwd());
+});
+program.command("doctor").description("Check your environment for Arcane prerequisites").option("--fix", "Automatically create missing session continuity files").action(async (opts) => {
+  await runDoctor(process.cwd(), { fix: opts.fix }, ASSETS_DIR);
+});
+var agentsCommand = program.command("agents").description("Manage the portable agent system (init, sync, list)");
+agentsCommand.command("init").description(
+  "Interactive agent roster setup \u2014 choose profile, naming strategy, and install definitions"
+).option(
+  "--profile <profile>",
+  "Agent profile: base | full | custom"
+).option(
+  "--naming <strategy>",
+  "Naming strategy: arcanos | generic | random | custom"
+).option("--force", "Reinitialize even if roster already exists").option("--dry-run", "Preview what would be created without writing files").action(
+  async (opts) => {
+    await runAgentsInit(
+      {
+        profile: opts.profile,
+        naming: opts.naming,
+        force: opts.force,
+        dryRun: opts.dryRun
+      },
+      process.cwd(),
+      ASSETS_DIR
+    );
+  }
+);
+agentsCommand.command("sync").description(
+  "Regenerate all client instruction files from canonical agent definitions"
+).option("--dry-run", "Preview what would be generated without writing files").option("--no-openclaw", "Skip OpenClaw workspace output").option("--no-copilot", "Skip Copilot output").option("--no-claude", "Skip Claude output").option("--no-codex", "Skip Codex output").action(
+  async (opts) => {
+    await runAgentsSync(
+      {
+        dryRun: opts.dryRun,
+        openclaw: opts.openclaw,
+        copilot: opts.copilot,
+        claude: opts.claude,
+        codex: opts.codex
+      },
+      process.cwd(),
+      ASSETS_DIR
+    );
+  }
+);
+agentsCommand.command("list").description("Show the current agent roster with assigned names and roles").action(async () => {
+  await runAgentsList(process.cwd());
+});
+if (realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await program.parseAsync(process.argv);
+}
+export {
+  ASSETS_DIR,
+  program
+};
+//# sourceMappingURL=index.js.map