@uipath/cli 1.203.0-preview.203 → 1.204.0-preview.206

package/dist/{index-z0m79t8p.js → index-nh7w4ccm.js}

@@ -24,7 +24,7 @@ import {
   readAuthFromEnv,
   resolveEnvFileLocationAsync,
   resolveEnvFilePathAsync
-} from "./index-vmn69waj.js";
+} from "./index-zwnedwxc.js";
 import {
   AGENT_DEFS,
   AGENT_DISPLAY_NAMES,
@@ -34,12 +34,14 @@ import {
   DISABLE_AUTOINSTALL_ENV,
   DISABLE_TOOL_LINE_CHECK_ENV,
   HIDDEN_CHANNELS,
+  HostOwnedToolError,
   InstallRefusedError,
   PUBLIC_CHANNELS,
   SECRET_FIELD_PATHS,
   SkillSourceError,
   SkillsError,
   SkillsRegistryAuthError,
+  TOOLS_DIRS_ENV_VAR,
   TOOLS_UPDATE_PHASES,
   TOOLS_WHITELIST,
   VALID_CHANNELS,
@@ -56,6 +58,7 @@ import {
   getAvailableSkills,
   getContentStoreForRead,
   getEffectiveRegistry,
+  getEnvToolsDirsDeclaration,
   getGlobalNpmUipathDir,
   getInstalledTools,
   getSkillsDestinationHint,
@@ -81,10 +84,12 @@ import {
   readManifest,
   readState,
   recordToolUpdateDate,
+  refreshGlobalNpmUipathDir,
   rejectIfGlobalOnly,
   removeFromManifest,
   removeSkillCatalog,
   resolveConfigFilePathAsync,
+  resolveNpmPrefixForToolsDir,
   resolvePinnedVersion,
   resolveRootDir,
   resolveRuntimeChannel,
@@ -108,20 +113,28 @@ import {
   versionLinePrefix,
   versionMigrationNotice,
   withConfigLock
-} from "./index-ttatj0sp.js";
+} from "./index-45h1c7ad.js";
 import {
+  AuthDimensions,
+  BaseDimensions,
+  CLI_APPLICATION_NAME,
   CONFIG_FILENAME,
   Command,
+  CommandDimensions,
+  CommonTelemetryEvents,
   DEFAULT_FETCH_TIMEOUT_MS,
   EXIT_CODES,
   LogLevel,
   OUTPUT_FORMATS,
+  Option,
   OutputFormatter,
   Pagination,
   REGISTER_EXPORT,
   RESULTS,
+  SkillsDimensions,
   TELEMETRY_ARG_VALUE_WITHHELD,
   UIPATH_HOME_DIR,
+  assertNoCuratedDimensionTargets,
   buildCommandTerminalTelemetryProperties,
   buildEnvironmentProperties,
   buildSkillEventTelemetryAttribution,
@@ -130,6 +143,7 @@ import {
   carriedInstructions,
   carriedRetry,
   catchError,
+  commandInvocationPath,
   commandTelemetryName,
   configureLogger,
   describeConnectivityError,
@@ -157,6 +171,7 @@ import {
   resolveEnvReference,
   runWithInvocationRequest,
   runWithTimings,
+  sanitizeTelemetryToken,
   setExecutionContextAuthSignal,
   setExitCode,
   setGlobalTelemetryProperties,
@@ -178,7 +193,7 @@ import {
   telemetryInit,
   telemetryShutdownWithoutFlush,
   validateOutputFilter
-} from "./index-7pvwjzsq.js";
+} from "./index-kyn5nn3d.js";
 import {
   isBrowser
 } from "./index-0gctz400.js";
@@ -1005,7 +1020,6 @@ var FLAG_HINTS = {
   v: "--version"
 };
 function commandPartsFromArgs(cleanedArgs) {
-  const commandParts = [];
   const userArgs = cleanedArgs.slice(2);
   for (let i = 0;i < userArgs.length; i++) {
     const arg = userArgs[i];
@@ -1018,17 +1032,18 @@ function commandPartsFromArgs(cleanedArgs) {
       }
       continue;
     }
-    commandParts.push(arg);
+    return [arg];
   }
-  return commandParts;
+  return [];
 }
 function commandEventNameFromArgs(cleanedArgs) {
   return commandTelemetryName(commandPartsFromArgs(cleanedArgs));
 }
-function helpInstructions(cleanedArgs) {
-  const commandParts = commandPartsFromArgs(cleanedArgs);
-  const command = ["uip", ...commandParts].join(" ");
-  return `Run '${command} --help' for usage information.`;
+function commandInvocationPathFromArgs(cleanedArgs) {
+  return commandInvocationPath(commandPartsFromArgs(cleanedArgs));
+}
+function helpInstructions(commandPath) {
+  return `Run '${commandPath} --help' for usage information.`;
 }
 function instructionsForUnknownCommand(cleanedArgs) {
   const firstUserToken = cleanedArgs.slice(2).find((a) => !a.startsWith("-"));
@@ -1044,10 +1059,11 @@ function isDisplayOnly(code, message) {
 function currentExitCode(fallback = 1) {
   return getExitCode() || fallback;
 }
-function trackCommandFailure(error, eventName, exitCode, context) {
+function trackCommandFailure(error, eventName, commandPath, exitCode, context) {
   const recordedFailure = takeRecordedCommandFailureTelemetry();
   emitInvocationRequest(eventName, false, {
-    command: "true",
+    [CommandDimensions.IsCommand]: "true",
+    [CommandDimensions.CommandName]: commandPath,
     ...buildCommandTerminalTelemetryProperties({
       error,
       exitCode,
@@ -1068,7 +1084,7 @@ async function handleParseError(error, cleanedArgs, context, telemetryOptions) {
       context.exit(exitCode ?? 0);
       return;
     }
-    const instructions = code === "commander.unknownCommand" ? instructionsForUnknownCommand(cleanedArgs) : helpInstructions(cleanedArgs);
+    const instructions = code === "commander.unknownCommand" ? instructionsForUnknownCommand(cleanedArgs) : helpInstructions(telemetryOptions.commandPath);
     OutputFormatter.error({
       Result: RESULTS.ValidationError,
       ErrorCode: "invalid_argument",
@@ -1077,12 +1093,12 @@ async function handleParseError(error, cleanedArgs, context, telemetryOptions) {
       Retry: "RetryWillNotFix"
     });
     const finalExitCode = currentExitCode();
-    trackCommandFailure(error, telemetryOptions.eventName, finalExitCode, context);
+    trackCommandFailure(error, telemetryOptions.eventName, telemetryOptions.commandPath, finalExitCode, context);
     await telemetryFlushAndShutdown();
     context.exit(finalExitCode);
     return;
   }
-  trackCommandFailure(error, telemetryOptions.eventName, currentExitCode(), context);
+  trackCommandFailure(error, telemetryOptions.eventName, telemetryOptions.commandPath, currentExitCode(), context);
   await telemetryFlushAndShutdown();
   context.exit(currentExitCode());
 }
@@ -1110,13 +1126,17 @@ function findUnknownHelpCommand(root, positionals, allArgs) {
 // cli.core.ts
 var HELP_FLAGS2 = new Set(["-h", "--help"]);
 var HELP_COMMAND_TOKEN = "help";
+var NO_APPLICATION_START = new Set([
+  "uip track",
+  `uip ${HELP_COMMAND_TOKEN}`
+]);
 function findSubcommand(command, token) {
   return command.commands.find((subcommand) => subcommand.name() === token || subcommand.aliases().includes(token));
 }
 function optionValueTokens(userArgs, index) {
   return !userArgs[index].includes("=") && index + 1 < userArgs.length && !userArgs[index + 1].startsWith("-") ? 1 : 0;
 }
-function commandEventNameFromProgram(program, cleanedArgs) {
+function commandPartsFromProgram(program, cleanedArgs) {
   const parts = [];
   let current = program;
   const userArgs = cleanedArgs.slice(2);
@@ -1143,15 +1163,16 @@ function commandEventNameFromProgram(program, cleanedArgs) {
     }
     break;
   }
-  return commandTelemetryName(parts);
+  return parts;
 }
-function trackRecordedCommandFailure(eventName, exitCode, context, error) {
+function trackRecordedCommandFailure(commandParts, exitCode, context, error) {
   const recordedFailure = takeRecordedCommandFailureTelemetry();
   if (!recordedFailure) {
     return;
   }
-  emitInvocationRequest(eventName, false, {
-    command: "true",
+  emitInvocationRequest(commandTelemetryName(commandParts), false, {
+    [CommandDimensions.IsCommand]: "true",
+    [CommandDimensions.CommandName]: commandInvocationPath(commandParts),
     ...buildCommandTerminalTelemetryProperties({
       error,
       exitCode,
@@ -1161,8 +1182,10 @@ function trackRecordedCommandFailure(eventName, exitCode, context, error) {
   });
 }
 function emitEarlyExitRequest(context, options) {
-  emitInvocationRequest(commandEventNameFromArgs(context.args), options.success, {
-    ...options.delegated ? { reexec: "true" } : { command: "true" },
+  const parts = options.program ? commandPartsFromProgram(options.program, context.args) : undefined;
+  emitInvocationRequest(parts ? commandTelemetryName(parts) : commandEventNameFromArgs(context.args), options.success, {
+    ...options.delegated ? { [CommandDimensions.IsReexec]: "true" } : { [CommandDimensions.IsCommand]: "true" },
+    [CommandDimensions.CommandName]: parts ? commandInvocationPath(parts) : commandInvocationPathFromArgs(context.args),
     ...buildCommandTerminalTelemetryProperties({
       exitCode: getExitCode() || (options.success ? 0 : 1),
       recordedFailure: takeRecordedCommandFailureTelemetry(),
@@ -1170,6 +1193,12 @@ function emitEarlyExitRequest(context, options) {
     })
   });
 }
+function emitApplicationStart(context) {
+  if (isHelpOrVersionInvocation(context.args) || NO_APPLICATION_START.has(commandInvocationPathFromArgs(context.args))) {
+    return;
+  }
+  telemetry.trackEvent(CommonTelemetryEvents.Start, {});
+}
 function runCliInvocation(fn) {
   return runWithTimings(TIMING_FALLBACK_COMMAND, () => runWithInvocationRequest(fn));
 }
@@ -1293,13 +1322,14 @@ async function initProgram(context, hooks = {}) {
   })();
   const agent = detectAgent();
   const defaultTelemetryProperties = {
-    cli_version: package_default.version
+    [BaseDimensions.ApplicationName]: CLI_APPLICATION_NAME,
+    [BaseDimensions.ProductVersion]: package_default.version
   };
   if (agent !== undefined) {
-    defaultTelemetryProperties.agent = agent;
+    defaultTelemetryProperties[BaseDimensions.Agent] = agent;
     const agentVersion = detectAgentVersion();
     if (agentVersion !== undefined) {
-      defaultTelemetryProperties.agent_version = agentVersion;
+      defaultTelemetryProperties[BaseDimensions.AgentVersion] = agentVersion;
     }
   }
   const telemetryPromise = isHelpOrVersionInvocation(cleanedArgs) ? Promise.resolve() : telemetryInit({
@@ -1326,10 +1356,10 @@ function finalizeProgram(args) {
 async function parseAndExit(program, cleanedArgs, context) {
   logger.debug(`Parsing args: ${cleanedArgs.slice(2).join(" ")}`);
   const nameTimingCommand = () => {
-    setTimingCommand(commandEventNameFromProgram(program, cleanedArgs).replace(/\./g, " "));
+    setTimingCommand(commandInvocationPath(commandPartsFromProgram(program, cleanedArgs)));
   };
   nameTimingCommand();
-  const initialCommandEventName = commandEventNameFromProgram(program, cleanedArgs);
+  const initialCommandParts = commandPartsFromProgram(program, cleanedArgs);
   const userArgs = cleanedArgs.slice(2);
   const firstToken = userArgs.find((a) => !a.startsWith("-"));
   const unknownRoot = firstToken && findUnknownHelpCommand(program, [firstToken], userArgs);
@@ -1341,7 +1371,7 @@ async function parseAndExit(program, cleanedArgs, context) {
       Instructions: "Check command arguments and options. Run 'uip --help' for available commands."
     });
     const exitCode = getExitCode() || 1;
-    trackRecordedCommandFailure(initialCommandEventName, exitCode, context, {
+    trackRecordedCommandFailure(initialCommandParts, exitCode, context, {
       code: "commander.unknownCommand",
       message
     });
@@ -1352,13 +1382,15 @@ async function parseAndExit(program, cleanedArgs, context) {
   const [parseError] = await catchError(program.parseAsync(cleanedArgs));
   nameTimingCommand();
   if (parseError) {
+    const commandParts = commandPartsFromProgram(program, cleanedArgs);
     await handleParseError(parseError, cleanedArgs, context, {
-      eventName: commandEventNameFromProgram(program, cleanedArgs)
+      eventName: commandTelemetryName(commandParts),
+      commandPath: commandInvocationPath(commandParts)
     });
   } else {
     const exitCode = getExitCode();
     if (exitCode !== 0) {
-      trackRecordedCommandFailure(commandEventNameFromProgram(program, cleanedArgs), exitCode, context);
+      trackRecordedCommandFailure(commandPartsFromProgram(program, cleanedArgs), exitCode, context);
     }
   }
   if (getExitCode() === 0) {
@@ -1649,6 +1681,11 @@ async function resolveToolsDirs(cliFilePath, cwd) {
   const seen = new Set;
   const dirs = [];
   const cliDir = dirname(cliFilePath);
+  const declaration = await getEnvToolsDirsDeclaration();
+  if (declaration) {
+    logger.debug(`Using only the host-declared tool directories: [${declaration.dirs.join(", ")}]`);
+    return [...declaration.dirs];
+  }
   const localCliToolsDir = await findNearestLocalCliToolsDir(cwd);
   if (localCliToolsDir) {
     seen.add(localCliToolsDir);
@@ -2936,26 +2973,26 @@ var promptSelect = async (options, message) => {
 // src/services/auth.ts
 class NodeAuth {
   async interactiveLogin(options) {
-    const { interactiveLogin } = await import("./index-hgvsratt.js");
+    const { interactiveLogin } = await import("./index-mttdq2yn.js");
     return await interactiveLogin({
       ...options,
       selectFromList: promptSelect
     });
   }
   async clientCredentialsLogin(options) {
-    const { clientCredentialsLogin } = await import("./index-hgvsratt.js");
+    const { clientCredentialsLogin } = await import("./index-mttdq2yn.js");
     return await clientCredentialsLogin(options);
   }
   async getLoginStatus(options) {
-    const { getLoginStatusAsync: getLoginStatusAsync2 } = await import("./index-hgvsratt.js");
+    const { getLoginStatusAsync: getLoginStatusAsync2 } = await import("./index-mttdq2yn.js");
     return getLoginStatusAsync2(options);
   }
   async fetchTenants(baseUrl, accessToken, organizationId) {
-    const { fetchTenantsAndOrganizations } = await import("./index-hgvsratt.js");
+    const { fetchTenantsAndOrganizations } = await import("./index-mttdq2yn.js");
     return fetchTenantsAndOrganizations(baseUrl, accessToken, organizationId);
   }
   async saveTenantSelection(envFilePath, tenantName, tenantId) {
-    const { saveEnvFileAsync } = await import("./index-hgvsratt.js");
+    const { saveEnvFileAsync } = await import("./index-mttdq2yn.js");
     await saveEnvFileAsync({
       envPath: envFilePath,
       data: {
@@ -2969,23 +3006,23 @@ class NodeAuth {
 
 class BrowserAuth {
   async interactiveLogin(options) {
-    const { interactiveLogin } = await import("./index-hgvsratt.js");
+    const { interactiveLogin } = await import("./index-mttdq2yn.js");
     return await interactiveLogin(options);
   }
   async clientCredentialsLogin(options) {
-    const { clientCredentialsLogin } = await import("./index-hgvsratt.js");
+    const { clientCredentialsLogin } = await import("./index-mttdq2yn.js");
     return await clientCredentialsLogin(options);
   }
   async getLoginStatus(options) {
-    const { getLoginStatusAsync: getLoginStatusAsync2 } = await import("./index-hgvsratt.js");
+    const { getLoginStatusAsync: getLoginStatusAsync2 } = await import("./index-mttdq2yn.js");
     return getLoginStatusAsync2(options);
   }
   async fetchTenants(baseUrl, accessToken, organizationId) {
-    const { fetchTenantsAndOrganizations } = await import("./index-hgvsratt.js");
+    const { fetchTenantsAndOrganizations } = await import("./index-mttdq2yn.js");
     return fetchTenantsAndOrganizations(baseUrl, accessToken, organizationId);
   }
   async saveTenantSelection(envFilePath, tenantName, tenantId) {
-    const { saveEnvFileAsync } = await import("./index-hgvsratt.js");
+    const { saveEnvFileAsync } = await import("./index-mttdq2yn.js");
     await saveEnvFileAsync({
       envPath: envFilePath,
       data: {
@@ -3000,10 +3037,10 @@ var auth = isBrowser() ? new BrowserAuth : new NodeAuth;
 
 // src/services/authTelemetry.ts
 var AuthTelemetryEvents = {
-  Login: "uip.auth.login",
-  TenantSelected: "uip.auth.tenant-selected",
-  TokenRefresh: "uip.auth.token-refresh",
-  Logout: "uip.auth.logout"
+  Login: "Authenticate.LogIn",
+  TenantSelected: "Authenticate.TenantSelected",
+  TokenRefresh: "Authenticate.TokenRefresh",
+  Logout: "Authenticate.LogOut"
 };
 var UIPATH_EMAIL_DOMAIN = "uipath.com";
 var decodeTokenClaims = (accessToken) => {
@@ -3079,11 +3116,11 @@ var populateTelemetryAuthContext = async (deps = {}) => {
   const isInternalUser = getInternalUserFlag(claims);
   const envProps = identity.baseUrl ? buildEnvironmentProperties(identity.baseUrl) : {};
   const defaultProps = {
-    ...userId ? { CloudUserId: userId } : {},
-    ...identity.tenantId ? { CloudTenantId: identity.tenantId } : {},
-    ...identity.organizationId ? { CloudOrganizationId: identity.organizationId } : {},
+    ...userId ? { [BaseDimensions.CloudUserId]: userId } : {},
+    ...identity.tenantId ? { [BaseDimensions.CloudTenantId]: identity.tenantId } : {},
+    ...identity.organizationId ? { [BaseDimensions.CloudOrganizationId]: identity.organizationId } : {},
     ...envProps,
-    ...isInternalUser !== undefined ? { IsInternalUser: isInternalUser } : {}
+    ...isInternalUser !== undefined ? { [BaseDimensions.IsInternalUser]: isInternalUser } : {}
   };
   if (Object.keys(defaultProps).length === 0)
     return;
@@ -3093,29 +3130,31 @@ var populateTelemetryAuthContext = async (deps = {}) => {
 };
 var trackAuthLogin = (flow, result) => {
   telemetry.trackEvent(AuthTelemetryEvents.Login, {
-    flow,
-    success: String(result.success),
-    ...!result.success ? { errorMessage: result.errorMessage } : {}
+    [AuthDimensions.AuthenticationMethod]: flow,
+    [AuthDimensions.Success]: String(result.success),
+    ...!result.success ? { [CommandDimensions.ErrorMessage]: result.errorMessage } : {}
   });
 };
 var trackTenantSelection = (result) => {
   telemetry.trackEvent(AuthTelemetryEvents.TenantSelected, {
-    success: String(result.success),
-    ...!result.success && result.errorMessage ? { errorMessage: result.errorMessage } : {}
+    [AuthDimensions.Success]: String(result.success),
+    ...!result.success && result.errorMessage ? { [CommandDimensions.ErrorMessage]: result.errorMessage } : {}
   });
 };
 var trackTokenRefresh = (status) => {
   if (!status.tokenRefresh?.attempted)
     return;
   telemetry.trackEvent(AuthTelemetryEvents.TokenRefresh, {
-    success: String(status.tokenRefresh.success),
-    ...status.tokenRefresh.errorMessage ? { errorMessage: status.tokenRefresh.errorMessage } : {}
+    [AuthDimensions.Success]: String(status.tokenRefresh.success),
+    ...status.tokenRefresh.errorMessage ? {
+      [CommandDimensions.ErrorMessage]: status.tokenRefresh.errorMessage
+    } : {}
   });
 };
 var trackAuthLogout = (result) => {
   telemetry.trackEvent(AuthTelemetryEvents.Logout, {
-    success: String(result.success),
-    ...!result.success && result.reason ? { reason: result.reason } : {}
+    [AuthDimensions.Success]: String(result.success),
+    ...!result.success && result.reason ? { [AuthDimensions.Reason]: result.reason } : {}
   });
 };
 
@@ -3543,6 +3582,9 @@ function buildIdentityDetail(identity) {
     ...identity.clientId ? { ClientId: identity.clientId } : {}
   };
 }
+function buildScopeDetail(scopes, detailed) {
+  return detailed && scopes ? { Scopes: scopes } : {};
+}
 function buildRefreshData(status) {
   const data = {
     Status: status.loginStatus,
@@ -3728,6 +3770,21 @@ var LOGIN_STATUS_EXAMPLES = [
         "Expiration Date": "2026-04-18T10:30:00Z"
       }
     }
+  },
+  {
+    Description: "Check which scopes the current token carries — the usual reason a command returns 401 or 403 while the session looks fine",
+    Command: "uip login status --detailed --output json",
+    Output: {
+      Code: "LoginStatus",
+      Data: {
+        Status: "Logged in",
+        Identity: "External application 4af76c75-c800-4ff5-b559-32610fa9ef1e",
+        IdentityType: "Application",
+        AuthFlow: "ClientCredentials",
+        ClientId: "4af76c75-c800-4ff5-b559-32610fa9ef1e",
+        Scopes: ["TM.Projects", "TM.TestCases", "TM.TestSets"]
+      }
+    }
   }
 ];
 var LOGIN_REFRESH_EXAMPLES = [
@@ -4034,12 +4091,12 @@ Open this URL in a browser to sign in:
       Data: buildLoginData(authResult ?? {})
     });
   }, (options) => ({
-    hasClientCredentials: !!(options.clientId && options.clientSecret),
-    hasTenant: !!options.tenant,
-    hasOrganization: !!options.organization,
-    interactive: canPrompt()
+    HasClientCredentials: !!(options.clientId && options.clientSecret),
+    HasTenant: !!options.tenant,
+    HasOrganization: !!options.organization,
+    Interactive: canPrompt()
   }));
-  loginCommand.command("status").description("Show current login status and session information").examples(LOGIN_STATUS_EXAMPLES).trackedAction(context, async () => {
+  loginCommand.command("status").description("Show current login status and session information").addOption(new Option("--detailed", "Also show the scopes the access token carries").hideHelp()).examples(LOGIN_STATUS_EXAMPLES).trackedAction(context, async (options) => {
     const [statusError, status] = await catchError(auth.getLoginStatus());
     if (statusError) {
       OutputFormatter.error({
@@ -4058,6 +4115,7 @@ Open this URL in a browser to sign in:
       CredentialSource: credentialSourceLabel(status.source),
       Provider: legacyProviderLabel(status.source),
       ...buildIdentityDetail(status.identity),
+      ...buildScopeDetail(status.scopes, options.detailed === true),
       ...activeProfile && status.source === "saved-login" /* SavedLogin */ ? { Profile: activeProfile } : {},
       BaseUrl: status.baseUrl,
       Organization: status.organizationName || status.organizationId || "N/A"
@@ -4109,7 +4167,7 @@ Open this URL in a browser to sign in:
       Data: buildRefreshData(status)
     });
   }, (options) => ({
-    loginValidityMinutes: options.loginValidity
+    LoginValidityMinutes: options.loginValidity
   }));
   registerProfilesCommand(loginCommand, context);
   const tenantCommand = loginCommand.command("tenant").description("Manage tenants");
@@ -4263,7 +4321,7 @@ Open this URL in a browser to sign in:
         Id: matchedTenant.id
       }
     });
-  }, (name) => ({ tenantName: name }));
+  }, (name) => ({ TenantName: name }));
   loginCommand.command("which").description("Print the auth source uip would use for the current cwd.").examples(LOGIN_WHICH_EXAMPLES).trackedAction(context, async () => {
     if (isEnvAuthEnabled()) {
       emitAuthEnv();
@@ -4390,7 +4448,7 @@ function registerLogoutCommand(program, context) {
 function registerMcpCommand(program) {
   const mcpCommand = program.command("mcp").description("Model Context Protocol (MCP) server");
   mcpCommand.command("serve").description("Start the MCP server (stdio transport)").trackedAction(processContext, async () => {
-    const { startMcpServer } = await import("./server-82exah8x.js");
+    const { startMcpServer } = await import("./server-x6j9cv7f.js");
     await startMcpServer(program);
   });
 }
@@ -5074,10 +5132,10 @@ function registerFeedbackCommand(program, context) {
       }
     });
   }, (options) => ({
-    feedbackType: options.type,
-    priority: options.priority,
-    hasEmail: !!options.email,
-    attachmentCount: options.attachment?.length ?? 0
+    FeedbackType: options.type,
+    Priority: options.priority,
+    HasEmail: !!options.email,
+    AttachmentCount: options.attachment?.length ?? 0
   }));
 }
 
@@ -5787,7 +5845,8 @@ function registerInstallCommand2(toolsCommand, _context, state) {
         packageSpec = `${packageName}@${candidate.version}`;
       }
       await toolService.install(packageSpec, location.path, {
-        global: location.global
+        global: location.global,
+        prefix: location.prefix
       });
       logger.info(`Installed to ${location.path}`);
       OutputFormatter.success({
@@ -5966,7 +6025,8 @@ function registerUninstallCommand2(toolsCommand, _context, state) {
 }
 async function runUninstall(packageName, location) {
   const [error] = await catchError(toolService.uninstall(packageName, location.path, {
-    global: location.global
+    global: location.global,
+    prefix: location.prefix
   }));
   return error;
 }
@@ -6030,7 +6090,7 @@ async function uninstallAll(state) {
   const results = [];
   for (const tool of installed) {
     const error = await runUninstall(`@uipath/${tool.name}`, location);
-    results.push(error ? { name: tool.name, status: "failed", error: error.message } : { name: tool.name, status: "uninstalled" });
+    results.push(!error ? { name: tool.name, status: "uninstalled" } : error instanceof HostOwnedToolError ? { name: tool.name, status: "skipped", error: error.message } : { name: tool.name, status: "failed", error: error.message });
   }
   OutputFormatter.success({
     Result: RESULTS.Success,
@@ -6157,37 +6217,239 @@ function registerToolsCommand(program, context, state) {
   registerUninstallCommand2(toolsCommand, context, state);
 }
 
+// src/commands/track-hook.ts
+var SCHEMA_VERSION = 4;
+var GENERIC_AGENT_TYPES = new Set([
+  "general-purpose",
+  "Explore",
+  "Plan",
+  "claude",
+  "claude-code-guide",
+  "statusline-setup",
+  "fork",
+  "default"
+]);
+var FILE_TOOLS = new Set([
+  "Edit",
+  "Write",
+  "Read",
+  "Glob",
+  "Grep",
+  "ReadFile",
+  "WriteFile",
+  "EditFile",
+  "LsDirectory"
+]);
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+function isTrue(value) {
+  return value === true || value === "true";
+}
+function isFalse(value) {
+  return value === false || value === "false";
+}
+function extractFields(payload) {
+  const input = isPlainObject2(payload.tool_input) ? payload.tool_input : {};
+  const response = isPlainObject2(payload.tool_response) ? payload.tool_response : {};
+  const effort = isPlainObject2(payload.effort) ? payload.effort : {};
+  let agentModel = str(payload.model);
+  if (!agentModel && isPlainObject2(payload.model)) {
+    agentModel = str(payload.model.id) || str(payload.model.display_name);
+  }
+  const rawDuration = payload.duration_ms;
+  const parsedDuration = typeof rawDuration === "string" && /^[0-9]+$/.test(rawDuration) ? Number(rawDuration) : rawDuration;
+  const durationMs = Number.isSafeInteger(parsedDuration) && parsedDuration >= 0 ? parsedDuration : null;
+  return {
+    event: str(payload.hook_event_name),
+    tool: str(payload.tool_name),
+    permissionMode: str(payload.permission_mode),
+    durationMs,
+    agentType: str(payload.agent_type),
+    sessionSource: str(payload.source),
+    reason: str(payload.reason),
+    agentModel,
+    skill: str(input.skill),
+    filePath: str(input.file_path),
+    subagentType: str(input.subagent_type) || str(input.agent_type),
+    interrupted: response.interrupted,
+    success: response.success,
+    resolvedModel: str(response.resolvedModel),
+    effortLevel: str(effort.level),
+    responseSeen: "tool_response" in payload
+  };
+}
+function isUipathCall(fields) {
+  if (fields.tool === "Skill") {
+    return fields.skill.startsWith("uipath:") || fields.skill.startsWith("uipath-");
+  }
+  if (fields.tool === "Agent" || fields.tool === "spawn_agent") {
+    const type = fields.subagentType;
+    if (type.startsWith("uipath:") || type.startsWith("uipath-")) {
+      return true;
+    }
+    return GENERIC_AGENT_TYPES.has(type);
+  }
+  if (FILE_TOOLS.has(fields.tool)) {
+    return /\.(cs|flow|xaml|uipx|bpmn)$/i.test(fields.filePath) || /(^|[/\\])(agent|caseplan|project|app\.config|action-schema)\.json$/i.test(fields.filePath);
+  }
+  return false;
+}
+function deriveFields(fields) {
+  const derived = { skillName: "", fileExtension: "" };
+  if (fields.tool === "Skill") {
+    derived.skillName = fields.skill;
+  } else if (FILE_TOOLS.has(fields.tool)) {
+    const match = fields.filePath.match(/\.[A-Za-z0-9]+$/);
+    derived.fileExtension = match ? match[0] : "";
+    if (fields.filePath.endsWith("agent.json")) {
+      derived.fileExtension = "agent.json";
+    }
+    if (fields.filePath.endsWith("caseplan.json")) {
+      derived.fileExtension = "caseplan.json";
+    }
+  }
+  return derived;
+}
+function computeOutcome(fields) {
+  if (isTrue(fields.interrupted)) {
+    return "interrupted";
+  }
+  if (isFalse(fields.success)) {
+    return "failure";
+  }
+  return fields.responseSeen ? "ok" : "unknown";
+}
+function mapEventName(event) {
+  switch (event) {
+    case "PostToolUse":
+      return "tool-use";
+    case "SessionStart":
+      return "session-start";
+    case "SessionEnd":
+      return "session-end";
+    case "Stop":
+    case "StopFailure":
+      return "completion";
+    default:
+      return "";
+  }
+}
+function lifecycleOutcome(event) {
+  if (event === "Stop") {
+    return "ok";
+  }
+  if (event === "StopFailure") {
+    return "failure";
+  }
+  return "";
+}
+function modelFamily(resolvedModel) {
+  if (!resolvedModel) {
+    return "";
+  }
+  for (const family of ["opus", "sonnet", "haiku", "fable"]) {
+    if (resolvedModel.includes(family)) {
+      return family;
+    }
+  }
+  return "other";
+}
+async function readPluginSkillsVersion() {
+  const fs = getFileSystem();
+  const root = fs.env.getenv("CLAUDE_PLUGIN_ROOT");
+  if (!root) {
+    return "";
+  }
+  try {
+    const manifest = await fs.readFile(fs.path.join(root, "version-manifest.json"), "utf-8");
+    const version = manifest ? JSON.parse(manifest).skillsVersion : undefined;
+    return typeof version === "string" ? version : "";
+  } catch {
+    return "";
+  }
+}
+function deriveSkillsEventFromHookPayload(raw, skillsVersion) {
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isPlainObject2(payload)) {
+    return null;
+  }
+  const fields = extractFields(payload);
+  const eventName = mapEventName(fields.event);
+  if (!eventName) {
+    return null;
+  }
+  let derived = { skillName: "", fileExtension: "" };
+  let outcome;
+  let subagentModel = "";
+  if (eventName === "tool-use") {
+    if (!isUipathCall(fields)) {
+      return null;
+    }
+    derived = deriveFields(fields);
+    outcome = computeOutcome(fields);
+    subagentModel = modelFamily(fields.resolvedModel);
+  } else {
+    outcome = lifecycleOutcome(fields.event);
+  }
+  const sessionSource = eventName === "session-start" ? fields.sessionSource : "";
+  const reason = eventName === "session-end" ? fields.reason : "";
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    eventName: sanitizeTelemetryToken(eventName),
+    skillName: sanitizeTelemetryToken(derived.skillName),
+    fileExtension: sanitizeTelemetryToken(derived.fileExtension),
+    outcome: sanitizeTelemetryToken(outcome),
+    permissionMode: sanitizeTelemetryToken(fields.permissionMode),
+    effortLevel: sanitizeTelemetryToken(fields.effortLevel),
+    skillsVersion: sanitizeTelemetryToken(skillsVersion),
+    subagentModel: sanitizeTelemetryToken(subagentModel),
+    subagentType: sanitizeTelemetryToken(fields.subagentType),
+    agentType: sanitizeTelemetryToken(fields.agentType),
+    agent_model: sanitizeTelemetryToken(fields.agentModel),
+    session_source: sanitizeTelemetryToken(sessionSource),
+    reason: sanitizeTelemetryToken(reason),
+    durationMs: fields.durationMs
+  };
+}
+
 // src/commands/track.ts
 var SKILLS_EVENTS = {
-  "tool-use": "uip.skills.tool-use",
-  "session-start": "uip.skills.session-start",
-  "session-end": "uip.skills.session-end",
-  completion: "uip.skills.completion"
+  "tool-use": "Cli.SkillsToolUse",
+  "session-start": "Cli.SkillsSessionStart",
+  "session-end": "Cli.SkillsSessionEnd",
+  completion: "Cli.SkillsCompletion"
 };
 var DEFAULT_EVENT_TOKEN = "tool-use";
-var SOURCE_DIMENSION_KEY = "source";
+var SOURCE_DIMENSION_KEY = SkillsDimensions.Source;
 var SOURCE_DIMENSION_VALUE = "skills-plugin";
 var STDIN_TIMEOUT_MS = 1e4;
-var ALLOWED_FIELDS = new Set([
-  "schemaVersion",
-  "toolName",
-  "skillName",
-  "skill_name",
-  "uipSubcommand",
-  "fileExtension",
-  "outcome",
-  "permissionMode",
-  "effortLevel",
-  "skillsVersion",
-  "toolUseId",
-  "subagentModel",
-  "subagentType",
-  "agentType",
-  "durationMs",
-  "session_source",
-  "reason",
-  "agent_model"
-]);
+var ALLOWED_FIELDS = {
+  schemaVersion: SkillsDimensions.SchemaVersion,
+  uipSubcommand: SkillsDimensions.UipSubcommand,
+  fileExtension: SkillsDimensions.FileExtension,
+  outcome: SkillsDimensions.Outcome,
+  permissionMode: SkillsDimensions.PermissionMode,
+  effortLevel: SkillsDimensions.EffortLevel,
+  skillsVersion: SkillsDimensions.SkillsVersion,
+  subagentModel: SkillsDimensions.SubagentModel,
+  subagentType: SkillsDimensions.SubagentType,
+  agentType: SkillsDimensions.AgentType,
+  durationMs: SkillsDimensions.DurationMs,
+  session_source: SkillsDimensions.SessionSource,
+  reason: AuthDimensions.Reason,
+  agent_model: BaseDimensions.AgentModel
+};
+var SKILL_NAME_INPUT_KEYS = ["skill_name", "skillName"];
+assertNoCuratedDimensionTargets(ALLOWED_FIELDS, "[track] ALLOWED_FIELDS");
 function isParsableJson(raw) {
   try {
     JSON.parse(raw);
@@ -6223,18 +6485,23 @@ function buildEventProperties(raw) {
   }
   const properties = {};
   for (const [key, value] of Object.entries(payload)) {
-    if (!ALLOWED_FIELDS.has(key)) {
+    const dimension = ALLOWED_FIELDS[key];
+    if (!dimension) {
       continue;
     }
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      properties[key] = String(value);
+      properties[dimension] = String(value);
     }
   }
-  let attribution = buildSkillEventTelemetryAttribution(properties.skill_name ?? properties.skillName, properties.uipSubcommand);
-  if (!attribution.skill_name && properties.skillName !== undefined) {
-    attribution = buildSkillEventTelemetryAttribution(properties.skillName, properties.uipSubcommand);
+  const skillNameInputs = SKILL_NAME_INPUT_KEYS.map((key) => {
+    const value = payload[key];
+    return typeof value === "string" ? value : undefined;
+  });
+  const subcommand = properties[SkillsDimensions.UipSubcommand];
+  let attribution = buildSkillEventTelemetryAttribution(skillNameInputs[0] ?? skillNameInputs[1], subcommand);
+  if (!attribution.SkillName && skillNameInputs[1] !== undefined) {
+    attribution = buildSkillEventTelemetryAttribution(skillNameInputs[1], subcommand);
   }
-  delete properties.skill_name;
   Object.assign(properties, attribution);
   if (Object.keys(properties).length === 0) {
     return null;
@@ -6242,9 +6509,9 @@ function buildEventProperties(raw) {
   return properties;
 }
 function registerTrackCommand(program) {
-  program.command("track", { hidden: true }).description("Ingest a skills-plugin telemetry event from stdin").action(async () => {
+  program.command("track", { hidden: true }).description("Ingest a skills-plugin telemetry event from stdin").option("--hook", "stdin carries a raw agent hook payload instead of a flat event").action(async (options) => {
     try {
-      const raw = await readStdinWithTimeout(STDIN_TIMEOUT_MS);
+      let raw = await readStdinWithTimeout(STDIN_TIMEOUT_MS);
       if (isTelemetryDisabled()) {
         logger.debug("[track] telemetry disabled; dropping event.");
         return;
@@ -6253,6 +6520,14 @@ function registerTrackCommand(program) {
         logger.debug("[track] no payload on stdin.");
         return;
       }
+      if (options.hook) {
+        const derived = deriveSkillsEventFromHookPayload(raw, await readPluginSkillsVersion());
+        if (!derived) {
+          logger.debug("[track] hook payload dropped (malformed, unrecognized event, or not attributable).");
+          return;
+        }
+        raw = JSON.stringify(derived);
+      }
       const eventName = resolveSkillsEventName(raw);
       if (!eventName) {
         logger.debug(isParsableJson(raw) ? "[track] unknown or invalid eventName; dropping event." : "[track] malformed JSON payload; dropping event.");
@@ -6459,7 +6734,11 @@ function registerUpdateCommand3(program, _context, state) {
     };
     const [err, report] = await catchError((async () => {
       const isDev = await isDevMode();
-      const location = await state.resolveInstallPath();
+      const [locationError, location] = await catchError(state.resolveInstallPath());
+      if (locationError && !(locationError instanceof InstallRefusedError)) {
+        throw locationError;
+      }
+      const hostOwnsCli = await getEnvToolsDirsDeclaration() !== null;
       return runUpdate({
         dryRun: raw.dryRun ?? false,
         channel,
@@ -6472,14 +6751,14 @@ function registerUpdateCommand3(program, _context, state) {
           agent: raw.agent,
           local: raw.local
         },
-        cli: { self: raw.self !== false },
+        cli: { self: raw.self !== false && !hostOwnsCli },
         versionPin: target.pin,
         versionPinOrigin: target.origin
       }, state, {
         cliPkgVersion: package_default.version,
-        isLocal: !location.global,
+        isLocal: location ? !location.global : false,
         isDev,
-        installPath: location.path
+        installPath: location?.path ?? ""
       });
     })());
     if (err) {
@@ -6611,6 +6890,20 @@ function createInstallPathResolver(toolsDir, isBrowser2) {
     const { getFileSystem: getFileSystem2 } = await import("./index-hhsf00x8.js");
     const fsLocal = getFileSystem2();
     const { dirname: dirnameFn, join: joinFn } = fsLocal.path;
+    const declaration = await getEnvToolsDirsDeclaration();
+    if (declaration) {
+      const target = declaration.installTarget;
+      const prefix = target ? resolveNpmPrefixForToolsDir(target) : null;
+      if (prefix) {
+        const [mkdirError] = await catchError(fsLocal.mkdir(prefix));
+        if (mkdirError) {
+          throw new InstallRefusedError(`Cannot create the ${TOOLS_DIRS_ENV_VAR} install prefix ${prefix}: ${String(mkdirError)}`, `Make the first ${TOOLS_DIRS_ENV_VAR} entry's npm prefix writable.`);
+        }
+        logger.debug(`Install path resolved from ${TOOLS_DIRS_ENV_VAR}: ${prefix} (global: true)`);
+        return { path: prefix, global: true, prefix };
+      }
+      throw new InstallRefusedError(`${TOOLS_DIRS_ENV_VAR} names no usable install target${target ? ` (${target} is not an npm global layout for this platform)` : ""}; refusing to install outside the host's tool directories.`, `Declare a writable npm global '@uipath' directory as the first ${TOOLS_DIRS_ENV_VAR} entry.`);
+    }
     if (toolsDir) {
       let path = dirnameFn(dirnameFn(toolsDir));
       while (isInsideNodeModules(path)) {
@@ -6641,7 +6934,7 @@ function createInstallPathResolver(toolsDir, isBrowser2) {
 }
 
 // src/services/installTelemetry.ts
-var INSTALL_ID_TELEMETRY_KEY = "install_id";
+var INSTALL_ID_TELEMETRY_KEY = BaseDimensions.InstallationId;
 function shouldPopulateTelemetryInstallContext(args) {
   return !isHelpOrVersionInvocation([...args]);
 }
@@ -6720,6 +7013,10 @@ async function runStartupSync(context, state) {
     logger.debug("Version sync skipped: dev mode (monorepo checkout)");
     return false;
   }
+  if (await getEnvToolsDirsDeclaration()) {
+    logger.debug("Version sync skipped: the host declared its tool directories and owns the CLI version");
+    return false;
+  }
   const [locationError, location] = await catchError(state.resolveInstallPath());
   if (!locationError && location && await isBundledDistribution(location.path)) {
     logger.debug("Version sync skipped: Studio-bundled CLI distribution");
@@ -6780,7 +7077,7 @@ async function resolveUpdateLocation(state, context) {
   return location;
 }
 async function runUpdateEngine(state, location, context, target) {
-  const { runUpdate: runUpdate2 } = await import("./updateService-e4yhztgq.js");
+  const { runUpdate: runUpdate2 } = await import("./updateService-r03h6d1b.js");
   const spinner = await startSpinner(formatUpdateStartMessage(target));
   if (!spinner) {
     writeSyncStatus(context, formatUpdateStartMessage(target));
@@ -7062,7 +7359,14 @@ class ToolManager {
       this.freshVerbs.add(verb);
       return;
     }
-    const location = await this.resolveInstallPath();
+    const [locationError, location] = await catchError(this.resolveInstallPath());
+    if (locationError instanceof InstallRefusedError) {
+      logger.debug(`Tool freshness check skipped: ${locationError.message}`);
+      this.freshVerbs.add(verb);
+      return;
+    }
+    if (locationError)
+      throw locationError;
     if (await isBundledDistribution(location.path)) {
       logger.debug("Tool freshness check skipped: Studio-bundled CLI distribution");
       this.freshVerbs.add(verb);
@@ -7104,7 +7408,8 @@ class ToolManager {
           spinner.text = `Installing ${packageSpec}…`;
         }
         const [installErr] = await catchError(toolService.install(packageSpec, location.path, {
-          global: location.global
+          global: location.global,
+          prefix: location.prefix
         }));
         if (installErr) {
           throw toolInstallFailedError(installed.toolName, packageSpec, installErr);
@@ -7249,12 +7554,25 @@ class ToolManager {
     }
     logger.debug(`Installing ${packageSpec} from ${candidate.registry ?? "the configured registry"} to ${location.path} (global: ${location.global})`);
     await toolService.install(packageSpec, location.path, {
-      global: location.global
+      global: location.global,
+      prefix: location.prefix
     });
     logger.info(`Installed ${packageSpec} successfully.`);
+    await this.includeGlobalInstallDirectory(location);
     await this.refreshDiscovery();
     await this.recordUpdateDate(packageName.replace(/^@uipath\//, ""));
   }
+  async includeGlobalInstallDirectory(location) {
+    if (!location.global || location.prefix)
+      return;
+    if (await getEnvToolsDirsDeclaration())
+      return;
+    const globalToolsDir = await refreshGlobalNpmUipathDir();
+    if (globalToolsDir && !this.toolsDirs.includes(globalToolsDir)) {
+      this.toolsDirs.push(globalToolsDir);
+      logger.debug(`Added global tool directory after install: ${globalToolsDir}`);
+    }
+  }
   async refreshDiscovery() {
     logger.debug(`Re-discovering tools in [${this.toolsDirs.join(", ")}]...`);
     this.discoveredTools = await discoverToolPaths(this.toolsDirs);
@@ -7298,6 +7616,63 @@ async function autoInstallToolIfNeeded(args, program, toolManager, context) {
 }
 
 // src/utils/registerToolCommands.ts
+async function loadToolCommand(program, entry, toolCommand) {
+  logger.debug(`Loading tool '${entry.toolName}'...`);
+  const tool = await importTool(entry);
+  if (!tool) {
+    return {
+      failure: {
+        Result: RESULTS.ConfigError,
+        Message: `Failed to load tool '${entry.toolName}' (version: ${entry.version || "unknown"}, path: ${entry.toolPath}).`,
+        Instructions: `Try reinstalling with 'uip tools install ${entry.commandPrefix}'.`,
+        TelemetryErrorClass: "missing_dependency"
+      }
+    };
+  }
+  setGlobalTelemetryProperties({
+    [BaseDimensions.ToolName]: tool.metadata.commandPrefix,
+    [BaseDimensions.ToolVersion]: tool.metadata.version
+  });
+  const idx = program.commands.indexOf(toolCommand);
+  if (idx >= 0) {
+    program.commands.splice(idx, 1);
+  }
+  const aliases = ALIASES_BY_COMMAND.get(entry.commandPrefix) ?? [];
+  const realCommand = program.command(tool.metadata.commandPrefix).description(tool.metadata.description);
+  if (aliases.length > 0)
+    realCommand.aliases(aliases);
+  const [regError] = await catchError(tool.registerCommands(realCommand));
+  if (regError) {
+    return {
+      failure: {
+        Result: RESULTS.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.",
+        TelemetryErrorClass: "internal"
+      }
+    };
+  }
+  stripHelpTextEventsForStructuredHelp(realCommand);
+  return { command: realCommand };
+}
+async function loadToolCommandsForArgs(program, discovered, context) {
+  const commandToken = context.args.slice(2).find((arg) => !arg.startsWith("-"));
+  const entry = discovered.find((candidate) => {
+    const aliases = ALIASES_BY_COMMAND.get(candidate.commandPrefix) ?? [];
+    return commandToken === candidate.commandPrefix || aliases.includes(commandToken ?? "");
+  });
+  if (!entry)
+    return true;
+  const stub = program.commands.find((command) => command.name() === entry.commandPrefix);
+  if (!stub)
+    return true;
+  const { failure } = await loadToolCommand(program, entry, stub);
+  if (failure) {
+    logger.debug(`Skipped loading tool for telemetry: ${failure.Message}`);
+    return false;
+  }
+  return true;
+}
 function registerToolCommands(program, discovered, context) {
   for (const entry of discovered) {
     const aliases = ALIASES_BY_COMMAND.get(entry.commandPrefix) ?? [];
@@ -7305,39 +7680,11 @@ function registerToolCommands(program, discovered, context) {
     if (aliases.length > 0)
       toolCommand.aliases(aliases);
     toolCommand.action(async () => {
-      logger.debug(`Loading tool '${entry.toolName}'...`);
-      const tool = await importTool(entry);
-      if (!tool) {
-        OutputFormatter.error({
-          Result: RESULTS.ConfigError,
-          Message: `Failed to load tool '${entry.toolName}' (version: ${entry.version || "unknown"}, path: ${entry.toolPath}).`,
-          Instructions: `Try reinstalling with 'uip tools install ${entry.commandPrefix}'.`,
-          TelemetryErrorClass: "missing_dependency"
-        });
+      const { command: realCommand, failure } = await loadToolCommand(program, entry, toolCommand);
+      if (failure) {
+        OutputFormatter.error(failure);
         return;
       }
-      setGlobalTelemetryProperties({
-        toolName: tool.metadata.commandPrefix,
-        toolVersion: tool.metadata.version
-      });
-      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);
-      if (aliases.length > 0)
-        realCommand.aliases(aliases);
-      const [regError] = await catchError(tool.registerCommands(realCommand));
-      if (regError) {
-        OutputFormatter.error({
-          Result: RESULTS.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.",
-          TelemetryErrorClass: "internal"
-        });
-        return;
-      }
-      stripHelpTextEventsForStructuredHelp(realCommand);
       const toolArgs = context.args.slice(2);
       const candidates = [entry.commandPrefix, ...aliases];
       const prefixIdx = toolArgs.findIndex((a) => candidates.includes(a));
@@ -7373,6 +7720,10 @@ async function resolveToolsDirectories(context) {
   if (toolsDirs.length > 0) {
     return { toolsDirs, toolsDir };
   }
+  if (await getEnvToolsDirsDeclaration()) {
+    logger.warn(`${TOOLS_DIRS_ENV_VAR} names no usable tool directory; no tools are available.`);
+    return { toolsDirs: [], toolsDir: undefined };
+  }
   logger.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"));
@@ -7400,7 +7751,7 @@ async function buildNodeProgram(context) {
       if (shouldPopulateTelemetryInstallContext(context.args)) {
         await populateTelemetryInstallContext();
       }
-      const { setActiveAuthProfile, setAuthFileConfig } = await import("./index-hgvsratt.js");
+      const { setActiveAuthProfile, setAuthFileConfig } = await import("./index-mttdq2yn.js");
       setActiveAuthProfile(profile);
       const [configErr, config] = await catchError(loadConfigAsync());
       if (configErr) {
@@ -7474,7 +7825,7 @@ async function buildNodeProgram(context) {
     discoveredTools
   });
   logger.debug("Node program built successfully — ready to parse args");
-  return { program, cleanedArgs, updateState };
+  return { program, cleanedArgs, updateState, discoveredTools };
 }
 async function runNode(context) {
   return runCliInvocation(() => runNodeInvocation(withRecordedExit(context)));
@@ -7482,6 +7833,7 @@ async function runNode(context) {
 async function runNodeInvocation(context) {
   const built = await buildNodeProgram(context);
   if (!built) {
+    emitApplicationStart(context);
     emitEarlyExitRequest(context, { success: false });
     await telemetryFlushAndShutdown();
     return;
@@ -7493,13 +7845,19 @@ async function runNodeInvocation(context) {
   const reexeced = await maybeRunDailyVersionSync(context, built.updateState);
   if (reexeced) {
     suppressTimingReport();
-    emitEarlyExitRequest(context, { success: true, delegated: true });
+    await loadToolCommandsForArgs(built.program, built.discoveredTools, context);
+    emitEarlyExitRequest(context, {
+      success: getExitCode() === 0,
+      delegated: true,
+      program: built.program
+    });
     await telemetryFlushAndShutdown();
     return;
   }
+  emitApplicationStart(context);
   await parseAndExit(built.program, built.cleanedArgs, context);
 }
 
 export { runNode };
 
-//# debugId=A4A81EB58587B10164756E2164756E21
+//# debugId=614F5EF94030176764756E2164756E21