ocx 1.1.1 → 1.2.0

package/dist/index.js

@@ -4511,12 +4511,10 @@ var {
 import { createHash } from "crypto";
 import { existsSync } from "fs";
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname, join } from "path";
 
-// src/ghost/config.ts
-import { mkdir } from "fs/promises";
-import { homedir } from "os";
-import path2, { dirname, join } from "path";
+// src/profile/manager.ts
+import { mkdir, readdir, readlink, rm, stat } from "fs/promises";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -5817,43 +5815,6 @@ var ParseErrorCode;
   ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
   ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
 })(ParseErrorCode || (ParseErrorCode = {}));
-function printParseErrorCode(code) {
-  switch (code) {
-    case 1:
-      return "InvalidSymbol";
-    case 2:
-      return "InvalidNumberFormat";
-    case 3:
-      return "PropertyNameExpected";
-    case 4:
-      return "ValueExpected";
-    case 5:
-      return "ColonExpected";
-    case 6:
-      return "CommaExpected";
-    case 7:
-      return "CloseBraceExpected";
-    case 8:
-      return "CloseBracketExpected";
-    case 9:
-      return "EndOfFileExpected";
-    case 10:
-      return "InvalidCommentToken";
-    case 11:
-      return "UnexpectedEndOfComment";
-    case 12:
-      return "UnexpectedEndOfString";
-    case 13:
-      return "UnexpectedEndOfNumber";
-    case 14:
-      return "InvalidUnicode";
-    case 15:
-      return "InvalidEscapeCharacter";
-    case 16:
-      return "InvalidCharacter";
-  }
-  return "<unknown ParseErrorCode>";
-}
 function modify(text, path, value, options) {
   return setProperty(text, path, value, options);
 }
@@ -10276,109 +10237,242 @@ class IntegrityError extends OCXError {
     this.name = "IntegrityError";
   }
 }
-
-class GhostNotInitializedError extends OCXError {
-  constructor() {
-    super("Ghost mode not initialized. Run `ocx ghost init` first.", "CONFIG_ERROR", EXIT_CODES.CONFIG);
-    this.name = "GhostNotInitializedError";
+class GhostConfigError extends OCXError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR", EXIT_CODES.CONFIG);
+    this.name = "GhostConfigError";
   }
 }
 
-class GhostAlreadyInitializedError extends OCXError {
-  constructor(configPath) {
-    const path2 = configPath ?? "~/.config/ocx/ghost.jsonc";
-    super(`Ghost mode already initialized.
-` + `Config: ${path2}
-
-` + `To reset, delete the config and run init again:
-` + `  rm ${path2} && ocx ghost init`, "CONFLICT", EXIT_CODES.GENERAL);
-    this.name = "GhostAlreadyInitializedError";
+class ProfileNotFoundError extends OCXError {
+  constructor(name) {
+    super(`Profile "${name}" not found`, "NOT_FOUND", EXIT_CODES.NOT_FOUND);
+    this.name = "ProfileNotFoundError";
   }
 }
 
-class GhostConfigError extends OCXError {
-  constructor(message) {
-    super(message, "CONFIG_ERROR", EXIT_CODES.CONFIG);
-    this.name = "GhostConfigError";
+class ProfileExistsError extends OCXError {
+  constructor(name) {
+    super(`Profile "${name}" already exists`, "CONFLICT", EXIT_CODES.GENERAL);
+    this.name = "ProfileExistsError";
   }
 }
 
-// src/ghost/config.ts
-var CONFIG_DIR_NAME = "ocx";
-var CONFIG_FILE_NAME = "ghost.jsonc";
-function formatZodError(error) {
-  return error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join(`
-`);
+class InvalidProfileNameError extends OCXError {
+  constructor(name, reason) {
+    super(`Invalid profile name "${name}": ${reason}`, "VALIDATION_ERROR", EXIT_CODES.GENERAL);
+    this.name = "InvalidProfileNameError";
+  }
 }
-function parseRawJsonc(filePath, content) {
-  const errors2 = [];
-  const raw = parse2(content, errors2, { allowTrailingComma: true });
-  const firstError = errors2[0];
-  if (firstError) {
-    throw new GhostConfigError(`Invalid JSON in ${filePath}:
-  Offset ${firstError.offset}: ${printParseErrorCode(firstError.error)}`);
+
+class ProfilesNotInitializedError extends OCXError {
+  constructor() {
+    super("Ghost profiles not initialized. Run 'ocx ghost init' first.", "NOT_FOUND", EXIT_CODES.NOT_FOUND);
+    this.name = "ProfilesNotInitializedError";
   }
-  return raw;
 }
-function parseJsoncFile(filePath, content, schema) {
-  const raw = parseRawJsonc(filePath, content);
-  const result = schema.safeParse(raw);
-  if (!result.success) {
-    throw new GhostConfigError(`Invalid config in ${filePath}:
-${formatZodError(result.error)}`);
+
+// src/profile/atomic.ts
+import { rename, symlink, unlink } from "fs/promises";
+async function atomicWrite(filePath, data) {
+  const tempPath = `${filePath}.tmp.${process.pid}`;
+  try {
+    await Bun.write(tempPath, JSON.stringify(data, null, "\t"), { mode: 384 });
+    await rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await unlink(tempPath);
+    } catch {}
+    throw error;
   }
-  return result.data;
 }
-function getGhostConfigDir() {
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
-  if (xdgConfigHome && isAbsolutePath(xdgConfigHome)) {
-    return path2.join(xdgConfigHome, CONFIG_DIR_NAME);
+async function atomicSymlink(target, linkPath) {
+  const tempLink = `${linkPath}.tmp.${process.pid}`;
+  try {
+    await symlink(target, tempLink);
+    await rename(tempLink, linkPath);
+  } catch (error) {
+    try {
+      await unlink(tempLink);
+    } catch {}
+    throw error;
   }
-  return path2.join(homedir(), ".config", CONFIG_DIR_NAME);
 }
-function getGhostConfigPath() {
-  return join(getGhostConfigDir(), CONFIG_FILE_NAME);
+
+// src/profile/paths.ts
+import { homedir } from "os";
+import path2 from "path";
+function getProfilesDir() {
+  const base = process.env.XDG_CONFIG_HOME || path2.join(homedir(), ".config");
+  return path2.join(base, "opencode", "profiles");
 }
-async function ghostConfigExists() {
-  const configPath = getGhostConfigPath();
-  const file = Bun.file(configPath);
-  return file.exists();
+function getProfileDir(name) {
+  return path2.join(getProfilesDir(), name);
 }
-async function loadGhostConfig() {
-  const configPath = getGhostConfigPath();
-  const file = Bun.file(configPath);
-  if (!await file.exists()) {
-    throw new GhostNotInitializedError;
-  }
-  const content = await file.text();
-  return parseJsoncFile(configPath, content, ghostConfigSchema);
+function getProfileGhostConfig(name) {
+  return path2.join(getProfileDir(name), "ghost.jsonc");
 }
-async function saveGhostConfig(config) {
-  const configPath = getGhostConfigPath();
-  const configDir = dirname(configPath);
-  await mkdir(configDir, { recursive: true });
-  const result = ghostConfigSchema.safeParse(config);
-  if (!result.success) {
-    throw new GhostConfigError(`Invalid config:
-${formatZodError(result.error)}`);
-  }
-  const content = JSON.stringify(result.data, null, 2);
-  await Bun.write(configPath, content);
+function getProfileOpencodeConfig(name) {
+  return path2.join(getProfileDir(name), "opencode.jsonc");
 }
-var OPENCODE_CONFIG_FILE_NAME = "opencode.jsonc";
-function getGhostOpencodeConfigPath() {
-  return join(getGhostConfigDir(), OPENCODE_CONFIG_FILE_NAME);
+function getProfileAgents(name) {
+  return path2.join(getProfileDir(name), "AGENTS.md");
 }
-async function loadGhostOpencodeConfig() {
-  const configPath = getGhostOpencodeConfigPath();
-  try {
-    const content = await Bun.file(configPath).text();
-    return parseRawJsonc(configPath, content);
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return {};
+function getCurrentSymlink() {
+  return path2.join(getProfilesDir(), "current");
+}
+
+// src/profile/schema.ts
+var profileNameSchema = exports_external.string().min(1, "Profile name is required").max(32, "Profile name must be 32 characters or less").regex(/^[a-zA-Z][a-zA-Z0-9._-]*$/, "Profile name must start with a letter and contain only alphanumeric characters, dots, underscores, or hyphens");
+var profileSchema = exports_external.object({
+  name: profileNameSchema,
+  ghost: ghostConfigSchema,
+  opencode: exports_external.record(exports_external.unknown()).optional(),
+  hasAgents: exports_external.boolean()
+});
+
+// src/profile/manager.ts
+var DEFAULT_GHOST_CONFIG = {
+  $schema: "https://ocx.kdco.dev/schemas/ghost.json",
+  registries: {}
+};
+
+class ProfileManager {
+  profilesDir;
+  constructor(profilesDir) {
+    this.profilesDir = profilesDir;
+  }
+  static create() {
+    return new ProfileManager(getProfilesDir());
+  }
+  async isInitialized() {
+    try {
+      const stats = await stat(this.profilesDir);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async ensureInitialized() {
+    if (!await this.isInitialized()) {
+      throw new ProfilesNotInitializedError;
+    }
+  }
+  async list() {
+    await this.ensureInitialized();
+    const entries = await readdir(this.profilesDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "current").map((e) => e.name).sort();
+  }
+  async exists(name) {
+    const dir = getProfileDir(name);
+    try {
+      const stats = await stat(dir);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async get(name) {
+    if (!await this.exists(name)) {
+      throw new ProfileNotFoundError(name);
+    }
+    const ghostPath = getProfileGhostConfig(name);
+    const ghostFile = Bun.file(ghostPath);
+    if (!await ghostFile.exists()) {
+      throw new GhostConfigError(`Profile "${name}" is missing ghost.jsonc. Expected at: ${ghostPath}`);
+    }
+    const ghostContent = await ghostFile.text();
+    const ghostRaw = parse2(ghostContent);
+    const ghost = ghostConfigSchema.parse(ghostRaw);
+    const opencodePath = getProfileOpencodeConfig(name);
+    const opencodeFile = Bun.file(opencodePath);
+    let opencode;
+    if (await opencodeFile.exists()) {
+      const opencodeContent = await opencodeFile.text();
+      opencode = parse2(opencodeContent);
+    }
+    const agentsPath = getProfileAgents(name);
+    const agentsFile = Bun.file(agentsPath);
+    const hasAgents = await agentsFile.exists();
+    return {
+      name,
+      ghost,
+      opencode,
+      hasAgents
+    };
+  }
+  async add(name) {
+    const result = profileNameSchema.safeParse(name);
+    if (!result.success) {
+      throw new InvalidProfileNameError(name, result.error.errors[0]?.message ?? "Invalid name");
+    }
+    if (await this.exists(name)) {
+      throw new ProfileExistsError(name);
+    }
+    const dir = getProfileDir(name);
+    await mkdir(dir, { recursive: true, mode: 448 });
+    const ghostPath = getProfileGhostConfig(name);
+    await atomicWrite(ghostPath, DEFAULT_GHOST_CONFIG);
+  }
+  async remove(name, force = false) {
+    if (!await this.exists(name)) {
+      throw new ProfileNotFoundError(name);
+    }
+    const current = await this.getCurrent();
+    const isCurrentProfile = current === name;
+    const profiles = await this.list();
+    if (isCurrentProfile && !force) {
+      throw new Error(`Cannot delete current profile "${name}". Use --force to override.`);
+    }
+    if (profiles.length <= 1) {
+      throw new Error("Cannot delete the last profile. At least one profile must exist.");
+    }
+    const remaining = profiles.filter((p) => p !== name);
+    const dir = getProfileDir(name);
+    await rm(dir, { recursive: true });
+    if (isCurrentProfile && remaining.length > 0) {
+      await this.setCurrent(remaining[0]);
+    }
+  }
+  async getCurrent(override) {
+    if (override) {
+      if (!await this.exists(override)) {
+        throw new ProfileNotFoundError(override);
+      }
+      return override;
+    }
+    const envProfile = process.env.OCX_PROFILE;
+    if (envProfile) {
+      if (!await this.exists(envProfile)) {
+        throw new ProfileNotFoundError(envProfile);
+      }
+      return envProfile;
+    }
+    await this.ensureInitialized();
+    const linkPath = getCurrentSymlink();
+    try {
+      const target = await readlink(linkPath);
+      return target;
+    } catch {
+      const profiles = await this.list();
+      const firstProfile = profiles[0];
+      if (!firstProfile) {
+        throw new ProfilesNotInitializedError;
+      }
+      return firstProfile;
+    }
+  }
+  async setCurrent(name) {
+    if (!await this.exists(name)) {
+      throw new ProfileNotFoundError(name);
     }
-    throw err;
+    const linkPath = getCurrentSymlink();
+    await atomicSymlink(name, linkPath);
+  }
+  async initialize() {
+    await mkdir(this.profilesDir, { recursive: true, mode: 448 });
+    await this.add("default");
+    await this.setCurrent("default");
   }
 }
 
@@ -10416,8 +10510,10 @@ class GhostConfigProvider {
     this.config = config;
   }
   static async create(_cwd) {
-    const config = await loadGhostConfig();
-    return new GhostConfigProvider(getGhostConfigDir(), config);
+    const manager = ProfileManager.create();
+    const profileName = await manager.getCurrent();
+    const profile = await manager.get(profileName);
+    return new GhostConfigProvider(getProfileDir(profileName), profile.ghost);
   }
   getRegistries() {
     return this.config.registries;
@@ -10432,7 +10528,7 @@ class GhostConfigProvider {
 // package.json
 var package_default = {
   name: "ocx",
-  version: "1.1.1",
+  version: "1.2.0",
   description: "OCX CLI - ShadCN-style registry for OpenCode extensions. Install agents, plugins, skills, and MCP servers.",
   author: "kdcokenny",
   license: "MIT",
@@ -12756,7 +12852,7 @@ async function handleNpmPlugins(inputs, options2, cwd) {
 }
 async function runRegistryAddCore(componentNames, options2, provider) {
   const cwd = provider.cwd;
-  const lockPath = join2(cwd, "ocx.lock");
+  const lockPath = join(cwd, "ocx.lock");
   const registries = provider.getRegistries();
   let lock = { lockVersion: 1, installed: {} };
   const existingLock = await readOcxLock(cwd);
@@ -12812,7 +12908,7 @@ async function runRegistryAddCore(componentNames, options2, provider) {
       }
       const computedHash = await hashBundle(files);
       for (const file of component.files) {
-        const targetPath = join2(cwd, file.target);
+        const targetPath = join(cwd, file.target);
         assertPathInside(targetPath, cwd);
       }
       const existingEntry = lock.installed[component.qualifiedName];
@@ -12821,7 +12917,7 @@ async function runRegistryAddCore(componentNames, options2, provider) {
         throw new IntegrityError(component.qualifiedName, existingEntry.hash, computedHash);
       }
       for (const file of component.files) {
-        const targetPath = join2(cwd, file.target);
+        const targetPath = join(cwd, file.target);
         if (existsSync(targetPath)) {
           const conflictingComponent = findComponentByFile(lock, file.target);
           if (conflictingComponent && conflictingComponent !== component.qualifiedName) {
@@ -12844,7 +12940,7 @@ async function runRegistryAddCore(componentNames, options2, provider) {
         const componentFile = component.files.find((f) => f.path === file.path);
         if (!componentFile)
           continue;
-        const targetPath = join2(cwd, componentFile.target);
+        const targetPath = join(cwd, componentFile.target);
         if (existsSync(targetPath)) {
           const existingContent = await Bun.file(targetPath).text();
           const incomingContent = file.content.toString("utf-8");
@@ -12900,9 +12996,9 @@ async function runRegistryAddCore(componentNames, options2, provider) {
       const result = await updateOpencodeJsonConfig(cwd, resolved.opencode);
       if (!options2.quiet && result.changed) {
         if (result.created) {
-          logger.info(`Created ${join2(cwd, "opencode.jsonc")}`);
+          logger.info(`Created ${join(cwd, "opencode.jsonc")}`);
         } else {
-          logger.info(`Updated ${join2(cwd, "opencode.jsonc")}`);
+          logger.info(`Updated ${join(cwd, "opencode.jsonc")}`);
         }
       }
     }
@@ -12914,7 +13010,7 @@ async function runRegistryAddCore(componentNames, options2, provider) {
       try {
         await updateOpencodeDevDependencies(cwd, resolved.npmDependencies, resolved.npmDevDependencies);
         const totalDeps = resolved.npmDependencies.length + resolved.npmDevDependencies.length;
-        npmSpin?.succeed(`Added ${totalDeps} dependencies to ${join2(cwd, ".opencode/package.json")}`);
+        npmSpin?.succeed(`Added ${totalDeps} dependencies to ${join(cwd, ".opencode/package.json")}`);
       } catch (error) {
         npmSpin?.fail("Failed to update .opencode/package.json");
         throw error;
@@ -12948,8 +13044,8 @@ async function installComponent(component, files, cwd, _options) {
     const componentFile = component.files.find((f) => f.path === file.path);
     if (!componentFile)
       continue;
-    const targetPath = join2(cwd, componentFile.target);
-    const targetDir = dirname2(targetPath);
+    const targetPath = join(cwd, componentFile.target);
+    const targetDir = dirname(targetPath);
     if (existsSync(targetPath)) {
       const existingContent = await Bun.file(targetPath).text();
       const incomingContent = file.content.toString("utf-8");
@@ -13038,7 +13134,7 @@ function mergeDevDependencies(existing, newDeps) {
   return { ...existing, devDependencies: merged };
 }
 async function readOpencodePackageJson(opencodeDir) {
-  const pkgPath = join2(opencodeDir, "package.json");
+  const pkgPath = join(opencodeDir, "package.json");
   if (!existsSync(pkgPath)) {
     return { ...DEFAULT_PACKAGE_JSON };
   }
@@ -13051,7 +13147,7 @@ async function readOpencodePackageJson(opencodeDir) {
   }
 }
 async function ensureManifestFilesAreTracked(opencodeDir) {
-  const gitignorePath = join2(opencodeDir, ".gitignore");
+  const gitignorePath = join(opencodeDir, ".gitignore");
   const filesToTrack = new Set(["package.json", "bun.lock"]);
   const requiredIgnores = ["node_modules"];
   let lines = [];
@@ -13074,12 +13170,12 @@ async function updateOpencodeDevDependencies(cwd, npmDeps, npmDevDeps) {
   const allDepSpecs = [...npmDeps, ...npmDevDeps];
   if (allDepSpecs.length === 0)
     return;
-  const opencodeDir = join2(cwd, ".opencode");
+  const opencodeDir = join(cwd, ".opencode");
   await mkdir2(opencodeDir, { recursive: true });
   const parsedDeps = allDepSpecs.map(parseNpmDependency);
   const existing = await readOpencodePackageJson(opencodeDir);
   const updated = mergeDevDependencies(existing, parsedDeps);
-  await Bun.write(join2(opencodeDir, "package.json"), `${JSON.stringify(updated, null, 2)}
+  await Bun.write(join(opencodeDir, "package.json"), `${JSON.stringify(updated, null, 2)}
 `);
   await ensureManifestFilesAreTracked(opencodeDir);
 }
@@ -13093,11 +13189,11 @@ function findComponentByFile(lock, filePath) {
 }
 
 // src/commands/build.ts
-import { join as join4, relative } from "path";
+import { join as join3, relative } from "path";
 
 // src/lib/build-registry.ts
 import { mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 class BuildRegistryError extends Error {
   errors;
   constructor(message, errors3 = []) {
@@ -13108,8 +13204,8 @@ class BuildRegistryError extends Error {
 }
 async function buildRegistry(options2) {
   const { source: sourcePath, out: outPath } = options2;
-  const jsoncFile = Bun.file(join3(sourcePath, "registry.jsonc"));
-  const jsonFile = Bun.file(join3(sourcePath, "registry.json"));
+  const jsoncFile = Bun.file(join2(sourcePath, "registry.jsonc"));
+  const jsonFile = Bun.file(join2(sourcePath, "registry.json"));
   const jsoncExists = await jsoncFile.exists();
   const jsonExists = await jsonFile.exists();
   if (!jsoncExists && !jsonExists) {
@@ -13125,7 +13221,7 @@ async function buildRegistry(options2) {
   }
   const registry = parseResult.data;
   const validationErrors = [];
-  const componentsDir = join3(outPath, "components");
+  const componentsDir = join2(outPath, "components");
   await mkdir3(componentsDir, { recursive: true });
   for (const component of registry.components) {
     const packument = {
@@ -13137,13 +13233,13 @@ async function buildRegistry(options2) {
         latest: registry.version
       }
     };
-    const packumentPath = join3(componentsDir, `${component.name}.json`);
+    const packumentPath = join2(componentsDir, `${component.name}.json`);
     await Bun.write(packumentPath, JSON.stringify(packument, null, 2));
     for (const rawFile of component.files) {
       const file = normalizeFile(rawFile);
-      const sourceFilePath = join3(sourcePath, "files", file.path);
-      const destFilePath = join3(componentsDir, component.name, file.path);
-      const destFileDir = dirname3(destFilePath);
+      const sourceFilePath = join2(sourcePath, "files", file.path);
+      const destFilePath = join2(componentsDir, component.name, file.path);
+      const destFileDir = dirname2(destFilePath);
       if (!await Bun.file(sourceFilePath).exists()) {
         validationErrors.push(`${component.name}: Source file not found at ${sourceFilePath}`);
         continue;
@@ -13169,11 +13265,11 @@ async function buildRegistry(options2) {
       description: c.description
     }))
   };
-  await Bun.write(join3(outPath, "index.json"), JSON.stringify(index, null, 2));
-  const wellKnownDir = join3(outPath, ".well-known");
+  await Bun.write(join2(outPath, "index.json"), JSON.stringify(index, null, 2));
+  const wellKnownDir = join2(outPath, ".well-known");
   await mkdir3(wellKnownDir, { recursive: true });
   const discovery = { registry: "/index.json" };
-  await Bun.write(join3(wellKnownDir, "ocx.json"), JSON.stringify(discovery, null, 2));
+  await Bun.write(join2(wellKnownDir, "ocx.json"), JSON.stringify(discovery, null, 2));
   return {
     name: registry.name,
     namespace: registry.namespace,
@@ -13187,8 +13283,8 @@ async function buildRegistry(options2) {
 function registerBuildCommand(program2) {
   program2.command("build").description("Build a registry from source (for registry authors)").argument("[path]", "Registry source directory", ".").option("--out <dir>", "Output directory", "./dist").option("--cwd <path>", "Working directory", process.cwd()).option("--json", "Output as JSON", false).option("-q, --quiet", "Suppress output", false).action(async (path5, options2) => {
     try {
-      const sourcePath = join4(options2.cwd, path5);
-      const outPath = join4(options2.cwd, options2.out);
+      const sourcePath = join3(options2.cwd, path5);
+      const outPath = join3(options2.cwd, options2.out);
       const spinner2 = createSpinner({
         text: "Building registry...",
         quiet: options2.quiet || options2.json
@@ -14143,7 +14239,7 @@ function resolveEditor() {
   return process.env.OCX_EDITOR || process.env.EDITOR || process.env.VISUAL || "vi";
 }
 function registerGhostConfigCommand(parent) {
-  const cmd = parent.command("config").description("Open ghost configuration in your editor");
+  const cmd = parent.command("config").description("Open current profile's ghost.jsonc in your editor").option("-p, --profile <name>", "Open a specific profile's config");
   addOutputOptions(cmd).action(async (options2) => {
     try {
       await runGhostConfig(options2);
@@ -14153,13 +14249,15 @@ function registerGhostConfigCommand(parent) {
   });
 }
 async function runGhostConfig(options2) {
-  const exists = await ghostConfigExists();
-  if (!exists) {
-    throw new GhostNotInitializedError;
+  const manager = ProfileManager.create();
+  if (!await manager.isInitialized()) {
+    throw new ProfilesNotInitializedError;
   }
-  const configPath = getGhostConfigPath();
+  const profileName = await manager.getCurrent(options2.profile);
+  await manager.get(profileName);
+  const configPath = getProfileGhostConfig(profileName);
   if (options2.json) {
-    console.log(JSON.stringify({ success: true, path: configPath }));
+    console.log(JSON.stringify({ success: true, profile: profileName, path: configPath }));
     return;
   }
   const editor = resolveEditor();
@@ -14178,22 +14276,8 @@ async function runGhostConfig(options2) {
 }
 
 // src/commands/ghost/init.ts
-import { mkdir as mkdir4, writeFile as writeFile2 } from "fs/promises";
-var DEFAULT_GHOST_CONFIG = `{
-  // OCX Ghost Mode Configuration
-  // This config is used when running commands with \`ocx ghost\` or \`ocx g\`
-  // Note: OpenCode settings go in ~/.config/ocx/opencode.jsonc (see: ocx ghost opencode --edit)
-  
-  // Component registries - add your registries here
-  // Example: "myregistry": { "url": "https://example.com/registry" }
-  "registries": {},
-  
-  // Where to install components (relative to project root)
-  "componentPath": "src/components"
-}
-`;
 function registerGhostInitCommand(parent) {
-  const cmd = parent.command("init").description("Initialize ghost mode with global configuration");
+  const cmd = parent.command("init").description("Initialize ghost mode with profiles");
   addOutputOptions(cmd);
   addVerboseOption(cmd);
   cmd.action(async (options2) => {
@@ -14205,47 +14289,176 @@ function registerGhostInitCommand(parent) {
   });
 }
 async function runGhostInit(options2) {
-  const configPath = getGhostConfigPath();
-  const configDir = getGhostConfigDir();
-  await mkdir4(configDir, { recursive: true });
-  try {
-    await writeFile2(configPath, DEFAULT_GHOST_CONFIG, { flag: "wx" });
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      throw new GhostAlreadyInitializedError(configPath);
-    }
-    throw err;
-  }
-  const opencodeResult = await ensureOpencodeConfig(configDir);
+  const manager = ProfileManager.create();
+  if (await manager.isInitialized()) {
+    const profilesDir2 = getProfilesDir();
+    throw new ProfileExistsError(`Ghost mode already initialized at ${profilesDir2}`);
+  }
+  await manager.initialize();
+  const profilesDir = getProfilesDir();
+  const ghostConfigPath = getProfileGhostConfig("default");
   if (options2.json) {
     console.log(JSON.stringify({
       success: true,
-      path: configPath,
-      opencodePath: opencodeResult.path,
-      opencodeCreated: opencodeResult.created
+      profilesDir,
+      defaultProfile: "default",
+      ghostConfigPath
     }));
     return;
   }
   if (!options2.quiet) {
     logger.success("Ghost mode initialized");
-    logger.info(`Created ${configPath}`);
-    if (opencodeResult.created) {
-      logger.info(`Created ${opencodeResult.path}`);
-    }
+    logger.info(`Created ${profilesDir}`);
+    logger.info(`Created profile "default"`);
     logger.info("");
     logger.info("Next steps:");
     logger.info("  1. Edit your config: ocx ghost config");
     logger.info("  2. Add registries: ocx ghost registry add <url> --name <name>");
     logger.info("  3. Add components: ocx ghost add <component>");
+    logger.info("  4. Create profiles: ocx ghost profile add <name>");
+  }
+}
+
+// src/profile/migrate.ts
+import { chmod, readdir as readdir2, rename as rename2, stat as stat2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import path5 from "path";
+function getLegacyConfigDir() {
+  const base = process.env.XDG_CONFIG_HOME || path5.join(homedir2(), ".config");
+  return path5.join(base, "ocx");
+}
+async function needsMigration() {
+  const legacyDir = getLegacyConfigDir();
+  const profilesDir = getProfilesDir();
+  try {
+    await stat2(legacyDir);
+    try {
+      await stat2(profilesDir);
+      return false;
+    } catch {
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+async function migrate(dryRun = false) {
+  const result = {
+    success: false,
+    migratedFiles: [],
+    backupPath: null,
+    errors: []
+  };
+  const legacyDir = getLegacyConfigDir();
+  const profilesDir = getProfilesDir();
+  try {
+    await stat2(legacyDir);
+  } catch {
+    result.errors.push(`No legacy config found at ${legacyDir}`);
+    return result;
+  }
+  try {
+    await stat2(profilesDir);
+    result.errors.push(`Profiles directory already exists at ${profilesDir}`);
+    return result;
+  } catch {}
+  const legacyFiles = await readdir2(legacyDir);
+  const filesToMigrate = legacyFiles.filter((f) => f === "ghost.jsonc" || f === "opencode.jsonc" || f === "AGENTS.md");
+  if (filesToMigrate.length === 0) {
+    result.errors.push("No migratable files found in legacy config");
+    return result;
+  }
+  if (dryRun) {
+    result.migratedFiles = filesToMigrate.map((f) => path5.join(legacyDir, f));
+    result.backupPath = `${legacyDir}.bak`;
+    result.success = true;
+    return result;
+  }
+  const manager = ProfileManager.create();
+  await manager.initialize();
+  const defaultProfileDir = getProfileDir("default");
+  for (const file of filesToMigrate) {
+    const srcPath = path5.join(legacyDir, file);
+    const destPath = path5.join(defaultProfileDir, file);
+    await Bun.write(destPath, Bun.file(srcPath));
+    await chmod(destPath, 384);
+    result.migratedFiles.push(file);
+  }
+  const backupPath = `${legacyDir}.bak`;
+  await rename2(legacyDir, backupPath);
+  result.backupPath = backupPath;
+  result.success = true;
+  return result;
+}
+
+// src/commands/ghost/migrate.ts
+function registerGhostMigrateCommand(parent) {
+  parent.command("migrate").description("Migrate from legacy ~/.config/ocx/ to new profiles system").option("--dry-run", "Preview changes without making them").action(async (options2) => {
+    try {
+      await runMigrate(options2);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function runMigrate(options2) {
+  const needsMigrationResult = await needsMigration();
+  if (!needsMigrationResult) {
+    const legacyDir = getLegacyConfigDir();
+    const profilesDir = getProfilesDir();
+    console.log("No migration needed.");
+    console.log(`  Legacy config: ${legacyDir} (not found)`);
+    console.log(`  Profiles: ${profilesDir}`);
+    return;
+  }
+  if (options2.dryRun) {
+    console.log(`Dry run - no changes will be made.
+`);
+  }
+  const result = await migrate(options2.dryRun);
+  if (!result.success) {
+    console.error("Migration failed:");
+    for (const error of result.errors) {
+      console.error(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+  if (options2.dryRun) {
+    console.log("Migration preview:");
+    console.log(`
+Files to migrate to default profile:`);
+    for (const file of result.migratedFiles) {
+      console.log(`  ${file}`);
+    }
+    console.log(`
+Legacy config will be renamed to:`);
+    console.log(`  ${result.backupPath}`);
+    console.log(`
+Run without --dry-run to perform migration.`);
+  } else {
+    console.log("Migration complete!");
+    console.log(`
+Migrated to default profile:`);
+    for (const file of result.migratedFiles) {
+      console.log(`  ${file}`);
+    }
+    console.log(`
+Legacy config backed up to:`);
+    console.log(`  ${result.backupPath}`);
+    console.log(`
+Profile location:`);
+    console.log(`  ${getProfileDir("default")}`);
   }
 }
 
 // src/commands/ghost/opencode.ts
 import { renameSync, rmSync } from "fs";
+import { copyFile as copyFilePromise } from "fs/promises";
+import path6 from "path";
 
 // src/utils/opencode-discovery.ts
 import { exists } from "fs/promises";
-import { dirname as dirname4, join as join5 } from "path";
+import { dirname as dirname3, join as join4 } from "path";
 var CONFIG_FILES = ["opencode.jsonc", "opencode.json"];
 var RULE_FILES = ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"];
 var CONFIG_DIRS = [".opencode"];
@@ -14253,13 +14466,13 @@ async function findUp(target, start, stop) {
   let current = start;
   const result = [];
   while (true) {
-    const search = join5(current, target);
+    const search = join4(current, target);
     if (await exists(search).catch(() => false)) {
       result.push(search);
     }
     if (stop === current)
       break;
-    const parent = dirname4(current);
+    const parent = dirname3(current);
     if (parent === current)
       break;
     current = parent;
@@ -14271,14 +14484,14 @@ async function* up(options2) {
   let current = start;
   while (true) {
     for (const target of targets) {
-      const search = join5(current, target);
+      const search = join4(current, target);
       if (await exists(search).catch(() => false)) {
         yield search;
       }
     }
     if (stop === current)
       break;
-    const parent = dirname4(current);
+    const parent = dirname3(current);
     if (parent === current)
       break;
     current = parent;
@@ -14288,14 +14501,14 @@ async function discoverProjectFiles(start, stop) {
   const excluded = new Set;
   for (const file of CONFIG_FILES) {
     const found = await findUp(file, start, stop);
-    for (const path5 of found) {
-      excluded.add(path5);
+    for (const path6 of found) {
+      excluded.add(path6);
     }
   }
   for (const file of RULE_FILES) {
     const found = await findUp(file, start, stop);
-    for (const path5 of found) {
-      excluded.add(path5);
+    for (const path6 of found) {
+      excluded.add(path6);
     }
   }
   for await (const dir of up({ targets: CONFIG_DIRS, start, stop })) {
@@ -14316,22 +14529,22 @@ function filterExcludedPaths(excludedPaths, includePatterns, excludePatterns) {
   const includeGlobs = includePatterns.map((p) => new Glob2(p));
   const excludeGlobs = excludePatterns?.map((p) => new Glob2(p)) ?? [];
   const filteredExclusions = new Set;
-  for (const path5 of excludedPaths) {
-    const matchesInclude = matchesAnyGlob(path5, includeGlobs);
-    const matchesExclude = matchesAnyGlob(path5, excludeGlobs);
+  for (const path6 of excludedPaths) {
+    const matchesInclude = matchesAnyGlob(path6, includeGlobs);
+    const matchesExclude = matchesAnyGlob(path6, excludeGlobs);
     if (matchesInclude && !matchesExclude) {
       continue;
     }
-    filteredExclusions.add(path5);
+    filteredExclusions.add(path6);
   }
   return filteredExclusions;
 }
 
 // src/utils/symlink-farm.ts
 import { randomBytes } from "crypto";
-import { mkdir as mkdir5, readdir, rename, rm, stat, symlink } from "fs/promises";
+import { mkdir as mkdir4, readdir as readdir3, rename as rename3, rm as rm2, stat as stat3, symlink as symlink2 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname5, isAbsolute, join as join6, relative as relative2 } from "path";
+import { dirname as dirname4, isAbsolute, join as join5, relative as relative2 } from "path";
 var STALE_SESSION_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 var REMOVING_THRESHOLD_MS = 60 * 60 * 1000;
 var GHOST_DIR_PREFIX = "ocx-ghost-";
@@ -14342,20 +14555,20 @@ async function createSymlinkFarm(sourceDir, excludePaths) {
     throw new Error(`sourceDir must be an absolute path, got: ${sourceDir}`);
   }
   const suffix = randomBytes(4).toString("hex");
-  const tempDir = join6(tmpdir(), `${GHOST_DIR_PREFIX}${suffix}`);
-  await Bun.write(join6(tempDir, GHOST_MARKER_FILE), "");
+  const tempDir = join5(tmpdir(), `${GHOST_DIR_PREFIX}${suffix}`);
+  await Bun.write(join5(tempDir, GHOST_MARKER_FILE), "");
   try {
-    const entries = await readdir(sourceDir, { withFileTypes: true });
+    const entries = await readdir3(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join6(sourceDir, entry.name);
+      const sourcePath = join5(sourceDir, entry.name);
       if (excludePaths.has(sourcePath))
         continue;
-      const targetPath = join6(tempDir, entry.name);
-      await symlink(sourcePath, targetPath);
+      const targetPath = join5(tempDir, entry.name);
+      await symlink2(sourcePath, targetPath);
     }
     return tempDir;
   } catch (error) {
-    await rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    await rm2(tempDir, { recursive: true, force: true }).catch(() => {});
     throw error;
   }
 }
@@ -14371,13 +14584,13 @@ async function injectGhostFiles(tempDir, sourceDir, injectPaths) {
     if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
       throw new Error(`injectPath must be within sourceDir: ${injectPath}`);
     }
-    const targetPath = join6(tempDir, relativePath);
-    const parentDir = dirname5(targetPath);
+    const targetPath = join5(tempDir, relativePath);
+    const parentDir = dirname4(targetPath);
     if (parentDir !== tempDir) {
-      await mkdir5(parentDir, { recursive: true });
+      await mkdir4(parentDir, { recursive: true });
     }
     try {
-      await symlink(injectPath, targetPath);
+      await symlink2(injectPath, targetPath);
     } catch (err) {
       if (err.code !== "EEXIST") {
         throw new Error(`Failed to inject ${injectPath} \u2192 ${targetPath}: ${err.message}`);
@@ -14388,11 +14601,11 @@ async function injectGhostFiles(tempDir, sourceDir, injectPaths) {
 async function cleanupSymlinkFarm(tempDir) {
   const removingPath = `${tempDir}${REMOVING_SUFFIX}`;
   try {
-    await rename(tempDir, removingPath);
+    await rename3(tempDir, removingPath);
   } catch {
     return;
   }
-  await rm(removingPath, { recursive: true, force: true });
+  await rm2(removingPath, { recursive: true, force: true });
 }
 async function cleanupOrphanedGhostDirs(tempBase = tmpdir()) {
   let cleanedCount = 0;
@@ -14401,19 +14614,19 @@ async function cleanupOrphanedGhostDirs(tempBase = tmpdir()) {
   }
   let dirNames;
   try {
-    dirNames = await readdir(tempBase);
+    dirNames = await readdir3(tempBase);
   } catch {
     return 0;
   }
   for (const dirName of dirNames) {
-    const dirPath = join6(tempBase, dirName);
+    const dirPath = join5(tempBase, dirName);
     const isRemovingDir = dirName.endsWith(REMOVING_SUFFIX);
     const isGhostDir = dirName.startsWith(GHOST_DIR_PREFIX) && !isRemovingDir;
     if (!isRemovingDir && !isGhostDir)
       continue;
     let stats;
     try {
-      stats = await stat(dirPath);
+      stats = await stat3(dirPath);
     } catch {
       continue;
     }
@@ -14426,10 +14639,10 @@ async function cleanupOrphanedGhostDirs(tempBase = tmpdir()) {
     try {
       if (isGhostDir) {
         const removingPath = `${dirPath}${REMOVING_SUFFIX}`;
-        await rename(dirPath, removingPath);
-        await rm(removingPath, { recursive: true, force: true });
+        await rename3(dirPath, removingPath);
+        await rm2(removingPath, { recursive: true, force: true });
       } else {
-        await rm(dirPath, { recursive: true, force: true });
+        await rm2(dirPath, { recursive: true, force: true });
       }
       cleanedCount++;
     } catch {}
@@ -14439,7 +14652,7 @@ async function cleanupOrphanedGhostDirs(tempBase = tmpdir()) {
 
 // src/commands/ghost/opencode.ts
 function registerGhostOpenCodeCommand(parent) {
-  parent.command("opencode").description("Launch OpenCode with ghost mode configuration").addOption(sharedOptions.json()).addOption(sharedOptions.quiet()).allowUnknownOption().allowExcessArguments(true).action(async (options2, command) => {
+  parent.command("opencode").description("Launch OpenCode with ghost mode configuration").option("-p, --profile <name>", "Use specific profile").addOption(sharedOptions.json()).addOption(sharedOptions.quiet()).allowUnknownOption().allowExcessArguments(true).action(async (options2, command) => {
     try {
       const args = command.args;
       await runGhostOpenCode(args, options2);
@@ -14449,24 +14662,39 @@ function registerGhostOpenCodeCommand(parent) {
   });
 }
 async function runGhostOpenCode(args, options2) {
-  if (!await ghostConfigExists()) {
-    throw new GhostNotInitializedError;
+  const manager = ProfileManager.create();
+  if (!await manager.isInitialized()) {
+    throw new ProfilesNotInitializedError;
+  }
+  if (!options2.quiet && await needsMigration()) {
+    console.log("Notice: Found legacy config at ~/.config/ocx/");
+    console.log(`Run 'ocx ghost migrate' to upgrade to the new profiles system.
+`);
   }
   await cleanupOrphanedGhostDirs();
-  const openCodeConfig = await loadGhostOpencodeConfig();
-  const ghostConfigDir = getGhostConfigDir();
-  if (Object.keys(openCodeConfig).length === 0 && !options2.quiet) {
-    logger.warn(`No opencode.jsonc found at ${getGhostOpencodeConfigPath()}. Run 'ocx ghost init' first.`);
+  const profileName = await manager.getCurrent(options2.profile);
+  const profile = await manager.get(profileName);
+  const profileDir = getProfileDir(profileName);
+  const profileOpencodePath = getProfileOpencodeConfig(profileName);
+  const profileOpencodeFile = Bun.file(profileOpencodePath);
+  const hasOpencodeConfig = await profileOpencodeFile.exists();
+  if (!hasOpencodeConfig && !options2.quiet) {
+    logger.warn(`No opencode.jsonc found at ${profileOpencodePath}. Create one to customize OpenCode settings.`);
   }
   const cwd = process.cwd();
   const gitContext = await detectGitRepo(cwd);
   const gitRoot = gitContext?.workTree ?? cwd;
   const discoveredPaths = await discoverProjectFiles(cwd, gitRoot);
-  const ghostConfig = await loadGhostConfig();
+  const ghostConfig = profile.ghost;
   const excludePaths = filterExcludedPaths(discoveredPaths, ghostConfig.include, ghostConfig.exclude);
   const tempDir = await createSymlinkFarm(cwd, excludePaths);
-  const ghostFiles = await discoverProjectFiles(ghostConfigDir, ghostConfigDir);
-  await injectGhostFiles(tempDir, ghostConfigDir, ghostFiles);
+  const ghostFiles = await discoverProjectFiles(profileDir, profileDir);
+  await injectGhostFiles(tempDir, profileDir, ghostFiles);
+  if (profile.hasAgents) {
+    const agentsPath = getProfileAgents(profileName);
+    const destAgentsPath = path6.join(tempDir, "AGENTS.md");
+    await copyFilePromise(agentsPath, destAgentsPath);
+  }
   let cleanupDone = false;
   const performCleanup = async () => {
     if (cleanupDone)
@@ -14494,8 +14722,9 @@ async function runGhostOpenCode(args, options2) {
     cwd: tempDir,
     env: {
       ...process.env,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify(openCodeConfig),
-      OPENCODE_CONFIG_DIR: ghostConfigDir,
+      ...profile.opencode && { OPENCODE_CONFIG_CONTENT: JSON.stringify(profile.opencode) },
+      OPENCODE_CONFIG_DIR: profileDir,
+      OCX_PROFILE: profileName,
       ...gitContext && {
         GIT_WORK_TREE: gitContext.workTree,
         GIT_DIR: gitContext.gitDir
@@ -14516,6 +14745,185 @@ async function runGhostOpenCode(args, options2) {
   }
 }
 
+// src/commands/ghost/profile/add.ts
+function registerProfileAddCommand(parent) {
+  parent.command("add <name>").description("Create a new ghost profile").option("--from <profile>", "Clone settings from existing profile").action(async (name, options2) => {
+    try {
+      await runProfileAdd(name, options2);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function runProfileAdd(name, options2) {
+  const manager = ProfileManager.create();
+  if (options2.from) {
+    const source = await manager.get(options2.from);
+    await manager.add(name);
+    await atomicWrite(getProfileGhostConfig(name), source.ghost);
+    logger.success(`Created profile "${name}" (cloned from "${options2.from}")`);
+  } else {
+    await manager.add(name);
+    logger.success(`Created profile "${name}"`);
+  }
+}
+
+// src/commands/ghost/profile/config.ts
+function registerProfileConfigCommand(parent) {
+  parent.command("config [name]").description("Open profile ghost.jsonc in editor").action(async (name) => {
+    try {
+      await runProfileConfig(name);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function runProfileConfig(name) {
+  const manager = ProfileManager.create();
+  const profileName = name ?? await manager.getCurrent();
+  await manager.get(profileName);
+  const configPath = getProfileGhostConfig(profileName);
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+  const proc = Bun.spawn([editor, configPath], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(`Editor exited with code ${exitCode}`);
+  }
+}
+
+// src/commands/ghost/profile/list.ts
+function registerProfileListCommand(parent) {
+  parent.command("list").alias("ls").description("List all ghost profiles").addOption(sharedOptions.json()).action(async (options2) => {
+    try {
+      await runProfileList(options2);
+    } catch (error) {
+      handleError(error, { json: options2.json });
+    }
+  });
+}
+async function runProfileList(options2) {
+  const manager = ProfileManager.create();
+  if (!await manager.isInitialized()) {
+    if (options2.json) {
+      console.log(JSON.stringify({ profiles: [], current: null }));
+    } else {
+      console.log("No profiles found. Run 'ocx ghost init' to create one.");
+    }
+    return;
+  }
+  const profiles = await manager.list();
+  const current = await manager.getCurrent();
+  if (options2.json) {
+    console.log(JSON.stringify({ profiles, current }, null, 2));
+    return;
+  }
+  if (profiles.length === 0) {
+    console.log("No profiles found.");
+    return;
+  }
+  for (const name of profiles) {
+    const marker = name === current ? "* " : "  ";
+    console.log(`${marker}${name}`);
+  }
+}
+
+// src/commands/ghost/profile/remove.ts
+function registerProfileRemoveCommand(parent) {
+  parent.command("remove <name>").alias("rm").description("Delete a ghost profile").option("-f, --force", "Skip confirmation and allow deleting current profile").action(async (name, options2) => {
+    try {
+      await runProfileRemove(name, options2);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function runProfileRemove(name, options2) {
+  const manager = ProfileManager.create();
+  if (!await manager.exists(name)) {
+    throw new ProfileNotFoundError(name);
+  }
+  if (!options2.force) {
+    if (!isTTY) {
+      throw new ValidationError("Cannot confirm deletion in non-interactive mode. Use --force to delete without confirmation.");
+    }
+    const confirmed = confirmDeletion(name);
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  await manager.remove(name, options2.force);
+  logger.success(`Deleted profile "${name}"`);
+}
+function confirmDeletion(name) {
+  const answer = prompt(`Delete profile "${name}"? This cannot be undone. [y/N]`);
+  return answer?.toLowerCase() === "y";
+}
+
+// src/commands/ghost/profile/show.ts
+function registerProfileShowCommand(parent) {
+  parent.command("show [name]").description("Display profile contents").addOption(sharedOptions.json()).action(async (name, options2) => {
+    try {
+      await runProfileShow(name, options2);
+    } catch (error) {
+      handleError(error, { json: options2.json });
+    }
+  });
+}
+async function runProfileShow(name, options2) {
+  const manager = ProfileManager.create();
+  const profileName = name ?? await manager.getCurrent();
+  const profile = await manager.get(profileName);
+  if (options2.json) {
+    console.log(JSON.stringify(profile, null, 2));
+    return;
+  }
+  console.log(`Profile: ${profile.name}`);
+  console.log(`
+Files:`);
+  console.log(`  ghost.jsonc: ${getProfileGhostConfig(profileName)}`);
+  if (profile.opencode) {
+    console.log(`  opencode.jsonc: ${getProfileOpencodeConfig(profileName)}`);
+  }
+  if (profile.hasAgents) {
+    console.log(`  AGENTS.md: ${getProfileAgents(profileName)}`);
+  }
+  console.log(`
+Ghost Config:`);
+  console.log(JSON.stringify(profile.ghost, null, 2));
+}
+
+// src/commands/ghost/profile/use.ts
+function registerProfileUseCommand(parent) {
+  parent.command("use <name>").description("Set the current ghost profile").action(async (name) => {
+    try {
+      await runProfileUse(name);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function runProfileUse(name) {
+  const manager = ProfileManager.create();
+  await manager.setCurrent(name);
+  logger.success(`Switched to profile "${name}"`);
+}
+
+// src/commands/ghost/profile/index.ts
+function registerGhostProfileCommand(parent) {
+  const profile = parent.command("profile").alias("p").description("Manage ghost mode profiles");
+  registerProfileListCommand(profile);
+  registerProfileAddCommand(profile);
+  registerProfileRemoveCommand(profile);
+  registerProfileUseCommand(profile);
+  registerProfileShowCommand(profile);
+  registerProfileConfigCommand(profile);
+}
+
 // src/commands/registry.ts
 async function runRegistryAddCore2(url, options2, callbacks) {
   if (callbacks.isLocked?.()) {
@@ -14644,11 +15052,12 @@ function registerRegistryCommand(program2) {
 }
 
 // src/commands/ghost/registry.ts
-async function ensureGhostInitialized() {
-  const exists2 = await ghostConfigExists();
-  if (!exists2) {
-    throw new GhostNotInitializedError;
+async function ensureProfilesInitialized() {
+  const manager = ProfileManager.create();
+  if (!await manager.isInitialized()) {
+    throw new ProfilesNotInitializedError;
   }
+  return manager;
 }
 function registerGhostRegistryCommand(parent) {
   const registry = parent.command("registry").description("Manage ghost mode registries");
@@ -14656,13 +15065,14 @@ function registerGhostRegistryCommand(parent) {
   addOutputOptions(addCmd);
   addCmd.action(async (url, options2) => {
     try {
-      await ensureGhostInitialized();
-      const config = await loadGhostConfig();
+      const manager = await ensureProfilesInitialized();
+      const profileName = await manager.getCurrent();
+      const profile = await manager.get(profileName);
       const result = await runRegistryAddCore2(url, options2, {
-        getRegistries: () => config.registries,
+        getRegistries: () => profile.ghost.registries,
         setRegistry: async (name, regConfig) => {
-          config.registries[name] = regConfig;
-          await saveGhostConfig(config);
+          profile.ghost.registries[name] = regConfig;
+          await atomicWrite(getProfileGhostConfig(profileName), profile.ghost);
         }
       });
       if (options2.json) {
@@ -14682,13 +15092,14 @@ function registerGhostRegistryCommand(parent) {
   addOutputOptions(removeCmd);
   removeCmd.action(async (name, options2) => {
     try {
-      await ensureGhostInitialized();
-      const config = await loadGhostConfig();
+      const manager = await ensureProfilesInitialized();
+      const profileName = await manager.getCurrent();
+      const profile = await manager.get(profileName);
       const result = await runRegistryRemoveCore(name, {
-        getRegistries: () => config.registries,
+        getRegistries: () => profile.ghost.registries,
         removeRegistry: async (regName) => {
-          delete config.registries[regName];
-          await saveGhostConfig(config);
+          delete profile.ghost.registries[regName];
+          await atomicWrite(getProfileGhostConfig(profileName), profile.ghost);
         }
       });
       if (options2.json) {
@@ -14704,10 +15115,11 @@ function registerGhostRegistryCommand(parent) {
   addOutputOptions(listCmd);
   listCmd.action(async (options2) => {
     try {
-      await ensureGhostInitialized();
-      const config = await loadGhostConfig();
+      const manager = await ensureProfilesInitialized();
+      const profileName = await manager.getCurrent();
+      const profile = await manager.get(profileName);
       const result = runRegistryListCore({
-        getRegistries: () => config.registries
+        getRegistries: () => profile.ghost.registries
       });
       if (options2.json) {
         outputJson({ success: true, data: result });
@@ -14880,12 +15292,14 @@ function registerGhostCommand(program2) {
   registerGhostAddCommand(ghost);
   registerGhostSearchCommand(ghost);
   registerGhostOpenCodeCommand(ghost);
+  registerGhostProfileCommand(ghost);
+  registerGhostMigrateCommand(ghost);
 }
 
 // src/commands/init.ts
 import { existsSync as existsSync2 } from "fs";
-import { cp, mkdir as mkdir6, readdir as readdir2, readFile, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { join as join7 } from "path";
+import { cp, mkdir as mkdir5, readdir as readdir4, readFile, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import { join as join6 } from "path";
 var TEMPLATE_REPO = "kdcokenny/ocx";
 var TEMPLATE_PATH = "examples/registry-starter";
 function registerInitCommand(program2) {
@@ -14903,7 +15317,7 @@ function registerInitCommand(program2) {
 }
 async function runInit(options2) {
   const cwd = options2.cwd ?? process.cwd();
-  const configPath = join7(cwd, "ocx.jsonc");
+  const configPath = join6(cwd, "ocx.jsonc");
   if (existsSync2(configPath)) {
     throw new ConflictError(`ocx.jsonc already exists at ${configPath}
 
@@ -14919,7 +15333,7 @@ async function runInit(options2) {
     };
     const config = ocxConfigSchema.parse(rawConfig);
     const content2 = JSON.stringify(config, null, 2);
-    await writeFile3(configPath, content2, "utf-8");
+    await writeFile2(configPath, content2, "utf-8");
     const opencodeResult = await ensureOpencodeConfig(cwd);
     spin?.succeed("Initialized OCX configuration");
     if (options2.json) {
@@ -14951,7 +15365,7 @@ async function runInitRegistry(directory, options2) {
   if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(namespace)) {
     throw new ValidationError("Invalid namespace format: must start with letter/number, use hyphens only between segments (e.g., 'my-registry')");
   }
-  const existingFiles = await readdir2(cwd).catch(() => []);
+  const existingFiles = await readdir4(cwd).catch(() => []);
   const hasVisibleFiles = existingFiles.some((f) => !f.startsWith("."));
   if (hasVisibleFiles && !options2.force) {
     throw new ConflictError("Directory is not empty. Use --force to overwrite existing files.");
@@ -14962,7 +15376,7 @@ async function runInitRegistry(directory, options2) {
     if (spin)
       spin.text = options2.local ? "Copying template..." : "Fetching template...";
     if (options2.local) {
-      await mkdir6(cwd, { recursive: true });
+      await mkdir5(cwd, { recursive: true });
       await copyDir(options2.local, cwd);
     } else {
       const version = options2.canary ? "main" : await getLatestVersion();
@@ -15010,12 +15424,12 @@ async function fetchAndExtractTemplate(destDir, version, verbose) {
   if (!response.ok || !response.body) {
     throw new NetworkError(`Failed to fetch template from ${tarballUrl}: ${response.statusText}`);
   }
-  const tempDir = join7(destDir, ".ocx-temp");
-  await mkdir6(tempDir, { recursive: true });
+  const tempDir = join6(destDir, ".ocx-temp");
+  await mkdir5(tempDir, { recursive: true });
   try {
-    const tarPath = join7(tempDir, "template.tar.gz");
+    const tarPath = join6(tempDir, "template.tar.gz");
     const arrayBuffer = await response.arrayBuffer();
-    await writeFile3(tarPath, Buffer.from(arrayBuffer));
+    await writeFile2(tarPath, Buffer.from(arrayBuffer));
     const proc = Bun.spawn(["tar", "-xzf", tarPath, "-C", tempDir], {
       stdout: "ignore",
       stderr: "pipe"
@@ -15025,15 +15439,15 @@ async function fetchAndExtractTemplate(destDir, version, verbose) {
       const stderr = await new Response(proc.stderr).text();
       throw new Error(`Failed to extract template: ${stderr}`);
     }
-    const extractedDirs = await readdir2(tempDir);
+    const extractedDirs = await readdir4(tempDir);
     const extractedDir = extractedDirs.find((d) => d.startsWith("ocx-"));
     if (!extractedDir) {
       throw new Error("Failed to find extracted template directory");
     }
-    const templateDir = join7(tempDir, extractedDir, TEMPLATE_PATH);
+    const templateDir = join6(tempDir, extractedDir, TEMPLATE_PATH);
     await copyDir(templateDir, destDir);
   } finally {
-    await rm2(tempDir, { recursive: true, force: true });
+    await rm3(tempDir, { recursive: true, force: true });
   }
 }
 async function replacePlaceholders(dir, values) {
@@ -15045,21 +15459,21 @@ async function replacePlaceholders(dir, values) {
     "AGENTS.md"
   ];
   for (const file of filesToProcess) {
-    const filePath = join7(dir, file);
+    const filePath = join6(dir, file);
     if (!existsSync2(filePath))
       continue;
     let content2 = await readFile(filePath).then((b) => b.toString());
     content2 = content2.replace(/my-registry/g, values.namespace);
     content2 = content2.replace(/Your Name/g, values.author);
-    await writeFile3(filePath, content2);
+    await writeFile2(filePath, content2);
   }
 }
 
 // src/commands/update.ts
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir7, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname6, join as join8 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname5, join as join7 } from "path";
 function registerUpdateCommand(program2) {
   program2.command("update [components...]").description("Update installed components (use @version suffix to pin, e.g., kdco/agents@1.2.0)").option("--all", "Update all installed components").option("--registry <name>", "Update all components from a specific registry").option("--dry-run", "Preview changes without applying").option("--cwd <path>", "Working directory", process.cwd()).option("-q, --quiet", "Suppress output").option("-v, --verbose", "Verbose output").option("--json", "Output as JSON").action(async (components, options2) => {
     try {
@@ -15071,7 +15485,7 @@ function registerUpdateCommand(program2) {
 }
 async function runUpdate(componentNames, options2) {
   const cwd = options2.cwd ?? process.cwd();
-  const lockPath = join8(cwd, "ocx.lock");
+  const lockPath = join7(cwd, "ocx.lock");
   const config = await readOcxConfig(cwd);
   if (!config) {
     throw new ConfigError("No ocx.jsonc found. Run 'ocx init' first.");
@@ -15196,12 +15610,12 @@ Version cannot be empty. Use 'kdco/agents@1.2.0' or omit the version for latest.
         const fileObj = update.component.files.find((f) => f.path === file.path);
         if (!fileObj)
           continue;
-        const targetPath = join8(cwd, fileObj.target);
-        const targetDir = dirname6(targetPath);
+        const targetPath = join7(cwd, fileObj.target);
+        const targetDir = dirname5(targetPath);
         if (!existsSync3(targetDir)) {
-          await mkdir7(targetDir, { recursive: true });
+          await mkdir6(targetDir, { recursive: true });
         }
-        await writeFile4(targetPath, file.content);
+        await writeFile3(targetPath, file.content);
         if (options2.verbose) {
           logger.info(`  \u2713 Updated ${fileObj.target}`);
         }
@@ -15220,7 +15634,7 @@ Version cannot be empty. Use 'kdco/agents@1.2.0' or omit the version for latest.
       };
     }
     installSpin?.succeed(`Updated ${updates.length} component(s)`);
-    await writeFile4(lockPath, JSON.stringify(lock, null, 2), "utf-8");
+    await writeFile3(lockPath, JSON.stringify(lock, null, 2), "utf-8");
     if (options2.json) {
       console.log(JSON.stringify({
         success: true,
@@ -15334,7 +15748,7 @@ async function hashBundle2(files) {
 `));
 }
 // src/index.ts
-var version = "1.1.1";
+var version = "1.2.0";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version);
   registerInitCommand(program2);
@@ -15361,4 +15775,4 @@ export {
   buildRegistry
 };
 
-//# debugId=66554E2EE245482F64756E2164756E21
+//# debugId=4A36829C127A179064756E2164756E21