ocx 1.4.2 → 1.4.4

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 = {
@@ -9847,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;
   }
 }
 
@@ -9875,6 +9881,9 @@ class ConflictError extends OCXError {
 }
 
 class IntegrityError extends OCXError {
+  component;
+  expected;
+  found;
   constructor(component, expected, found) {
     const message = `Integrity verification failed for "${component}"
 ` + `  Expected: ${expected}
@@ -9883,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";
   }
 }
@@ -9902,15 +9914,20 @@ 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. Use --force to overwrite.`, "CONFLICT", EXIT_CODES.CONFLICT);
+  profile;
+  constructor(profile, hint) {
+    const message = hint ? `Profile "${profile}" already exists. ${hint}` : `Profile "${profile}" already exists.`;
+    super(message, "CONFLICT", EXIT_CODES.CONFLICT);
+    this.profile = profile;
     this.name = "ProfileExistsError";
   }
 }
@@ -9937,8 +9954,12 @@ class RegistryExistsError extends OCXError {
 }
 
 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";
   }
 }
@@ -9950,6 +9971,68 @@ class ProfilesNotInitializedError extends OCXError {
   }
 }
 
+// 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'
@@ -9999,11 +10082,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;
@@ -10132,7 +10215,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("~")) {
@@ -10149,17 +10232,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) {
@@ -10283,16 +10367,24 @@ var installedComponentSchema = exports_external.object({
   installedAt: exports_external.string(),
   updatedAt: exports_external.string().optional()
 });
+var installedFromSchema = exports_external.object({
+  registry: exports_external.string(),
+  component: exports_external.string(),
+  version: exports_external.string().optional(),
+  hash: exports_external.string(),
+  installedAt: exports_external.string()
+});
 var ocxLockSchema = exports_external.object({
   lockVersion: exports_external.literal(1),
+  installedFrom: installedFromSchema.optional(),
   installed: exports_external.record(qualifiedComponentSchema, installedComponentSchema).default({})
 });
 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) {
@@ -10307,8 +10399,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 };
@@ -10339,8 +10431,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);
 }
@@ -10355,8 +10447,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);
 }
@@ -10364,10 +10456,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() {
@@ -10436,19 +10528,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
@@ -10470,7 +10562,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/**",
@@ -10498,38 +10589,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;
     }
@@ -10537,8 +10628,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
@@ -10556,7 +10647,6 @@ var DEFAULT_OCX_CONFIG = {
   registries: {},
   renameWindow: true,
   exclude: [
-    "**/AGENTS.md",
     "**/CLAUDE.md",
     "**/CONTEXT.md",
     "**/.opencode/**",
@@ -10565,6 +10655,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;
@@ -10650,7 +10755,7 @@ class ProfileManager {
     const ocxPath = getProfileOcxConfig(name);
     const ocxFile = Bun.file(ocxPath);
     if (!await ocxFile.exists()) {
-      await atomicWrite(ocxPath, DEFAULT_OCX_CONFIG);
+      await Bun.write(ocxPath, DEFAULT_OCX_CONFIG_TEMPLATE, { mode: 384 });
     }
     const opencodePath = getProfileOpencodeConfig(name);
     const opencodeFile = Bun.file(opencodePath);
@@ -10679,6 +10784,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)) {
@@ -10728,7 +10871,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);
       }
     }
@@ -10889,7 +11032,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) {
@@ -10982,7 +11125,7 @@ class ConfigResolver {
 // package.json
 var package_default = {
   name: "ocx",
-  version: "1.4.2",
+  version: "1.4.4",
   description: "OCX CLI - ShadCN-style registry for OpenCode extensions. Install agents, plugins, skills, and MCP servers.",
   author: "kdcokenny",
   license: "MIT",
@@ -11061,14 +11204,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);
@@ -11115,9 +11272,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();
 }
@@ -11192,13 +11354,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);
@@ -11209,12 +11371,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, {
@@ -11241,7 +11412,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());
@@ -11258,17 +11429,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: {
@@ -11285,8 +11456,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 };
     }
@@ -11295,16 +11466,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 };
   }
@@ -11318,7 +11489,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 };
 }
@@ -11335,13 +11506,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")
@@ -11350,27 +11521,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) {
@@ -11384,8 +11555,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;
@@ -11427,7 +11598,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;
@@ -11493,12 +11664,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;
@@ -11636,6 +11895,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 = {}) {
@@ -11651,8 +11919,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);
   }
@@ -11695,6 +11963,110 @@ function formatErrorAsJson(error) {
       }
     };
   }
+  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,
@@ -11713,7 +12085,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: {
@@ -11738,15 +12117,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)) {
@@ -13507,7 +13886,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];
@@ -13517,7 +13896,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) {
@@ -13541,7 +13920,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");
@@ -13606,7 +13985,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();
@@ -13648,8 +14027,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");
@@ -13662,7 +14041,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);
   }
@@ -13738,7 +14117,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 };
   }
@@ -13751,7 +14130,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 = [];
@@ -13774,12 +14153,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);
@@ -13795,101 +14174,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...",
@@ -13902,7 +14191,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`);
@@ -14204,16 +14493,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 }
       };
     }
@@ -15030,7 +15319,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";
@@ -15068,8 +15357,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)) {
@@ -15099,13 +15388,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 {
@@ -15144,7 +15433,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);
@@ -15203,21 +15492,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 {}
@@ -15238,8 +15527,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) {
@@ -15265,7 +15554,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}/`);
       }
     }
@@ -15525,7 +15814,7 @@ async function copyDir(src, dest) {
 }
 function getReleaseTag() {
   if (false) {}
-  return `v${"1.4.2"}`;
+  return `v${"1.4.4"}`;
 }
 function getTemplateUrl(version) {
   const ref = version === "main" ? "heads/main" : `tags/${version}`;
@@ -15566,6 +15855,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",
@@ -15580,16 +15872,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() {
@@ -15632,7 +15925,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}`;
   }
@@ -15654,16 +15947,16 @@ function buildOpenCodeEnv(opts) {
   };
 }
 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();
@@ -15748,12 +16041,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");
 }
@@ -15768,7 +16057,7 @@ function hashBundle2(files) {
 `));
 }
 async function installProfileFromRegistry(options2) {
-  const { namespace, component, profileName, force, registryUrl, registries, quiet } = options2;
+  const { namespace, component, profileName, registryUrl, registries, quiet } = options2;
   const parseResult = profileNameSchema.safeParse(profileName);
   if (!parseResult.success) {
     throw new ValidationError(`Invalid profile name: "${profileName}". ` + `Profile names must start with a letter and contain only alphanumeric characters, dots, underscores, or hyphens.`);
@@ -15776,9 +16065,8 @@ async function installProfileFromRegistry(options2) {
   const profileDir = getProfileDir(profileName);
   const qualifiedName = `${namespace}/${component}`;
   const profileExists = existsSync9(profileDir);
-  if (profileExists && !force) {
-    throw new ConflictError(`Profile "${profileName}" already exists.
-Use --force to overwrite.`);
+  if (profileExists) {
+    throw new ConflictError(`Profile "${profileName}" already exists. Remove it first with 'ocx profile rm ${profileName}'.`);
   }
   const fetchSpin = quiet ? null : createSpinner({ text: `Fetching ${qualifiedName}...` });
   fetchSpin?.start();
@@ -15805,7 +16093,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 = {
@@ -15813,53 +16101,17 @@ 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`);
-  let resolvedDeps = null;
-  const dependencyBundles = [];
-  if (manifest.dependencies.length > 0) {
-    const depsSpin = quiet ? null : createSpinner({ text: "Resolving dependencies..." });
-    depsSpin?.start();
-    try {
-      const depRefs = manifest.dependencies.map((dep) => dep.includes("/") ? dep : `${namespace}/${dep}`);
-      resolvedDeps = await resolveDependencies(registries, depRefs);
-      for (const depComponent of resolvedDeps.components) {
-        const files = [];
-        for (const file of depComponent.files) {
-          const content2 = await fetchFileContent(depComponent.baseUrl, depComponent.name, file.path);
-          const resolvedTarget = resolveTargetPath(file.target, true);
-          files.push({
-            path: file.path,
-            target: resolvedTarget,
-            content: Buffer.from(content2)
-          });
-        }
-        const registryIndex = await fetchRegistryIndex(depComponent.baseUrl);
-        dependencyBundles.push({
-          qualifiedName: depComponent.qualifiedName,
-          registryName: depComponent.registryName,
-          files,
-          hash: hashBundle2(files),
-          version: registryIndex.version
-        });
-      }
-      depsSpin?.succeed(`Resolved ${resolvedDeps.components.length} dependencies`);
-    } catch (error) {
-      depsSpin?.fail("Failed to resolve dependencies");
-      throw error;
-    }
-  }
   const profilesDir = getProfilesDir();
   await mkdir8(profilesDir, { recursive: true, mode: 448 });
   const stagingDir = await mkdtemp(join8(profilesDir, ".staging-"));
-  const stagingOpencodeDir = join8(stagingDir, ".opencode");
   try {
-    await mkdir8(stagingOpencodeDir, { recursive: true, mode: 448 });
     const writeSpin = quiet ? null : createSpinner({ text: "Writing profile files..." });
     writeSpin?.start();
     for (const file of profileFiles) {
@@ -15870,37 +16122,20 @@ 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 targetPath = join8(stagingDir, target);
       const targetDir = dirname4(targetPath);
       if (!existsSync9(targetDir)) {
         await mkdir8(targetDir, { recursive: true });
       }
       await writeFile3(targetPath, file.content);
     }
-    writeSpin?.succeed(`Wrote ${profileFiles.length + dependencyFiles.length} profile files`);
-    if (dependencyBundles.length > 0) {
-      const depWriteSpin = quiet ? null : createSpinner({ text: "Writing dependency files..." });
-      depWriteSpin?.start();
-      let depFileCount = 0;
-      for (const bundle of dependencyBundles) {
-        for (const file of bundle.files) {
-          const targetPath = join8(stagingOpencodeDir, file.target);
-          const targetDir = dirname4(targetPath);
-          if (!existsSync9(targetDir)) {
-            await mkdir8(targetDir, { recursive: true });
-          }
-          await writeFile3(targetPath, file.content);
-          depFileCount++;
-        }
-      }
-      depWriteSpin?.succeed(`Wrote ${depFileCount} dependency files`);
-    }
+    writeSpin?.succeed(`Wrote ${profileFiles.length + embeddedFiles.length} profile files`);
     const profileHash = hashBundle2(profileFiles.map((f) => ({ path: f.path, content: f.content })));
     const registryIndex = await fetchRegistryIndex(registryUrl);
     const lock = {
-      version: 1,
+      lockVersion: 1,
       installedFrom: {
         registry: namespace,
         component,
@@ -15910,36 +16145,32 @@ Use --force to overwrite.`);
       },
       installed: {}
     };
-    for (const bundle of dependencyBundles) {
-      lock.installed[bundle.qualifiedName] = {
-        registry: bundle.registryName,
-        version: bundle.version,
-        hash: bundle.hash,
-        files: bundle.files.map((f) => f.target),
-        installedAt: new Date().toISOString()
-      };
-    }
-    await writeFile3(join8(stagingDir, "ocx.lock"), JSON.stringify(lock, null, "\t"));
-    const moveSpin = quiet ? null : createSpinner({ text: "Finalizing installation..." });
-    moveSpin?.start();
+    await writeOcxLock(stagingDir, lock, join8(stagingDir, "ocx.lock"));
+    const renameSpin = quiet ? null : createSpinner({ text: "Moving to profile directory..." });
+    renameSpin?.start();
     const profilesDir2 = dirname4(profileDir);
     if (!existsSync9(profilesDir2)) {
       await mkdir8(profilesDir2, { recursive: true, mode: 448 });
     }
-    if (profileExists && force) {
-      const backupDir = `${profileDir}.backup-${Date.now()}`;
-      await rename2(profileDir, backupDir);
+    await rename3(stagingDir, profileDir);
+    renameSpin?.succeed("Profile installed");
+    if (manifest.dependencies.length > 0) {
+      const depsSpin = quiet ? null : createSpinner({ text: "Installing dependencies..." });
+      depsSpin?.start();
       try {
-        await rename2(stagingDir, profileDir);
-      } catch (err) {
-        await rename2(backupDir, profileDir);
-        throw err;
+        const depRefs = manifest.dependencies.map((dep) => dep.includes("/") ? dep : `${namespace}/${dep}`);
+        const provider = {
+          cwd: profileDir,
+          getRegistries: () => registries,
+          getComponentPath: () => ""
+        };
+        await runAddCore(depRefs, { profile: profileName }, provider);
+        depsSpin?.succeed(`Installed ${manifest.dependencies.length} dependencies`);
+      } catch (error) {
+        depsSpin?.fail("Failed to install dependencies");
+        throw error;
       }
-      await rm3(backupDir, { recursive: true, force: true });
-    } else {
-      await rename2(stagingDir, profileDir);
     }
-    moveSpin?.succeed("Installation complete");
     if (!quiet) {
       logger.info("");
       logger.success(`Installed profile "${profileName}" from ${qualifiedName}`);
@@ -15948,12 +16179,9 @@ Use --force to overwrite.`);
       for (const file of profileFiles) {
         logger.info(`  ${file.target}`);
       }
-      if (dependencyBundles.length > 0) {
-        logger.info("");
-        logger.info("Dependencies:");
-        for (const bundle of dependencyBundles) {
-          logger.info(`  ${bundle.qualifiedName}`);
-        }
+      for (const file of embeddedFiles) {
+        const target = file.target.startsWith(".opencode/") ? file.target.slice(".opencode/".length) : file.target;
+        logger.info(`  ${target}`);
       }
     }
   } catch (error) {
@@ -15972,9 +16200,6 @@ function parseFromOption(from) {
     throw new ValidationError("--from value cannot be empty");
   }
   const trimmed = from.trim();
-  if (trimmed.startsWith("./") || trimmed.startsWith("~/") || trimmed.startsWith("/")) {
-    return { type: "local-path", path: trimmed };
-  }
   const slashCount = (trimmed.match(/\//g) || []).length;
   if (slashCount === 1) {
     const [namespace, component] = trimmed.split("/").map((s) => s.trim());
@@ -16022,12 +16247,11 @@ async function requireGlobalRegistry(namespace) {
   return { config: globalConfig, registryUrl: registry.url };
 }
 function registerProfileAddCommand(parent) {
-  parent.command("add <name>").description("Create a new profile, clone from existing, or install from registry").option("--from <source>", "Clone from existing profile or install from registry (e.g., kdco/minimal)").option("-f, --force", "Overwrite existing profile").addHelpText("after", `
+  parent.command("add <name>").description("Create a new profile, clone from existing, or install from registry").option("--from <source>", "Clone from existing profile or install from registry (e.g., kdco/minimal)").addHelpText("after", `
 Examples:
   $ ocx profile add work                      # Create empty profile
   $ ocx profile add work --from dev           # Clone from existing profile
   $ ocx profile add work --from kdco/minimal  # Install from registry
-  $ ocx profile add work --from kdco/minimal --force  # Overwrite existing
 `).action(async (name, options2) => {
     try {
       await runProfileAdd(name, options2);
@@ -16038,28 +16262,15 @@ Examples:
 }
 async function runProfileAdd(name, options2) {
   const manager = await ProfileManager.requireInitialized();
-  const profileExists = await manager.exists(name);
-  if (profileExists && !options2.force) {
-    logger.error(`\u2717 Profile "${name}" already exists`);
-    logger.error("");
-    logger.error("Use --force to overwrite the existing profile.");
-    throw new ProfileExistsError(name);
-  }
   if (!options2.from) {
-    await createEmptyProfile(manager, name, profileExists);
+    await createEmptyProfile(manager, name);
     return;
   }
   const fromInput = parseFromOption(options2.from);
   switch (fromInput.type) {
     case "local-profile":
-      await cloneFromLocalProfile(manager, name, fromInput.name, profileExists);
+      await cloneFromLocalProfile(manager, name, fromInput.name);
       break;
-    case "local-path":
-      throw new ValidationError(`Local path installation is not yet implemented: "${fromInput.path}"
-
-` + `Currently supported sources:
-` + `  - Existing profile: --from <profile-name>
-` + `  - Registry: --from <namespace>/<component>`);
     case "registry": {
       const { config: globalConfig, registryUrl } = await requireGlobalRegistry(fromInput.namespace);
       const registries = {};
@@ -16070,7 +16281,6 @@ async function runProfileAdd(name, options2) {
         namespace: fromInput.namespace,
         component: fromInput.component,
         profileName: name,
-        force: options2.force,
         registryUrl,
         registries
       });
@@ -16078,18 +16288,20 @@ async function runProfileAdd(name, options2) {
     }
   }
 }
-async function createEmptyProfile(manager, name, exists) {
+async function createEmptyProfile(manager, name) {
+  const exists = await manager.exists(name);
   if (exists) {
-    await manager.remove(name);
+    throw new ProfileExistsError(name, `Remove it first with 'ocx profile rm ${name}'.`);
   }
   await manager.add(name);
   logger.success(`Created profile "${name}"`);
 }
-async function cloneFromLocalProfile(manager, name, sourceName, exists) {
-  const source = await manager.get(sourceName);
+async function cloneFromLocalProfile(manager, name, sourceName) {
+  const exists = await manager.exists(name);
   if (exists) {
-    await manager.remove(name);
+    throw new ProfileExistsError(name, `Remove it first with 'ocx profile rm ${name}'.`);
   }
+  const source = await manager.get(sourceName);
   await manager.add(name);
   await atomicWrite(getProfileOcxConfig(name), source.ocx);
   logger.success(`Created profile "${name}" (cloned from "${sourceName}")`);
@@ -16122,6 +16334,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) => {
@@ -16180,6 +16411,7 @@ function registerProfileCommand(program2) {
   registerProfileListCommand(profile);
   registerProfileAddCommand(profile);
   registerProfileRemoveCommand(profile);
+  registerProfileMoveCommand(profile);
   registerProfileShowCommand(profile);
 }
 
@@ -16517,9 +16749,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.2";
+  version = "1.4.4";
 }
 var defaultVersionProvider = new BuildTimeVersionProvider;
 
@@ -16582,57 +17265,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 existsSync11, 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 = {
@@ -16710,8 +17344,8 @@ async function downloadToTemp(version) {
   try {
     chmodSync(tempPath, 493);
   } catch (error) {
-    if (existsSync11(tempPath)) {
-      unlinkSync2(tempPath);
+    if (existsSync12(tempPath)) {
+      unlinkSync3(tempPath);
     }
     throw new SelfUpdateError(`Failed to set permissions: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -16720,31 +17354,31 @@ async function downloadToTemp(version) {
 function atomicReplace(tempPath, execPath) {
   const backupPath = `${execPath}.backup`;
   try {
-    if (existsSync11(execPath)) {
+    if (existsSync12(execPath)) {
       renameSync2(execPath, backupPath);
     }
     renameSync2(tempPath, execPath);
-    if (existsSync11(backupPath)) {
-      unlinkSync2(backupPath);
+    if (existsSync12(backupPath)) {
+      unlinkSync3(backupPath);
     }
   } catch (error) {
-    if (existsSync11(backupPath) && !existsSync11(execPath)) {
+    if (existsSync12(backupPath) && !existsSync12(execPath)) {
       try {
         renameSync2(backupPath, execPath);
       } catch {}
     }
-    if (existsSync11(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 (existsSync11(tempPath)) {
+  if (existsSync12(tempPath)) {
     try {
-      unlinkSync2(tempPath);
+      unlinkSync3(tempPath);
     } catch {}
   }
 }
@@ -16913,12 +17547,13 @@ 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 existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { mkdir as mkdir9, writeFile as writeFile4 } from "fs/promises";
 import { dirname as dirname6, join as join10 } from "path";
 function registerUpdateCommand(program2) {
@@ -17060,7 +17695,7 @@ Version cannot be empty. Use 'kdco/agents@1.2.0' or omit the version for latest.
           continue;
         const targetPath = join10(provider.cwd, fileObj.target);
         const targetDir = dirname6(targetPath);
-        if (!existsSync12(targetDir)) {
+        if (!existsSync13(targetDir)) {
           await mkdir9(targetDir, { recursive: true });
         }
         await writeFile4(targetPath, file.content);
@@ -17209,8 +17844,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())
@@ -17224,7 +17859,7 @@ function registerUpdateCheckHook(program2) {
   });
 }
 // src/index.ts
-var version = "1.4.2";
+var version = "1.4.4";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version);
   registerInitCommand(program2);
@@ -17256,4 +17891,4 @@ export {
   buildRegistry
 };
 
-//# debugId=52AD8D268EBA9E8864756E2164756E21
+//# debugId=C29AE4337E16008A64756E2164756E21