ocx 1.4.1 → 1.4.3

package/dist/index.js

@@ -3949,7 +3949,7 @@ var require_fuzzysort = __commonJS((exports, module) => {
       results.total = resultsLen + limitedCount;
       return results;
     };
-    var highlight = (result, open = "<b>", close = "</b>") => {
+    var highlight2 = (result, open = "<b>", close = "</b>") => {
       var callback = typeof open === "function" ? open : undefined;
       var target = result.target;
       var targetLen = target.length;
@@ -4019,7 +4019,7 @@ var require_fuzzysort = __commonJS((exports, module) => {
         return this._indexes = indexes;
       }
       ["highlight"](open, close) {
-        return highlight(this, open, close);
+        return highlight2(this, open, close);
       }
       get ["score"]() {
         return normalizeScore(this._score);
@@ -4510,13 +4510,13 @@ var {
 // src/commands/add.ts
 import { createHash } from "crypto";
 import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir4, writeFile } from "fs/promises";
-import { dirname, join as join3 } from "path";
+import { mkdir as mkdir5, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
 
 // src/schemas/config.ts
 import { existsSync } from "fs";
 import { mkdir } from "fs/promises";
-import path from "path";
+import path2 from "path";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -9815,7 +9815,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 // src/schemas/registry.ts
-import { isAbsolute, normalize } from "path";
+import { isAbsolute as isAbsolute2, normalize } from "path";
 
 // src/utils/errors.ts
 var EXIT_CODES = {
@@ -9824,7 +9824,8 @@ var EXIT_CODES = {
   NOT_FOUND: 66,
   NETWORK: 69,
   CONFIG: 78,
-  INTEGRITY: 1
+  INTEGRITY: 1,
+  CONFLICT: 6
 };
 
 class OCXError extends Error {
@@ -9846,9 +9847,15 @@ class NotFoundError extends OCXError {
 }
 
 class NetworkError extends OCXError {
-  constructor(message) {
+  url;
+  status;
+  statusText;
+  constructor(message, options) {
     super(message, "NETWORK_ERROR", EXIT_CODES.NETWORK);
     this.name = "NetworkError";
+    this.url = options?.url;
+    this.status = options?.status;
+    this.statusText = options?.statusText;
   }
 }
 
@@ -9868,12 +9875,15 @@ class ValidationError extends OCXError {
 
 class ConflictError extends OCXError {
   constructor(message) {
-    super(message, "CONFLICT", EXIT_CODES.GENERAL);
+    super(message, "CONFLICT", EXIT_CODES.CONFLICT);
     this.name = "ConflictError";
   }
 }
 
 class IntegrityError extends OCXError {
+  component;
+  expected;
+  found;
   constructor(component, expected, found) {
     const message = `Integrity verification failed for "${component}"
 ` + `  Expected: ${expected}
@@ -9882,6 +9892,9 @@ class IntegrityError extends OCXError {
 ` + `The registry content has changed since this component was locked.
 ` + `Use 'ocx update ${component}' to intentionally update this component.`;
     super(message, "INTEGRITY_ERROR", EXIT_CODES.INTEGRITY);
+    this.component = component;
+    this.expected = expected;
+    this.found = found;
     this.name = "IntegrityError";
   }
 }
@@ -9901,33 +9914,124 @@ class OcxConfigError extends OCXError {
 }
 
 class ProfileNotFoundError extends OCXError {
-  constructor(name) {
-    super(`Profile "${name}" not found`, "NOT_FOUND", EXIT_CODES.NOT_FOUND);
+  profile;
+  constructor(profile) {
+    super(`Profile "${profile}" not found`, "NOT_FOUND", EXIT_CODES.NOT_FOUND);
+    this.profile = profile;
     this.name = "ProfileNotFoundError";
   }
 }
 
 class ProfileExistsError extends OCXError {
-  constructor(name) {
-    super(`Profile "${name}" already exists`, "CONFLICT", EXIT_CODES.GENERAL);
+  profile;
+  constructor(profile) {
+    super(`Profile "${profile}" already exists. Use --force to overwrite.`, "CONFLICT", EXIT_CODES.CONFLICT);
+    this.profile = profile;
     this.name = "ProfileExistsError";
   }
 }
 
+class RegistryExistsError extends OCXError {
+  registryName;
+  existingUrl;
+  newUrl;
+  targetLabel;
+  constructor(registryName, existingUrl, newUrl, targetLabel) {
+    const target = targetLabel ? ` in ${targetLabel}` : "";
+    const message = `Registry "${registryName}" already exists${target}.
+` + `  Current: ${existingUrl}
+` + `  New:     ${newUrl}
+
+` + `Use --force to overwrite.`;
+    super(message, "CONFLICT", EXIT_CODES.CONFLICT);
+    this.registryName = registryName;
+    this.existingUrl = existingUrl;
+    this.newUrl = newUrl;
+    this.targetLabel = targetLabel;
+    this.name = "RegistryExistsError";
+  }
+}
+
 class InvalidProfileNameError extends OCXError {
-  constructor(name, reason) {
-    super(`Invalid profile name "${name}": ${reason}`, "VALIDATION_ERROR", EXIT_CODES.GENERAL);
+  profile;
+  reason;
+  constructor(profile, reason) {
+    super(`Invalid profile name "${profile}": ${reason}`, "VALIDATION_ERROR", EXIT_CODES.GENERAL);
+    this.profile = profile;
+    this.reason = reason;
     this.name = "InvalidProfileNameError";
   }
 }
 
 class ProfilesNotInitializedError extends OCXError {
   constructor() {
-    super("Profiles not initialized. Run 'ocx profile add default' first.", "NOT_FOUND", EXIT_CODES.NOT_FOUND);
+    super("Profiles not initialized. Run 'ocx init --global' first.", "NOT_FOUND", EXIT_CODES.NOT_FOUND);
     this.name = "ProfilesNotInitializedError";
   }
 }
 
+// src/utils/path-security.ts
+import * as path from "path";
+
+class PathValidationError extends Error {
+  attemptedPath;
+  reason;
+  constructor(message, attemptedPath, reason) {
+    super(message);
+    this.attemptedPath = attemptedPath;
+    this.reason = reason;
+    this.name = "PathValidationError";
+  }
+}
+var WINDOWS_RESERVED = new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9"
+]);
+function validatePath(basePath, userPath) {
+  if (userPath.includes("\x00")) {
+    throw new PathValidationError("Path contains null bytes", userPath, "null_byte");
+  }
+  if (path.isAbsolute(userPath) || path.win32.isAbsolute(userPath)) {
+    throw new PathValidationError("Path must be relative", userPath, "absolute_path");
+  }
+  if (/^[a-zA-Z]:/.test(userPath) || userPath.startsWith("\\\\")) {
+    throw new PathValidationError("Path contains Windows absolute", userPath, "windows_absolute");
+  }
+  const baseName = path.basename(userPath).toUpperCase().split(".")[0] ?? "";
+  if (WINDOWS_RESERVED.has(baseName)) {
+    throw new PathValidationError("Path uses Windows reserved name", userPath, "windows_reserved");
+  }
+  const normalized = userPath.normalize("NFC");
+  const unified = normalized.replace(/\\/g, "/");
+  const resolvedBase = path.resolve(basePath);
+  const resolvedCombined = path.resolve(resolvedBase, unified);
+  const relativePath = path.relative(resolvedBase, resolvedCombined);
+  if (relativePath.startsWith("../") || relativePath.startsWith("..\\") || relativePath === ".." || path.isAbsolute(relativePath)) {
+    throw new PathValidationError("Path escapes base directory", userPath, "path_traversal");
+  }
+  return resolvedCombined;
+}
+
 // src/schemas/registry.ts
 var npmSpecifierSchema = exports_external.string().refine((val) => val.startsWith("npm:"), {
   message: 'npm specifier must start with "npm:" prefix'
@@ -9977,11 +10081,11 @@ var componentTypeSchema = exports_external.enum([
   "ocx:bundle",
   "ocx:profile"
 ]);
-var profileTargetPathSchema = exports_external.enum(["ocx.jsonc", "opencode.jsonc", "AGENTS.md"]);
-var targetPathSchema = exports_external.string().refine((path) => path.startsWith(".opencode/"), {
+var PROFILE_RESERVED_TARGETS = new Set(["ocx.lock", ".opencode"]);
+var targetPathSchema = exports_external.string().refine((path2) => path2.startsWith(".opencode/"), {
   message: 'Target path must start with ".opencode/"'
-}).refine((path) => {
-  const parts = path.split("/");
+}).refine((path2) => {
+  const parts = path2.split("/");
   const dir = parts[1];
   if (!dir)
     return false;
@@ -10110,7 +10214,7 @@ var componentManifestSchema = exports_external.object({
   opencode: opencodeConfigSchema.optional()
 });
 function validateSafePath(filePath) {
-  if (isAbsolute(filePath)) {
+  if (isAbsolute2(filePath)) {
     throw new ValidationError(`Invalid path: "${filePath}" - absolute paths not allowed`);
   }
   if (filePath.startsWith("~")) {
@@ -10127,17 +10231,18 @@ function inferTargetPath(sourcePath) {
 function validateFileTarget(target, componentType) {
   const isProfile = componentType === "ocx:profile";
   if (isProfile) {
-    const isProfileFile = profileTargetPathSchema.safeParse(target).success;
-    const isOpencodeTarget = target.startsWith(".opencode/");
-    if (!isProfileFile && !isOpencodeTarget) {
-      throw new ValidationError(`Invalid profile target: "${target}". ` + `Must be a profile file (ocx.jsonc, opencode.jsonc, AGENTS.md) or start with ".opencode/"`);
+    if (PROFILE_RESERVED_TARGETS.has(target)) {
+      throw new ValidationError(`Target "${target}" is reserved for installer use`);
     }
-    if (isOpencodeTarget) {
-      const parseResult = targetPathSchema.safeParse(target);
-      if (!parseResult.success) {
-        throw new ValidationError(`Invalid embedded target: "${target}". ${parseResult.error.errors[0]?.message}`);
+    try {
+      validatePath("/dummy/base", target);
+    } catch (error) {
+      if (error instanceof PathValidationError) {
+        throw new ValidationError(`Invalid profile target "${target}": ${error.message}`);
       }
+      throw error;
     }
+    return;
   } else {
     const parseResult = targetPathSchema.safeParse(target);
     if (!parseResult.success) {
@@ -10269,8 +10374,8 @@ var CONFIG_FILE = "ocx.jsonc";
 var LOCK_FILE = "ocx.lock";
 var LOCAL_CONFIG_DIR = ".opencode";
 function findOcxConfig(cwd) {
-  const dotOpencodePath = path.join(cwd, LOCAL_CONFIG_DIR, CONFIG_FILE);
-  const rootPath = path.join(cwd, CONFIG_FILE);
+  const dotOpencodePath = path2.join(cwd, LOCAL_CONFIG_DIR, CONFIG_FILE);
+  const rootPath = path2.join(cwd, CONFIG_FILE);
   const dotOpencodeExists = existsSync(dotOpencodePath);
   const rootExists = existsSync(rootPath);
   if (dotOpencodeExists && rootExists) {
@@ -10285,8 +10390,8 @@ function findOcxConfig(cwd) {
   return { path: dotOpencodePath, exists: false };
 }
 function findOcxLock(cwd, options) {
-  const dotOpencodePath = path.join(cwd, LOCAL_CONFIG_DIR, LOCK_FILE);
-  const rootPath = path.join(cwd, LOCK_FILE);
+  const dotOpencodePath = path2.join(cwd, LOCAL_CONFIG_DIR, LOCK_FILE);
+  const rootPath = path2.join(cwd, LOCK_FILE);
   if (options?.isFlattened) {
     if (existsSync(rootPath)) {
       return { path: rootPath, exists: true };
@@ -10317,8 +10422,8 @@ async function readOcxConfig(cwd) {
   }
 }
 async function writeOcxConfig(cwd, config, existingPath) {
-  const configPath = existingPath ?? path.join(cwd, LOCAL_CONFIG_DIR, CONFIG_FILE);
-  await mkdir(path.dirname(configPath), { recursive: true });
+  const configPath = existingPath ?? path2.join(cwd, LOCAL_CONFIG_DIR, CONFIG_FILE);
+  await mkdir(path2.dirname(configPath), { recursive: true });
   const content = JSON.stringify(config, null, 2);
   await Bun.write(configPath, content);
 }
@@ -10333,8 +10438,8 @@ async function readOcxLock(cwd, options) {
   return ocxLockSchema.parse(json);
 }
 async function writeOcxLock(cwd, lock, existingPath) {
-  const lockPath = existingPath ?? path.join(cwd, LOCAL_CONFIG_DIR, LOCK_FILE);
-  await mkdir(path.dirname(lockPath), { recursive: true });
+  const lockPath = existingPath ?? path2.join(cwd, LOCAL_CONFIG_DIR, LOCK_FILE);
+  await mkdir(path2.dirname(lockPath), { recursive: true });
   const content = JSON.stringify(lock, null, 2);
   await Bun.write(lockPath, content);
 }
@@ -10342,10 +10447,10 @@ async function writeOcxLock(cwd, lock, existingPath) {
 // src/utils/paths.ts
 import { stat } from "fs/promises";
 import { homedir } from "os";
-import { isAbsolute as isAbsolute2, join } from "path";
+import { isAbsolute as isAbsolute3, join } from "path";
 function getGlobalConfigPath() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  const base = xdg && isAbsolute2(xdg) ? xdg : join(homedir(), ".config");
+  const base = xdg && isAbsolute3(xdg) ? xdg : join(homedir(), ".config");
   return join(base, "opencode");
 }
 async function globalDirectoryExists() {
@@ -10399,7 +10504,7 @@ class GlobalConfigProvider {
   static async requireInitialized() {
     const basePath = getGlobalConfigPath();
     if (!await globalDirectoryExists()) {
-      throw new ConfigError("Global config not found. Run 'opencode' once to initialize, then retry.");
+      throw new ConfigError("Global config not found. Run 'ocx init --global' first.");
     }
     const config = await readOcxConfig(basePath);
     return new GlobalConfigProvider(basePath, config);
@@ -10414,19 +10519,19 @@ class GlobalConfigProvider {
 
 // src/config/resolver.ts
 import { existsSync as existsSync3, statSync as statSync2 } from "fs";
-import { join as join2, relative } from "path";
+import { join as join2, relative as relative2 } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
 
 // src/profile/manager.ts
-import { mkdir as mkdir2, readdir, rm, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir2, readdir, rename as rename2, rm, stat as stat2 } from "fs/promises";
 
 // src/schemas/ocx.ts
 var {Glob } = globalThis.Bun;
 
 // src/utils/path-helpers.ts
-import path2 from "path";
+import path3 from "path";
 function isAbsolutePath(p) {
-  return path2.posix.isAbsolute(p) || path2.win32.isAbsolute(p);
+  return path3.posix.isAbsolute(p) || path3.win32.isAbsolute(p);
 }
 
 // src/schemas/common.ts
@@ -10448,7 +10553,6 @@ var profileOcxConfigSchema = exports_external.object({
   componentPath: safeRelativePathSchema.optional(),
   renameWindow: exports_external.boolean().default(true).describe("Set terminal/tmux window name when launching OpenCode"),
   exclude: exports_external.array(globPatternSchema).default([
-    "**/AGENTS.md",
     "**/CLAUDE.md",
     "**/CONTEXT.md",
     "**/.opencode/**",
@@ -10476,38 +10580,38 @@ async function atomicWrite(filePath, data) {
 // src/profile/paths.ts
 import { existsSync as existsSync2, statSync } from "fs";
 import { homedir as homedir2 } from "os";
-import path3 from "path";
+import path4 from "path";
 var OCX_CONFIG_FILE = "ocx.jsonc";
 var OPENCODE_CONFIG_FILE = "opencode.jsonc";
 var LOCAL_CONFIG_DIR2 = ".opencode";
 function getProfilesDir() {
-  const base = process.env.XDG_CONFIG_HOME || path3.join(homedir2(), ".config");
-  return path3.join(base, "opencode", "profiles");
+  const base = process.env.XDG_CONFIG_HOME || path4.join(homedir2(), ".config");
+  return path4.join(base, "opencode", "profiles");
 }
 function getProfileDir(name) {
-  return path3.join(getProfilesDir(), name);
+  return path4.join(getProfilesDir(), name);
 }
 function getProfileOcxConfig(name) {
-  return path3.join(getProfileDir(name), "ocx.jsonc");
+  return path4.join(getProfileDir(name), "ocx.jsonc");
 }
 function getProfileOpencodeConfig(name) {
-  return path3.join(getProfileDir(name), "opencode.jsonc");
+  return path4.join(getProfileDir(name), "opencode.jsonc");
 }
 function getProfileAgents(name) {
-  return path3.join(getProfileDir(name), "AGENTS.md");
+  return path4.join(getProfileDir(name), "AGENTS.md");
 }
 function findLocalConfigDir(cwd) {
   let currentDir = cwd;
   while (true) {
-    const configDir = path3.join(currentDir, LOCAL_CONFIG_DIR2);
+    const configDir = path4.join(currentDir, LOCAL_CONFIG_DIR2);
     if (existsSync2(configDir) && statSync(configDir).isDirectory()) {
       return configDir;
     }
-    const gitDir = path3.join(currentDir, ".git");
+    const gitDir = path4.join(currentDir, ".git");
     if (existsSync2(gitDir)) {
       return null;
     }
-    const parentDir = path3.dirname(currentDir);
+    const parentDir = path4.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -10515,8 +10619,8 @@ function findLocalConfigDir(cwd) {
   }
 }
 function getGlobalConfig() {
-  const base = process.env.XDG_CONFIG_HOME || path3.join(homedir2(), ".config");
-  return path3.join(base, "opencode", "ocx.jsonc");
+  const base = process.env.XDG_CONFIG_HOME || path4.join(homedir2(), ".config");
+  return path4.join(base, "opencode", "ocx.jsonc");
 }
 
 // src/profile/schema.ts
@@ -10534,7 +10638,6 @@ var DEFAULT_OCX_CONFIG = {
   registries: {},
   renameWindow: true,
   exclude: [
-    "**/AGENTS.md",
     "**/CLAUDE.md",
     "**/CONTEXT.md",
     "**/.opencode/**",
@@ -10543,6 +10646,21 @@ var DEFAULT_OCX_CONFIG = {
   ],
   include: []
 };
+var DEFAULT_OCX_CONFIG_TEMPLATE = `{
+  "$schema": "https://ocx.kdco.dev/schemas/ocx.json",
+  "registries": {},
+  "renameWindow": true,
+  "exclude": [
+    // "**/AGENTS.md",
+    "**/CLAUDE.md",
+    "**/CONTEXT.md",
+    "**/.opencode/**",
+    "**/opencode.jsonc",
+    "**/opencode.json"
+  ],
+  "include": []
+}
+`;
 
 class ProfileManager {
   profilesDir;
@@ -10626,7 +10744,25 @@ class ProfileManager {
     const dir = getProfileDir(name);
     await mkdir2(dir, { recursive: true, mode: 448 });
     const ocxPath = getProfileOcxConfig(name);
-    await atomicWrite(ocxPath, DEFAULT_OCX_CONFIG);
+    const ocxFile = Bun.file(ocxPath);
+    if (!await ocxFile.exists()) {
+      await Bun.write(ocxPath, DEFAULT_OCX_CONFIG_TEMPLATE, { mode: 384 });
+    }
+    const opencodePath = getProfileOpencodeConfig(name);
+    const opencodeFile = Bun.file(opencodePath);
+    if (!await opencodeFile.exists()) {
+      await atomicWrite(opencodePath, {});
+    }
+    const agentsPath = getProfileAgents(name);
+    const agentsFile = Bun.file(agentsPath);
+    if (!await agentsFile.exists()) {
+      const agentsContent = `# Profile Instructions
+
+<!-- Add your custom instructions for this profile here -->
+<!-- These will be included when running \`ocx opencode -p ${name}\` -->
+`;
+      await Bun.write(agentsPath, agentsContent, { mode: 384 });
+    }
   }
   async remove(name) {
     if (!await this.exists(name)) {
@@ -10639,6 +10775,44 @@ class ProfileManager {
     const dir = getProfileDir(name);
     await rm(dir, { recursive: true });
   }
+  async move(oldName, newName) {
+    const oldResult = profileNameSchema.safeParse(oldName);
+    if (!oldResult.success) {
+      throw new InvalidProfileNameError(oldName, oldResult.error.errors[0]?.message ?? "Invalid name");
+    }
+    const newResult = profileNameSchema.safeParse(newName);
+    if (!newResult.success) {
+      throw new InvalidProfileNameError(newName, newResult.error.errors[0]?.message ?? "Invalid name");
+    }
+    await this.ensureInitialized();
+    if (!await this.exists(oldName)) {
+      throw new ProfileNotFoundError(oldName);
+    }
+    if (oldName === newName) {
+      return { warnActiveProfile: false };
+    }
+    if (await this.exists(newName)) {
+      throw new ConflictError(`Cannot move: profile "${newName}" already exists. Remove it first with 'ocx p rm ${newName}'.`);
+    }
+    const warnActiveProfile = process.env.OCX_PROFILE === oldName;
+    const oldDir = getProfileDir(oldName);
+    const newDir = getProfileDir(newName);
+    try {
+      await rename2(oldDir, newDir);
+    } catch (error) {
+      if (error instanceof Error && "code" in error) {
+        const code = error.code;
+        if (code === "EEXIST" || code === "ENOTEMPTY") {
+          throw new ConflictError(`Cannot move: profile "${newName}" already exists. Remove it first with 'ocx p rm ${newName}'.`);
+        }
+        if (code === "ENOENT") {
+          throw new ProfileNotFoundError(oldName);
+        }
+      }
+      throw error;
+    }
+    return { warnActiveProfile };
+  }
   async resolveProfile(override) {
     if (override) {
       if (!await this.exists(override)) {
@@ -10688,7 +10862,7 @@ function discoverInstructionFiles(projectDir, gitRoot) {
     for (const filename of INSTRUCTION_FILES) {
       const filePath = join2(currentDir, filename);
       if (existsSync3(filePath) && statSync2(filePath).isFile()) {
-        const relativePath = relative(root, filePath);
+        const relativePath = relative2(root, filePath);
         discovered.push(relativePath);
       }
     }
@@ -10765,11 +10939,13 @@ class ConfigResolver {
       }
     }
     const shouldLoadLocal = this.shouldLoadLocalConfig();
-    if (shouldLoadLocal && this.localConfigDir) {
+    if (!this.profile && shouldLoadLocal && this.localConfigDir) {
       const localOcxConfig = this.loadLocalOcxConfig();
       if (localOcxConfig) {
-        registries = { ...registries, ...localOcxConfig.registries };
+        registries = localOcxConfig.registries;
       }
+    }
+    if (shouldLoadLocal && this.localConfigDir) {
       const localOpencodeConfig = this.loadLocalOpencodeConfig();
       if (localOpencodeConfig) {
         opencode = this.deepMerge(opencode, localOpencodeConfig);
@@ -10810,7 +10986,7 @@ class ConfigResolver {
       }
     }
     const shouldLoadLocal = this.shouldLoadLocalConfig();
-    if (shouldLoadLocal && this.localConfigDir) {
+    if (!this.profile && shouldLoadLocal && this.localConfigDir) {
       const localOcxConfig = this.loadLocalOcxConfig();
       if (localOcxConfig) {
         const localOcxPath = join2(this.localConfigDir, OCX_CONFIG_FILE);
@@ -10819,6 +10995,8 @@ class ConfigResolver {
           origins.set(`registries.${key}`, { path: localOcxPath, source: "local-config" });
         }
       }
+    }
+    if (shouldLoadLocal && this.localConfigDir) {
       const localOpencodeConfig = this.loadLocalOpencodeConfig();
       if (localOpencodeConfig) {
         opencode = this.deepMerge(opencode, localOpencodeConfig);
@@ -10845,7 +11023,7 @@ class ConfigResolver {
       return true;
     const gitRoot = detectGitRoot(this.cwd);
     const root = gitRoot ?? this.cwd;
-    const relativePath = relative(root, this.localConfigDir);
+    const relativePath = relative2(root, this.localConfigDir);
     const exclude = this.profile.ocx.exclude ?? [];
     const include = this.profile.ocx.include ?? [];
     for (const pattern of include) {
@@ -10938,7 +11116,7 @@ class ConfigResolver {
 // package.json
 var package_default = {
   name: "ocx",
-  version: "1.4.1",
+  version: "1.4.3",
   description: "OCX CLI - ShadCN-style registry for OpenCode extensions. Install agents, plugins, skills, and MCP servers.",
   author: "kdcokenny",
   license: "MIT",
@@ -11017,14 +11195,28 @@ async function fetchWithCache(url, parse3) {
     return cached;
   }
   const promise = (async () => {
-    const response = await fetch(url);
+    let response;
+    try {
+      response = await fetch(url);
+    } catch (error) {
+      throw new NetworkError(`Network request failed for ${url}: ${error instanceof Error ? error.message : String(error)}`, { url });
+    }
     if (!response.ok) {
       if (response.status === 404) {
         throw new NotFoundError(`Not found: ${url}`);
       }
-      throw new NetworkError(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+      throw new NetworkError(`Failed to fetch ${url}: ${response.status} ${response.statusText}`, {
+        url,
+        status: response.status,
+        statusText: response.statusText
+      });
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch (error) {
+      throw new NetworkError(`Invalid JSON response from ${url}: ${error instanceof Error ? error.message : String(error)}`, { url });
     }
-    const data = await response.json();
     return parse3(data);
   })();
   cache.set(url, promise);
@@ -11071,9 +11263,14 @@ async function fetchComponentVersion(baseUrl, name, version) {
 }
 async function fetchFileContent(baseUrl, componentName, filePath) {
   const url = `${baseUrl.replace(/\/$/, "")}/components/${componentName}/${filePath}`;
-  const response = await fetch(url);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    throw new NetworkError(`Network request failed for ${url}: ${error instanceof Error ? error.message : String(error)}`, { url });
+  }
   if (!response.ok) {
-    throw new NetworkError(`Failed to fetch file ${filePath} for ${componentName}: ${response.status} ${response.statusText}`);
+    throw new NetworkError(`Failed to fetch file ${filePath} for ${componentName} from ${url}: ${response.status} ${response.statusText}`, { url, status: response.status, statusText: response.statusText });
   }
   return response.text();
 }
@@ -11148,13 +11345,13 @@ async function resolveDependencies(registries, componentNames) {
   const npmDeps = new Set;
   const npmDevDeps = new Set;
   let opencode = {};
-  async function resolve(componentNamespace, componentName, path4 = []) {
+  async function resolve2(componentNamespace, componentName, path5 = []) {
     const qualifiedName = createQualifiedComponent(componentNamespace, componentName);
     if (resolved.has(qualifiedName)) {
       return;
     }
     if (visiting.has(qualifiedName)) {
-      const cycle = [...path4, qualifiedName].join(" \u2192 ");
+      const cycle = [...path5, qualifiedName].join(" \u2192 ");
       throw new ValidationError(`Circular dependency detected: ${cycle}`);
     }
     visiting.add(qualifiedName);
@@ -11165,12 +11362,21 @@ async function resolveDependencies(registries, componentNames) {
     let component;
     try {
       component = await fetchComponent(regConfig.url, componentName);
-    } catch (_err) {
-      throw new OCXError(`Component '${componentName}' not found in registry '${componentNamespace}'.`, "NOT_FOUND");
+    } catch (err) {
+      if (err instanceof NetworkError) {
+        throw err;
+      }
+      if (err instanceof NotFoundError) {
+        throw new NotFoundError(`Component '${componentName}' not found in registry '${componentNamespace}'.`);
+      }
+      if (err instanceof OCXError) {
+        throw err;
+      }
+      throw new NetworkError(`Failed to fetch component '${componentName}' from registry '${componentNamespace}': ${err instanceof Error ? err.message : String(err)}`, { url: regConfig.url });
     }
     for (const dep of component.dependencies) {
       const depRef = parseComponentRef(dep, componentNamespace);
-      await resolve(depRef.namespace, depRef.component, [...path4, qualifiedName]);
+      await resolve2(depRef.namespace, depRef.component, [...path5, qualifiedName]);
     }
     const normalizedComponent = normalizeComponentManifest(component);
     resolved.set(qualifiedName, {
@@ -11197,7 +11403,7 @@ async function resolveDependencies(registries, componentNames) {
   }
   for (const name of componentNames) {
     const ref = parseComponentRef(name);
-    await resolve(ref.namespace, ref.component);
+    await resolve2(ref.namespace, ref.component);
   }
   const components = Array.from(resolved.values());
   const installOrder = Array.from(resolved.keys());
@@ -11214,17 +11420,17 @@ async function resolveDependencies(registries, componentNames) {
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import path4 from "path";
+import path5 from "path";
 var LOCAL_CONFIG_DIR3 = ".opencode";
 function isGlobalConfigPath(cwd) {
-  const base = process.env.XDG_CONFIG_HOME || path4.join(homedir3(), ".config");
-  const globalConfigDir = path4.resolve(base, "opencode");
-  const resolvedCwd = path4.resolve(cwd);
+  const base = process.env.XDG_CONFIG_HOME || path5.join(homedir3(), ".config");
+  const globalConfigDir = path5.resolve(base, "opencode");
+  const resolvedCwd = path5.resolve(cwd);
   if (resolvedCwd === globalConfigDir) {
     return true;
   }
-  const relative2 = path4.relative(globalConfigDir, resolvedCwd);
-  return relative2 !== "" && !relative2.startsWith("..") && !path4.isAbsolute(relative2);
+  const relative3 = path5.relative(globalConfigDir, resolvedCwd);
+  return relative3 !== "" && !relative3.startsWith("..") && !path5.isAbsolute(relative3);
 }
 var JSONC_OPTIONS = {
   formattingOptions: {
@@ -11241,8 +11447,8 @@ var OPENCODE_CONFIG_TEMPLATE = `{
 `;
 function findOpencodeConfig(cwd) {
   if (isGlobalConfigPath(cwd)) {
-    const rootJsonc2 = path4.join(cwd, "opencode.jsonc");
-    const rootJson2 = path4.join(cwd, "opencode.json");
+    const rootJsonc2 = path5.join(cwd, "opencode.jsonc");
+    const rootJson2 = path5.join(cwd, "opencode.json");
     if (existsSync4(rootJsonc2)) {
       return { path: rootJsonc2, exists: true };
     }
@@ -11251,16 +11457,16 @@ function findOpencodeConfig(cwd) {
     }
     return { path: rootJsonc2, exists: false };
   }
-  const dotOpencodeJsonc = path4.join(cwd, LOCAL_CONFIG_DIR3, "opencode.jsonc");
-  const dotOpencodeJson = path4.join(cwd, LOCAL_CONFIG_DIR3, "opencode.json");
+  const dotOpencodeJsonc = path5.join(cwd, LOCAL_CONFIG_DIR3, "opencode.jsonc");
+  const dotOpencodeJson = path5.join(cwd, LOCAL_CONFIG_DIR3, "opencode.json");
   if (existsSync4(dotOpencodeJsonc)) {
     return { path: dotOpencodeJsonc, exists: true };
   }
   if (existsSync4(dotOpencodeJson)) {
     return { path: dotOpencodeJson, exists: true };
   }
-  const rootJsonc = path4.join(cwd, "opencode.jsonc");
-  const rootJson = path4.join(cwd, "opencode.json");
+  const rootJsonc = path5.join(cwd, "opencode.jsonc");
+  const rootJson = path5.join(cwd, "opencode.json");
   if (existsSync4(rootJsonc)) {
     return { path: rootJsonc, exists: true };
   }
@@ -11274,7 +11480,7 @@ async function ensureOpencodeConfig(cwd) {
   if (exists) {
     return { path: configPath, created: false };
   }
-  await mkdir3(path4.dirname(configPath), { recursive: true });
+  await mkdir3(path5.dirname(configPath), { recursive: true });
   await Bun.write(configPath, OPENCODE_CONFIG_TEMPLATE);
   return { path: configPath, created: true };
 }
@@ -11291,13 +11497,13 @@ async function readOpencodeJsonConfig(cwd) {
     path: configPath
   };
 }
-async function writeOpencodeJsonConfig(path5, content) {
-  await Bun.write(path5, content);
+async function writeOpencodeJsonConfig(path6, content) {
+  await Bun.write(path6, content);
 }
-function getValueAtPath(content, path5) {
+function getValueAtPath(content, path6) {
   const parsed = parse2(content, [], { allowTrailingComma: true });
   let current = parsed;
-  for (const segment of path5) {
+  for (const segment of path6) {
     if (current === null || current === undefined)
       return;
     if (typeof current !== "object")
@@ -11306,27 +11512,27 @@ function getValueAtPath(content, path5) {
   }
   return current;
 }
-function applyValueAtPath(content, path5, value) {
+function applyValueAtPath(content, path6, value) {
   if (value === null || value === undefined) {
     return content;
   }
   if (typeof value === "object" && !Array.isArray(value)) {
-    const existingValue = getValueAtPath(content, path5);
+    const existingValue = getValueAtPath(content, path6);
     if (existingValue !== undefined && (existingValue === null || typeof existingValue !== "object")) {
-      const edits2 = modify(content, path5, value, JSONC_OPTIONS);
+      const edits2 = modify(content, path6, value, JSONC_OPTIONS);
       return applyEdits(content, edits2);
     }
     let updatedContent = content;
     for (const [key, val] of Object.entries(value)) {
-      updatedContent = applyValueAtPath(updatedContent, [...path5, key], val);
+      updatedContent = applyValueAtPath(updatedContent, [...path6, key], val);
     }
     return updatedContent;
   }
   if (Array.isArray(value)) {
-    const edits2 = modify(content, path5, value, JSONC_OPTIONS);
+    const edits2 = modify(content, path6, value, JSONC_OPTIONS);
     return applyEdits(content, edits2);
   }
-  const edits = modify(content, path5, value, JSONC_OPTIONS);
+  const edits = modify(content, path6, value, JSONC_OPTIONS);
   return applyEdits(content, edits);
 }
 async function updateOpencodeJsonConfig(cwd, opencode) {
@@ -11340,8 +11546,8 @@ async function updateOpencodeJsonConfig(cwd, opencode) {
   } else {
     const config = { $schema: "https://opencode.ai/config.json" };
     content = JSON.stringify(config, null, "\t");
-    configPath = isGlobalConfigPath(cwd) ? path4.join(cwd, "opencode.jsonc") : path4.join(cwd, LOCAL_CONFIG_DIR3, "opencode.jsonc");
-    await mkdir3(path4.dirname(configPath), { recursive: true });
+    configPath = isGlobalConfigPath(cwd) ? path5.join(cwd, "opencode.jsonc") : path5.join(cwd, LOCAL_CONFIG_DIR3, "opencode.jsonc");
+    await mkdir3(path5.dirname(configPath), { recursive: true });
     created = true;
   }
   const originalContent = content;
@@ -11383,7 +11589,7 @@ function parseEnvBool(value, defaultValue) {
   return defaultValue;
 }
 // src/utils/git-context.ts
-import { basename, resolve } from "path";
+import { basename as basename2, resolve as resolve2 } from "path";
 function getGitEnv() {
   const { GIT_DIR: _, GIT_WORK_TREE: __, ...cleanEnv } = process.env;
   return cleanEnv;
@@ -11449,12 +11655,100 @@ async function getRepoName(cwd) {
   if (!rootPath) {
     return null;
   }
-  return basename(rootPath);
+  return basename2(rootPath);
 }
 async function getGitInfo(cwd) {
   const [repoName, branch] = await Promise.all([getRepoName(cwd), getBranch(cwd)]);
   return { repoName, branch };
 }
+// src/lib/build-registry.ts
+import { mkdir as mkdir4 } from "fs/promises";
+import { dirname, join as join3 } from "path";
+class BuildRegistryError extends Error {
+  errors;
+  constructor(message, errors2 = []) {
+    super(message);
+    this.errors = errors2;
+    this.name = "BuildRegistryError";
+  }
+}
+async function buildRegistry(options) {
+  const { source: sourcePath, out: outPath } = options;
+  const jsoncFile = Bun.file(join3(sourcePath, "registry.jsonc"));
+  const jsonFile = Bun.file(join3(sourcePath, "registry.json"));
+  const jsoncExists = await jsoncFile.exists();
+  const jsonExists = await jsonFile.exists();
+  if (!jsoncExists && !jsonExists) {
+    throw new BuildRegistryError("No registry.jsonc or registry.json found in source directory");
+  }
+  const registryFile = jsoncExists ? jsoncFile : jsonFile;
+  const content = await registryFile.text();
+  const registryData = parse2(content, [], { allowTrailingComma: true });
+  const parseResult = registrySchema.safeParse(registryData);
+  if (!parseResult.success) {
+    const errors2 = parseResult.error.errors.map((e3) => `${e3.path.join(".")}: ${e3.message}`);
+    throw new BuildRegistryError("Registry validation failed", errors2);
+  }
+  const registry = parseResult.data;
+  const validationErrors = [];
+  const componentsDir = join3(outPath, "components");
+  await mkdir4(componentsDir, { recursive: true });
+  for (const component of registry.components) {
+    const packument = {
+      name: component.name,
+      versions: {
+        [registry.version]: component
+      },
+      "dist-tags": {
+        latest: registry.version
+      }
+    };
+    const packumentPath = join3(componentsDir, `${component.name}.json`);
+    await Bun.write(packumentPath, JSON.stringify(packument, null, 2));
+    for (const rawFile of component.files) {
+      const file = normalizeFile(rawFile, component.type);
+      const sourceFilePath = join3(sourcePath, "files", file.path);
+      const destFilePath = join3(componentsDir, component.name, file.path);
+      const destFileDir = dirname(destFilePath);
+      if (!await Bun.file(sourceFilePath).exists()) {
+        validationErrors.push(`${component.name}: Source file not found at ${sourceFilePath}`);
+        continue;
+      }
+      await mkdir4(destFileDir, { recursive: true });
+      const sourceFile = Bun.file(sourceFilePath);
+      await Bun.write(destFilePath, sourceFile);
+    }
+  }
+  if (validationErrors.length > 0) {
+    throw new BuildRegistryError(`Build failed with ${validationErrors.length} errors`, validationErrors);
+  }
+  const index = {
+    name: registry.name,
+    namespace: registry.namespace,
+    version: registry.version,
+    author: registry.author,
+    ...registry.opencode && { opencode: registry.opencode },
+    ...registry.ocx && { ocx: registry.ocx },
+    components: registry.components.map((c) => ({
+      name: c.name,
+      type: c.type,
+      description: c.description
+    }))
+  };
+  await Bun.write(join3(outPath, "index.json"), JSON.stringify(index, null, 2));
+  const wellKnownDir = join3(outPath, ".well-known");
+  await mkdir4(wellKnownDir, { recursive: true });
+  const discovery = { registry: "/index.json" };
+  await Bun.write(join3(wellKnownDir, "ocx.json"), JSON.stringify(discovery, null, 2));
+  return {
+    name: registry.name,
+    namespace: registry.namespace,
+    version: registry.version,
+    componentsCount: registry.components.length,
+    outputPath: outPath
+  };
+}
+
 // ../../node_modules/.bun/kleur@4.1.5/node_modules/kleur/index.mjs
 var FORCE_COLOR;
 var NODE_DISABLE_COLORS;
@@ -11592,6 +11886,15 @@ var logger = {
     console.log("");
   }
 };
+var highlight = {
+  component: (text) => kleur_default.cyan(text),
+  path: (text) => kleur_default.green(text),
+  command: (text) => kleur_default.yellow(text),
+  url: (text) => kleur_default.blue().underline(text),
+  error: (text) => kleur_default.red(text),
+  dim: (text) => kleur_default.gray(text),
+  bold: (text) => kleur_default.bold(text)
+};
 
 // src/utils/handle-error.ts
 function handleError(error, options2 = {}) {
@@ -11607,8 +11910,8 @@ function handleError(error, options2 = {}) {
   if (error instanceof ZodError) {
     logger.error("Validation failed:");
     for (const issue of error.issues) {
-      const path5 = issue.path.join(".");
-      logger.error(`  ${path5}: ${issue.message}`);
+      const path6 = issue.path.join(".");
+      logger.error(`  ${path6}: ${issue.message}`);
     }
     process.exit(EXIT_CODES.CONFIG);
   }
@@ -11632,6 +11935,129 @@ function wrapAction(action) {
   };
 }
 function formatErrorAsJson(error) {
+  if (error instanceof RegistryExistsError) {
+    return {
+      success: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        details: {
+          registryName: error.registryName,
+          existingUrl: error.existingUrl,
+          newUrl: error.newUrl,
+          ...error.targetLabel && { targetLabel: error.targetLabel }
+        }
+      },
+      exitCode: error.exitCode,
+      meta: {
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+  if (error instanceof IntegrityError) {
+    return {
+      success: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        details: {
+          component: error.component,
+          expected: error.expected,
+          found: error.found
+        }
+      },
+      exitCode: error.exitCode,
+      meta: {
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+  if (error instanceof NetworkError) {
+    const details = {};
+    if (error.url)
+      details.url = error.url;
+    if (error.status !== undefined)
+      details.status = error.status;
+    if (error.statusText)
+      details.statusText = error.statusText;
+    return {
+      success: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        ...Object.keys(details).length > 0 && { details }
+      },
+      exitCode: error.exitCode,
+      meta: {
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+  if (error instanceof ProfileNotFoundError) {
+    return {
+      success: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        details: {
+          profile: error.profile
+        }
+      },
+      exitCode: error.exitCode,
+      meta: {
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+  if (error instanceof ProfileExistsError) {
+    return {
+      success: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        details: {
+          profile: error.profile
+        }
+      },
+      exitCode: error.exitCode,
+      meta: {
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+  if (error instanceof InvalidProfileNameError) {
+    return {
+      success: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        details: {
+          profile: error.profile,
+          reason: error.reason
+        }
+      },
+      exitCode: error.exitCode,
+      meta: {
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+  if (error instanceof BuildRegistryError) {
+    return {
+      success: false,
+      error: {
+        code: "BUILD_ERROR",
+        message: error.message,
+        details: {
+          errors: error.errors
+        }
+      },
+      exitCode: EXIT_CODES.GENERAL,
+      meta: {
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
   if (error instanceof OCXError) {
     return {
       success: false,
@@ -11650,7 +12076,14 @@ function formatErrorAsJson(error) {
       success: false,
       error: {
         code: "VALIDATION_ERROR",
-        message: error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")
+        message: error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; "),
+        details: {
+          issues: error.issues.map((i) => ({
+            path: i.path.join("."),
+            message: i.message,
+            code: i.code
+          }))
+        }
       },
       exitCode: EXIT_CODES.CONFIG,
       meta: {
@@ -11675,15 +12108,15 @@ function outputJson(data) {
   console.log(JSON.stringify(data, null, 2));
 }
 // src/utils/path-safety.ts
-import path5 from "path";
+import path6 from "path";
 function isPathInside(childPath, parentPath) {
-  const resolvedChild = path5.resolve(childPath);
-  const resolvedParent = path5.resolve(parentPath);
+  const resolvedChild = path6.resolve(childPath);
+  const resolvedParent = path6.resolve(parentPath);
   if (resolvedChild === resolvedParent) {
     return true;
   }
-  const relative2 = path5.relative(resolvedParent, resolvedChild);
-  return !!relative2 && !relative2.startsWith("..") && !isAbsolutePath(relative2);
+  const relative3 = path6.relative(resolvedParent, resolvedChild);
+  return !!relative3 && !relative3.startsWith("..") && !isAbsolutePath(relative3);
 }
 function assertPathInside(childPath, parentPath) {
   if (!isPathInside(childPath, parentPath)) {
@@ -11695,6 +12128,7 @@ var sharedOptions = {
   cwd: () => new Option("--cwd <path>", "Working directory").default(process.cwd()),
   quiet: () => new Option("-q, --quiet", "Suppress output"),
   json: () => new Option("--json", "Output as JSON"),
+  profile: () => new Option("-p, --profile <name>", "Target a specific profile's config"),
   force: () => new Option("-f, --force", "Skip confirmation prompts"),
   verbose: () => new Option("-v, --verbose", "Verbose output"),
   global: new Option("-g, --global", "Install to global OpenCode config (~/.config/opencode)")
@@ -11711,6 +12145,20 @@ function addVerboseOption(cmd) {
 function addGlobalOption(cmd) {
   return cmd.addOption(sharedOptions.global);
 }
+function addProfileOption(cmd) {
+  return cmd.addOption(sharedOptions.profile());
+}
+function validateProfileName(name) {
+  if (!name || name.length === 0) {
+    throw new InvalidProfileNameError(name, "cannot be empty");
+  }
+  if (name.length > 32) {
+    throw new InvalidProfileNameError(name, "must be 32 characters or less");
+  }
+  if (!/^[a-zA-Z][a-zA-Z0-9._-]*$/.test(name)) {
+    throw new InvalidProfileNameError(name, "must start with a letter and contain only alphanumeric characters, dots, underscores, or hyphens");
+  }
+}
 // ../../node_modules/.bun/ora@8.2.0/node_modules/ora/index.js
 import process9 from "process";
 
@@ -13429,7 +13877,7 @@ async function runRegistryAddCore(componentNames, options2, provider) {
       }
       const computedHash = await hashBundle(files);
       for (const file of component.files) {
-        const targetPath = join3(cwd, resolveTargetPath(file.target, isFlattened));
+        const targetPath = join4(cwd, resolveTargetPath(file.target, isFlattened));
         assertPathInside(targetPath, cwd);
       }
       const existingEntry = lock.installed[component.qualifiedName];
@@ -13439,7 +13887,7 @@ async function runRegistryAddCore(componentNames, options2, provider) {
       }
       for (const file of component.files) {
         const resolvedTarget = resolveTargetPath(file.target, isFlattened);
-        const targetPath = join3(cwd, resolvedTarget);
+        const targetPath = join4(cwd, resolvedTarget);
         if (existsSync5(targetPath)) {
           const conflictingComponent = findComponentByFile(lock, resolvedTarget);
           if (conflictingComponent && conflictingComponent !== component.qualifiedName) {
@@ -13463,7 +13911,7 @@ async function runRegistryAddCore(componentNames, options2, provider) {
         if (!componentFile)
           continue;
         const resolvedTarget = resolveTargetPath(componentFile.target, isFlattened);
-        const targetPath = join3(cwd, resolvedTarget);
+        const targetPath = join4(cwd, resolvedTarget);
         if (existsSync5(targetPath)) {
           const existingContent = await Bun.file(targetPath).text();
           const incomingContent = file.content.toString("utf-8");
@@ -13528,7 +13976,7 @@ async function runRegistryAddCore(componentNames, options2, provider) {
     }
     const hasNpmDeps = resolved.npmDependencies.length > 0;
     const hasNpmDevDeps = resolved.npmDevDependencies.length > 0;
-    const packageJsonPath = options2.global || options2.profile ? join3(cwd, "package.json") : join3(cwd, ".opencode/package.json");
+    const packageJsonPath = options2.global || options2.profile ? join4(cwd, "package.json") : join4(cwd, ".opencode/package.json");
     if (hasNpmDeps || hasNpmDevDeps) {
       const npmSpin = options2.quiet ? null : createSpinner({ text: `Updating ${packageJsonPath}...` });
       npmSpin?.start();
@@ -13570,8 +14018,8 @@ async function installComponent(component, files, cwd, options2) {
     if (!componentFile)
       continue;
     const resolvedTarget = resolveTargetPath(componentFile.target, !!options2.isFlattened);
-    const targetPath = join3(cwd, resolvedTarget);
-    const targetDir = dirname(targetPath);
+    const targetPath = join4(cwd, resolvedTarget);
+    const targetDir = dirname2(targetPath);
     if (existsSync5(targetPath)) {
       const existingContent = await Bun.file(targetPath).text();
       const incomingContent = file.content.toString("utf-8");
@@ -13584,7 +14032,7 @@ async function installComponent(component, files, cwd, options2) {
       result.written.push(resolvedTarget);
     }
     if (!existsSync5(targetDir)) {
-      await mkdir4(targetDir, { recursive: true });
+      await mkdir5(targetDir, { recursive: true });
     }
     await writeFile(targetPath, file.content);
   }
@@ -13660,7 +14108,7 @@ function mergeDevDependencies(existing, newDeps) {
   return { ...existing, devDependencies: merged };
 }
 async function readOpencodePackageJson(opencodeDir) {
-  const pkgPath = join3(opencodeDir, "package.json");
+  const pkgPath = join4(opencodeDir, "package.json");
   if (!existsSync5(pkgPath)) {
     return { ...DEFAULT_PACKAGE_JSON };
   }
@@ -13673,7 +14121,7 @@ async function readOpencodePackageJson(opencodeDir) {
   }
 }
 async function ensureManifestFilesAreTracked(opencodeDir) {
-  const gitignorePath = join3(opencodeDir, ".gitignore");
+  const gitignorePath = join4(opencodeDir, ".gitignore");
   const filesToTrack = new Set(["package.json", "bun.lock"]);
   const requiredIgnores = ["node_modules"];
   let lines = [];
@@ -13696,12 +14144,12 @@ async function updateOpencodeDevDependencies(cwd, npmDeps, npmDevDeps, options2
   const allDepSpecs = [...npmDeps, ...npmDevDeps];
   if (allDepSpecs.length === 0)
     return;
-  const packageDir = options2.isFlattened ? cwd : join3(cwd, ".opencode");
-  await mkdir4(packageDir, { recursive: true });
+  const packageDir = options2.isFlattened ? cwd : join4(cwd, ".opencode");
+  await mkdir5(packageDir, { recursive: true });
   const parsedDeps = allDepSpecs.map(parseNpmDependency);
   const existing = await readOpencodePackageJson(packageDir);
   const updated = mergeDevDependencies(existing, parsedDeps);
-  await Bun.write(join3(packageDir, "package.json"), `${JSON.stringify(updated, null, 2)}
+  await Bun.write(join4(packageDir, "package.json"), `${JSON.stringify(updated, null, 2)}
 `);
   if (!options2.isFlattened) {
     await ensureManifestFilesAreTracked(packageDir);
@@ -13717,101 +14165,11 @@ function findComponentByFile(lock, filePath) {
 }
 
 // src/commands/build.ts
-import { join as join5, relative as relative2 } from "path";
-
-// src/lib/build-registry.ts
-import { mkdir as mkdir5 } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
-class BuildRegistryError extends Error {
-  errors;
-  constructor(message, errors3 = []) {
-    super(message);
-    this.errors = errors3;
-    this.name = "BuildRegistryError";
-  }
-}
-async function buildRegistry(options2) {
-  const { source: sourcePath, out: outPath } = options2;
-  const jsoncFile = Bun.file(join4(sourcePath, "registry.jsonc"));
-  const jsonFile = Bun.file(join4(sourcePath, "registry.json"));
-  const jsoncExists = await jsoncFile.exists();
-  const jsonExists = await jsonFile.exists();
-  if (!jsoncExists && !jsonExists) {
-    throw new BuildRegistryError("No registry.jsonc or registry.json found in source directory");
-  }
-  const registryFile = jsoncExists ? jsoncFile : jsonFile;
-  const content2 = await registryFile.text();
-  const registryData = parse2(content2, [], { allowTrailingComma: true });
-  const parseResult = registrySchema.safeParse(registryData);
-  if (!parseResult.success) {
-    const errors3 = parseResult.error.errors.map((e3) => `${e3.path.join(".")}: ${e3.message}`);
-    throw new BuildRegistryError("Registry validation failed", errors3);
-  }
-  const registry = parseResult.data;
-  const validationErrors = [];
-  const componentsDir = join4(outPath, "components");
-  await mkdir5(componentsDir, { recursive: true });
-  for (const component of registry.components) {
-    const packument = {
-      name: component.name,
-      versions: {
-        [registry.version]: component
-      },
-      "dist-tags": {
-        latest: registry.version
-      }
-    };
-    const packumentPath = join4(componentsDir, `${component.name}.json`);
-    await Bun.write(packumentPath, JSON.stringify(packument, null, 2));
-    for (const rawFile of component.files) {
-      const file = normalizeFile(rawFile, component.type);
-      const sourceFilePath = join4(sourcePath, "files", file.path);
-      const destFilePath = join4(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;
-      }
-      await mkdir5(destFileDir, { recursive: true });
-      const sourceFile = Bun.file(sourceFilePath);
-      await Bun.write(destFilePath, sourceFile);
-    }
-  }
-  if (validationErrors.length > 0) {
-    throw new BuildRegistryError(`Build failed with ${validationErrors.length} errors`, validationErrors);
-  }
-  const index = {
-    name: registry.name,
-    namespace: registry.namespace,
-    version: registry.version,
-    author: registry.author,
-    ...registry.opencode && { opencode: registry.opencode },
-    ...registry.ocx && { ocx: registry.ocx },
-    components: registry.components.map((c) => ({
-      name: c.name,
-      type: c.type,
-      description: c.description
-    }))
-  };
-  await Bun.write(join4(outPath, "index.json"), JSON.stringify(index, null, 2));
-  const wellKnownDir = join4(outPath, ".well-known");
-  await mkdir5(wellKnownDir, { recursive: true });
-  const discovery = { registry: "/index.json" };
-  await Bun.write(join4(wellKnownDir, "ocx.json"), JSON.stringify(discovery, null, 2));
-  return {
-    name: registry.name,
-    namespace: registry.namespace,
-    version: registry.version,
-    componentsCount: registry.components.length,
-    outputPath: outPath
-  };
-}
-
-// src/commands/build.ts
+import { join as join5, relative as relative3 } from "path";
 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 (path6, options2) => {
+  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 (path7, options2) => {
     try {
-      const sourcePath = join5(options2.cwd, path6);
+      const sourcePath = join5(options2.cwd, path7);
       const outPath = join5(options2.cwd, options2.out);
       const spinner2 = createSpinner({
         text: "Building registry...",
@@ -13824,7 +14182,7 @@ function registerBuildCommand(program2) {
         out: outPath
       });
       if (!options2.json) {
-        const msg = `Built ${result.componentsCount} components to ${relative2(options2.cwd, outPath)}`;
+        const msg = `Built ${result.componentsCount} components to ${relative3(options2.cwd, outPath)}`;
         spinner2.succeed(msg);
         if (!process.stdout.isTTY) {
           logger.success(`Built ${result.componentsCount} components`);
@@ -13861,7 +14219,7 @@ import { existsSync as existsSync6 } from "fs";
 import { mkdir as mkdir6 } from "fs/promises";
 import { join as join6 } from "path";
 function registerConfigEditCommand(parent) {
-  parent.command("edit").description("Open configuration file in editor").option("-g, --global", "Edit global ocx.jsonc").action(async (options2) => {
+  parent.command("edit").description("Open configuration file in editor").option("-g, --global", "Edit global ocx.jsonc").option("-p, --profile <name>", "Edit specific profile's config").action(async (options2) => {
     try {
       await runConfigEdit(options2);
     } catch (error) {
@@ -13870,12 +14228,26 @@ function registerConfigEditCommand(parent) {
   });
 }
 async function runConfigEdit(options2) {
+  if (options2.global && options2.profile) {
+    throw new ValidationError("Cannot use both --global and --profile flags");
+  }
   let configPath;
-  if (options2.global) {
+  if (options2.profile) {
+    const parseResult = profileNameSchema.safeParse(options2.profile);
+    if (!parseResult.success) {
+      throw new ValidationError(`Invalid profile name "${options2.profile}": ${parseResult.error.errors[0]?.message ?? "Invalid name"}`);
+    }
+    await ProfileManager.requireInitialized();
+    const manager = ProfileManager.create();
+    if (!await manager.exists(options2.profile)) {
+      throw new ProfileNotFoundError(options2.profile);
+    }
+    configPath = getProfileOcxConfig(options2.profile);
+  } else if (options2.global) {
     configPath = getGlobalConfig();
     if (!existsSync6(configPath)) {
       throw new ConfigError(`Global config not found at ${configPath}.
-` + "Run 'opencode' once to initialize, then retry.");
+Run 'ocx init --global' first.`);
     }
   } else {
     const localConfigDir = findLocalConfigDir(process.cwd());
@@ -14112,16 +14484,16 @@ class Diff {
       }
     }
   }
-  addToPath(path6, added, removed, oldPosInc, options2) {
-    const last = path6.lastComponent;
+  addToPath(path7, added, removed, oldPosInc, options2) {
+    const last = path7.lastComponent;
     if (last && !options2.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path6.oldPos + oldPosInc,
+        oldPos: path7.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path6.oldPos + oldPosInc,
+        oldPos: path7.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -14938,7 +15310,7 @@ import {
   rmSync,
   unlinkSync
 } from "fs";
-import path6 from "path";
+import path7 from "path";
 var GHOST_CONFIG_FILE = "ghost.jsonc";
 var BACKUP_EXT = ".bak";
 var CURRENT_SYMLINK = "current";
@@ -14976,8 +15348,8 @@ function planMigration() {
     if (!entry.isDirectory() || entry.name === CURRENT_SYMLINK)
       continue;
     const profileName = entry.name;
-    const ghostConfig = path6.join(profilesDir, profileName, GHOST_CONFIG_FILE);
-    const ocxConfig = path6.join(profilesDir, profileName, OCX_CONFIG_FILE);
+    const ghostConfig = path7.join(profilesDir, profileName, GHOST_CONFIG_FILE);
+    const ocxConfig = path7.join(profilesDir, profileName, OCX_CONFIG_FILE);
     if (!existsSync7(ghostConfig))
       continue;
     if (existsSync7(ocxConfig)) {
@@ -15007,13 +15379,13 @@ function planMigration() {
     if (!entry.isDirectory() || entry.name === CURRENT_SYMLINK)
       continue;
     const profileName = entry.name;
-    const profileDir = path6.join(profilesDir, profileName);
-    const dotOpencode = path6.join(profileDir, ".opencode");
+    const profileDir = path7.join(profilesDir, profileName);
+    const dotOpencode = path7.join(profileDir, ".opencode");
     if (!existsSync7(dotOpencode))
       continue;
     for (const dir of FLATTEN_DIRS) {
-      const source = path6.join(dotOpencode, dir);
-      const destination = path6.join(profileDir, dir);
+      const source = path7.join(dotOpencode, dir);
+      const destination = path7.join(profileDir, dir);
       if (!existsSync7(source))
         continue;
       try {
@@ -15052,7 +15424,7 @@ function planMigration() {
       });
     }
   }
-  const currentPath = path6.join(profilesDir, CURRENT_SYMLINK);
+  const currentPath = path7.join(profilesDir, CURRENT_SYMLINK);
   if (existsSync7(currentPath)) {
     try {
       const stat3 = lstatSync(currentPath);
@@ -15111,21 +15483,21 @@ function executeMigration(plan) {
       } catch {}
     }
   } catch (error) {
-    for (const rename2 of completedRenames) {
+    for (const rename3 of completedRenames) {
       try {
-        if (existsSync7(rename2.destination)) {
-          if (rename2.isDir) {
-            rmSync(rename2.destination, { recursive: true, force: true });
+        if (existsSync7(rename3.destination)) {
+          if (rename3.isDir) {
+            rmSync(rename3.destination, { recursive: true, force: true });
           } else {
-            unlinkSync(rename2.destination);
+            unlinkSync(rename3.destination);
           }
         }
-        mkdirSync(path6.dirname(rename2.source), { recursive: true });
-        if (existsSync7(rename2.backup)) {
-          if (rename2.isDir) {
-            cpSync(rename2.backup, rename2.source, { recursive: true });
+        mkdirSync(path7.dirname(rename3.source), { recursive: true });
+        if (existsSync7(rename3.backup)) {
+          if (rename3.isDir) {
+            cpSync(rename3.backup, rename3.source, { recursive: true });
           } else {
-            copyFileSync(rename2.backup, rename2.source);
+            copyFileSync(rename3.backup, rename3.source);
           }
         }
       } catch {}
@@ -15146,8 +15518,8 @@ function executeMigration(plan) {
   try {
     const processedProfiles = new Set(plan.profiles.filter((a) => a.type === "move-dir").map((a) => a.profileName));
     for (const profileName of processedProfiles) {
-      const profileDir = path6.join(getProfilesDir(), profileName);
-      const dotOpencode = path6.join(profileDir, ".opencode");
+      const profileDir = path7.join(getProfilesDir(), profileName);
+      const dotOpencode = path7.join(profileDir, ".opencode");
       if (existsSync7(dotOpencode)) {
         const remaining = readdirSync(dotOpencode);
         if (remaining.length === 0) {
@@ -15173,7 +15545,7 @@ function printPlan(plan, dryRun) {
       if (action.type === "rename") {
         console.log(`  \u2713 ${action.profileName}: ${GHOST_CONFIG_FILE} \u2192 ${OCX_CONFIG_FILE}`);
       } else {
-        const dirName = path6.basename(action.source);
+        const dirName = path7.basename(action.source);
         console.log(`  \u2713 ${action.profileName}: .opencode/${dirName}/ \u2192 ${dirName}/`);
       }
     }
@@ -15291,34 +15663,90 @@ async function runInit(options2) {
   }
 }
 async function runInitGlobal(options2) {
-  const manager = ProfileManager.create();
-  if (await manager.isInitialized()) {
-    const profilesDir = getProfilesDir();
-    throw new ProfileExistsError(`Global profiles already initialized at ${profilesDir}`);
-  }
   const spin = options2.quiet ? null : createSpinner({ text: "Initializing global profiles..." });
   spin?.start();
   try {
-    await manager.initialize();
+    const created = [];
+    const existed = [];
+    const globalConfigPath = getGlobalConfig();
+    if (existsSync8(globalConfigPath)) {
+      existed.push("globalConfig");
+    } else {
+      await mkdir7(dirname3(globalConfigPath), { recursive: true, mode: 448 });
+      await atomicWrite(globalConfigPath, {
+        $schema: OCX_SCHEMA_URL,
+        registries: {}
+      });
+      created.push("globalConfig");
+    }
     const profilesDir = getProfilesDir();
-    const ocxConfigPath = getProfileOcxConfig("default");
+    if (!existsSync8(profilesDir)) {
+      await mkdir7(profilesDir, { recursive: true, mode: 448 });
+    }
+    const profileDir = getProfileDir("default");
+    if (!existsSync8(profileDir)) {
+      await mkdir7(profileDir, { recursive: true, mode: 448 });
+    }
+    const ocxPath = getProfileOcxConfig("default");
+    if (existsSync8(ocxPath)) {
+      existed.push("profileOcx");
+    } else {
+      await atomicWrite(ocxPath, DEFAULT_OCX_CONFIG);
+      created.push("profileOcx");
+    }
+    const opencodePath = getProfileOpencodeConfig("default");
+    if (existsSync8(opencodePath)) {
+      existed.push("profileOpencode");
+    } else {
+      await atomicWrite(opencodePath, {});
+      created.push("profileOpencode");
+    }
+    const agentsPath = getProfileAgents("default");
+    if (existsSync8(agentsPath)) {
+      existed.push("profileAgents");
+    } else {
+      const agentsContent = `# Profile Instructions
+
+<!-- Add your custom instructions for this profile here -->
+<!-- These will be included when running \`ocx opencode -p default\` -->
+`;
+      await Bun.write(agentsPath, agentsContent, { mode: 384 });
+      created.push("profileAgents");
+    }
     spin?.succeed("Initialized global profiles");
     if (options2.json) {
       console.log(JSON.stringify({
         success: true,
-        profilesDir,
-        defaultProfile: "default",
-        ocxConfigPath
+        files: {
+          globalConfig: globalConfigPath,
+          profileOcx: ocxPath,
+          profileOpencode: opencodePath,
+          profileAgents: agentsPath
+        },
+        created,
+        existed
       }));
     } else if (!options2.quiet) {
-      logger.info(`Created ${profilesDir}`);
-      logger.info(`Created profile "default"`);
-      logger.info("");
-      logger.info("Next steps:");
-      logger.info("  1. Edit your profile config: ocx profile config");
-      logger.info("  2. Add registries: ocx registry add <url> --profile default");
-      logger.info("  3. Launch OpenCode: ocx opencode");
-      logger.info("  4. Create more profiles: ocx profile add <name>");
+      if (created.length > 0) {
+        for (const key of created) {
+          if (key === "globalConfig")
+            logger.info(`Created global config: ${globalConfigPath}`);
+          if (key === "profileOcx")
+            logger.info(`Created profile config: ${ocxPath}`);
+          if (key === "profileOpencode")
+            logger.info(`Created profile opencode config: ${opencodePath}`);
+          if (key === "profileAgents")
+            logger.info(`Created profile instructions: ${agentsPath}`);
+        }
+        logger.info("");
+        logger.info("Next steps:");
+        logger.info("  1. Edit your profile config: ocx config edit -p default");
+        logger.info("  2. Add registries: ocx registry add <url> --name <name> --global");
+        logger.info("  3. Launch OpenCode: ocx opencode");
+        logger.info("  4. Create more profiles: ocx profile add <name>");
+      } else {
+        logger.info("Global profiles already initialized (all files exist)");
+      }
     }
   } catch (error) {
     spin?.fail("Failed to initialize");
@@ -15346,7 +15774,7 @@ async function runInitRegistry(directory, options2) {
       await mkdir7(cwd, { recursive: true });
       await copyDir(options2.local, cwd);
     } else {
-      const version = options2.canary ? "main" : await getLatestVersion();
+      const version = options2.canary ? "main" : getReleaseTag();
       await fetchAndExtractTemplate(cwd, version, options2.verbose);
     }
     if (spin)
@@ -15375,15 +15803,16 @@ async function runInitRegistry(directory, options2) {
 async function copyDir(src, dest) {
   await cp(src, dest, { recursive: true });
 }
-async function getLatestVersion() {
-  const pkgPath = new URL("../../package.json", import.meta.url);
-  const pkgContent = await readFile(pkgPath);
-  const pkg = JSON.parse(pkgContent.toString());
-  return `v${pkg.version}`;
+function getReleaseTag() {
+  if (false) {}
+  return `v${"1.4.3"}`;
 }
-async function fetchAndExtractTemplate(destDir, version, verbose) {
+function getTemplateUrl(version) {
   const ref = version === "main" ? "heads/main" : `tags/${version}`;
-  const tarballUrl = `https://github.com/${TEMPLATE_REPO}/archive/refs/${ref}.tar.gz`;
+  return `https://github.com/${TEMPLATE_REPO}/archive/refs/${ref}.tar.gz`;
+}
+async function fetchAndExtractTemplate(destDir, version, verbose) {
+  const tarballUrl = getTemplateUrl(version);
   if (verbose) {
     logger.info(`Fetching ${tarballUrl}`);
   }
@@ -15417,6 +15846,9 @@ async function fetchAndExtractTemplate(destDir, version, verbose) {
     await rm2(tempDir, { recursive: true, force: true });
   }
 }
+function toTitleCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
 async function replacePlaceholders(dir, values) {
   const filesToProcess = [
     "registry.jsonc",
@@ -15431,16 +15863,17 @@ async function replacePlaceholders(dir, values) {
       continue;
     let content2 = await readFile(filePath).then((b) => b.toString());
     content2 = content2.replace(/my-registry/g, values.namespace);
+    content2 = content2.replace(/My Registry/g, toTitleCase(values.namespace));
     content2 = content2.replace(/Your Name/g, values.author);
     await writeFile2(filePath, content2);
   }
 }
 
 // src/commands/opencode.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 
 // src/utils/terminal-title.ts
-import path7 from "path";
+import path8 from "path";
 var MAX_BRANCH_LENGTH = 20;
 var titleSaved = false;
 function isInsideTmux() {
@@ -15483,7 +15916,7 @@ function restoreTerminalTitle() {
   titleSaved = false;
 }
 function formatTerminalName(cwd, profileName, gitInfo) {
-  const repoName = gitInfo.repoName ?? path7.basename(cwd);
+  const repoName = gitInfo.repoName ?? path8.basename(cwd);
   if (!gitInfo.branch) {
     return `ocx[${profileName}]:${repoName}`;
   }
@@ -15492,17 +15925,29 @@ function formatTerminalName(cwd, profileName, gitInfo) {
 }
 
 // src/commands/opencode.ts
+function resolveOpenCodeBinary(opts) {
+  return opts.configBin ?? opts.envBin ?? "opencode";
+}
+function buildOpenCodeEnv(opts) {
+  return {
+    ...opts.baseEnv,
+    ...opts.disableProjectConfig && { OPENCODE_DISABLE_PROJECT_CONFIG: "true" },
+    ...opts.profileDir && { OPENCODE_CONFIG_DIR: opts.profileDir },
+    ...opts.mergedConfig && { OPENCODE_CONFIG_CONTENT: JSON.stringify(opts.mergedConfig) },
+    ...opts.profileName && { OCX_PROFILE: opts.profileName }
+  };
+}
 function registerOpencodeCommand(program2) {
-  program2.command("opencode [path]").alias("oc").description("Launch OpenCode with resolved configuration").option("-p, --profile <name>", "Use specific profile").option("--no-rename", "Disable terminal/tmux window renaming").addOption(sharedOptions.quiet()).addOption(sharedOptions.json()).allowUnknownOption().allowExcessArguments(true).action(async (path8, options2, command) => {
+  program2.command("opencode [path]").alias("oc").description("Launch OpenCode with resolved configuration").option("-p, --profile <name>", "Use specific profile").option("--no-rename", "Disable terminal/tmux window renaming").addOption(sharedOptions.quiet()).addOption(sharedOptions.json()).allowUnknownOption().allowExcessArguments(true).action(async (path9, options2, command) => {
     try {
-      await runOpencode(path8, command.args, options2);
+      await runOpencode(path9, command.args, options2);
     } catch (error) {
       handleError(error, { json: options2.json });
     }
   });
 }
 async function runOpencode(pathArg, args, options2) {
-  const projectDir = pathArg ? resolve2(pathArg) : process.cwd();
+  const projectDir = pathArg ? resolve3(pathArg) : process.cwd();
   const resolver = await ConfigResolver.create(projectDir, { profile: options2.profile });
   const config = resolver.resolve();
   const profile = resolver.getProfile();
@@ -15546,17 +15991,20 @@ async function runOpencode(pathArg, args, options2) {
     const gitInfo = await getGitInfo(projectDir);
     setTerminalName(formatTerminalName(projectDir, config.profileName ?? "default", gitInfo));
   }
-  const bin = ocxConfig?.bin ?? process.env.OPENCODE_BIN ?? "opencode";
+  const bin = resolveOpenCodeBinary({
+    configBin: ocxConfig?.bin,
+    envBin: process.env.OPENCODE_BIN
+  });
   proc = Bun.spawn({
     cmd: [bin, ...args],
     cwd: projectDir,
-    env: {
-      ...process.env,
-      OPENCODE_DISABLE_PROJECT_CONFIG: "true",
-      ...profileDir && { OPENCODE_CONFIG_DIR: profileDir },
-      ...configToPass && { OPENCODE_CONFIG_CONTENT: JSON.stringify(configToPass) },
-      ...config.profileName && { OCX_PROFILE: config.profileName }
-    },
+    env: buildOpenCodeEnv({
+      baseEnv: process.env,
+      profileDir,
+      profileName: config.profileName ?? undefined,
+      mergedConfig: configToPass,
+      disableProjectConfig: true
+    }),
     stdin: "inherit",
     stdout: "inherit",
     stderr: "inherit"
@@ -15584,12 +16032,8 @@ async function runOpencode(pathArg, args, options2) {
 // src/commands/profile/install-from-registry.ts
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync9 } from "fs";
-import { mkdir as mkdir8, mkdtemp, rename as rename2, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir8, mkdtemp, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname4, join as join8 } from "path";
-var PROFILE_FILE_TARGETS = new Set(["ocx.jsonc", "opencode.jsonc", "AGENTS.md"]);
-function isProfileFile(target) {
-  return PROFILE_FILE_TARGETS.has(target);
-}
 function hashContent2(content2) {
   return createHash2("sha256").update(content2).digest("hex");
 }
@@ -15641,7 +16085,7 @@ Use --force to overwrite.`);
   const filesSpin = quiet ? null : createSpinner({ text: "Downloading profile files..." });
   filesSpin?.start();
   const profileFiles = [];
-  const dependencyFiles = [];
+  const embeddedFiles = [];
   for (const file of normalized.files) {
     const content2 = await fetchFileContent(registryUrl, component, file.path);
     const fileEntry = {
@@ -15649,10 +16093,10 @@ Use --force to overwrite.`);
       target: file.target,
       content: Buffer.from(content2)
     };
-    if (isProfileFile(file.target)) {
-      profileFiles.push(fileEntry);
+    if (file.target.startsWith(".opencode/")) {
+      embeddedFiles.push(fileEntry);
     } else {
-      dependencyFiles.push(fileEntry);
+      profileFiles.push(fileEntry);
     }
   }
   filesSpin?.succeed(`Downloaded ${normalized.files.length} files`);
@@ -15706,7 +16150,7 @@ Use --force to overwrite.`);
       }
       await writeFile3(targetPath, file.content);
     }
-    for (const file of dependencyFiles) {
+    for (const file of embeddedFiles) {
       const target = file.target.startsWith(".opencode/") ? file.target.slice(".opencode/".length) : file.target;
       const targetPath = join8(stagingOpencodeDir, target);
       const targetDir = dirname4(targetPath);
@@ -15715,7 +16159,7 @@ Use --force to overwrite.`);
       }
       await writeFile3(targetPath, file.content);
     }
-    writeSpin?.succeed(`Wrote ${profileFiles.length + dependencyFiles.length} profile files`);
+    writeSpin?.succeed(`Wrote ${profileFiles.length + embeddedFiles.length} profile files`);
     if (dependencyBundles.length > 0) {
       const depWriteSpin = quiet ? null : createSpinner({ text: "Writing dependency files..." });
       depWriteSpin?.start();
@@ -15764,16 +16208,16 @@ Use --force to overwrite.`);
     }
     if (profileExists && force) {
       const backupDir = `${profileDir}.backup-${Date.now()}`;
-      await rename2(profileDir, backupDir);
+      await rename3(profileDir, backupDir);
       try {
-        await rename2(stagingDir, profileDir);
+        await rename3(stagingDir, profileDir);
       } catch (err) {
-        await rename2(backupDir, profileDir);
+        await rename3(backupDir, profileDir);
         throw err;
       }
       await rm3(backupDir, { recursive: true, force: true });
     } else {
-      await rename2(stagingDir, profileDir);
+      await rename3(stagingDir, profileDir);
     }
     moveSpin?.succeed("Installation complete");
     if (!quiet) {
@@ -15846,14 +16290,14 @@ async function requireGlobalRegistry(namespace) {
     throw new ConfigError(`Registry "${namespace}" is not configured globally.
 
 ` + `Profile installation requires global registry configuration.
-` + `Run: ocx registry add ${namespace} <url> --global`);
+` + `Run: ocx registry add <url> --name ${namespace} --global`);
   }
   const registry = globalConfig.registries[namespace];
   if (!registry) {
     throw new ConfigError(`Registry "${namespace}" is not configured globally.
 
 ` + `Profile installation requires global registry configuration.
-` + `Run: ocx registry add ${namespace} <url> --global`);
+` + `Run: ocx registry add <url> --name ${namespace} --global`);
   }
   return { config: globalConfig, registryUrl: registry.url };
 }
@@ -15931,33 +16375,6 @@ async function cloneFromLocalProfile(manager, name, sourceName, exists) {
   logger.success(`Created profile "${name}" (cloned from "${sourceName}")`);
 }
 
-// src/commands/profile/config.ts
-function registerProfileConfigCommand(parent) {
-  parent.command("config [name]").description("Open profile ocx.jsonc in editor").action(async (name) => {
-    try {
-      await runProfileConfig(name);
-    } catch (error) {
-      handleError(error);
-    }
-  });
-}
-async function runProfileConfig(name) {
-  const manager = await ProfileManager.requireInitialized();
-  const profileName = name ?? await manager.resolveProfile();
-  await manager.get(profileName);
-  const configPath = getProfileOcxConfig(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/profile/list.ts
 function registerProfileListCommand(parent) {
   parent.command("list").alias("ls").description("List all global profiles").addOption(sharedOptions.json()).action(async (options2) => {
@@ -15985,6 +16402,25 @@ async function runProfileList(options2) {
   }
 }
 
+// src/commands/profile/move.ts
+function registerProfileMoveCommand(parent) {
+  parent.command("move <old-name> <new-name>").alias("mv").description("Move (rename) a profile").action(async (oldName, newName) => {
+    try {
+      await runProfileMove(oldName, newName);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function runProfileMove(oldName, newName) {
+  const manager = await ProfileManager.requireInitialized();
+  const { warnActiveProfile } = await manager.move(oldName, newName);
+  if (warnActiveProfile) {
+    logger.warn(`Moving active profile. Update OCX_PROFILE env var to "${newName}".`);
+  }
+  logger.success(`Moved profile "${oldName}" \u2192 "${newName}"`);
+}
+
 // src/commands/profile/remove.ts
 function registerProfileRemoveCommand(parent) {
   parent.command("remove <name>").alias("rm").description("Delete a global profile").action(async (name) => {
@@ -16043,23 +16479,45 @@ function registerProfileCommand(program2) {
   registerProfileListCommand(profile);
   registerProfileAddCommand(profile);
   registerProfileRemoveCommand(profile);
+  registerProfileMoveCommand(profile);
   registerProfileShowCommand(profile);
-  registerProfileConfigCommand(profile);
 }
 
 // src/commands/registry.ts
+import { existsSync as existsSync10 } from "fs";
+import { dirname as dirname5, join as join9 } from "path";
 async function runRegistryAddCore2(url, options2, callbacks) {
   if (callbacks.isLocked?.()) {
     throw new Error("Registries are locked. Cannot add.");
   }
-  const name = options2.name || new URL(url).hostname.replace(/\./g, "-");
+  const trimmedUrl = url.trim();
+  if (!trimmedUrl) {
+    throw new ValidationError("Registry URL is required");
+  }
+  let derivedName;
+  try {
+    const parsed = new URL(trimmedUrl);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new ValidationError(`Invalid registry URL: ${trimmedUrl} (must use http or https)`);
+    }
+    derivedName = options2.name || parsed.hostname.replace(/\./g, "-");
+  } catch (error) {
+    if (error instanceof ValidationError)
+      throw error;
+    throw new ValidationError(`Invalid registry URL: ${trimmedUrl}`);
+  }
+  const name = derivedName;
   const registries = callbacks.getRegistries();
+  const existingRegistry = registries[name];
+  if (existingRegistry && !options2.force) {
+    throw new RegistryExistsError(name, existingRegistry.url, trimmedUrl);
+  }
   const isUpdate = name in registries;
   await callbacks.setRegistry(name, {
-    url,
+    url: trimmedUrl,
     version: options2.version
   });
-  return { name, url, updated: isUpdate };
+  return { name, url: trimmedUrl, updated: isUpdate };
 }
 async function runRegistryRemoveCore(name, callbacks) {
   if (callbacks.isLocked?.()) {
@@ -16082,43 +16540,69 @@ function runRegistryListCore(callbacks) {
   }));
   return { registries: list, locked };
 }
+async function resolveRegistryTarget(options2, command, cwd) {
+  const cwdExplicitlyProvided = command.getOptionValueSource("cwd") === "cli";
+  if (options2.global && options2.profile) {
+    throw new ValidationError("Cannot use both --global and --profile flags");
+  }
+  if (cwdExplicitlyProvided && options2.profile) {
+    throw new ValidationError("Cannot use both --cwd and --profile flags");
+  }
+  if (options2.global && cwdExplicitlyProvided) {
+    throw new ValidationError("Cannot use both --global and --cwd flags");
+  }
+  if (options2.profile) {
+    validateProfileName(options2.profile);
+    const manager = await ProfileManager.requireInitialized();
+    if (!await manager.exists(options2.profile)) {
+      throw new ProfileNotFoundError(options2.profile);
+    }
+    const configPath = getProfileOcxConfig(options2.profile);
+    if (!existsSync10(configPath)) {
+      throw new OcxConfigError(`Profile '${options2.profile}' has no ocx.jsonc. Run 'ocx profile config ${options2.profile}' to create it.`);
+    }
+    return {
+      scope: "profile",
+      configPath,
+      configDir: dirname5(configPath),
+      targetLabel: `profile '${options2.profile}' config`
+    };
+  }
+  if (options2.global) {
+    const configDir = getGlobalConfigPath();
+    return {
+      scope: "global",
+      configPath: join9(configDir, "ocx.jsonc"),
+      configDir,
+      targetLabel: "global config"
+    };
+  }
+  const found = findOcxConfig(cwd);
+  return {
+    scope: "local",
+    configPath: found.path,
+    configDir: found.exists ? dirname5(found.path) : join9(cwd, ".opencode"),
+    targetLabel: "local config"
+  };
+}
 function registerRegistryCommand(program2) {
   const registry = program2.command("registry").description("Manage registries");
-  const addCmd = registry.command("add").description("Add a registry").argument("<url>", "Registry URL").option("--name <name>", "Registry alias (defaults to hostname)").option("--version <version>", "Pin to specific version");
+  const addCmd = registry.command("add").description("Add a registry").argument("<url>", "Registry URL").option("--name <name>", "Registry alias (defaults to hostname)").option("--version <version>", "Pin to specific version").option("-f, --force", "Overwrite existing registry");
   addGlobalOption(addCmd);
+  addProfileOption(addCmd);
   addCommonOptions(addCmd);
   addCmd.action(async (url, options2, command) => {
+    let target;
     try {
-      const cwdExplicitlyProvided = command.getOptionValueSource("cwd") === "cli";
-      if (options2.global && cwdExplicitlyProvided) {
-        logger.error("Cannot use --global with --cwd. They are mutually exclusive.");
+      const cwd = options2.cwd ?? process.cwd();
+      target = await resolveRegistryTarget(options2, command, cwd);
+      const { configDir, configPath } = target;
+      const config = await readOcxConfig(configDir);
+      if (!config) {
+        const initHint = target.scope === "global" ? "Run 'ocx init --global' first." : target.scope === "profile" ? `Run 'ocx profile config ${options2.profile}' to create it.` : "Run 'ocx init' first.";
+        logger.error(`${target.targetLabel} not found. ${initHint}`);
         process.exit(1);
       }
-      let configDir;
-      let configPath;
-      const config = await (async () => {
-        if (options2.global) {
-          configDir = getGlobalConfigPath();
-          const found = findOcxConfig(configDir);
-          configPath = found.path;
-          const cfg = await readOcxConfig(configDir);
-          if (!cfg) {
-            logger.error("Global config not found. Run 'opencode' once to initialize.");
-            process.exit(1);
-          }
-          return cfg;
-        } else {
-          configDir = options2.cwd ?? process.cwd();
-          const found = findOcxConfig(configDir);
-          configPath = found.path;
-          const cfg = await readOcxConfig(configDir);
-          if (!cfg) {
-            logger.error("No ocx.jsonc found. Run 'ocx init' first.");
-            process.exit(1);
-          }
-          return cfg;
-        }
-      })();
       const result = await runRegistryAddCore2(url, options2, {
         getRegistries: () => config.registries,
         isLocked: () => config.lockRegistries ?? false,
@@ -16130,65 +16614,46 @@ function registerRegistryCommand(program2) {
       if (options2.json) {
         outputJson({ success: true, data: result });
       } else if (!options2.quiet) {
-        const location = options2.global ? "global config" : "local config";
         if (result.updated) {
-          logger.success(`Updated registry in ${location}: ${result.name} -> ${result.url}`);
+          logger.success(`Updated registry in ${target.targetLabel}: ${result.name} -> ${result.url}`);
         } else {
-          logger.success(`Added registry to ${location}: ${result.name} -> ${result.url}`);
+          logger.success(`Added registry to ${target.targetLabel}: ${result.name} -> ${result.url}`);
         }
       }
     } catch (error) {
+      if (error instanceof RegistryExistsError && !error.targetLabel) {
+        const enrichedError = new RegistryExistsError(error.registryName, error.existingUrl, error.newUrl, target?.targetLabel ?? "config");
+        handleError(enrichedError, { json: options2.json });
+      }
       handleError(error, { json: options2.json });
     }
   });
   const removeCmd = registry.command("remove").description("Remove a registry").argument("<name>", "Registry name");
   addGlobalOption(removeCmd);
+  addProfileOption(removeCmd);
   addCommonOptions(removeCmd);
   removeCmd.action(async (name, options2, command) => {
     try {
-      const cwdExplicitlyProvided = command.getOptionValueSource("cwd") === "cli";
-      if (options2.global && cwdExplicitlyProvided) {
-        logger.error("Cannot use --global with --cwd. They are mutually exclusive.");
+      const cwd = options2.cwd ?? process.cwd();
+      const target = await resolveRegistryTarget(options2, command, cwd);
+      const config = await readOcxConfig(target.configDir);
+      if (!config) {
+        const initHint = target.scope === "global" ? "Run 'ocx init --global' first." : target.scope === "profile" ? `Run 'ocx profile config ${options2.profile}' to create it.` : "Run 'ocx init' first.";
+        logger.error(`${target.targetLabel} not found. ${initHint}`);
         process.exit(1);
       }
-      let configDir;
-      let configPath;
-      const config = await (async () => {
-        if (options2.global) {
-          configDir = getGlobalConfigPath();
-          const found = findOcxConfig(configDir);
-          configPath = found.path;
-          const cfg = await readOcxConfig(configDir);
-          if (!cfg) {
-            logger.error("Global config not found. Run 'opencode' once to initialize.");
-            process.exit(1);
-          }
-          return cfg;
-        } else {
-          configDir = options2.cwd ?? process.cwd();
-          const found = findOcxConfig(configDir);
-          configPath = found.path;
-          const cfg = await readOcxConfig(configDir);
-          if (!cfg) {
-            logger.error("No ocx.jsonc found. Run 'ocx init' first.");
-            process.exit(1);
-          }
-          return cfg;
-        }
-      })();
       const result = await runRegistryRemoveCore(name, {
         getRegistries: () => config.registries,
         isLocked: () => config.lockRegistries ?? false,
         removeRegistry: async (regName) => {
           delete config.registries[regName];
-          await writeOcxConfig(configDir, config, configPath);
+          await writeOcxConfig(target.configDir, config, target.configPath);
         }
       });
       if (options2.json) {
         outputJson({ success: true, data: result });
       } else if (!options2.quiet) {
-        const location = options2.global ? "global config" : "local config";
-        logger.success(`Removed registry from ${location}: ${result.removed}`);
+        logger.success(`Removed registry from ${target.targetLabel}: ${result.removed}`);
       }
     } catch (error) {
       handleError(error, { json: options2.json });
@@ -16196,36 +16661,18 @@ function registerRegistryCommand(program2) {
   });
   const listCmd = registry.command("list").description("List configured registries");
   addGlobalOption(listCmd);
+  addProfileOption(listCmd);
   addCommonOptions(listCmd);
   listCmd.action(async (options2, command) => {
     try {
-      const cwdExplicitlyProvided = command.getOptionValueSource("cwd") === "cli";
-      if (options2.global && cwdExplicitlyProvided) {
-        logger.error("Cannot use --global with --cwd. They are mutually exclusive.");
-        process.exit(1);
-      }
-      let configDir;
-      const config = await (async () => {
-        if (options2.global) {
-          configDir = getGlobalConfigPath();
-          const cfg = await readOcxConfig(configDir);
-          if (!cfg) {
-            logger.warn("Global config not found. Run 'opencode' once to initialize.");
-            return null;
-          }
-          return cfg;
-        } else {
-          configDir = options2.cwd ?? process.cwd();
-          const cfg = await readOcxConfig(configDir);
-          if (!cfg) {
-            logger.warn("No ocx.jsonc found. Run 'ocx init' first.");
-            return null;
-          }
-          return cfg;
-        }
-      })();
-      if (!config)
+      const cwd = options2.cwd ?? process.cwd();
+      const target = await resolveRegistryTarget(options2, command, cwd);
+      const config = await readOcxConfig(target.configDir);
+      if (!config) {
+        const initHint = target.scope === "global" ? "Run 'ocx init --global' first." : target.scope === "profile" ? `Run 'ocx profile config ${options2.profile}' to create it.` : "Run 'ocx init' first.";
+        logger.warn(`${target.targetLabel} not found. ${initHint}`);
         return;
+      }
       const result = runRegistryListCore({
         getRegistries: () => config.registries,
         isLocked: () => config.lockRegistries ?? false
@@ -16236,7 +16683,8 @@ function registerRegistryCommand(program2) {
         if (result.registries.length === 0) {
           logger.info("No registries configured.");
         } else {
-          logger.info(`Configured registries${options2.global ? " (global)" : ""}${result.locked ? kleur_default.yellow(" (locked)") : ""}:`);
+          const scopeLabel = target.scope === "global" ? " (global)" : target.scope === "profile" ? ` (profile '${options2.profile}')` : "";
+          logger.info(`Configured registries${scopeLabel}${result.locked ? kleur_default.yellow(" (locked)") : ""}:`);
           for (const reg of result.registries) {
             console.log(`  ${kleur_default.cyan(reg.name)}: ${reg.url} ${kleur_default.dim(`(${reg.version})`)}`);
           }
@@ -16369,9 +16817,460 @@ async function runSearchCore(query, options2, provider) {
   }
 }
 
+// src/commands/self/uninstall.ts
+import { existsSync as existsSync11, lstatSync as lstatSync2, readdirSync as readdirSync2, realpathSync, rmSync as rmSync2, unlinkSync as unlinkSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import path9 from "path";
+
+// src/self-update/detect-method.ts
+function parseInstallMethod(input) {
+  const VALID_METHODS = ["curl", "npm", "yarn", "pnpm", "bun"];
+  const method = VALID_METHODS.find((m) => m === input);
+  if (!method) {
+    throw new SelfUpdateError(`Invalid install method: "${input}"
+Valid methods: ${VALID_METHODS.join(", ")}`);
+  }
+  return method;
+}
+var isCompiledBinary = () => Bun.main.startsWith("/$bunfs/");
+var isTempExecution = (path9) => path9.includes("/_npx/") || path9.includes("/.cache/bunx/") || path9.includes("/.pnpm/_temp/");
+var isYarnGlobalInstall = (path9) => path9.includes("/.yarn/global") || path9.includes("/.config/yarn/global");
+var isPnpmGlobalInstall = (path9) => path9.includes("/.pnpm/") || path9.includes("/pnpm/global");
+var isBunGlobalInstall = (path9) => path9.includes("/.bun/bin") || path9.includes("/.bun/install/global");
+var isNpmGlobalInstall = (path9) => path9.includes("/.npm/") || path9.includes("/node_modules/");
+function detectInstallMethod() {
+  if (isCompiledBinary()) {
+    return "curl";
+  }
+  const scriptPath = process.argv[1] ?? "";
+  if (isTempExecution(scriptPath))
+    return "unknown";
+  if (isYarnGlobalInstall(scriptPath))
+    return "yarn";
+  if (isPnpmGlobalInstall(scriptPath))
+    return "pnpm";
+  if (isBunGlobalInstall(scriptPath))
+    return "bun";
+  if (isNpmGlobalInstall(scriptPath))
+    return "npm";
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.includes("yarn"))
+    return "yarn";
+  if (userAgent.includes("pnpm"))
+    return "pnpm";
+  if (userAgent.includes("bun"))
+    return "bun";
+  if (userAgent.includes("npm"))
+    return "npm";
+  return "unknown";
+}
+function getExecutablePath() {
+  if (typeof Bun !== "undefined" && Bun.main.startsWith("/$bunfs/")) {
+    return process.execPath;
+  }
+  return process.argv[1] ?? process.execPath;
+}
+
+// src/commands/self/uninstall.ts
+var UNINSTALL_EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1,
+  SAFETY_ERROR: 2
+};
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+function tildify(absolutePath) {
+  const home = homedir4();
+  if (!home)
+    return absolutePath;
+  if (absolutePath === home)
+    return "~";
+  if (absolutePath.startsWith(home + path9.sep)) {
+    return `~${absolutePath.slice(home.length)}`;
+  }
+  return absolutePath;
+}
+function getRelativePathIfContained(parent, child) {
+  const normalizedParent = path9.normalize(parent);
+  const normalizedChild = path9.normalize(child);
+  const relative4 = path9.relative(normalizedParent, normalizedChild);
+  if (relative4.startsWith("..") || path9.isAbsolute(relative4)) {
+    return null;
+  }
+  return relative4;
+}
+function isLexicallyInside(root, target) {
+  return getRelativePathIfContained(root, target) !== null;
+}
+function isRealpathInside(root, target) {
+  if (!existsSync11(target)) {
+    return { contained: true };
+  }
+  try {
+    const realRoot = realpathSync(root);
+    const realTarget = realpathSync(target);
+    return { contained: getRelativePathIfContained(realRoot, realTarget) !== null };
+  } catch (err) {
+    if (isNodeError(err) && (err.code === "EACCES" || err.code === "EPERM")) {
+      return { contained: false, error: "permission" };
+    }
+    return { contained: false, error: "io" };
+  }
+}
+function validateRootDirectory(rootPath) {
+  try {
+    const stats = lstatSync2(rootPath);
+    if (stats.isSymbolicLink()) {
+      return { valid: false, reason: "symlink" };
+    }
+    if (!stats.isDirectory()) {
+      return { valid: false, reason: "not-directory" };
+    }
+    return { valid: true };
+  } catch (err) {
+    if (isNodeError(err)) {
+      if (err.code === "ENOENT") {
+        return { valid: false, reason: "not-found" };
+      }
+      if (err.code === "EACCES" || err.code === "EPERM") {
+        return { valid: false, reason: "permission" };
+      }
+    }
+    return { valid: false, reason: "permission" };
+  }
+}
+function getPathKind(targetPath) {
+  if (!existsSync11(targetPath)) {
+    return "missing";
+  }
+  try {
+    const stats = lstatSync2(targetPath);
+    if (stats.isSymbolicLink()) {
+      return "symlink";
+    }
+    if (stats.isDirectory()) {
+      return "directory";
+    }
+    return "file";
+  } catch {
+    return "missing";
+  }
+}
+function isDirectoryEmpty(dirPath) {
+  if (!existsSync11(dirPath)) {
+    return true;
+  }
+  try {
+    const entries = readdirSync2(dirPath);
+    return entries.length === 0;
+  } catch {
+    return false;
+  }
+}
+function classifyTargetSafety(target) {
+  if (target.kind === "missing") {
+    return "safe";
+  }
+  if (target.kind === "symlink") {
+    return isLexicallyInside(target.rootPath, target.absolutePath) ? "safe" : "forbidden";
+  }
+  const result = isRealpathInside(target.rootPath, target.absolutePath);
+  if (result.error) {
+    return "error";
+  }
+  return result.contained ? "safe" : "forbidden";
+}
+function isPackageManaged(method) {
+  return method === "npm" || method === "pnpm" || method === "bun" || method === "yarn";
+}
+function getPackageManagerCommand(method) {
+  switch (method) {
+    case "npm":
+      return "npm uninstall -g ocx";
+    case "pnpm":
+      return "pnpm remove -g ocx";
+    case "bun":
+      return "bun remove -g ocx";
+    case "yarn":
+      return "yarn global remove ocx";
+    default:
+      return "npm uninstall -g ocx";
+  }
+}
+function getGlobalConfigRoot() {
+  const base = process.env.XDG_CONFIG_HOME || path9.join(homedir4(), ".config");
+  return path9.join(base, "opencode");
+}
+function buildConfigTargets() {
+  const rootPath = getGlobalConfigRoot();
+  const targets = [];
+  const profilesDir = getProfilesDir();
+  const profilesRelative = getRelativePathIfContained(rootPath, profilesDir);
+  if (profilesRelative) {
+    const kind = getPathKind(profilesDir);
+    targets.push({
+      rootPath,
+      relativePath: profilesRelative,
+      absolutePath: profilesDir,
+      displayPath: tildify(profilesDir),
+      kind,
+      deleteIfEmpty: false,
+      safetyStatus: classifyTargetSafety({ rootPath, absolutePath: profilesDir, kind })
+    });
+  }
+  const globalConfig = getGlobalConfig();
+  const configRelative = getRelativePathIfContained(rootPath, globalConfig);
+  if (configRelative) {
+    const kind = getPathKind(globalConfig);
+    targets.push({
+      rootPath,
+      relativePath: configRelative,
+      absolutePath: globalConfig,
+      displayPath: tildify(globalConfig),
+      kind,
+      deleteIfEmpty: false,
+      safetyStatus: classifyTargetSafety({ rootPath, absolutePath: globalConfig, kind })
+    });
+  }
+  const rootKind = getPathKind(rootPath);
+  targets.push({
+    rootPath,
+    relativePath: ".",
+    absolutePath: rootPath,
+    displayPath: tildify(rootPath),
+    kind: rootKind,
+    deleteIfEmpty: true,
+    safetyStatus: rootKind === "missing" ? "safe" : "safe"
+  });
+  return targets;
+}
+function buildBinaryTarget() {
+  const method = detectInstallMethod();
+  if (isPackageManaged(method)) {
+    return null;
+  }
+  if (method === "curl") {
+    const binaryPath = getExecutablePath();
+    const kind = getPathKind(binaryPath);
+    const parentDir = path9.dirname(binaryPath);
+    return {
+      rootPath: parentDir,
+      relativePath: path9.basename(binaryPath),
+      absolutePath: binaryPath,
+      displayPath: tildify(binaryPath),
+      kind,
+      deleteIfEmpty: false,
+      safetyStatus: kind === "missing" ? "safe" : "safe"
+    };
+  }
+  return null;
+}
+function executeRemoval(target) {
+  if (target.kind === "missing") {
+    return { target, success: true, skipped: true, reason: "not found" };
+  }
+  if (target.safetyStatus === "forbidden") {
+    return {
+      target,
+      success: false,
+      skipped: true,
+      reason: "containment violation",
+      error: new Error("Target escapes containment boundary")
+    };
+  }
+  if (target.deleteIfEmpty && target.kind === "directory") {
+    if (!isDirectoryEmpty(target.absolutePath)) {
+      return { target, success: true, skipped: true, reason: "not empty" };
+    }
+  }
+  try {
+    if (target.kind === "directory") {
+      rmSync2(target.absolutePath, { recursive: true, force: true });
+    } else {
+      unlinkSync2(target.absolutePath);
+    }
+    return { target, success: true, skipped: false };
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    const reason = isNodeError(err) && (err.code === "EACCES" || err.code === "EPERM") ? "permission denied" : undefined;
+    return { target, success: false, skipped: false, reason, error };
+  }
+}
+function executeRemovals(targets) {
+  return targets.map(executeRemoval);
+}
+function removeBinary(binaryPath) {
+  const target = {
+    rootPath: path9.dirname(binaryPath),
+    relativePath: path9.basename(binaryPath),
+    absolutePath: binaryPath,
+    displayPath: tildify(binaryPath),
+    kind: getPathKind(binaryPath),
+    deleteIfEmpty: false,
+    safetyStatus: "safe"
+  };
+  if (target.kind === "missing") {
+    return { target, success: true, skipped: true, reason: "not found" };
+  }
+  if (process.platform === "win32") {
+    logger.info(`To complete uninstall, manually delete: ${target.displayPath}`);
+    return { target, success: true, skipped: true };
+  }
+  try {
+    unlinkSync2(binaryPath);
+    return { target, success: true, skipped: false };
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    return { target, success: false, skipped: false, reason: "permission denied", error: err };
+  }
+}
+function printDryRun(configTargets, binaryTarget, installMethod) {
+  logger.info(`Dry run - the following would be removed:
+`);
+  const existingConfigTargets = configTargets.filter((t2) => t2.kind !== "missing");
+  for (const target of existingConfigTargets) {
+    const kindLabel = target.kind === "directory" ? "[dir] " : "[file]";
+    const emptyNote = target.deleteIfEmpty ? " (if empty)" : "";
+    logger.log(`  ${kindLabel} ${highlight.path(target.displayPath)}${emptyNote}`);
+  }
+  if (binaryTarget && binaryTarget.kind !== "missing") {
+    logger.log(`  [bin]  ${highlight.path(binaryTarget.displayPath)}`);
+  }
+  if (isPackageManaged(installMethod)) {
+    logger.log("");
+    logger.info(`Binary managed by ${installMethod}. Run:`);
+    logger.log(`  ${highlight.command(getPackageManagerCommand(installMethod))}`);
+  }
+  if (existingConfigTargets.length === 0 && (!binaryTarget || binaryTarget.kind === "missing")) {
+    logger.info("Nothing to remove.");
+  }
+}
+function printRemovalPlan(configTargets, binaryTarget) {
+  const existingConfigTargets = configTargets.filter((t2) => t2.kind !== "missing");
+  if (existingConfigTargets.length > 0 || binaryTarget && binaryTarget.kind !== "missing") {
+    logger.info("Removing OCX files...");
+  }
+}
+function printResults(results, binaryResult, installMethod) {
+  logger.break();
+  for (const result of results) {
+    if (result.skipped) {
+      if (result.reason === "not found") {
+        continue;
+      }
+      if (result.reason === "not empty") {
+        logger.info(`Kept ${highlight.path(result.target.displayPath)} (not empty)`);
+        continue;
+      }
+      if (result.reason === "permission denied") {
+        logger.warn(`Skipped ${highlight.path(result.target.displayPath)} (permission denied)`);
+        continue;
+      }
+      if (result.reason === "containment violation") {
+        logger.warn(`Skipped ${highlight.path(result.target.displayPath)} (containment violation)`);
+        continue;
+      }
+    }
+    if (result.success) {
+      logger.success(`Removed ${highlight.path(result.target.displayPath)}`);
+    } else {
+      logger.error(`Failed to remove ${result.target.displayPath}: ${result.error?.message}`);
+    }
+  }
+  if (binaryResult) {
+    if (binaryResult.skipped && binaryResult.reason === "not found") {} else if (binaryResult.success && !binaryResult.skipped) {
+      logger.success(`Removed binary ${highlight.path(binaryResult.target.displayPath)}`);
+    } else if (!binaryResult.success) {
+      logger.error(`Failed to remove binary ${binaryResult.target.displayPath}: ${binaryResult.error?.message}`);
+    }
+  }
+  if (isPackageManaged(installMethod)) {
+    logger.break();
+    logger.info(`Binary is managed by ${installMethod}. To complete uninstall, run:`);
+    logger.log(`  ${highlight.command(getPackageManagerCommand(installMethod))}`);
+  }
+}
+function printNothingToRemove() {
+  logger.info("Nothing to remove. OCX is not installed globally.");
+}
+async function runUninstall(options2) {
+  const rootPath = getGlobalConfigRoot();
+  const rootValidation = validateRootDirectory(rootPath);
+  if (!rootValidation.valid) {
+    switch (rootValidation.reason) {
+      case "not-found":
+        break;
+      case "symlink":
+        logger.error("Safety error: Global config root is a symlink. Aborting.");
+        process.exit(UNINSTALL_EXIT_CODES.SAFETY_ERROR);
+        break;
+      case "not-directory":
+        logger.error("Safety error: Global config root is not a directory. Aborting.");
+        process.exit(UNINSTALL_EXIT_CODES.SAFETY_ERROR);
+        break;
+      case "permission":
+        logger.error("Error: Cannot access global config root (permission denied).");
+        process.exit(UNINSTALL_EXIT_CODES.ERROR);
+        break;
+    }
+  }
+  const configTargets = buildConfigTargets();
+  const forbiddenTargets = configTargets.filter((t2) => t2.safetyStatus === "forbidden");
+  if (forbiddenTargets.length > 0) {
+    logger.error("Safety error: Target escapes containment boundary:");
+    for (const target of forbiddenTargets) {
+      logger.error(`  ${target.displayPath}`);
+    }
+    process.exit(UNINSTALL_EXIT_CODES.SAFETY_ERROR);
+  }
+  const errorTargets = configTargets.filter((t2) => t2.safetyStatus === "error");
+  if (errorTargets.length > 0) {
+    logger.error("Error: Cannot verify containment for targets (permission/IO error):");
+    for (const target of errorTargets) {
+      logger.error(`  ${target.displayPath}`);
+    }
+    process.exit(UNINSTALL_EXIT_CODES.ERROR);
+  }
+  const installMethod = detectInstallMethod();
+  const binaryTarget = buildBinaryTarget();
+  const existingConfigTargets = configTargets.filter((t2) => t2.kind !== "missing");
+  const hasBinary = binaryTarget && binaryTarget.kind !== "missing";
+  const hasPackageManager = isPackageManaged(installMethod);
+  if (existingConfigTargets.length === 0 && !hasBinary && !hasPackageManager) {
+    printNothingToRemove();
+    process.exit(UNINSTALL_EXIT_CODES.SUCCESS);
+  }
+  if (options2.dryRun) {
+    printDryRun(configTargets, binaryTarget, installMethod);
+    process.exit(UNINSTALL_EXIT_CODES.SUCCESS);
+  }
+  printRemovalPlan(configTargets, binaryTarget);
+  const configResults = executeRemovals(configTargets);
+  let binaryResult = null;
+  if (binaryTarget) {
+    binaryResult = removeBinary(binaryTarget.absolutePath);
+  }
+  printResults(configResults, binaryResult, installMethod);
+  const hasFailures = configResults.some((r2) => !r2.success && !r2.skipped);
+  const binaryFailed = binaryResult && !binaryResult.success && !binaryResult.skipped;
+  if (hasFailures || binaryFailed) {
+    process.exit(UNINSTALL_EXIT_CODES.ERROR);
+  }
+  if (isPackageManaged(installMethod)) {
+    process.exit(UNINSTALL_EXIT_CODES.ERROR);
+  }
+  process.exit(UNINSTALL_EXIT_CODES.SUCCESS);
+}
+function registerSelfUninstallCommand(parent) {
+  parent.command("uninstall").description("Remove OCX global configuration and binary").option("--dry-run", "Preview what would be removed").action(wrapAction(async (options2) => {
+    await runUninstall(options2);
+  }));
+}
+
 // src/self-update/version-provider.ts
 class BuildTimeVersionProvider {
-  version = "1.4.1";
+  version = "1.4.3";
 }
 var defaultVersionProvider = new BuildTimeVersionProvider;
 
@@ -16434,57 +17333,8 @@ async function checkForUpdate(versionProvider, timeoutMs = VERSION_CHECK_TIMEOUT
   }
 }
 
-// src/self-update/detect-method.ts
-function parseInstallMethod(input) {
-  const VALID_METHODS = ["curl", "npm", "yarn", "pnpm", "bun"];
-  const method = VALID_METHODS.find((m) => m === input);
-  if (!method) {
-    throw new SelfUpdateError(`Invalid install method: "${input}"
-Valid methods: ${VALID_METHODS.join(", ")}`);
-  }
-  return method;
-}
-var isCompiledBinary = () => Bun.main.startsWith("/$bunfs/");
-var isTempExecution = (path8) => path8.includes("/_npx/") || path8.includes("/.cache/bunx/") || path8.includes("/.pnpm/_temp/");
-var isYarnGlobalInstall = (path8) => path8.includes("/.yarn/global") || path8.includes("/.config/yarn/global");
-var isPnpmGlobalInstall = (path8) => path8.includes("/.pnpm/") || path8.includes("/pnpm/global");
-var isBunGlobalInstall = (path8) => path8.includes("/.bun/bin") || path8.includes("/.bun/install/global");
-var isNpmGlobalInstall = (path8) => path8.includes("/.npm/") || path8.includes("/node_modules/");
-function detectInstallMethod() {
-  if (isCompiledBinary()) {
-    return "curl";
-  }
-  const scriptPath = process.argv[1] ?? "";
-  if (isTempExecution(scriptPath))
-    return "unknown";
-  if (isYarnGlobalInstall(scriptPath))
-    return "yarn";
-  if (isPnpmGlobalInstall(scriptPath))
-    return "pnpm";
-  if (isBunGlobalInstall(scriptPath))
-    return "bun";
-  if (isNpmGlobalInstall(scriptPath))
-    return "npm";
-  const userAgent = process.env.npm_config_user_agent ?? "";
-  if (userAgent.includes("yarn"))
-    return "yarn";
-  if (userAgent.includes("pnpm"))
-    return "pnpm";
-  if (userAgent.includes("bun"))
-    return "bun";
-  if (userAgent.includes("npm"))
-    return "npm";
-  return "unknown";
-}
-function getExecutablePath() {
-  if (typeof Bun !== "undefined" && Bun.main.startsWith("/$bunfs/")) {
-    return process.execPath;
-  }
-  return process.argv[1] ?? process.execPath;
-}
-
 // src/self-update/download.ts
-import { chmodSync, existsSync as existsSync10, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
+import { chmodSync, existsSync as existsSync12, renameSync as renameSync2, unlinkSync as unlinkSync3 } from "fs";
 var GITHUB_REPO2 = "kdcokenny/ocx";
 var DEFAULT_DOWNLOAD_BASE_URL = `https://github.com/${GITHUB_REPO2}/releases/download`;
 var PLATFORM_MAP = {
@@ -16562,8 +17412,8 @@ async function downloadToTemp(version) {
   try {
     chmodSync(tempPath, 493);
   } catch (error) {
-    if (existsSync10(tempPath)) {
-      unlinkSync2(tempPath);
+    if (existsSync12(tempPath)) {
+      unlinkSync3(tempPath);
     }
     throw new SelfUpdateError(`Failed to set permissions: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -16572,31 +17422,31 @@ async function downloadToTemp(version) {
 function atomicReplace(tempPath, execPath) {
   const backupPath = `${execPath}.backup`;
   try {
-    if (existsSync10(execPath)) {
+    if (existsSync12(execPath)) {
       renameSync2(execPath, backupPath);
     }
     renameSync2(tempPath, execPath);
-    if (existsSync10(backupPath)) {
-      unlinkSync2(backupPath);
+    if (existsSync12(backupPath)) {
+      unlinkSync3(backupPath);
     }
   } catch (error) {
-    if (existsSync10(backupPath) && !existsSync10(execPath)) {
+    if (existsSync12(backupPath) && !existsSync12(execPath)) {
       try {
         renameSync2(backupPath, execPath);
       } catch {}
     }
-    if (existsSync10(tempPath)) {
+    if (existsSync12(tempPath)) {
       try {
-        unlinkSync2(tempPath);
+        unlinkSync3(tempPath);
       } catch {}
     }
     throw new SelfUpdateError(`Update failed: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 function cleanupTempFile(tempPath) {
-  if (existsSync10(tempPath)) {
+  if (existsSync12(tempPath)) {
     try {
-      unlinkSync2(tempPath);
+      unlinkSync3(tempPath);
     } catch {}
   }
 }
@@ -16765,14 +17615,15 @@ function registerSelfUpdateCommand(parent) {
 // src/commands/self/index.ts
 function registerSelfCommand(program2) {
   const self = program2.command("self").description("Manage the OCX CLI");
+  registerSelfUninstallCommand(self);
   registerSelfUpdateCommand(self);
 }
 
 // src/commands/update.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { mkdir as mkdir9, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname5, join as join9 } from "path";
+import { dirname as dirname6, join as join10 } 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 {
@@ -16910,9 +17761,9 @@ 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 = join9(provider.cwd, fileObj.target);
-        const targetDir = dirname5(targetPath);
-        if (!existsSync11(targetDir)) {
+        const targetPath = join10(provider.cwd, fileObj.target);
+        const targetDir = dirname6(targetPath);
+        if (!existsSync13(targetDir)) {
           await mkdir9(targetDir, { recursive: true });
         }
         await writeFile4(targetPath, file.content);
@@ -17061,8 +17912,8 @@ function shouldCheckForUpdate() {
   return true;
 }
 function registerUpdateCheckHook(program2) {
-  program2.hook("postAction", async (thisCommand) => {
-    if (thisCommand.name() === "update" && thisCommand.parent?.name() === "self") {
+  program2.hook("postAction", async (_thisCommand, actionCommand) => {
+    if (actionCommand.name() === "update" && actionCommand.parent?.name() === "self") {
       return;
     }
     if (!shouldCheckForUpdate())
@@ -17076,7 +17927,7 @@ function registerUpdateCheckHook(program2) {
   });
 }
 // src/index.ts
-var version = "1.4.1";
+var version = "1.4.3";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version);
   registerInitCommand(program2);
@@ -17108,4 +17959,4 @@ export {
   buildRegistry
 };
 
-//# debugId=4E10E39074E11B3A64756E2164756E21
+//# debugId=947205F975538A0764756E2164756E21