@ashx-j/lunr 0.2.24 → 0.2.25

package/dist/node-runtime/{chunk-F4FLTQKV.js → chunk-LQP3RB67.js}

@@ -5,38 +5,17 @@ import {
 import {
   require_semver
 } from "./chunk-DVGWF6A2.js";
-import {
-  parseFrontmatter
-} from "./chunk-QFWG2RVL.js";
-import {
-  SettingsManager
-} from "./chunk-RORY2HMJ.js";
 import {
   minimatch
 } from "./chunk-CGBXPL3E.js";
-import {
-  getGlobalInstructionsPath,
-  loadSelectedUserInstructions
-} from "./chunk-M3LZLQW2.js";
-import {
-  measureStartup,
-  resetTimings
-} from "./chunk-PVCDKGR6.js";
-import {
-  loadThemeFromPath
-} from "./chunk-RDDAZOMU.js";
 import {
   CONFIG_DIR_NAME,
   canonicalizePath,
-  getAgentDir,
-  isBunBinary,
   isLocalPath,
-  isNodeBundle,
   markPathIgnoredByCloudSync,
   resolvePath,
   spawnProcess,
-  spawnProcessSync,
-  waitForChildProcess
+  spawnProcessSync
 } from "./chunk-FQMM2EZ2.js";
 import {
   __commonJS,
@@ -634,13 +613,13 @@ var require_hosts = __commonJS({
     var maybeJoin = (...args) => args.every((arg) => arg) ? args.join("") : "", maybeEncode = (arg) => arg ? encodeURIComponent(arg) : "", formatHashFragment = (f) => f.toLowerCase().replace(/^\W+/g, "").replace(/(?<!\W)\W+$/, "").replace(/\//g, "").replace(/\W+/g, "-"), defaults = {
       sshtemplate: ({ domain, user, project, committish }) => `git@${domain}:${user}/${project}.git${maybeJoin("#", committish)}`,
       sshurltemplate: ({ domain, user, project, committish }) => `git+ssh://git@${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
-      edittemplate: ({ domain, user, project, committish, editpath, path: path2 }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path2)}`,
+      edittemplate: ({ domain, user, project, committish, editpath, path }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path)}`,
       browsetemplate: ({ domain, user, project, committish, treepath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}`,
-      browsetreetemplate: ({ domain, user, project, committish, treepath, path: path2, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path2}${maybeJoin("#", hashformat(fragment || ""))}`,
-      browseblobtemplate: ({ domain, user, project, committish, blobpath, path: path2, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path2}${maybeJoin("#", hashformat(fragment || ""))}`,
+      browsetreetemplate: ({ domain, user, project, committish, treepath, path, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path}${maybeJoin("#", hashformat(fragment || ""))}`,
+      browseblobtemplate: ({ domain, user, project, committish, blobpath, path, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path}${maybeJoin("#", hashformat(fragment || ""))}`,
       docstemplate: ({ domain, user, project, treepath, committish }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}#readme`,
       httpstemplate: ({ auth, domain, user, project, committish }) => `git+https://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
-      filetemplate: ({ domain, user, project, committish, path: path2 }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path2}`,
+      filetemplate: ({ domain, user, project, committish, path }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path}`,
       shortcuttemplate: ({ type, user, project, committish }) => `${type}:${user}/${project}${maybeJoin("#", committish)}`,
       pathtemplate: ({ user, project, committish }) => `${user}/${project}${maybeJoin("#", committish)}`,
       bugstemplate: ({ domain, user, project }) => `https://${domain}/${user}/${project}/issues`,
@@ -654,7 +633,7 @@ var require_hosts = __commonJS({
       treepath: "tree",
       blobpath: "blob",
       editpath: "edit",
-      filetemplate: ({ auth, user, project, committish, path: path2 }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path2}`,
+      filetemplate: ({ auth, user, project, committish, path }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path}`,
       gittemplate: ({ auth, domain, user, project, committish }) => `git://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
       tarballtemplate: ({ domain, user, project, committish }) => `https://codeload.${domain}/${user}/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`,
       extract: (url) => {
@@ -669,7 +648,7 @@ var require_hosts = __commonJS({
       treepath: "src",
       blobpath: "src",
       editpath: "?mode=edit",
-      edittemplate: ({ domain, user, project, committish, treepath, path: path2, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path2, editpath)}`,
+      edittemplate: ({ domain, user, project, committish, treepath, path, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path, editpath)}`,
       tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/get/${maybeEncode(committish || "HEAD")}.tar.gz`,
       extract: (url) => {
         let [, user, project, aux] = url.pathname.split("/", 4);
@@ -685,10 +664,10 @@ var require_hosts = __commonJS({
       editpath: "-/edit",
       tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/api/v4/projects/${maybeEncode(user + "/" + project)}/repository/archive.tar.gz?sha=${maybeEncode(committish || "HEAD")}`,
       extract: (url) => {
-        let path2 = url.pathname.slice(1);
-        if (path2.includes("/-/") || path2.includes("/archive.tar.gz"))
+        let path = url.pathname.slice(1);
+        if (path.includes("/-/") || path.includes("/archive.tar.gz"))
           return;
-        let segments = path2.split("/"), project = segments.pop();
+        let segments = path.split("/"), project = segments.pop();
         project.endsWith(".git") && (project = project.slice(0, -4));
         let user = segments.join("/");
         if (!(!user || !project))
@@ -703,11 +682,11 @@ var require_hosts = __commonJS({
       sshurltemplate: ({ domain, project, committish }) => `git+ssh://git@${domain}/${project}.git${maybeJoin("#", committish)}`,
       edittemplate: ({ domain, user, project, committish, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", maybeEncode(committish))}/${editpath}`,
       browsetemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
-      browsetreetemplate: ({ domain, project, committish, path: path2, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path2))}`,
-      browseblobtemplate: ({ domain, project, committish, path: path2, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path2))}`,
+      browsetreetemplate: ({ domain, project, committish, path, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path))}`,
+      browseblobtemplate: ({ domain, project, committish, path, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path))}`,
       docstemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
       httpstemplate: ({ domain, project, committish }) => `git+https://${domain}/${project}.git${maybeJoin("#", committish)}`,
-      filetemplate: ({ user, project, committish, path: path2 }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path2}`,
+      filetemplate: ({ user, project, committish, path }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path}`,
       shortcuttemplate: ({ type, project, committish }) => `${type}:${project}${maybeJoin("#", committish)}`,
       pathtemplate: ({ project, committish }) => `${project}${maybeJoin("#", committish)}`,
       bugstemplate: ({ domain, project }) => `https://${domain}/${project}`,
@@ -733,7 +712,7 @@ var require_hosts = __commonJS({
       domain: "git.sr.ht",
       treepath: "tree",
       blobpath: "tree",
-      filetemplate: ({ domain, user, project, committish, path: path2 }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path2}`,
+      filetemplate: ({ domain, user, project, committish, path }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path}`,
       httpstemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}${maybeJoin("#", committish)}`,
       tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || "HEAD"}.tar.gz`,
       bugstemplate: () => null,
@@ -835,8 +814,8 @@ var require_lib = __commonJS({
         } = new URL(url);
         if (!hostname)
           return null;
-        let proto = /(?:git\+)http:$/.test(protocol) ? "http:" : "https:", path2 = pathname.replace(/\.git$/, "");
-        return `${proto}//${hostname}${path2}`;
+        let proto = /(?:git\+)http:$/.test(protocol) ? "http:" : "https:", path = pathname.replace(/\.git$/, "");
+        return `${proto}//${hostname}${path}`;
       } catch {
         return null;
       }
@@ -911,16 +890,16 @@ var require_lib = __commonJS({
       sshurl(opts) {
         return this.#fill(this.sshurltemplate, opts);
       }
-      browse(path2, ...args) {
-        return typeof path2 != "string" ? this.#fill(this.browsetemplate, path2) : typeof args[0] != "string" ? this.#fill(this.browsetreetemplate, { ...args[0], path: path2 }) : this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path: path2 });
+      browse(path, ...args) {
+        return typeof path != "string" ? this.#fill(this.browsetemplate, path) : typeof args[0] != "string" ? this.#fill(this.browsetreetemplate, { ...args[0], path }) : this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path });
       }
       // If the path is known to be a file, then browseFile should be used. For some hosts
       // the url is the same as browse, but for others like GitHub a file can use both `/tree/`
       // and `/blob/` in the path. When using a default committish of `HEAD` then the `/tree/`
       // path will redirect to a specific commit. Using the `/blob/` path avoids this and
       // does not redirect to a different commit.
-      browseFile(path2, ...args) {
-        return typeof args[0] != "string" ? this.#fill(this.browseblobtemplate, { ...args[0], path: path2 }) : this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path: path2 });
+      browseFile(path, ...args) {
+        return typeof args[0] != "string" ? this.#fill(this.browseblobtemplate, { ...args[0], path }) : this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path });
       }
       docs(opts) {
         return this.#fill(this.docstemplate, opts);
@@ -943,11 +922,11 @@ var require_lib = __commonJS({
       tarball(opts) {
         return this.#fill(this.tarballtemplate, { ...opts, noCommittish: !1 });
       }
-      file(path2, opts) {
-        return this.#fill(this.filetemplate, { ...opts, path: path2 });
+      file(path, opts) {
+        return this.#fill(this.filetemplate, { ...opts, path });
       }
-      edit(path2, opts) {
-        return this.#fill(this.edittemplate, { ...opts, path: path2 });
+      edit(path, opts) {
+        return this.#fill(this.edittemplate, { ...opts, path });
       }
       getDefaultRepresentation() {
         return this.default;
@@ -1197,11 +1176,11 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path2, checkUnignored, mode) {
+      test(path, checkUnignored, mode) {
         let ignored = !1, unignored = !1, matchedRule;
         this._rules.forEach((rule) => {
           let { negative } = rule;
-          unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored || !rule[mode].test(path2) || (ignored = !negative, unignored = negative, matchedRule = negative ? UNDEFINED : rule);
+          unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored || !rule[mode].test(path) || (ignored = !negative, unignored = negative, matchedRule = negative ? UNDEFINED : rule);
         });
         let ret = {
           ignored,
@@ -1211,13 +1190,13 @@ var require_ignore = __commonJS({
       }
     }, throwError = (message, Ctor) => {
       throw new Ctor(message);
-    }, checkPath = (path2, originalPath, doThrow) => isString(path2) ? path2 ? checkPath.isNotRelative(path2) ? doThrow(
+    }, checkPath = (path, originalPath, doThrow) => isString(path) ? path ? checkPath.isNotRelative(path) ? doThrow(
       `path should be a \`path.relative()\`d string, but got "${originalPath}"`,
       RangeError
     ) : !0 : doThrow("path must not be empty", TypeError) : doThrow(
       `path must be a string, but got \`${originalPath}\``,
       TypeError
-    ), isNotRelative = (path2) => REGEX_TEST_INVALID_PATH.test(path2);
+    ), isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -1240,17 +1219,17 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        let path2 = originalPath && checkPath.convert(originalPath);
+        let path = originalPath && checkPath.convert(originalPath);
         return checkPath(
-          path2,
+          path,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
-        ), this._t(path2, cache, checkUnignored, slices);
+        ), this._t(path, cache, checkUnignored, slices);
       }
-      checkIgnore(path2) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path2))
-          return this.test(path2);
-        let slices = path2.split(SLASH).filter(Boolean);
+      checkIgnore(path) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path))
+          return this.test(path);
+        let slices = path.split(SLASH).filter(Boolean);
         if (slices.pop(), slices.length) {
           let parent = this._t(
             slices.join(SLASH) + SLASH,
@@ -1261,39 +1240,39 @@ var require_ignore = __commonJS({
           if (parent.ignored)
             return parent;
         }
-        return this._rules.test(path2, !1, MODE_CHECK_IGNORE);
+        return this._rules.test(path, !1, MODE_CHECK_IGNORE);
       }
-      _t(path2, cache, checkUnignored, slices) {
-        if (path2 in cache)
-          return cache[path2];
-        if (slices || (slices = path2.split(SLASH).filter(Boolean)), slices.pop(), !slices.length)
-          return cache[path2] = this._rules.test(path2, checkUnignored, MODE_IGNORE);
+      _t(path, cache, checkUnignored, slices) {
+        if (path in cache)
+          return cache[path];
+        if (slices || (slices = path.split(SLASH).filter(Boolean)), slices.pop(), !slices.length)
+          return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
         let parent = this._t(
           slices.join(SLASH) + SLASH,
           cache,
           checkUnignored,
           slices
         );
-        return cache[path2] = parent.ignored ? parent : this._rules.test(path2, checkUnignored, MODE_IGNORE);
+        return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
       }
-      ignores(path2) {
-        return this._test(path2, this._ignoreCache, !1).ignored;
+      ignores(path) {
+        return this._test(path, this._ignoreCache, !1).ignored;
       }
       createFilter() {
-        return (path2) => !this.ignores(path2);
+        return (path) => !this.ignores(path);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path2) {
-        return this._test(path2, this._testCache, !0);
+      test(path) {
+        return this._test(path, this._testCache, !0);
       }
-    }, factory = (options) => new Ignore(options), isPathValid = (path2) => checkPath(path2 && checkPath.convert(path2), path2, RETURN_FALSE), setupWindows = () => {
+    }, factory = (options) => new Ignore(options), isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE), setupWindows = () => {
       let makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       let REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path2) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path2) || isNotRelative(path2);
+      checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
     };
     // Detect `process` so that it can run in browsers.
     typeof process < "u" && process.platform === "win32" && setupWindows();
@@ -1304,417 +1283,6 @@ var require_ignore = __commonJS({
   }
 });
 
-// packages/coding-agent/dist/core/event-bus.js
-import { EventEmitter } from "node:events";
-function createEventBus() {
-  let emitter = new EventEmitter();
-  return {
-    emit: (channel, data) => {
-      emitter.emit(channel, data);
-    },
-    on: (channel, handler) => {
-      let safeHandler = async (data) => {
-        try {
-          await handler(data);
-        } catch (err) {
-          console.error(`Event handler error (${channel}):`, err);
-        }
-      };
-      return emitter.on(channel, safeHandler), () => emitter.off(channel, safeHandler);
-    },
-    clear: () => {
-      emitter.removeAllListeners();
-    }
-  };
-}
-
-// packages/coding-agent/dist/core/source-info.js
-function createSourceInfo(path2, metadata) {
-  return {
-    path: path2,
-    source: metadata.source,
-    scope: metadata.scope,
-    origin: metadata.origin,
-    baseDir: metadata.baseDir
-  };
-}
-function createSyntheticSourceInfo(path2, options) {
-  return {
-    path: path2,
-    source: options.source,
-    scope: options.scope ?? "temporary",
-    origin: options.origin ?? "top-level",
-    baseDir: options.baseDir
-  };
-}
-
-// packages/coding-agent/dist/core/extensions/loader.js
-import * as fs from "node:fs";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-
-// packages/coding-agent/dist/core/exec.js
-import { spawn } from "node:child_process";
-async function execCommand(command, args, cwd, options) {
-  return new Promise((resolve6) => {
-    let proc = spawn(command, args, {
-      cwd,
-      shell: !1,
-      stdio: ["ignore", "pipe", "pipe"]
-    }), stdout = "", stderr = "", killed = !1, timeoutId, killProcess = () => {
-      killed || (killed = !0, proc.kill("SIGTERM"), setTimeout(() => {
-        proc.killed || proc.kill("SIGKILL");
-      }, 5e3));
-    };
-    options?.signal && (options.signal.aborted ? killProcess() : options.signal.addEventListener("abort", killProcess, { once: !0 })), options?.timeout && options.timeout > 0 && (timeoutId = setTimeout(() => {
-      killProcess();
-    }, options.timeout)), proc.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    }), proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    }), waitForChildProcess(proc).then((code) => {
-      timeoutId && clearTimeout(timeoutId), options?.signal && options.signal.removeEventListener("abort", killProcess), resolve6({ stdout, stderr, code: code ?? 0, killed });
-    }).catch((_err) => {
-      timeoutId && clearTimeout(timeoutId), options?.signal && options.signal.removeEventListener("abort", killProcess), resolve6({ stdout, stderr, code: 1, killed });
-    });
-  });
-}
-
-// packages/coding-agent/dist/core/extensions/loader.js
-var bunExtensionHost, createJitiFn;
-var require2 = createRequire(new URL("../core/extensions/loader.js", import.meta.url).href), _aliases = null;
-function getAliases() {
-  if (_aliases)
-    return _aliases;
-  let __dirname = path.dirname(fileURLToPath(new URL("../core/extensions/loader.js", import.meta.url).href)), packageIndex = path.resolve(__dirname, "../..", isNodeBundle ? "node-runtime/index.js" : "index.js"), typeboxEntry = require2.resolve("typebox"), typeboxCompileEntry = require2.resolve("typebox/compile"), typeboxValueEntry = require2.resolve("typebox/value"), packagesRoot = path.resolve(__dirname, "../../../../"), resolveWorkspaceOrImport = (workspaceRelativePath, specifier) => {
-    let workspacePath = path.join(packagesRoot, workspaceRelativePath);
-    return fs.existsSync(workspacePath) ? workspacePath : fileURLToPath(import.meta.resolve(specifier));
-  }, piCodingAgentEntry = packageIndex, piAgentCoreEntry = resolveWorkspaceOrImport("agent/dist/index.js", "@ashx-j/lunr-agent"), piTuiEntry = resolveWorkspaceOrImport("tui/dist/index.js", "@ashx-j/lunr-tui"), piAiCompatEntry = resolveWorkspaceOrImport("ai/dist/compat.js", "@ashx-j/lunr-ai/compat"), piAiOauthEntry = resolveWorkspaceOrImport("ai/dist/oauth.js", "@ashx-j/lunr-ai/oauth"), piAiProvidersEntry = resolveWorkspaceOrImport("ai/dist/providers/all.js", "@ashx-j/lunr-ai/providers/all");
-  return _aliases = {
-    "@ashx-j/lunr": piCodingAgentEntry,
-    "@ashx-j/lunr-agent": piAgentCoreEntry,
-    "@ashx-j/lunr-tui": piTuiEntry,
-    "@ashx-j/lunr-ai/providers/all": piAiProvidersEntry,
-    "@ashx-j/lunr-ai/compat": piAiCompatEntry,
-    "@ashx-j/lunr-ai/oauth": piAiOauthEntry,
-    "@ashx-j/lunr-ai": piAiCompatEntry,
-    "@ashx-j/lunr": piCodingAgentEntry,
-    "@ashx-j/lunr-agent": piAgentCoreEntry,
-    "@ashx-j/lunr-tui": piTuiEntry,
-    "@ashx-j/lunr-ai/providers/all": piAiProvidersEntry,
-    "@ashx-j/lunr-ai/compat": piAiCompatEntry,
-    "@ashx-j/lunr-ai/oauth": piAiOauthEntry,
-    "@ashx-j/lunr-ai": piAiCompatEntry,
-    "@mariozechner/pi-coding-agent": piCodingAgentEntry,
-    "@mariozechner/pi-agent-core": piAgentCoreEntry,
-    "@mariozechner/pi-tui": piTuiEntry,
-    "@mariozechner/pi-ai/providers/all": piAiProvidersEntry,
-    "@mariozechner/pi-ai/compat": piAiCompatEntry,
-    "@mariozechner/pi-ai/oauth": piAiOauthEntry,
-    "@mariozechner/pi-ai": piAiCompatEntry,
-    typebox: typeboxEntry,
-    "typebox/compile": typeboxCompileEntry,
-    "typebox/value": typeboxValueEntry,
-    "@sinclair/typebox": typeboxEntry,
-    "@sinclair/typebox/compile": typeboxCompileEntry,
-    "@sinclair/typebox/value": typeboxValueEntry
-  }, _aliases;
-}
-var extensionCacheCwd, extensionCacheGeneration = 0, extensionCache = /* @__PURE__ */ new Map();
-function clearExtensionCache() {
-  extensionCache.clear(), extensionCacheCwd = void 0, extensionCacheGeneration++;
-}
-function useExtensionCacheCwd(cwd) {
-  let resolvedCwd = resolvePath(cwd);
-  return extensionCacheCwd !== void 0 && extensionCacheCwd !== resolvedCwd && clearExtensionCache(), extensionCacheCwd = resolvedCwd, { cwd: resolvedCwd, generation: extensionCacheGeneration };
-}
-function createExtensionRuntime() {
-  let notInitialized = () => {
-    throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
-  }, state = {}, runtime = {
-    sendMessage: notInitialized,
-    sendUserMessage: notInitialized,
-    appendEntry: notInitialized,
-    setSessionName: notInitialized,
-    getSessionName: notInitialized,
-    setLabel: notInitialized,
-    getActiveTools: notInitialized,
-    getAllTools: notInitialized,
-    setActiveTools: notInitialized,
-    // registerTool() is valid during extension load; refresh is only needed post-bind.
-    refreshTools: () => {
-    },
-    getCommands: notInitialized,
-    setModel: () => Promise.reject(new Error("Extension runtime not initialized")),
-    getThinkingLevel: notInitialized,
-    setThinkingLevel: notInitialized,
-    flagValues: /* @__PURE__ */ new Map(),
-    pendingProviderRegistrations: [],
-    assertActive: () => {
-      if (state.staleMessage)
-        throw new Error(state.staleMessage);
-    },
-    invalidate: (message) => {
-      state.staleMessage ??= message ?? "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
-    },
-    // Pre-bind: queue registrations so bindCore() can flush them once the
-    // model registry is available. bindCore() replaces both with direct calls.
-    registerProvider: (name, config, extensionPath = "<unknown>") => {
-      runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
-    },
-    unregisterProvider: (name) => {
-      runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter((r) => r.name !== name);
-    }
-  };
-  return runtime;
-}
-function createExtensionAPI(extension, runtime, cwd, eventBus) {
-  return {
-    // Registration methods - write to extension
-    on(event, handler) {
-      runtime.assertActive();
-      let list = extension.handlers.get(event) ?? [];
-      list.push(handler), extension.handlers.set(event, list);
-    },
-    registerTool(tool) {
-      runtime.assertActive(), extension.tools.set(tool.name, {
-        definition: tool,
-        sourceInfo: extension.sourceInfo
-      }), runtime.refreshTools();
-    },
-    registerCommand(name, options) {
-      runtime.assertActive(), extension.commands.set(name, {
-        name,
-        sourceInfo: extension.sourceInfo,
-        ...options
-      });
-    },
-    registerShortcut(shortcut, options) {
-      runtime.assertActive(), extension.shortcuts.set(shortcut, { shortcut, extensionPath: extension.path, ...options });
-    },
-    registerFlag(name, options) {
-      runtime.assertActive(), extension.flags.set(name, { name, extensionPath: extension.path, ...options }), options.default !== void 0 && !runtime.flagValues.has(name) && runtime.flagValues.set(name, options.default);
-    },
-    registerMessageRenderer(customType, renderer) {
-      runtime.assertActive(), extension.messageRenderers.set(customType, renderer);
-    },
-    registerEntryRenderer(customType, renderer) {
-      runtime.assertActive(), extension.entryRenderers ??= /* @__PURE__ */ new Map(), extension.entryRenderers.set(customType, renderer);
-    },
-    // Flag access - checks extension registered it, reads from runtime
-    getFlag(name) {
-      if (runtime.assertActive(), !!extension.flags.has(name))
-        return runtime.flagValues.get(name);
-    },
-    // Action methods - delegate to shared runtime
-    sendMessage(message, options) {
-      runtime.assertActive(), runtime.sendMessage(message, options);
-    },
-    sendUserMessage(content, options) {
-      runtime.assertActive(), runtime.sendUserMessage(content, options);
-    },
-    appendEntry(customType, data) {
-      runtime.assertActive(), runtime.appendEntry(customType, data);
-    },
-    setSessionName(name) {
-      runtime.assertActive(), runtime.setSessionName(name);
-    },
-    getSessionName() {
-      return runtime.assertActive(), runtime.getSessionName();
-    },
-    setLabel(entryId, label) {
-      runtime.assertActive(), runtime.setLabel(entryId, label);
-    },
-    exec(command, args, options) {
-      return runtime.assertActive(), execCommand(command, args, options?.cwd ?? cwd, options);
-    },
-    getActiveTools() {
-      return runtime.assertActive(), runtime.getActiveTools();
-    },
-    getAllTools() {
-      return runtime.assertActive(), runtime.getAllTools();
-    },
-    setActiveTools(toolNames) {
-      runtime.assertActive(), runtime.setActiveTools(toolNames);
-    },
-    getCommands() {
-      return runtime.assertActive(), runtime.getCommands();
-    },
-    setModel(model) {
-      return runtime.assertActive(), runtime.setModel(model);
-    },
-    getThinkingLevel() {
-      return runtime.assertActive(), runtime.getThinkingLevel();
-    },
-    setThinkingLevel(level) {
-      runtime.assertActive(), runtime.setThinkingLevel(level);
-    },
-    registerProvider(name, config) {
-      runtime.assertActive(), runtime.registerProvider(name, config, extension.path);
-    },
-    unregisterProvider(name) {
-      runtime.assertActive(), runtime.unregisterProvider(name, extension.path);
-    },
-    events: eventBus
-  };
-}
-function isCurrentCacheToken(cacheToken) {
-  return cacheToken !== void 0 && extensionCacheCwd === cacheToken.cwd && extensionCacheGeneration === cacheToken.generation;
-}
-async function ensureExtensionHost() {
-  if (createJitiFn)
-    return createJitiFn;
-  if (isBunBinary && bunExtensionHost)
-    return bunExtensionHost.createJiti;
-  let { createJiti } = await import("jiti/static");
-  return createJitiFn = createJiti, createJiti;
-}
-async function loadExtensionModule(extensionPath, cacheToken) {
-  if (isCurrentCacheToken(cacheToken)) {
-    let cachedFactory = extensionCache.get(extensionPath);
-    if (cachedFactory)
-      return cachedFactory;
-  }
-  let factory = await (await ensureExtensionHost())(new URL("../core/extensions/loader.js", import.meta.url).href, {
-    moduleCache: !1,
-    // In Bun binary: use virtualModules for bundled packages (no filesystem resolution)
-    // Also disable tryNative so jiti handles ALL imports (not just the entry point)
-    // In Node.js/dev: use aliases to resolve to node_modules paths
-    ...isBunBinary ? { virtualModules: bunExtensionHost?.virtualModules, tryNative: !1 } : { alias: getAliases() }
-  }).import(extensionPath, { default: !0 });
-  if (typeof factory == "function")
-    return isCurrentCacheToken(cacheToken) && extensionCache.set(extensionPath, factory), factory;
-}
-function createExtension(extensionPath, resolvedPath) {
-  let source = extensionPath.startsWith("<") && extensionPath.endsWith(">") ? extensionPath.slice(1, -1).split(":")[0] || "temporary" : "local", baseDir = extensionPath.startsWith("<") ? void 0 : path.dirname(resolvedPath);
-  return {
-    path: extensionPath,
-    resolvedPath,
-    sourceInfo: createSyntheticSourceInfo(extensionPath, { source, baseDir }),
-    handlers: /* @__PURE__ */ new Map(),
-    tools: /* @__PURE__ */ new Map(),
-    messageRenderers: /* @__PURE__ */ new Map(),
-    entryRenderers: /* @__PURE__ */ new Map(),
-    commands: /* @__PURE__ */ new Map(),
-    flags: /* @__PURE__ */ new Map(),
-    shortcuts: /* @__PURE__ */ new Map()
-  };
-}
-async function loadExtension(extensionPath, cwd, eventBus, runtime, cacheToken) {
-  let resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: !0 });
-  try {
-    let factory = await measureStartup(`${extensionPath} module import`, () => loadExtensionModule(resolvedPath, cacheToken));
-    if (!factory)
-      return { extension: null, error: `Extension does not export a valid factory function: ${extensionPath}` };
-    let extension = createExtension(extensionPath, resolvedPath), api = createExtensionAPI(extension, runtime, cwd, eventBus);
-    return await measureStartup(`${extensionPath} factory`, () => factory(api)), { extension, error: null };
-  } catch (err) {
-    return { extension: null, error: `Failed to load extension: ${err instanceof Error ? err.message : String(err)}` };
-  }
-}
-async function loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath = "<inline>") {
-  let extension = createExtension(extensionPath, extensionPath), resolvedCwd = resolvePath(cwd), api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
-  return await measureStartup(`${extensionPath} factory`, () => factory(api)), extension;
-}
-async function loadExtensionsInternal(paths, cwd, eventBus, runtime, useCache = !1) {
-  let extensions = [], errors = [], cacheToken = useCache ? useExtensionCacheCwd(cwd) : void 0, resolvedCwd = cacheToken?.cwd ?? resolvePath(cwd), resolvedEventBus = eventBus ?? createEventBus(), resolvedRuntime = runtime ?? createExtensionRuntime();
-  for (let extPath of paths) {
-    let { extension, error } = await loadExtension(extPath, resolvedCwd, resolvedEventBus, resolvedRuntime, cacheToken);
-    if (error) {
-      errors.push({ path: extPath, error });
-      continue;
-    }
-    extension && extensions.push(extension);
-  }
-  return {
-    extensions,
-    errors,
-    runtime: resolvedRuntime
-  };
-}
-async function loadExtensions(paths, cwd, eventBus, runtime) {
-  return loadExtensionsInternal(paths, cwd, eventBus, runtime);
-}
-async function loadExtensionsCached(paths, cwd, eventBus, runtime) {
-  return loadExtensionsInternal(paths, cwd, eventBus, runtime, !0);
-}
-function readPiManifest(packageJsonPath) {
-  try {
-    let content = fs.readFileSync(packageJsonPath, "utf-8"), pkg = JSON.parse(content);
-    return pkg.pi && typeof pkg.pi == "object" ? pkg.pi : null;
-  } catch {
-    return null;
-  }
-}
-function isExtensionFile(name) {
-  return name.endsWith(".ts") || name.endsWith(".js");
-}
-function resolveExtensionEntries(dir) {
-  let packageJsonPath = path.join(dir, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
-    let manifest = readPiManifest(packageJsonPath);
-    if (manifest?.extensions?.length) {
-      let entries = [];
-      for (let extPath of manifest.extensions) {
-        let resolvedExtPath = path.resolve(dir, extPath);
-        fs.existsSync(resolvedExtPath) && entries.push(resolvedExtPath);
-      }
-      if (entries.length > 0)
-        return entries;
-    }
-  }
-  let indexTs = path.join(dir, "index.ts"), indexJs = path.join(dir, "index.js");
-  return fs.existsSync(indexTs) ? [indexTs] : fs.existsSync(indexJs) ? [indexJs] : null;
-}
-function discoverExtensionsInDir(dir) {
-  if (!fs.existsSync(dir))
-    return [];
-  let discovered = [];
-  try {
-    let entries = fs.readdirSync(dir, { withFileTypes: !0 });
-    for (let entry of entries) {
-      let entryPath = path.join(dir, entry.name);
-      if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
-        discovered.push(entryPath);
-        continue;
-      }
-      if (entry.isDirectory() || entry.isSymbolicLink()) {
-        let entries2 = resolveExtensionEntries(entryPath);
-        entries2 && discovered.push(...entries2);
-      }
-    }
-  } catch {
-    return [];
-  }
-  return discovered;
-}
-async function discoverAndLoadExtensions(configuredPaths, cwd, agentDir = getAgentDir(), eventBus) {
-  let resolvedCwd = resolvePath(cwd), resolvedAgentDir = resolvePath(agentDir), allPaths = [], seen = /* @__PURE__ */ new Set(), addPaths = (paths) => {
-    for (let p of paths) {
-      let resolved = path.resolve(p);
-      seen.has(resolved) || (seen.add(resolved), allPaths.push(p));
-    }
-  }, localExtDir = path.join(resolvedCwd, CONFIG_DIR_NAME, "extensions");
-  addPaths(discoverExtensionsInDir(localExtDir));
-  let globalExtDir = path.join(resolvedAgentDir, "extensions");
-  addPaths(discoverExtensionsInDir(globalExtDir));
-  for (let p of configuredPaths) {
-    let resolved = resolvePath(p, resolvedCwd, { normalizeUnicodeSpaces: !0 });
-    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
-      let entries = resolveExtensionEntries(resolved);
-      if (entries) {
-        addPaths(entries);
-        continue;
-      }
-      addPaths(discoverExtensionsInDir(resolved));
-      continue;
-    }
-    addPaths([resolved]);
-  }
-  return loadExtensions(allPaths, resolvedCwd, eventBus);
-}
-
 // packages/coding-agent/dist/utils/git.js
 var import_hosted_git_info = __toESM(require_lib(), 1);
 function splitRef(url) {
@@ -1785,23 +1353,23 @@ function buildGitSource(args) {
   };
 }
 function parseGenericGitUrl(url) {
-  let { repo: repoWithoutRef, ref } = splitRef(url), repo = repoWithoutRef, host = "", path2 = "", scpLikeMatch = repoWithoutRef.match(/^git@([^:]+):(.+)$/);
+  let { repo: repoWithoutRef, ref } = splitRef(url), repo = repoWithoutRef, host = "", path = "", scpLikeMatch = repoWithoutRef.match(/^git@([^:]+):(.+)$/);
   if (scpLikeMatch)
-    host = scpLikeMatch[1] ?? "", path2 = scpLikeMatch[2] ?? "";
+    host = scpLikeMatch[1] ?? "", path = scpLikeMatch[2] ?? "";
   else if (repoWithoutRef.startsWith("https://") || repoWithoutRef.startsWith("http://") || repoWithoutRef.startsWith("ssh://") || repoWithoutRef.startsWith("git://"))
     try {
       let parsed = new URL(repoWithoutRef);
-      host = parsed.hostname, path2 = parsed.pathname.replace(/^\/+/, "");
+      host = parsed.hostname, path = parsed.pathname.replace(/^\/+/, "");
     } catch {
       return null;
     }
   else {
     let slashIndex = repoWithoutRef.indexOf("/");
-    if (slashIndex < 0 || (host = repoWithoutRef.slice(0, slashIndex), path2 = repoWithoutRef.slice(slashIndex + 1), !host.includes(".") && host !== "localhost"))
+    if (slashIndex < 0 || (host = repoWithoutRef.slice(0, slashIndex), path = repoWithoutRef.slice(slashIndex + 1), !host.includes(".") && host !== "localhost"))
       return null;
     repo = `https://${repoWithoutRef}`;
   }
-  return buildGitSource({ repo, host, path: path2, ref });
+  return buildGitSource({ repo, host, path, ref });
 }
 function parseGitUrl(source) {
   let trimmed = source.trim(), hasGitPrefix = trimmed.startsWith("git:"), url = hasGitPrefix ? trimmed.slice(4).trim() : trimmed;
@@ -1841,9 +1409,9 @@ function parseGitUrl(source) {
 
 // packages/coding-agent/dist/core/package-manager.js
 import { createHash } from "node:crypto";
-import { chmodSync, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync, statSync as statSync2, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname as dirname2, join as join2, relative, resolve as resolve2, sep } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 
 // node_modules/glob/dist/esm/index.min.js
 import { fileURLToPath as Wi } from "node:url";
@@ -1876,12 +1444,12 @@ var Gt = (n7, t, e) => {
     s.length && o !== void 0 && (h = [r, o]);
   }
   return h;
-}, fe = "\0SLASH" + Math.random() + "\0", ue = "\0OPEN" + Math.random() + "\0", qt = "\0CLOSE" + Math.random() + "\0", de = "\0COMMA" + Math.random() + "\0", pe = "\0PERIOD" + Math.random() + "\0", is = new RegExp(fe, "g"), rs = new RegExp(ue, "g"), ns = new RegExp(qt, "g"), os = new RegExp(de, "g"), hs = new RegExp(pe, "g"), as = /\\\\/g, ls = /\\{/g, cs = /\\}/g, fs2 = /\\,/g, us = /\\./g, ds = 1e5;
+}, fe = "\0SLASH" + Math.random() + "\0", ue = "\0OPEN" + Math.random() + "\0", qt = "\0CLOSE" + Math.random() + "\0", de = "\0COMMA" + Math.random() + "\0", pe = "\0PERIOD" + Math.random() + "\0", is = new RegExp(fe, "g"), rs = new RegExp(ue, "g"), ns = new RegExp(qt, "g"), os = new RegExp(de, "g"), hs = new RegExp(pe, "g"), as = /\\\\/g, ls = /\\{/g, cs = /\\}/g, fs = /\\,/g, us = /\\./g, ds = 1e5;
 function Ht(n7) {
   return isNaN(n7) ? n7.charCodeAt(0) : parseInt(n7, 10);
 }
 function ps(n7) {
-  return n7.replace(as, fe).replace(ls, ue).replace(cs, qt).replace(fs2, de).replace(us, pe);
+  return n7.replace(as, fe).replace(ls, ue).replace(cs, qt).replace(fs, de).replace(us, pe);
 }
 function ms(n7) {
   return n7.replace(is, "\\").replace(rs, "{").replace(ns, "}").replace(os, ",").replace(hs, ".");
@@ -4650,7 +4218,7 @@ function getEnv() {
   if (process.platform !== "linux" || Object.keys(process.env).length > 0)
     return process.env;
   try {
-    let data = readFileSync2("/proc/self/environ", "utf-8"), env = {};
+    let data = readFileSync("/proc/self/environ", "utf-8"), env = {};
     for (let entry of data.split("\0")) {
       let idx = entry.indexOf("=");
       idx > 0 && (env[entry.slice(0, idx)] = entry.slice(idx + 1));
@@ -4687,7 +4255,7 @@ function getHomeDir() {
   return process.env.HOME || homedir();
 }
 function getExtensionTempFolder(agentDir) {
-  let tempFolder = join2(agentDir, "tmp", "extensions");
+  let tempFolder = join(agentDir, "tmp", "extensions");
   return mkdirSync(tempFolder, { recursive: !0, mode: 448 }), chmodSync(tempFolder, 448), tempFolder;
 }
 function prefixIgnorePattern(line, prefix) {
@@ -4702,10 +4270,10 @@ function prefixIgnorePattern(line, prefix) {
 function addIgnoreRules(ig, dir, rootDir) {
   let relativeDir = relative(rootDir, dir), prefix = relativeDir ? `${toPosixPath(relativeDir)}/` : "";
   for (let filename of IGNORE_FILE_NAMES) {
-    let ignorePath = join2(dir, filename);
-    if (existsSync2(ignorePath))
+    let ignorePath = join(dir, filename);
+    if (existsSync(ignorePath))
       try {
-        let patterns = readFileSync2(ignorePath, "utf-8").split(/\r?\n/).map((line) => prefixIgnorePattern(line, prefix)).filter((line) => !!line);
+        let patterns = readFileSync(ignorePath, "utf-8").split(/\r?\n/).map((line) => prefixIgnorePattern(line, prefix)).filter((line) => !!line);
         patterns.length > 0 && ig.add(patterns);
       } catch {
       }
@@ -4728,19 +4296,19 @@ function splitPatterns(entries) {
 }
 function collectFiles(dir, filePattern, skipNodeModules = !0, ignoreMatcher, rootDir) {
   let files = [];
-  if (!existsSync2(dir))
+  if (!existsSync(dir))
     return files;
   let root = rootDir ?? dir, ig = ignoreMatcher ?? (0, import_ignore.default)();
   addIgnoreRules(ig, dir, root);
   try {
-    let entries = readdirSync2(dir, { withFileTypes: !0 });
+    let entries = readdirSync(dir, { withFileTypes: !0 });
     for (let entry of entries) {
       if (entry.name.startsWith(".") || skipNodeModules && entry.name === "node_modules")
         continue;
-      let fullPath = join2(dir, entry.name), isDir = entry.isDirectory(), isFile = entry.isFile();
+      let fullPath = join(dir, entry.name), isDir = entry.isDirectory(), isFile = entry.isFile();
       if (entry.isSymbolicLink())
         try {
-          let stats = statSync2(fullPath);
+          let stats = statSync(fullPath);
           isDir = stats.isDirectory(), isFile = stats.isFile();
         } catch {
           continue;
@@ -4754,19 +4322,19 @@ function collectFiles(dir, filePattern, skipNodeModules = !0, ignoreMatcher, roo
 }
 function collectSkillEntries(dir, mode, ignoreMatcher, rootDir) {
   let entries = [];
-  if (!existsSync2(dir))
+  if (!existsSync(dir))
     return entries;
   let root = rootDir ?? dir, ig = ignoreMatcher ?? (0, import_ignore.default)();
   addIgnoreRules(ig, dir, root);
   try {
-    let dirEntries = readdirSync2(dir, { withFileTypes: !0 });
+    let dirEntries = readdirSync(dir, { withFileTypes: !0 });
     for (let entry of dirEntries) {
       if (entry.name !== "SKILL.md")
         continue;
-      let fullPath = join2(dir, entry.name), isFile = entry.isFile();
+      let fullPath = join(dir, entry.name), isFile = entry.isFile();
       if (entry.isSymbolicLink())
         try {
-          isFile = statSync2(fullPath).isFile();
+          isFile = statSync(fullPath).isFile();
         } catch {
           continue;
         }
@@ -4777,10 +4345,10 @@ function collectSkillEntries(dir, mode, ignoreMatcher, rootDir) {
     for (let entry of dirEntries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
-      let fullPath = join2(dir, entry.name), isDir = entry.isDirectory(), isFile = entry.isFile();
+      let fullPath = join(dir, entry.name), isDir = entry.isDirectory(), isFile = entry.isFile();
       if (entry.isSymbolicLink())
         try {
-          let stats = statSync2(fullPath);
+          let stats = statSync(fullPath);
           isDir = stats.isDirectory(), isFile = stats.isFile();
         } catch {
           continue;
@@ -4800,20 +4368,20 @@ function collectAutoSkillEntries(dir, mode) {
   return collectSkillEntries(dir, mode);
 }
 function findGitRepoRoot(startDir) {
-  let dir = resolve2(startDir);
+  let dir = resolve(startDir);
   for (; ; ) {
-    if (existsSync2(join2(dir, ".git")))
+    if (existsSync(join(dir, ".git")))
       return dir;
-    let parent = dirname2(dir);
+    let parent = dirname(dir);
     if (parent === dir)
       return null;
     dir = parent;
   }
 }
 function collectAncestorAgentsSkillDirs(startDir) {
-  let skillDirs = [], resolvedStartDir = resolve2(startDir), gitRepoRoot = findGitRepoRoot(resolvedStartDir), dir = resolvedStartDir;
-  for (; skillDirs.push(join2(dir, ".agents", "skills")), !(gitRepoRoot && dir === gitRepoRoot); ) {
-    let parent = dirname2(dir);
+  let skillDirs = [], resolvedStartDir = resolve(startDir), gitRepoRoot = findGitRepoRoot(resolvedStartDir), dir = resolvedStartDir;
+  for (; skillDirs.push(join(dir, ".agents", "skills")), !(gitRepoRoot && dir === gitRepoRoot); ) {
+    let parent = dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -4822,19 +4390,19 @@ function collectAncestorAgentsSkillDirs(startDir) {
 }
 function collectAutoPromptEntries(dir) {
   let entries = [];
-  if (!existsSync2(dir))
+  if (!existsSync(dir))
     return entries;
   let ig = (0, import_ignore.default)();
   addIgnoreRules(ig, dir, dir);
   try {
-    let dirEntries = readdirSync2(dir, { withFileTypes: !0 });
+    let dirEntries = readdirSync(dir, { withFileTypes: !0 });
     for (let entry of dirEntries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
-      let fullPath = join2(dir, entry.name), isFile = entry.isFile();
+      let fullPath = join(dir, entry.name), isFile = entry.isFile();
       if (entry.isSymbolicLink())
         try {
-          isFile = statSync2(fullPath).isFile();
+          isFile = statSync(fullPath).isFile();
         } catch {
           continue;
         }
@@ -4847,19 +4415,19 @@ function collectAutoPromptEntries(dir) {
 }
 function collectAutoThemeEntries(dir) {
   let entries = [];
-  if (!existsSync2(dir))
+  if (!existsSync(dir))
     return entries;
   let ig = (0, import_ignore.default)();
   addIgnoreRules(ig, dir, dir);
   try {
-    let dirEntries = readdirSync2(dir, { withFileTypes: !0 });
+    let dirEntries = readdirSync(dir, { withFileTypes: !0 });
     for (let entry of dirEntries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
-      let fullPath = join2(dir, entry.name), isFile = entry.isFile();
+      let fullPath = join(dir, entry.name), isFile = entry.isFile();
       if (entry.isSymbolicLink())
         try {
-          isFile = statSync2(fullPath).isFile();
+          isFile = statSync(fullPath).isFile();
         } catch {
           continue;
         }
@@ -4872,47 +4440,47 @@ function collectAutoThemeEntries(dir) {
 }
 function readPiManifestFile(packageJsonPath) {
   try {
-    let content = readFileSync2(packageJsonPath, "utf-8");
+    let content = readFileSync(packageJsonPath, "utf-8");
     return JSON.parse(content).pi ?? null;
   } catch {
     return null;
   }
 }
-function resolveExtensionEntries2(dir) {
-  let packageJsonPath = join2(dir, "package.json");
-  if (existsSync2(packageJsonPath)) {
+function resolveExtensionEntries(dir) {
+  let packageJsonPath = join(dir, "package.json");
+  if (existsSync(packageJsonPath)) {
     let manifest = readPiManifestFile(packageJsonPath);
     if (manifest?.extensions?.length) {
       let entries = [];
       for (let extPath of manifest.extensions) {
-        let resolvedExtPath = resolve2(dir, extPath);
-        existsSync2(resolvedExtPath) && entries.push(resolvedExtPath);
+        let resolvedExtPath = resolve(dir, extPath);
+        existsSync(resolvedExtPath) && entries.push(resolvedExtPath);
       }
       if (entries.length > 0)
         return entries;
     }
   }
-  let indexTs = join2(dir, "index.ts"), indexJs = join2(dir, "index.js");
-  return existsSync2(indexTs) ? [indexTs] : existsSync2(indexJs) ? [indexJs] : null;
+  let indexTs = join(dir, "index.ts"), indexJs = join(dir, "index.js");
+  return existsSync(indexTs) ? [indexTs] : existsSync(indexJs) ? [indexJs] : null;
 }
 function collectAutoExtensionEntries(dir) {
   let entries = [];
-  if (!existsSync2(dir))
+  if (!existsSync(dir))
     return entries;
-  let rootEntries = resolveExtensionEntries2(dir);
+  let rootEntries = resolveExtensionEntries(dir);
   if (rootEntries)
     return rootEntries;
   let ig = (0, import_ignore.default)();
   addIgnoreRules(ig, dir, dir);
   try {
-    let dirEntries = readdirSync2(dir, { withFileTypes: !0 });
+    let dirEntries = readdirSync(dir, { withFileTypes: !0 });
     for (let entry of dirEntries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
-      let fullPath = join2(dir, entry.name), isDir = entry.isDirectory(), isFile = entry.isFile();
+      let fullPath = join(dir, entry.name), isDir = entry.isDirectory(), isFile = entry.isFile();
       if (entry.isSymbolicLink())
         try {
-          let stats = statSync2(fullPath);
+          let stats = statSync(fullPath);
           isDir = stats.isDirectory(), isFile = stats.isFile();
         } catch {
           continue;
@@ -4922,7 +4490,7 @@ function collectAutoExtensionEntries(dir) {
         if (isFile && (entry.name.endsWith(".ts") || entry.name.endsWith(".js")))
           entries.push(fullPath);
         else if (isDir) {
-          let resolvedEntries = resolveExtensionEntries2(fullPath);
+          let resolvedEntries = resolveExtensionEntries(fullPath);
           resolvedEntries && entries.push(...resolvedEntries);
         }
       }
@@ -4935,7 +4503,7 @@ function collectResourceFiles(dir, resourceType) {
   return resourceType === "skills" ? collectSkillEntries(dir, "pi") : resourceType === "extensions" ? collectAutoExtensionEntries(dir) : collectFiles(dir, FILE_PATTERNS[resourceType]);
 }
 function matchesAnyPattern(filePath, patterns, baseDir) {
-  let rel = toPosixPath(relative(baseDir, filePath)), name = basename(filePath), filePathPosix = toPosixPath(filePath), isSkillFile = name === "SKILL.md", parentDir = isSkillFile ? dirname2(filePath) : void 0, parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : void 0, parentName = isSkillFile ? basename(parentDir) : void 0, parentDirPosix = isSkillFile ? toPosixPath(parentDir) : void 0;
+  let rel = toPosixPath(relative(baseDir, filePath)), name = basename(filePath), filePathPosix = toPosixPath(filePath), isSkillFile = name === "SKILL.md", parentDir = isSkillFile ? dirname(filePath) : void 0, parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : void 0, parentName = isSkillFile ? basename(parentDir) : void 0, parentDirPosix = isSkillFile ? toPosixPath(parentDir) : void 0;
   return patterns.some((pattern) => {
     let normalizedPattern = toPosixPath(pattern);
     return minimatch(rel, normalizedPattern) || minimatch(name, normalizedPattern) || minimatch(filePathPosix, normalizedPattern) ? !0 : isSkillFile ? minimatch(parentRel, normalizedPattern) || minimatch(parentName, normalizedPattern) || minimatch(parentDirPosix, normalizedPattern) : !1;
@@ -4948,7 +4516,7 @@ function normalizeExactPattern(pattern) {
 function matchesAnyExactPattern(filePath, patterns, baseDir) {
   if (patterns.length === 0)
     return !1;
-  let rel = toPosixPath(relative(baseDir, filePath)), name = basename(filePath), filePathPosix = toPosixPath(filePath), isSkillFile = name === "SKILL.md", parentDir = isSkillFile ? dirname2(filePath) : void 0, parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : void 0, parentDirPosix = isSkillFile ? toPosixPath(parentDir) : void 0;
+  let rel = toPosixPath(relative(baseDir, filePath)), name = basename(filePath), filePathPosix = toPosixPath(filePath), isSkillFile = name === "SKILL.md", parentDir = isSkillFile ? dirname(filePath) : void 0, parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : void 0, parentDirPosix = isSkillFile ? toPosixPath(parentDir) : void 0;
   return patterns.some((pattern) => {
     let normalized = normalizeExactPattern(pattern);
     return normalized === rel || normalized === filePathPosix ? !0 : isSkillFile ? normalized === parentRel || normalized === parentDirPosix : !1;
@@ -5012,16 +4580,16 @@ var DefaultPackageManager = class {
   getInstalledPath(source, scope) {
     let parsed = this.parseSource(source);
     if (parsed.type === "npm") {
-      let path2 = this.getNpmInstallPath(parsed, scope);
-      return existsSync2(path2) ? path2 : void 0;
+      let path = this.getNpmInstallPath(parsed, scope);
+      return existsSync(path) ? path : void 0;
     }
     if (parsed.type === "git") {
-      let path2 = this.getGitInstallPath(parsed, scope);
-      return existsSync2(path2) ? path2 : void 0;
+      let path = this.getGitInstallPath(parsed, scope);
+      return existsSync(path) ? path : void 0;
     }
     if (parsed.type === "local") {
-      let baseDir = this.getBaseDirForScope(scope), path2 = this.resolvePathFromBase(parsed.path, baseDir);
-      return existsSync2(path2) ? path2 : void 0;
+      let baseDir = this.getBaseDirForScope(scope), path = this.resolvePathFromBase(parsed.path, baseDir);
+      return existsSync(path) ? path : void 0;
     }
   }
   emitProgress(event) {
@@ -5044,7 +4612,7 @@ var DefaultPackageManager = class {
       allPackages.push({ pkg, scope: "user" });
     let packageSources = this.dedupePackages(allPackages);
     await this.resolvePackageSources(packageSources, accumulator, onMissing);
-    let globalBaseDir = this.agentDir, projectBaseDir = join2(this.cwd, CONFIG_DIR_NAME);
+    let globalBaseDir = this.agentDir, projectBaseDir = join(this.cwd, CONFIG_DIR_NAME);
     for (let resourceType of RESOURCE_TYPES) {
       let target = this.getTargetMap(accumulator, resourceType), globalEntries = globalSettings[resourceType] ?? [], projectEntries = projectSettings[resourceType] ?? [];
       this.resolveLocalEntries(projectEntries, resourceType, target, {
@@ -5098,7 +4666,7 @@ var DefaultPackageManager = class {
       }
       if (parsed.type === "local") {
         let resolved = this.resolvePath(parsed.path);
-        if (!existsSync2(resolved))
+        if (!existsSync(resolved))
           throw new Error(`Path does not exist: ${resolved}`);
         return;
       }
@@ -5168,7 +4736,7 @@ var DefaultPackageManager = class {
     await Promise.all(tasks);
   }
   async shouldUpdateNpmSource(source, scope) {
-    let installedPath = this.getManagedNpmInstallPath(source, scope), installedVersion = existsSync2(installedPath) ? this.getInstalledNpmVersion(installedPath) : void 0;
+    let installedPath = this.getManagedNpmInstallPath(source, scope), installedVersion = existsSync(installedPath) ? this.getInstalledNpmVersion(installedPath) : void 0;
     if (!installedVersion)
       return !0;
     try {
@@ -5211,7 +4779,7 @@ var DefaultPackageManager = class {
       };
       if (parsed.type === "npm") {
         let installedPath = this.getNpmInstallPath(parsed, resolvedScope);
-        if (!existsSync2(installedPath) || !await this.installedNpmMatchesConfiguredVersion(parsed, installedPath)) {
+        if (!existsSync(installedPath) || !await this.installedNpmMatchesConfiguredVersion(parsed, installedPath)) {
           if (!await installMissing())
             continue;
           installedPath = this.getNpmInstallPath(parsed, resolvedScope);
@@ -5221,7 +4789,7 @@ var DefaultPackageManager = class {
       }
       if (parsed.type === "git") {
         let installedPath = this.getGitInstallPath(parsed, resolvedScope);
-        if (existsSync2(installedPath))
+        if (existsSync(installedPath))
           resolvedScope === "temporary" && !parsed.pinned && !isOfflineModeEnabled() && await this.refreshTemporaryGitSource(parsed, resolvedSource);
         else if (!await installMissing())
           continue;
@@ -5237,11 +4805,11 @@ var DefaultPackageManager = class {
   }
   resolveLocalExtensionSource(source, accumulator, filter, metadata, baseDir) {
     let resolved = this.resolvePathFromBase(source.path, baseDir);
-    if (existsSync2(resolved))
+    if (existsSync(resolved))
       try {
-        let stats = statSync2(resolved);
+        let stats = statSync(resolved);
         if (stats.isFile()) {
-          metadata.baseDir = dirname2(resolved), this.addResource(accumulator.extensions, resolved, metadata, !0);
+          metadata.baseDir = dirname(resolved), this.addResource(accumulator.extensions, resolved, metadata, !0);
           return;
         }
         stats.isDirectory() && (metadata.baseDir = resolved, this.collectPackageResources(resolved, accumulator, filter, metadata) || this.addResource(accumulator.extensions, resolved, metadata, !0));
@@ -5327,10 +4895,10 @@ var DefaultPackageManager = class {
     return installedVersion ? source.range ? (0, import_semver.satisfies)(installedVersion, source.range) : !0 : !1;
   }
   getInstalledNpmVersion(installedPath) {
-    let packageJsonPath = join2(installedPath, "package.json");
-    if (existsSync2(packageJsonPath))
+    let packageJsonPath = join(installedPath, "package.json");
+    if (existsSync(packageJsonPath))
       try {
-        let content = readFileSync2(packageJsonPath, "utf-8");
+        let content = readFileSync(packageJsonPath, "utf-8");
         return JSON.parse(content).version;
       } catch {
         return;
@@ -5508,7 +5076,7 @@ var DefaultPackageManager = class {
   }
   async uninstallNpm(source, scope) {
     let installRoot = this.getNpmInstallRoot(scope, !1);
-    if (!existsSync2(installRoot))
+    if (!existsSync(installRoot))
       return;
     let packageManagerName = this.getPackageManagerName();
     if (packageManagerName === "bun") {
@@ -5520,7 +5088,7 @@ var DefaultPackageManager = class {
   }
   async installGit(source, scope) {
     let targetDir = this.getGitInstallPath(source, scope);
-    if (existsSync2(targetDir)) {
+    if (existsSync(targetDir)) {
       if (source.ref) {
         await this.ensureGitRef(targetDir, ["fetch", "origin", source.ref], "FETCH_HEAD");
         return;
@@ -5530,16 +5098,16 @@ var DefaultPackageManager = class {
       return;
     }
     let gitRoot = this.getGitInstallRoot(scope);
-    gitRoot && this.ensureGitIgnore(gitRoot), mkdirSync(dirname2(targetDir), { recursive: !0 }), await this.runCommand("git", ["clone", source.repo, targetDir], { timeoutMs: PACKAGE_INSTALL_TIMEOUT_MS }), source.ref && await this.runCommand("git", ["checkout", source.ref], {
+    gitRoot && this.ensureGitIgnore(gitRoot), mkdirSync(dirname(targetDir), { recursive: !0 }), await this.runCommand("git", ["clone", source.repo, targetDir], { timeoutMs: PACKAGE_INSTALL_TIMEOUT_MS }), source.ref && await this.runCommand("git", ["checkout", source.ref], {
       cwd: targetDir,
       timeoutMs: PACKAGE_INSTALL_TIMEOUT_MS
     });
-    let packageJsonPath = join2(targetDir, "package.json");
-    existsSync2(packageJsonPath) && await this.runNpmCommand(this.getGitDependencyInstallArgs(), { cwd: targetDir });
+    let packageJsonPath = join(targetDir, "package.json");
+    existsSync(packageJsonPath) && await this.runNpmCommand(this.getGitDependencyInstallArgs(), { cwd: targetDir });
   }
   async updateGit(source, scope) {
     let targetDir = this.getGitInstallPath(source, scope);
-    if (!existsSync2(targetDir)) {
+    if (!existsSync(targetDir)) {
       await this.installGit(source, scope);
       return;
     }
@@ -5562,8 +5130,8 @@ var DefaultPackageManager = class {
     if (localHead.trim() === targetHead.trim())
       return;
     await this.runCommand("git", ["reset", "--hard", commitRef], { cwd: targetDir }), await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
-    let packageJsonPath = join2(targetDir, "package.json");
-    existsSync2(packageJsonPath) && await this.runNpmCommand(this.getGitDependencyInstallArgs(), { cwd: targetDir });
+    let packageJsonPath = join(targetDir, "package.json");
+    existsSync(packageJsonPath) && await this.runNpmCommand(this.getGitDependencyInstallArgs(), { cwd: targetDir });
   }
   async refreshTemporaryGitSource(source, sourceStr) {
     if (!isOfflineModeEnabled())
@@ -5576,41 +5144,41 @@ var DefaultPackageManager = class {
   }
   async removeGit(source, scope) {
     let targetDir = this.getGitInstallPath(source, scope);
-    existsSync2(targetDir) && (rmSync(targetDir, { recursive: !0, force: !0 }), this.pruneEmptyGitParents(targetDir, this.getGitInstallRoot(scope)));
+    existsSync(targetDir) && (rmSync(targetDir, { recursive: !0, force: !0 }), this.pruneEmptyGitParents(targetDir, this.getGitInstallRoot(scope)));
   }
   pruneEmptyGitParents(targetDir, installRoot) {
     if (!installRoot)
       return;
-    let resolvedRoot = resolve2(installRoot), current = dirname2(targetDir);
+    let resolvedRoot = resolve(installRoot), current = dirname(targetDir);
     for (; current.startsWith(resolvedRoot) && current !== resolvedRoot; ) {
-      if (!existsSync2(current)) {
-        current = dirname2(current);
+      if (!existsSync(current)) {
+        current = dirname(current);
         continue;
       }
-      if (readdirSync2(current).length > 0)
+      if (readdirSync(current).length > 0)
         break;
       try {
         rmSync(current, { recursive: !0, force: !0 });
       } catch {
         break;
       }
-      current = dirname2(current);
+      current = dirname(current);
     }
   }
   ensureNpmProject(installRoot) {
-    existsSync2(installRoot) || mkdirSync(installRoot, { recursive: !0 }), markPathIgnoredByCloudSync(installRoot), this.ensureGitIgnore(installRoot);
-    let packageJsonPath = join2(installRoot, "package.json");
-    existsSync2(packageJsonPath) || writeFileSync(packageJsonPath, JSON.stringify({ name: "pi-extensions", private: !0 }, null, 2), "utf-8");
+    existsSync(installRoot) || mkdirSync(installRoot, { recursive: !0 }), markPathIgnoredByCloudSync(installRoot), this.ensureGitIgnore(installRoot);
+    let packageJsonPath = join(installRoot, "package.json");
+    existsSync(packageJsonPath) || writeFileSync(packageJsonPath, JSON.stringify({ name: "pi-extensions", private: !0 }, null, 2), "utf-8");
   }
   ensureGitIgnore(dir) {
-    existsSync2(dir) || mkdirSync(dir, { recursive: !0 });
-    let ignorePath = join2(dir, ".gitignore");
-    existsSync2(ignorePath) || writeFileSync(ignorePath, `*
+    existsSync(dir) || mkdirSync(dir, { recursive: !0 });
+    let ignorePath = join(dir, ".gitignore");
+    existsSync(ignorePath) || writeFileSync(ignorePath, `*
 !.gitignore
 `, "utf-8");
   }
   getNpmInstallRoot(scope, temporary) {
-    return temporary ? this.getTemporaryDir("npm") : scope === "project" ? (this.assertProjectTrustedForScope(scope), join2(this.cwd, CONFIG_DIR_NAME, "npm")) : join2(this.agentDir, "npm");
+    return temporary ? this.getTemporaryDir("npm") : scope === "project" ? (this.assertProjectTrustedForScope(scope), join(this.cwd, CONFIG_DIR_NAME, "npm")) : join(this.agentDir, "npm");
   }
   getGlobalNpmRoot() {
     let npmCommand = this.getNpmCommand(), commandKey = [npmCommand.command, ...npmCommand.args].join("\0");
@@ -5618,7 +5186,7 @@ var DefaultPackageManager = class {
       return this.globalNpmRoot;
     if (this.getPackageManagerName() === "bun") {
       let binDir = this.runNpmCommandSync(["pm", "bin", "-g"]).trim();
-      this.globalNpmRoot = join2(dirname2(binDir), "install", "global", "node_modules");
+      this.globalNpmRoot = join(dirname(binDir), "install", "global", "node_modules");
     } else
       this.globalNpmRoot = this.runNpmCommandSync(["root", "-g"]).trim();
     return this.globalNpmRootCommandKey = commandKey, this.globalNpmRoot;
@@ -5628,27 +5196,27 @@ var DefaultPackageManager = class {
       return;
     let output = this.runNpmCommandSync(["list", "-g", "--depth", "0", "--json"]), entries = JSON.parse(output);
     for (let entry of entries) {
-      let path2 = entry.dependencies?.[packageName]?.path;
-      if (path2)
-        return path2;
+      let path = entry.dependencies?.[packageName]?.path;
+      if (path)
+        return path;
     }
   }
   getManagedNpmInstallPath(source, scope) {
-    return scope === "temporary" ? join2(this.getTemporaryDir("npm"), "node_modules", source.name) : scope === "project" ? (this.assertProjectTrustedForScope(scope), join2(this.cwd, CONFIG_DIR_NAME, "npm", "node_modules", source.name)) : join2(this.agentDir, "npm", "node_modules", source.name);
+    return scope === "temporary" ? join(this.getTemporaryDir("npm"), "node_modules", source.name) : scope === "project" ? (this.assertProjectTrustedForScope(scope), join(this.cwd, CONFIG_DIR_NAME, "npm", "node_modules", source.name)) : join(this.agentDir, "npm", "node_modules", source.name);
   }
   getLegacyGlobalNpmInstallPath(source) {
     try {
-      return this.getPnpmGlobalPackagePath(source.name) ?? join2(this.getGlobalNpmRoot(), source.name);
+      return this.getPnpmGlobalPackagePath(source.name) ?? join(this.getGlobalNpmRoot(), source.name);
     } catch {
       return;
     }
   }
   getNpmInstallPath(source, scope) {
     let managedPath = this.getManagedNpmInstallPath(source, scope);
-    if (scope !== "user" || existsSync2(managedPath))
+    if (scope !== "user" || existsSync(managedPath))
       return managedPath;
     let legacyPath = this.getLegacyGlobalNpmInstallPath(source);
-    return legacyPath && existsSync2(legacyPath) ? legacyPath : managedPath;
+    return legacyPath && existsSync(legacyPath) ? legacyPath : managedPath;
   }
   getGitInstallPath(source, scope) {
     if (scope === "temporary")
@@ -5660,20 +5228,20 @@ var DefaultPackageManager = class {
   }
   getGitInstallRoot(scope) {
     if (scope !== "temporary")
-      return scope === "project" ? (this.assertProjectTrustedForScope(scope), join2(this.cwd, CONFIG_DIR_NAME, "git")) : join2(this.agentDir, "git");
+      return scope === "project" ? (this.assertProjectTrustedForScope(scope), join(this.cwd, CONFIG_DIR_NAME, "git")) : join(this.agentDir, "git");
   }
   getTemporaryDir(prefix, suffix) {
     let root = this.resolveManagedPath(getExtensionTempFolder(this.agentDir), prefix), hash = createHash("sha256").update(`${prefix}-${suffix ?? ""}`).digest("hex").slice(0, 8);
     return this.resolveManagedPath(root, hash, suffix ?? "");
   }
   resolveManagedPath(root, ...parts) {
-    let resolvedRoot = resolve2(root), resolvedPath = resolve2(resolvedRoot, ...parts);
+    let resolvedRoot = resolve(root), resolvedPath = resolve(resolvedRoot, ...parts);
     if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${sep}`))
       throw new Error(`Refusing to use path outside package install root: ${resolvedPath}`);
     return resolvedPath;
   }
   getBaseDirForScope(scope) {
-    return scope === "project" ? (this.assertProjectTrustedForScope(scope), join2(this.cwd, CONFIG_DIR_NAME)) : scope === "user" ? this.agentDir : this.cwd;
+    return scope === "project" ? (this.assertProjectTrustedForScope(scope), join(this.cwd, CONFIG_DIR_NAME)) : scope === "user" ? this.agentDir : this.cwd;
   }
   resolvePath(input) {
     return resolvePath(input, this.cwd, { homeDir: getHomeDir(), trim: !0 });
@@ -5699,8 +5267,8 @@ var DefaultPackageManager = class {
     }
     let hasAnyDir = !1;
     for (let resourceType of RESOURCE_TYPES) {
-      let dir = join2(packageRoot, resourceType);
-      if (existsSync2(dir)) {
+      let dir = join(packageRoot, resourceType);
+      if (existsSync(dir)) {
         let files = collectResourceFiles(dir, resourceType);
         for (let f of files)
           this.addResource(this.getTargetMap(accumulator, resourceType), f, metadata, !0);
@@ -5715,8 +5283,8 @@ var DefaultPackageManager = class {
       this.addManifestEntries(entries, packageRoot, resourceType, target, metadata);
       return;
     }
-    let dir = join2(packageRoot, resourceType);
-    if (existsSync2(dir)) {
+    let dir = join(packageRoot, resourceType);
+    if (existsSync(dir)) {
       let files = collectResourceFiles(dir, resourceType);
       for (let f of files)
         this.addResource(target, f, metadata, !0);
@@ -5753,18 +5321,18 @@ var DefaultPackageManager = class {
       let allFiles2 = this.collectFilesFromManifestEntries(entries, packageRoot, resourceType), manifestPatterns = entries.filter(isOverridePattern), enabledByManifest = manifestPatterns.length > 0 ? applyPatterns(allFiles2, manifestPatterns, packageRoot) : new Set(allFiles2);
       return { allFiles: Array.from(enabledByManifest), enabledByManifest };
     }
-    let conventionDir = join2(packageRoot, resourceType);
-    if (!existsSync2(conventionDir))
+    let conventionDir = join(packageRoot, resourceType);
+    if (!existsSync(conventionDir))
       return { allFiles: [], enabledByManifest: /* @__PURE__ */ new Set() };
     let allFiles = collectResourceFiles(conventionDir, resourceType);
     return { allFiles, enabledByManifest: new Set(allFiles) };
   }
   readPiManifest(packageRoot) {
-    let packageJsonPath = join2(packageRoot, "package.json");
-    if (!existsSync2(packageJsonPath))
+    let packageJsonPath = join(packageRoot, "package.json");
+    if (!existsSync(packageJsonPath))
       return null;
     try {
-      let content = readFileSync2(packageJsonPath, "utf-8");
+      let content = readFileSync(packageJsonPath, "utf-8");
       return JSON.parse(content).pi ?? null;
     } catch {
       return null;
@@ -5783,7 +5351,7 @@ var DefaultPackageManager = class {
       absolute: !0,
       dot: !1,
       nodir: !1
-    }).map((match) => resolve2(match)) : [resolve2(root, entry)]);
+    }).map((match) => resolve(match)) : [resolve(root, entry)]);
     return this.collectFilesFromPaths(resolved, resourceType);
   }
   resolveLocalEntries(entries, resourceType, target, metadata, baseDir) {
@@ -5815,32 +5383,32 @@ var DefaultPackageManager = class {
       prompts: projectSettings.prompts ?? [],
       themes: projectSettings.themes ?? []
     }, userDirs = {
-      extensions: join2(globalBaseDir, "extensions"),
-      skills: join2(globalBaseDir, "skills"),
-      prompts: join2(globalBaseDir, "prompts"),
-      themes: join2(globalBaseDir, "themes")
+      extensions: join(globalBaseDir, "extensions"),
+      skills: join(globalBaseDir, "skills"),
+      prompts: join(globalBaseDir, "prompts"),
+      themes: join(globalBaseDir, "themes")
     }, projectDirs = {
-      extensions: join2(projectBaseDir, "extensions"),
-      skills: join2(projectBaseDir, "skills"),
-      prompts: join2(projectBaseDir, "prompts"),
-      themes: join2(projectBaseDir, "themes")
-    }, userAgentsSkillsDir = join2(getHomeDir(), ".agents", "skills"), projectTrusted = this.settingsManager.isProjectTrusted(), projectAgentsSkillDirs = projectTrusted ? collectAncestorAgentsSkillDirs(this.cwd).filter((dir) => resolve2(dir) !== resolve2(userAgentsSkillsDir)) : [], addResources = (resourceType, paths, metadata, overrides, baseDir) => {
+      extensions: join(projectBaseDir, "extensions"),
+      skills: join(projectBaseDir, "skills"),
+      prompts: join(projectBaseDir, "prompts"),
+      themes: join(projectBaseDir, "themes")
+    }, userAgentsSkillsDir = join(getHomeDir(), ".agents", "skills"), projectTrusted = this.settingsManager.isProjectTrusted(), projectAgentsSkillDirs = projectTrusted ? collectAncestorAgentsSkillDirs(this.cwd).filter((dir) => resolve(dir) !== resolve(userAgentsSkillsDir)) : [], addResources = (resourceType, paths, metadata, overrides, baseDir) => {
       let target = this.getTargetMap(accumulator, resourceType);
-      for (let path2 of paths) {
-        let enabled = isEnabledByOverrides(path2, overrides, baseDir);
-        this.addResource(target, path2, metadata, enabled);
+      for (let path of paths) {
+        let enabled = isEnabledByOverrides(path, overrides, baseDir);
+        this.addResource(target, path, metadata, enabled);
       }
     };
     projectTrusted && (addResources("extensions", collectAutoExtensionEntries(projectDirs.extensions), projectMetadata, projectOverrides.extensions, projectBaseDir), addResources("skills", collectAutoSkillEntries(projectDirs.skills, "pi"), projectMetadata, projectOverrides.skills, projectBaseDir));
     for (let agentsSkillsDir of projectAgentsSkillDirs) {
-      let agentsBaseDir = dirname2(agentsSkillsDir), agentsMetadata = {
+      let agentsBaseDir = dirname(agentsSkillsDir), agentsMetadata = {
         ...projectMetadata,
         baseDir: agentsBaseDir
       };
       addResources("skills", collectAutoSkillEntries(agentsSkillsDir, "agents"), agentsMetadata, projectOverrides.skills, agentsBaseDir);
     }
     projectTrusted && (addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir), addResources("themes", collectAutoThemeEntries(projectDirs.themes), projectMetadata, projectOverrides.themes, projectBaseDir)), addResources("extensions", collectAutoExtensionEntries(userDirs.extensions), userMetadata, userOverrides.extensions, globalBaseDir), addResources("skills", collectAutoSkillEntries(userDirs.skills, "pi"), userMetadata, userOverrides.skills, globalBaseDir);
-    let userAgentsBaseDir = dirname2(userAgentsSkillsDir), userAgentsMetadata = {
+    let userAgentsBaseDir = dirname(userAgentsSkillsDir), userAgentsMetadata = {
       ...userMetadata,
       baseDir: userAgentsBaseDir
     };
@@ -5849,9 +5417,9 @@ var DefaultPackageManager = class {
   collectFilesFromPaths(paths, resourceType) {
     let files = [];
     for (let p of paths)
-      if (existsSync2(p))
+      if (existsSync(p))
         try {
-          let stats = statSync2(p);
+          let stats = statSync(p);
           stats.isFile() ? files.push(p) : stats.isDirectory() && files.push(...collectResourceFiles(p, resourceType));
         } catch {
         }
@@ -5871,8 +5439,8 @@ var DefaultPackageManager = class {
         throw new Error(`Unknown resource type: ${resourceType}`);
     }
   }
-  addResource(map, path2, metadata, enabled) {
-    path2 && (map.has(path2) || map.set(path2, { metadata, enabled }));
+  addResource(map, path, metadata, enabled) {
+    path && (map.has(path) || map.set(path, { metadata, enabled }));
   }
   createAccumulator() {
     return {
@@ -5884,8 +5452,8 @@ var DefaultPackageManager = class {
   }
   toResolvedPaths(accumulator) {
     let mapToResolved = (entries) => {
-      let resolved = Array.from(entries.entries()).map(([path2, { metadata, enabled }]) => ({
-        path: path2,
+      let resolved = Array.from(entries.entries()).map(([path, { metadata, enabled }]) => ({
+        path,
         enabled,
         metadata
       }));
@@ -5975,919 +5543,8 @@ var DefaultPackageManager = class {
   }
 };
 
-// packages/coding-agent/dist/core/skills.js
-var import_ignore2 = __toESM(require_ignore(), 1);
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
-import { basename as basename2, dirname as dirname3, join as join3, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
-var MAX_NAME_LENGTH = 64, MAX_DESCRIPTION_LENGTH = 1024, IGNORE_FILE_NAMES2 = [".gitignore", ".ignore", ".fdignore"];
-function toPosixPath2(p) {
-  return p.split(sep2).join("/");
-}
-function prefixIgnorePattern2(line, prefix) {
-  let trimmed = line.trim();
-  if (!trimmed || trimmed.startsWith("#") && !trimmed.startsWith("\\#"))
-    return null;
-  let pattern = line, negated = !1;
-  pattern.startsWith("!") ? (negated = !0, pattern = pattern.slice(1)) : pattern.startsWith("\\!") && (pattern = pattern.slice(1)), pattern.startsWith("/") && (pattern = pattern.slice(1));
-  let prefixed = prefix ? `${prefix}${pattern}` : pattern;
-  return negated ? `!${prefixed}` : prefixed;
-}
-function addIgnoreRules2(ig, dir, rootDir) {
-  let relativeDir = relative2(rootDir, dir), prefix = relativeDir ? `${toPosixPath2(relativeDir)}/` : "";
-  for (let filename of IGNORE_FILE_NAMES2) {
-    let ignorePath = join3(dir, filename);
-    if (existsSync3(ignorePath))
-      try {
-        let patterns = readFileSync3(ignorePath, "utf-8").split(/\r?\n/).map((line) => prefixIgnorePattern2(line, prefix)).filter((line) => !!line);
-        patterns.length > 0 && ig.add(patterns);
-      } catch {
-      }
-  }
-}
-function validateName(name) {
-  let errors = [];
-  return name.length > MAX_NAME_LENGTH && errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`), /^[a-z0-9-]+$/.test(name) || errors.push("name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)"), (name.startsWith("-") || name.endsWith("-")) && errors.push("name must not start or end with a hyphen"), name.includes("--") && errors.push("name must not contain consecutive hyphens"), errors;
-}
-function validateDescription(description) {
-  let errors = [];
-  return !description || description.trim() === "" ? errors.push("description is required") : description.length > MAX_DESCRIPTION_LENGTH && errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`), errors;
-}
-function createSkillSourceInfo(filePath, baseDir, source) {
-  switch (source) {
-    case "user":
-      return createSyntheticSourceInfo(filePath, {
-        source: "local",
-        scope: "user",
-        baseDir
-      });
-    case "project":
-      return createSyntheticSourceInfo(filePath, {
-        source: "local",
-        scope: "project",
-        baseDir
-      });
-    case "path":
-      return createSyntheticSourceInfo(filePath, {
-        source: "local",
-        baseDir
-      });
-    default:
-      return createSyntheticSourceInfo(filePath, { source, baseDir });
-  }
-}
-function loadSkillsFromDir(options) {
-  let { dir, source } = options;
-  return loadSkillsFromDirInternal(dir, source, !0);
-}
-function loadSkillsFromDirInternal(dir, source, includeRootFiles, ignoreMatcher, rootDir) {
-  let skills = [], diagnostics = [];
-  if (!existsSync3(dir))
-    return { skills, diagnostics };
-  let root = rootDir ?? dir, ig = ignoreMatcher ?? (0, import_ignore2.default)();
-  addIgnoreRules2(ig, dir, root);
-  try {
-    let entries = readdirSync3(dir, { withFileTypes: !0 });
-    for (let entry of entries) {
-      if (entry.name !== "SKILL.md")
-        continue;
-      let fullPath = join3(dir, entry.name), isFile = entry.isFile();
-      if (entry.isSymbolicLink())
-        try {
-          isFile = statSync3(fullPath).isFile();
-        } catch {
-          continue;
-        }
-      let relPath = toPosixPath2(relative2(root, fullPath));
-      if (!isFile || ig.ignores(relPath))
-        continue;
-      let result = loadSkillFromFile(fullPath, source);
-      return result.skill && skills.push(result.skill), diagnostics.push(...result.diagnostics), { skills, diagnostics };
-    }
-    for (let entry of entries) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules")
-        continue;
-      let fullPath = join3(dir, entry.name), isDirectory = entry.isDirectory(), isFile = entry.isFile();
-      if (entry.isSymbolicLink())
-        try {
-          let stats = statSync3(fullPath);
-          isDirectory = stats.isDirectory(), isFile = stats.isFile();
-        } catch {
-          continue;
-        }
-      let relPath = toPosixPath2(relative2(root, fullPath)), ignorePath = isDirectory ? `${relPath}/` : relPath;
-      if (ig.ignores(ignorePath))
-        continue;
-      if (isDirectory) {
-        let subResult = loadSkillsFromDirInternal(fullPath, source, !1, ig, root);
-        skills.push(...subResult.skills), diagnostics.push(...subResult.diagnostics);
-        continue;
-      }
-      if (!isFile || !includeRootFiles || !entry.name.endsWith(".md"))
-        continue;
-      let result = loadSkillFromFile(fullPath, source);
-      result.skill && skills.push(result.skill), diagnostics.push(...result.diagnostics);
-    }
-  } catch {
-  }
-  return { skills, diagnostics };
-}
-function loadSkillFromFile(filePath, source) {
-  let diagnostics = [];
-  try {
-    let rawContent = readFileSync3(filePath, "utf-8"), { frontmatter } = parseFrontmatter(rawContent), skillDir = dirname3(filePath), parentDirName = basename2(skillDir), descErrors = validateDescription(frontmatter.description);
-    for (let error of descErrors)
-      diagnostics.push({ type: "warning", message: error, path: filePath });
-    let name = frontmatter.name || parentDirName, nameErrors = validateName(name);
-    for (let error of nameErrors)
-      diagnostics.push({ type: "warning", message: error, path: filePath });
-    return !frontmatter.description || frontmatter.description.trim() === "" ? { skill: null, diagnostics } : {
-      skill: {
-        name,
-        description: frontmatter.description,
-        filePath,
-        baseDir: skillDir,
-        sourceInfo: createSkillSourceInfo(filePath, skillDir, source),
-        disableModelInvocation: frontmatter["disable-model-invocation"] === !0
-      },
-      diagnostics
-    };
-  } catch (error) {
-    let message = error instanceof Error ? error.message : "failed to parse skill file";
-    return diagnostics.push({ type: "warning", message, path: filePath }), { skill: null, diagnostics };
-  }
-}
-function formatSkillsForPrompt(skills) {
-  let visibleSkills = skills.filter((s) => !s.disableModelInvocation);
-  if (visibleSkills.length === 0)
-    return "";
-  let lines = [
-    `
-
-The following skills provide specialized instructions for specific tasks.`,
-    "Use the read tool to load a skill's file when the task matches its description.",
-    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
-    "",
-    "<available_skills>"
-  ];
-  for (let skill of visibleSkills)
-    lines.push("  <skill>"), lines.push(`    <name>${escapeXml(skill.name)}</name>`), lines.push(`    <description>${escapeXml(skill.description)}</description>`), lines.push(`    <location>${escapeXml(skill.filePath)}</location>`), lines.push("  </skill>");
-  return lines.push("</available_skills>"), lines.join(`
-`);
-}
-function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-function loadSkills(options) {
-  let { agentDir, skillPaths, includeDefaults } = options, resolvedCwd = resolvePath(options.cwd), resolvedAgentDir = resolvePath(agentDir ?? getAgentDir()), skillMap = /* @__PURE__ */ new Map(), realPathSet = /* @__PURE__ */ new Set(), allDiagnostics = [], collisionDiagnostics = [];
-  function addSkills(result) {
-    allDiagnostics.push(...result.diagnostics);
-    for (let skill of result.skills) {
-      let realPath = canonicalizePath(skill.filePath);
-      if (realPathSet.has(realPath))
-        continue;
-      let existing = skillMap.get(skill.name);
-      existing ? collisionDiagnostics.push({
-        type: "collision",
-        message: `name "${skill.name}" collision`,
-        path: skill.filePath,
-        collision: {
-          resourceType: "skill",
-          name: skill.name,
-          winnerPath: existing.filePath,
-          loserPath: skill.filePath
-        }
-      }) : (skillMap.set(skill.name, skill), realPathSet.add(realPath));
-    }
-  }
-  includeDefaults && (addSkills(loadSkillsFromDirInternal(join3(resolvedAgentDir, "skills"), "user", !0)), addSkills(loadSkillsFromDirInternal(resolve3(resolvedCwd, CONFIG_DIR_NAME, "skills"), "project", !0)));
-  let userSkillsDir = join3(resolvedAgentDir, "skills"), projectSkillsDir = resolve3(resolvedCwd, CONFIG_DIR_NAME, "skills"), isUnderPath = (target, root) => {
-    let normalizedRoot = resolve3(root);
-    if (target === normalizedRoot)
-      return !0;
-    let prefix = normalizedRoot.endsWith(sep2) ? normalizedRoot : `${normalizedRoot}${sep2}`;
-    return target.startsWith(prefix);
-  }, getSource = (resolvedPath) => {
-    if (!includeDefaults) {
-      if (isUnderPath(resolvedPath, userSkillsDir))
-        return "user";
-      if (isUnderPath(resolvedPath, projectSkillsDir))
-        return "project";
-    }
-    return "path";
-  };
-  for (let rawPath of skillPaths) {
-    let resolvedPath = resolvePath(rawPath, resolvedCwd, { trim: !0 });
-    if (!existsSync3(resolvedPath)) {
-      allDiagnostics.push({ type: "warning", message: "skill path does not exist", path: resolvedPath });
-      continue;
-    }
-    try {
-      let stats = statSync3(resolvedPath), source = getSource(resolvedPath);
-      if (stats.isDirectory())
-        addSkills(loadSkillsFromDirInternal(resolvedPath, source, !0));
-      else if (stats.isFile() && resolvedPath.endsWith(".md")) {
-        let result = loadSkillFromFile(resolvedPath, source);
-        result.skill ? addSkills({ skills: [result.skill], diagnostics: result.diagnostics }) : allDiagnostics.push(...result.diagnostics);
-      } else
-        allDiagnostics.push({ type: "warning", message: "skill path is not a markdown file", path: resolvedPath });
-    } catch (error) {
-      let message = error instanceof Error ? error.message : "failed to read skill path";
-      allDiagnostics.push({ type: "warning", message, path: resolvedPath });
-    }
-  }
-  return {
-    skills: Array.from(skillMap.values()),
-    diagnostics: [...allDiagnostics, ...collisionDiagnostics]
-  };
-}
-
-// packages/coding-agent/dist/core/resource-loader.js
-import { existsSync as existsSync5, readdirSync as readdirSync5, readFileSync as readFileSync5, statSync as statSync5 } from "node:fs";
-import { dirname as dirname5, join as join5, resolve as resolve5, sep as sep4 } from "node:path";
-import chalk from "chalk";
-
-// packages/coding-agent/dist/core/prompt-templates.js
-import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
-import { basename as basename3, dirname as dirname4, join as join4, resolve as resolve4, sep as sep3 } from "path";
-function parseCommandArgs(argsString) {
-  let args = [], current = "", inQuote = null;
-  for (let i = 0; i < argsString.length; i++) {
-    let char = argsString[i];
-    inQuote ? char === inQuote ? inQuote = null : current += char : char === '"' || char === "'" ? inQuote = char : /\s/.test(char) ? current && (args.push(current), current = "") : current += char;
-  }
-  return current && args.push(current), args;
-}
-function substituteArgs(content, args) {
-  let allArgs = args.join(" ");
-  return content.replace(/\$\{(\d+):-([^}]*)\}|\$\{@:(\d+)(?::(\d+))?\}|\$(ARGUMENTS|@|\d+)/g, (_match, defaultNum, defaultValue, sliceStart, sliceLength, simple) => {
-    if (defaultNum) {
-      let index2 = parseInt(defaultNum, 10) - 1, value = args[index2];
-      return value || defaultValue;
-    }
-    if (sliceStart) {
-      let start = parseInt(sliceStart, 10) - 1;
-      if (start < 0 && (start = 0), sliceLength) {
-        let length = parseInt(sliceLength, 10);
-        return args.slice(start, start + length).join(" ");
-      }
-      return args.slice(start).join(" ");
-    }
-    if (simple === "ARGUMENTS" || simple === "@")
-      return allArgs;
-    let index = parseInt(simple, 10) - 1;
-    return args[index] ?? "";
-  });
-}
-function loadTemplateFromFile(filePath, sourceInfo) {
-  try {
-    let rawContent = readFileSync4(filePath, "utf-8"), { frontmatter, body } = parseFrontmatter(rawContent), name = basename3(filePath).replace(/\.md$/, ""), description = frontmatter.description || "";
-    if (!description) {
-      let firstLine = body.split(`
-`).find((line) => line.trim());
-      firstLine && (description = firstLine.slice(0, 60), firstLine.length > 60 && (description += "..."));
-    }
-    return {
-      name,
-      description,
-      ...frontmatter["argument-hint"] && { argumentHint: frontmatter["argument-hint"] },
-      content: body,
-      sourceInfo,
-      filePath
-    };
-  } catch {
-    return null;
-  }
-}
-function loadTemplatesFromDir(dir, getSourceInfo) {
-  let templates = [];
-  if (!existsSync4(dir))
-    return templates;
-  try {
-    let entries = readdirSync4(dir, { withFileTypes: !0 });
-    for (let entry of entries) {
-      let fullPath = join4(dir, entry.name), isFile = entry.isFile();
-      if (entry.isSymbolicLink())
-        try {
-          isFile = statSync4(fullPath).isFile();
-        } catch {
-          continue;
-        }
-      if (isFile && entry.name.endsWith(".md")) {
-        let template = loadTemplateFromFile(fullPath, getSourceInfo(fullPath));
-        template && templates.push(template);
-      }
-    }
-  } catch {
-    return templates;
-  }
-  return templates;
-}
-function loadPromptTemplates(options) {
-  let resolvedCwd = resolvePath(options.cwd), resolvedAgentDir = resolvePath(options.agentDir), promptPaths = options.promptPaths, includeDefaults = options.includeDefaults, templates = [], globalPromptsDir = join4(resolvedAgentDir, "prompts"), projectPromptsDir = resolve4(resolvedCwd, CONFIG_DIR_NAME, "prompts"), isUnderPath = (target, root) => {
-    let normalizedRoot = resolve4(root);
-    if (target === normalizedRoot)
-      return !0;
-    let prefix = normalizedRoot.endsWith(sep3) ? normalizedRoot : `${normalizedRoot}${sep3}`;
-    return target.startsWith(prefix);
-  }, getSourceInfo = (resolvedPath) => isUnderPath(resolvedPath, globalPromptsDir) ? createSyntheticSourceInfo(resolvedPath, {
-    source: "local",
-    scope: "user",
-    baseDir: globalPromptsDir
-  }) : isUnderPath(resolvedPath, projectPromptsDir) ? createSyntheticSourceInfo(resolvedPath, {
-    source: "local",
-    scope: "project",
-    baseDir: projectPromptsDir
-  }) : createSyntheticSourceInfo(resolvedPath, {
-    source: "local",
-    baseDir: statSync4(resolvedPath).isDirectory() ? resolvedPath : dirname4(resolvedPath)
-  });
-  includeDefaults && (templates.push(...loadTemplatesFromDir(globalPromptsDir, getSourceInfo)), templates.push(...loadTemplatesFromDir(projectPromptsDir, getSourceInfo)));
-  for (let rawPath of promptPaths) {
-    let resolvedPath = resolvePath(rawPath, resolvedCwd, { trim: !0 });
-    if (existsSync4(resolvedPath))
-      try {
-        let stats = statSync4(resolvedPath);
-        if (stats.isDirectory())
-          templates.push(...loadTemplatesFromDir(resolvedPath, getSourceInfo));
-        else if (stats.isFile() && resolvedPath.endsWith(".md")) {
-          let template = loadTemplateFromFile(resolvedPath, getSourceInfo(resolvedPath));
-          template && templates.push(template);
-        }
-      } catch {
-      }
-  }
-  return templates;
-}
-function expandPromptTemplate(text, templates) {
-  if (!text.startsWith("/"))
-    return text;
-  let match = text.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/);
-  if (!match)
-    return text;
-  let templateName = match[1], argsString = match[2] ?? "", template = templates.find((t) => t.name === templateName);
-  if (template) {
-    let args = parseCommandArgs(argsString);
-    return substituteArgs(template.content, args);
-  }
-  return text;
-}
-
-// packages/coding-agent/dist/core/resource-loader.js
-function inlineExtensionPath(input, index) {
-  return `<inline:${typeof input != "function" ? input.name : index + 1}>`;
-}
-function resolvePromptInput(input, description) {
-  if (input) {
-    if (existsSync5(input))
-      try {
-        return readFileSync5(input, "utf-8");
-      } catch (error) {
-        return console.error(chalk.yellow(`Warning: Could not read ${description} file ${input}: ${error}`)), input;
-      }
-    return input;
-  }
-}
-function loadContextFileFromDir(dir) {
-  let candidates = ["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
-  for (let filename of candidates) {
-    let filePath = join5(dir, filename);
-    if (existsSync5(filePath))
-      try {
-        return {
-          path: filePath,
-          content: readFileSync5(filePath, "utf-8")
-        };
-      } catch (error) {
-        console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));
-      }
-  }
-  return null;
-}
-function loadProjectContextFiles(options) {
-  let resolvedCwd = resolvePath(options.cwd), resolvedAgentDir = resolvePath(options.agentDir), contextFiles = [], seenPaths = /* @__PURE__ */ new Set(), userContexts = options.settingsManager ? loadSelectedUserInstructions({ agentDir: resolvedAgentDir, settingsManager: options.settingsManager }) : [getGlobalInstructionsPath(resolvedAgentDir)].map((path2) => loadContextFileFromDir(dirname5(path2))).filter((file) => file !== null);
-  for (let userContext of userContexts)
-    contextFiles.push(userContext), seenPaths.add(userContext.path);
-  let ancestorContextFiles = [], currentDir = resolvedCwd;
-  for (; ; ) {
-    let contextFile = loadContextFileFromDir(currentDir);
-    contextFile && !seenPaths.has(contextFile.path) && (ancestorContextFiles.unshift(contextFile), seenPaths.add(contextFile.path));
-    let parentDir = dirname5(currentDir);
-    if (parentDir === currentDir)
-      break;
-    currentDir = parentDir;
-  }
-  return contextFiles.push(...ancestorContextFiles), contextFiles;
-}
-var DefaultResourceLoader = class {
-  cwd;
-  agentDir;
-  settingsManager;
-  eventBus;
-  packageManager;
-  additionalExtensionPaths;
-  additionalSkillPaths;
-  additionalPromptTemplatePaths;
-  additionalThemePaths;
-  extensionFactories;
-  noExtensions;
-  noSkills;
-  noPromptTemplates;
-  noThemes;
-  noContextFiles;
-  systemPromptSource;
-  appendSystemPromptSource;
-  extensionsOverride;
-  skillsOverride;
-  promptsOverride;
-  themesOverride;
-  agentsFilesOverride;
-  systemPromptOverride;
-  appendSystemPromptOverride;
-  extensionsResult;
-  skills;
-  skillDiagnostics;
-  prompts;
-  promptDiagnostics;
-  themes;
-  themeDiagnostics;
-  agentsFiles;
-  systemPrompt;
-  appendSystemPrompt;
-  lastSkillPaths;
-  extensionSkillSourceInfos;
-  extensionPromptSourceInfos;
-  extensionThemeSourceInfos;
-  lastPromptPaths;
-  lastThemePaths;
-  loaded;
-  constructor(options) {
-    this.cwd = resolvePath(options.cwd), this.agentDir = resolvePath(options.agentDir), this.settingsManager = options.settingsManager ?? SettingsManager.create(this.cwd, this.agentDir), this.eventBus = options.eventBus ?? createEventBus(), this.packageManager = new DefaultPackageManager({
-      cwd: this.cwd,
-      agentDir: this.agentDir,
-      settingsManager: this.settingsManager
-    }), this.additionalExtensionPaths = options.additionalExtensionPaths ?? [], this.additionalSkillPaths = options.additionalSkillPaths ?? [], this.additionalPromptTemplatePaths = options.additionalPromptTemplatePaths ?? [], this.additionalThemePaths = options.additionalThemePaths ?? [], this.extensionFactories = options.extensionFactories ?? [], this.noExtensions = options.noExtensions ?? !1, this.noSkills = options.noSkills ?? !1, this.noPromptTemplates = options.noPromptTemplates ?? !1, this.noThemes = options.noThemes ?? !1, this.noContextFiles = options.noContextFiles ?? !1, this.systemPromptSource = options.systemPrompt, this.appendSystemPromptSource = options.appendSystemPrompt, this.extensionsOverride = options.extensionsOverride, this.skillsOverride = options.skillsOverride, this.promptsOverride = options.promptsOverride, this.themesOverride = options.themesOverride, this.agentsFilesOverride = options.agentsFilesOverride, this.systemPromptOverride = options.systemPromptOverride, this.appendSystemPromptOverride = options.appendSystemPromptOverride, this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() }, this.skills = [], this.skillDiagnostics = [], this.prompts = [], this.promptDiagnostics = [], this.themes = [], this.themeDiagnostics = [], this.agentsFiles = [], this.appendSystemPrompt = [], this.lastSkillPaths = [], this.extensionSkillSourceInfos = /* @__PURE__ */ new Map(), this.extensionPromptSourceInfos = /* @__PURE__ */ new Map(), this.extensionThemeSourceInfos = /* @__PURE__ */ new Map(), this.lastPromptPaths = [], this.lastThemePaths = [], this.loaded = !1;
-  }
-  getExtensions() {
-    return this.extensionsResult;
-  }
-  getSkills() {
-    return { skills: this.skills, diagnostics: this.skillDiagnostics };
-  }
-  getPrompts() {
-    return { prompts: this.prompts, diagnostics: this.promptDiagnostics };
-  }
-  getThemes() {
-    return { themes: this.themes, diagnostics: this.themeDiagnostics };
-  }
-  getAgentsFiles() {
-    return { agentsFiles: this.agentsFiles };
-  }
-  contextFilesEnabled() {
-    return !this.noContextFiles;
-  }
-  getSystemPrompt() {
-    return this.systemPrompt;
-  }
-  getAppendSystemPrompt() {
-    return this.appendSystemPrompt;
-  }
-  async attachInlineExtensions(factories) {
-    let loaded = new Set(this.extensionsResult.extensions.map((extension) => extension.path)), pending = factories.filter((factory, index) => {
-      let path2 = inlineExtensionPath(factory, this.extensionFactories.length + index);
-      return !loaded.has(path2);
-    });
-    if (pending.length === 0)
-      return { extensions: [], errors: [], runtime: this.extensionsResult.runtime };
-    let attached = await this.loadExtensionFactories(this.extensionsResult.runtime, pending);
-    return this.extensionFactories.push(...pending), this.extensionsResult.extensions.push(...attached.extensions), this.extensionsResult.errors.push(...attached.errors), this.addExtensionConflictDiagnostics(this.extensionsResult), {
-      extensions: attached.extensions,
-      errors: attached.errors,
-      runtime: this.extensionsResult.runtime
-    };
-  }
-  extendResources(paths) {
-    let skillPaths = this.normalizeExtensionPaths(paths.skillPaths ?? []), promptPaths = this.normalizeExtensionPaths(paths.promptPaths ?? []), themePaths = this.normalizeExtensionPaths(paths.themePaths ?? []);
-    for (let entry of skillPaths)
-      this.extensionSkillSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
-    for (let entry of promptPaths)
-      this.extensionPromptSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
-    for (let entry of themePaths)
-      this.extensionThemeSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
-    skillPaths.length > 0 && (this.lastSkillPaths = this.mergePaths(this.lastSkillPaths, skillPaths.map((entry) => entry.path)), this.updateSkillsFromPaths(this.lastSkillPaths)), promptPaths.length > 0 && (this.lastPromptPaths = this.mergePaths(this.lastPromptPaths, promptPaths.map((entry) => entry.path)), this.updatePromptsFromPaths(this.lastPromptPaths)), themePaths.length > 0 && (this.lastThemePaths = this.mergePaths(this.lastThemePaths, themePaths.map((entry) => entry.path)), this.updateThemesFromPaths(this.lastThemePaths));
-  }
-  resolveOnMissing(skipMissingPackageInstall) {
-    if (skipMissingPackageInstall)
-      return async () => "skip";
-  }
-  async loadProjectTrustExtensions(options) {
-    return this.settingsManager.setProjectTrusted(!1), await this.settingsManager.reload(), this.loadCurrentExtensionSet({
-      includeInlineFactories: !0,
-      skipMissingPackageInstall: options?.skipMissingPackageInstall
-    });
-  }
-  async reload(options) {
-    resetTimings("extensions"), this.loaded && clearExtensionCache();
-    let preTrustExtensions;
-    if (options?.resolveProjectTrust) {
-      preTrustExtensions = await this.loadProjectTrustExtensions(options);
-      let projectTrusted = await options.resolveProjectTrust({ extensionsResult: preTrustExtensions });
-      this.settingsManager.setProjectTrusted(projectTrusted);
-    }
-    await this.settingsManager.reload();
-    let resolvedPaths = await this.packageManager.resolve(this.resolveOnMissing(options?.skipMissingPackageInstall)), cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
-      temporary: !0
-    }), metadataByPath = /* @__PURE__ */ new Map();
-    this.extensionSkillSourceInfos = /* @__PURE__ */ new Map(), this.extensionPromptSourceInfos = /* @__PURE__ */ new Map(), this.extensionThemeSourceInfos = /* @__PURE__ */ new Map();
-    let getEnabledResources = (resources) => {
-      for (let r of resources)
-        metadataByPath.has(r.path) || metadataByPath.set(r.path, r.metadata);
-      return resources.filter((r) => r.enabled);
-    }, getEnabledPaths = (resources) => getEnabledResources(resources).map((r) => r.path), enabledExtensions = getEnabledPaths(resolvedPaths.extensions), enabledSkillResources = getEnabledResources(resolvedPaths.skills), enabledPrompts = getEnabledPaths(resolvedPaths.prompts), enabledThemes = getEnabledPaths(resolvedPaths.themes), enabledSkills = enabledSkillResources.map((resource) => this.mapSkillPath(resource, metadataByPath));
-    for (let r of cliExtensionPaths.extensions)
-      metadataByPath.has(r.path) || metadataByPath.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
-    for (let r of cliExtensionPaths.skills)
-      metadataByPath.has(r.path) || metadataByPath.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
-    let cliEnabledExtensions = getEnabledPaths(cliExtensionPaths.extensions), cliEnabledSkills = getEnabledPaths(cliExtensionPaths.skills), cliEnabledPrompts = getEnabledPaths(cliExtensionPaths.prompts), cliEnabledThemes = getEnabledPaths(cliExtensionPaths.themes), extensionPaths = this.noExtensions ? cliEnabledExtensions : this.mergePaths(cliEnabledExtensions, enabledExtensions), extensionsResult = await this.loadFinalExtensionSet(extensionPaths, preTrustExtensions);
-    for (let p of this.additionalExtensionPaths)
-      if (isLocalPath(p)) {
-        let resolved = this.resolveResourcePath(p);
-        existsSync5(resolved) || extensionsResult.errors.push({ path: resolved, error: `Extension path does not exist: ${resolved}` });
-      }
-    this.extensionsResult = this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult, this.applyExtensionSourceInfo(this.extensionsResult.extensions, metadataByPath);
-    let skillPaths = this.noSkills ? this.mergePaths(cliEnabledSkills, this.additionalSkillPaths) : this.mergePaths([...cliEnabledSkills, ...enabledSkills], this.additionalSkillPaths);
-    this.lastSkillPaths = skillPaths, this.updateSkillsFromPaths(skillPaths, metadataByPath);
-    for (let p of this.additionalSkillPaths)
-      if (isLocalPath(p)) {
-        let resolved = this.resolveResourcePath(p);
-        !existsSync5(resolved) && !this.skillDiagnostics.some((d) => d.path === resolved) && this.skillDiagnostics.push({ type: "error", message: "Skill path does not exist", path: resolved });
-      }
-    let promptPaths = this.noPromptTemplates ? this.mergePaths(cliEnabledPrompts, this.additionalPromptTemplatePaths) : this.mergePaths([...cliEnabledPrompts, ...enabledPrompts], this.additionalPromptTemplatePaths);
-    this.lastPromptPaths = promptPaths, this.updatePromptsFromPaths(promptPaths, metadataByPath);
-    for (let p of this.additionalPromptTemplatePaths)
-      if (isLocalPath(p)) {
-        let resolved = this.resolveResourcePath(p);
-        !existsSync5(resolved) && !this.promptDiagnostics.some((d) => d.path === resolved) && this.promptDiagnostics.push({
-          type: "error",
-          message: "Prompt template path does not exist",
-          path: resolved
-        });
-      }
-    let themePaths = this.noThemes ? this.mergePaths(cliEnabledThemes, this.additionalThemePaths) : this.mergePaths([...cliEnabledThemes, ...enabledThemes], this.additionalThemePaths);
-    this.lastThemePaths = themePaths, this.updateThemesFromPaths(themePaths, metadataByPath);
-    for (let p of this.additionalThemePaths) {
-      let resolved = this.resolveResourcePath(p);
-      !existsSync5(resolved) && !this.themeDiagnostics.some((d) => d.path === resolved) && this.themeDiagnostics.push({ type: "error", message: "Theme path does not exist", path: resolved });
-    }
-    let agentsFiles = {
-      agentsFiles: this.noContextFiles ? [] : loadProjectContextFiles({
-        cwd: this.cwd,
-        agentDir: this.agentDir,
-        settingsManager: this.settingsManager
-      })
-    }, resolvedAgentsFiles = this.agentsFilesOverride ? this.agentsFilesOverride(agentsFiles) : agentsFiles;
-    this.agentsFiles = resolvedAgentsFiles.agentsFiles;
-    let baseSystemPrompt = resolvePromptInput(this.systemPromptSource ?? this.discoverSystemPromptFile(), "system prompt");
-    this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
-    let baseAppend = (this.appendSystemPromptSource ?? (this.discoverAppendSystemPromptFile() ? [this.discoverAppendSystemPromptFile()] : [])).map((s) => resolvePromptInput(s, "append system prompt")).filter((s) => s !== void 0);
-    this.appendSystemPrompt = this.appendSystemPromptOverride ? this.appendSystemPromptOverride(baseAppend) : baseAppend, this.loaded = !0;
-  }
-  async loadCurrentExtensionSet(options) {
-    let resolvedPaths = await this.packageManager.resolve(this.resolveOnMissing(options.skipMissingPackageInstall)), cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
-      temporary: !0
-    }), enabledExtensions = resolvedPaths.extensions.filter((r) => r.enabled).map((r) => r.path), cliEnabledExtensions = cliExtensionPaths.extensions.filter((r) => r.enabled).map((r) => r.path), extensionPaths = this.noExtensions ? cliEnabledExtensions : this.mergePaths(cliEnabledExtensions, enabledExtensions), extensionsResult = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus);
-    if (!options.includeInlineFactories)
-      return extensionsResult;
-    let inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime);
-    return extensionsResult.extensions.push(...inlineExtensions.extensions), extensionsResult.errors.push(...inlineExtensions.errors), extensionsResult;
-  }
-  resolveExtensionLoadPath(path2) {
-    return resolvePath(path2, this.cwd, { normalizeUnicodeSpaces: !0 });
-  }
-  async loadFinalExtensionSet(extensionPaths, preTrustExtensions) {
-    if (!preTrustExtensions) {
-      let extensionsResult2 = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus), inlineExtensions2 = await this.loadExtensionFactories(extensionsResult2.runtime);
-      return extensionsResult2.extensions.push(...inlineExtensions2.extensions), extensionsResult2.errors.push(...inlineExtensions2.errors), this.addExtensionConflictDiagnostics(extensionsResult2), extensionsResult2;
-    }
-    let preloadedByPath = new Map(preTrustExtensions.extensions.filter((extension) => !extension.path.startsWith("<inline:")).map((extension) => [extension.resolvedPath, extension])), failedPreloadPaths = new Set(preTrustExtensions.errors.map((error) => this.resolveExtensionLoadPath(error.path))), remainingPaths = extensionPaths.filter((path2) => {
-      let resolvedPath = this.resolveExtensionLoadPath(path2);
-      return !preloadedByPath.has(resolvedPath) && !failedPreloadPaths.has(resolvedPath);
-    }), remainingExtensions = await loadExtensionsCached(remainingPaths, this.cwd, this.eventBus, preTrustExtensions.runtime), loadedByPath = new Map(preloadedByPath);
-    for (let extension of remainingExtensions.extensions)
-      loadedByPath.set(extension.resolvedPath, extension);
-    let inlineExtensions = preTrustExtensions.extensions.filter((extension) => extension.path.startsWith("<inline:")), orderedExtensions = extensionPaths.map((path2) => loadedByPath.get(this.resolveExtensionLoadPath(path2))).filter((extension) => extension !== void 0);
-    orderedExtensions.push(...inlineExtensions);
-    let extensionsResult = {
-      extensions: orderedExtensions,
-      errors: [...preTrustExtensions.errors, ...remainingExtensions.errors],
-      runtime: preTrustExtensions.runtime
-    };
-    return this.addExtensionConflictDiagnostics(extensionsResult), extensionsResult;
-  }
-  addExtensionConflictDiagnostics(extensionsResult) {
-    let conflicts = this.detectExtensionConflicts(extensionsResult.extensions);
-    for (let conflict of conflicts)
-      extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
-  }
-  mapSkillPath(resource, metadataByPath) {
-    if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package")
-      return resource.path;
-    try {
-      if (!statSync5(resource.path).isDirectory())
-        return resource.path;
-    } catch {
-      return resource.path;
-    }
-    let skillFile = join5(resource.path, "SKILL.md");
-    return existsSync5(skillFile) ? (metadataByPath.has(skillFile) || metadataByPath.set(skillFile, resource.metadata), skillFile) : resource.path;
-  }
-  normalizeExtensionPaths(entries) {
-    return entries.map((entry) => {
-      let metadata = entry.metadata.baseDir ? { ...entry.metadata, baseDir: this.resolveResourcePath(entry.metadata.baseDir) } : entry.metadata;
-      return {
-        path: this.resolveResourcePath(entry.path),
-        metadata
-      };
-    });
-  }
-  updateSkillsFromPaths(skillPaths, metadataByPath) {
-    let skillsResult;
-    this.noSkills && skillPaths.length === 0 ? skillsResult = { skills: [], diagnostics: [] } : skillsResult = loadSkills({
-      cwd: this.cwd,
-      agentDir: this.agentDir,
-      skillPaths,
-      includeDefaults: !1
-    });
-    let resolvedSkills = this.skillsOverride ? this.skillsOverride(skillsResult) : skillsResult;
-    this.skills = resolvedSkills.skills.map((skill) => ({
-      ...skill,
-      sourceInfo: this.findSourceInfoForPath(skill.filePath, this.extensionSkillSourceInfos, metadataByPath) ?? skill.sourceInfo ?? this.getDefaultSourceInfoForPath(skill.filePath)
-    })), this.skillDiagnostics = resolvedSkills.diagnostics;
-  }
-  updatePromptsFromPaths(promptPaths, metadataByPath) {
-    let promptsResult;
-    if (this.noPromptTemplates && promptPaths.length === 0)
-      promptsResult = { prompts: [], diagnostics: [] };
-    else {
-      let allPrompts = loadPromptTemplates({
-        cwd: this.cwd,
-        agentDir: this.agentDir,
-        promptPaths,
-        includeDefaults: !1
-      });
-      promptsResult = this.dedupePrompts(allPrompts);
-    }
-    let resolvedPrompts = this.promptsOverride ? this.promptsOverride(promptsResult) : promptsResult;
-    this.prompts = resolvedPrompts.prompts.map((prompt) => ({
-      ...prompt,
-      sourceInfo: this.findSourceInfoForPath(prompt.filePath, this.extensionPromptSourceInfos, metadataByPath) ?? prompt.sourceInfo ?? this.getDefaultSourceInfoForPath(prompt.filePath)
-    })), this.promptDiagnostics = resolvedPrompts.diagnostics;
-  }
-  updateThemesFromPaths(themePaths, metadataByPath) {
-    let themesResult;
-    if (this.noThemes && themePaths.length === 0)
-      themesResult = { themes: [], diagnostics: [] };
-    else {
-      let loaded = this.loadThemes(themePaths, !1), deduped = this.dedupeThemes(loaded.themes);
-      themesResult = { themes: deduped.themes, diagnostics: [...loaded.diagnostics, ...deduped.diagnostics] };
-    }
-    let resolvedThemes = this.themesOverride ? this.themesOverride(themesResult) : themesResult;
-    this.themes = resolvedThemes.themes.map((theme) => {
-      let sourcePath = theme.sourcePath;
-      return theme.sourceInfo = sourcePath ? this.findSourceInfoForPath(sourcePath, this.extensionThemeSourceInfos, metadataByPath) ?? theme.sourceInfo ?? this.getDefaultSourceInfoForPath(sourcePath) : theme.sourceInfo, theme;
-    }), this.themeDiagnostics = resolvedThemes.diagnostics;
-  }
-  applyExtensionSourceInfo(extensions, metadataByPath) {
-    for (let extension of extensions) {
-      extension.sourceInfo = this.findSourceInfoForPath(extension.path, void 0, metadataByPath) ?? this.getDefaultSourceInfoForPath(extension.path);
-      for (let command of extension.commands.values())
-        command.sourceInfo = extension.sourceInfo;
-      for (let tool of extension.tools.values())
-        tool.sourceInfo = extension.sourceInfo;
-    }
-  }
-  findSourceInfoForPath(resourcePath, extraSourceInfos, metadataByPath) {
-    if (!resourcePath)
-      return;
-    if (resourcePath.startsWith("<"))
-      return this.getDefaultSourceInfoForPath(resourcePath);
-    let normalizedResourcePath = resolve5(resourcePath);
-    if (extraSourceInfos)
-      for (let [sourcePath, sourceInfo] of extraSourceInfos.entries()) {
-        let normalizedSourcePath = resolve5(sourcePath);
-        if (normalizedResourcePath === normalizedSourcePath || normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep4}`))
-          return { ...sourceInfo, path: resourcePath };
-      }
-    if (metadataByPath) {
-      let exact = metadataByPath.get(normalizedResourcePath) ?? metadataByPath.get(resourcePath);
-      if (exact)
-        return createSourceInfo(resourcePath, exact);
-      for (let [sourcePath, metadata] of metadataByPath.entries()) {
-        let normalizedSourcePath = resolve5(sourcePath);
-        if (normalizedResourcePath === normalizedSourcePath || normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep4}`))
-          return createSourceInfo(resourcePath, metadata);
-      }
-    }
-  }
-  getDefaultSourceInfoForPath(filePath) {
-    if (filePath.startsWith("<") && filePath.endsWith(">"))
-      return {
-        path: filePath,
-        source: filePath.slice(1, -1).split(":")[0] || "temporary",
-        scope: "temporary",
-        origin: "top-level"
-      };
-    let normalizedPath = resolve5(filePath), agentRoots = [
-      join5(this.agentDir, "skills"),
-      join5(this.agentDir, "prompts"),
-      join5(this.agentDir, "themes"),
-      join5(this.agentDir, "extensions")
-    ], projectRoots = [
-      join5(this.cwd, CONFIG_DIR_NAME, "skills"),
-      join5(this.cwd, CONFIG_DIR_NAME, "prompts"),
-      join5(this.cwd, CONFIG_DIR_NAME, "themes"),
-      join5(this.cwd, CONFIG_DIR_NAME, "extensions")
-    ];
-    for (let root of agentRoots)
-      if (this.isUnderPath(normalizedPath, root))
-        return { path: filePath, source: "local", scope: "user", origin: "top-level", baseDir: root };
-    for (let root of projectRoots)
-      if (this.isUnderPath(normalizedPath, root))
-        return { path: filePath, source: "local", scope: "project", origin: "top-level", baseDir: root };
-    return {
-      path: filePath,
-      source: "local",
-      scope: "temporary",
-      origin: "top-level",
-      baseDir: statSync5(normalizedPath).isDirectory() ? normalizedPath : resolve5(normalizedPath, "..")
-    };
-  }
-  mergePaths(primary, additional) {
-    let merged = [], seen = /* @__PURE__ */ new Set();
-    for (let p of [...primary, ...additional]) {
-      let resolved = this.resolveResourcePath(p), canonicalPath = canonicalizePath(resolved);
-      seen.has(canonicalPath) || (seen.add(canonicalPath), merged.push(resolved));
-    }
-    return merged;
-  }
-  resolveResourcePath(p) {
-    return resolvePath(p, this.cwd, { trim: !0 });
-  }
-  loadThemes(paths, includeDefaults = !0) {
-    let themes = [], diagnostics = [];
-    if (includeDefaults) {
-      let defaultDirs = [join5(this.agentDir, "themes"), join5(this.cwd, CONFIG_DIR_NAME, "themes")];
-      for (let dir of defaultDirs)
-        this.loadThemesFromDir(dir, themes, diagnostics);
-    }
-    for (let p of paths) {
-      let resolved = this.resolveResourcePath(p);
-      if (!existsSync5(resolved)) {
-        diagnostics.push({ type: "warning", message: "theme path does not exist", path: resolved });
-        continue;
-      }
-      try {
-        let stats = statSync5(resolved);
-        stats.isDirectory() ? this.loadThemesFromDir(resolved, themes, diagnostics) : stats.isFile() && resolved.endsWith(".json") ? this.loadThemeFromFile(resolved, themes, diagnostics) : diagnostics.push({ type: "warning", message: "theme path is not a json file", path: resolved });
-      } catch (error) {
-        let message = error instanceof Error ? error.message : "failed to read theme path";
-        diagnostics.push({ type: "warning", message, path: resolved });
-      }
-    }
-    return { themes, diagnostics };
-  }
-  loadThemesFromDir(dir, themes, diagnostics) {
-    if (existsSync5(dir))
-      try {
-        let entries = readdirSync5(dir, { withFileTypes: !0 });
-        for (let entry of entries) {
-          let isFile = entry.isFile();
-          if (entry.isSymbolicLink())
-            try {
-              isFile = statSync5(join5(dir, entry.name)).isFile();
-            } catch {
-              continue;
-            }
-          isFile && entry.name.endsWith(".json") && this.loadThemeFromFile(join5(dir, entry.name), themes, diagnostics);
-        }
-      } catch (error) {
-        let message = error instanceof Error ? error.message : "failed to read theme directory";
-        diagnostics.push({ type: "warning", message, path: dir });
-      }
-  }
-  loadThemeFromFile(filePath, themes, diagnostics) {
-    try {
-      themes.push(loadThemeFromPath(filePath));
-    } catch (error) {
-      let message = error instanceof Error ? error.message : "failed to load theme";
-      diagnostics.push({ type: "warning", message, path: filePath });
-    }
-  }
-  async loadExtensionFactories(runtime, factories = this.extensionFactories) {
-    let extensions = [], errors = [];
-    for (let [index, input] of factories.entries()) {
-      let factory = typeof input != "function" ? input.factory : input, extensionPath = inlineExtensionPath(input, index);
-      try {
-        let extension = await loadExtensionFromFactory(factory, this.cwd, this.eventBus, runtime, extensionPath);
-        extensions.push(extension);
-      } catch (error) {
-        let message = error instanceof Error ? error.message : "failed to load extension";
-        errors.push({ path: extensionPath, error: message });
-      }
-    }
-    return { extensions, errors };
-  }
-  dedupePrompts(prompts) {
-    let seen = /* @__PURE__ */ new Map(), diagnostics = [];
-    for (let prompt of prompts) {
-      let existing = seen.get(prompt.name);
-      existing ? diagnostics.push({
-        type: "collision",
-        message: `name "/${prompt.name}" collision`,
-        path: prompt.filePath,
-        collision: {
-          resourceType: "prompt",
-          name: prompt.name,
-          winnerPath: existing.filePath,
-          loserPath: prompt.filePath
-        }
-      }) : seen.set(prompt.name, prompt);
-    }
-    return { prompts: Array.from(seen.values()), diagnostics };
-  }
-  dedupeThemes(themes) {
-    let seen = /* @__PURE__ */ new Map(), diagnostics = [];
-    for (let t of themes) {
-      let name = t.name ?? "unnamed", existing = seen.get(name);
-      existing ? diagnostics.push({
-        type: "collision",
-        message: `name "${name}" collision`,
-        path: t.sourcePath,
-        collision: {
-          resourceType: "theme",
-          name,
-          winnerPath: existing.sourcePath ?? "<builtin>",
-          loserPath: t.sourcePath ?? "<builtin>"
-        }
-      }) : seen.set(name, t);
-    }
-    return { themes: Array.from(seen.values()), diagnostics };
-  }
-  discoverSystemPromptFile() {
-    let projectPath = join5(this.cwd, CONFIG_DIR_NAME, "SYSTEM.md");
-    if (this.settingsManager.isProjectTrusted() && existsSync5(projectPath))
-      return projectPath;
-    let globalPath = join5(this.agentDir, "SYSTEM.md");
-    if (existsSync5(globalPath))
-      return globalPath;
-  }
-  discoverAppendSystemPromptFile() {
-    let projectPath = join5(this.cwd, CONFIG_DIR_NAME, "APPEND_SYSTEM.md");
-    if (this.settingsManager.isProjectTrusted() && existsSync5(projectPath))
-      return projectPath;
-    let globalPath = join5(this.agentDir, "APPEND_SYSTEM.md");
-    if (existsSync5(globalPath))
-      return globalPath;
-  }
-  isUnderPath(target, root) {
-    let normalizedRoot = resolve5(root);
-    if (target === normalizedRoot)
-      return !0;
-    let prefix = normalizedRoot.endsWith(sep4) ? normalizedRoot : `${normalizedRoot}${sep4}`;
-    return target.startsWith(prefix);
-  }
-  detectExtensionConflicts(extensions) {
-    let conflicts = [], toolOwners = /* @__PURE__ */ new Map(), flagOwners = /* @__PURE__ */ new Map();
-    for (let ext of extensions) {
-      for (let toolName of ext.tools.keys()) {
-        let existingOwner = toolOwners.get(toolName);
-        existingOwner && existingOwner !== ext.path ? conflicts.push({
-          path: ext.path,
-          message: `Tool "${toolName}" conflicts with ${existingOwner}`
-        }) : toolOwners.set(toolName, ext.path);
-      }
-      for (let flagName of ext.flags.keys()) {
-        let existingOwner = flagOwners.get(flagName);
-        existingOwner && existingOwner !== ext.path ? conflicts.push({
-          path: ext.path,
-          message: `Flag "--${flagName}" conflicts with ${existingOwner}`
-        }) : flagOwners.set(flagName, ext.path);
-      }
-    }
-    return conflicts;
-  }
-};
-
 export {
-  createEventBus,
-  createSyntheticSourceInfo,
-  createExtensionRuntime,
-  discoverAndLoadExtensions,
+  require_ignore,
   parseGitUrl,
-  DefaultPackageManager,
-  expandPromptTemplate,
-  loadSkillsFromDir,
-  formatSkillsForPrompt,
-  loadSkills,
-  loadProjectContextFiles,
-  DefaultResourceLoader
+  DefaultPackageManager
 };