ocx 1.2.2 → 1.3.0

package/dist/index.js

@@ -3761,6 +3761,333 @@ var require_cli_spinners = __commonJS((exports, module) => {
   module.exports = spinners;
 });
 
+// ../../node_modules/.bun/ignore@7.0.5/node_modules/ignore/index.js
+var require_ignore = __commonJS((exports, module) => {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var UNDEFINED = undefined;
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+  var REGEX_TEST_TRAILING_SLASH = /\/$/;
+  var SLASH2 = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define2 = (object, key, value) => {
+    Object.defineProperty(object, key, { value });
+    return value;
+  };
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*\\\*\\\*\\\//,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ]
+  ];
+  var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+  var MODE_IGNORE = "regex";
+  var MODE_CHECK_IGNORE = "checkRegex";
+  var UNDERSCORE = "_";
+  var TRAILING_WILD_CARD_REPLACERS = {
+    [MODE_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    },
+    [MODE_CHECK_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }
+  };
+  var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+
+  class IgnoreRule {
+    constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+      this.pattern = pattern;
+      this.mark = mark;
+      this.negative = negative;
+      define2(this, "body", body);
+      define2(this, "ignoreCase", ignoreCase);
+      define2(this, "regexPrefix", prefix);
+    }
+    get regex() {
+      const key = UNDERSCORE + MODE_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_IGNORE, key);
+    }
+    get checkRegex() {
+      const key = UNDERSCORE + MODE_CHECK_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_CHECK_IGNORE, key);
+    }
+    _make(mode, key) {
+      const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
+      const regex2 = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+      return define2(this, key, regex2);
+    }
+  }
+  var createRule = ({
+    pattern,
+    mark
+  }, ignoreCase) => {
+    let negative = false;
+    let body = pattern;
+    if (body.indexOf("!") === 0) {
+      negative = true;
+      body = body.substr(1);
+    }
+    body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regexPrefix = makeRegexPrefix(body);
+    return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
+  };
+
+  class RuleManager {
+    constructor(ignoreCase) {
+      this._ignoreCase = ignoreCase;
+      this._rules = [];
+    }
+    _add(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules._rules);
+        this._added = true;
+        return;
+      }
+      if (isString(pattern)) {
+        pattern = {
+          pattern
+        };
+      }
+      if (checkPattern(pattern.pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+      return this._added;
+    }
+    test(path5, checkUnignored, mode) {
+      let ignored = false;
+      let unignored = false;
+      let matchedRule;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule[mode].test(path5);
+        if (!matched) {
+          return;
+        }
+        ignored = !negative;
+        unignored = negative;
+        matchedRule = negative ? UNDEFINED : rule;
+      });
+      const ret = {
+        ignored,
+        unignored
+      };
+      if (matchedRule) {
+        ret.rule = matchedRule;
+      }
+      return ret;
+    }
+  }
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path5, originalPath, doThrow) => {
+    if (!isString(path5)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path5) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path5)) {
+      const r2 = "`path.relative()`d";
+      return doThrow(`path should be a ${r2} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path5) => REGEX_TEST_INVALID_PATH.test(path5);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p) => p;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define2(this, KEY_IGNORE, true);
+      this._rules = new RuleManager(ignoreCase);
+      this._strictPathCheck = !allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    add(pattern) {
+      if (this._rules.add(pattern)) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _test(originalPath, cache2, checkUnignored, slices) {
+      const path5 = originalPath && checkPath.convert(originalPath);
+      checkPath(path5, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path5, cache2, checkUnignored, slices);
+    }
+    checkIgnore(path5) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path5)) {
+        return this.test(path5);
+      }
+      const slices = path5.split(SLASH2).filter(Boolean);
+      slices.pop();
+      if (slices.length) {
+        const parent = this._t(slices.join(SLASH2) + SLASH2, this._testCache, true, slices);
+        if (parent.ignored) {
+          return parent;
+        }
+      }
+      return this._rules.test(path5, false, MODE_CHECK_IGNORE);
+    }
+    _t(path5, cache2, checkUnignored, slices) {
+      if (path5 in cache2) {
+        return cache2[path5];
+      }
+      if (!slices) {
+        slices = path5.split(SLASH2).filter(Boolean);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache2[path5] = this._rules.test(path5, checkUnignored, MODE_IGNORE);
+      }
+      const parent = this._t(slices.join(SLASH2) + SLASH2, cache2, checkUnignored, slices);
+      return cache2[path5] = parent.ignored ? parent : this._rules.test(path5, checkUnignored, MODE_IGNORE);
+    }
+    ignores(path5) {
+      return this._test(path5, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path5) => !this.ignores(path5);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path5) {
+      return this._test(path5, this._testCache, true);
+    }
+  }
+  var factory = (options2) => new Ignore(options2);
+  var isPathValid = (path5) => checkPath(path5 && checkPath.convert(path5), path5, RETURN_FALSE);
+  var setupWindows = () => {
+    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path5) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path5) || isNotRelative(path5);
+  };
+  if (typeof process !== "undefined" && process.platform === "win32") {
+    setupWindows();
+  }
+  module.exports = factory;
+  factory.default = factory;
+  module.exports.isPathValid = isPathValid;
+  define2(module.exports, Symbol.for("setupWindows"), setupWindows);
+});
+
 // ../../node_modules/.bun/fuzzysort@3.1.0/node_modules/fuzzysort/fuzzysort.js
 var require_fuzzysort = __commonJS((exports, module) => {
   ((root, UMD) => {
@@ -3949,8 +4276,8 @@ var require_fuzzysort = __commonJS((exports, module) => {
       results.total = resultsLen + limitedCount;
       return results;
     };
-    var highlight = (result, open = "<b>", close = "</b>") => {
-      var callback = typeof open === "function" ? open : undefined;
+    var highlight = (result, open2 = "<b>", close = "</b>") => {
+      var callback = typeof open2 === "function" ? open2 : undefined;
       var target = result.target;
       var targetLen = target.length;
       var indexes = result.indexes;
@@ -3969,7 +4296,7 @@ var require_fuzzysort = __commonJS((exports, module) => {
               parts.push(highlighted);
               highlighted = "";
             } else {
-              highlighted += open;
+              highlighted += open2;
             }
           }
           if (indexesI === indexes.length) {
@@ -4018,8 +4345,8 @@ var require_fuzzysort = __commonJS((exports, module) => {
       set ["indexes"](indexes) {
         return this._indexes = indexes;
       }
-      ["highlight"](open, close) {
-        return highlight(this, open, close);
+      ["highlight"](open2, close) {
+        return highlight(this, open2, close);
       }
       get ["score"]() {
         return normalizeScore(this._score);
@@ -10165,8 +10492,16 @@ var ghostConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   registries: exports_external.record(registryConfigSchema).default({}),
   componentPath: safeRelativePathSchema.optional(),
-  include: exports_external.array(globPatternSchema).optional(),
-  exclude: exports_external.array(globPatternSchema).optional()
+  exclude: exports_external.array(globPatternSchema).default([
+    "**/AGENTS.md",
+    "**/CLAUDE.md",
+    "**/CONTEXT.md",
+    ".opencode",
+    "opencode.jsonc",
+    "opencode.json"
+  ]).describe("Glob patterns to exclude from the symlink farm"),
+  include: exports_external.array(globPatternSchema).default([]).describe("Glob patterns to re-include from excluded set (for power users)"),
+  renameWindow: exports_external.boolean().default(true).describe("Set terminal/tmux window name when launching OpenCode")
 });
 
 // src/utils/errors.ts
@@ -10237,6 +10572,13 @@ class IntegrityError extends OCXError {
     this.name = "IntegrityError";
   }
 }
+
+class SelfUpdateError extends OCXError {
+  constructor(message) {
+    super(message, "UPDATE_ERROR", EXIT_CODES.GENERAL);
+    this.name = "SelfUpdateError";
+  }
+}
 class GhostConfigError extends OCXError {
   constructor(message) {
     super(message, "CONFIG_ERROR", EXIT_CODES.CONFIG);
@@ -10334,7 +10676,17 @@ var profileSchema = exports_external.object({
 // src/profile/manager.ts
 var DEFAULT_GHOST_CONFIG = {
   $schema: "https://ocx.kdco.dev/schemas/ghost.json",
-  registries: {}
+  registries: {},
+  exclude: [
+    "**/AGENTS.md",
+    "**/CLAUDE.md",
+    "**/CONTEXT.md",
+    ".opencode",
+    "opencode.jsonc",
+    "opencode.json"
+  ],
+  include: [],
+  renameWindow: true
 };
 
 class ProfileManager {
@@ -10528,7 +10880,7 @@ class GhostConfigProvider {
 // package.json
 var package_default = {
   name: "ocx",
-  version: "1.2.2",
+  version: "1.3.0",
   description: "OCX CLI - ShadCN-style registry for OpenCode extensions. Install agents, plugins, skills, and MCP servers.",
   author: "kdcokenny",
   license: "MIT",
@@ -10576,9 +10928,11 @@ var package_default = {
     test: "bun test"
   },
   dependencies: {
+    chokidar: "^5.0.0",
     commander: "^14.0.0",
     diff: "^8.0.0",
     fuzzysort: "^3.1.0",
+    ignore: "^7.0.5",
     "jsonc-parser": "3.3.1",
     kleur: "^4.1.5",
     ora: "^8.2.0",
@@ -10920,6 +11274,19 @@ function isContentIdentical(existing, incoming) {
 var isCI = Boolean(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.JENKINS_URL || process.env.BUILDKITE);
 var isTTY = Boolean(process.stdout.isTTY && !isCI);
 var supportsColor = Boolean(isTTY && process.env.FORCE_COLOR !== "0" && process.env.NO_COLOR === undefined);
+function parseEnvBool(value, defaultValue) {
+  if (value == null || value === "") {
+    return defaultValue;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return defaultValue;
+}
 // src/utils/git-context.ts
 import { basename, resolve } from "path";
 function getGitEnv() {
@@ -11194,6 +11561,15 @@ function handleError(error, options2 = {}) {
   }
   process.exit(EXIT_CODES.GENERAL);
 }
+function wrapAction(action) {
+  return async (...args) => {
+    try {
+      await action(...args);
+    } catch (error) {
+      handleError(error);
+    }
+  };
+}
 function formatErrorAsJson(error) {
   if (error instanceof OCXError) {
     return {
@@ -12714,20 +13090,18 @@ function parseNpmSpecifier(specifier) {
 function isNpmSpecifier(input) {
   return input.trim().startsWith("npm:");
 }
-async function validateNpmPackage(packageName) {
+async function validateNpmPackage(packageName, signal) {
   validateNpmPackageName(packageName);
   const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName);
   const url = `${NPM_REGISTRY_BASE}/${encodedName}`;
   try {
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT_MS);
+    const fetchSignal = signal ?? AbortSignal.timeout(NPM_FETCH_TIMEOUT_MS);
     const response = await fetch(url, {
-      signal: controller.signal,
+      signal: fetchSignal,
       headers: {
         Accept: "application/json"
       }
     });
-    clearTimeout(timeoutId);
     if (response.status === 404) {
       throw new NotFoundError(`npm package \`${packageName}\` not found on registry`);
     }
@@ -12740,8 +13114,8 @@ async function validateNpmPackage(packageName) {
     if (error instanceof NotFoundError || error instanceof NetworkError) {
       throw error;
     }
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new NetworkError(`Request to npm registry timed out after ${NPM_FETCH_TIMEOUT_MS / 1000}s for package \`${packageName}\``);
+    if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) {
+      throw new NetworkError(`Request to npm registry timed out for package \`${packageName}\``);
     }
     const message = error instanceof Error ? error.message : String(error);
     throw new NetworkError(`Failed to fetch npm package \`${packageName}\`: ${message}`);
@@ -12765,8 +13139,8 @@ function validateOpenCodePlugin(packageJson) {
   }
   return { valid: true, warnings };
 }
-async function fetchPackageVersion(packageName, version) {
-  const metadata = await validateNpmPackage(packageName);
+async function fetchPackageVersion(packageName, version, signal) {
+  const metadata = await validateNpmPackage(packageName, signal);
   const resolvedVersion = version ?? metadata["dist-tags"].latest;
   const versionData = metadata.versions[resolvedVersion];
   if (!versionData) {
@@ -14387,317 +14761,1905 @@ async function runGhostInit(options2) {
   }
 }
 
-// src/profile/migrate.ts
-import { chmod, readdir as readdir2, rename as rename2, stat as stat2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import path5 from "path";
-function getLegacyConfigDir() {
-  const base = process.env.XDG_CONFIG_HOME || path5.join(homedir2(), ".config");
-  return path5.join(base, "ocx");
-}
-async function needsMigration() {
-  const legacyDir = getLegacyConfigDir();
-  const profilesDir = getProfilesDir();
-  try {
-    await stat2(legacyDir);
+// src/commands/ghost/opencode.ts
+import { renameSync, rmSync } from "fs";
+import { copyFile, mkdir as mkdir5, readdir as readdir5 } from "fs/promises";
+import path7 from "path";
+var {Glob: Glob3 } = globalThis.Bun;
+
+// src/utils/file-sync.ts
+import { existsSync as existsSync2, lstatSync, mkdirSync, readFileSync, rmdirSync, unlinkSync } from "fs";
+import { dirname as dirname5, join as join6, relative as relative4 } from "path";
+
+// ../../node_modules/.bun/chokidar@5.0.0/node_modules/chokidar/index.js
+import { EventEmitter } from "events";
+import { stat as statcb, Stats } from "fs";
+import { readdir as readdir3, stat as stat4 } from "fs/promises";
+import * as sp2 from "path";
+
+// ../../node_modules/.bun/readdirp@5.0.0/node_modules/readdirp/index.js
+import { lstat, readdir as readdir2, realpath, stat as stat2 } from "fs/promises";
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "path";
+import { Readable } from "stream";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === undefined)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+
+class ReaddirpStream extends Readable {
+  parents;
+  reading;
+  parent;
+  _stat;
+  _maxDepth;
+  _wantsDir;
+  _wantsFile;
+  _wantsEverything;
+  _root;
+  _isDirent;
+  _statsProp;
+  _rdOptions;
+  _fileFilter;
+  _directoryFilter;
+  constructor(options2 = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options2.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options2 };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat2;
+    if (wantBigintFsStats) {
+      this._stat = (path5) => statMethod(path5, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = undefined;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
     try {
-      await stat2(profilesDir);
-      return false;
-    } catch {
-      return true;
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path5, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path5));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
     }
-  } catch {
-    return false;
-  }
-}
-async function migrate(dryRun = false) {
-  const result = {
-    success: false,
-    migratedFiles: [],
-    backupPath: null,
-    errors: []
-  };
-  const legacyDir = getLegacyConfigDir();
-  const profilesDir = getProfilesDir();
-  try {
-    await stat2(legacyDir);
-  } catch {
-    result.errors.push(`No legacy config found at ${legacyDir}`);
-    return result;
-  }
-  try {
-    await stat2(profilesDir);
-    result.errors.push(`Profiles directory already exists at ${profilesDir}`);
-    return result;
-  } catch {}
-  const legacyFiles = await readdir2(legacyDir);
-  const filesToMigrate = legacyFiles.filter((f) => f === "ghost.jsonc" || f === "opencode.jsonc" || f === "AGENTS.md");
-  if (filesToMigrate.length === 0) {
-    result.errors.push("No migratable files found in legacy config");
-    return result;
-  }
-  if (dryRun) {
-    result.migratedFiles = filesToMigrate.map((f) => path5.join(legacyDir, f));
-    result.backupPath = `${legacyDir}.bak`;
-    result.success = true;
-    return result;
   }
-  const manager = ProfileManager.create();
-  await manager.initialize();
-  const defaultProfileDir = getProfileDir("default");
-  for (const file of filesToMigrate) {
-    const srcPath = path5.join(legacyDir, file);
-    const destPath = path5.join(defaultProfileDir, file);
-    await Bun.write(destPath, Bun.file(srcPath));
-    await chmod(destPath, 384);
-    result.migratedFiles.push(file);
-  }
-  const backupPath = `${legacyDir}.bak`;
-  await rename2(legacyDir, backupPath);
-  result.backupPath = backupPath;
-  result.success = true;
-  return result;
-}
-
-// src/commands/ghost/migrate.ts
-function registerGhostMigrateCommand(parent) {
-  parent.command("migrate").description("Migrate from legacy ~/.config/ocx/ to new profiles system").option("--dry-run", "Preview changes without making them").action(async (options2) => {
+  async _exploreDir(path5, depth) {
+    let files;
     try {
-      await runMigrate(options2);
+      files = await readdir2(path5, this._rdOptions);
     } catch (error) {
-      handleError(error);
+      this._onError(error);
     }
-  });
-}
-async function runMigrate(options2) {
-  const needsMigrationResult = await needsMigration();
-  if (!needsMigrationResult) {
-    const legacyDir = getLegacyConfigDir();
-    const profilesDir = getProfilesDir();
-    console.log("No migration needed.");
-    console.log(`  Legacy config: ${legacyDir} (not found)`);
-    console.log(`  Profiles: ${profilesDir}`);
-    return;
+    return { files, depth, path: path5 };
   }
-  if (options2.dryRun) {
-    console.log(`Dry run - no changes will be made.
-`);
-  }
-  const result = await migrate(options2.dryRun);
-  if (!result.success) {
-    console.error("Migration failed:");
-    for (const error of result.errors) {
-      console.error(`  - ${error}`);
-    }
-    process.exit(1);
-  }
-  if (options2.dryRun) {
-    console.log("Migration preview:");
-    console.log(`
-Files to migrate to default profile:`);
-    for (const file of result.migratedFiles) {
-      console.log(`  ${file}`);
-    }
-    console.log(`
-Legacy config will be renamed to:`);
-    console.log(`  ${result.backupPath}`);
-    console.log(`
-Run without --dry-run to perform migration.`);
-  } else {
-    console.log("Migration complete!");
-    console.log(`
-Migrated to default profile:`);
-    for (const file of result.migratedFiles) {
-      console.log(`  ${file}`);
+  async _formatEntry(dirent, path5) {
+    let entry;
+    const basename2 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path5, basename2));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename2 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
     }
-    console.log(`
-Legacy config backed up to:`);
-    console.log(`  ${result.backupPath}`);
-    console.log(`
-Profile location:`);
-    console.log(`  ${getProfileDir("default")}`);
+    return entry;
   }
-}
-
-// src/commands/ghost/opencode.ts
-import { renameSync, rmSync } from "fs";
-import { copyFile as copyFilePromise } from "fs/promises";
-import path8 from "path";
-
-// src/utils/opencode-discovery.ts
-import { exists } from "fs/promises";
-import { dirname as dirname3, join as join4 } from "path";
-var CONFIG_FILES = ["opencode.jsonc", "opencode.json"];
-var RULE_FILES = ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"];
-var CONFIG_DIRS = [".opencode"];
-async function findUp(target, start, stop) {
-  let current = start;
-  const result = [];
-  while (true) {
-    const search = join4(current, target);
-    if (await exists(search).catch(() => false)) {
-      result.push(search);
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
     }
-    if (stop === current)
-      break;
-    const parent = dirname3(current);
-    if (parent === current)
-      break;
-    current = parent;
   }
-  return result;
-}
-async function* up(options2) {
-  const { targets, start, stop } = options2;
-  let current = start;
-  while (true) {
-    for (const target of targets) {
-      const search = join4(current, target);
-      if (await exists(search).catch(() => false)) {
-        yield search;
-      }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
     }
-    if (stop === current)
-      break;
-    const parent = dirname3(current);
-    if (parent === current)
-      break;
-    current = parent;
-  }
-}
-async function discoverProjectFiles(start, stop) {
-  const excluded = new Set;
-  for (const file of CONFIG_FILES) {
-    const found = await findUp(file, start, stop);
-    for (const path6 of found) {
-      excluded.add(path6);
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
     }
   }
-  for (const file of RULE_FILES) {
-    const found = await findUp(file, start, stop);
-    for (const path6 of found) {
-      excluded.add(path6);
-    }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
   }
-  for await (const dir of up({ targets: CONFIG_DIRS, start, stop })) {
-    excluded.add(dir);
+}
+function readdirp(root, options2 = {}) {
+  let type = options2.entryType || options2.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options2.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
   }
-  return excluded;
+  options2.root = root;
+  return new ReaddirpStream(options2);
 }
 
-// src/utils/symlink-farm.ts
-import { randomBytes } from "crypto";
-import { mkdir as mkdir4, readdir as readdir3, rename as rename3, rm as rm2, stat as stat3, symlink as symlink2 } from "fs/promises";
-import { tmpdir } from "os";
-import { dirname as dirname4, isAbsolute, join as join5, relative as relative2 } from "path";
-
-// src/utils/pattern-filter.ts
-import path6 from "path";
-var {Glob: Glob2 } = globalThis.Bun;
-function normalizeForMatching(absolutePath, projectRoot) {
-  const relativePath = path6.relative(projectRoot, absolutePath);
-  return relativePath.split(path6.sep).join("/").replace(/^\.\//, "");
-}
-class PathMatcher {
-  includeGlobs;
-  excludeGlobs;
-  includePatterns;
-  constructor(includePatterns = [], excludePatterns = []) {
-    this.includePatterns = includePatterns;
-    this.includeGlobs = includePatterns.map((p) => ({ pattern: p, glob: new Glob2(p) }));
-    this.excludeGlobs = excludePatterns.map((p) => ({ pattern: p, glob: new Glob2(p) }));
-  }
-  getDisposition(relativePath) {
-    if (this.excludeGlobs.some((g) => g.glob.match(relativePath))) {
-      return { type: "excluded" };
-    }
-    if (this.includeGlobs.some((g) => g.glob.match(relativePath))) {
-      return { type: "included" };
-    }
-    const patternsInsideDir = this.includePatterns.filter((pattern) => {
-      if (pattern.startsWith(`${relativePath}/`))
-        return true;
-      if (pattern.startsWith("**/"))
-        return true;
-      return false;
-    });
-    if (patternsInsideDir.length > 0) {
-      return { type: "partial", patterns: patternsInsideDir };
-    }
-    if (this.includePatterns.length > 0) {
-      return { type: "excluded" };
-    }
-    return { type: "included" };
-  }
-  targetsInside(dirPath) {
-    const normalizedDir = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
-    return this.includePatterns.some((p) => p.startsWith(normalizedDir));
+// ../../node_modules/.bun/chokidar@5.0.0/node_modules/chokidar/handler.js
+import { watch as fs_watch, unwatchFile, watchFile } from "fs";
+import { realpath as fsrealpath, lstat as lstat2, open, stat as stat3 } from "fs/promises";
+import { type as osType } from "os";
+import * as sp from "path";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat3 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
   }
-  getInnerPatterns(dirPath) {
-    const normalizedDir = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
-    return this.includePatterns.filter((p) => p.startsWith(normalizedDir));
+};
+var addAndConvert = (main2, prop, item) => {
+  let container = main2[prop];
+  if (!(container instanceof Set)) {
+    main2[prop] = container = new Set([container]);
   }
-  hasIncludePatterns() {
-    return this.includePatterns.length > 0;
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
   }
-}
-function createPathMatcher(includePatterns = [], excludePatterns = []) {
-  return new PathMatcher(includePatterns, excludePatterns);
-}
-
-// src/utils/symlink-farm.ts
-var STALE_SESSION_THRESHOLD_MS = 24 * 60 * 60 * 1000;
-var REMOVING_THRESHOLD_MS = 60 * 60 * 1000;
-var GHOST_DIR_PREFIX = "ocx-ghost-";
-var REMOVING_SUFFIX = "-removing";
-var GHOST_MARKER_FILE = ".ocx-ghost-marker";
-async function createSymlinkFarm(sourceDir, excludePaths, options2) {
-  if (!isAbsolute(sourceDir)) {
-    throw new Error(`sourceDir must be an absolute path, got: ${sourceDir}`);
+};
+var delFromSet = (main2, prop, item) => {
+  const container = main2[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main2[prop];
   }
-  const suffix = randomBytes(4).toString("hex");
-  const tempDir = join5(tmpdir(), `${GHOST_DIR_PREFIX}${suffix}`);
-  await Bun.write(join5(tempDir, GHOST_MARKER_FILE), "");
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = new Map;
+function createFsWatchInstance(path5, options2, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path5);
+    emitRaw(rawEvent, evPath, { watchedPath: path5 });
+    if (evPath && path5 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path5, evPath), KEY_LISTENERS, sp.join(path5, evPath));
+    }
+  };
   try {
-    const matcher = createPathMatcher(options2?.includePatterns ?? [], options2?.excludePatterns ?? []);
-    const plan = await computeSymlinkPlan(sourceDir, sourceDir, excludePaths, matcher);
-    await executeSymlinkPlan(plan, sourceDir, tempDir);
-    return tempDir;
+    return fs_watch(path5, {
+      persistent: options2.persistent
+    }, handleEvent);
   } catch (error) {
-    await rm2(tempDir, { recursive: true, force: true }).catch(() => {});
-    throw error;
+    errHandler(error);
+    return;
   }
 }
-async function injectGhostFiles(tempDir, sourceDir, injectPaths) {
-  if (!isAbsolute(tempDir)) {
-    throw new Error(`tempDir must be an absolute path, got: ${tempDir}`);
-  }
-  if (!isAbsolute(sourceDir)) {
-    throw new Error(`sourceDir must be an absolute path, got: ${sourceDir}`);
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path5, fullPath, options2, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options2.persistent) {
+    watcher = createFsWatchInstance(path5, options2, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
   }
-  for (const injectPath of injectPaths) {
-    const relativePath = relative2(sourceDir, injectPath);
-    if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-      throw new Error(`injectPath must be within sourceDir: ${injectPath}`);
-    }
-    const targetPath = join5(tempDir, relativePath);
-    const parentDir = dirname4(targetPath);
-    if (parentDir !== tempDir) {
-      await mkdir4(parentDir, { recursive: true });
-    }
-    try {
-      await symlink2(injectPath, targetPath);
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(path5, options2, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path5, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {}
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = new Map;
+var setFsWatchFileListener = (path5, fullPath, options2, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options2.persistent || copts.interval > options2.interval)) {
+    unwatchFile(fullPath);
+    cont = undefined;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options: options2,
+      watcher: watchFile(fullPath, options2, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path5, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+
+class NodeFsHandler {
+  fsw;
+  _boundHandleError;
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  _watchWithNodeFs(path5, listener) {
+    const opts = this.fsw.options;
+    const directory = sp.dirname(path5);
+    const basename3 = sp.basename(path5);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename3);
+    const absolutePath = sp.resolve(path5);
+    const options2 = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options2.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path5, absolutePath, options2, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path5, absolutePath, options2, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname4 = sp.dirname(file);
+    const basename3 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname4);
+    let prevStats = stats;
+    if (parent.has(basename3))
+      return;
+    const listener = async (path5, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat3(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path5);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path5, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname4, basename3);
+        }
+      } else if (parent.has(basename3)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  async _handleSymlink(entry, directory, path5, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path5);
+      } catch (e3) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path5, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path5, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sp.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1000);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = new Set;
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      const item = entry.path;
+      let path5 = sp.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path5, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path5 = sp.join(dir, sp.relative(dir, path5));
+        this._addToNodeFs(path5, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve3, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = undefined;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve3(undefined);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = undefined;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir.has(sp.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sp.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  async _addToNodeFs(path5, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path5) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path5);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sp.resolve(path5);
+        const targetPath = follow ? await fsrealpath(path5) : path5;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path5) : path5;
+        if (this.fsw.closed)
+          return;
+        const parent = sp.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path5, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(sp.resolve(path5), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path5, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path5;
+      }
+    }
+  }
+}
+
+// ../../node_modules/.bun/chokidar@5.0.0/node_modules/chokidar/index.js
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//g;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative4 = sp2.relative(matcher.path, string);
+        if (!relative4) {
+          return false;
+        }
+        return !relative4.startsWith("..") && !sp2.isAbsolute(relative4);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path5) {
+  if (typeof path5 !== "string")
+    throw new Error("string expected");
+  path5 = sp2.normalize(path5);
+  path5 = path5.replace(/\\/g, "/");
+  let prepend = false;
+  if (path5.startsWith("//"))
+    prepend = true;
+  path5 = path5.replace(DOUBLE_SLASH_RE, "/");
+  if (prepend)
+    path5 = "/" + path5;
+  return path5;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path5 = normalizePath(testString);
+  for (let index = 0;index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path5, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path5) => toUnix(sp2.normalize(toUnix(path5)));
+var normalizeIgnored = (cwd = "") => (path5) => {
+  if (typeof path5 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path5) ? path5 : sp2.join(cwd, path5));
+  } else {
+    return path5;
+  }
+};
+var getAbsolutePath = (path5, cwd) => {
+  if (sp2.isAbsolute(path5)) {
+    return path5;
+  }
+  return sp2.join(cwd, path5);
+};
+var EMPTY_SET = Object.freeze(new Set);
+
+class DirEntry {
+  path;
+  _removeWatcher;
+  items;
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = new Set;
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir3(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+}
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+
+class WatchHelper {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
+  constructor(path5, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path5;
+    this.path = path5 = path5.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sp2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+}
+
+class FSWatcher extends EventEmitter {
+  closed;
+  options;
+  _closers;
+  _ignoredPaths;
+  _throttled;
+  _streams;
+  _symlinkPaths;
+  _watched;
+  _pendingWrites;
+  _pendingUnlinks;
+  _readyCount;
+  _emitReady;
+  _closePromise;
+  _userIgnored;
+  _readyEmitted;
+  _emitRaw;
+  _boundRemove;
+  _nodeFsHandler;
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = new Map;
+    this._ignoredPaths = new Set;
+    this._throttled = new Map;
+    this._streams = new Set;
+    this._symlinkPaths = new Map;
+    this._watched = new Map;
+    this._pendingWrites = new Map;
+    this._pendingUnlinks = new Map;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+    const opts = {
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      atomic: true,
+      ..._opts,
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === undefined)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== undefined) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = undefined;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path5) => {
+        const absPath = getAbsolutePath(path5, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path5) => {
+      this._removeIgnoredPath(path5);
+    });
+    this._userIgnored = undefined;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path5) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path5, !_internal, undefined, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path5) => {
+      if (!sp2.isAbsolute(path5) && !this._closers.has(path5)) {
+        if (cwd)
+          path5 = sp2.join(cwd, path5);
+        path5 = sp2.resolve(path5);
+      }
+      this._closePath(path5);
+      this._addIgnoredPath(path5);
+      if (this._watched.has(path5)) {
+        this._addIgnoredPath({
+          path: path5,
+          recursive: true
+        });
+      }
+      this._userIgnored = undefined;
+    });
+    return this;
+  }
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = undefined;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => {
+      return;
+    }) : Promise.resolve();
+    return this._closePromise;
+  }
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  async _emit(event, path5, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path5 = sp2.normalize(path5);
+    if (opts.cwd)
+      path5 = sp2.relative(opts.cwd, path5);
+    const args = [path5];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path5))) {
+      pw.lastChange = new Date;
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path5, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path6) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path6);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path5)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path5);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path5, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path5, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path5) : path5;
+      let stats2;
+      try {
+        stats2 = await stat4(fullPath);
+      } catch (err) {}
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  _throttle(actionType, path5, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, new Map);
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path5);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path5);
+      const count = item ? item.count : 0;
+      action.delete(path5);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path5, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  _awaitWriteFinish(path5, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path5;
+    if (this.options.cwd && !sp2.isAbsolute(path5)) {
+      fullPath = sp2.join(this.options.cwd, path5);
+    }
+    const now = new Date;
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path5)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(new Date);
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path5).lastChange = now2;
+        }
+        const pw = writes.get(path5);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path5);
+          awfEmit(undefined, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path5)) {
+      writes.set(path5, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path5);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  _isIgnored(path5, stats) {
+    if (this.options.atomic && DOT_RE.test(path5))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, undefined);
+    }
+    return this._userIgnored(path5, stats);
+  }
+  _isntIgnored(path5, stat5) {
+    return !this._isIgnored(path5, stat5);
+  }
+  _getWatchHelpers(path5) {
+    return new WatchHelper(path5, this.options.followSymlinks, this);
+  }
+  _getWatchedDir(directory) {
+    const dir = sp2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  _remove(directory, item, isDirectory) {
+    const path5 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path5);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path5) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path5, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path5);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path5, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path5;
+    if (this.options.cwd)
+      relPath = sp2.relative(this.options.cwd, path5);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path5);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path5))
+      this._emit(eventName, path5);
+    this._closePath(path5);
+  }
+  _closePath(path5) {
+    this._closeFile(path5);
+    const dir = sp2.dirname(path5);
+    this._getWatchedDir(dir).remove(sp2.basename(path5));
+  }
+  _closeFile(path5) {
+    const closers = this._closers.get(path5);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path5);
+  }
+  _addPathCloser(path5, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path5);
+    if (!list) {
+      list = [];
+      this._closers.set(path5, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options2 = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options2);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = undefined;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = undefined;
+      }
+    });
+    return stream;
+  }
+}
+function watch(paths, options2 = {}) {
+  const watcher = new FSWatcher(options2);
+  watcher.add(paths);
+  return watcher;
+}
+var chokidar_default = { watch, FSWatcher };
+
+// src/utils/file-sync.ts
+var import_ignore = __toESM(require_ignore(), 1);
+var OS_JUNK = [/\.DS_Store$/, /Thumbs\.db$/];
+function loadGitignore(projectDir) {
+  const ig = import_ignore.default();
+  const gitignorePath = join6(projectDir, ".gitignore");
+  try {
+    if (existsSync2(gitignorePath)) {
+      ig.add(readFileSync(gitignorePath, "utf8"));
+    }
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.warn(`Warning: Could not read .gitignore: ${err.message}`);
+    }
+  }
+  return ig;
+}
+function normalizePath2(p) {
+  return p.replace(/\\/g, "/").replace(/\/$/, "");
+}
+function isSymlink(filePath) {
+  try {
+    return lstatSync(filePath).isSymbolicLink();
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return false;
+    throw err;
+  }
+}
+function isExcluded(relativePath, gitignore) {
+  if (!relativePath)
+    return false;
+  if (OS_JUNK.some((p) => p.test(relativePath)))
+    return true;
+  if (gitignore.ignores(relativePath))
+    return true;
+  return false;
+}
+async function syncFile(src, dest) {
+  mkdirSync(dirname5(dest), { recursive: true });
+  await Bun.write(dest, Bun.file(src));
+}
+function syncDelete(dest) {
+  try {
+    unlinkSync(dest);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+  }
+}
+function createFileSync(tempDir, projectDir, options2) {
+  const failures = [];
+  const syncedFiles = new Set;
+  const gitignore = loadGitignore(projectDir);
+  const isCI2 = process.env.CI === "true";
+  const watcher = chokidar_default.watch(tempDir, {
+    followSymlinks: false,
+    ignoreInitial: true,
+    usePolling: isCI2,
+    interval: 100,
+    awaitWriteFinish: {
+      stabilityThreshold: 200,
+      pollInterval: 50
+    },
+    ignored: (filePath) => isExcluded(relative4(tempDir, filePath), gitignore)
+  });
+  watcher.on("error", (err) => {
+    failures.push({ path: "<watcher>", error: err });
+  });
+  const handleAdd = async (filePath) => {
+    if (isSymlink(filePath))
+      return;
+    const relativePath = relative4(tempDir, filePath);
+    const normalizedPath = normalizePath2(relativePath);
+    if (options2?.overlayFiles?.has(normalizedPath))
+      return;
+    const destPath = join6(projectDir, relativePath);
+    try {
+      await syncFile(filePath, destPath);
+      syncedFiles.add(normalizedPath);
+    } catch (err) {
+      failures.push({ path: relativePath, error: err });
+    }
+  };
+  const handleChange = async (filePath) => {
+    if (isSymlink(filePath))
+      return;
+    const relativePath = relative4(tempDir, filePath);
+    const normalizedPath = normalizePath2(relativePath);
+    if (options2?.overlayFiles?.has(normalizedPath))
+      return;
+    const destPath = join6(projectDir, relativePath);
+    try {
+      await syncFile(filePath, destPath);
+    } catch (err) {
+      failures.push({ path: relativePath, error: err });
+    }
+  };
+  const handleUnlink = async (filePath) => {
+    const relativePath = relative4(tempDir, filePath);
+    const normalizedPath = normalizePath2(relativePath);
+    if (!syncedFiles.has(normalizedPath))
+      return;
+    const destPath = join6(projectDir, relativePath);
+    try {
+      syncDelete(destPath);
+      syncedFiles.delete(normalizedPath);
+    } catch (err) {
+      failures.push({ path: relativePath, error: err });
+    }
+  };
+  const handleAddDir = (dirPath) => {
+    if (isSymlink(dirPath))
+      return;
+    const relativePath = relative4(tempDir, dirPath);
+    try {
+      mkdirSync(join6(projectDir, relativePath), { recursive: true });
     } catch (err) {
       if (err.code !== "EEXIST") {
-        throw new Error(`Failed to inject ${injectPath} \u2192 ${targetPath}: ${err.message}`);
+        failures.push({ path: relativePath, error: err });
+      }
+    }
+  };
+  const handleUnlinkDir = (dirPath) => {
+    const relativePath = relative4(tempDir, dirPath);
+    const destPath = join6(projectDir, relativePath);
+    try {
+      rmdirSync(destPath);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT" && code !== "ENOTEMPTY") {
+        failures.push({ path: relativePath, error: err });
+      }
+    }
+  };
+  watcher.on("add", handleAdd);
+  watcher.on("change", handleChange);
+  watcher.on("unlink", handleUnlink);
+  watcher.on("addDir", handleAddDir);
+  watcher.on("unlinkDir", handleUnlinkDir);
+  return {
+    close: async () => {
+      await watcher.close();
+    },
+    getFailures: () => [...failures],
+    getSyncCount: () => syncedFiles.size
+  };
+}
+
+// src/utils/symlink-farm.ts
+import { randomBytes } from "crypto";
+import { mkdir as mkdir4, readdir as readdir4, rename as rename2, rm as rm2, stat as stat5, symlink as symlink2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join7, relative as relative5 } from "path";
+
+// src/utils/pattern-filter.ts
+import path5 from "path";
+var {Glob: Glob2 } = globalThis.Bun;
+function normalizeForMatching(absolutePath, projectRoot) {
+  const relativePath = path5.relative(projectRoot, absolutePath);
+  return relativePath.split(path5.sep).join("/").replace(/^\.\//, "");
+}
+class PathMatcher {
+  includeGlobs;
+  excludeGlobs;
+  includePatterns;
+  excludePatterns;
+  constructor(includePatterns = [], excludePatterns = []) {
+    this.includePatterns = includePatterns;
+    this.excludePatterns = excludePatterns;
+    this.includeGlobs = includePatterns.map((p) => ({ pattern: p, glob: new Glob2(p) }));
+    this.excludeGlobs = excludePatterns.map((p) => ({ pattern: p, glob: new Glob2(p) }));
+  }
+  getDisposition(relativePath) {
+    const matchesExclude = this.excludeGlobs.some((g) => g.glob.match(relativePath));
+    const matchesInclude = this.includeGlobs.some((g) => g.glob.match(relativePath));
+    if (this.includePatterns.length > 0 && this.excludePatterns.length > 0) {
+      if (matchesInclude) {
+        return { type: "included" };
+      }
+      if (matchesExclude) {
+        return { type: "excluded" };
+      }
+      const hasIncludesInside = this.includePatterns.some((pattern) => {
+        if (pattern.startsWith(`${relativePath}/`))
+          return true;
+        if (pattern.startsWith("**/"))
+          return true;
+        return false;
+      });
+      const hasExcludesInside2 = this.excludePatterns.some((pattern) => {
+        if (pattern.startsWith(`${relativePath}/`))
+          return true;
+        if (pattern.startsWith("**/"))
+          return true;
+        return false;
+      });
+      if (hasIncludesInside || hasExcludesInside2) {
+        return { type: "partial", patterns: this.includePatterns };
       }
+      return { type: "included" };
+    }
+    if (this.includePatterns.length > 0) {
+      if (matchesInclude) {
+        return { type: "included" };
+      }
+      const hasIncludesInside = this.includePatterns.some((pattern) => {
+        if (pattern.startsWith(`${relativePath}/`))
+          return true;
+        if (pattern.startsWith("**/"))
+          return true;
+        return false;
+      });
+      if (hasIncludesInside) {
+        return { type: "partial", patterns: this.includePatterns };
+      }
+      return { type: "excluded" };
+    }
+    if (matchesExclude) {
+      return { type: "excluded" };
+    }
+    const hasExcludesInside = this.excludePatterns.some((pattern) => {
+      if (pattern.startsWith(`${relativePath}/`))
+        return true;
+      if (pattern.startsWith("**/"))
+        return true;
+      return false;
+    });
+    if (hasExcludesInside) {
+      return { type: "partial", patterns: [] };
     }
+    return { type: "included" };
+  }
+  targetsInside(dirPath) {
+    const normalizedDir = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
+    return this.includePatterns.some((p) => p.startsWith(normalizedDir));
+  }
+  getInnerPatterns(dirPath) {
+    const normalizedDir = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
+    return this.includePatterns.filter((p) => p.startsWith(normalizedDir));
+  }
+  hasIncludePatterns() {
+    return this.includePatterns.length > 0;
+  }
+}
+function createPathMatcher(includePatterns = [], excludePatterns = []) {
+  return new PathMatcher(includePatterns, excludePatterns);
+}
+
+// src/utils/symlink-farm.ts
+var STALE_SESSION_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+var REMOVING_THRESHOLD_MS = 60 * 60 * 1000;
+var GHOST_DIR_PREFIX = "ocx-ghost-";
+var REMOVING_SUFFIX = "-removing";
+var GHOST_MARKER_FILE = ".ocx-ghost-marker";
+async function createSymlinkFarm(sourceDir, options2) {
+  if (!isAbsolute2(sourceDir)) {
+    throw new Error(`sourceDir must be an absolute path, got: ${sourceDir}`);
+  }
+  const suffix = randomBytes(4).toString("hex");
+  const tempDir = join7(tmpdir(), `${GHOST_DIR_PREFIX}${suffix}`);
+  await Bun.write(join7(tempDir, GHOST_MARKER_FILE), "");
+  try {
+    const matcher = createPathMatcher(options2?.includePatterns ?? [], options2?.excludePatterns ?? []);
+    const plan = await computeSymlinkPlan(sourceDir, sourceDir, matcher);
+    await executeSymlinkPlan(plan, sourceDir, tempDir);
+    return tempDir;
+  } catch (error) {
+    await rm2(tempDir, { recursive: true, force: true }).catch(() => {});
+    throw error;
   }
 }
 async function cleanupSymlinkFarm(tempDir) {
   const removingPath = `${tempDir}${REMOVING_SUFFIX}`;
   try {
-    await rename3(tempDir, removingPath);
+    await rename2(tempDir, removingPath);
   } catch {
     return;
   }
@@ -14705,24 +16667,24 @@ async function cleanupSymlinkFarm(tempDir) {
 }
 async function cleanupOrphanedGhostDirs(tempBase = tmpdir()) {
   let cleanedCount = 0;
-  if (!isAbsolute(tempBase)) {
+  if (!isAbsolute2(tempBase)) {
     throw new Error(`tempBase must be an absolute path, got: ${tempBase}`);
   }
   let dirNames;
   try {
-    dirNames = await readdir3(tempBase);
+    dirNames = await readdir4(tempBase);
   } catch {
     return 0;
   }
   for (const dirName of dirNames) {
-    const dirPath = join5(tempBase, dirName);
+    const dirPath = join7(tempBase, dirName);
     const isRemovingDir = dirName.endsWith(REMOVING_SUFFIX);
     const isGhostDir = dirName.startsWith(GHOST_DIR_PREFIX) && !isRemovingDir;
     if (!isRemovingDir && !isGhostDir)
       continue;
     let stats;
     try {
-      stats = await stat3(dirPath);
+      stats = await stat5(dirPath);
     } catch {
       continue;
     }
@@ -14735,7 +16697,7 @@ async function cleanupOrphanedGhostDirs(tempBase = tmpdir()) {
     try {
       if (isGhostDir) {
         const removingPath = `${dirPath}${REMOVING_SUFFIX}`;
-        await rename3(dirPath, removingPath);
+        await rename2(dirPath, removingPath);
         await rm2(removingPath, { recursive: true, force: true });
       } else {
         await rm2(dirPath, { recursive: true, force: true });
@@ -14745,21 +16707,8 @@ async function cleanupOrphanedGhostDirs(tempBase = tmpdir()) {
   }
   return cleanedCount;
 }
-async function handleExcludedEntry(isDirectory, disposition, computeNestedPlan) {
-  if (disposition.type === "excluded") {
-    return { action: "skip" };
-  }
-  if (disposition.type === "included") {
-    return { action: "includeWhole" };
-  }
-  if (isDirectory) {
-    const nestedPlan = await computeNestedPlan();
-    return { action: "partial", nestedPlan };
-  }
-  return { action: "skip" };
-}
-async function computeSymlinkPlan(sourceDir, projectRoot, excludedPaths, matcher, insideExcludedTree = false) {
-  if (!isAbsolute(sourceDir)) {
+async function computeSymlinkPlan(sourceDir, projectRoot, matcher) {
+  if (!isAbsolute2(sourceDir)) {
     throw new Error(`sourceDir must be an absolute path, got: ${sourceDir}`);
   }
   const plan = {
@@ -14767,49 +16716,25 @@ async function computeSymlinkPlan(sourceDir, projectRoot, excludedPaths, matcher
     files: [],
     partialDirs: new Map
   };
-  const entries = await readdir3(sourceDir, { withFileTypes: true });
+  const entries = await readdir4(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join5(sourceDir, entry.name);
+    const sourcePath = join7(sourceDir, entry.name);
     const relativePath = normalizeForMatching(sourcePath, projectRoot);
-    if (insideExcludedTree) {
-      const disposition = matcher.getDisposition(relativePath);
-      const result = await handleExcludedEntry(entry.isDirectory(), disposition, () => computeSymlinkPlan(sourcePath, projectRoot, excludedPaths, matcher, true));
-      if (result.action === "skip") {
-        continue;
-      }
-      if (result.action === "includeWhole") {
-        if (entry.isDirectory()) {
-          plan.wholeDirs.push(entry.name);
-        } else {
-          plan.files.push(entry.name);
-        }
-        continue;
-      }
-      plan.partialDirs.set(entry.name, result.nestedPlan);
+    const disposition = matcher.getDisposition(relativePath);
+    if (disposition.type === "excluded") {
       continue;
     }
-    if (excludedPaths.has(sourcePath)) {
-      if (!matcher.hasIncludePatterns()) {
-        continue;
-      }
-      const disposition = matcher.getDisposition(relativePath);
-      const result = await handleExcludedEntry(entry.isDirectory(), disposition, () => computeSymlinkPlan(sourcePath, projectRoot, excludedPaths, matcher, true));
-      if (result.action === "skip") {
-        continue;
-      }
-      if (result.action === "includeWhole") {
-        if (entry.isDirectory()) {
-          plan.wholeDirs.push(entry.name);
-        } else {
-          plan.files.push(entry.name);
-        }
-        continue;
+    if (disposition.type === "included") {
+      if (entry.isDirectory()) {
+        plan.wholeDirs.push(entry.name);
+      } else {
+        plan.files.push(entry.name);
       }
-      plan.partialDirs.set(entry.name, result.nestedPlan);
       continue;
     }
     if (entry.isDirectory()) {
-      plan.wholeDirs.push(entry.name);
+      const nestedPlan = await computeSymlinkPlan(sourcePath, projectRoot, matcher);
+      plan.partialDirs.set(entry.name, nestedPlan);
     } else {
       plan.files.push(entry.name);
     }
@@ -14817,33 +16742,34 @@ async function computeSymlinkPlan(sourceDir, projectRoot, excludedPaths, matcher
   return plan;
 }
 async function executeSymlinkPlan(plan, sourceRoot, targetRoot) {
-  if (!isAbsolute(sourceRoot)) {
+  if (!isAbsolute2(sourceRoot)) {
     throw new Error(`sourceRoot must be an absolute path, got: ${sourceRoot}`);
   }
-  if (!isAbsolute(targetRoot)) {
+  if (!isAbsolute2(targetRoot)) {
     throw new Error(`targetRoot must be an absolute path, got: ${targetRoot}`);
   }
   for (const dirName of plan.wholeDirs) {
-    const sourcePath = join5(sourceRoot, dirName);
-    const targetPath = join5(targetRoot, dirName);
+    const sourcePath = join7(sourceRoot, dirName);
+    const targetPath = join7(targetRoot, dirName);
     await symlink2(sourcePath, targetPath);
   }
   for (const fileName of plan.files) {
-    const sourcePath = join5(sourceRoot, fileName);
-    const targetPath = join5(targetRoot, fileName);
+    const sourcePath = join7(sourceRoot, fileName);
+    const targetPath = join7(targetRoot, fileName);
     await symlink2(sourcePath, targetPath);
   }
   for (const [dirName, nestedPlan] of plan.partialDirs) {
-    const sourcePath = join5(sourceRoot, dirName);
-    const targetPath = join5(targetRoot, dirName);
+    const sourcePath = join7(sourceRoot, dirName);
+    const targetPath = join7(targetRoot, dirName);
     await mkdir4(targetPath, { recursive: true });
     await executeSymlinkPlan(nestedPlan, sourcePath, targetPath);
   }
 }
 
 // src/utils/terminal-title.ts
-import path7 from "path";
+import path6 from "path";
 var MAX_BRANCH_LENGTH = 20;
+var titleSaved = false;
 function isInsideTmux() {
   return Boolean(process.env.TMUX);
 }
@@ -14864,8 +16790,27 @@ function setTerminalName(name) {
   setTmuxWindowName(name);
   setTerminalTitle(name);
 }
+function saveTerminalTitle() {
+  if (titleSaved || !isTTY) {
+    return;
+  }
+  process.stdout.write("\x1B[22;2t");
+  titleSaved = true;
+}
+function restoreTerminalTitle() {
+  if (!titleSaved) {
+    return;
+  }
+  if (isInsideTmux()) {
+    Bun.spawnSync(["tmux", "set-window-option", "automatic-rename", "on"]);
+  }
+  if (isTTY) {
+    process.stdout.write("\x1B[23;2t");
+  }
+  titleSaved = false;
+}
 function formatTerminalName(cwd, profileName, gitInfo) {
-  const repoName = gitInfo.repoName ?? path7.basename(cwd);
+  const repoName = gitInfo.repoName ?? path6.basename(cwd);
   if (!gitInfo.branch) {
     return `ghost[${profileName}]:${repoName}`;
   }
@@ -14875,7 +16820,7 @@ function formatTerminalName(cwd, profileName, gitInfo) {
 
 // src/commands/ghost/opencode.ts
 function registerGhostOpenCodeCommand(parent) {
-  parent.command("opencode").description("Launch OpenCode with ghost mode configuration").option("-p, --profile <name>", "Use specific profile").addOption(sharedOptions.json()).addOption(sharedOptions.quiet()).allowUnknownOption().allowExcessArguments(true).action(async (options2, command) => {
+  parent.command("opencode").description("Launch OpenCode with ghost mode configuration").option("-p, --profile <name>", "Use specific profile").option("--no-rename", "Disable terminal/tmux window renaming").addOption(sharedOptions.json()).addOption(sharedOptions.quiet()).allowUnknownOption().allowExcessArguments(true).action(async (options2, command) => {
     try {
       const args = command.args;
       await runGhostOpenCode(args, options2);
@@ -14889,11 +16834,6 @@ async function runGhostOpenCode(args, options2) {
   if (!await manager.isInitialized()) {
     throw new ProfilesNotInitializedError;
   }
-  if (!options2.quiet && await needsMigration()) {
-    console.log("Notice: Found legacy config at ~/.config/ocx/");
-    console.log(`Run 'ocx ghost migrate' to upgrade to the new profiles system.
-`);
-  }
   await cleanupOrphanedGhostDirs();
   const profileName = await manager.getCurrent(options2.profile);
   const profile = await manager.get(profileName);
@@ -14906,28 +16846,29 @@ async function runGhostOpenCode(args, options2) {
   }
   const cwd = process.cwd();
   const gitContext = await detectGitRepo(cwd);
-  const gitRoot = gitContext?.workTree ?? cwd;
-  const discoveredPaths = await discoverProjectFiles(cwd, gitRoot);
   const ghostConfig = profile.ghost;
-  const tempDir = await createSymlinkFarm(cwd, discoveredPaths, {
+  const tempDir = await createSymlinkFarm(cwd, {
     includePatterns: ghostConfig.include,
     excludePatterns: ghostConfig.exclude
   });
-  const ghostFiles = await discoverProjectFiles(profileDir, profileDir);
-  await injectGhostFiles(tempDir, profileDir, ghostFiles);
-  if (profile.hasAgents) {
-    const agentsPath = getProfileAgents(profileName);
-    const destAgentsPath = path8.join(tempDir, "AGENTS.md");
-    await copyFilePromise(agentsPath, destAgentsPath);
-  }
+  const overlayFiles = await injectProfileOverlay(tempDir, profileDir, ghostConfig.include);
   let cleanupDone = false;
+  let fileSync;
+  fileSync = createFileSync(tempDir, cwd, { overlayFiles });
   const performCleanup = async () => {
     if (cleanupDone)
       return;
     cleanupDone = true;
     await cleanupSymlinkFarm(tempDir);
   };
+  const shouldRename = options2.rename !== false && ghostConfig.renameWindow !== false;
   const exitHandler = () => {
+    if (shouldRename) {
+      restoreTerminalTitle();
+    }
+    if (fileSync) {
+      fileSync.close().catch(() => {});
+    }
     if (!cleanupDone && tempDir) {
       try {
         const removingPath = `${tempDir}${REMOVING_SUFFIX}`;
@@ -14942,8 +16883,11 @@ async function runGhostOpenCode(args, options2) {
   const sigtermHandler = () => proc?.kill("SIGTERM");
   process.on("SIGINT", sigintHandler);
   process.on("SIGTERM", sigtermHandler);
-  const gitInfo = await getGitInfo(cwd);
-  setTerminalName(formatTerminalName(cwd, profileName, gitInfo));
+  if (shouldRename) {
+    saveTerminalTitle();
+    const gitInfo = await getGitInfo(cwd);
+    setTerminalName(formatTerminalName(cwd, profileName, gitInfo));
+  }
   proc = Bun.spawn({
     cmd: ["opencode", ...args],
     cwd: tempDir,
@@ -14963,14 +16907,62 @@ async function runGhostOpenCode(args, options2) {
   });
   try {
     const exitCode = await proc.exited;
+    process.off("SIGINT", sigintHandler);
+    process.off("SIGTERM", sigtermHandler);
+    process.off("exit", exitHandler);
+    if (fileSync) {
+      await fileSync.close();
+      const syncCount = fileSync.getSyncCount();
+      const failures = fileSync.getFailures();
+      if (syncCount > 0 && !options2.quiet) {
+        logger.info(`Synced ${syncCount} new files to project`);
+      }
+      if (failures.length > 0) {
+        logger.warn(`${failures.length} files failed to sync`);
+        for (const f of failures) {
+          logger.debug(`  ${f.path}: ${f.error.message}`);
+        }
+      }
+    }
+    await performCleanup();
     process.exit(exitCode);
-  } finally {
+  } catch (error) {
     process.off("SIGINT", sigintHandler);
     process.off("SIGTERM", sigtermHandler);
     process.off("exit", exitHandler);
+    if (fileSync) {
+      await fileSync.close();
+    }
     await performCleanup();
+    throw error;
   }
 }
+function userExplicitlyIncluded(relativePath, compiledPatterns) {
+  if (compiledPatterns.length === 0)
+    return false;
+  return compiledPatterns.some((glob) => glob.match(relativePath));
+}
+async function injectProfileOverlay(tempDir, profileDir, includePatterns) {
+  const entries = await readdir5(profileDir, { withFileTypes: true, recursive: true });
+  const injectedFiles = new Set;
+  const compiledIncludePatterns = includePatterns.map((p) => new Glob3(p));
+  for (const entry of entries) {
+    const relativePath = path7.relative(profileDir, path7.join(entry.parentPath, entry.name));
+    if (relativePath === "ghost.jsonc")
+      continue;
+    if (relativePath === ".gitignore")
+      continue;
+    if (userExplicitlyIncluded(relativePath, compiledIncludePatterns))
+      continue;
+    if (entry.isDirectory())
+      continue;
+    const destPath = path7.join(tempDir, relativePath);
+    await mkdir5(path7.dirname(destPath), { recursive: true });
+    await copyFile(path7.join(entry.parentPath, entry.name), destPath);
+    injectedFiles.add(normalizePath2(relativePath));
+  }
+  return new Set(injectedFiles);
+}
 
 // src/commands/ghost/profile/add.ts
 function registerProfileAddCommand(parent) {
@@ -15506,13 +17498,12 @@ function registerGhostCommand(program2) {
   registerGhostSearchCommand(ghost);
   registerGhostOpenCodeCommand(ghost);
   registerGhostProfileCommand(ghost);
-  registerGhostMigrateCommand(ghost);
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync2 } from "fs";
-import { cp, mkdir as mkdir5, readdir as readdir4, readFile, rm as rm3, writeFile as writeFile2 } from "fs/promises";
-import { join as join6 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { cp, mkdir as mkdir6, readdir as readdir6, readFile, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import { join as join8 } from "path";
 var TEMPLATE_REPO = "kdcokenny/ocx";
 var TEMPLATE_PATH = "examples/registry-starter";
 function registerInitCommand(program2) {
@@ -15530,8 +17521,8 @@ function registerInitCommand(program2) {
 }
 async function runInit(options2) {
   const cwd = options2.cwd ?? process.cwd();
-  const configPath = join6(cwd, "ocx.jsonc");
-  if (existsSync2(configPath)) {
+  const configPath = join8(cwd, "ocx.jsonc");
+  if (existsSync3(configPath)) {
     throw new ConflictError(`ocx.jsonc already exists at ${configPath}
 
 ` + `To reset, delete the config and run init again:
@@ -15578,7 +17569,7 @@ async function runInitRegistry(directory, options2) {
   if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(namespace)) {
     throw new ValidationError("Invalid namespace format: must start with letter/number, use hyphens only between segments (e.g., 'my-registry')");
   }
-  const existingFiles = await readdir4(cwd).catch(() => []);
+  const existingFiles = await readdir6(cwd).catch(() => []);
   const hasVisibleFiles = existingFiles.some((f) => !f.startsWith("."));
   if (hasVisibleFiles && !options2.force) {
     throw new ConflictError("Directory is not empty. Use --force to overwrite existing files.");
@@ -15589,7 +17580,7 @@ async function runInitRegistry(directory, options2) {
     if (spin)
       spin.text = options2.local ? "Copying template..." : "Fetching template...";
     if (options2.local) {
-      await mkdir5(cwd, { recursive: true });
+      await mkdir6(cwd, { recursive: true });
       await copyDir(options2.local, cwd);
     } else {
       const version = options2.canary ? "main" : await getLatestVersion();
@@ -15605,7 +17596,7 @@ async function runInitRegistry(directory, options2) {
       logger.info("");
       logger.info("Next steps:");
       logger.info("  1. bun install");
-      logger.info("  2. Edit registry.json with your components");
+      logger.info("  2. Edit registry.jsonc with your components");
       logger.info("  3. bun run build");
       logger.info("");
       logger.info("Deploy to:");
@@ -15637,10 +17628,10 @@ async function fetchAndExtractTemplate(destDir, version, verbose) {
   if (!response.ok || !response.body) {
     throw new NetworkError(`Failed to fetch template from ${tarballUrl}: ${response.statusText}`);
   }
-  const tempDir = join6(destDir, ".ocx-temp");
-  await mkdir5(tempDir, { recursive: true });
+  const tempDir = join8(destDir, ".ocx-temp");
+  await mkdir6(tempDir, { recursive: true });
   try {
-    const tarPath = join6(tempDir, "template.tar.gz");
+    const tarPath = join8(tempDir, "template.tar.gz");
     const arrayBuffer = await response.arrayBuffer();
     await writeFile2(tarPath, Buffer.from(arrayBuffer));
     const proc = Bun.spawn(["tar", "-xzf", tarPath, "-C", tempDir], {
@@ -15652,12 +17643,12 @@ async function fetchAndExtractTemplate(destDir, version, verbose) {
       const stderr = await new Response(proc.stderr).text();
       throw new Error(`Failed to extract template: ${stderr}`);
     }
-    const extractedDirs = await readdir4(tempDir);
+    const extractedDirs = await readdir6(tempDir);
     const extractedDir = extractedDirs.find((d) => d.startsWith("ocx-"));
     if (!extractedDir) {
       throw new Error("Failed to find extracted template directory");
     }
-    const templateDir = join6(tempDir, extractedDir, TEMPLATE_PATH);
+    const templateDir = join8(tempDir, extractedDir, TEMPLATE_PATH);
     await copyDir(templateDir, destDir);
   } finally {
     await rm3(tempDir, { recursive: true, force: true });
@@ -15665,15 +17656,15 @@ async function fetchAndExtractTemplate(destDir, version, verbose) {
 }
 async function replacePlaceholders(dir, values) {
   const filesToProcess = [
-    "registry.json",
+    "registry.jsonc",
     "package.json",
     "wrangler.jsonc",
     "README.md",
     "AGENTS.md"
   ];
   for (const file of filesToProcess) {
-    const filePath = join6(dir, file);
-    if (!existsSync2(filePath))
+    const filePath = join8(dir, file);
+    if (!existsSync3(filePath))
       continue;
     let content2 = await readFile(filePath).then((b) => b.toString());
     content2 = content2.replace(/my-registry/g, values.namespace);
@@ -15682,11 +17673,393 @@ async function replacePlaceholders(dir, values) {
   }
 }
 
-// src/commands/update.ts
+// src/self-update/version-provider.ts
+class BuildTimeVersionProvider {
+  version = "1.3.0";
+}
+var defaultVersionProvider = new BuildTimeVersionProvider;
+
+// src/self-update/check.ts
+var VERSION_CHECK_TIMEOUT_MS = 200;
+var PACKAGE_NAME = "ocx";
+function parseVersion2(v) {
+  const [main2 = ""] = v.split("-");
+  const parts = main2.split(".");
+  const major = parseInt(parts[0] ?? "", 10);
+  const minor = parseInt(parts[1] ?? "", 10);
+  const patch = parseInt(parts[2] ?? "", 10);
+  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) {
+    return null;
+  }
+  return { major, minor, patch };
+}
+function compareSemver2(a, b) {
+  const vA = parseVersion2(a);
+  const vB = parseVersion2(b);
+  if (!vA || !vB) {
+    return null;
+  }
+  if (vA.major !== vB.major)
+    return vA.major - vB.major;
+  if (vA.minor !== vB.minor)
+    return vA.minor - vB.minor;
+  return vA.patch - vB.patch;
+}
+async function checkForUpdate(versionProvider) {
+  const provider = versionProvider ?? defaultVersionProvider;
+  const current = provider.version || "0.0.0-dev";
+  if (current === "0.0.0-dev") {
+    return null;
+  }
+  try {
+    const result = await fetchPackageVersion(PACKAGE_NAME, undefined, AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS));
+    const latest = result.version;
+    const comparison = compareSemver2(latest, current);
+    if (comparison === null) {
+      return null;
+    }
+    return {
+      current,
+      latest,
+      updateAvailable: comparison > 0
+    };
+  } catch {
+    return null;
+  }
+}
+
+// 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 existsSync4, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
+var GITHUB_REPO2 = "kdcokenny/ocx";
+var DEFAULT_DOWNLOAD_BASE_URL = `https://github.com/${GITHUB_REPO2}/releases/download`;
+var PLATFORM_MAP = {
+  "arm64-darwin": "ocx-darwin-arm64",
+  "x64-darwin": "ocx-darwin-x64",
+  "arm64-linux": "ocx-linux-arm64",
+  "x64-linux": "ocx-linux-x64",
+  "x64-win32": "ocx-windows-x64.exe"
+};
+function getDownloadBaseUrl() {
+  const envUrl = process.env.OCX_DOWNLOAD_URL;
+  if (envUrl) {
+    return envUrl.replace(/\/+$/, "");
+  }
+  return DEFAULT_DOWNLOAD_BASE_URL;
+}
+function getDownloadUrl(version) {
+  const platform = `${process.arch}-${process.platform}`;
+  const target = PLATFORM_MAP[platform];
+  if (!target) {
+    const supported = Object.keys(PLATFORM_MAP).join(", ");
+    throw new SelfUpdateError(`Unsupported platform: ${platform}
+` + `Supported platforms: ${supported}`);
+  }
+  const baseUrl = getDownloadBaseUrl();
+  return `${baseUrl}/v${version}/${target}`;
+}
+async function downloadWithProgress(url, dest) {
+  const spin = createSpinner({ text: "Downloading update..." });
+  spin.start();
+  let response;
+  try {
+    response = await fetch(url, { redirect: "follow" });
+  } catch (error) {
+    spin.fail("Download failed");
+    throw new SelfUpdateError(`Network error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!response.ok) {
+    spin.fail("Download failed");
+    throw new SelfUpdateError(`Failed to download: HTTP ${response.status} ${response.statusText}`);
+  }
+  if (!response.body) {
+    spin.fail("Download failed");
+    throw new SelfUpdateError("Download failed: Empty response body");
+  }
+  const reader = response.body.getReader();
+  const writer = Bun.file(dest).writer();
+  const total = Number(response.headers.get("content-length") || 0);
+  let received = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      await writer.write(value);
+      received += value.length;
+      if (total > 0) {
+        const pct = Math.round(received / total * 100);
+        spin.text = `Downloading... ${pct}%`;
+      }
+    }
+    await writer.end();
+    spin.succeed("Download complete");
+  } catch (error) {
+    spin.fail("Download failed");
+    await writer.end();
+    throw new SelfUpdateError(`Download interrupted: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function downloadToTemp(version) {
+  const execPath = getExecutablePath();
+  const tempPath = `${execPath}.new.${Date.now()}`;
+  const url = getDownloadUrl(version);
+  await downloadWithProgress(url, tempPath);
+  try {
+    chmodSync(tempPath, 493);
+  } catch (error) {
+    if (existsSync4(tempPath)) {
+      unlinkSync2(tempPath);
+    }
+    throw new SelfUpdateError(`Failed to set permissions: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return { tempPath, execPath };
+}
+function atomicReplace(tempPath, execPath) {
+  const backupPath = `${execPath}.backup`;
+  try {
+    if (existsSync4(execPath)) {
+      renameSync2(execPath, backupPath);
+    }
+    renameSync2(tempPath, execPath);
+    if (existsSync4(backupPath)) {
+      unlinkSync2(backupPath);
+    }
+  } catch (error) {
+    if (existsSync4(backupPath) && !existsSync4(execPath)) {
+      try {
+        renameSync2(backupPath, execPath);
+      } catch {}
+    }
+    if (existsSync4(tempPath)) {
+      try {
+        unlinkSync2(tempPath);
+      } catch {}
+    }
+    throw new SelfUpdateError(`Update failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function cleanupTempFile(tempPath) {
+  if (existsSync4(tempPath)) {
+    try {
+      unlinkSync2(tempPath);
+    } catch {}
+  }
+}
+
+// src/self-update/notify.ts
+function notifyUpdate(current, latest) {
+  if (!process.stdout.isTTY)
+    return;
+  console.error(`${kleur_default.cyan("info")}: update available - ${kleur_default.green(latest)} (current: ${kleur_default.dim(current)})`);
+  console.error(`  run ${kleur_default.cyan("`ocx self update`")} to upgrade`);
+}
+function notifyUpToDate(version) {
+  console.error(`${kleur_default.cyan("info")}: ocx unchanged - ${kleur_default.dim(version)}`);
+}
+function notifyUpdated(from, to) {
+  console.error(`  ${kleur_default.green("ocx updated")} - ${to} (from ${from})`);
+}
+
+// src/self-update/verify.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir6, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname5, join as join7 } from "path";
+var GITHUB_REPO3 = "kdcokenny/ocx";
+function parseSha256Sums(content2) {
+  const checksums = new Map;
+  for (const line of content2.split(`
+`)) {
+    const match = line.match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
+    if (match?.[1] && match[2]) {
+      checksums.set(match[2].trim(), match[1].toLowerCase());
+    }
+  }
+  return checksums;
+}
+function hashContent2(content2) {
+  return createHash2("sha256").update(content2).digest("hex");
+}
+async function fetchChecksums(version) {
+  const url = `https://github.com/${GITHUB_REPO3}/releases/download/v${version}/SHA256SUMS.txt`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new SelfUpdateError(`Failed to fetch checksums: ${response.status}`);
+  }
+  const content2 = await response.text();
+  return parseSha256Sums(content2);
+}
+async function verifyChecksum(filePath, expectedHash, filename) {
+  const file = Bun.file(filePath);
+  const content2 = await file.arrayBuffer();
+  const actualHash = hashContent2(Buffer.from(content2));
+  if (actualHash !== expectedHash) {
+    throw new IntegrityError(filename, expectedHash, actualHash);
+  }
+}
+
+// src/commands/self/update.ts
+var SEMVER_PATTERN = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+async function updateCommand(options2) {
+  const method = options2.method ? parseInstallMethod(options2.method) : detectInstallMethod();
+  const result = await checkForUpdate();
+  if (!result) {
+    throw new SelfUpdateError("Failed to check for updates");
+  }
+  const { current, latest, updateAvailable } = result;
+  if (!updateAvailable && !options2.force) {
+    notifyUpToDate(current);
+    return;
+  }
+  const targetVersion = latest;
+  switch (method) {
+    case "curl": {
+      await updateViaCurl(current, targetVersion);
+      break;
+    }
+    case "npm":
+    case "pnpm":
+    case "bun":
+    case "unknown": {
+      await updateViaPackageManager(method, current, targetVersion);
+      break;
+    }
+  }
+}
+async function updateViaCurl(current, targetVersion) {
+  const url = getDownloadUrl(targetVersion);
+  const filename = url.split("/").pop();
+  if (!filename) {
+    throw new SelfUpdateError("Failed to determine binary filename from download URL");
+  }
+  const checksums = await fetchChecksums(targetVersion);
+  const expectedHash = checksums.get(filename);
+  if (!expectedHash) {
+    throw new SelfUpdateError(`Security error: No checksum found for ${filename}. Update aborted.`);
+  }
+  const { tempPath, execPath } = await downloadToTemp(targetVersion);
+  try {
+    await verifyChecksum(tempPath, expectedHash, filename);
+  } catch (error) {
+    cleanupTempFile(tempPath);
+    throw error;
+  }
+  atomicReplace(tempPath, execPath);
+  notifyUpdated(current, targetVersion);
+}
+async function runPackageManager(cmd) {
+  const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new SelfUpdateError(`Package manager command failed: ${stderr.trim()}`);
+  }
+}
+async function updateViaPackageManager(method, current, targetVersion) {
+  if (!SEMVER_PATTERN.test(targetVersion)) {
+    throw new SelfUpdateError(`Invalid version format: ${targetVersion}`);
+  }
+  const spin = createSpinner({ text: `Updating via ${method}...` });
+  spin.start();
+  try {
+    switch (method) {
+      case "npm": {
+        await runPackageManager(["npm", "install", "-g", `ocx@${targetVersion}`]);
+        break;
+      }
+      case "yarn": {
+        await runPackageManager(["yarn", "global", "add", `ocx@${targetVersion}`]);
+        break;
+      }
+      case "pnpm": {
+        await runPackageManager(["pnpm", "install", "-g", `ocx@${targetVersion}`]);
+        break;
+      }
+      case "bun": {
+        await runPackageManager(["bun", "install", "-g", `ocx@${targetVersion}`]);
+        break;
+      }
+      case "unknown": {
+        throw new SelfUpdateError(`Could not detect install method. Update manually with one of:
+` + `  npm install -g ocx@latest
+` + `  pnpm install -g ocx@latest
+` + "  bun install -g ocx@latest");
+      }
+    }
+    spin.succeed(`Updated via ${method}`);
+    notifyUpdated(current, targetVersion);
+  } catch (error) {
+    if (error instanceof SelfUpdateError) {
+      spin.fail(`Update failed`);
+      throw error;
+    }
+    spin.fail(`Update failed`);
+    throw new SelfUpdateError(`Failed to run ${method}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function registerSelfUpdateCommand(parent) {
+  parent.command("update").description("Update OCX to the latest version").option("-f, --force", "Reinstall even if already up to date").option("-m, --method <method>", "Override install method detection (curl|npm|pnpm|bun)").action(wrapAction(async (options2) => {
+    await updateCommand(options2);
+  }));
+}
+
+// src/commands/self/index.ts
+function registerSelfCommand(program2) {
+  const self = program2.command("self").description("Manage the OCX CLI");
+  registerSelfUpdateCommand(self);
+}
+
+// src/commands/update.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir7, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname7, join as join9 } from "path";
 function registerUpdateCommand(program2) {
   program2.command("update [components...]").description("Update installed components (use @version suffix to pin, e.g., kdco/agents@1.2.0)").option("--all", "Update all installed components").option("--registry <name>", "Update all components from a specific registry").option("--dry-run", "Preview changes without applying").option("--cwd <path>", "Working directory", process.cwd()).option("-q, --quiet", "Suppress output").option("-v, --verbose", "Verbose output").option("--json", "Output as JSON").action(async (components, options2) => {
     try {
@@ -15698,7 +18071,7 @@ function registerUpdateCommand(program2) {
 }
 async function runUpdate(componentNames, options2) {
   const cwd = options2.cwd ?? process.cwd();
-  const lockPath = join7(cwd, "ocx.lock");
+  const lockPath = join9(cwd, "ocx.lock");
   const config = await readOcxConfig(cwd);
   if (!config) {
     throw new ConfigError("No ocx.jsonc found. Run 'ocx init' first.");
@@ -15823,10 +18196,10 @@ Version cannot be empty. Use 'kdco/agents@1.2.0' or omit the version for latest.
         const fileObj = update.component.files.find((f) => f.path === file.path);
         if (!fileObj)
           continue;
-        const targetPath = join7(cwd, fileObj.target);
-        const targetDir = dirname5(targetPath);
-        if (!existsSync3(targetDir)) {
-          await mkdir6(targetDir, { recursive: true });
+        const targetPath = join9(cwd, fileObj.target);
+        const targetDir = dirname7(targetPath);
+        if (!existsSync5(targetDir)) {
+          await mkdir7(targetDir, { recursive: true });
         }
         await writeFile3(targetPath, file.content);
         if (options2.verbose) {
@@ -15947,21 +18320,49 @@ function outputDryRun(results, options2) {
     }
   }
 }
-async function hashContent2(content2) {
-  return createHash2("sha256").update(content2).digest("hex");
+async function hashContent3(content2) {
+  return createHash3("sha256").update(content2).digest("hex");
 }
 async function hashBundle2(files) {
   const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
   const manifestParts = [];
   for (const file of sorted) {
-    const hash = await hashContent2(file.content);
+    const hash = await hashContent3(file.content);
     manifestParts.push(`${file.path}:${hash}`);
   }
-  return hashContent2(manifestParts.join(`
+  return hashContent3(manifestParts.join(`
 `));
 }
+
+// src/self-update/index.ts
+function shouldCheckForUpdate() {
+  if (process.env.OCX_SELF_UPDATE === "off")
+    return false;
+  if (parseEnvBool(process.env.OCX_NO_UPDATE_CHECK, false))
+    return false;
+  if (process.env.CI)
+    return false;
+  if (!process.stdout.isTTY)
+    return false;
+  return true;
+}
+function registerUpdateCheckHook(program2) {
+  program2.hook("postAction", async (thisCommand) => {
+    if (thisCommand.name() === "update" && thisCommand.parent?.name() === "self") {
+      return;
+    }
+    if (!shouldCheckForUpdate())
+      return;
+    try {
+      const result = await checkForUpdate();
+      if (result?.updateAvailable) {
+        notifyUpdate(result.current, result.latest);
+      }
+    } catch {}
+  });
+}
 // src/index.ts
-var version = "1.2.2";
+var version = "1.3.0";
 async function main2() {
   const program2 = new Command().name("ocx").description("OpenCode Extensions - Install agents, skills, plugins, and commands").version(version);
   registerInitCommand(program2);
@@ -15972,6 +18373,8 @@ async function main2() {
   registerRegistryCommand(program2);
   registerBuildCommand(program2);
   registerGhostCommand(program2);
+  registerSelfCommand(program2);
+  registerUpdateCheckHook(program2);
   await program2.parseAsync(process.argv);
 }
 if (import.meta.main) {
@@ -15988,4 +18391,4 @@ export {
   buildRegistry
 };
 
-//# debugId=DCBED805AED28C6C64756E2164756E21
+//# debugId=FE5CBBF0E272CBE164756E2164756E21