@uipath/cli 0.1.11 → 0.1.16

package/dist/index.js

@@ -52,11 +52,11 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@uipath/cli",
-    version: "0.1.11",
+    version: "0.1.16",
     description: "Cross platform CLI for UiPath",
     repository: {
       type: "git",
-      url: "https://github.com/UiPath/uipcli.git",
+      url: "https://github.com/UiPath/cli.git",
       directory: "packages/cli"
     },
     publishConfig: {
@@ -84,12 +84,14 @@ var init_package = __esm(() => {
     ],
     scripts: {
       build: "bun build ./index.ts --outdir dist --format esm --target node --external commander --external @uipath/common --external @uipath/auth --external @uipath/filesystem",
+      typecheck: "tsc --noEmit",
       "browser:build": "bun run build-browser.ts",
       lint: "biome check ."
     },
     devDependencies: {
-      "@types/bun": "latest",
-      "@types/node": "^25.2.3",
+      "@inquirer/prompts": "^8.3.2",
+      "@types/bun": "^1.3.9",
+      "@types/node": "^25.5.0",
       esbuild: "^0.27.3",
       typescript: "^5"
     },
@@ -101,8 +103,8 @@ var init_package = __esm(() => {
     },
     peerDependencies: {
       commander: "^14.0.3",
-      "@uipath/common": "^0.1.7",
-      "@uipath/auth": "^0.1.6",
+      "@uipath/common": "^0.1.12",
+      "@uipath/auth": "^0.1.9",
       "@uipath/filesystem": "^0.1.6"
     }
   };
@@ -176,12 +178,12 @@ var init_auth = __esm(() => {
 });
 
 // src/commands/login.ts
-import path from "node:path";
 import { DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME } from "@uipath/auth";
 import { catchError, OutputFormatter } from "@uipath/common";
+import { getFileSystem } from "@uipath/filesystem";
 function resolveAuthFilePath(folder) {
   if (folder) {
-    return path.join(folder, DEFAULT_AUTH_FILENAME);
+    return getFileSystem().path.join(folder, DEFAULT_AUTH_FILENAME);
   }
   return DEFAULT_ENV_FILENAME;
 }
@@ -353,12 +355,12 @@ var init_login = __esm(() => {
 });
 
 // src/commands/logout.ts
-import path2 from "node:path";
 import { DEFAULT_AUTH_FILENAME as DEFAULT_AUTH_FILENAME2, logout } from "@uipath/auth";
 import { catchError as catchError2, OutputFormatter as OutputFormatter2 } from "@uipath/common";
+import { getFileSystem as getFileSystem2 } from "@uipath/filesystem";
 function registerLogoutCommand(program, context) {
   program.command("logout").description("Logout from UiPath Cloud by removing credentials").option("-f, --file <folder>", "Path to credentials folder").trackedAction(context, async (options) => {
-    const file = options.file ? path2.join(options.file, DEFAULT_AUTH_FILENAME2) : undefined;
+    const file = options.file ? getFileSystem2().path.join(options.file, DEFAULT_AUTH_FILENAME2) : undefined;
     const [logoutError, result] = await catchError2(logout({ file }));
     if (logoutError) {
       OutputFormatter2.error({
@@ -623,10 +625,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path) {
+  if (!path)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -937,11 +939,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path);
     return iss;
   });
 }
@@ -1179,7 +1181,7 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path3 = []) => {
+  const processError = (error2, path = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1189,7 +1191,7 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1221,8 +1223,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13497,13 +13499,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path = ref.slice(1).split("/").filter(Boolean);
+  if (path.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path[0] === defsKey) {
+    const key = path[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14271,7 +14273,12 @@ class BufferSink {
 }
 
 // src/mcp/cli-bridge.ts
-import { getOutputSink, runWithSink, setGlobalSink } from "@uipath/common";
+import {
+  catchError as catchError3,
+  getOutputSink,
+  runWithSink,
+  setGlobalSink
+} from "@uipath/common";
 async function executeCommand(command) {
   const args = command.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
   const cleanArgs = args.map((a) => a.replace(/^["']|["']$/g, ""));
@@ -14293,22 +14300,20 @@ async function executeCommand(command) {
     }
   };
   const previousSink = getOutputSink();
-  try {
-    setGlobalSink(sink);
-    await runWithSink(sink, async () => {
-      const { run } = await Promise.resolve().then(() => (init_cli(), exports_cli));
-      await run(context);
-    });
-  } catch (error48) {
+  setGlobalSink(sink);
+  const [error48] = await catchError3(runWithSink(sink, async () => {
+    const { run } = await Promise.resolve().then(() => (init_cli(), exports_cli));
+    await run(context);
+  }));
+  if (error48) {
     if (error48 instanceof ExitError) {
       exitCode = error48.exitCode;
     } else {
       exitCode = 1;
       sink.writeErr(error48 instanceof Error ? error48.message : String(error48));
     }
-  } finally {
-    setGlobalSink(previousSink);
   }
+  setGlobalSink(previousSink);
   return { stdout: sink.stdout, stderr: sink.stderr, exitCode };
 }
 var ExitError;
@@ -14358,7 +14363,7 @@ function introspectCommands(program) {
   }
   lines.push(`
 Global Options (can be used with any command):`, "  --output <table|json|yaml|plain>: Output format (default: json)", "  --output-filter <expression>: JMESPath expression to filter output", "  --log-level <debug|info|warn|error>: Log level threshold (default: info)", "  --log-file <path>: Write logs to file instead of stderr", `
-Pass the command without the 'uip' prefix. Example: "login status --output json"`, `Filter example: "tools installed --output-filter 'Data[].name'"`);
+Pass the command without the 'uip' prefix. Example: "login status --output json"`, `Filter example: "tools list --output-filter 'Data[].name'"`);
   return lines.join(`
 `);
 }
@@ -14802,8 +14807,8 @@ class ParseStatus {
   }
 }
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path, errorMaps, issueData } = params;
+  const fullPath = [...path, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -14848,11 +14853,11 @@ var init_errorUtil = __esm(() => {
 
 // ../../node_modules/zod/v3/types.js
 class ParseInputLazyPath {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path;
     this._key = key;
   }
   get path() {
@@ -18429,7 +18434,7 @@ var init_types2 = __esm(() => {
   ProgressTokenSchema = union([string2(), number2().int()]);
   CursorSchema = string2();
   TaskCreationParamsSchema = looseObject({
-    ttl: union([number2(), _null3()]).optional(),
+    ttl: number2().optional(),
     pollInterval: number2().optional()
   });
   TaskMetadataSchema = object({
@@ -18577,7 +18582,8 @@ var init_types2 = __esm(() => {
     roots: object({
       listChanged: boolean2().optional()
     }).optional(),
-    tasks: ClientTasksCapabilitySchema.optional()
+    tasks: ClientTasksCapabilitySchema.optional(),
+    extensions: record(string2(), AssertObjectSchema).optional()
   });
   InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
     protocolVersion: string2(),
@@ -18602,7 +18608,8 @@ var init_types2 = __esm(() => {
     tools: object({
       listChanged: boolean2().optional()
     }).optional(),
-    tasks: ServerTasksCapabilitySchema.optional()
+    tasks: ServerTasksCapabilitySchema.optional(),
+    extensions: record(string2(), AssertObjectSchema).optional()
   });
   InitializeResultSchema = ResultSchema.extend({
     protocolVersion: string2(),
@@ -18717,6 +18724,7 @@ var init_types2 = __esm(() => {
     uri: string2(),
     description: optional(string2()),
     mimeType: optional(string2()),
+    size: optional(number2()),
     annotations: AnnotationsSchema.optional(),
     _meta: optional(looseObject({}))
   });
@@ -24665,8 +24673,8 @@ var require_utils = __commonJS((exports, module) => {
     }
     return ind;
   }
-  function removeDotSegments(path3) {
-    let input = path3;
+  function removeDotSegments(path) {
+    let input = path;
     const output = [];
     let nextSlash = -1;
     let len = 0;
@@ -24856,8 +24864,8 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path3, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path3 && path3 !== "/" ? path3 : undefined;
+      const [path, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path && path !== "/" ? path : undefined;
       wsComponent.query = query;
       wsComponent.resourceName = undefined;
     }
@@ -26083,6 +26091,7 @@ var require_limitLength = __commonJS((exports) => {
 var require_pattern = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code2();
+  var util_1 = require_util();
   var codegen_1 = require_codegen();
   var error48 = {
     message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
@@ -26095,10 +26104,18 @@ var require_pattern = __commonJS((exports) => {
     $data: true,
     error: error48,
     code(cxt) {
-      const { data, $data, schema, schemaCode, it } = cxt;
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
-      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-      cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      if ($data) {
+        const { regExp } = it.opts.code;
+        const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+        const valid = gen.let("valid");
+        gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+        cxt.fail$data((0, codegen_1._)`!${valid}`);
+      } else {
+        const regExp = (0, code_1.usePattern)(cxt, schema);
+        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      }
     }
   };
   exports.default = def;
@@ -29729,16 +29746,16 @@ __export(exports_claude, {
   install: () => install
 });
 import { logger } from "@uipath/common";
-import { getFileSystem } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem3 } from "@uipath/filesystem";
 async function install(skill, rootDir) {
-  const fs = getFileSystem();
+  const fs = getFileSystem3();
   const target = fs.path.join(rootDir, ".claude", "skills", skill.name);
   await fs.mkdir(target);
   await fs.copyDirectory(skill.skillDir, target);
   logger.info(`  claude: installed ${skill.name}`);
 }
 async function uninstall(skillName, rootDir) {
-  const fs = getFileSystem();
+  const fs = getFileSystem3();
   const target = fs.path.join(rootDir, ".claude", "skills", skillName);
   if (await fs.exists(target)) {
     await fs.rm(target);
@@ -32395,15 +32412,15 @@ var init_js_yaml = __esm(() => {
 
 // src/commands/skills/contentStore.ts
 import { spawn } from "node:child_process";
-import { catchError as catchError3, logger as logger2, UIPATH_HOME_DIR } from "@uipath/common";
-import { getFileSystem as getFileSystem2 } from "@uipath/filesystem";
+import { catchError as catchError4, logger as logger2, UIPATH_HOME_DIR } from "@uipath/common";
+import { getFileSystem as getFileSystem4 } from "@uipath/filesystem";
 async function getContentStore(rootDir) {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const storePath = fs.path.join(rootDir, STORE_NAME);
   let needsClone = true;
   if (await fs.exists(fs.path.join(storePath, ".git"))) {
     logger2.info("Updating content store...");
-    const [pullError] = await catchError3(runGit(["pull", "--ff-only"], storePath));
+    const [pullError] = await catchError4(runGit(["pull", "--ff-only"], storePath));
     if (pullError) {
       logger2.warn("git pull failed, re-cloning...");
     } else {
@@ -32421,7 +32438,7 @@ async function getContentStore(rootDir) {
       await fs.rm(storePath);
     }
     await fs.mkdir(storePath);
-    const [cloneError] = await catchError3(runGit(["clone", "--depth", "1", REPO_URL, storePath], rootDir));
+    const [cloneError] = await catchError4(runGit(["clone", "--depth", "1", REPO_URL, storePath], rootDir));
     if (cloneError) {
       logger2.info("git clone failed, falling back to zip download...");
       await downloadAndExtractZip(storePath);
@@ -32432,8 +32449,16 @@ async function getContentStore(rootDir) {
   }
   return storePath;
 }
+async function readSkillDescription(fs, skillMdPath) {
+  const [err, content] = await catchError4(fs.readFile(skillMdPath, { encoding: "utf-8" }));
+  if (err || !content)
+    return;
+  const head = content.length > 2048 ? content.slice(0, 2048) : content;
+  const { meta: meta3 } = parseSkillMd(head);
+  return meta3.description;
+}
 async function getAvailableSkills(storePath) {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const skills = [];
   const rootSkillsDir = fs.path.join(storePath, "skills");
   if (await fs.exists(rootSkillsDir)) {
@@ -32442,7 +32467,8 @@ async function getAvailableSkills(storePath) {
       const skillDir = fs.path.join(rootSkillsDir, name);
       const stat = await fs.stat(skillDir);
       if (stat?.isDirectory() && await fs.exists(fs.path.join(skillDir, "SKILL.md"))) {
-        skills.push({ name, skillDir });
+        const description = await readSkillDescription(fs, fs.path.join(skillDir, "SKILL.md"));
+        skills.push({ name, skillDir, description });
       }
     }
   }
@@ -32462,7 +32488,8 @@ async function getAvailableSkills(storePath) {
       const skillDir = fs.path.join(entrySkillsDir, name);
       const stat = await fs.stat(skillDir);
       if (stat?.isDirectory() && await fs.exists(fs.path.join(skillDir, "SKILL.md"))) {
-        skills.push({ name, skillDir });
+        const description = await readSkillDescription(fs, fs.path.join(skillDir, "SKILL.md"));
+        skills.push({ name, skillDir, description });
       }
     }
   }
@@ -32477,7 +32504,7 @@ function parseSkillMd(content) {
   return { meta: meta3, body: fmMatch[2] };
 }
 async function getSkillMetadata(skillMdPath) {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const content = await fs.readFile(skillMdPath, { encoding: "utf-8" });
   if (content === null) {
     throw new Error(`Skill metadata not found: ${skillMdPath}`);
@@ -32485,7 +32512,7 @@ async function getSkillMetadata(skillMdPath) {
   return parseSkillMd(content);
 }
 function rewriteBody(body, skillDir, targetDir) {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const relFromTarget = fs.path.relative(targetDir, skillDir).split("\\").join("/");
   return body.replace(/(\[.*?\]\()(?!https?:\/\/|\/)([^)]+?)(\))/g, (_match, prefix, relPath, suffix) => {
     const rewritten = [relFromTarget, relPath].join("/").replace(/\/+/g, "/");
@@ -32495,7 +32522,7 @@ function rewriteBody(body, skillDir, targetDir) {
 async function setMarkedBlock(filePath, marker, content, commentStyle = "hash") {
   const startTag = commentStyle === "html" ? `<!-- ${marker} START -->` : `# ${marker} START`;
   const endTag = commentStyle === "html" ? `<!-- ${marker} END -->` : `# ${marker} END`;
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const block = `${startTag}
 ${content}
 ${endTag}`;
@@ -32514,7 +32541,7 @@ ${endTag}`;
   }
 }
 async function removeMarkedBlock(filePath, marker, commentStyle = "hash") {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const startTag = commentStyle === "html" ? `<!-- ${marker} START -->` : `# ${marker} START`;
   const endTag = commentStyle === "html" ? `<!-- ${marker} END -->` : `# ${marker} END`;
   const existing = await fs.readFile(filePath, { encoding: "utf-8" });
@@ -32531,7 +32558,7 @@ async function removeMarkedBlock(filePath, marker, commentStyle = "hash") {
   await fs.writeFile(filePath, updated);
 }
 async function addToGitignore(rootDir, entry) {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const gitignorePath = fs.path.join(rootDir, ".gitignore");
   const content = await fs.readFile(gitignorePath, { encoding: "utf-8" }) ?? "";
   const lines = content.split(`
@@ -32545,19 +32572,19 @@ async function addToGitignore(rootDir, entry) {
   }
 }
 async function readManifest(storePath) {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const manifestPath = fs.path.join(storePath, MANIFEST_NAME);
   const content = await fs.readFile(manifestPath, { encoding: "utf-8" });
   if (content === null) {
     return { skills: {} };
   }
-  const [parseError, parsed] = catchError3(() => JSON.parse(content));
+  const [parseError, parsed] = catchError4(() => JSON.parse(content));
   if (parseError)
     return { skills: {} };
   return parsed;
 }
 async function writeManifest(storePath, manifest) {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const manifestPath = fs.path.join(storePath, MANIFEST_NAME);
   await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 4)}
 `);
@@ -32623,7 +32650,7 @@ function runGit(args, cwd) {
   });
 }
 async function downloadAndExtractZip(storePath) {
-  const fs = getFileSystem2();
+  const fs = getFileSystem4();
   const response = await fetch(ZIP_URL, {
     signal: AbortSignal.timeout(60000)
   });
@@ -32675,9 +32702,9 @@ __export(exports_codex, {
   install: () => install2
 });
 import { logger as logger3 } from "@uipath/common";
-import { getFileSystem as getFileSystem3 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem5 } from "@uipath/filesystem";
 async function install2(skill, rootDir) {
-  const fs = getFileSystem3();
+  const fs = getFileSystem5();
   const isGlobal = fs.path.resolve(rootDir) === fs.path.resolve(fs.env.homedir());
   const targetFile = isGlobal ? fs.path.join(rootDir, ".codex", "instructions.md") : fs.path.join(rootDir, "codex.md");
   await fs.mkdir(fs.path.dirname(targetFile));
@@ -32689,7 +32716,7 @@ async function install2(skill, rootDir) {
   logger3.info(`  codex: installed ${skill.name}`);
 }
 async function uninstall2(skillName, rootDir) {
-  const fs = getFileSystem3();
+  const fs = getFileSystem5();
   const isGlobal = fs.path.resolve(rootDir) === fs.path.resolve(fs.env.homedir());
   const targetFile = isGlobal ? fs.path.join(rootDir, ".codex", "instructions.md") : fs.path.join(rootDir, "codex.md");
   const marker = `uipath-skill:${skillName}`;
@@ -32706,9 +32733,9 @@ __export(exports_copilot, {
   install: () => install3
 });
 import { logger as logger4 } from "@uipath/common";
-import { getFileSystem as getFileSystem4 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem6 } from "@uipath/filesystem";
 async function install3(skill, rootDir) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem6();
   const skillMdPath = fs.path.join(skill.skillDir, "SKILL.md");
   const { meta: meta3, body } = await getSkillMetadata(skillMdPath);
   const targetDir = fs.path.join(rootDir, ".github", "instructions");
@@ -32722,7 +32749,7 @@ applyTo: "${Array.isArray(meta3.globs) ? meta3.globs.join(", ") : meta3.globs}"
   logger4.info(`  copilot: installed ${skill.name}`);
 }
 async function uninstall3(skillName, rootDir) {
-  const fs = getFileSystem4();
+  const fs = getFileSystem6();
   const target = fs.path.join(rootDir, ".github", "instructions", `${skillName}.instructions.md`);
   if (await fs.exists(target)) {
     await fs.rm(target);
@@ -32739,9 +32766,9 @@ __export(exports_cursor, {
   install: () => install4
 });
 import { logger as logger5 } from "@uipath/common";
-import { getFileSystem as getFileSystem5 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem7 } from "@uipath/filesystem";
 async function install4(skill, rootDir) {
-  const fs = getFileSystem5();
+  const fs = getFileSystem7();
   const skillMdPath = fs.path.join(skill.skillDir, "SKILL.md");
   const { meta: meta3, body } = await getSkillMetadata(skillMdPath);
   const targetDir = fs.path.join(rootDir, ".cursor", "rules");
@@ -32752,7 +32779,7 @@ async function install4(skill, rootDir) {
   logger5.info(`  cursor: installed ${skill.name}`);
 }
 async function uninstall4(skillName, rootDir) {
-  const fs = getFileSystem5();
+  const fs = getFileSystem7();
   const target = fs.path.join(rootDir, ".cursor", "rules", `${skillName}.mdc`);
   if (await fs.exists(target)) {
     await fs.rm(target);
@@ -32784,9 +32811,9 @@ __export(exports_gemini, {
   install: () => install5
 });
 import { logger as logger6 } from "@uipath/common";
-import { getFileSystem as getFileSystem6 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem8 } from "@uipath/filesystem";
 async function install5(skill, rootDir) {
-  const fs = getFileSystem6();
+  const fs = getFileSystem8();
   const geminiDir = fs.path.join(rootDir, ".gemini");
   const geminiMd = fs.path.join(geminiDir, "GEMINI.md");
   await fs.mkdir(geminiDir);
@@ -32798,7 +32825,7 @@ async function install5(skill, rootDir) {
   logger6.info(`  gemini: installed ${skill.name}`);
 }
 async function uninstall5(skillName, rootDir) {
-  const fs = getFileSystem6();
+  const fs = getFileSystem8();
   const geminiMd = fs.path.join(rootDir, ".gemini", "GEMINI.md");
   const marker = `uipath-skill:${skillName}`;
   await removeMarkedBlock(geminiMd, marker, "html");
@@ -32827,74 +32854,1884 @@ var init_agents = __esm(() => {
   };
 });
 
-// src/commands/skills/prompt.ts
-import { createInterface } from "node:readline";
-function ask(rl, prompt) {
-  return new Promise((resolve, reject) => {
-    rl.question(prompt, (line) => {
-      resolve(line.trim());
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/key.js
+var isUpKey = (key, keybindings = []) => key.name === "up" || keybindings.includes("vim") && key.name === "k" || keybindings.includes("emacs") && key.ctrl && key.name === "p", isDownKey = (key, keybindings = []) => key.name === "down" || keybindings.includes("vim") && key.name === "j" || keybindings.includes("emacs") && key.ctrl && key.name === "n", isSpaceKey = (key) => key.name === "space", isNumberKey = (key) => "1234567890".includes(key.name), isEnterKey = (key) => key.name === "enter" || key.name === "return";
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/errors.js
+var AbortPromptError, CancelPromptError, ExitPromptError, HookError, ValidationError;
+var init_errors4 = __esm(() => {
+  AbortPromptError = class AbortPromptError extends Error {
+    name = "AbortPromptError";
+    message = "Prompt was aborted";
+    constructor(options) {
+      super();
+      this.cause = options?.cause;
+    }
+  };
+  CancelPromptError = class CancelPromptError extends Error {
+    name = "CancelPromptError";
+    message = "Prompt was canceled";
+  };
+  ExitPromptError = class ExitPromptError extends Error {
+    name = "ExitPromptError";
+  };
+  HookError = class HookError extends Error {
+    name = "HookError";
+  };
+  ValidationError = class ValidationError extends Error {
+    name = "ValidationError";
+  };
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/hook-engine.js
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
+function createStore(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {}
+  };
+  return store;
+}
+function withHooks(rl, cb) {
+  const store = createStore(rl);
+  return hookStorage.run(store, () => {
+    function cycle(render) {
+      store.handleChange = () => {
+        store.index = 0;
+        render();
+      };
+      store.handleChange();
+    }
+    return cb(cycle);
+  });
+}
+function getStore() {
+  const store = hookStorage.getStore();
+  if (!store) {
+    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
+  }
+  return store;
+}
+function readline() {
+  return getStore().rl;
+}
+function withUpdates(fn) {
+  const wrapped = (...args) => {
+    const store = getStore();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+  const store = getStore();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value) {
+      store.hooks[index] = value;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange() {
+  getStore().handleChange();
+}
+var hookStorage, effectScheduler;
+var init_hook_engine = __esm(() => {
+  init_errors4();
+  hookStorage = new AsyncLocalStorage;
+  effectScheduler = {
+    queue(cb) {
+      const store = getStore();
+      const { index } = store;
+      store.hooksEffect.push(() => {
+        store.hooksCleanup[index]?.();
+        const cleanFn = cb(readline());
+        if (cleanFn != null && typeof cleanFn !== "function") {
+          throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+        }
+        store.hooksCleanup[index] = cleanFn;
+      });
+    },
+    run() {
+      const store = getStore();
+      withUpdates(() => {
+        store.hooksEffect.forEach((effect) => {
+          effect();
+        });
+        store.hooksEffect.length = 0;
+      })();
+    },
+    clearAll() {
+      const store = getStore();
+      store.hooksCleanup.forEach((cleanFn) => {
+        cleanFn?.();
+      });
+      store.hooksEffect.length = 0;
+      store.hooksCleanup.length = 0;
+    }
+  };
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/use-state.js
+import { AsyncResource as AsyncResource2 } from "node:async_hooks";
+function useState(defaultValue) {
+  return withPointer((pointer) => {
+    const setState = AsyncResource2.bind(function setState2(newValue) {
+      if (pointer.get() !== newValue) {
+        pointer.set(newValue);
+        handleChange();
+      }
     });
-    rl.once("close", () => reject(new Error("Input stream closed before selection.")));
+    if (pointer.initialized) {
+      return [pointer.get(), setState];
+    }
+    const value = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+    pointer.set(value);
+    return [value, setState];
   });
 }
-async function promptAgentSelection(operation = "manage") {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stderr
+var init_use_state = __esm(() => {
+  init_hook_engine();
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/use-effect.js
+function useEffect(cb, depArray) {
+  withPointer((pointer) => {
+    const oldDeps = pointer.get();
+    const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i2) => !Object.is(dep, oldDeps[i2]));
+    if (hasChanged) {
+      effectScheduler.queue(cb);
+    }
+    pointer.set(depArray);
   });
-  const prompt = `
-Select agents to ${operation} skills for:
-` + ALL_AGENTS.map((a, i2) => `  ${i2 + 1}. ${AGENT_DISPLAY_NAMES[a]}`).join(`
-`) + `
+}
+var init_use_effect = __esm(() => {
+  init_hook_engine();
+});
 
-Enter numbers separated by commas (e.g., 1,2,3) or 'all': `;
-  try {
+// ../../node_modules/@inquirer/figures/dist/index.js
+import process4 from "node:process";
+function isUnicodeSupported() {
+  if (process4.platform !== "win32") {
+    return process4.env["TERM"] !== "linux";
+  }
+  return Boolean(process4.env["WT_SESSION"]) || Boolean(process4.env["TERMINUS_SUBLIME"]) || process4.env["ConEmuTask"] === "{cmd::Cmder}" || process4.env["TERM_PROGRAM"] === "Terminus-Sublime" || process4.env["TERM_PROGRAM"] === "vscode" || process4.env["TERM"] === "xterm-256color" || process4.env["TERM"] === "alacritty" || process4.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+var common2, specialMainSymbols, specialFallbackSymbols, mainSymbols, fallbackSymbols, shouldUseMain, figures, dist_default, replacements;
+var init_dist = __esm(() => {
+  common2 = {
+    circleQuestionMark: "(?)",
+    questionMarkPrefix: "(?)",
+    square: "█",
+    squareDarkShade: "▓",
+    squareMediumShade: "▒",
+    squareLightShade: "░",
+    squareTop: "▀",
+    squareBottom: "▄",
+    squareLeft: "▌",
+    squareRight: "▐",
+    squareCenter: "■",
+    bullet: "●",
+    dot: "․",
+    ellipsis: "…",
+    pointerSmall: "›",
+    triangleUp: "▲",
+    triangleUpSmall: "▴",
+    triangleDown: "▼",
+    triangleDownSmall: "▾",
+    triangleLeftSmall: "◂",
+    triangleRightSmall: "▸",
+    home: "⌂",
+    heart: "♥",
+    musicNote: "♪",
+    musicNoteBeamed: "♫",
+    arrowUp: "↑",
+    arrowDown: "↓",
+    arrowLeft: "←",
+    arrowRight: "→",
+    arrowLeftRight: "↔",
+    arrowUpDown: "↕",
+    almostEqual: "≈",
+    notEqual: "≠",
+    lessOrEqual: "≤",
+    greaterOrEqual: "≥",
+    identical: "≡",
+    infinity: "∞",
+    subscriptZero: "₀",
+    subscriptOne: "₁",
+    subscriptTwo: "₂",
+    subscriptThree: "₃",
+    subscriptFour: "₄",
+    subscriptFive: "₅",
+    subscriptSix: "₆",
+    subscriptSeven: "₇",
+    subscriptEight: "₈",
+    subscriptNine: "₉",
+    oneHalf: "½",
+    oneThird: "⅓",
+    oneQuarter: "¼",
+    oneFifth: "⅕",
+    oneSixth: "⅙",
+    oneEighth: "⅛",
+    twoThirds: "⅔",
+    twoFifths: "⅖",
+    threeQuarters: "¾",
+    threeFifths: "⅗",
+    threeEighths: "⅜",
+    fourFifths: "⅘",
+    fiveSixths: "⅚",
+    fiveEighths: "⅝",
+    sevenEighths: "⅞",
+    line: "─",
+    lineBold: "━",
+    lineDouble: "═",
+    lineDashed0: "┄",
+    lineDashed1: "┅",
+    lineDashed2: "┈",
+    lineDashed3: "┉",
+    lineDashed4: "╌",
+    lineDashed5: "╍",
+    lineDashed6: "╴",
+    lineDashed7: "╶",
+    lineDashed8: "╸",
+    lineDashed9: "╺",
+    lineDashed10: "╼",
+    lineDashed11: "╾",
+    lineDashed12: "−",
+    lineDashed13: "–",
+    lineDashed14: "‐",
+    lineDashed15: "⁃",
+    lineVertical: "│",
+    lineVerticalBold: "┃",
+    lineVerticalDouble: "║",
+    lineVerticalDashed0: "┆",
+    lineVerticalDashed1: "┇",
+    lineVerticalDashed2: "┊",
+    lineVerticalDashed3: "┋",
+    lineVerticalDashed4: "╎",
+    lineVerticalDashed5: "╏",
+    lineVerticalDashed6: "╵",
+    lineVerticalDashed7: "╷",
+    lineVerticalDashed8: "╹",
+    lineVerticalDashed9: "╻",
+    lineVerticalDashed10: "╽",
+    lineVerticalDashed11: "╿",
+    lineDownLeft: "┐",
+    lineDownLeftArc: "╮",
+    lineDownBoldLeftBold: "┓",
+    lineDownBoldLeft: "┒",
+    lineDownLeftBold: "┑",
+    lineDownDoubleLeftDouble: "╗",
+    lineDownDoubleLeft: "╖",
+    lineDownLeftDouble: "╕",
+    lineDownRight: "┌",
+    lineDownRightArc: "╭",
+    lineDownBoldRightBold: "┏",
+    lineDownBoldRight: "┎",
+    lineDownRightBold: "┍",
+    lineDownDoubleRightDouble: "╔",
+    lineDownDoubleRight: "╓",
+    lineDownRightDouble: "╒",
+    lineUpLeft: "┘",
+    lineUpLeftArc: "╯",
+    lineUpBoldLeftBold: "┛",
+    lineUpBoldLeft: "┚",
+    lineUpLeftBold: "┙",
+    lineUpDoubleLeftDouble: "╝",
+    lineUpDoubleLeft: "╜",
+    lineUpLeftDouble: "╛",
+    lineUpRight: "└",
+    lineUpRightArc: "╰",
+    lineUpBoldRightBold: "┗",
+    lineUpBoldRight: "┖",
+    lineUpRightBold: "┕",
+    lineUpDoubleRightDouble: "╚",
+    lineUpDoubleRight: "╙",
+    lineUpRightDouble: "╘",
+    lineUpDownLeft: "┤",
+    lineUpBoldDownBoldLeftBold: "┫",
+    lineUpBoldDownBoldLeft: "┨",
+    lineUpDownLeftBold: "┥",
+    lineUpBoldDownLeftBold: "┩",
+    lineUpDownBoldLeftBold: "┪",
+    lineUpDownBoldLeft: "┧",
+    lineUpBoldDownLeft: "┦",
+    lineUpDoubleDownDoubleLeftDouble: "╣",
+    lineUpDoubleDownDoubleLeft: "╢",
+    lineUpDownLeftDouble: "╡",
+    lineUpDownRight: "├",
+    lineUpBoldDownBoldRightBold: "┣",
+    lineUpBoldDownBoldRight: "┠",
+    lineUpDownRightBold: "┝",
+    lineUpBoldDownRightBold: "┡",
+    lineUpDownBoldRightBold: "┢",
+    lineUpDownBoldRight: "┟",
+    lineUpBoldDownRight: "┞",
+    lineUpDoubleDownDoubleRightDouble: "╠",
+    lineUpDoubleDownDoubleRight: "╟",
+    lineUpDownRightDouble: "╞",
+    lineDownLeftRight: "┬",
+    lineDownBoldLeftBoldRightBold: "┳",
+    lineDownLeftBoldRightBold: "┯",
+    lineDownBoldLeftRight: "┰",
+    lineDownBoldLeftBoldRight: "┱",
+    lineDownBoldLeftRightBold: "┲",
+    lineDownLeftRightBold: "┮",
+    lineDownLeftBoldRight: "┭",
+    lineDownDoubleLeftDoubleRightDouble: "╦",
+    lineDownDoubleLeftRight: "╥",
+    lineDownLeftDoubleRightDouble: "╤",
+    lineUpLeftRight: "┴",
+    lineUpBoldLeftBoldRightBold: "┻",
+    lineUpLeftBoldRightBold: "┷",
+    lineUpBoldLeftRight: "┸",
+    lineUpBoldLeftBoldRight: "┹",
+    lineUpBoldLeftRightBold: "┺",
+    lineUpLeftRightBold: "┶",
+    lineUpLeftBoldRight: "┵",
+    lineUpDoubleLeftDoubleRightDouble: "╩",
+    lineUpDoubleLeftRight: "╨",
+    lineUpLeftDoubleRightDouble: "╧",
+    lineUpDownLeftRight: "┼",
+    lineUpBoldDownBoldLeftBoldRightBold: "╋",
+    lineUpDownBoldLeftBoldRightBold: "╈",
+    lineUpBoldDownLeftBoldRightBold: "╇",
+    lineUpBoldDownBoldLeftRightBold: "╊",
+    lineUpBoldDownBoldLeftBoldRight: "╉",
+    lineUpBoldDownLeftRight: "╀",
+    lineUpDownBoldLeftRight: "╁",
+    lineUpDownLeftBoldRight: "┽",
+    lineUpDownLeftRightBold: "┾",
+    lineUpBoldDownBoldLeftRight: "╂",
+    lineUpDownLeftBoldRightBold: "┿",
+    lineUpBoldDownLeftBoldRight: "╃",
+    lineUpBoldDownLeftRightBold: "╄",
+    lineUpDownBoldLeftBoldRight: "╅",
+    lineUpDownBoldLeftRightBold: "╆",
+    lineUpDoubleDownDoubleLeftDoubleRightDouble: "╬",
+    lineUpDoubleDownDoubleLeftRight: "╫",
+    lineUpDownLeftDoubleRightDouble: "╪",
+    lineCross: "╳",
+    lineBackslash: "╲",
+    lineSlash: "╱"
+  };
+  specialMainSymbols = {
+    tick: "✔",
+    info: "ℹ",
+    warning: "⚠",
+    cross: "✘",
+    squareSmall: "◻",
+    squareSmallFilled: "◼",
+    circle: "◯",
+    circleFilled: "◉",
+    circleDotted: "◌",
+    circleDouble: "◎",
+    circleCircle: "ⓞ",
+    circleCross: "ⓧ",
+    circlePipe: "Ⓘ",
+    radioOn: "◉",
+    radioOff: "◯",
+    checkboxOn: "☒",
+    checkboxOff: "☐",
+    checkboxCircleOn: "ⓧ",
+    checkboxCircleOff: "Ⓘ",
+    pointer: "❯",
+    triangleUpOutline: "△",
+    triangleLeft: "◀",
+    triangleRight: "▶",
+    lozenge: "◆",
+    lozengeOutline: "◇",
+    hamburger: "☰",
+    smiley: "㋡",
+    mustache: "෴",
+    star: "★",
+    play: "▶",
+    nodejs: "⬢",
+    oneSeventh: "⅐",
+    oneNinth: "⅑",
+    oneTenth: "⅒"
+  };
+  specialFallbackSymbols = {
+    tick: "√",
+    info: "i",
+    warning: "‼",
+    cross: "×",
+    squareSmall: "□",
+    squareSmallFilled: "■",
+    circle: "( )",
+    circleFilled: "(*)",
+    circleDotted: "( )",
+    circleDouble: "( )",
+    circleCircle: "(○)",
+    circleCross: "(×)",
+    circlePipe: "(│)",
+    radioOn: "(*)",
+    radioOff: "( )",
+    checkboxOn: "[×]",
+    checkboxOff: "[ ]",
+    checkboxCircleOn: "(×)",
+    checkboxCircleOff: "( )",
+    pointer: ">",
+    triangleUpOutline: "∆",
+    triangleLeft: "◄",
+    triangleRight: "►",
+    lozenge: "♦",
+    lozengeOutline: "◊",
+    hamburger: "≡",
+    smiley: "☺",
+    mustache: "┌─┐",
+    star: "✶",
+    play: "►",
+    nodejs: "♦",
+    oneSeventh: "1/7",
+    oneNinth: "1/9",
+    oneTenth: "1/10"
+  };
+  mainSymbols = {
+    ...common2,
+    ...specialMainSymbols
+  };
+  fallbackSymbols = {
+    ...common2,
+    ...specialFallbackSymbols
+  };
+  shouldUseMain = isUnicodeSupported();
+  figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+  dist_default = figures;
+  replacements = Object.entries(specialMainSymbols);
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/theme.js
+import { styleText } from "node:util";
+var defaultTheme;
+var init_theme = __esm(() => {
+  init_dist();
+  defaultTheme = {
+    prefix: {
+      idle: styleText("blue", "?"),
+      done: styleText("green", dist_default.tick)
+    },
+    spinner: {
+      interval: 80,
+      frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].map((frame) => styleText("yellow", frame))
+    },
+    style: {
+      answer: (text) => styleText("cyan", text),
+      message: (text) => styleText("bold", text),
+      error: (text) => styleText("red", `> ${text}`),
+      defaultAnswer: (text) => styleText("dim", `(${text})`),
+      help: (text) => styleText("dim", text),
+      highlight: (text) => styleText("cyan", text),
+      key: (text) => styleText("cyan", styleText("bold", `<${text}>`))
+    }
+  };
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/make-theme.js
+function isPlainObject3(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+  const output = {};
+  for (const obj of objects) {
+    for (const [key, value] of Object.entries(obj)) {
+      const prevValue = output[key];
+      output[key] = isPlainObject3(prevValue) && isPlainObject3(value) ? deepMerge(prevValue, value) : value;
+    }
+  }
+  return output;
+}
+function makeTheme(...themes) {
+  const themesToMerge = [
+    defaultTheme,
+    ...themes.filter((theme) => theme != null)
+  ];
+  return deepMerge(...themesToMerge);
+}
+var init_make_theme = __esm(() => {
+  init_theme();
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/use-prefix.js
+function usePrefix({ status = "idle", theme }) {
+  const [showLoader, setShowLoader] = useState(false);
+  const [tick, setTick] = useState(0);
+  const { prefix, spinner } = makeTheme(theme);
+  useEffect(() => {
+    if (status === "loading") {
+      let tickInterval;
+      let inc = -1;
+      const delayTimeout = setTimeout(() => {
+        setShowLoader(true);
+        tickInterval = setInterval(() => {
+          inc = inc + 1;
+          setTick(inc % spinner.frames.length);
+        }, spinner.interval);
+      }, 300);
+      return () => {
+        clearTimeout(delayTimeout);
+        clearInterval(tickInterval);
+      };
+    } else {
+      setShowLoader(false);
+    }
+  }, [status]);
+  if (showLoader) {
+    return spinner.frames[tick];
+  }
+  const iconName = status === "loading" ? "idle" : status;
+  return typeof prefix === "string" ? prefix : prefix[iconName] ?? prefix["idle"];
+}
+var init_use_prefix = __esm(() => {
+  init_use_state();
+  init_use_effect();
+  init_make_theme();
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/use-memo.js
+function useMemo(fn, dependencies) {
+  return withPointer((pointer) => {
+    const prev = pointer.get();
+    if (!prev || prev.dependencies.length !== dependencies.length || prev.dependencies.some((dep, i2) => dep !== dependencies[i2])) {
+      const value = fn();
+      pointer.set({ value, dependencies });
+      return value;
+    }
+    return prev.value;
+  });
+}
+var init_use_memo = __esm(() => {
+  init_hook_engine();
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/use-ref.js
+function useRef(val) {
+  return useState({ current: val })[0];
+}
+var init_use_ref = __esm(() => {
+  init_use_state();
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/use-keypress.js
+function useKeypress(userHandler) {
+  const signal = useRef(userHandler);
+  signal.current = userHandler;
+  useEffect((rl) => {
+    let ignore = false;
+    const handler = withUpdates((_input, event) => {
+      if (ignore)
+        return;
+      signal.current(event, rl);
+    });
+    rl.input.on("keypress", handler);
+    return () => {
+      ignore = true;
+      rl.input.removeListener("keypress", handler);
+    };
+  }, []);
+}
+var init_use_keypress = __esm(() => {
+  init_use_ref();
+  init_use_effect();
+  init_hook_engine();
+});
+
+// ../../node_modules/cli-width/index.js
+var require_cli_width = __commonJS((exports, module) => {
+  module.exports = cliWidth;
+  function normalizeOpts(options) {
+    const defaultOpts = {
+      defaultWidth: 0,
+      output: process.stdout,
+      tty: __require("tty")
+    };
+    if (!options) {
+      return defaultOpts;
+    }
+    Object.keys(defaultOpts).forEach(function(key) {
+      if (!options[key]) {
+        options[key] = defaultOpts[key];
+      }
+    });
+    return options;
+  }
+  function cliWidth(options) {
+    const opts = normalizeOpts(options);
+    if (opts.output.getWindowSize) {
+      return opts.output.getWindowSize()[0] || opts.defaultWidth;
+    }
+    if (opts.tty.getWindowSize) {
+      return opts.tty.getWindowSize()[1] || opts.defaultWidth;
+    }
+    if (opts.output.columns) {
+      return opts.output.columns;
+    }
+    if (process.env.CLI_WIDTH) {
+      const width = parseInt(process.env.CLI_WIDTH, 10);
+      if (!isNaN(width) && width !== 0) {
+        return width;
+      }
+    }
+    return opts.defaultWidth;
+  }
+});
+
+// ../../node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength, isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+}, isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+var init_utils = __esm(() => {
+  getCodePointsLength = (() => {
+    const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+    return (input) => {
+      let surrogatePairsNr = 0;
+      SURROGATE_PAIR_RE.lastIndex = 0;
+      while (SURROGATE_PAIR_RE.test(input)) {
+        surrogatePairsNr += 1;
+      }
+      return input.length - surrogatePairsNr;
+    };
+  })();
+});
+
+// ../../node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE, CONTROL_RE, CJKT_WIDE_RE, TAB_RE, EMOJI_RE, LATIN_RE, MODIFIER_RE, NO_TRUNCATION, getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
     while (true) {
-      const answer = await ask(rl, prompt);
-      if (answer.toLowerCase() === "all" || answer === "") {
-        return [...ALL_AGENTS];
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index >= length) {
+        break outer;
+      }
+      for (let i2 = 0, l = PARSE_BLOCKS.length;i2 < l; i2++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i2];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+}, dist_default2;
+var init_dist2 = __esm(() => {
+  init_utils();
+  ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+  CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+  CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+  TAB_RE = /\t{1,1000}/y;
+  EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+  LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+  MODIFIER_RE = /\p{M}+/gu;
+  NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+  dist_default2 = getStringTruncatedWidth;
+});
+
+// ../../node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2, fastStringWidth = (input, options = {}) => {
+  return dist_default2(input, NO_TRUNCATION2, options).width;
+}, dist_default3;
+var init_dist3 = __esm(() => {
+  init_dist2();
+  NO_TRUNCATION2 = {
+    limit: Infinity,
+    ellipsis: "",
+    ellipsisWidth: 0
+  };
+  dist_default3 = fastStringWidth;
+});
+
+// ../../node_modules/fast-wrap-ansi/lib/main.js
+function wrapAnsi(string5, columns, options) {
+  return String(string5).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+var ESC = "\x1B", CSI = "›", END_CODE = 39, ANSI_ESCAPE_BELL = "\x07", ANSI_CSI = "[", ANSI_OSC = "]", ANSI_SGR_TERMINATOR = "m", ANSI_ESCAPE_LINK, GROUP_REGEX, getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+}, wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`, wrapAnsiHyperlink = (url2) => `${ESC}${ANSI_ESCAPE_LINK}${url2}${ANSI_ESCAPE_BELL}`, wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default3(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default3(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
       }
-      const indices = answer.split(",").map((s) => Number.parseInt(s.trim(), 10) - 1).filter((i2) => i2 >= 0 && i2 < ALL_AGENTS.length);
-      if (indices.length > 0) {
-        return [...new Set(indices.map((i2) => ALL_AGENTS[i2]))];
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+}, stringVisibleTrimSpacesRight = (string5) => {
+  const words = string5.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default3(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string5;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+}, exec = (string5, columns, options = {}) => {
+  if (options.trim !== false && string5.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string5.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default3(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default3(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default3(rows.at(-1) ?? "");
+        continue;
       }
-      rl.write(`Invalid input. Enter numbers (1-5), comma-separated, or 'all'.
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
 `);
+  let inSurrogate = false;
+  for (let i2 = 0;i2 < preString.length; i2++) {
+    const character = preString[i2];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i2 + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i2 + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
     }
-  } finally {
-    rl.close();
   }
+  return returnValue;
+}, CRLF_OR_LF;
+var init_main = __esm(() => {
+  init_dist3();
+  ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+  GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+  CRLF_OR_LF = /\r?\n/;
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/utils.js
+function breakLines(content, width) {
+  return content.split(`
+`).flatMap((line) => wrapAnsi(line, width, { trim: false, hard: true }).split(`
+`).map((str2) => str2.trimEnd())).join(`
+`);
+}
+function readlineWidth() {
+  return import_cli_width.default({ defaultWidth: 80, output: readline().output });
 }
-async function promptSkillSelection(availableSkills, operation = "manage") {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stderr
+var import_cli_width;
+var init_utils2 = __esm(() => {
+  init_main();
+  init_hook_engine();
+  import_cli_width = __toESM(require_cli_width(), 1);
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+function usePointerPosition({ active, renderedItems, pageSize, loop }) {
+  const state = useRef({
+    lastPointer: active,
+    lastActive: undefined
+  });
+  const { lastPointer, lastActive } = state.current;
+  const middle = Math.floor(pageSize / 2);
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const defaultPointerPosition = renderedItems.slice(0, active).reduce((acc, item) => acc + item.length, 0);
+  let pointer = defaultPointerPosition;
+  if (renderedLength > pageSize) {
+    if (loop) {
+      pointer = lastPointer;
+      if (lastActive != null && lastActive < active && active - lastActive < pageSize) {
+        pointer = Math.min(middle, Math.abs(active - lastActive) === 1 ? Math.min(lastPointer + (renderedItems[lastActive]?.length ?? 0), Math.max(defaultPointerPosition, lastPointer)) : lastPointer + active - lastActive);
+      }
+    } else {
+      const spaceUnderActive = renderedItems.slice(active).reduce((acc, item) => acc + item.length, 0);
+      pointer = spaceUnderActive < pageSize - middle ? pageSize - spaceUnderActive : Math.min(defaultPointerPosition, middle);
+    }
+  }
+  state.current.lastPointer = pointer;
+  state.current.lastActive = active;
+  return pointer;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true }) {
+  const width = readlineWidth();
+  const bound = (num) => (num % items.length + items.length) % items.length;
+  const renderedItems = items.map((item, index) => {
+    if (item == null)
+      return [];
+    return breakLines(renderItem({ item, index, isActive: index === active }), width).split(`
+`);
   });
-  const prompt = `
-Select skills to ${operation}:
-` + availableSkills.map((s, i2) => `  ${i2 + 1}. ${s}`).join(`
-`) + `
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+  const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+  const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+  const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+  const pageBuffer = Array.from({ length: pageSize });
+  pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+  const itemVisited = new Set([active]);
+  let bufferPointer = activeItemPosition + activeItem.length;
+  let itemPointer = bound(active + 1);
+  while (bufferPointer < pageSize && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+    pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer += linesToAdd.length;
+    itemPointer = bound(itemPointer + 1);
+  }
+  bufferPointer = activeItemPosition - 1;
+  itemPointer = bound(active - 1);
+  while (bufferPointer >= 0 && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+    pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer -= linesToAdd.length;
+    itemPointer = bound(itemPointer - 1);
+  }
+  return pageBuffer.filter((line) => typeof line === "string").join(`
+`);
+}
+var init_use_pagination = __esm(() => {
+  init_use_ref();
+  init_utils2();
+});
 
-Enter numbers separated by commas (e.g., 1,2,3) or 'all': `;
-  try {
-    while (true) {
-      const answer = await ask(rl, prompt);
-      if (answer.toLowerCase() === "all" || answer === "") {
-        return [...availableSkills];
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/node_modules/mute-stream/lib/index.js
+var require_lib = __commonJS((exports, module) => {
+  var Stream = __require("stream");
+
+  class MuteStream extends Stream {
+    #isTTY = null;
+    constructor(opts = {}) {
+      super(opts);
+      this.writable = this.readable = true;
+      this.muted = false;
+      this.on("pipe", this._onpipe);
+      this.replace = opts.replace;
+      this._prompt = opts.prompt || null;
+      this._hadControl = false;
+    }
+    #destSrc(key, def) {
+      if (this._dest) {
+        return this._dest[key];
       }
-      const indices = answer.split(",").map((s) => Number.parseInt(s.trim(), 10) - 1).filter((i2) => i2 >= 0 && i2 < availableSkills.length);
-      if (indices.length > 0) {
-        return [...new Set(indices.map((i2) => availableSkills[i2]))];
+      if (this._src) {
+        return this._src[key];
       }
-      rl.write(`Invalid input. Enter numbers (1-${availableSkills.length}), comma-separated, or 'all'.
-`);
+      return def;
+    }
+    #proxy(method, ...args) {
+      if (typeof this._dest?.[method] === "function") {
+        this._dest[method](...args);
+      }
+      if (typeof this._src?.[method] === "function") {
+        this._src[method](...args);
+      }
+    }
+    get isTTY() {
+      if (this.#isTTY !== null) {
+        return this.#isTTY;
+      }
+      return this.#destSrc("isTTY", false);
+    }
+    set isTTY(val) {
+      this.#isTTY = val;
+    }
+    get rows() {
+      return this.#destSrc("rows");
+    }
+    get columns() {
+      return this.#destSrc("columns");
+    }
+    mute() {
+      this.muted = true;
+    }
+    unmute() {
+      this.muted = false;
+    }
+    _onpipe(src) {
+      this._src = src;
+    }
+    pipe(dest, options) {
+      this._dest = dest;
+      return super.pipe(dest, options);
+    }
+    pause() {
+      if (this._src) {
+        return this._src.pause();
+      }
+    }
+    resume() {
+      if (this._src) {
+        return this._src.resume();
+      }
+    }
+    write(c) {
+      if (this.muted) {
+        if (!this.replace) {
+          return true;
+        }
+        if (c.match(/^\u001b/)) {
+          if (c.indexOf(this._prompt) === 0) {
+            c = c.slice(this._prompt.length);
+            c = c.replace(/./g, this.replace);
+            c = this._prompt + c;
+          }
+          this._hadControl = true;
+          return this.emit("data", c);
+        } else {
+          if (this._prompt && this._hadControl && c.indexOf(this._prompt) === 0) {
+            this._hadControl = false;
+            this.emit("data", this._prompt);
+            c = c.slice(this._prompt.length);
+          }
+          c = c.toString().replace(/./g, this.replace);
+        }
+      }
+      this.emit("data", c);
+    }
+    end(c) {
+      if (this.muted) {
+        if (c && this.replace) {
+          c = c.toString().replace(/./g, this.replace);
+        } else {
+          c = null;
+        }
+      }
+      if (c) {
+        this.emit("data", c);
+      }
+      this.emit("end");
+    }
+    destroy(...args) {
+      return this.#proxy("destroy", ...args);
+    }
+    destroySoon(...args) {
+      return this.#proxy("destroySoon", ...args);
+    }
+    close(...args) {
+      return this.#proxy("close", ...args);
+    }
+  }
+  module.exports = MuteStream;
+});
+
+// ../../node_modules/signal-exit/dist/mjs/signals.js
+var signals;
+var init_signals = __esm(() => {
+  signals = [];
+  signals.push("SIGHUP", "SIGINT", "SIGTERM");
+  if (process.platform !== "win32") {
+    signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+  }
+  if (process.platform === "linux") {
+    signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+  }
+});
+
+// ../../node_modules/signal-exit/dist/mjs/index.js
+class Emitter {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i2 = list.indexOf(fn);
+    if (i2 === -1) {
+      return;
+    }
+    if (i2 === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i2, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+}
+
+class SignalExitBase {
+}
+var processOk = (process5) => !!process5 && typeof process5 === "object" && typeof process5.removeListener === "function" && typeof process5.emit === "function" && typeof process5.reallyExit === "function" && typeof process5.listeners === "function" && typeof process5.kill === "function" && typeof process5.pid === "number" && typeof process5.on === "function", kExitEmitter, global, ObjectDefineProperty, signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+}, SignalExitFallback, SignalExit, process5, onExit, load2, unload;
+var init_mjs = __esm(() => {
+  init_signals();
+  kExitEmitter = Symbol.for("signal-exit emitter");
+  global = globalThis;
+  ObjectDefineProperty = Object.defineProperty.bind(Object);
+  SignalExitFallback = class SignalExitFallback extends SignalExitBase {
+    onExit() {
+      return () => {};
+    }
+    load() {}
+    unload() {}
+  };
+  SignalExit = class SignalExit extends SignalExitBase {
+    #hupSig = process5.platform === "win32" ? "SIGINT" : "SIGHUP";
+    #emitter = new Emitter;
+    #process;
+    #originalProcessEmit;
+    #originalProcessReallyExit;
+    #sigListeners = {};
+    #loaded = false;
+    constructor(process5) {
+      super();
+      this.#process = process5;
+      this.#sigListeners = {};
+      for (const sig of signals) {
+        this.#sigListeners[sig] = () => {
+          const listeners = this.#process.listeners(sig);
+          let { count } = this.#emitter;
+          const p = process5;
+          if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+            count += p.__signal_exit_emitter__.count;
+          }
+          if (listeners.length === count) {
+            this.unload();
+            const ret = this.#emitter.emit("exit", null, sig);
+            const s = sig === "SIGHUP" ? this.#hupSig : sig;
+            if (!ret)
+              process5.kill(process5.pid, s);
+          }
+        };
+      }
+      this.#originalProcessReallyExit = process5.reallyExit;
+      this.#originalProcessEmit = process5.emit;
+    }
+    onExit(cb, opts) {
+      if (!processOk(this.#process)) {
+        return () => {};
+      }
+      if (this.#loaded === false) {
+        this.load();
+      }
+      const ev = opts?.alwaysLast ? "afterExit" : "exit";
+      this.#emitter.on(ev, cb);
+      return () => {
+        this.#emitter.removeListener(ev, cb);
+        if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+          this.unload();
+        }
+      };
+    }
+    load() {
+      if (this.#loaded) {
+        return;
+      }
+      this.#loaded = true;
+      this.#emitter.count += 1;
+      for (const sig of signals) {
+        try {
+          const fn = this.#sigListeners[sig];
+          if (fn)
+            this.#process.on(sig, fn);
+        } catch (_) {}
+      }
+      this.#process.emit = (ev, ...a) => {
+        return this.#processEmit(ev, ...a);
+      };
+      this.#process.reallyExit = (code) => {
+        return this.#processReallyExit(code);
+      };
+    }
+    unload() {
+      if (!this.#loaded) {
+        return;
+      }
+      this.#loaded = false;
+      signals.forEach((sig) => {
+        const listener = this.#sigListeners[sig];
+        if (!listener) {
+          throw new Error("Listener not defined for signal: " + sig);
+        }
+        try {
+          this.#process.removeListener(sig, listener);
+        } catch (_) {}
+      });
+      this.#process.emit = this.#originalProcessEmit;
+      this.#process.reallyExit = this.#originalProcessReallyExit;
+      this.#emitter.count -= 1;
+    }
+    #processReallyExit(code) {
+      if (!processOk(this.#process)) {
+        return 0;
+      }
+      this.#process.exitCode = code || 0;
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+    }
+    #processEmit(ev, ...args) {
+      const og = this.#originalProcessEmit;
+      if (ev === "exit" && processOk(this.#process)) {
+        if (typeof args[0] === "number") {
+          this.#process.exitCode = args[0];
+        }
+        const ret = og.call(this.#process, ev, ...args);
+        this.#emitter.emit("exit", this.#process.exitCode, null);
+        return ret;
+      } else {
+        return og.call(this.#process, ev, ...args);
+      }
+    }
+  };
+  process5 = globalThis.process;
+  ({
+    onExit,
+    load: load2,
+    unload
+  } = signalExitWrap(processOk(process5) ? new SignalExit(process5) : new SignalExitFallback));
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/ansi/dist/index.js
+var ESC2 = "\x1B[", cursorLeft, cursorHide, cursorShow, cursorUp = (rows = 1) => rows > 0 ? `${ESC2}${rows}A` : "", cursorDown = (rows = 1) => rows > 0 ? `${ESC2}${rows}B` : "", cursorTo = (x, y) => {
+  if (typeof y === "number" && !Number.isNaN(y)) {
+    return `${ESC2}${y + 1};${x + 1}H`;
+  }
+  return `${ESC2}${x + 1}G`;
+}, eraseLine, eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
+var init_dist4 = __esm(() => {
+  cursorLeft = ESC2 + "G";
+  cursorHide = ESC2 + "?25l";
+  cursorShow = ESC2 + "?25h";
+  eraseLine = ESC2 + "2K";
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/screen-manager.js
+import { stripVTControlCharacters } from "node:util";
+
+class ScreenManager {
+  height = 0;
+  extraLinesUnderPrompt = 0;
+  cursorPos;
+  rl;
+  constructor(rl) {
+    this.rl = rl;
+    this.cursorPos = rl.getCursorPos();
+  }
+  write(content) {
+    this.rl.output.unmute();
+    this.rl.output.write(content);
+    this.rl.output.mute();
+  }
+  render(content, bottomContent = "") {
+    const promptLine = lastLine(content);
+    const rawPromptLine = stripVTControlCharacters(promptLine);
+    let prompt = rawPromptLine;
+    if (this.rl.line.length > 0) {
+      prompt = prompt.slice(0, -this.rl.line.length);
+    }
+    this.rl.setPrompt(prompt);
+    this.cursorPos = this.rl.getCursorPos();
+    const width = readlineWidth();
+    content = breakLines(content, width);
+    bottomContent = breakLines(bottomContent, width);
+    if (rawPromptLine.length % width === 0) {
+      content += `
+`;
+    }
+    let output = content + (bottomContent ? `
+` + bottomContent : "");
+    const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+    const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+    if (bottomContentHeight > 0)
+      output += cursorUp(bottomContentHeight);
+    output += cursorTo(this.cursorPos.cols);
+    this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+    this.extraLinesUnderPrompt = bottomContentHeight;
+    this.height = height(output);
+  }
+  checkCursorPos() {
+    const cursorPos = this.rl.getCursorPos();
+    if (cursorPos.cols !== this.cursorPos.cols) {
+      this.write(cursorTo(cursorPos.cols));
+      this.cursorPos = cursorPos;
+    }
+  }
+  done({ clearContent }) {
+    this.rl.setPrompt("");
+    let output = cursorDown(this.extraLinesUnderPrompt);
+    output += clearContent ? eraseLines(this.height) : `
+`;
+    output += cursorShow;
+    this.write(output);
+    this.rl.close();
+  }
+}
+var height = (content) => content.split(`
+`).length, lastLine = (content) => content.split(`
+`).pop() ?? "";
+var init_screen_manager = __esm(() => {
+  init_utils2();
+  init_dist4();
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/promise-polyfill.js
+var PromisePolyfill;
+var init_promise_polyfill = __esm(() => {
+  PromisePolyfill = class PromisePolyfill extends Promise {
+    static withResolver() {
+      let resolve;
+      let reject;
+      const promise3 = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      return { promise: promise3, resolve, reject };
+    }
+  };
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/create-prompt.js
+import * as readline2 from "node:readline";
+import { AsyncResource as AsyncResource3 } from "node:async_hooks";
+function getCallSites() {
+  const _prepareStackTrace = Error.prepareStackTrace;
+  let result = [];
+  try {
+    Error.prepareStackTrace = (_, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+  } catch {
+    return result;
+  }
+  Error.prepareStackTrace = _prepareStackTrace;
+  return result;
+}
+function createPrompt(view) {
+  const callSites = getCallSites();
+  const prompt = (config2, context = {}) => {
+    const { input = process.stdin, signal } = context;
+    const cleanups = new Set;
+    const output = new import_mute_stream.default;
+    output.pipe(context.output ?? process.stdout);
+    output.mute();
+    const rl = readline2.createInterface({
+      terminal: true,
+      input,
+      output
+    });
+    const screen = new ScreenManager(rl);
+    const { promise: promise3, resolve, reject } = PromisePolyfill.withResolver();
+    const cancel = () => reject(new CancelPromptError);
+    if (signal) {
+      const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
+      if (signal.aborted) {
+        abort();
+        return Object.assign(promise3, { cancel });
+      }
+      signal.addEventListener("abort", abort);
+      cleanups.add(() => signal.removeEventListener("abort", abort));
+    }
+    cleanups.add(onExit((code, signal2) => {
+      reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal2}`));
+    }));
+    const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
+    rl.on("SIGINT", sigint);
+    cleanups.add(() => rl.removeListener("SIGINT", sigint));
+    return withHooks(rl, (cycle) => {
+      const hooksCleanup = AsyncResource3.bind(() => effectScheduler.clearAll());
+      rl.on("close", hooksCleanup);
+      cleanups.add(() => rl.removeListener("close", hooksCleanup));
+      const startCycle = () => {
+        const checkCursorPos = () => screen.checkCursorPos();
+        rl.input.on("keypress", checkCursorPos);
+        cleanups.add(() => rl.input.removeListener("keypress", checkCursorPos));
+        cycle(() => {
+          try {
+            const nextView = view(config2, (value) => {
+              setImmediate(() => resolve(value));
+            });
+            if (nextView === undefined) {
+              const callerFilename = callSites[1]?.getFileName();
+              throw new Error(`Prompt functions must return a string.
+    at ${callerFilename}`);
+            }
+            const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+            screen.render(content, bottomContent);
+            effectScheduler.run();
+          } catch (error48) {
+            reject(error48);
+          }
+        });
+      };
+      if ("readableFlowing" in input) {
+        nativeSetImmediate(startCycle);
+      } else {
+        startCycle();
+      }
+      return Object.assign(promise3.then((answer) => {
+        effectScheduler.clearAll();
+        return answer;
+      }, (error48) => {
+        effectScheduler.clearAll();
+        throw error48;
+      }).finally(() => {
+        cleanups.forEach((cleanup) => cleanup());
+        screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+        output.end();
+      }).then(() => promise3), { cancel });
+    });
+  };
+  return prompt;
+}
+var import_mute_stream, nativeSetImmediate;
+var init_create_prompt = __esm(() => {
+  init_mjs();
+  init_screen_manager();
+  init_promise_polyfill();
+  init_hook_engine();
+  init_errors4();
+  import_mute_stream = __toESM(require_lib(), 1);
+  nativeSetImmediate = globalThis.setImmediate;
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/Separator.js
+import { styleText as styleText2 } from "node:util";
+
+class Separator {
+  separator = styleText2("dim", Array.from({ length: 15 }).join(dist_default.line));
+  type = "separator";
+  constructor(separator) {
+    if (separator) {
+      this.separator = separator;
     }
-  } finally {
-    rl.close();
+  }
+  static isSeparator(choice) {
+    return Boolean(choice && typeof choice === "object" && "type" in choice && choice.type === "separator");
   }
 }
-var ALL_AGENTS, AGENT_DISPLAY_NAMES;
+var init_Separator = __esm(() => {
+  init_dist();
+});
+
+// ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/index.js
+var init_dist5 = __esm(() => {
+  init_use_prefix();
+  init_use_state();
+  init_use_memo();
+  init_use_keypress();
+  init_make_theme();
+  init_use_pagination();
+  init_create_prompt();
+  init_Separator();
+  init_errors4();
+});
+
+// ../../node_modules/@inquirer/checkbox/dist/index.js
+import { styleText as styleText3 } from "node:util";
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !Separator.isSeparator(item);
+}
+function isChecked(item) {
+  return !Separator.isSeparator(item) && item.checked;
+}
+function toggle(item) {
+  return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+function check2(checked) {
+  return function(item) {
+    return isSelectable(item) ? { ...item, checked } : item;
+  };
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice === "string") {
+      return {
+        value: choice,
+        name: choice,
+        short: choice,
+        checkedName: choice,
+        disabled: false,
+        checked: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var checkboxTheme, dist_default4;
+var init_dist6 = __esm(() => {
+  init_dist5();
+  init_dist4();
+  init_dist();
+  checkboxTheme = {
+    icon: {
+      checked: styleText3("green", dist_default.circleFilled),
+      unchecked: dist_default.circle,
+      cursor: dist_default.pointer,
+      disabledChecked: styleText3("green", dist_default.circleDouble),
+      disabledUnchecked: "-"
+    },
+    style: {
+      disabled: (text) => styleText3("dim", text),
+      renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+      description: (text) => styleText3("cyan", text),
+      keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText3("bold", key)} ${styleText3("dim", action)}`).join(styleText3("dim", " • "))
+    },
+    i18n: { disabledError: "This option is disabled and cannot be toggled." },
+    keybindings: []
+  };
+  dist_default4 = createPrompt((config2, done) => {
+    const { pageSize = 7, loop = true, required: required2, validate = () => true } = config2;
+    const shortcuts = { all: "a", invert: "i", ...config2.shortcuts };
+    const theme = makeTheme(checkboxTheme, config2.theme);
+    const { keybindings } = theme;
+    const [status, setStatus] = useState("idle");
+    const prefix = usePrefix({ status, theme });
+    const [items, setItems] = useState(normalizeChoices(config2.choices));
+    const bounds = useMemo(() => {
+      const first = items.findIndex(isNavigable);
+      const last = items.findLastIndex(isNavigable);
+      if (first === -1) {
+        throw new ValidationError("[checkbox prompt] No selectable choices. All choices are disabled.");
+      }
+      return { first, last };
+    }, [items]);
+    const [active, setActive] = useState(bounds.first);
+    const [errorMsg, setError] = useState();
+    useKeypress(async (key) => {
+      if (isEnterKey(key)) {
+        const selection = items.filter(isChecked);
+        const isValid2 = await validate([...selection]);
+        if (required2 && !selection.length) {
+          setError("At least one choice must be selected");
+        } else if (isValid2 === true) {
+          setStatus("done");
+          done(selection.map((choice) => choice.value));
+        } else {
+          setError(isValid2 || "You must select a valid value");
+        }
+      } else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+        if (errorMsg) {
+          setError(undefined);
+        }
+        if (loop || isUpKey(key, keybindings) && active !== bounds.first || isDownKey(key, keybindings) && active !== bounds.last) {
+          const offset = isUpKey(key, keybindings) ? -1 : 1;
+          let next = active;
+          do {
+            next = (next + offset + items.length) % items.length;
+          } while (!isNavigable(items[next]));
+          setActive(next);
+        }
+      } else if (isSpaceKey(key)) {
+        const activeItem = items[active];
+        if (activeItem && !Separator.isSeparator(activeItem)) {
+          if (activeItem.disabled) {
+            setError(theme.i18n.disabledError);
+          } else {
+            setError(undefined);
+            setItems(items.map((choice, i2) => i2 === active ? toggle(choice) : choice));
+          }
+        }
+      } else if (key.name === shortcuts.all) {
+        const selectAll = items.some((choice) => isSelectable(choice) && !choice.checked);
+        setItems(items.map(check2(selectAll)));
+      } else if (key.name === shortcuts.invert) {
+        setItems(items.map(toggle));
+      } else if (isNumberKey(key)) {
+        const selectedIndex = Number(key.name) - 1;
+        let selectableIndex = -1;
+        const position = items.findIndex((item) => {
+          if (Separator.isSeparator(item))
+            return false;
+          selectableIndex++;
+          return selectableIndex === selectedIndex;
+        });
+        const selectedItem = items[position];
+        if (selectedItem && isSelectable(selectedItem)) {
+          setActive(position);
+          setItems(items.map((choice, i2) => i2 === position ? toggle(choice) : choice));
+        }
+      }
+    });
+    const message = theme.style.message(config2.message, status);
+    let description;
+    const page = usePagination({
+      items,
+      active,
+      renderItem({ item, isActive }) {
+        if (Separator.isSeparator(item)) {
+          return ` ${item.separator}`;
+        }
+        const cursor = isActive ? theme.icon.cursor : " ";
+        if (item.disabled) {
+          const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+          const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
+          return theme.style.disabled(`${cursor}${checkbox2} ${item.name} ${disabledLabel}`);
+        }
+        if (isActive) {
+          description = item.description;
+        }
+        const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+        const name = item.checked ? item.checkedName : item.name;
+        const color = isActive ? theme.style.highlight : (x) => x;
+        return color(`${cursor}${checkbox} ${name}`);
+      },
+      pageSize,
+      loop
+    });
+    if (status === "done") {
+      const selection = items.filter(isChecked);
+      const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+      return [prefix, message, answer].filter(Boolean).join(" ");
+    }
+    const keys = [
+      ["↑↓", "navigate"],
+      ["space", "select"]
+    ];
+    if (shortcuts.all)
+      keys.push([shortcuts.all, "all"]);
+    if (shortcuts.invert)
+      keys.push([shortcuts.invert, "invert"]);
+    keys.push(["⏎", "submit"]);
+    const helpLine = theme.style.keysHelpTip(keys);
+    const lines = [
+      [prefix, message].filter(Boolean).join(" "),
+      page,
+      " ",
+      description ? theme.style.description(description) : "",
+      errorMsg ? theme.style.error(errorMsg) : "",
+      helpLine
+    ].filter(Boolean).join(`
+`).trimEnd();
+    return `${lines}${cursorHide}`;
+  });
+});
+
+// ../../node_modules/@inquirer/prompts/dist/index.js
+var init_dist7 = __esm(() => {
+  init_dist6();
+});
+
+// src/commands/skills/prompt.ts
+function truncate(text, maxLen) {
+  if (text.length <= maxLen)
+    return text;
+  return `${text.slice(0, maxLen - 3)}...`;
+}
+async function promptAgentSelection(operation = "manage") {
+  const selected = await dist_default4({
+    message: `Select agents to ${operation} skills for`,
+    required: true,
+    choices: ALL_AGENTS.map((a) => ({
+      name: AGENT_DISPLAY_NAMES[a],
+      value: a,
+      description: AGENT_DESTINATIONS[a]
+    }))
+  });
+  return selected;
+}
+async function promptSkillSelection(skills, operation = "manage") {
+  const selected = await dist_default4({
+    message: `Select skills to ${operation}`,
+    required: true,
+    choices: skills.map((s) => ({
+      name: s.name,
+      value: s.name,
+      description: s.description ? truncate(s.description, 120) : undefined
+    }))
+  });
+  return selected;
+}
+var ALL_AGENTS, AGENT_DISPLAY_NAMES, AGENT_DESTINATIONS;
 var init_prompt = __esm(() => {
+  init_dist7();
   ALL_AGENTS = [
     "claude",
     "cursor",
@@ -32909,14 +34746,28 @@ var init_prompt = __esm(() => {
     gemini: "Gemini CLI",
     codex: "Codex"
   };
+  AGENT_DESTINATIONS = {
+    claude: ".claude/skills/<skill>/",
+    cursor: ".cursor/rules/<skill>.mdc",
+    copilot: ".github/instructions/<skill>.instructions.md",
+    gemini: ".gemini/GEMINI.md",
+    codex: "~/.codex/instructions.md"
+  };
 });
 
 // src/commands/skills/skillsService.ts
-import { catchError as catchError4, OutputFormatter as OutputFormatter3 } from "@uipath/common";
-import { getFileSystem as getFileSystem7 } from "@uipath/filesystem";
+import { catchError as catchError5, logger as logger7, OutputFormatter as OutputFormatter3 } from "@uipath/common";
+import { getFileSystem as getFileSystem9 } from "@uipath/filesystem";
+function handlePromptCancellation(err, operation) {
+  if (err instanceof Error && err.name === "ExitPromptError") {
+    logger7.warn(`${operation.charAt(0).toUpperCase() + operation.slice(1)} cancelled.`);
+    throw Object.assign(new Error("cancelled"), { exitCode: 130 });
+  }
+  throw err;
+}
 async function resolveSkillsContext(options, operation) {
   const isLocal = !!options.local;
-  const fs = getFileSystem7();
+  const fs = getFileSystem9();
   const rootDir = isLocal ? fs.env.cwd() : fs.env.homedir();
   const storePath = await getContentStore(rootDir);
   const availableSkills = await getAvailableSkills(storePath);
@@ -32931,8 +34782,9 @@ async function resolveSkillsContext(options, operation) {
   }
   let selectedSkills = availableSkills;
   if (!options.skills && !options.agents) {
-    const availableNames = availableSkills.map((s) => s.name);
-    const chosen = await promptSkillSelection(availableNames, operation);
+    const [skillErr, chosen] = await catchError5(promptSkillSelection(availableSkills, operation));
+    if (skillErr)
+      handlePromptCancellation(skillErr, operation);
     selectedSkills = availableSkills.filter((s) => chosen.includes(s.name));
   } else if (options.skills) {
     const requested = options.skills.split(",").map((s) => s.trim());
@@ -32973,7 +34825,10 @@ async function resolveSkillsContext(options, operation) {
       return null;
     }
   } else {
-    agents = await promptAgentSelection(operation);
+    const [agentErr, selected] = await catchError5(promptAgentSelection(operation));
+    if (agentErr)
+      handlePromptCancellation(agentErr, operation);
+    agents = selected;
   }
   return { rootDir, storePath, selectedSkills, agents, isLocal };
 }
@@ -32983,7 +34838,7 @@ async function runAgentInstalls(resolved) {
   for (const agent of agents) {
     const handler = getAgentHandler(agent);
     for (const skill of selectedSkills) {
-      const [installError] = await catchError4(handler.install(skill, rootDir));
+      const [installError] = await catchError5(handler.install(skill, rootDir));
       if (installError) {
         OutputFormatter3.error({
           Result: "Failure",
@@ -32996,7 +34851,7 @@ async function runAgentInstalls(resolved) {
       installed.push(`${agent}:${skill.name}`);
     }
   }
-  const [manifestError] = await catchError4(updateManifestAfterInstall(storePath, selectedSkills.map((s) => s.name), agents));
+  const [manifestError] = await catchError5(updateManifestAfterInstall(storePath, selectedSkills.map((s) => s.name), agents));
   if (manifestError) {
     OutputFormatter3.error({
       Result: "Failure",
@@ -33007,7 +34862,7 @@ async function runAgentInstalls(resolved) {
     return null;
   }
   if (isLocal) {
-    const [gitignoreError] = await catchError4(addToGitignore(rootDir, `${STORE_NAME}/`));
+    const [gitignoreError] = await catchError5(addToGitignore(rootDir, `${STORE_NAME}/`));
     if (gitignoreError) {
       OutputFormatter3.error({
         Result: "Failure",
@@ -33027,12 +34882,16 @@ var init_skillsService = __esm(() => {
 });
 
 // src/commands/skills/install.ts
-import { catchError as catchError5, OutputFormatter as OutputFormatter4, processContext as processContext2 } from "@uipath/common";
+import { catchError as catchError6, OutputFormatter as OutputFormatter4, processContext as processContext2 } from "@uipath/common";
 function registerInstallCommand(skillsCommand) {
   skillsCommand.command("install").description("Download skills from UiPath and install them for your coding agents.").option("--agents <agents>", "Target agents: claude, cursor, copilot, gemini, codex (comma-separated)").option("--skills <skills>", "Specific skills to install (comma-separated)").option("--local", "Install to current project instead of globally").trackedAction(processContext2, async (options) => {
-    const [contextError, resolved] = await catchError5(resolveSkillsContext(options, "install"));
+    const [contextError, resolved] = await catchError6(resolveSkillsContext(options, "install"));
     if (contextError || !resolved) {
       if (contextError) {
+        if (contextError.exitCode === 130) {
+          processContext2.exit(130);
+          return;
+        }
         OutputFormatter4.error({
           Result: "Failure",
           Message: `Failed to install skills: ${contextError.message}`,
@@ -33063,21 +34922,25 @@ var init_install = __esm(() => {
 
 // src/commands/skills/uninstall.ts
 import {
-  catchError as catchError6,
-  logger as logger7,
+  catchError as catchError7,
+  logger as logger8,
   OutputFormatter as OutputFormatter5,
   processContext as processContext3
 } from "@uipath/common";
-import { getFileSystem as getFileSystem8 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem10 } from "@uipath/filesystem";
 function registerUninstallCommand(skillsCommand) {
   skillsCommand.command("uninstall").description("Remove previously installed skills from agent configurations.").option("--agents <agents>", "Target agents: claude, cursor, copilot, gemini, codex (comma-separated)").option("--skills <skills>", "Specific skills to uninstall (comma-separated)").option("--local", "Uninstall from current project instead of globally").trackedAction(processContext3, async (options) => {
-    const [contextError, resolved] = await catchError6(resolveSkillsContext(options, "uninstall"));
+    const [contextError, resolved] = await catchError7(resolveSkillsContext(options, "uninstall"));
     const isLocal = !!options.local;
     let rootDir;
     let storePath;
     let skillNames;
     let agents;
     if (contextError) {
+      if (contextError.exitCode === 130) {
+        processContext3.exit(130);
+        return;
+      }
       OutputFormatter5.error({
         Result: "Failure",
         Message: `Failed to uninstall skills: ${contextError.message}`,
@@ -33095,7 +34958,7 @@ function registerUninstallCommand(skillsCommand) {
       if (!options.skills || !options.agents) {
         return;
       }
-      const fs = getFileSystem8();
+      const fs = getFileSystem10();
       rootDir = isLocal ? fs.env.cwd() : fs.env.homedir();
       storePath = fs.path.join(rootDir, STORE_NAME);
       const manifest = await readManifest(storePath);
@@ -33122,13 +34985,13 @@ function registerUninstallCommand(skillsCommand) {
         processContext3.exit(1);
         return;
       }
-      logger7.info(`Uninstalling skills from manifest: ${inManifest.join(", ")}`);
+      logger8.info(`Uninstalling skills from manifest: ${inManifest.join(", ")}`);
     }
     const uninstalled = [];
     for (const agent of agents) {
       const handler = getAgentHandler(agent);
       for (const name of skillNames) {
-        const [uninstallError] = await catchError6(handler.uninstall(name, rootDir));
+        const [uninstallError] = await catchError7(handler.uninstall(name, rootDir));
         if (uninstallError) {
           OutputFormatter5.error({
             Result: "Failure",
@@ -33163,16 +35026,20 @@ var init_uninstall = __esm(() => {
 
 // src/commands/skills/update.ts
 import {
-  catchError as catchError7,
-  logger as logger8,
+  catchError as catchError8,
+  logger as logger9,
   OutputFormatter as OutputFormatter6,
   processContext as processContext4
 } from "@uipath/common";
 function registerUpdateCommand(skillsCommand) {
   skillsCommand.command("update").description("Re-fetch skills from UiPath and reinstall to get the latest versions.").option("--agents <agents>", "Target agents: claude, cursor, copilot, gemini, codex (comma-separated)").option("--skills <skills>", "Specific skills to update (comma-separated)").option("--local", "Update in current project instead of globally").trackedAction(processContext4, async (options) => {
-    const [contextError, resolved] = await catchError7(resolveSkillsContext(options, "update"));
+    const [contextError, resolved] = await catchError8(resolveSkillsContext(options, "update"));
     if (contextError || !resolved) {
       if (contextError) {
+        if (contextError.exitCode === 130) {
+          processContext4.exit(130);
+          return;
+        }
         OutputFormatter6.error({
           Result: "Failure",
           Message: `Failed to update skills: ${contextError.message}`,
@@ -33183,13 +35050,13 @@ function registerUpdateCommand(skillsCommand) {
       return;
     }
     if (!options.skills) {
-      const [manifestErr, manifest] = await catchError7(readManifest(resolved.storePath));
-      const [skillsErr, availableSkills] = await catchError7(getAvailableSkills(resolved.storePath));
+      const [manifestErr, manifest] = await catchError8(readManifest(resolved.storePath));
+      const [skillsErr, availableSkills] = await catchError8(getAvailableSkills(resolved.storePath));
       if (!manifestErr && !skillsErr && availableSkills) {
         const availableNames = availableSkills.map((s) => s.name);
         const removed = Object.keys(manifest.skills).filter((s) => !availableNames.includes(s));
         if (removed.length > 0) {
-          logger8.warn(`Previously installed skills no longer available: ${removed.join(", ")}. They may have been removed or renamed. Use 'uipath skills uninstall --skills ${removed.join(",")}' to clean up.`);
+          logger9.warn(`Previously installed skills no longer available: ${removed.join(", ")}. They may have been removed or renamed. Use 'uipath skills uninstall --skills ${removed.join(",")}' to clean up.`);
         }
       }
     }
@@ -33246,15 +35113,15 @@ var exports_npmrc = {};
 __export(exports_npmrc, {
   findNpmrcConfig: () => findNpmrcConfig
 });
-import { logger as logger9 } from "@uipath/common";
-import { getFileSystem as getFileSystem9 } from "@uipath/filesystem";
+import { catchError as catchError9, logger as logger10 } from "@uipath/common";
+import { getFileSystem as getFileSystem11 } from "@uipath/filesystem";
 function expandEnvVars(raw) {
   let hasMissing = false;
   const expanded = raw.replace(/\$\{([^}]+)\}/g, (_, v) => {
     const val = process.env[v];
     if (val === undefined) {
       hasMissing = true;
-      logger9.warn(`Warning: .npmrc references \${${v}} but it is not set.`);
+      logger10.warn(`Warning: .npmrc references \${${v}} but it is not set.`);
       return "";
     }
     return val;
@@ -33287,14 +35154,13 @@ function parseNpmrc(content) {
   return result;
 }
 function registryHost(url2) {
-  try {
-    return new URL(url2).host;
-  } catch {
+  const [error48, parsed] = catchError9(() => new URL(url2));
+  if (error48)
     return;
-  }
+  return parsed.host;
 }
 async function findNpmrcConfig() {
-  const fs = getFileSystem9();
+  const fs = getFileSystem11();
   const paths = [];
   let dir = fs.env.cwd();
   for (let i2 = 0;i2 < 20; i2++) {
@@ -33305,22 +35171,31 @@ async function findNpmrcConfig() {
     dir = parent;
   }
   paths.push(fs.path.join(fs.env.homedir(), ".npmrc"));
+  logger10.debug(`Searching for .npmrc in ${paths.length} locations`);
   let scopedRegistry;
   let prefix;
   const allTokensByHost = new Map;
   for (const p of paths) {
-    try {
-      const content = await fs.readFile(p, "utf-8");
-      const parsed = parseNpmrc(content);
-      if (parsed.scopedRegistry && !scopedRegistry)
-        scopedRegistry = parsed.scopedRegistry;
-      if (parsed.prefix && !prefix)
-        prefix = parsed.prefix;
-      for (const [host, token] of parsed.tokensByHost) {
-        if (!allTokensByHost.has(host))
-          allTokensByHost.set(host, token);
+    const [readError, content] = await catchError9(fs.readFile(p, "utf-8"));
+    if (readError) {
+      continue;
+    }
+    logger10.debug(`Found .npmrc at ${p}`);
+    if (!content)
+      continue;
+    const parsed = parseNpmrc(content);
+    if (parsed.scopedRegistry && !scopedRegistry) {
+      scopedRegistry = parsed.scopedRegistry;
+      logger10.debug(`@uipath:registry = ${scopedRegistry} (from ${p})`);
+    }
+    if (parsed.prefix && !prefix)
+      prefix = parsed.prefix;
+    for (const [host, token] of parsed.tokensByHost) {
+      if (!allTokensByHost.has(host)) {
+        allTokensByHost.set(host, token);
+        logger10.debug(`Auth token found for host '${host}' (from ${p})`);
       }
-    } catch {}
+    }
   }
   let authToken;
   if (scopedRegistry) {
@@ -33334,8 +35209,13 @@ async function findNpmrcConfig() {
 var init_npmrc = () => {};
 
 // src/services/toolService.ts
-import { DEFAULT_FETCH_TIMEOUT_MS, logger as logger10 } from "@uipath/common";
-import { getFileSystem as getFileSystem10 } from "@uipath/filesystem";
+import {
+  catchError as catchError10,
+  DEFAULT_FETCH_TIMEOUT_MS,
+  extractErrorMessageSync,
+  logger as logger11
+} from "@uipath/common";
+import { getFileSystem as getFileSystem12 } from "@uipath/filesystem";
 function isValidSemver(v) {
   return SEMVER_RE.test(v);
 }
@@ -33400,9 +35280,19 @@ function validateVersionString(version2) {
 function resolveToolPackageName(arg) {
   return WHITELIST_BY_COMMAND.get(arg) ?? WHITELIST_BY_SHORT_NAME.get(arg) ?? arg;
 }
+function parsePackageSpec(spec) {
+  const versionSeparator = spec.startsWith("@") ? spec.indexOf("@", 1) : spec.indexOf("@");
+  if (versionSeparator === -1) {
+    return { name: spec, version: undefined };
+  }
+  return {
+    name: spec.slice(0, versionSeparator),
+    version: spec.slice(versionSeparator + 1) || undefined
+  };
+}
 async function isDevMode() {
-  try {
-    const fs = getFileSystem10();
+  const [error48, result] = await catchError10((async () => {
+    const fs = getFileSystem12();
     let dir = fs.env.cwd();
     for (let i2 = 0;i2 < 10; i2++) {
       const pkgPath = fs.path.join(dir, "package.json");
@@ -33410,8 +35300,12 @@ async function isDevMode() {
         const raw = await fs.readFile(pkgPath, "utf-8");
         if (raw) {
           const pkg = JSON.parse(raw);
-          if (pkg.workspaces && pkg.private && pkg.name === "uipcli") {
-            return true;
+          if (pkg.workspaces && pkg.private) {
+            const bunLockPath = fs.path.join(dir, "bun.lock");
+            if (await fs.exists(bunLockPath)) {
+              logger11.debug(`Dev mode detected — found monorepo root at ${dir}`);
+              return true;
+            }
           }
         }
       }
@@ -33420,7 +35314,15 @@ async function isDevMode() {
         break;
       dir = parent;
     }
-  } catch {}
+    return false;
+  })());
+  if (error48) {
+    logger11.debug("Dev mode not detected — using npm");
+    return false;
+  }
+  if (result)
+    return true;
+  logger11.debug("Dev mode not detected — using npm");
   return false;
 }
 async function runPackageManager(args, cwd) {
@@ -33433,6 +35335,7 @@ async function runPackageManager(args, cwd) {
   const isWindows = process.platform === "win32";
   const useBun = await isDevMode();
   const pm = useBun ? "bun" : "npm";
+  logger11.debug(`Running package manager: ${pm} ${args.join(" ")}${cwd ? ` (cwd: ${cwd})` : ""}`);
   const pmArgs = useBun ? args.filter((a) => a !== "-g").map((a) => a === "uninstall" ? "remove" : a) : args;
   return new Promise((resolve, reject) => {
     const proc = isWindows ? spawn2([pm, ...pmArgs].map((a) => a.includes(" ") ? `"${a}"` : a).join(" "), [], {
@@ -33446,7 +35349,7 @@ async function runPackageManager(args, cwd) {
     let stderr = "";
     const MAX_STDERR = 65536;
     proc.stdout?.on("data", (d) => {
-      logger10.info(d.toString().trimEnd());
+      logger11.info(d.toString().trimEnd());
     });
     proc.stderr?.on("data", (d) => {
       if (stderr.length < MAX_STDERR) {
@@ -33468,18 +35371,20 @@ async function runPackageManager(args, cwd) {
   });
 }
 async function resolveRegistry() {
+  logger11.debug("Resolving npm registry for @uipath packages...");
   const { findNpmrcConfig: findNpmrcConfig2 } = await Promise.resolve().then(() => (init_npmrc(), exports_npmrc));
   const config2 = await findNpmrcConfig2();
   const registryUrl = config2.scopedRegistry || DEFAULT_REGISTRY;
-  try {
-    new URL(registryUrl);
-  } catch {
+  logger11.debug(`Registry URL: ${registryUrl}${config2.scopedRegistry ? " (from .npmrc)" : " (default)"}`);
+  const [urlError] = catchError10(() => new URL(registryUrl));
+  if (urlError) {
     throw new Error(`Invalid @uipath:registry URL in .npmrc: "${registryUrl}"`);
   }
   const envToken = globalThis.process?.env?.GH_NPM_REGISTRY_TOKEN;
   const authToken = envToken || config2.authToken || undefined;
+  logger11.debug(`Auth token: ${authToken ? `found (source: ${envToken ? "GH_NPM_REGISTRY_TOKEN env" : ".npmrc"})` : "not found"}`);
   if (authToken && !config2.scopedRegistry) {
-    logger10.warn("Auth token found but no @uipath:registry configured in .npmrc — " + "token will be sent to the default registry (npmjs.org)");
+    logger11.warn("Auth token found but no @uipath:registry configured in .npmrc — " + "token will be sent to the default registry (npmjs.org)");
   }
   return { registryUrl, authToken };
 }
@@ -33488,6 +35393,7 @@ class NodeToolService {
   async fetchPackageInfo(registryUrl, packageName, headers) {
     const encodedName = packageName.replaceAll("/", "%2f");
     const url2 = `${registryUrl.replace(/\/+$/, "")}/${encodedName}`;
+    logger11.debug(`Fetching package info: ${url2}`);
     const fetchHeaders = {
       Accept: "application/json",
       ...headers
@@ -33504,17 +35410,15 @@ class NodeToolService {
     }
     const data = await response.json();
     const latestVersion = data["dist-tags"]?.latest;
-    let registryLabel;
-    try {
-      registryLabel = new URL(registryUrl).host;
-    } catch {
-      registryLabel = registryUrl;
-    }
+    const [labelError, parsedUrl] = catchError10(() => new URL(registryUrl));
+    const registryLabel = labelError ? registryUrl : parsedUrl.host;
+    const availableVersions = Object.keys(data.versions || {}).filter(isValidSemver).sort((a, b) => compareSemver(b, a));
+    logger11.debug(`Package '${packageName}': latest=${latestVersion ?? "unknown"}, ${availableVersions.length} versions available`);
     return {
       name: data.name,
       version: latestVersion || "latest",
       description: data.description || "",
-      availableVersions: Object.keys(data.versions || {}).filter(isValidSemver).sort((a, b) => compareSemver(b, a)),
+      availableVersions,
       registry: registryLabel
     };
   }
@@ -33526,17 +35430,17 @@ class NodeToolService {
     const packages = [...TOOLS_WHITELIST.keys()];
     const settled = await Promise.allSettled(packages.map((name) => this.fetchPackageInfo(registryUrl, name, headers)));
     const results = [];
-    const errors4 = [];
+    const errors5 = [];
     for (const r of settled) {
       if (r.status === "fulfilled") {
         results.push(r.value);
       } else {
-        errors4.push(r.reason instanceof Error ? r.reason.message : String(r.reason));
+        errors5.push(r.reason instanceof Error ? r.reason.message : String(r.reason));
       }
     }
     if (results.length === 0) {
       throw new Error(`All ${packages.length} package lookups on ${registryUrl} failed:
-${errors4.map((e) => `  - ${e}`).join(`
+${errors5.map((e) => `  - ${e}`).join(`
 `)}`);
     }
     if (query && query.trim() !== "") {
@@ -33546,6 +35450,7 @@ ${errors4.map((e) => `  - ${e}`).join(`
     return results;
   }
   async searchLatestVersion(packageName, versionPrefix) {
+    logger11.debug(`Searching latest version of '${packageName}'${versionPrefix ? ` with prefix '${versionPrefix}'` : ""}`);
     const { registryUrl, authToken } = await resolveRegistry();
     const headers = {};
     if (authToken)
@@ -33554,24 +35459,40 @@ ${errors4.map((e) => `  - ${e}`).join(`
     if (versionPrefix && info.availableVersions) {
       const matching = info.availableVersions.filter((v) => v.startsWith(versionPrefix));
       const stable = matching.find((v) => !v.includes("-"));
-      if (stable)
+      if (stable) {
+        logger11.debug(`Resolved version: ${stable} (stable, prefix match)`);
         return stable;
-      if (matching.length > 0)
+      }
+      if (matching.length > 0) {
+        logger11.debug(`Resolved version: ${matching[0]} (prerelease, prefix match)`);
         return matching[0];
+      }
+      logger11.debug(`No version found matching prefix '${versionPrefix}'`);
       return null;
     }
+    logger11.debug(`Resolved version: ${info.version ?? "null"} (latest)`);
     return info.version ?? null;
   }
   async install(packageName, destination, options) {
     validatePackageSpec(packageName);
-    if (options?.global) {
-      await runPackageManager(["install", "-g", packageName], destination);
-    } else {
-      await runPackageManager(["install", packageName], destination);
+    const baseArgs = options?.global ? ["install", "-g", packageName] : ["install", packageName];
+    for (let attempt = 0;attempt <= NPM_MAX_RETRIES; attempt++) {
+      const [err] = await catchError10(runPackageManager(baseArgs, destination));
+      if (!err) {
+        return;
+      }
+      const msg = extractErrorMessageSync(err);
+      const isTransient = TRANSIENT_NPM_ERRORS.some((code) => msg.includes(code));
+      if (!isTransient || attempt === NPM_MAX_RETRIES) {
+        throw err;
+      }
+      const delayMs = 1000 * (attempt + 1);
+      logger11.warn(`npm install failed with transient error (attempt ${attempt + 1}/${NPM_MAX_RETRIES + 1}), retrying in ${delayMs}ms: ${msg}`);
+      await new Promise((r) => setTimeout(r, delayMs));
     }
   }
   async uninstall(packageName, destination, options) {
-    const fs = getFileSystem10();
+    const fs = getFileSystem12();
     const nodeModulesDir = fs.path.resolve(destination, "node_modules");
     const packageDir = fs.path.resolve(fs.path.join(destination, "node_modules", packageName));
     if (!packageDir.startsWith(`${nodeModulesDir}/`) && !packageDir.startsWith(`${nodeModulesDir}\\`)) {
@@ -33580,14 +35501,12 @@ ${errors4.map((e) => `  - ${e}`).join(`
     if (!await fs.exists(packageDir)) {
       throw new Error(`Package '${packageName}' is not installed at ${destination}`);
     }
-    try {
-      const stat = await fs.stat(packageDir);
-      if (!stat) {
-        await fs.rm(packageDir);
-        logger10.info(`Removed workspace-linked package '${packageName}'`);
-        return;
-      }
-    } catch (_e) {}
+    const [statError, stat] = await catchError10(fs.stat(packageDir));
+    if (!statError && !stat) {
+      await fs.rm(packageDir);
+      logger11.info(`Removed workspace-linked package '${packageName}'`);
+      return;
+    }
     if (options?.global) {
       await runPackageManager(["uninstall", "-g", packageName], destination);
     } else {
@@ -33595,7 +35514,7 @@ ${errors4.map((e) => `  - ${e}`).join(`
     }
     if (await fs.exists(packageDir)) {
       await fs.rm(packageDir);
-      logger10.info(`Package directory for '${packageName}' still existed after uninstall — removed manually`);
+      logger11.info(`Package directory for '${packageName}' still existed after uninstall — removed manually`);
     }
   }
 }
@@ -33622,11 +35541,12 @@ function truncateVersionsForDisplay(versions2) {
   }
   return result;
 }
-var SEMVER_RE, SAFE_PACKAGE_SPEC, SAFE_VERSION, NPM_TIMEOUT_MS = 180000, TOOLS_WHITELIST, WHITELIST_BY_COMMAND, WHITELIST_BY_SHORT_NAME, DEFAULT_REGISTRY = "https://registry.npmjs.org", toolService;
+var SEMVER_RE, SAFE_PACKAGE_SPEC, SAFE_VERSION, NPM_TIMEOUT_MS = 180000, NPM_MAX_RETRIES = 2, TRANSIENT_NPM_ERRORS, TOOLS_WHITELIST, WHITELIST_BY_COMMAND, WHITELIST_BY_SHORT_NAME, DEFAULT_REGISTRY = "https://registry.npmjs.org", toolService;
 var init_toolService = __esm(() => {
   SEMVER_RE = /^\d+\.\d+\.\d+(-[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*)?(\+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*)?$/;
   SAFE_PACKAGE_SPEC = /^@?[a-zA-Z0-9._/-]+(@[a-zA-Z0-9._+:~^<>=| -]+)?$/;
   SAFE_VERSION = /^[a-zA-Z0-9._+:~^<>=| -]+$/;
+  TRANSIENT_NPM_ERRORS = ["ENOTEMPTY", "EPERM", "EBUSY"];
   TOOLS_WHITELIST = new Map([
     ["@uipath/solution-tool", "solution"],
     ["@uipath/agent-tool", "agent"],
@@ -33654,15 +35574,25 @@ var init_toolService = __esm(() => {
 
 // src/commands/tools/install.ts
 import {
-  catchError as catchError8,
-  logger as logger11,
+  catchError as catchError11,
+  logger as logger12,
   OutputFormatter as OutputFormatter7,
   processContext as processContext5
 } from "@uipath/common";
 function registerInstallCommand2(toolsCommand, _context, state) {
   const { resolveInstallPath, getCliVersionPrefix } = state;
-  toolsCommand.command("install").description("Install a tool from registry").argument("<package-name>", "Name of the package to install").trackedAction(processContext5, async (packageArg) => {
-    const packageName = resolveToolPackageName(packageArg);
+  toolsCommand.command("install").description("Install a tool from registry").argument("<package-name>", "Name of the package to install (optionally with @version)").trackedAction(processContext5, async (packageArg) => {
+    const { name: rawName, version: explicitVersion } = parsePackageSpec(packageArg);
+    if (explicitVersion && !isValidSemver(explicitVersion)) {
+      OutputFormatter7.error({
+        Result: "Failure",
+        Message: `Invalid version '${explicitVersion}'.`,
+        Instructions: "Version must be a valid semver string (e.g. 1.0.0 or 1.0.0-beta.1)."
+      });
+      processContext5.exit(1);
+      return;
+    }
+    const packageName = resolveToolPackageName(rawName);
     if (!TOOLS_WHITELIST.has(packageName)) {
       OutputFormatter7.error({
         Result: "Failure",
@@ -33672,10 +35602,13 @@ function registerInstallCommand2(toolsCommand, _context, state) {
       processContext5.exit(1);
       return;
     }
-    const [error48] = await catchError8((async () => {
+    const [error48] = await catchError11((async () => {
       const location = await resolveInstallPath(packageName);
-      let packageSpec = packageName;
-      if (!packageName.includes("@", 1)) {
+      let packageSpec;
+      if (explicitVersion) {
+        packageSpec = `${packageName}@${explicitVersion}`;
+      } else {
+        packageSpec = packageName;
         const cliPrefix = getCliVersionPrefix();
         const version2 = await toolService.searchLatestVersion(packageName, cliPrefix);
         if (version2) {
@@ -33685,7 +35618,7 @@ function registerInstallCommand2(toolsCommand, _context, state) {
       await toolService.install(packageSpec, location.path, {
         global: location.global
       });
-      logger11.info(`Installed to ${location.path}`);
+      logger12.info(`Installed to ${location.path}`);
       OutputFormatter7.success({
         Result: "Success",
         Code: "Message",
@@ -33712,20 +35645,26 @@ var init_install2 = __esm(() => {
 import { OutputFormatter as OutputFormatter8, processContext as processContext6 } from "@uipath/common";
 function registerListCommand(toolsCommand, state) {
   toolsCommand.command("list").description("List installed tools").trackedAction(processContext6, async () => {
+    const data = state.tools.length > 0 ? state.tools.map((tool) => tool.metadata) : (state.discoveredTools ?? []).map((d) => ({
+      name: d.toolName,
+      version: d.version,
+      description: d.description,
+      commandPrefix: d.commandPrefix
+    }));
     OutputFormatter8.success({
       Result: "Success",
       Code: "ToolList",
-      Data: state.tools.map((tool) => tool.metadata)
+      Data: data
     });
   });
 }
 var init_list = () => {};
 
 // src/commands/tools/search.ts
-import { catchError as catchError9, OutputFormatter as OutputFormatter9, processContext as processContext7 } from "@uipath/common";
+import { catchError as catchError12, OutputFormatter as OutputFormatter9, processContext as processContext7 } from "@uipath/common";
 function registerSearchCommand(toolsCommand, _context) {
   toolsCommand.command("search").description("Search for tools in the configured registry").argument("[query]", "Search query (name or keyword)").trackedAction(processContext7, async (query) => {
-    const [error48, results] = await catchError9(toolService.search(query));
+    const [error48, results] = await catchError12(toolService.search(query));
     if (error48) {
       OutputFormatter9.error({
         Result: "Failure",
@@ -33751,7 +35690,7 @@ var init_search = __esm(() => {
 });
 
 // src/commands/tools/uninstall.ts
-import { catchError as catchError10, OutputFormatter as OutputFormatter10, processContext as processContext8 } from "@uipath/common";
+import { catchError as catchError13, OutputFormatter as OutputFormatter10, processContext as processContext8 } from "@uipath/common";
 function registerUninstallCommand2(toolsCommand, _context, state) {
   const { resolveInstallPath } = state;
   toolsCommand.command("uninstall").description("Uninstall an installed tool").argument("<package-name>", "Package name (e.g. @uipath/rpa-tool) or command alias (e.g. rpa)").trackedAction(processContext8, async (packageArg) => {
@@ -33760,12 +35699,12 @@ function registerUninstallCommand2(toolsCommand, _context, state) {
       OutputFormatter10.error({
         Result: "Failure",
         Message: `Unknown tool '${packageArg}'.`,
-        Instructions: `Use 'uip tools installed' to see installed tools.`
+        Instructions: `Use 'uip tools list' to see installed tools.`
       });
       processContext8.exit(1);
       return;
     }
-    const [error48] = await catchError10((async () => {
+    const [error48] = await catchError13((async () => {
       const location = await resolveInstallPath();
       await toolService.uninstall(packageName, location.path, {
         global: location.global
@@ -33782,7 +35721,7 @@ function registerUninstallCommand2(toolsCommand, _context, state) {
       OutputFormatter10.error({
         Result: "Failure",
         Message: `Failed to uninstall '${packageName}': ${error48.message}`,
-        Instructions: "Use 'uip tools installed' to see installed tools."
+        Instructions: "Use 'uip tools list' to see installed tools."
       });
       processContext8.exit(1);
     }
@@ -33794,12 +35733,12 @@ var init_uninstall2 = __esm(() => {
 
 // src/commands/tools/update.ts
 import {
-  catchError as catchError11,
-  logger as logger12,
+  catchError as catchError14,
+  logger as logger13,
   OutputFormatter as OutputFormatter11,
   processContext as processContext9
 } from "@uipath/common";
-import { getFileSystem as getFileSystem11 } from "@uipath/filesystem";
+import { getFileSystem as getFileSystem13 } from "@uipath/filesystem";
 function registerUpdateCommand2(toolsCommand, _context, state) {
   const { tools, toolsDirs, resolveInstallPath, getCliVersionPrefix } = state;
   toolsCommand.command("update").description("Update installed tools").option("--name <scoped-tool-name>", "scoped package name").option("--version <version>", "package version to install", "latest").trackedAction(processContext9, async (options) => {
@@ -33812,7 +35751,7 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       processContext9.exit(1);
       return;
     }
-    const [locationError, location] = await catchError11(resolveInstallPath());
+    const [locationError, location] = await catchError14(resolveInstallPath());
     if (locationError) {
       OutputFormatter11.error({
         Result: "Failure",
@@ -33828,13 +35767,13 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       OutputFormatter11.error({
         Result: "Failure",
         Message: `Tool '${options.name}' is not installed.`,
-        Instructions: "Use 'uip tools installed' to see installed tools."
+        Instructions: "Use 'uip tools list' to see installed tools."
       });
       processContext9.exit(1);
       return;
     }
     if (options.version !== "latest") {
-      const [validateError] = catchError11(() => validateVersionString(options.version));
+      const [validateError] = catchError14(() => validateVersionString(options.version));
       if (validateError) {
         OutputFormatter11.error({
           Result: "Failure",
@@ -33849,7 +35788,7 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
     const previousVersions = new Map(toUpdate.map((t) => [t.metadata.name, t.metadata.version]));
     for (const tool of toUpdate) {
       const fullName = `@uipath/${tool.metadata.name}`;
-      const [updateError] = await catchError11((async () => {
+      const [updateError] = await catchError14((async () => {
         let targetVersion = options.version;
         if (targetVersion === "latest") {
           const cliPrefix = getCliVersionPrefix();
@@ -33887,7 +35826,7 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
         });
       }
     }
-    const fs = getFileSystem11();
+    const fs = getFileSystem13();
     const updatedVersions = new Map;
     for (const dir of toolsDirs) {
       for (const tool of toUpdate) {
@@ -33897,10 +35836,10 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
         const pkgPath = fs.path.join(dir, name, "package.json");
         if (!await fs.exists(pkgPath))
           continue;
-        const [readError, raw] = await catchError11(fs.readFile(pkgPath, "utf-8"));
+        const [readError, raw] = await catchError14(fs.readFile(pkgPath, "utf-8"));
         if (readError || !raw)
           continue;
-        const [parseError, pkg] = catchError11(() => JSON.parse(raw));
+        const [parseError, pkg] = catchError14(() => JSON.parse(raw));
         if (parseError || !pkg.version)
           continue;
         updatedVersions.set(name, pkg.version);
@@ -33932,7 +35871,7 @@ function registerUpdateCommand2(toolsCommand, _context, state) {
       Data: results
     });
     if (failed.length > 0) {
-      logger12.error(`Failed to update ${failed.length} tool(s): ${failed.map((f) => `${f.name}: ${f.error}`).join("; ")}`);
+      logger13.error(`Failed to update ${failed.length} tool(s): ${failed.map((f) => `${f.name}: ${f.error}`).join("; ")}`);
       processContext9.exit(1);
     }
   });
@@ -33958,18 +35897,82 @@ var init_tools = __esm(() => {
   init_update2();
 });
 
+// src/services/installPath.ts
+import { catchError as catchError15, logger as logger14 } from "@uipath/common";
+function createInstallPathResolver(toolsDir, isBrowser2) {
+  return async (packageName) => {
+    if (isBrowser2) {
+      const path = packageName ? `/tools/${packageName.replace(/[/@]/g, "_")}` : "/tools";
+      return { path, global: false };
+    }
+    const { getFileSystem: getFileSystem14 } = await import("@uipath/filesystem");
+    const fsLocal = getFileSystem14();
+    const { dirname: dirnameFn, join: joinFn } = fsLocal.path;
+    if (toolsDir) {
+      let path = dirnameFn(dirnameFn(toolsDir));
+      while (insideNodeModules(path)) {
+        const parent = dirnameFn(path);
+        if (parent === path)
+          break;
+        path = parent;
+      }
+      let isGlobal = true;
+      const pkgJsonPath = joinFn(path, "package.json");
+      if (await fsLocal.exists(pkgJsonPath)) {
+        const [, raw] = await catchError15(fsLocal.readFile(pkgJsonPath, "utf-8"));
+        if (raw) {
+          const [, pkgJson] = catchError15(() => JSON.parse(raw));
+          if (pkgJson) {
+            const deps = {
+              ...pkgJson.dependencies,
+              ...pkgJson.devDependencies
+            };
+            if (deps && "@uipath/cli" in deps) {
+              isGlobal = false;
+            }
+            if (pkgJson.workspaces) {
+              isGlobal = false;
+            }
+          }
+        }
+      }
+      logger14.debug(`Install path resolved: ${path} (global: ${isGlobal})`);
+      return { path, global: isGlobal };
+    }
+    let searchDir = fsLocal.env.cwd();
+    for (let i2 = 0;i2 < 10; i2++) {
+      const nodeModulesPath = joinFn(searchDir, "node_modules");
+      const [, exists] = await catchError15(fsLocal.exists(nodeModulesPath));
+      if (exists) {
+        logger14.debug(`Install path resolved via fallback: ${searchDir}`);
+        return { path: searchDir, global: false };
+      }
+      const parentDir = dirnameFn(searchDir);
+      if (parentDir === searchDir)
+        break;
+      searchDir = parentDir;
+    }
+    throw new Error("Unable to determine install location. No node_modules found in parent directories.");
+  };
+}
+var insideNodeModules = (dir) => /[\\/]node_modules([\\/]|$)/.test(dir);
+var init_installPath = () => {};
+
 // src/services/storage.ts
-import { getFileSystem as getFileSystem12, getFileSystemAsync } from "@uipath/filesystem";
+import { logger as logger15 } from "@uipath/common";
+import { getFileSystem as getFileSystem14, getFileSystemAsync } from "@uipath/filesystem";
 
 class GeneralizedStorage {
   async init() {
+    logger15.debug("Initializing filesystem...");
     await getFileSystemAsync();
+    logger15.debug("Filesystem initialized");
   }
   get fs() {
-    return getFileSystem12();
+    return getFileSystem14();
   }
-  async read(path3) {
-    const res = await this.fs.readFile(path3);
+  async read(path) {
+    const res = await this.fs.readFile(path);
     if (res === null)
       return null;
     if (typeof res === "string") {
@@ -33977,25 +35980,25 @@ class GeneralizedStorage {
     }
     return res;
   }
-  async readText(path3) {
-    return this.fs.readFile(path3, "utf-8");
+  async readText(path) {
+    return this.fs.readFile(path, "utf-8");
   }
-  async write(path3, content) {
-    await this.fs.writeFile(path3, content);
+  async write(path, content) {
+    await this.fs.writeFile(path, content);
   }
-  async exists(path3) {
-    return this.fs.exists(path3);
+  async exists(path) {
+    return this.fs.exists(path);
   }
-  async readdir(path3) {
-    return this.fs.readdir(path3);
+  async readdir(path) {
+    return this.fs.readdir(path);
   }
-  async remove(path3) {
-    if (!await this.fs.exists(path3))
+  async remove(path) {
+    if (!await this.fs.exists(path))
       return;
-    await this.fs.rm(path3);
+    await this.fs.rm(path);
   }
-  async mkdir(path3) {
-    await this.fs.mkdir(path3);
+  async mkdir(path) {
+    await this.fs.mkdir(path);
   }
 }
 var storage;
@@ -34004,36 +36007,38 @@ var init_storage = __esm(() => {
 });
 
 // src/utils/toolLoader.ts
-import { logger as logger13 } from "@uipath/common";
+import { catchError as catchError16, logger as logger16 } from "@uipath/common";
+import { getFileSystem as getFileSystem15 } from "@uipath/filesystem";
 import { Command } from "commander";
 function isRunningFromSource() {
-  try {
-    const mainUrl = import.meta.url;
-    return mainUrl.endsWith(".ts");
-  } catch {
+  const [error48, mainUrl] = catchError16(() => import.meta.url);
+  if (error48) {
     return false;
   }
+  return mainUrl.endsWith(".ts");
 }
 function joinPath(...parts) {
   return parts.filter((p) => p).join("/").replace(/\/+/g, "/");
 }
-async function discoverTools(toolsDirs) {
-  try {
-    await storage.init();
-  } catch (error48) {
-    logger13.error("Storage initialization failed:", error48);
+async function discoverToolPaths(toolsDirs) {
+  const [initError] = await catchError16(storage.init());
+  if (initError) {
+    logger16.error("Storage initialization failed:", initError);
     return [];
   }
   const dirs = Array.isArray(toolsDirs) ? toolsDirs : [toolsDirs];
-  const tools = [];
-  const seenCommands = new Set;
+  const discovered = [];
+  const seenPrefixes = new Set;
   for (const toolsDir of dirs) {
     if (!await storage.exists(toolsDir)) {
+      logger16.debug(`Tools directory does not exist, skipping: ${toolsDir}`);
       continue;
     }
-    for (const toolName of WHITELIST_BY_SHORT_NAME.keys()) {
+    logger16.debug(`Scanning tools directory: ${toolsDir}`);
+    const toolNames = [...WHITELIST_BY_SHORT_NAME.keys()];
+    const resolvedPaths = await Promise.all(toolNames.map(async (toolName) => {
       const toolDir = joinPath(toolsDir, toolName);
-      const possiblePaths = isRunningFromSource() ? [
+      const possiblePaths = _isRunningFromSource ? [
         joinPath(toolDir, "src", "tool.ts"),
         joinPath(toolDir, "dist", "tool.js"),
         joinPath(toolDir, "tool.js")
@@ -34042,123 +36047,403 @@ async function discoverTools(toolsDirs) {
         joinPath(toolDir, "tool.js"),
         joinPath(toolDir, "src", "tool.ts")
       ];
-      let toolPath = null;
-      for (const path3 of possiblePaths) {
-        if (await storage.exists(path3)) {
-          toolPath = path3;
-          break;
+      const factoryPaths = _isRunningFromSource ? [
+        joinPath(toolDir, "src", "packager-tool.ts"),
+        joinPath(toolDir, "dist", "packager-tool.js")
+      ] : [
+        joinPath(toolDir, "dist", "packager-tool.js"),
+        joinPath(toolDir, "src", "packager-tool.ts")
+      ];
+      const [existResults, factoryExistResults, pkgJson] = await Promise.all([
+        Promise.all(possiblePaths.map((p) => storage.exists(p))),
+        Promise.all(factoryPaths.map((p) => storage.exists(p))),
+        storage.readText(joinPath(toolDir, "package.json")).catch(() => null)
+      ]);
+      const foundIndex = existResults.indexOf(true);
+      const factoryIndex = factoryExistResults.indexOf(true);
+      let description = "";
+      let version2 = "";
+      if (pkgJson) {
+        const [parseErr, pkg] = catchError16(() => JSON.parse(pkgJson));
+        if (!parseErr) {
+          description = pkg.description ?? "";
+          version2 = pkg.version ?? "";
         }
       }
+      return {
+        toolName,
+        toolPath: foundIndex >= 0 ? possiblePaths[foundIndex] : null,
+        packagerToolPath: factoryIndex >= 0 ? factoryPaths[factoryIndex] : undefined,
+        description,
+        version: version2
+      };
+    }));
+    for (const {
+      toolName,
+      toolPath,
+      packagerToolPath,
+      description,
+      version: version2
+    } of resolvedPaths) {
       if (!toolPath) {
+        logger16.debug(`Tool '${toolName}' not found in ${joinPath(toolsDir, toolName)}`);
         continue;
       }
-      try {
-        let toolModule;
-        const isNode = typeof process !== "undefined" && process.versions && process.versions.node;
-        const isBrowser2 = !isNode;
-        const savedTrackedAction = Command.prototype.trackedAction;
-        if (isBrowser2) {
-          const content = await storage.readText(toolPath);
-          if (!content)
-            continue;
-          const blob = new Blob([content], {
-            type: "text/javascript"
-          });
-          const blobUrl = URL.createObjectURL(blob);
-          try {
-            toolModule = await import(blobUrl);
-          } finally {
-            URL.revokeObjectURL(blobUrl);
-          }
-        } else {
-          const { pathToFileURL } = await import("node:url");
-          const fileUrl = pathToFileURL(toolPath).href;
-          toolModule = await import(fileUrl);
-        }
-        if (savedTrackedAction && Command.prototype.trackedAction !== savedTrackedAction) {
-          Command.prototype.trackedAction = savedTrackedAction;
-          logger13.warn(`Tool ${toolName} overwrote Command.prototype.trackedAction — restored CLI version. ` + `This tool likely bundles @uipath/common instead of externalizing it.`);
-        }
-        const { metadata, registerCommands } = toolModule ?? {};
-        if (!metadata || !registerCommands) {
-          logger13.warn(`Tool ${toolName} missing required exports (metadata or registerCommands), skipping`);
-          continue;
-        }
-        const prefix = metadata.commandPrefix;
-        if (seenCommands.has(prefix)) {
-          logger13.info(`Tool ${toolName} (command '${prefix}') already loaded from a higher-priority path, skipping`);
-          continue;
-        }
-        seenCommands.add(prefix);
-        const tool = {
-          metadata,
-          registerCommands
-        };
-        tools.push(tool);
-      } catch (error48) {
-        logger13.error(`Failed to load tool ${toolName}:`, error48);
+      const packageName = WHITELIST_BY_SHORT_NAME.get(toolName);
+      const commandPrefix = packageName ? TOOLS_WHITELIST.get(packageName) : undefined;
+      if (!commandPrefix || !packageName) {
+        logger16.warn(`Tool '${toolName}' found at ${toolPath} but not in whitelist, skipping`);
+        continue;
+      }
+      if (seenPrefixes.has(commandPrefix)) {
+        logger16.info(`Tool ${toolName} (command '${commandPrefix}') already found from a higher-priority path, skipping`);
+        continue;
       }
+      seenPrefixes.add(commandPrefix);
+      discovered.push({
+        toolName,
+        toolPath,
+        commandPrefix,
+        packageName,
+        description,
+        version: version2,
+        packagerToolPath
+      });
+      logger16.debug(`Discovered tool '${toolName}' at ${toolPath} (prefix: ${commandPrefix})`);
+    }
+  }
+  return discovered;
+}
+async function importModuleByPath(modulePath) {
+  const savedTrackedAction = Command.prototype.trackedAction;
+  const [error48, mod] = await catchError16((async () => {
+    if (_isBrowser) {
+      const content = await storage.readText(modulePath);
+      if (!content)
+        return;
+      const blob = new Blob([content], { type: "text/javascript" });
+      const blobUrl = URL.createObjectURL(blob);
+      const [importError, imported] = await catchError16(import(blobUrl));
+      URL.revokeObjectURL(blobUrl);
+      if (importError)
+        throw importError;
+      return imported;
+    } else {
+      const { pathToFileURL } = await import("node:url");
+      const fileUrl = pathToFileURL(modulePath).href;
+      return await import(fileUrl);
+    }
+  })());
+  if (savedTrackedAction && Command.prototype.trackedAction !== savedTrackedAction) {
+    Command.prototype.trackedAction = savedTrackedAction;
+    logger16.warn(`Import of ${modulePath} overwrote Command.prototype.trackedAction — restored CLI version.`);
+  }
+  if (error48)
+    throw error48;
+  return mod;
+}
+async function importTool(discovered) {
+  const { toolName, toolPath } = discovered;
+  logger16.debug(`Loading tool '${toolName}' from ${toolPath}`);
+  const [error48, toolModule] = await catchError16(importModuleByPath(toolPath));
+  if (error48) {
+    logger16.error(`Failed to load tool ${toolName}:`, error48);
+    return;
+  }
+  const { metadata, registerCommands } = toolModule ?? {};
+  if (!metadata || !registerCommands) {
+    logger16.warn(`Tool ${toolName} missing required exports (metadata or registerCommands), skipping`);
+    return;
+  }
+  logger16.debug(`Tool '${toolName}' loaded successfully (prefix: ${metadata.commandPrefix}, version: ${metadata.version ?? "unknown"})`);
+  return { metadata, registerCommands };
+}
+async function importPackagerTool(discovered) {
+  const { toolName, packagerToolPath } = discovered;
+  if (!packagerToolPath)
+    return;
+  logger16.debug(`Loading packager factory for '${toolName}' from ${packagerToolPath}`);
+  const [error48] = await catchError16(importModuleByPath(packagerToolPath));
+  if (error48) {
+    throw new Error(`Failed to load packager factory for '${toolName}' from ${packagerToolPath}: ${error48 instanceof Error ? error48.message : error48}`);
+  }
+}
+async function discoverTools(toolsDirs) {
+  const discovered = await discoverToolPaths(toolsDirs);
+  const tools = [];
+  for (const entry of discovered) {
+    const tool = await importTool(entry);
+    if (tool) {
+      tools.push(tool);
     }
   }
   return tools;
 }
+function isInsideNodeModules(dir) {
+  const segments = dir.replace(/\\/g, "/").split("/").filter(Boolean);
+  return segments.includes("node_modules");
+}
+async function findNearestToolsDir(startDir, seen) {
+  const fs = getFileSystem15();
+  const { dirname, join } = fs.path;
+  const results = [];
+  let searchPath = startDir;
+  for (let i2 = 0;i2 < MAX_WALK_DEPTH; i2++) {
+    const candidate = join(searchPath, "node_modules", "@uipath");
+    const [, exists] = await catchError16(fs.exists(candidate));
+    if (exists) {
+      if (seen.has(candidate)) {
+        logger16.debug(`Tools directory already seen, stopping walk: ${candidate}`);
+        break;
+      }
+      seen.add(candidate);
+      results.push(candidate);
+      logger16.debug(`Found tools directory: ${candidate}`);
+      if (!isInsideNodeModules(searchPath)) {
+        break;
+      }
+      logger16.debug("Search path is inside node_modules, continuing walk for hoisted packages");
+    }
+    const parentPath = dirname(searchPath);
+    if (parentPath === searchPath) {
+      break;
+    }
+    searchPath = parentPath;
+  }
+  if (results.length === 0) {
+    logger16.debug(`No tools directory found walking up from ${startDir}`);
+  }
+  return results;
+}
+async function resolveToolsDirs(cliFilePath, cwd) {
+  const fs = getFileSystem15();
+  const { dirname } = fs.path;
+  const seen = new Set;
+  const dirs = [];
+  dirs.push(...await findNearestToolsDir(dirname(cliFilePath), seen));
+  dirs.push(...await findNearestToolsDir(cwd, seen));
+  logger16.debug(`Resolved ${dirs.length} tool directories: ${dirs.join(", ") || "(none)"}`);
+  return dirs;
+}
+var _isRunningFromSource, _isBrowser, MAX_WALK_DEPTH = 10;
 var init_toolLoader = __esm(() => {
   init_storage();
   init_toolService();
+  _isRunningFromSource = isRunningFromSource();
+  _isBrowser = !(typeof process !== "undefined" && process.versions && process.versions.node);
 });
 
 // src/services/tool-manager.ts
-import { logger as logger14 } from "@uipath/common";
+import { logger as logger17 } from "@uipath/common";
 
 class ToolManager {
   toolsDirs;
   resolveInstallPath;
   cliVersionPrefix;
   tools;
-  constructor(tools, toolsDirs, resolveInstallPath, cliVersionPrefix) {
+  discoveredTools;
+  discoveredPrefixes;
+  constructor(tools, toolsDirs, resolveInstallPath, cliVersionPrefix, discoveredTools) {
     this.toolsDirs = toolsDirs;
     this.resolveInstallPath = resolveInstallPath;
     this.cliVersionPrefix = cliVersionPrefix;
     this.tools = tools;
+    this.discoveredTools = discoveredTools ?? [];
+    this.discoveredPrefixes = new Set(this.discoveredTools.map((d) => d.commandPrefix));
   }
   isInstalled(verb) {
-    return this.tools.some((t) => t.metadata.commandPrefix === verb);
+    return this.discoveredPrefixes.has(verb) || this.tools.some((t) => t.metadata.commandPrefix === verb);
   }
   async ensureAvailable(verb) {
-    if (this.isInstalled(verb))
+    if (this.isInstalled(verb)) {
+      logger17.debug(`Tool '${verb}' is already installed`);
       return;
+    }
     const packageName = WHITELIST_BY_COMMAND.get(verb);
     if (!packageName) {
       throw new Error(`Unknown tool verb '${verb}'.`);
     }
-    logger14.info(`Tool '${verb}' is not installed. Searching for compatible version...`);
+    logger17.info(`Tool '${verb}' is not installed. Searching for compatible version...`);
+    logger17.debug(`Searching latest version of '${packageName}' with prefix '${this.cliVersionPrefix}'`);
     const version2 = await toolService.searchLatestVersion(packageName, this.cliVersionPrefix);
     if (!version2) {
       throw new Error(`No compatible version of '${packageName}' found for CLI (needs ${this.cliVersionPrefix}x).`);
     }
     const packageSpec = `${packageName}@${version2}`;
     const location = await this.resolveInstallPath();
+    logger17.debug(`Installing ${packageSpec} to ${location.path} (global: ${location.global})`);
     await toolService.install(packageSpec, location.path, {
       global: location.global
     });
-    logger14.info(`Installed ${packageSpec} successfully.`);
+    logger17.info(`Installed ${packageSpec} successfully.`);
+    logger17.debug("Re-discovering tools after install...");
     this.tools = await discoverTools(this.toolsDirs);
   }
+  async ensurePackagerFactory(verb) {
+    let entry = this.discoveredTools.find((d) => d.commandPrefix === verb);
+    if (!entry) {
+      logger17.info(`Tool '${verb}' not found on disk. Attempting install...`);
+      await this.installTool(verb);
+      entry = this.discoveredTools.find((d) => d.commandPrefix === verb);
+      if (!entry) {
+        const discovered = this.discoveredTools.map((d) => d.commandPrefix).join(", ");
+        throw new Error(`Tool '${verb}' was not found after installation. ` + `Scanned directories: [${this.toolsDirs.join(", ")}]. ` + `Discovered tools: [${discovered || "none"}].`);
+      }
+    }
+    if (entry.packagerToolPath) {
+      logger17.debug(`Loading packager factory for '${verb}' from ${entry.packagerToolPath}`);
+      await importPackagerTool(entry);
+      return;
+    }
+    logger17.debug(`Tool '${verb}' has no packager-tool entry point, falling back to full tool import`);
+    const tool = await importTool(entry);
+    if (!tool) {
+      throw new Error(`Tool '${verb}' was discovered on disk but failed to load. ` + `Entry point: ${entry.toolPath}`);
+    }
+  }
   getTools() {
     return this.tools;
   }
+  async installTool(verb) {
+    const packageName = WHITELIST_BY_COMMAND.get(verb);
+    if (!packageName) {
+      throw new Error(`Unknown tool verb '${verb}'.`);
+    }
+    logger17.info(`Tool '${verb}' is not installed. Searching for compatible version...`);
+    const version2 = await toolService.searchLatestVersion(packageName, this.cliVersionPrefix);
+    if (!version2) {
+      throw new Error(`No compatible version of '${packageName}' found for CLI (needs ${this.cliVersionPrefix}x).`);
+    }
+    const packageSpec = `${packageName}@${version2}`;
+    const location = await this.resolveInstallPath();
+    logger17.debug(`Installing ${packageSpec} to ${location.path} (global: ${location.global})`);
+    await toolService.install(packageSpec, location.path, {
+      global: location.global
+    });
+    logger17.info(`Installed ${packageSpec} successfully.`);
+    logger17.debug(`Re-discovering tools in [${this.toolsDirs.join(", ")}]...`);
+    this.discoveredTools = await discoverToolPaths(this.toolsDirs);
+    this.discoveredPrefixes = new Set(this.discoveredTools.map((d) => d.commandPrefix));
+    logger17.debug(`After install, discovered: [${this.discoveredTools.map((d) => d.commandPrefix).join(", ") || "none"}]`);
+  }
 }
 var init_tool_manager = __esm(() => {
   init_toolLoader();
   init_toolService();
 });
 
-// src/telemetry-events.ts
-var CliTelemetryEvents;
-var init_telemetry_events = __esm(() => {
-  CliTelemetryEvents = {
-    Help: "uip.help",
-    Version: "uip.version"
+// src/utils/autoInstall.ts
+import { catchError as catchError17, logger as logger18, OutputFormatter as OutputFormatter12 } from "@uipath/common";
+async function autoInstallToolIfNeeded(args, program, toolManager, context) {
+  if (context.capabilities.isBrowser)
+    return false;
+  const OPTS_WITH_VALUES = new Set(program.options.filter((o) => o.required || o.optional).flatMap((o) => [o.short, o.long].filter(Boolean)));
+  let requestedVerb;
+  const cliArgs = args.slice(2);
+  for (let i2 = 0;i2 < cliArgs.length; i2++) {
+    const a = cliArgs[i2];
+    if (OPTS_WITH_VALUES.has(a)) {
+      i2++;
+      continue;
+    }
+    if (a.startsWith("-"))
+      continue;
+    if (WHITELIST_BY_COMMAND.has(a))
+      requestedVerb = a;
+    break;
+  }
+  if (requestedVerb && !toolManager.isInstalled(requestedVerb)) {
+    logger18.debug(`Tool '${requestedVerb}' not installed — attempting auto-install`);
+    const [error48] = await catchError17(toolManager.ensureAvailable(requestedVerb));
+    if (error48) {
+      OutputFormatter12.error({
+        Result: "Failure",
+        Message: `Failed to auto-install '${requestedVerb}': ${error48.message}`,
+        Instructions: `Run 'uip tools install ${requestedVerb}' to install manually.`
+      });
+      context.exit(1);
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+var init_autoInstall = __esm(() => {
+  init_toolService();
+});
+
+// src/utils/globalOptions.ts
+import {
+  getOutputSink as getOutputSink2
+} from "@uipath/common";
+function stripGlobalOptions(args) {
+  const cleaned = [];
+  let format;
+  let filter;
+  let logLevel;
+  let logFile;
+  for (let i2 = 0;i2 < args.length; i2++) {
+    if (args[i2] === "--output-filter" && i2 + 1 < args.length) {
+      filter = args[i2 + 1];
+      i2++;
+      continue;
+    }
+    if (args[i2]?.startsWith("--output-filter=")) {
+      filter = args[i2].substring("--output-filter=".length);
+      continue;
+    }
+    if (args[i2] === "--output" && i2 + 1 < args.length) {
+      const v = args[i2 + 1];
+      if (VALID_FORMATS.includes(v)) {
+        format = v;
+        i2++;
+        continue;
+      }
+    }
+    if (args[i2]?.startsWith("--output=")) {
+      const v = args[i2].substring("--output=".length);
+      if (VALID_FORMATS.includes(v)) {
+        format = v;
+        continue;
+      }
+    }
+    if (args[i2] === "--log-level" && i2 + 1 < args.length) {
+      const parsed = VALID_LOG_LEVELS[args[i2 + 1].toLowerCase()];
+      if (parsed !== undefined) {
+        logLevel = parsed;
+      }
+      i2++;
+      continue;
+    }
+    if (args[i2]?.startsWith("--log-level=")) {
+      const parsed = VALID_LOG_LEVELS[args[i2].substring("--log-level=".length).toLowerCase()];
+      if (parsed !== undefined) {
+        logLevel = parsed;
+      }
+      continue;
+    }
+    if (args[i2] === "--log-file" && i2 + 1 < args.length) {
+      logFile = args[i2 + 1];
+      i2++;
+      continue;
+    }
+    if (args[i2]?.startsWith("--log-file=")) {
+      logFile = args[i2].substring("--log-file=".length);
+      continue;
+    }
+    cleaned.push(args[i2]);
+  }
+  const resolvedFormat = format ?? (getOutputSink2().capabilities.isInteractive ? "table" : "json");
+  return { args: cleaned, format: resolvedFormat, filter, logLevel, logFile };
+}
+var VALID_FORMATS, VALID_LOG_LEVELS;
+var init_globalOptions = __esm(() => {
+  VALID_FORMATS = ["table", "json", "yaml", "plain"];
+  VALID_LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
   };
 });
 
@@ -34166,16 +36451,247 @@ var init_telemetry_events = __esm(() => {
 import {
   extractCommandHelp,
   getOutputFormat,
-  OutputFormatter as OutputFormatter12
+  getOutputSink as getOutputSink3,
+  OutputFormatter as OutputFormatter13
 } from "@uipath/common";
-import { Help } from "commander";
+function getCommandPath(cmd) {
+  const names = [];
+  let current = cmd;
+  while (current) {
+    const name = current.name();
+    if (name) {
+      names.unshift(name);
+    }
+    current = current.parent ?? null;
+  }
+  return names.join(" ");
+}
+function isRootCommand(cmd) {
+  return !cmd.parent;
+}
+function getHelpWidth() {
+  const width = getOutputSink3().capabilities.outputWidth;
+  if (!Number.isFinite(width) || width <= 0) {
+    return 80;
+  }
+  return width < 56 ? width : Math.min(width, 120);
+}
+function centerText(text, width) {
+  if (text.length >= width) {
+    return text;
+  }
+  const left = Math.floor((width - text.length) / 2);
+  const right = width - text.length - left;
+  return `${" ".repeat(left)}${text}${" ".repeat(right)}`;
+}
+function wrapText(text, width) {
+  if (width <= 0) {
+    return [text];
+  }
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return [""];
+  }
+  const words = trimmed.split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (current.length === 0) {
+      if (word.length <= width) {
+        current = word;
+        continue;
+      }
+      for (let index = 0;index < word.length; index += width) {
+        lines.push(word.slice(index, index + width));
+      }
+      continue;
+    }
+    if (current.length + word.length + 1 <= width) {
+      current = `${current} ${word}`;
+      continue;
+    }
+    lines.push(current);
+    current = "";
+    if (word.length <= width) {
+      current = word;
+      continue;
+    }
+    for (let index = 0;index < word.length; index += width) {
+      const chunk = word.slice(index, index + width);
+      if (chunk.length === width || index + width < word.length) {
+        lines.push(chunk);
+      } else {
+        current = chunk;
+      }
+    }
+  }
+  if (current.length > 0) {
+    lines.push(current);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+function summarizeDescription(description) {
+  const [firstLine = ""] = description.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  return firstLine || "No description";
+}
+function renderRows(rows, contentWidth) {
+  if (rows.length === 0) {
+    return [];
+  }
+  const longestLabel = Math.max(...rows.map((row) => row.Label.length));
+  const maxLabelWidth = Math.max(contentWidth - 3 - 12, 1);
+  const labelWidth = Math.min(longestLabel, Math.max(18, Math.floor(contentWidth * 0.38)), maxLabelWidth);
+  const descriptionWidth = Math.max(contentWidth - labelWidth - 3, 1);
+  const lines = [];
+  for (const row of rows) {
+    const labelLines = wrapText(row.Label, labelWidth);
+    const descriptionLines = wrapText(row.Description, descriptionWidth);
+    const rowHeight = Math.max(labelLines.length, descriptionLines.length);
+    for (let index = 0;index < rowHeight; index++) {
+      const label = (labelLines[index] ?? "").padEnd(labelWidth);
+      const description = descriptionLines[index] ?? "";
+      lines.push(`${label}   ${description}`);
+    }
+  }
+  return lines;
+}
+function renderSection(section, width) {
+  const contentWidth = Math.max(width - 4, 16);
+  const title = ` ${section.Title} `;
+  const ruleWidth = Math.max(width - title.length - 3, 0);
+  const top = `┌─${title}${"─".repeat(ruleWidth)}┐`;
+  const body = section.Lines.map((line) => `│ ${line.padEnd(contentWidth)} │`);
+  const bottom = `└${"─".repeat(width - 2)}┘`;
+  return [top, ...body, bottom].join(`
+`);
+}
+function renderBanner(description, cmd) {
+  const title = description || "UiPath CLI";
+  const tagline = "Build automations, agents, and orchestrations from your terminal.";
+  const rootName = getCommandPath(cmd);
+  const usage = [
+    `${rootName} <command> [options]`,
+    `${rootName} <tool> <command> [options]`
+  ];
+  return [
+    `  ${title}`,
+    `  ${tagline}`,
+    "",
+    `  Usage: ${usage[0]}`,
+    `         ${usage[1]}`
+  ].join(`
+`);
+}
+function renderCommandHeader(commandPath, description, width) {
+  const lines = [centerText(commandPath, width)];
+  if (description) {
+    lines.push(centerText(description, width));
+  }
+  lines.push(centerText("Use --help with nested commands for more detail.", width));
+  return lines.join(`
+`);
+}
+function buildUsageLines(cmd, helper) {
+  return [helper.commandUsage(cmd)];
+}
+function sortByLabel(rows) {
+  return [...rows].sort((a, b) => a.Label.localeCompare(b.Label));
+}
+function buildTableHelpSections(cmd, helper) {
+  const contentWidth = Math.max(getHelpWidth() - 4, 16);
+  const baseHelp = extractCommandHelp(cmd, helper);
+  const sections = [];
+  if (!isRootCommand(cmd)) {
+    sections.push({
+      Title: "Usage",
+      Lines: buildUsageLines(cmd, helper)
+    });
+  }
+  if (baseHelp.Arguments.length > 0) {
+    sections.push({
+      Title: "Arguments",
+      Lines: renderRows(baseHelp.Arguments.map((argument) => ({
+        Label: argument.Name,
+        Description: argument.Description || "No description"
+      })), contentWidth)
+    });
+  }
+  const subcommands = helper.visibleCommands(cmd).map((subcommand) => ({
+    Key: subcommand.name(),
+    Label: subcommand.name(),
+    Description: summarizeDescription(helper.subcommandDescription(subcommand) || "")
+  }));
+  if (isRootCommand(cmd)) {
+    const builtIns = subcommands.filter((subcommand) => BUILT_IN_ROOT_COMMANDS.has(subcommand.Key) && subcommand.Key !== "help");
+    const tools = subcommands.filter((subcommand) => !BUILT_IN_ROOT_COMMANDS.has(subcommand.Key));
+    if (builtIns.length > 0) {
+      sections.push({
+        Title: "Commands",
+        Lines: renderRows(sortByLabel(builtIns.map(({ Label, Description }) => ({
+          Label,
+          Description
+        }))), contentWidth)
+      });
+    }
+    if (tools.length > 0) {
+      sections.push({
+        Title: "Installed Tools",
+        Lines: renderRows(sortByLabel(tools.map(({ Label, Description }) => ({
+          Label,
+          Description
+        }))), contentWidth)
+      });
+    }
+  } else if (subcommands.length > 0) {
+    sections.push({
+      Title: "Commands",
+      Lines: renderRows(sortByLabel(subcommands.map(({ Label, Description }) => ({
+        Label,
+        Description
+      }))), contentWidth)
+    });
+  }
+  const allOptions = [
+    ...baseHelp.Options.map((option) => ({
+      Label: option.Flags,
+      Description: option.Description || "No description"
+    })),
+    ...GLOBAL_OPTIONS.map((option) => ({
+      Label: option.Flags,
+      Description: option.Description
+    }))
+  ];
+  if (allOptions.length > 0) {
+    sections.push({
+      Title: "Options",
+      Lines: renderRows(allOptions, contentWidth)
+    });
+  }
+  return sections;
+}
+function renderTableHelp(cmd, helper) {
+  const width = getHelpWidth();
+  const description = helper.commandDescription(cmd);
+  const parts = [];
+  if (isRootCommand(cmd)) {
+    parts.push(renderBanner(description, cmd));
+  } else {
+    parts.push(renderCommandHeader(getCommandPath(cmd), description, width));
+  }
+  for (const section of buildTableHelpSections(cmd, helper)) {
+    parts.push(renderSection(section, width));
+  }
+  return parts.join(`
+
+`) + `
+`;
+}
 function createHelpConfiguration(isBrowser2) {
-  const originalFormatHelp = Help.prototype.formatHelp;
   const config2 = {
     formatHelp(cmd, helper) {
       const format = getOutputFormat();
       if (format === "table") {
-        return originalFormatHelp.call(this, cmd, helper);
+        return renderTableHelp(cmd, helper);
       }
       const baseHelp = extractCommandHelp(cmd, helper);
       const subcommands = helper.visibleCommands(cmd).map((sub) => ({
@@ -34192,7 +36708,7 @@ function createHelpConfiguration(isBrowser2) {
         Code: "Help",
         Data: helpData
       };
-      return OutputFormatter12.formatToString(output);
+      return OutputFormatter13.formatToString(output);
     }
   };
   if (isBrowser2) {
@@ -34208,7 +36724,7 @@ function createHelpConfiguration(isBrowser2) {
   }
   return config2;
 }
-var GLOBAL_OPTIONS;
+var GLOBAL_OPTIONS, BUILT_IN_ROOT_COMMANDS;
 var init_helpFormatter = __esm(() => {
   GLOBAL_OPTIONS = [
     {
@@ -34228,6 +36744,136 @@ var init_helpFormatter = __esm(() => {
       Description: "Write logs to file instead of stderr"
     }
   ];
+  BUILT_IN_ROOT_COMMANDS = new Set([
+    "help",
+    "login",
+    "logout",
+    "mcp",
+    "skills",
+    "tools"
+  ]);
+});
+
+// src/telemetry-events.ts
+var CliTelemetryEvents;
+var init_telemetry_events = __esm(() => {
+  CliTelemetryEvents = {
+    Help: "uip.help",
+    Version: "uip.version"
+  };
+});
+
+// src/utils/parseError.ts
+import {
+  OutputFormatter as OutputFormatter14,
+  telemetry,
+  telemetryFlushAndShutdown
+} from "@uipath/common";
+async function handleParseError(error48, cleanedArgs, context) {
+  const isObj = error48 !== null && typeof error48 === "object";
+  const e = isObj ? error48 : {};
+  const code = typeof e.code === "string" ? e.code : undefined;
+  const message = typeof e.message === "string" ? e.message : String(error48);
+  const exitCode = typeof e.exitCode === "number" ? e.exitCode : undefined;
+  if (code?.startsWith("commander.")) {
+    if (code === "commander.helpDisplayed" || code === "commander.version" || message === "(outputHelp)") {
+      const eventName = code === "commander.version" ? CliTelemetryEvents.Version : CliTelemetryEvents.Help;
+      const command = cleanedArgs.slice(2).filter((a) => !a.startsWith("-")).join(" ") || "root";
+      telemetry.trackEvent(eventName, { command });
+      await telemetryFlushAndShutdown();
+      context.exit(exitCode ?? 0);
+      return;
+    }
+    OutputFormatter14.error({
+      Result: "ValidationError",
+      Message: message,
+      Instructions: "Check command arguments and options. Use --help for usage information."
+    });
+    await telemetryFlushAndShutdown();
+    context.exit(exitCode ?? 1);
+    return;
+  }
+  await telemetryFlushAndShutdown();
+  context.exit(1);
+}
+var init_parseError = __esm(() => {
+  init_telemetry_events();
+});
+
+// src/utils/registerToolCommands.ts
+import { catchError as catchError18, logger as logger19, OutputFormatter as OutputFormatter15 } from "@uipath/common";
+function registerLazyToolCommands(program, discovered, context) {
+  logger19.debug("Registering lazy tool commands...");
+  for (const entry of discovered) {
+    logger19.debug(`Registering lazy command for tool '${entry.toolName}' (prefix: ${entry.commandPrefix})`);
+    const toolCommand = program.command(entry.commandPrefix).description(entry.description).allowUnknownOption().allowExcessArguments(true).helpOption(false);
+    toolCommand.action(async () => {
+      logger19.debug(`Lazy-loading tool '${entry.toolName}' on first use...`);
+      const tool = await importTool(entry);
+      if (!tool) {
+        OutputFormatter15.error({
+          Result: "Failure",
+          Message: `Failed to load tool '${entry.toolName}'.`,
+          Instructions: `Try reinstalling with 'uip tools install ${entry.commandPrefix}'.`
+        });
+        context.exit(1);
+        return;
+      }
+      const idx = program.commands.indexOf(toolCommand);
+      if (idx >= 0) {
+        program.commands.splice(idx, 1);
+      }
+      const realCommand = program.command(tool.metadata.commandPrefix).description(tool.metadata.description);
+      const [regError] = await catchError18(tool.registerCommands(realCommand));
+      if (regError) {
+        OutputFormatter15.error({
+          Result: "Failure",
+          Message: `Failed to register commands from tool '${tool.metadata.name}': ${regError.message}`,
+          Instructions: "This might be due to a command name conflict with existing commands."
+        });
+        context.exit(1);
+        return;
+      }
+      await program.parseAsync(context.args);
+    });
+  }
+}
+var init_registerToolCommands = __esm(() => {
+  init_toolLoader();
+});
+
+// src/utils/resolveToolsDirectories.ts
+import { fileURLToPath } from "node:url";
+import { logger as logger20 } from "@uipath/common";
+import { getFileSystem as getFileSystem16 } from "@uipath/filesystem";
+async function resolveToolsDirectories(context) {
+  if (context.capabilities.isBrowser) {
+    logger20.debug("Browser mode — tools directory: /tools");
+    return { toolsDirs: ["/tools"], toolsDir: "/tools" };
+  }
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const fs = getFileSystem16();
+  const toolsDirs = await resolveToolsDirs(currentFilePath, fs.env.cwd());
+  const toolsDir = toolsDirs[0];
+  if (toolsDirs.length > 0) {
+    return { toolsDirs, toolsDir };
+  }
+  logger20.warn("Unable to determine tools directory. Please ensure the CLI is installed correctly.");
+  const { dirname, join } = fs.path;
+  const isInstalledPackage = process.execPath.includes(join("@uipath", "cli", "dist", "uip"));
+  if (isInstalledPackage) {
+    const execDir = dirname(process.execPath);
+    const packageDir = dirname(execDir);
+    const fallbackDir2 = dirname(packageDir);
+    logger20.debug(`Fallback (installed package): ${fallbackDir2}`);
+    return { toolsDirs: [fallbackDir2], toolsDir: fallbackDir2 };
+  }
+  const fallbackDir = join(dirname(currentFilePath), "..");
+  logger20.debug(`Fallback (development mode): ${fallbackDir}`);
+  return { toolsDirs: [fallbackDir], toolsDir: fallbackDir };
+}
+var init_resolveToolsDirectories = __esm(() => {
+  init_toolLoader();
 });
 
 // cli.ts
@@ -34235,20 +36881,16 @@ var exports_cli = {};
 __export(exports_cli, {
   run: () => run
 });
-import { fileURLToPath } from "node:url";
 import {
+  catchError as catchError19,
   configureLogger,
-  DEFAULT_LOG_LEVEL,
-  getOutputFormat as getOutputFormat2,
-  getOutputSink as getOutputSink2,
   LogLevel,
-  OutputFormatter as OutputFormatter13,
+  logger as logger21,
   registerHelpAll,
   setOutputFilter,
   setOutputFormat,
-  setToolProvider,
-  telemetry,
-  telemetryFlushAndShutdown,
+  setPackagerFactoryProvider,
+  telemetryFlushAndShutdown as telemetryFlushAndShutdown2,
   telemetryInit
 } from "@uipath/common";
 import { Command as Command2 } from "commander";
@@ -34269,13 +36911,14 @@ async function buildProgram(context) {
     logLevel,
     logFile
   } = stripGlobalOptions(context.args);
+  context.args = cleanedArgs;
   setOutputFormat(helpFormat);
   setOutputFilter(filter);
   configureLogger({
     ...logLevel !== undefined && { level: logLevel },
     ...logFile !== undefined && { logFile }
   });
-  await telemetryInit({ uip_version: package_default.version });
+  logger21.debug(`CLI v${package_default.version} starting — output=${helpFormat}, logLevel=${logLevel !== undefined ? LogLevel[logLevel].toLowerCase() : "default"}, logFile=${logFile ?? "none"}`);
   program.exitOverride();
   program.configureOutput({
     writeOut: context.output.writeOut,
@@ -34285,280 +36928,75 @@ async function buildProgram(context) {
     getErrHelpWidth: context.output.getOutputWidth
   });
   program.configureHelp(createHelpConfiguration(context.capabilities.isBrowser));
-  program.addHelpText("after", () => {
-    if (getOutputFormat2() !== "table")
-      return "";
-    return `
-Global Options:
-` + `  --output <table|json|yaml|plain>    Output format (default: table for interactive, json otherwise)
-` + `  --output-filter <expression>        JMESPath expression to filter output
-` + `  --log-level <debug|info|warn|error>  Log level threshold (default: ${LogLevel[DEFAULT_LOG_LEVEL].toLowerCase()})
-` + "  --log-file <path>                    Write logs to file instead of stderr";
-  });
-  try {
-    await storage.init();
-  } catch (error48) {
-    if (context.capabilities.isBrowser) {
-      context.output.writeErr(`Storage initialization failed: ${errorMessage(error48)}`);
+  const storageAndToolsDirsPromise = (async () => {
+    logger21.debug("Initializing storage...");
+    const [storageError] = await catchError19(storage.init());
+    if (storageError) {
+      if (context.capabilities.isBrowser) {
+        context.output.writeErr(`Storage initialization failed: ${errorMessage(storageError)}`);
+      } else {
+        throw storageError;
+      }
     } else {
-      throw error48;
+      logger21.debug("Storage initialized");
     }
-  }
+    logger21.debug("Resolving tool directories...");
+    const result = await resolveToolsDirectories(context);
+    logger21.debug(`Resolved ${result.toolsDirs.length} tool directories: ${result.toolsDirs.join(", ") || "(none)"}`);
+    return result;
+  })();
+  const [, { toolsDirs, toolsDir }] = await Promise.all([
+    telemetryInit({ uip_version: package_default.version }).then(() => logger21.debug("Telemetry initialized")).catch((err) => logger21.warn(`Telemetry init failed (non-fatal): ${errorMessage(err)}`)),
+    storageAndToolsDirsPromise
+  ]);
+  logger21.debug("Registering login/logout commands");
   registerLoginCommand(program, context);
   registerLogoutCommand(program, context);
-  let toolsDirs = [];
-  let toolsDir;
-  if (context.capabilities.isBrowser) {
-    toolsDir = "/tools";
-    toolsDirs = [toolsDir];
-  } else {
-    const { getFileSystem: getFileSystem13 } = await import("@uipath/filesystem");
-    const fs = getFileSystem13();
-    const { dirname, join } = fs.path;
-    const currentFilePath = fileURLToPath(import.meta.url);
-    let searchPath = dirname(currentFilePath);
-    const seen = new Set;
-    for (let i2 = 0;i2 < 10; i2++) {
-      const nodeModulesPath = join(searchPath, "node_modules", "@uipath");
-      try {
-        if (await fs.exists(nodeModulesPath)) {
-          if (!seen.has(nodeModulesPath)) {
-            seen.add(nodeModulesPath);
-            toolsDirs.push(nodeModulesPath);
-          }
-        }
-      } catch (_e) {}
-      const parentPath = dirname(searchPath);
-      if (parentPath === searchPath) {
-        break;
-      }
-      searchPath = parentPath;
-    }
-    searchPath = process.cwd();
-    for (let i2 = 0;i2 < 10; i2++) {
-      const nodeModulesPath = join(searchPath, "node_modules", "@uipath");
-      try {
-        if (!seen.has(nodeModulesPath) && await fs.exists(nodeModulesPath)) {
-          seen.add(nodeModulesPath);
-          toolsDirs.push(nodeModulesPath);
-        }
-      } catch (_e) {}
-      const parentPath = dirname(searchPath);
-      if (parentPath === searchPath)
-        break;
-      searchPath = parentPath;
-    }
-    toolsDir = toolsDirs[0];
-    if (toolsDirs.length === 0) {
-      context.output.writeErr(`Unable to determine tools directory. Please ensure the CLI is installed correctly.
-`);
-      const isInstalledPackage = process.execPath.includes(join("@uipath", "cli", "dist", "uip"));
-      if (isInstalledPackage) {
-        const execDir = dirname(process.execPath);
-        const packageDir = dirname(execDir);
-        toolsDir = dirname(packageDir);
-        toolsDirs = [toolsDir];
-      } else {
-        const currentFileUrl = import.meta.url;
-        const currentFilePath2 = fileURLToPath(currentFileUrl);
-        toolsDir = join(dirname(currentFilePath2), "..");
-        toolsDirs = [toolsDir];
-      }
-    }
-  }
-  async function resolveInstallPath(packageName) {
-    if (context.capabilities.isBrowser) {
-      const path3 = packageName ? `/tools/${packageName.replace(/[/@]/g, "_")}` : "/tools";
-      return { path: path3, global: false };
-    }
-    const { getFileSystem: getFileSystem13 } = await import("@uipath/filesystem");
-    const fsLocal = getFileSystem13();
-    const { dirname: dirnameFn, join: joinFn } = fsLocal.path;
-    const { existsSync } = await import("node:fs");
-    if (toolsDir) {
-      const path3 = dirnameFn(dirnameFn(toolsDir));
-      let isGlobal = true;
-      const pkgJsonPath = joinFn(path3, "package.json");
-      if (existsSync(pkgJsonPath)) {
-        try {
-          const { readFileSync } = await import("node:fs");
-          const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
-          const deps = {
-            ...pkgJson.dependencies,
-            ...pkgJson.devDependencies
-          };
-          if (deps && "@uipath/cli" in deps) {
-            isGlobal = false;
-          }
-        } catch {}
-      }
-      return { path: path3, global: isGlobal };
-    }
-    let searchDir = process.cwd();
-    for (let i2 = 0;i2 < 10; i2++) {
-      const nodeModulesPath = joinFn(searchDir, "node_modules");
-      try {
-        if (await fsLocal.exists(nodeModulesPath)) {
-          return { path: searchDir, global: false };
-        }
-      } catch (_e) {}
-      const parentDir = dirnameFn(searchDir);
-      if (parentDir === searchDir)
-        break;
-      searchDir = parentDir;
-    }
-    throw new Error("Unable to determine install location. No node_modules found in parent directories.");
-  }
-  const initialTools = await discoverTools(toolsDirs);
-  const toolManager = new ToolManager(initialTools, toolsDirs, resolveInstallPath, getCliVersionPrefix());
-  setToolProvider((verb) => toolManager.ensureAvailable(verb));
-  if (!context.capabilities.isBrowser && toolsDir) {
-    const OPTS_WITH_VALUES = new Set(program.options.filter((o) => o.required || o.optional).flatMap((o) => [o.short, o.long].filter(Boolean)));
-    let requestedVerb;
-    const cliArgs = context.args.slice(2);
-    for (let i2 = 0;i2 < cliArgs.length; i2++) {
-      const a = cliArgs[i2];
-      if (OPTS_WITH_VALUES.has(a)) {
-        i2++;
-        continue;
-      }
-      if (a.startsWith("-"))
-        continue;
-      if (WHITELIST_BY_COMMAND.has(a))
-        requestedVerb = a;
-      break;
-    }
-    if (requestedVerb && !toolManager.isInstalled(requestedVerb)) {
-      try {
-        await toolManager.ensureAvailable(requestedVerb);
-      } catch (error48) {
-        OutputFormatter13.error({
-          Result: "Failure",
-          Message: `Failed to auto-install '${requestedVerb}': ${errorMessage(error48)}`,
-          Instructions: `Run 'uip tools install ${requestedVerb}' to install manually.`
-        });
-        context.exit(1);
-      }
-    }
-  }
-  for (const tool of toolManager.getTools()) {
-    try {
-      const toolCommand = program.command(tool.metadata.commandPrefix).description(tool.metadata.description);
-      await tool.registerCommands(toolCommand);
-    } catch (error48) {
-      context.output.writeErr(`❌ Failed to register commands from tool '${tool.metadata.name}': ${errorMessage(error48)}`);
-      context.output.writeErr(`   This might be due to a command name conflict with existing commands.`);
-      context.exit(1);
-    }
-  }
+  const resolveInstallPath = createInstallPathResolver(toolsDir, context.capabilities.isBrowser);
+  logger21.debug("Discovering tool paths...");
+  let discoveredTools = await discoverToolPaths(toolsDirs);
+  logger21.debug(`Discovered ${discoveredTools.length} tools: ${discoveredTools.map((t) => t.commandPrefix).join(", ") || "(none)"}`);
+  const toolManager = new ToolManager([], toolsDirs, resolveInstallPath, getCliVersionPrefix(), discoveredTools);
+  setPackagerFactoryProvider((verb) => toolManager.ensurePackagerFactory(verb));
+  if (toolsDir) {
+    const installed = await autoInstallToolIfNeeded(context.args, program, toolManager, context);
+    if (installed) {
+      discoveredTools = await discoverToolPaths(toolsDirs);
+    }
+  }
+  registerLazyToolCommands(program, discoveredTools, context);
   registerToolsCommand(program, context, {
     tools: toolManager.getTools(),
+    discoveredTools,
     toolsDirs,
     resolveInstallPath,
     getCliVersionPrefix
   });
   if (!context.capabilities.isBrowser) {
+    logger21.debug("Registering skills command");
     registerSkillsCommand(program);
   }
+  logger21.debug("Registering MCP command");
   registerMcpCommand(program);
   registerHelpAll(program);
   for (const cmd of program.commands) {
     registerHelpAll(cmd);
   }
+  logger21.debug("Program built successfully — ready to parse args");
   return { program, cleanedArgs };
 }
-function stripGlobalOptions(args) {
-  const cleaned = [];
-  let format;
-  let filter;
-  let logLevel;
-  let logFile;
-  for (let i2 = 0;i2 < args.length; i2++) {
-    if (args[i2] === "--output-filter" && i2 + 1 < args.length) {
-      filter = args[i2 + 1];
-      i2++;
-      continue;
-    }
-    if (args[i2]?.startsWith("--output-filter=")) {
-      filter = args[i2].substring("--output-filter=".length);
-      continue;
-    }
-    if (args[i2] === "--output" && i2 + 1 < args.length) {
-      const v = args[i2 + 1];
-      if (VALID_FORMATS.includes(v)) {
-        format = v;
-        i2++;
-        continue;
-      }
-    }
-    if (args[i2]?.startsWith("--output=")) {
-      const v = args[i2].substring("--output=".length);
-      if (VALID_FORMATS.includes(v)) {
-        format = v;
-        continue;
-      }
-    }
-    if (args[i2] === "--log-level" && i2 + 1 < args.length) {
-      const parsed = VALID_LOG_LEVELS[args[i2 + 1].toLowerCase()];
-      if (parsed !== undefined) {
-        logLevel = parsed;
-      }
-      i2++;
-      continue;
-    }
-    if (args[i2]?.startsWith("--log-level=")) {
-      const parsed = VALID_LOG_LEVELS[args[i2].substring("--log-level=".length).toLowerCase()];
-      if (parsed !== undefined) {
-        logLevel = parsed;
-      }
-      continue;
-    }
-    if (args[i2] === "--log-file" && i2 + 1 < args.length) {
-      logFile = args[i2 + 1];
-      i2++;
-      continue;
-    }
-    if (args[i2]?.startsWith("--log-file=")) {
-      logFile = args[i2].substring("--log-file=".length);
-      continue;
-    }
-    cleaned.push(args[i2]);
-  }
-  const resolvedFormat = format ?? (getOutputSink2().capabilities.isInteractive ? "table" : "json");
-  return { args: cleaned, format: resolvedFormat, filter, logLevel, logFile };
-}
 async function run(context) {
   const { program, cleanedArgs } = await buildProgram(context);
-  try {
-    await program.parseAsync(cleanedArgs);
-  } catch (error48) {
-    const e = error48;
-    if (e?.code?.startsWith("commander.")) {
-      if (e.code === "commander.helpDisplayed" || e.code === "commander.version" || e.message === "(outputHelp)") {
-        const eventName = e.code === "commander.version" ? CliTelemetryEvents.Version : CliTelemetryEvents.Help;
-        const command = cleanedArgs.slice(2).filter((a) => !a.startsWith("-")).join(" ") || "root";
-        telemetry.trackEvent(eventName, { command });
-        await telemetryFlushAndShutdown();
-        context.exit(e.exitCode ?? 0);
-        return;
-      }
-      OutputFormatter13.error({
-        Result: "ValidationError",
-        Message: e.message ?? String(error48),
-        Instructions: "Check command arguments and options. Use --help for usage information."
-      });
-      await telemetryFlushAndShutdown();
-      context.exit(e.exitCode ?? 1);
-      return;
-    }
-    await telemetryFlushAndShutdown();
-    context.exit(1);
+  logger21.debug(`Parsing args: ${cleanedArgs.slice(2).join(" ")}`);
+  const [parseError] = await catchError19(program.parseAsync(cleanedArgs));
+  if (parseError) {
+    await handleParseError(parseError, cleanedArgs, context);
     return;
   }
-  await telemetryFlushAndShutdown();
+  logger21.debug("Command completed — flushing telemetry");
+  await telemetryFlushAndShutdown2();
   context.exit(0);
 }
-var VALID_FORMATS, VALID_LOG_LEVELS;
 var init_cli = __esm(() => {
   init_package();
   init_login();
@@ -34566,19 +37004,16 @@ var init_cli = __esm(() => {
   init_mcp2();
   init_skills();
   init_tools();
+  init_installPath();
   init_storage();
   init_tool_manager();
-  init_toolService();
-  init_telemetry_events();
+  init_autoInstall();
+  init_globalOptions();
   init_helpFormatter();
+  init_parseError();
+  init_registerToolCommands();
+  init_resolveToolsDirectories();
   init_toolLoader();
-  VALID_FORMATS = ["table", "json", "yaml", "plain"];
-  VALID_LOG_LEVELS = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3
-  };
 });
 
 // src/suppress-dep-warnings.ts
@@ -34593,7 +37028,12 @@ process.emitWarning = (...args) => {
 
 // index.ts
 init_cli();
-import { configureLogger as configureLogger2 } from "@uipath/common";
+import {
+  configureLogger as configureLogger2,
+  createPollAbortController,
+  installConsoleGuard,
+  setProcessContextPollSignal
+} from "@uipath/common";
 
 // src/sinks/terminal-sink.ts
 class TerminalSink {
@@ -34613,7 +37053,7 @@ class TerminalSink {
     process.stderr.write(str2);
   }
   writeLog(str2) {
-    process.stdout.write(str2);
+    process.stderr.write(str2);
   }
   static detectColor(isTTY) {
     if (process.env.NO_COLOR)
@@ -34627,6 +37067,9 @@ class TerminalSink {
 // index.ts
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 configureLogger2({ sink: new TerminalSink });
+installConsoleGuard();
+var pollController = createPollAbortController();
+setProcessContextPollSignal(pollController.signal);
 var run2 = async (args) => {
   const context = {
     args,
@@ -34642,7 +37085,8 @@ var run2 = async (args) => {
     },
     capabilities: {
       isBrowser: false
-    }
+    },
+    pollSignal: pollController.signal
   };
   return run(context);
 };