@uipath/tasks-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/{tool-s6dm918n.js → tool-df3kr747.js}

@@ -1,8 +1,9 @@
 import {
+  __toESM,
   __commonJS,
-  __require,
-  __toESM
-} from "./tool-1de529jm.js";
+  __exportCjs,
+  __require
+} from "./tool-epsr41wx.js";
 
 // ../../node_modules/commander/lib/error.js
 var require_error = __commonJS(function(exports) {
@@ -124,7 +125,7 @@ var require_help = __commonJS(function(exports) {
       this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
     }
     visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+      const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);
       const helpCommand = cmd._getHelpCommand();
       if (helpCommand && !helpCommand._hidden) {
         visibleCommands.push(helpCommand);
@@ -604,8 +605,8 @@ var require_option = __commonJS(function(exports) {
     }
   }
   function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
+    return str.split("-").reduce((str, word) => {
+      return str + word[0].toUpperCase() + word.slice(1);
     });
   }
   function splitOptionFlags(flags) {
@@ -726,8 +727,8 @@ var require_suggestSimilar = __commonJS(function(exports) {
 var require_command = __commonJS(function(exports) {
   var EventEmitter = __require("node:events").EventEmitter;
   var childProcess = __require("node:child_process");
-  var path2 = __require("node:path");
-  var fs2 = __require("node:fs");
+  var path = __require("node:path");
+  var fs = __require("node:fs");
   var process2 = __require("node:process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error();
@@ -1176,44 +1177,44 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       return source;
     }
-    _prepareUserArgs(argv, parseOptions) {
-      if (argv !== undefined && !Array.isArray(argv)) {
+    _prepareUserArgs(argv2, parseOptions) {
+      if (argv2 !== undefined && !Array.isArray(argv2)) {
         throw new Error("first parameter to parse must be array or undefined");
       }
       parseOptions = parseOptions || {};
-      if (argv === undefined && parseOptions.from === undefined) {
+      if (argv2 === undefined && parseOptions.from === undefined) {
         if (process2.versions?.electron) {
           parseOptions.from = "electron";
         }
-        const execArgv = process2.execArgv ?? [];
-        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
+        const execArgv2 = process2.execArgv ?? [];
+        if (execArgv2.includes("-e") || execArgv2.includes("--eval") || execArgv2.includes("-p") || execArgv2.includes("--print")) {
           parseOptions.from = "eval";
         }
       }
-      if (argv === undefined) {
-        argv = process2.argv;
+      if (argv2 === undefined) {
+        argv2 = process2.argv;
       }
-      this.rawArgs = argv.slice();
+      this.rawArgs = argv2.slice();
       let userArgs;
       switch (parseOptions.from) {
         case undefined:
         case "node":
-          this._scriptPath = argv[1];
-          userArgs = argv.slice(2);
+          this._scriptPath = argv2[1];
+          userArgs = argv2.slice(2);
           break;
         case "electron":
           if (process2.defaultApp) {
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
+            this._scriptPath = argv2[1];
+            userArgs = argv2.slice(2);
           } else {
-            userArgs = argv.slice(1);
+            userArgs = argv2.slice(1);
           }
           break;
         case "user":
-          userArgs = argv.slice(0);
+          userArgs = argv2.slice(0);
           break;
         case "eval":
-          userArgs = argv.slice(1);
+          userArgs = argv2.slice(1);
           break;
         default:
           throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
@@ -1262,7 +1263,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.processedArgs = [];
     }
     _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-      if (fs2.existsSync(executableFile))
+      if (fs.existsSync(executableFile))
         return;
       const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
       const executableMissing = `'${executableFile}' does not exist
@@ -1276,12 +1277,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       let launchWithNode = false;
       const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
       function findFile(baseDir, baseName) {
-        const localBin = path2.resolve(baseDir, baseName);
-        if (fs2.existsSync(localBin))
+        const localBin = path.resolve(baseDir, baseName);
+        if (fs.existsSync(localBin))
           return localBin;
-        if (sourceExt.includes(path2.extname(baseName)))
+        if (sourceExt.includes(path.extname(baseName)))
           return;
-        const foundExt = sourceExt.find((ext) => fs2.existsSync(`${localBin}${ext}`));
+        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
         if (foundExt)
           return `${localBin}${foundExt}`;
         return;
@@ -1293,23 +1294,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this._scriptPath) {
         let resolvedScriptPath;
         try {
-          resolvedScriptPath = fs2.realpathSync(this._scriptPath);
+          resolvedScriptPath = fs.realpathSync(this._scriptPath);
         } catch {
           resolvedScriptPath = this._scriptPath;
         }
-        executableDir = path2.resolve(path2.dirname(resolvedScriptPath), executableDir);
+        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
       }
       if (executableDir) {
         let localFile = findFile(executableDir, executableFile);
         if (!localFile && !subcommand._executableFile && this._scriptPath) {
-          const legacyName = path2.basename(this._scriptPath, path2.extname(this._scriptPath));
+          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
           if (legacyName !== this._name) {
             localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
           }
         }
         executableFile = localFile || executableFile;
       }
-      launchWithNode = sourceExt.includes(path2.extname(executableFile));
+      launchWithNode = sourceExt.includes(path.extname(executableFile));
       let proc;
       if (process2.platform !== "win32") {
         if (launchWithNode) {
@@ -1736,18 +1737,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.error(message, { code: "commander.missingMandatoryOptionValue" });
     }
     _conflictingOption(option, conflictingOption) {
-      const findBestOptionFromValue = (option2) => {
-        const optionKey = option2.attributeName();
+      const findBestOptionFromValue = (option) => {
+        const optionKey = option.attributeName();
         const optionValue = this.getOptionValue(optionKey);
         const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
         const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
         if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
           return negativeOption;
         }
-        return positiveOption || option2;
+        return positiveOption || option;
       };
-      const getErrorMessage = (option2) => {
-        const bestOption = findBestOptionFromValue(option2);
+      const getErrorMessage = (option) => {
+        const bestOption = findBestOptionFromValue(option);
         const optionKey = bestOption.attributeName();
         const source = this.getOptionValueSource(optionKey);
         if (source === "env") {
@@ -1898,13 +1899,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
         cmd.helpGroup(this._defaultCommandGroup);
     }
     nameFromFilename(filename) {
-      this._name = path2.basename(filename, path2.extname(filename));
+      this._name = path.basename(filename, path.extname(filename));
       return this;
     }
-    executableDir(path3) {
-      if (path3 === undefined)
+    executableDir(path) {
+      if (path === undefined)
         return this._executableDir;
-      this._executableDir = path3;
+      this._executableDir = path;
       return this;
     }
     helpInformation(contextOptions) {
@@ -2001,11 +2002,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = Number(process2.exitCode ?? 0);
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
+      let exitCode2 = Number(process2.exitCode ?? 0);
+      if (exitCode2 === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
+        exitCode2 = 1;
       }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
+      this._exit(exitCode2, "commander.help", "(outputHelp)");
     }
     addHelpText(position, text) {
       const allowedValues = ["beforeAll", "before", "after", "afterAll"];
@@ -2077,25 +2078,207 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.useColor = useColor;
 });
 
-// ../../node_modules/commander/index.js
-var require_commander = __commonJS(function(exports) {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  var { Help } = require_help();
-  var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-});
+// ../common/src/telemetry/telemetry-dimensions.ts
+var BaseDimensions = {
+  ApplicationName: "ApplicationName",
+  ProductVersion: "ProductVersion",
+  InstallationId: "InstallationId",
+  CloudUserId: "CloudUserId",
+  CloudTenantId: "CloudTenantId",
+  CloudOrganizationId: "CloudOrganizationId",
+  IsInternalUser: "IsInternalUser",
+  Environment: "Environment",
+  BaseUrl: "BaseUrl",
+  Region: "Region",
+  Agent: "Agent",
+  AgentVersion: "AgentVersion",
+  AgentModel: "AgentModel",
+  ToolName: "ToolName",
+  ToolVersion: "ToolVersion",
+  ExecutionContext: "ExecutionContext",
+  CiProvider: "CiProvider",
+  SessionIdSource: "SessionIdSource",
+  SessionId: "SessionId"
+};
+var CommandDimensions = {
+  IsCommand: "IsCommand",
+  IsReexec: "IsReexec",
+  CommandName: "CommandName",
+  ExitCode: "ExitCode",
+  TerminalOutcome: "TerminalOutcome",
+  ErrorClass: "ErrorClass",
+  TerminalSignal: "TerminalSignal",
+  ErrorMessage: "ErrorMessage",
+  SkillName: "SkillName",
+  ProductArea: "ProductArea",
+  Mode: "Mode"
+};
+var ProjectDimensions = {
+  ProjectKey: "ProjectKey",
+  ProjectType: "ProjectType",
+  ProjectIdentityStatus: "ProjectIdentityStatus",
+  SolutionKey: "SolutionKey",
+  SolutionProjectKey: "SolutionProjectKey",
+  SolutionIdentityStatus: "SolutionIdentityStatus",
+  PreviousSolutionKey: "PreviousSolutionKey"
+};
+var GUID_KEY_DIMENSIONS = new Set([
+  ProjectDimensions.ProjectKey,
+  ProjectDimensions.SolutionKey,
+  ProjectDimensions.SolutionProjectKey,
+  ProjectDimensions.PreviousSolutionKey
+]);
+var ShipDimensions = {
+  ShipKind: "ShipKind",
+  Target: "Target",
+  ProjectType: "ProjectType",
+  ProjectTypes: "ProjectTypes",
+  ArtifactCorrelationKey: "ArtifactCorrelationKey",
+  PackageName: "PackageName",
+  PackageVersion: "PackageVersion",
+  PackageVersionKey: "PackageVersionKey",
+  DeploymentKey: "DeploymentKey",
+  SolutionId: "SolutionId",
+  FolderKey: "FolderKey",
+  FeedId: "FeedId"
+};
+var ErrorDimensions = {
+  Result: "Result",
+  ErrorCode: "ErrorCode",
+  Retry: "Retry",
+  ErrorMessage: "ErrorMessage",
+  HttpStatus: "HttpStatus",
+  UpstreamErrorCode: "UpstreamErrorCode"
+};
+var AuthDimensions = {
+  AuthenticationMethod: "AuthenticationMethod",
+  Success: "Success",
+  Reason: "Reason"
+};
+var SkillsDimensions = {
+  SchemaVersion: "SchemaVersion",
+  AgentType: "AgentType",
+  SkillsVersion: "SkillsVersion",
+  UipSubcommand: "UipSubcommand",
+  FileExtension: "FileExtension",
+  SubagentModel: "SubagentModel",
+  SubagentType: "SubagentType",
+  PermissionMode: "PermissionMode",
+  EffortLevel: "EffortLevel",
+  SessionSource: "SessionSource",
+  Outcome: "Outcome",
+  DurationMs: "DurationMs",
+  Source: "Source"
+};
+var PackagerDimensions = {
+  ProjectId: "ProjectId",
+  ProjectType: "ProjectType",
+  SolutionId: "SolutionId"
+};
+var ScopeDimensions = {
+  FolderId: "FolderId"
+};
+var ID_DIMENSIONS = new Set([
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.InstallationId,
+  ShipDimensions.ArtifactCorrelationKey,
+  ShipDimensions.PackageVersionKey,
+  ShipDimensions.DeploymentKey,
+  ShipDimensions.SolutionId,
+  ShipDimensions.FolderKey,
+  ShipDimensions.FeedId,
+  PackagerDimensions.ProjectId
+]);
+var NON_IDENTIFIER_PLACEHOLDER_PATTERN = /^(?:\[[A-Z_]+\]|<[^>]+>)$/;
+var RESERVED_DIMENSION_NAMES = new Set([
+  ...Object.values(BaseDimensions),
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions),
+  ...Object.values(ProjectDimensions),
+  ...Object.values(ErrorDimensions),
+  ...Object.values(AuthDimensions),
+  ...Object.values(SkillsDimensions),
+  ...Object.values(PackagerDimensions),
+  ...Object.values(ScopeDimensions)
+]);
+var CURATED_DIMENSIONS = new Set([
+  BaseDimensions.ApplicationName,
+  BaseDimensions.ProductVersion,
+  BaseDimensions.InstallationId,
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.IsInternalUser,
+  BaseDimensions.Environment,
+  BaseDimensions.BaseUrl,
+  BaseDimensions.Region,
+  BaseDimensions.Agent,
+  BaseDimensions.AgentVersion,
+  BaseDimensions.ToolVersion,
+  BaseDimensions.ExecutionContext,
+  BaseDimensions.CiProvider,
+  BaseDimensions.SessionIdSource,
+  BaseDimensions.SessionId,
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions),
+  ...Object.values(ProjectDimensions)
+]);
+function lowercaseIdDimensionValues(properties) {
+  let changed = false;
+  const result = {
+    ...properties
+  };
+  for (const key of Object.keys(result)) {
+    const value = result[key];
+    if (!ID_DIMENSIONS.has(key) || typeof value !== "string" || NON_IDENTIFIER_PLACEHOLDER_PATTERN.test(value)) {
+      continue;
+    }
+    const lowered = value.toLowerCase();
+    if (lowered !== value) {
+      result[key] = lowered;
+      changed = true;
+    }
+  }
+  return changed ? result : properties;
+}
+
+// ../common/src/telemetry/project-identity.ts
+function projectKey(id) {
+  if (typeof id !== "string")
+    return;
+  const key = id.trim().toLowerCase().replaceAll("-", "");
+  return /^[0-9a-f]{32}$/.test(key) ? key : undefined;
+}
+function projectIdentityProperties(identity) {
+  const key = identity.id ? projectKey(identity.id) : undefined;
+  return {
+    [ProjectDimensions.ProjectIdentityStatus]: identity.status === "resolved" && !key ? "invalid" : identity.status,
+    [ProjectDimensions.ProjectType]: identity.projectType,
+    ...identity.status === "resolved" && key ? {
+      [ProjectDimensions.ProjectKey]: key
+    } : {}
+  };
+}
+var PROJECT_IDENTITY_LOOKUP_BUDGET_MS = 1000;
+async function withinProjectIdentityBudget(work, onTimeout) {
+  work.catch(() => {
+    return;
+  });
+  let timer;
+  const expired = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      onTimeout?.();
+      resolve(undefined);
+    }, PROJECT_IDENTITY_LOOKUP_BUDGET_MS);
+  });
+  try {
+    return await Promise.race([work, expired]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 // ../common/src/telemetry/pseudonymize.ts
 var PSEUDONYM_DOMAIN = "uipath-cli/telemetry/pseudonym/v1:";
@@ -2560,6 +2743,8 @@ function redactProperty(name, value) {
   if (isSensitiveName(name)) {
     return REDACTED;
   }
+  if (GUID_KEY_DIMENSIONS.has(name))
+    return projectKey(value);
   if (typeof value === "boolean" || typeof value === "number") {
     return value;
   }
@@ -2634,6 +2819,63 @@ function settlePromiseLike(thenable) {
   return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [toError(error), undefined]);
 }
 
+// ../common/src/error-codes.ts
+var CLI_ERROR_CODES = [
+  "invalid_argument",
+  "authentication_required",
+  "permission_denied",
+  "local_permission_denied",
+  "not_found",
+  "rate_limited",
+  "network_error",
+  "timeout",
+  "server_error",
+  "method_not_allowed",
+  "not_supported",
+  "configuration_error",
+  "execution_failed",
+  "unknown_error"
+];
+var RETRY_HINTS = [
+  "RetryWillNotFix",
+  "RetryLater",
+  "RetryAfter1Second",
+  "RetryAfter10Seconds",
+  "RetryAfter30Seconds",
+  "RetryAfter60Seconds"
+];
+var CLI_ERROR_CODE_VALUES = new Set(CLI_ERROR_CODES);
+var RETRY_HINT_VALUES = new Set(RETRY_HINTS);
+function isCliErrorCode(value) {
+  return typeof value === "string" && CLI_ERROR_CODE_VALUES.has(value);
+}
+function isRetryHint(value) {
+  return typeof value === "string" && RETRY_HINT_VALUES.has(value);
+}
+function carriedErrorCode(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const code = error.errorCode;
+  return isCliErrorCode(code) ? code : undefined;
+}
+function carriedRetry(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const retry = error.retry;
+  return isRetryHint(retry) ? retry : undefined;
+}
+function defaultRetryForErrorCode(errorCode) {
+  switch (errorCode) {
+    case "network_error":
+    case "rate_limited":
+    case "server_error":
+    case "timeout":
+      return "RetryLater";
+    default:
+      return "RetryWillNotFix";
+  }
+}
+
 // ../common/src/error-graph.ts
 function* walkErrorGraph(error) {
   const queue = [error];
@@ -2678,6 +2920,40 @@ function findHttpStatusInGraph(error) {
   return;
 }
 
+// ../common/src/http-status.ts
+function classifyHttpStatus(status) {
+  if (status === undefined)
+    return;
+  if (status === 400 || status === 409 || status === 413 || status === 422) {
+    return { errorCode: "invalid_argument", retry: "RetryWillNotFix" };
+  }
+  if (status === 401) {
+    return {
+      errorCode: "authentication_required",
+      retry: "RetryWillNotFix"
+    };
+  }
+  if (status === 403) {
+    return { errorCode: "permission_denied", retry: "RetryWillNotFix" };
+  }
+  if (status === 404) {
+    return { errorCode: "not_found", retry: "RetryWillNotFix" };
+  }
+  if (status === 405) {
+    return { errorCode: "method_not_allowed", retry: "RetryWillNotFix" };
+  }
+  if (status === 408) {
+    return { errorCode: "timeout", retry: "RetryLater" };
+  }
+  if (status === 429) {
+    return { errorCode: "rate_limited", retry: "RetryLater" };
+  }
+  if (status >= 500 && status < 600) {
+    return { errorCode: "server_error", retry: "RetryLater" };
+  }
+  return;
+}
+
 // ../common/src/local-permission-codes.ts
 var LOCAL_PERMISSION_ERROR_CODES = new Set([
   "EACCES",
@@ -2690,6 +2966,8 @@ var DEFAULT_401 = "Unauthorized (401). The session is missing or expired, or its
 var DEFAULT_403 = "Forbidden (403). The account lacks permission for this operation, or the token carries no scope for this API. Run `uip login status --detailed` to see the token's scopes.";
 var DEFAULT_405 = "Method Not Allowed (405). The endpoint may not exist or the base URL may be incorrect.";
 var DEFAULT_413 = "Payload too large (413). The upload exceeded the server or CDN size limit. Reduce the package size — for example, exclude unused dependencies or remove large files from the project — and try again.";
+var CLOUDFLARE_BLOCK_403 = "Forbidden (403) by Cloudflare, in front of the service: the answer is a Cloudflare HTML page, not the service's JSON, so the service did not see the request and did not check the account's roles or the token's scopes. Cloudflare blocks a request when its content matches a firewall rule (text that looks like SQL or script code, for example) or when it comes from a network the firewall does not allow.";
+var CLOUDFLARE_BLOCK_403_INSTRUCTIONS = "If the request carries text that looks like code, change that text and try again. Otherwise send the time of the request and the Cloudflare Ray ID, when the message gives one, to the owner of the service or UiPath support.";
 var HTML_RESPONSE_MESSAGE = "Received HTML instead of the expected JSON response.";
 var NETWORK_ERROR_CODES = new Set([
   "ECONNREFUSED",
@@ -2775,9 +3053,23 @@ function localPermissionPath(path, message) {
     return path;
   return message ? /'([^']+)'/.exec(message)?.[1] : undefined;
 }
-function isHtmlDocument(body) {
-  return /^\s*(<!doctype html|<html\b)/i.test(body);
-}
+function readHeader(response, name) {
+  const headers = response?.headers;
+  if (!headers || typeof headers !== "object")
+    return;
+  if (typeof headers.get === "function") {
+    const value = headers.get(name);
+    if (value)
+      return value;
+  }
+  const plain = headers;
+  const key = Object.keys(plain).find((k) => k.toLowerCase() === name.toLowerCase());
+  const value = key === undefined ? undefined : plain[key];
+  return typeof value === "string" && value !== "" ? value : undefined;
+}
+function isHtmlDocument(body) {
+  return /^\s*(<!doctype html|<html\b)/i.test(body);
+}
 function retryHintForRetryAfter(seconds) {
   if (seconds <= 1) {
     return "RetryAfter1Second";
@@ -2791,36 +3083,9 @@ function retryHintForRetryAfter(seconds) {
   return "RetryAfter60Seconds";
 }
 function classifyError(status, error) {
-  if (status === 400 || status === 409 || status === 422) {
-    return { errorCode: "invalid_argument", retry: "RetryWillNotFix" };
-  }
-  if (status === 401) {
-    return {
-      errorCode: "authentication_required",
-      retry: "RetryWillNotFix"
-    };
-  }
-  if (status === 403) {
-    return { errorCode: "permission_denied", retry: "RetryWillNotFix" };
-  }
-  if (status === 404) {
-    return { errorCode: "not_found", retry: "RetryWillNotFix" };
-  }
-  if (status === 405) {
-    return { errorCode: "method_not_allowed", retry: "RetryWillNotFix" };
-  }
-  if (status === 413) {
-    return { errorCode: "invalid_argument", retry: "RetryWillNotFix" };
-  }
-  if (status === 408) {
-    return { errorCode: "timeout", retry: "RetryLater" };
-  }
-  if (status === 429) {
-    return { errorCode: "rate_limited", retry: "RetryLater" };
-  }
-  if (status !== undefined && status >= 500 && status < 600) {
-    return { errorCode: "server_error", retry: "RetryLater" };
-  }
+  const byStatus = classifyHttpStatus(status);
+  if (byStatus)
+    return byStatus;
   if (status === undefined && describePermissionError(error)) {
     return {
       errorCode: "local_permission_denied",
@@ -2836,6 +3101,17 @@ function classifyError(status, error) {
   }
   return { errorCode: "unknown_error", retry: "RetryWillNotFix" };
 }
+function withCarriedClass(inferred, error) {
+  const errorCode = carriedErrorCode(error);
+  const retry = carriedRetry(error);
+  if (errorCode === undefined || errorCode === inferred.errorCode) {
+    return {
+      errorCode: inferred.errorCode,
+      retry: retry ?? inferred.retry
+    };
+  }
+  return { errorCode, retry: retry ?? defaultRetryForErrorCode(errorCode) };
+}
 function formatHttpStatusMessage(status, rawMessage, extractedMessage, inferredStatus) {
   if (extractedMessage) {
     return `HTTP ${status}: ${extractedMessage}`;
@@ -2891,9 +3167,14 @@ async function extractErrorDetails(error, options) {
   const classificationStatus = status ?? findHttpStatusInGraph(error);
   const classification = classifyError(classificationStatus, error);
   let retry = classification.retry;
+  const htmlForbidden = status === 403 && rawBody !== undefined && isHtmlDocument(rawBody);
+  const rayId = htmlForbidden ? readHeader(response, "cf-ray") : undefined;
+  const cloudflareBlock = htmlForbidden && (rayId !== undefined || /\bcloudflare\b/i.test(readHeader(response, "server") ?? ""));
   if (status === 401) {
     message = DEFAULT_401;
     result = "AuthenticationError";
+  } else if (cloudflareBlock) {
+    message = rayId ? `${CLOUDFLARE_BLOCK_403} Cloudflare Ray ID: ${rayId}.` : CLOUDFLARE_BLOCK_403;
   } else if (status === 403) {
     message = options?.forbiddenMessage ?? DEFAULT_403;
     result = "AuthenticationError";
@@ -2941,7 +3222,9 @@ async function extractErrorDetails(error, options) {
     }
   }
   let details = rawMessage;
-  if (rawBody) {
+  if (htmlForbidden) {
+    details = cloudflareBlock ? CLOUDFLARE_BLOCK_403_INSTRUCTIONS : HTML_RESPONSE_MESSAGE;
+  } else if (rawBody) {
     if (parsedBody) {
       const extra = {};
       if (parsedBody.errorCode)
@@ -2975,6 +3258,8 @@ async function extractErrorDetails(error, options) {
   }
   if (parsedBody?.requestId && typeof parsedBody.requestId === "string") {
     context.requestId = parsedBody.requestId;
+  } else if (cloudflareBlock && rayId) {
+    context.requestId = rayId;
   }
   if (parsedBody?.traceId && typeof parsedBody.traceId === "string") {
     context.traceId = parsedBody.traceId;
@@ -2983,16 +3268,7 @@ async function extractErrorDetails(error, options) {
     context.path = permission.path;
   }
   if (status === 429) {
-    const resp = response;
-    const headersObj = resp?.headers;
-    let retryAfterValue;
-    if (headersObj && typeof headersObj === "object" && typeof headersObj.get === "function") {
-      retryAfterValue = headersObj.get("retry-after") ?? undefined;
-    }
-    if (!retryAfterValue && headersObj && typeof headersObj === "object") {
-      const headers = headersObj;
-      retryAfterValue = headers["retry-after"] ?? headers["Retry-After"];
-    }
+    const retryAfterValue = readHeader(response, "retry-after");
     if (retryAfterValue) {
       const seconds = Number(retryAfterValue);
       if (!Number.isNaN(seconds)) {
@@ -3026,9 +3302,8 @@ async function extractErrorDetails(error, options) {
   }
   return {
     result,
-    errorCode: classification.errorCode,
+    ...withCarriedClass({ errorCode: classification.errorCode, retry }, error),
     message,
-    retry,
     details,
     ...hasContext ? { context } : {},
     ...parsedErrors ? { parsedErrors } : {}
@@ -3053,13 +3328,77 @@ function extractErrorMessageSync(error) {
   return describeThrownValue(error);
 }
 
-// ../common/src/exit-code.ts
-function setExitCode(code) {
-  process.exitCode = code;
-}
+// ../common/src/result-types.ts
+var RESULTS = {
+  Success: "Success",
+  Failure: "Failure",
+  ConfigError: "ConfigError",
+  AuthenticationError: "AuthenticationError",
+  ValidationError: "ValidationError",
+  TimeoutError: "TimeoutError"
+};
+
+// ../../node_modules/commander/index.js
+var exports_commander = {};
+__exportCjs(exports_commander, {
+  program: () => $program,
+  createCommand: () => $createCommand,
+  createOption: () => $createOption,
+  createArgument: () => $createArgument,
+  Command: () => $Command,
+  Option: () => $Option,
+  Argument: () => $Argument,
+  Help: () => $Help,
+  CommanderError: () => $CommanderError,
+  InvalidArgumentError: () => $InvalidArgumentError,
+  InvalidOptionArgumentError: () => $InvalidOptionArgumentError
+}, {
+  program: (value) => $program = value,
+  createCommand: (value) => $createCommand = value,
+  createOption: (value) => $createOption = value,
+  createArgument: (value) => $createArgument = value,
+  Command: (value) => $Command = value,
+  Option: (value) => $Option = value,
+  Argument: (value) => $Argument = value,
+  Help: (value) => $Help = value,
+  CommanderError: (value) => $CommanderError = value,
+  InvalidArgumentError: (value) => $InvalidArgumentError = value,
+  InvalidOptionArgumentError: (value) => $InvalidOptionArgumentError = value
+});
+var { Argument } = require_argument();
+var { Command: Command2 } = require_command();
+var { CommanderError, InvalidArgumentError } = require_error();
+var { Help } = require_help();
+var { Option: Option2 } = require_option();
+var $program = new Command2;
+var $createCommand = (name) => new Command2(name);
+var $createOption = (flags, description) => new Option2(flags, description);
+var $createArgument = (name, description) => new Argument(name, description);
+var $Command = Command2;
+var $Option = Option2;
+var $Argument = Argument;
+var $Help = Help;
+var $CommanderError = CommanderError;
+var $InvalidArgumentError = InvalidArgumentError;
+var $InvalidOptionArgumentError = InvalidArgumentError;
+
+// ../../node_modules/commander/esm.mjs
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError: CommanderError2,
+  InvalidArgumentError: InvalidArgumentError2,
+  InvalidOptionArgumentError,
+  Command,
+  Argument: Argument2,
+  Option,
+  Help: Help2
+} = exports_commander;
 
 // ../filesystem/src/node.ts
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
@@ -3070,6 +3409,9 @@ var LOCK_MAX_WAIT_MS = 20000;
 var LOCK_MAX_HOLD_MS = 60000;
 var LOCK_RETRY_MIN_MS = 100;
 var LOCK_RETRY_JITTER_MS = 200;
+var HASH_CHUNK_BYTES = 256 * 1024;
+var hashBuffers = [];
+var HASH_BUFFERS_KEPT = 64;
 
 class NodeFileSystem {
   path = {
@@ -3088,7 +3430,7 @@ class NodeFileSystem {
   };
   utils = {
     open: async (url) => {
-      const { default: open } = await import("./index-sby22td6.js");
+      const { default: open } = await import("./index-nzr4mx5p.js");
       await open(url);
     }
   };
@@ -3127,6 +3469,15 @@ class NodeFileSystem {
       throw error;
     }
   }
+  async readdirEntries(dirPath) {
+    try {
+      return await fs.readdir(dirPath, { withFileTypes: true });
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
   async stat(filePath) {
     try {
       const stats = await fs.stat(filePath);
@@ -3134,7 +3485,8 @@ class NodeFileSystem {
         isFile: () => stats.isFile(),
         isDirectory: () => stats.isDirectory(),
         size: stats.size,
-        mtimeMs: stats.mtimeMs
+        mtimeMs: stats.mtimeMs,
+        ctimeMs: stats.ctimeMs
       };
     } catch (error) {
       if (this.isEnoent(error))
@@ -3248,6 +3600,42 @@ class NodeFileSystem {
       throw error;
     }
   }
+  async hashFile(filePath) {
+    let handle;
+    try {
+      handle = await fs.open(filePath, "r");
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+    const buffer = hashBuffers.pop() ?? Buffer.allocUnsafe(HASH_CHUNK_BYTES);
+    try {
+      const opened = await handle.stat();
+      const stats = {
+        isFile: () => opened.isFile(),
+        isDirectory: () => opened.isDirectory(),
+        size: opened.size,
+        mtimeMs: opened.mtimeMs,
+        ctimeMs: opened.ctimeMs
+      };
+      const hash = createHash("sha256");
+      let size = 0;
+      for (;; ) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, null);
+        if (bytesRead === 0)
+          break;
+        hash.update(buffer.subarray(0, bytesRead));
+        size += bytesRead;
+      }
+      return { sha256: hash.digest("hex"), size, stats };
+    } finally {
+      if (hashBuffers.length < HASH_BUFFERS_KEPT) {
+        hashBuffers.push(buffer);
+      }
+      await handle.close();
+    }
+  }
   async realpath(filePath) {
     try {
       return await fs.realpath(filePath);
@@ -3331,8 +3719,8 @@ function getOutputSink() {
 
 // ../common/src/logger.ts
 var logFilePathSlot = singleton("logFilePath");
-function setGlobalLogFilePath(path2) {
-  logFilePathSlot.set(path2);
+function setGlobalLogFilePath(path) {
+  logFilePathSlot.set(path);
 }
 function getGlobalLogFilePath() {
   return logFilePathSlot.get("");
@@ -3400,14 +3788,14 @@ class SimpleLogger {
     return this.fileLoggingEnabled || !!getGlobalLogFilePath();
   }
   writeToFile(formatted) {
-    const path2 = this.logFilePath || getGlobalLogFilePath();
-    if (!path2)
+    const path = this.logFilePath || getGlobalLogFilePath();
+    if (!path)
       return;
     const timestamp = new Date().toISOString();
     this.pendingWrites = Promise.all([
       this.pendingWrites,
       this.pendingInit
-    ]).then(() => getFileSystem().appendFile(path2, `${timestamp} ${formatted}`).catch(() => {}));
+    ]).then(() => getFileSystem().appendFile(path, `${timestamp} ${formatted}`).catch(() => {}));
   }
   write(formatted) {
     if (this.isFileLoggingActive()) {
@@ -3457,17 +3845,17 @@ class SimpleLogger {
       setGlobalLogFilePath("");
     }
   }
-  setLogFile(path2) {
-    this.logFilePath = path2;
-    setGlobalLogFilePath(path2);
-    if (!path2)
+  setLogFile(path) {
+    this.logFilePath = path;
+    setGlobalLogFilePath(path);
+    if (!path)
       return;
     this.fileLoggingEnabled = true;
-    const fs2 = getFileSystem();
+    const fs = getFileSystem();
     this.pendingInit = (async () => {
       const [error] = await catchError((async () => {
-        await fs2.mkdir(fs2.path.dirname(path2));
-        await fs2.writeFile(path2, "");
+        await fs.mkdir(fs.path.dirname(path));
+        await fs.writeFile(path, "");
       })());
       if (error)
         this.fileLoggingEnabled = false;
@@ -3515,18 +3903,111 @@ function getLogFilePath() {
   return logger.getLogFilePath();
 }
 
+// ../common/src/timings.ts
+var TIMINGS_ENV_VAR = "UIP_TIMINGS";
+function createStorage2() {
+  const [error, mod] = catchError(() => __require("node:async_hooks"));
+  if (error || typeof mod?.AsyncLocalStorage !== "function") {
+    return {
+      getStore: () => {
+        return;
+      },
+      run: (_store, fn) => fn()
+    };
+  }
+  return new mod.AsyncLocalStorage;
+}
+var storageSlot = singleton("TimingStorage");
+var stateSlot = singleton("Timings");
+var rootStartedSlot = singleton("TimingsRootStarted");
+var longLivedHostSlot = singleton("TimingsLongLivedHost");
+var storage = storageSlot.getOrInit(createStorage2, (value) => ("getStore" in value));
+function newState(baseline) {
+  return { baseline, httpMs: 0, httpCalls: 0 };
+}
+function getState() {
+  const scoped = storage.getStore();
+  if (scoped) {
+    return scoped;
+  }
+  const pinned = livePinnedState();
+  if (pinned !== undefined) {
+    return pinned;
+  }
+  return newState(processStartIsInvocationStart() ? 0 : performance.now());
+}
+function livePinnedState() {
+  const pinned = stateSlot.get();
+  return pinned !== undefined && "httpCalls" in pinned && !pinned.finished ? pinned : undefined;
+}
+function processStartIsInvocationStart() {
+  return !rootStartedSlot.get(false) && !longLivedHostSlot.get(false);
+}
+function timingsEnabled() {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  const value = process.env?.[TIMINGS_ENV_VAR];
+  if (value === undefined) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+}
+function recordExitCode(exitCode) {
+  if (!timingsEnabled()) {
+    return;
+  }
+  getState().exitCode = exitCode;
+}
+function invocationStartedAt() {
+  return new Date(performance.timeOrigin + getState().baseline);
+}
+function invocationElapsedMs() {
+  return performance.now() - getState().baseline;
+}
+function markCommandStart() {
+  if (!timingsEnabled()) {
+    return;
+  }
+  getState().commandStart = performance.now();
+}
+function recordCommandDuration(durationMs) {
+  if (!timingsEnabled()) {
+    return;
+  }
+  getState().commandMs = durationMs;
+}
+
+// ../common/src/exit-code.ts
+function setExitCode(code) {
+  process.exitCode = code;
+  recordExitCode(code);
+}
+var GENERIC_FAILURE_EXIT_CODE = 1;
+function recordCommandExit(code) {
+  if (code === GENERIC_FAILURE_EXIT_CODE && getExitCode() !== 0) {
+    return;
+  }
+  setExitCode(code);
+}
+function getExitCode() {
+  const code = process.exitCode;
+  return typeof code === "number" ? code : 0;
+}
+
 // ../common/src/output-codecs.ts
 var yamlSlot = singleton("YamlCodec");
 var jmespathSlot = singleton("JmespathCodec");
 async function loadOutputCodecsAsync(needed) {
   const loads = [];
   if (needed.yaml && yamlSlot.get() === undefined) {
-    loads.push(import("./js-yaml-88tdqrtd.js").then((mod) => {
+    loads.push(import("./js-yaml-a2bk27p6.js").then((mod) => {
       yamlSlot.set(mod);
     }));
   }
   if (needed.filter && jmespathSlot.get() === undefined) {
-    loads.push(import("./jmespath-231m3hyn.js").then((m)=>__toESM(m.default,1)).then((mod) => {
+    loads.push(import("./jmespath-ab6tdc42.js").then((m)=>__toESM(m.default,1)).then((mod) => {
       jmespathSlot.set(mod);
     }));
   }
@@ -3551,155 +4032,6 @@ function getOutputFilter() {
   return filterSlot.get();
 }
 
-// ../common/src/telemetry/telemetry-dimensions.ts
-var BaseDimensions = {
-  ApplicationName: "ApplicationName",
-  ProductVersion: "ProductVersion",
-  InstallationId: "InstallationId",
-  CloudUserId: "CloudUserId",
-  CloudTenantId: "CloudTenantId",
-  CloudOrganizationId: "CloudOrganizationId",
-  IsInternalUser: "IsInternalUser",
-  Environment: "Environment",
-  BaseUrl: "BaseUrl",
-  Region: "Region",
-  Agent: "Agent",
-  AgentVersion: "AgentVersion",
-  AgentModel: "AgentModel",
-  ToolName: "ToolName",
-  ToolVersion: "ToolVersion",
-  ExecutionContext: "ExecutionContext",
-  CiProvider: "CiProvider",
-  SessionIdSource: "SessionIdSource",
-  SessionId: "SessionId"
-};
-var CommandDimensions = {
-  IsCommand: "IsCommand",
-  IsReexec: "IsReexec",
-  CommandName: "CommandName",
-  ExitCode: "ExitCode",
-  TerminalOutcome: "TerminalOutcome",
-  ErrorClass: "ErrorClass",
-  TerminalSignal: "TerminalSignal",
-  ErrorMessage: "ErrorMessage",
-  SkillName: "SkillName",
-  ProductArea: "ProductArea",
-  Mode: "Mode"
-};
-var ShipDimensions = {
-  ShipKind: "ShipKind",
-  Target: "Target",
-  ProjectType: "ProjectType",
-  ProjectTypes: "ProjectTypes",
-  ArtifactCorrelationKey: "ArtifactCorrelationKey",
-  PackageName: "PackageName",
-  PackageVersion: "PackageVersion",
-  PackageVersionKey: "PackageVersionKey",
-  DeploymentKey: "DeploymentKey",
-  SolutionId: "SolutionId",
-  FolderKey: "FolderKey",
-  FeedId: "FeedId"
-};
-var ErrorDimensions = {
-  Result: "Result",
-  ErrorCode: "ErrorCode",
-  Retry: "Retry",
-  ErrorMessage: "ErrorMessage",
-  HttpStatus: "HttpStatus",
-  UpstreamErrorCode: "UpstreamErrorCode"
-};
-var AuthDimensions = {
-  AuthenticationMethod: "AuthenticationMethod",
-  Success: "Success",
-  Reason: "Reason"
-};
-var SkillsDimensions = {
-  SchemaVersion: "SchemaVersion",
-  AgentType: "AgentType",
-  SkillsVersion: "SkillsVersion",
-  UipSubcommand: "UipSubcommand",
-  FileExtension: "FileExtension",
-  SubagentModel: "SubagentModel",
-  SubagentType: "SubagentType",
-  PermissionMode: "PermissionMode",
-  EffortLevel: "EffortLevel",
-  SessionSource: "SessionSource",
-  Outcome: "Outcome",
-  DurationMs: "DurationMs",
-  Source: "Source"
-};
-var PackagerDimensions = {
-  ProjectId: "ProjectId",
-  ProjectType: "ProjectType",
-  SolutionId: "SolutionId"
-};
-var ScopeDimensions = {
-  FolderId: "FolderId"
-};
-var ID_DIMENSIONS = new Set([
-  BaseDimensions.CloudUserId,
-  BaseDimensions.CloudTenantId,
-  BaseDimensions.CloudOrganizationId,
-  BaseDimensions.InstallationId,
-  ShipDimensions.ArtifactCorrelationKey,
-  ShipDimensions.PackageVersionKey,
-  ShipDimensions.DeploymentKey,
-  ShipDimensions.SolutionId,
-  ShipDimensions.FolderKey,
-  ShipDimensions.FeedId,
-  PackagerDimensions.ProjectId
-]);
-var NON_IDENTIFIER_PLACEHOLDER_PATTERN = /^(?:\[[A-Z_]+\]|<[^>]+>)$/;
-var RESERVED_DIMENSION_NAMES = new Set([
-  ...Object.values(BaseDimensions),
-  ...Object.values(CommandDimensions),
-  ...Object.values(ShipDimensions),
-  ...Object.values(ErrorDimensions),
-  ...Object.values(AuthDimensions),
-  ...Object.values(SkillsDimensions),
-  ...Object.values(PackagerDimensions),
-  ...Object.values(ScopeDimensions)
-]);
-var CURATED_DIMENSIONS = new Set([
-  BaseDimensions.ApplicationName,
-  BaseDimensions.ProductVersion,
-  BaseDimensions.InstallationId,
-  BaseDimensions.CloudUserId,
-  BaseDimensions.CloudTenantId,
-  BaseDimensions.CloudOrganizationId,
-  BaseDimensions.IsInternalUser,
-  BaseDimensions.Environment,
-  BaseDimensions.BaseUrl,
-  BaseDimensions.Region,
-  BaseDimensions.Agent,
-  BaseDimensions.AgentVersion,
-  BaseDimensions.ToolVersion,
-  BaseDimensions.ExecutionContext,
-  BaseDimensions.CiProvider,
-  BaseDimensions.SessionIdSource,
-  BaseDimensions.SessionId,
-  ...Object.values(CommandDimensions),
-  ...Object.values(ShipDimensions)
-]);
-function lowercaseIdDimensionValues(properties) {
-  let changed = false;
-  const result = {
-    ...properties
-  };
-  for (const key of Object.keys(result)) {
-    const value = result[key];
-    if (!ID_DIMENSIONS.has(key) || typeof value !== "string" || NON_IDENTIFIER_PLACEHOLDER_PATTERN.test(value)) {
-      continue;
-    }
-    const lowered = value.toLowerCase();
-    if (lowered !== value) {
-      result[key] = lowered;
-      changed = true;
-    }
-  }
-  return changed ? result : properties;
-}
-
 // ../common/src/telemetry/command-terminal.ts
 var recordedFailureSlot = singleton("CommandTelemetryFailure");
 var AUTH_ERROR_CODES = new Set([
@@ -3812,23 +4144,14 @@ function terminalSignalFor(input, outcome) {
   if (input.recordedFailure?.terminalSignal) {
     return input.recordedFailure.terminalSignal;
   }
-  const explicit = findStringInCauseChain(input.error, "terminalSignal") ?? findStringInCauseChain(input.error, "signal");
-  if (explicit) {
-    return explicit;
-  }
-  return outcome === "cancelled" ? "SIGINT" : undefined;
-}
-function classifyHttpStatus(status) {
-  if (status === 401 || status === 403) {
-    return "auth";
-  }
-  if (status === 400 || status === 409 || status === 422) {
-    return "validation";
-  }
-  if (status === 408) {
-    return "timeout";
+  const explicit = findStringInCauseChain(input.error, "terminalSignal") ?? findStringInCauseChain(input.error, "signal");
+  if (explicit) {
+    return explicit;
   }
-  return "network_http";
+  return outcome === "cancelled" ? "SIGINT" : undefined;
+}
+function classifyFailingHttpStatus(status) {
+  return classifyFromErrorCode(classifyHttpStatus(status)?.errorCode) ?? "network_http";
 }
 function classifyFromResult(result) {
   switch (result) {
@@ -3908,7 +4231,7 @@ function classifyError2(input) {
   }
   const status = recorded?.context?.httpStatus ?? findHttpStatusInGraph(input.error);
   if (status !== undefined) {
-    return classifyHttpStatus(status);
+    return classifyFailingHttpStatus(status);
   }
   return classifyFromResult(recorded?.result) ?? classifyFromErrorCode(recorded?.errorCode) ?? classifyFromError(input.error) ?? "unknown";
 }
@@ -3940,6 +4263,7 @@ function buildCommandTerminalTelemetryProperties(input) {
 var CommonTelemetryEvents = {
   Start: "Application.Start",
   Error: "Application.Error",
+  ProjectActivity: "Cli.ProjectActivity",
   ShipSucceeded: "Cli.ShipSucceeded"
 };
 
@@ -4457,87 +4781,21 @@ class TelemetryService {
     return hex;
   }
 }
-// ../common/src/timings.ts
-var TIMINGS_ENV_VAR = "UIP_TIMINGS";
-function createStorage2() {
-  const [error, mod] = catchError(() => __require("node:async_hooks"));
-  if (error || typeof mod?.AsyncLocalStorage !== "function") {
-    return {
-      getStore: () => {
-        return;
-      },
-      run: (_store, fn) => fn()
-    };
-  }
-  return new mod.AsyncLocalStorage;
-}
-var storageSlot = singleton("TimingStorage");
-var stateSlot = singleton("Timings");
-var rootStartedSlot = singleton("TimingsRootStarted");
-var longLivedHostSlot = singleton("TimingsLongLivedHost");
-var storage = storageSlot.getOrInit(createStorage2, (value) => ("getStore" in value));
-function newState(baseline) {
-  return { baseline, httpMs: 0, httpCalls: 0 };
-}
-function getState() {
-  const scoped = storage.getStore();
-  if (scoped) {
-    return scoped;
-  }
-  const pinned = livePinnedState();
-  if (pinned !== undefined) {
-    return pinned;
-  }
-  return newState(processStartIsInvocationStart() ? 0 : performance.now());
-}
-function livePinnedState() {
-  const pinned = stateSlot.get();
-  return pinned !== undefined && "httpCalls" in pinned && !pinned.finished ? pinned : undefined;
-}
-function processStartIsInvocationStart() {
-  return !rootStartedSlot.get(false) && !longLivedHostSlot.get(false);
-}
-function timingsEnabled() {
-  if (typeof process === "undefined") {
-    return false;
-  }
-  const value = process.env?.[TIMINGS_ENV_VAR];
-  if (value === undefined) {
-    return false;
-  }
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true";
-}
-function recordExitCode(exitCode) {
-  if (!timingsEnabled()) {
-    return;
-  }
-  getState().exitCode = exitCode;
-}
-function invocationStartedAt() {
-  return new Date(performance.timeOrigin + getState().baseline);
-}
-function invocationElapsedMs() {
-  return performance.now() - getState().baseline;
-}
-function markCommandStart() {
-  if (!timingsEnabled()) {
-    return;
-  }
-  getState().commandStart = performance.now();
-}
-function recordCommandDuration(durationMs) {
-  if (!timingsEnabled()) {
-    return;
-  }
-  getState().commandMs = durationMs;
-}
 // ../common/src/telemetry/proxy-http-agent.ts
 var slot = singleton("ProxyAuthHttpsAgent");
 
 // ../common/src/telemetry/node-appinsights-telemetry-provider.ts
 var providerSlot = singleton("TelemetryProvider");
 
+// ../common/src/telemetry/telemetry-config.ts
+function isTelemetryDisabled() {
+  const value = process.env.UIPATH_TELEMETRY_DISABLED;
+  return value === "1" || value === "true";
+}
+function isProjectTelemetryDisabled() {
+  return isTelemetryDisabled() || process.env.UIPATH_PROJECT_TELEMETRY_DISABLED === "1" || process.env.UIPATH_PROJECT_TELEMETRY_DISABLED === "true";
+}
+
 // ../common/src/telemetry/telemetry-spool.ts
 var sidecarEntrySlot = singleton("TelemetrySidecarEntry");
 var MAX_SPOOL_AGE_MS = 72 * 60 * 60 * 1000;
@@ -4573,7 +4831,6 @@ var telemetry = new Proxy({}, {
     return typeof value === "function" ? value.bind(instance) : value;
   }
 });
-
 // ../common/src/formatter.ts
 var ANSI_STYLES = {
   red: "\x1B[31m",
@@ -4583,46 +4840,6 @@ var ANSI_RESET = "\x1B[0m";
 function styleLine(line, style) {
   return style ? `${ANSI_STYLES[style]}${line}${ANSI_RESET}` : line;
 }
-var CLI_ERROR_CODES = [
-  "invalid_argument",
-  "authentication_required",
-  "permission_denied",
-  "local_permission_denied",
-  "not_found",
-  "rate_limited",
-  "network_error",
-  "timeout",
-  "server_error",
-  "method_not_allowed",
-  "not_supported",
-  "configuration_error",
-  "execution_failed",
-  "unknown_error"
-];
-var RETRY_HINTS = [
-  "RetryWillNotFix",
-  "RetryLater",
-  "RetryAfter1Second",
-  "RetryAfter10Seconds",
-  "RetryAfter30Seconds",
-  "RetryAfter60Seconds"
-];
-var CLI_ERROR_CODE_VALUES = new Set(CLI_ERROR_CODES);
-var RETRY_HINT_VALUES = new Set(RETRY_HINTS);
-function isCliErrorCode(value) {
-  return typeof value === "string" && CLI_ERROR_CODE_VALUES.has(value);
-}
-function isRetryHint(value) {
-  return typeof value === "string" && RETRY_HINT_VALUES.has(value);
-}
-var RESULTS = {
-  Success: "Success",
-  Failure: "Failure",
-  ConfigError: "ConfigError",
-  AuthenticationError: "AuthenticationError",
-  ValidationError: "ValidationError",
-  TimeoutError: "TimeoutError"
-};
 var EXIT_CODES = {
   Success: 0,
   Failure: 1,
@@ -4631,6 +4848,9 @@ var EXIT_CODES = {
   ValidationError: 3,
   TimeoutError: 4
 };
+function exitCodeForResult(result) {
+  return EXIT_CODES[result] ?? EXIT_CODES.Failure;
+}
 function escapeNonAscii(jsonText) {
   return jsonText.replace(/[\u0080-\uffff]/g, (c) => {
     const hex = c.charCodeAt(0).toString(16).padStart(4, "0");
@@ -5306,8 +5526,8 @@ function carriesOnlyNulls(value) {
   }
   return false;
 }
-function nameList(names, cap2 = 12) {
-  const shown = names.slice(0, cap2).map((n) => `\`${n}\``);
+function nameList(names, cap = 12) {
+  const shown = names.slice(0, cap).map((n) => `\`${n}\``);
   const rest = names.length - shown.length;
   return shown.join(", ") + (rest > 0 ? `, and ${rest} more` : "");
 }
@@ -5444,40 +5664,11 @@ function defaultErrorCodeForResult(result) {
       return "unknown_error";
   }
 }
-function parseHttpStatusFromMessage2(message) {
-  const match = /^HTTP\s+(\d{3})(?::|\s|-|$)/i.exec(message.trim());
-  if (!match)
-    return;
-  const status = Number(match[1]);
-  return Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
-}
-function defaultErrorCodeForHttpStatus(status) {
-  if (status === undefined)
-    return;
-  if (status === 400 || status === 409 || status === 422) {
-    return "invalid_argument";
-  }
-  if (status === 401)
-    return "authentication_required";
-  if (status === 403)
-    return "permission_denied";
-  if (status === 404)
-    return "not_found";
-  if (status === 405)
-    return "method_not_allowed";
-  if (status === 408)
-    return "timeout";
-  if (status === 429)
-    return "rate_limited";
-  if (status >= 500 && status < 600)
-    return "server_error";
-  return;
-}
 var LOCAL_PERMISSION_TEXT_PATTERN = new RegExp(`(?:\\b|\\()(?:${[...LOCAL_PERMISSION_ERROR_CODES].join("|")})(?::\\s|\\))`);
 function defaultErrorCodeForFailure(data) {
   if (data.Result === RESULTS.Failure) {
-    const status = data.Context?.httpStatus ?? parseHttpStatusFromMessage2(data.Message);
-    const errorCode = defaultErrorCodeForHttpStatus(status);
+    const status = data.Context?.httpStatus ?? parseHttpStatusFromMessage(data.Message);
+    const errorCode = classifyHttpStatus(status)?.errorCode;
     if (errorCode)
       return errorCode;
     if (status === undefined && (LOCAL_PERMISSION_TEXT_PATTERN.test(data.Message) || LOCAL_PERMISSION_TEXT_PATTERN.test(data.Instructions))) {
@@ -5486,17 +5677,6 @@ function defaultErrorCodeForFailure(data) {
   }
   return defaultErrorCodeForResult(data.Result);
 }
-function defaultRetryForErrorCode(errorCode) {
-  switch (errorCode) {
-    case "network_error":
-    case "rate_limited":
-    case "server_error":
-    case "timeout":
-      return "RetryLater";
-    default:
-      return "RetryWillNotFix";
-  }
-}
 var OutputFormatter;
 ((OutputFormatter) => {
   function success(data, options) {
@@ -5528,7 +5708,7 @@ var OutputFormatter;
     data.Log ??= getLogFilePath() || undefined;
     data.ErrorCode ??= defaultErrorCodeForFailure(data);
     data.Retry ??= defaultRetryForErrorCode(data.ErrorCode);
-    const exitCode = EXIT_CODES[data.Result] ?? 1;
+    const exitCode = exitCodeForResult(data.Result);
     setExitCode(exitCode);
     recordCommandFailureTelemetry({
       result: data.Result,
@@ -5623,21 +5803,227 @@ var OutputFormatter;
   OutputFormatter.formatToString = formatToString;
 })(OutputFormatter ||= {});
 
-// ../../node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
+// ../common/src/pass-through-tail.ts
+function maybeOption(arg) {
+  return arg.length > 1 && arg[0] === "-";
+}
+function tokenizeTail(cmd, tail) {
+  const find = (flag) => cmd.options.find((option) => option.long === flag || option.short === flag);
+  const digitShort = cmd.options.some((option) => option.short !== undefined && /^-\d$/.test(option.short));
+  const negativeNumber = (arg) => !digitShort && /^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(arg);
+  const tokens = [];
+  let firstUnknown = -1;
+  let sentinel = -1;
+  let variadic;
+  let group;
+  let groupIndex = 0;
+  let i = 0;
+  while (i < tail.length || group !== undefined) {
+    const index = group === undefined ? i : groupIndex;
+    const arg = group ?? tail[i++];
+    group = undefined;
+    if (arg === "--") {
+      sentinel = index;
+      tokens.push({ kind: "sentinel", index });
+      for (let j = i;j < tail.length; j++) {
+        tokens.push({
+          kind: "operand",
+          index: j,
+          text: tail[j],
+          literal: true
+        });
+      }
+      break;
+    }
+    if (variadic && (!maybeOption(arg) || negativeNumber(arg))) {
+      tokens.push({
+        kind: "option",
+        index,
+        text: arg,
+        option: variadic,
+        value: arg
+      });
+      continue;
+    }
+    variadic = undefined;
+    if (maybeOption(arg)) {
+      const option = find(arg);
+      if (option) {
+        let value;
+        if (option.required) {
+          value = tail[i];
+          if (value !== undefined)
+            i++;
+        } else if (option.optional) {
+          const next = tail[i];
+          if (next !== undefined && (!maybeOption(next) || negativeNumber(next))) {
+            value = next;
+            i++;
+          }
+        }
+        tokens.push({
+          kind: "option",
+          index,
+          text: arg,
+          option,
+          ...value === undefined ? {} : { value }
+        });
+        variadic = option.variadic ? option : undefined;
+        continue;
+      }
+    }
+    if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
+      const option = find(`-${arg[1]}`);
+      if (option) {
+        if (option.required || option.optional) {
+          tokens.push({
+            kind: "option",
+            index,
+            text: arg,
+            option,
+            value: arg.slice(2)
+          });
+        } else {
+          tokens.push({ kind: "option", index, text: arg, option });
+          group = `-${arg.slice(2)}`;
+          groupIndex = index;
+        }
+        continue;
+      }
+    }
+    if (/^--[^=]+=/.test(arg)) {
+      const equals = arg.indexOf("=");
+      const option = find(arg.slice(0, equals));
+      if (option && (option.required || option.optional)) {
+        tokens.push({
+          kind: "option",
+          index,
+          text: arg,
+          option,
+          value: arg.slice(equals + 1)
+        });
+        continue;
+      }
+    }
+    if (maybeOption(arg) && !negativeNumber(arg)) {
+      const equals = arg.startsWith("--") ? arg.indexOf("=") : -1;
+      if (firstUnknown === -1)
+        firstUnknown = index;
+      tokens.push({
+        kind: "unknown",
+        index,
+        text: arg,
+        flag: equals > 0 ? arg.slice(0, equals) : arg,
+        ...equals > 0 ? { inlineValue: arg.slice(equals + 1) } : {}
+      });
+      continue;
+    }
+    tokens.push({ kind: "operand", index, text: arg, literal: false });
+  }
+  return { tokens, firstUnknown, sentinel };
+}
+
+// ../common/src/project-telemetry.ts
+var RESOLVER = Symbol.for("@uipath/common/projectTelemetryResolver");
+var CAPTURE = Symbol.for("@uipath/common/projectTelemetryCapture");
+var CONTEXT_RESOLVER = Symbol.for("@uipath/common/projectContextTelemetryResolver");
+var RULES = Symbol.for("@uipath/common/projectTargetRules");
+function logSkipped(what, error) {
+  logger.debug(`[project-telemetry] ${what} skipped: ${error instanceof Error ? error.message : String(error)}`);
+}
+function bounded(work, what) {
+  return withinProjectIdentityBudget(work, () => logSkipped(what, `no answer within ${PROJECT_IDENTITY_LOOKUP_BUDGET_MS} ms`));
+}
+async function identityWithContext(command, identity) {
+  const props = projectIdentityProperties(identity);
+  if (!identity.projectDirectory || isProjectTelemetryDisabled())
+    return props;
+  for (let node = command;node; node = node.parent ?? undefined) {
+    const resolver = node[CONTEXT_RESOLVER];
+    if (typeof resolver !== "function")
+      continue;
+    try {
+      return {
+        ...await resolver(identity.projectDirectory),
+        ...props
+      };
+    } catch (error) {
+      logSkipped("solution context lookup", error);
+      return props;
+    }
+  }
+  return props;
+}
+function getProjectTelemetryResolver(command) {
+  for (let node = command;node; node = node.parent) {
+    const resolver = node[RESOLVER];
+    if (typeof resolver === "function")
+      return resolver;
+  }
+  return;
+}
+function attachProjectTelemetryCapture(command, capture) {
+  command[CAPTURE] = capture;
+}
+class ProjectTelemetrySession {
+  resolver;
+  command;
+  target;
+  props = {};
+  explicit = false;
+  input;
+  constructor(resolver, command) {
+    this.resolver = resolver;
+    this.command = command;
+  }
+  async setTarget(path) {
+    this.target = path;
+    if (this.input) {
+      await this.resolve({
+        ...this.input,
+        phase: "after",
+        success: true
+      });
+      this.explicit = true;
+    }
+  }
+  async setIdentity(identity) {
+    try {
+      const props = await bounded(identityWithContext(this.command, identity), "project identity capture");
+      if (props !== undefined)
+        this.setProperties(props);
+    } catch (error) {
+      logSkipped("project identity capture", error);
+    }
+  }
+  setProperties(properties) {
+    try {
+      this.props = { ...properties };
+      this.explicit = true;
+    } catch (error) {
+      logSkipped("project identity properties", error);
+    }
+  }
+  properties() {
+    return { ...this.props };
+  }
+  async resolve(input) {
+    this.input = input;
+    if (this.explicit)
+      return;
+    try {
+      const props = await bounded(this.resolver({
+        ...input,
+        target: this.target
+      }), `project identity (${input.phase})`);
+      if (props !== undefined) {
+        this.props = props;
+      }
+    } catch (error) {
+      logSkipped(`project identity (${input.phase})`, error);
+    }
+  }
+}
 
 // ../common/src/telemetry/command-attribution.ts
 var LEGACY_SKILL_NAMESPACE = "uipath:";
@@ -5883,8 +6269,7 @@ var pollSignalSlot = singleton("PollSignal");
 var TELEMETRY_COMMAND_ARG_PREFIX = "uip.cmd.arg.";
 var processContext = {
   exit: (code) => {
-    recordExitCode(code);
-    setExitCode(code);
+    recordCommandExit(code);
   },
   get pollSignal() {
     return pollSignalSlot.get();
@@ -5909,6 +6294,8 @@ function recordableArgValue(value, choices) {
 function extractCommandParams(cmd) {
   const params = {};
   forEachSuppliedArgument(cmd, (name, value, choices, defaulted) => {
+    if (name === undefined)
+      return;
     const recordable = recordableArgValue(value, choices);
     params[`${TELEMETRY_COMMAND_ARG_PREFIX}${name}`] = recordable === TELEMETRY_ARG_VALUE_WITHHELD && defaulted ? TELEMETRY_ARG_VALUE_DEFAULTED : recordable;
   });
@@ -5924,7 +6311,8 @@ function isDefaultedPositional(cmd, index) {
 function forEachSuppliedArgument(cmd, visit) {
   const registered = cmd.registeredArguments ?? [];
   const processed = cmd.processedArgs ?? [];
-  for (let i = 0;i < registered.length; i++) {
+  const bound = boundPositionalCount(cmd);
+  for (let i = 0;i < bound; i++) {
     const name = registered[i].name();
     if (name && processed[i] !== undefined) {
       visit(name, processed[i], registered[i].argChoices, isDefaultedPositional(cmd, i));
@@ -5939,6 +6327,71 @@ function forEachSuppliedArgument(cmd, visit) {
       visit(key, value, choicesByAttribute.get(key), isDefaultedOption(cmd, key));
     }
   }
+  forEachPassThroughToken(cmd, bound, (name, value) => {
+    visit(name, value, name === undefined ? undefined : choicesByAttribute.get(name), false);
+  });
+}
+function boundPositionalCount(cmd) {
+  const registered = cmd.registeredArguments ?? [];
+  if (registered.some((argument) => argument.variadic)) {
+    return registered.length;
+  }
+  if ((cmd.args ?? []).length <= registered.length) {
+    return registered.length;
+  }
+  const firstFlag = tokenizeTail(cmd, (cmd.args ?? []).slice(1)).tokens.find((token) => token.kind !== "operand")?.index ?? -1;
+  return firstFlag === -1 ? registered.length : Math.min(registered.length, firstFlag + 1);
+}
+function forEachPassThroughToken(cmd, bound, visit) {
+  const registered = cmd.registeredArguments ?? [];
+  const fillsPositionals = !registered.some((argument) => argument.variadic);
+  const { tokens, firstUnknown } = tokenizeTail(cmd, (cmd.args ?? []).slice(bound));
+  const repeated = new Map;
+  let nextPositional = bound;
+  for (const token of tokens) {
+    const pastUnknown = firstUnknown !== -1 && token.index > firstUnknown;
+    if (token.kind === "sentinel")
+      continue;
+    if (token.kind === "operand") {
+      const claimable = !pastUnknown && fillsPositionals && nextPositional < registered.length;
+      const name = claimable ? registered[nextPositional++].name() : undefined;
+      visit(name || undefined, token.text);
+      continue;
+    }
+    if (token.kind === "unknown") {
+      const bare = token.flag.replace(/^-+/, "");
+      const key = bare.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      const keyable = token.flag.startsWith("--") || token.flag.length === 2;
+      if (!pastUnknown && keyable && /^[a-z][a-z0-9-]*$/i.test(bare) && key) {
+        visit(key, token.inlineValue ?? true);
+      } else {
+        visit(undefined, token.text);
+        if (token.inlineValue !== undefined) {
+          visit(undefined, token.inlineValue);
+        } else if (!token.flag.startsWith("--") && token.flag.length > 2) {
+          visit(undefined, token.flag.slice(2));
+        }
+      }
+      continue;
+    }
+    if (pastUnknown) {
+      visit(undefined, token.text);
+      if (token.value !== undefined)
+        visit(undefined, token.value);
+      continue;
+    }
+    const option = token.option;
+    const name = option.attributeName();
+    const value = option.negate ? false : option.required || option.optional ? token.value ?? true : true;
+    const previous = repeated.get(name);
+    if (previous) {
+      previous.push(value);
+      visit(name, previous);
+    } else {
+      repeated.set(name, [value]);
+      visit(name, value);
+    }
+  }
 }
 function withheldArgumentValues(cmd) {
   const values = [];
@@ -6000,6 +6453,8 @@ Command.prototype.trackedAction = function(context, fn, properties) {
     const telemetryName = commandTelemetryName(commandParts);
     const commandPath = commandInvocationPath(commandParts);
     const props = typeof properties === "function" ? properties(...args) : properties;
+    const projectResolver = getProjectTelemetryResolver(command);
+    const projectSession = projectResolver && !isProjectTelemetryDisabled() ? new ProjectTelemetrySession(projectResolver, command) : undefined;
     markCommandStart();
     const supplied = recordSuppliedArgumentValues(withheldArgumentValues(command));
     try {
@@ -6012,6 +6467,12 @@ Command.prototype.trackedAction = function(context, fn, properties) {
         if (violation) {
           return Promise.reject(violation);
         }
+        if (projectSession) {
+          return projectSession.resolve({ command, args, phase: "before" }).then(() => {
+            attachProjectTelemetryCapture(command, projectSession);
+            return fn(...args);
+          });
+        }
         return fn(...args);
       }));
       if (error) {
@@ -6020,22 +6481,26 @@ Command.prototype.trackedAction = function(context, fn, properties) {
         const typed = error;
         const customInstructions = typeof typed.instructions === "string" ? typed.instructions : undefined;
         const customResult = typeof typed.result === "string" && typed.result !== RESULTS.Success && Object.values(RESULTS).includes(typed.result) ? typed.result : undefined;
-        const finalResult = customResult ?? RESULTS.Failure;
+        const cancellationExitCode = typed.exitCode === 130 || isPromptCancellation(error) ? 130 : undefined;
+        const classified = cancellationExitCode === undefined ? await extractErrorDetails(error) : undefined;
+        const finalResult = customResult ?? classified?.result ?? RESULTS.Failure;
         const typedErrorCode = typed.errorCode ?? typed.ErrorCode;
         const customErrorCode = isCliErrorCode(typedErrorCode) ? typedErrorCode : undefined;
         const typedRetry = typed.retry ?? typed.Retry;
         const customRetry = isRetryHint(typedRetry) ? typedRetry : undefined;
         const typedContext = typed.context ?? typed.Context;
         const customContext = isErrorContext(typedContext) ? typedContext : undefined;
-        const cancellationExitCode = typed.exitCode === 130 || isPromptCancellation(error) ? 130 : undefined;
         fallbackExitCode = cancellationExitCode ?? EXIT_CODES[finalResult];
+        const errorCode = customErrorCode ?? classified?.errorCode;
+        const retry = customRetry ?? classified?.retry;
+        const errorContext = customContext ?? classified?.context;
         OutputFormatter.error({
           Result: finalResult,
-          ...customErrorCode ? { ErrorCode: customErrorCode } : {},
+          ...errorCode ? { ErrorCode: errorCode } : {},
           Message: errorMessage,
           Instructions: customInstructions ?? commandHelpHint(commandPath),
-          ...customRetry ? { Retry: customRetry } : {},
-          ...customContext ? { Context: customContext } : {}
+          ...retry ? { Retry: retry } : {},
+          ...errorContext ? { Context: errorContext } : {}
         });
         context.exit(fallbackExitCode);
       }
@@ -6044,6 +6509,14 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       const exitCode = fallbackExitCode === 130 ? fallbackExitCode : exitCodeFromProcess(fallbackExitCode);
       const recordedFailure = takeRecordedCommandFailureTelemetry();
       const success = !error && exitCode === 0;
+      if (projectSession) {
+        await projectSession.resolve({
+          command,
+          args,
+          phase: "after",
+          success
+        });
+      }
       const terminalTelemetry = buildCommandTerminalTelemetryProperties({
         error,
         exitCode,
@@ -6061,6 +6534,7 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       }
       const baseProperties = redactProperties({
         ...commandParams,
+        ...projectSession?.properties(),
         ...props,
         ...buildCommandTelemetryAttribution(commandPath, process.env.UIPATH_SKILL),
         ...buildAgentSessionTelemetry(process.env),
@@ -6071,6 +6545,8 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       });
       emitInvocationRequest(telemetryName, success, baseProperties);
     } finally {
+      if (projectSession)
+        attachProjectTelemetryCapture(command, undefined);
       releaseSuppliedArgumentValues(supplied);
     }
   });
@@ -6085,7 +6561,7 @@ function isGuid(value) {
 async function classifiedFailure(message, error) {
   const details = await extractErrorDetails(error);
   return {
-    Result: RESULTS.Failure,
+    Result: details.result,
     ErrorCode: details.errorCode,
     Message: message,
     Instructions: details.message,
@@ -6726,9 +7202,9 @@ function getProfileStorage() {
   if (isAuthProfileStorage(existing)) {
     return existing;
   }
-  const storage2 = createProfileStorage();
-  globalSlot[AUTH_PROFILE_STORAGE_KEY] = storage2;
-  return storage2;
+  const storage = createProfileStorage();
+  globalSlot[AUTH_PROFILE_STORAGE_KEY] = storage;
+  return storage;
 }
 var profileStorage = getProfileStorage();
 
@@ -6759,8 +7235,8 @@ function resolveAuthProfileFilePath(profile) {
   if (normalized === undefined) {
     throw new AuthProfileValidationError(`"${DEFAULT_AUTH_PROFILE}" is the built-in profile and does not have a profile file path.`);
   }
-  const fs2 = getFileSystem();
-  return fs2.path.join(fs2.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR, normalized, AUTH_FILENAME);
+  const fs = getFileSystem();
+  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR, normalized, AUTH_FILENAME);
 }
 function getActiveAuthProfileFilePath() {
   const profile = getActiveAuthProfile();
@@ -6867,6 +7343,8 @@ var ENV_AUTH_VARS = {
 };
 
 class EnvAuthConfigError extends Error {
+  errorCode = "configuration_error";
+  retry = "RetryWillNotFix";
   constructor(message) {
     super(message);
     this.name = "EnvAuthConfigError";
@@ -6905,11 +7383,11 @@ var readAuthFromEnv = () => {
     if (!rawUrl) {
       throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} is not a JWT (treating it as an opaque token, ` + `e.g. a Personal Access Token). Set ${OPAQUE_TOKEN_BASE_URL_VAR} to the ` + `UiPath base URL if this is a PAT, or fix the token if it was meant to ` + `be a JWT (parse error: ${parseErrorMessage}).`);
     }
-    const baseUrl2 = resolveBaseUrl(rawUrl, `Failed to validate ${OPAQUE_TOKEN_BASE_URL_VAR}`);
+    const baseUrl = resolveBaseUrl(rawUrl, `Failed to validate ${OPAQUE_TOKEN_BASE_URL_VAR}`);
     return {
       loginStatus: "Logged in",
       accessToken,
-      baseUrl: baseUrl2,
+      baseUrl,
       organizationName,
       organizationId,
       tenantName,
@@ -6950,8 +7428,8 @@ var SURFACE_WINDOW_MS = 60 * 60 * 1000;
 async function refreshTokenFingerprint(refreshToken) {
   const bytes = new TextEncoder().encode(refreshToken);
   if (globalThis.crypto?.subtle) {
-    const digest2 = await globalThis.crypto.subtle.digest("SHA-256", bytes);
-    return Array.from(new Uint8Array(digest2), (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
   }
   const { createHash } = await import("node:crypto");
   return createHash("sha256").update(refreshToken).digest("hex").slice(0, 16);
@@ -6960,9 +7438,9 @@ function breakerPathFor(authPath) {
   return `${authPath}${BREAKER_SUFFIX}`;
 }
 async function loadRefreshBreaker(authPath) {
-  const fs2 = getFileSystem();
+  const fs = getFileSystem();
   try {
-    const content = await fs2.readFile(breakerPathFor(authPath), "utf-8");
+    const content = await fs.readFile(breakerPathFor(authPath), "utf-8");
     if (!content)
       return {};
     const parsed = JSON.parse(content);
@@ -6973,20 +7451,20 @@ async function loadRefreshBreaker(authPath) {
 }
 async function saveRefreshBreaker(authPath, state) {
   try {
-    const fs2 = getFileSystem();
-    const path2 = breakerPathFor(authPath);
-    await fs2.mkdir(fs2.path.dirname(path2));
-    const tempPath = `${path2}.tmp`;
-    await fs2.writeFile(tempPath, JSON.stringify(state));
-    await fs2.rename(tempPath, path2);
+    const fs = getFileSystem();
+    const path = breakerPathFor(authPath);
+    await fs.mkdir(fs.path.dirname(path));
+    const tempPath = `${path}.tmp`;
+    await fs.writeFile(tempPath, JSON.stringify(state));
+    await fs.rename(tempPath, path);
   } catch {}
 }
 async function clearRefreshBreaker(authPath) {
-  const fs2 = getFileSystem();
-  const path2 = breakerPathFor(authPath);
+  const fs = getFileSystem();
+  const path = breakerPathFor(authPath);
   try {
-    if (await fs2.exists(path2)) {
-      await fs2.rm(path2);
+    if (await fs.exists(path)) {
+      await fs.rm(path);
     }
   } catch {}
 }
@@ -7007,13 +7485,13 @@ var ROBOT_USER_SERVICES_PIPE = "UiPathUserServices";
 var ROBOT_USER_SERVICES_ALTERNATE_PIPE = `${ROBOT_USER_SERVICES_PIPE}Alternate`;
 var PIPE_NAME_MAX_LENGTH = 103;
 var getRobotIpcPipeNames = async () => {
-  const fs2 = getFileSystem();
-  const username = fs2.env.getenv("USER") ?? fs2.env.getenv("USERNAME");
+  const fs = getFileSystem();
+  const username = fs.env.getenv("USER") ?? fs.env.getenv("USERNAME");
   if (!username) {
     throw new Error("Unable to determine current username");
   }
-  const tempPath = fs2.env.getenv("TMPDIR") ?? "/tmp/";
-  return [ROBOT_USER_SERVICES_PIPE, ROBOT_USER_SERVICES_ALTERNATE_PIPE].map((baseName) => fs2.path.join(tempPath, `${baseName}_${username}`).substring(0, PIPE_NAME_MAX_LENGTH));
+  const tempPath = fs.env.getenv("TMPDIR") ?? "/tmp/";
+  return [ROBOT_USER_SERVICES_PIPE, ROBOT_USER_SERVICES_ALTERNATE_PIPE].map((baseName) => fs.path.join(tempPath, `${baseName}_${username}`).substring(0, PIPE_NAME_MAX_LENGTH));
 };
 var defaultIsRobotIpcAvailable = async () => {
   if (process.platform === "win32") {
@@ -7023,20 +7501,20 @@ var defaultIsRobotIpcAvailable = async () => {
   if (pipeNamesError || !pipeNames) {
     return false;
   }
-  const fs2 = getFileSystem();
+  const fs = getFileSystem();
   for (const pipeName of pipeNames) {
-    const [existsError, exists] = await catchError2(fs2.exists(pipeName));
+    const [existsError, exists] = await catchError2(fs.exists(pipeName));
     if (!existsError && exists === true) {
       return true;
     }
   }
   return false;
 };
-var withTimeout = (promise, timeoutMs) => new Promise((resolve2, reject) => {
+var withTimeout = (promise, timeoutMs) => new Promise((resolve, reject) => {
   const timer = setTimeout(() => reject(new Error(`Robot IPC call timed out after ${timeoutMs}ms`)), timeoutMs);
   promise.then((value) => {
     clearTimeout(timer);
-    resolve2(value);
+    resolve(value);
   }, (error) => {
     clearTimeout(timer);
     reject(error);
@@ -7209,9 +7687,12 @@ var refreshAccessToken = async ({
     body: tokenParams
   });
   const tokenData = await tokenResponse.json();
-  if (!tokenResponse.ok) {
+  if (tokenResponse.status === 400 || tokenResponse.status === 401) {
     throw new TokenRefreshOAuthError;
   }
+  if (!tokenResponse.ok) {
+    throw new Error(`Token refresh failed: HTTP ${tokenResponse.status}`);
+  }
   const newAccessToken = tokenData.access_token;
   const newRefreshToken = tokenData.refresh_token;
   if (typeof newAccessToken !== "string" || typeof newRefreshToken !== "string") {
@@ -7243,9 +7724,9 @@ var errorCode = (err) => {
   }
   return "EUNKNOWN";
 };
-var probeAsync = async (fs2, candidate) => {
+var probeAsync = async (fs, candidate) => {
   try {
-    const stats = await fs2.stat(candidate);
+    const stats = await fs.stat(candidate);
     if (stats === null) {
       return { exists: false };
     }
@@ -7272,36 +7753,36 @@ var probeAsync = async (fs2, candidate) => {
   }
 };
 var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
-  const fs2 = getFileSystem();
-  if (fs2.path.isAbsolute(envFilePath)) {
-    const probe2 = await probeAsync(fs2, envFilePath);
-    return probe2.exists ? { exists: true, absolutePath: envFilePath, source: "absolute" } : {
+  const fs = getFileSystem();
+  if (fs.path.isAbsolute(envFilePath)) {
+    const probe = await probeAsync(fs, envFilePath);
+    return probe.exists ? { exists: true, absolutePath: envFilePath, source: "absolute" } : {
       exists: false,
       absolutePath: envFilePath,
       source: "absolute",
-      ...probe2.unusable ? { unusable: probe2.unusable } : {}
+      ...probe.unusable ? { unusable: probe.unusable } : {}
     };
   }
-  const cwd = opts?.cwd ?? fs2.env.cwd();
+  const cwd = opts?.cwd ?? fs.env.cwd();
   let searchDir = cwd;
   while (true) {
-    const candidate = fs2.path.join(searchDir, envFilePath);
-    const probe2 = await probeAsync(fs2, candidate);
-    if (probe2.exists) {
+    const candidate = fs.path.join(searchDir, envFilePath);
+    const probe = await probeAsync(fs, candidate);
+    if (probe.exists) {
       return {
         exists: true,
         absolutePath: candidate,
         source: searchDir === cwd ? "cwd" : "ancestor"
       };
     }
-    const parentDir = fs2.path.dirname(searchDir);
+    const parentDir = fs.path.dirname(searchDir);
     if (parentDir === searchDir) {
       break;
     }
     searchDir = parentDir;
   }
-  const homePath = fs2.path.join(fs2.env.homedir(), envFilePath);
-  const probe = await probeAsync(fs2, homePath);
+  const homePath = fs.path.join(fs.env.homedir(), envFilePath);
+  const probe = await probeAsync(fs, homePath);
   if (probe.exists) {
     return { exists: true, absolutePath: homePath, source: "home" };
   }
@@ -7344,12 +7825,12 @@ var parseEnvContent = (content) => {
   return env;
 };
 var loadEnvFileAsync = async ({ envPath }) => {
-  const fs2 = getFileSystem();
-  const absolutePath = fs2.path.isAbsolute(envPath) ? envPath : fs2.path.join(fs2.env.cwd(), envPath);
-  if (!await fs2.exists(absolutePath)) {
+  const fs = getFileSystem();
+  const absolutePath = fs.path.isAbsolute(envPath) ? envPath : fs.path.join(fs.env.cwd(), envPath);
+  if (!await fs.exists(absolutePath)) {
     throw new Error(`Environment file not found: ${envPath}`);
   }
-  const content = await fs2.readFile(absolutePath, "utf-8");
+  const content = await fs.readFile(absolutePath, "utf-8");
   if (content === null) {
     throw new Error(`Environment file not found: ${envPath}`);
   }
@@ -7360,10 +7841,10 @@ var saveEnvFileAsync = async ({
   data,
   merge = true
 }) => {
-  const fs2 = getFileSystem();
-  const absolutePath = fs2.path.isAbsolute(envPath) ? envPath : fs2.path.join(fs2.env.homedir(), envPath);
+  const fs = getFileSystem();
+  const absolutePath = fs.path.isAbsolute(envPath) ? envPath : fs.path.join(fs.env.homedir(), envPath);
   let existingData = {};
-  if (merge && await fs2.exists(absolutePath)) {
+  if (merge && await fs.exists(absolutePath)) {
     try {
       existingData = await loadEnvFileAsync({ envPath: absolutePath });
     } catch {}
@@ -7381,11 +7862,11 @@ var saveEnvFileAsync = async ({
   const content = `${lines.join(`
 `)}
 `;
-  const dir = fs2.path.dirname(absolutePath);
-  await fs2.mkdir(dir);
+  const dir = fs.path.dirname(absolutePath);
+  await fs.mkdir(dir);
   const tempPath = `${absolutePath}.tmp`;
-  await fs2.writeFile(tempPath, content);
-  await fs2.rename(tempPath, absolutePath);
+  await fs.writeFile(tempPath, content);
+  await fs.rename(tempPath, absolutePath);
 };
 
 // ../auth/src/loginStatus.ts
@@ -7509,11 +7990,11 @@ async function loadFileCredentials(loadEnvFile, absolutePath) {
   return { credentials };
 }
 async function getGlobalCredsHint(getFs, loadEnvFile, absolutePath, envFilePath) {
-  const fs2 = getFs();
-  const globalPath = fs2.path.join(fs2.env.homedir(), envFilePath);
+  const fs = getFs();
+  const globalPath = fs.path.join(fs.env.homedir(), envFilePath);
   if (absolutePath === globalPath)
     return;
-  if (!await fs2.exists(globalPath))
+  if (!await fs.exists(globalPath))
     return;
   try {
     const globalCreds = await loadEnvFile({ envPath: globalPath });
@@ -7930,26 +8411,38 @@ function errorMessage(error) {
 }
 
 // ../auth/src/authContext.ts
+class AuthContextUnavailableError extends Error {
+  instructionContext;
+  sessionHint;
+  errorCode = "authentication_required";
+  retry = "RetryWillNotFix";
+  constructor(message, instructionContext = "auth", sessionHint) {
+    super(message);
+    this.instructionContext = instructionContext;
+    this.sessionHint = sessionHint;
+    this.name = "AuthContextUnavailableError";
+  }
+}
 var getAuthContext = async (options = {}) => {
   const status = await getLoginStatusAsync({
     ensureTokenValidityMinutes: options.ensureTokenValidityMinutes,
     envFilePath: options.envFilePath
   });
   if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
-    throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
+    throw new AuthContextUnavailableError(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.", "auth", status.hint);
   }
-  const tenantName = options.tenant ?? status.tenantName;
+  const tenantName = options.tenant || status.tenantName;
   if (options.requireOrganizationId && !status.organizationId) {
-    throw new Error("Organization ID not available. Ensure you are logged in with an organization context.");
+    throw new AuthContextUnavailableError("Organization ID not available. Ensure you are logged in with an organization context.", "identity");
   }
   if (options.requireOrganizationName && !status.organizationName) {
-    throw new Error("Organization name not available. Ensure you are logged in with an organization context.");
+    throw new AuthContextUnavailableError("Organization name not available. Ensure you are logged in with an organization context.", "identity");
   }
   if (options.requireTenantId && !status.tenantId) {
-    throw new Error("Tenant ID not available. Ensure UIPATH_TENANT_ID is set.");
+    throw new AuthContextUnavailableError(`Tenant ID not available. Ensure UIPATH_TENANT_ID is set.${status.hint ? ` ${status.hint}` : ""}`, "identity", status.hint);
   }
-  if (options.requireTenantName && tenantName === undefined) {
-    throw new Error("Tenant not provided and UIPATH_TENANT_NAME not set. Run 'uip login' to select a tenant, or use 'uip login tenant set <tenant>' to switch tenants.");
+  if (options.requireTenantName && !tenantName) {
+    throw new AuthContextUnavailableError("Tenant not provided and UIPATH_TENANT_NAME not set. Run 'uip login' to select a tenant, or use 'uip login tenant set <tenant>' to switch tenants.", "identity");
   }
   return {
     baseUrl: status.baseUrl,
@@ -7968,6 +8461,6 @@ var TENANT_SELECTION_CODES = new Set([
   TENANT_SELECTION_REQUIRED_CODE,
   INVALID_TENANT_CODE
 ]);
-export { catchError, extractErrorMessage, extractErrorMessageSync, RESULTS, OutputFormatter, classifiedFailure, Command, Option, processContext, isGuid, createHiddenDeprecatedTenantOption, getSdkUserAgentToken, addSdkUserAgentHeader, installSdkUserAgentHeader, resolveSessionIdentity, getLoginStatusAsync, getAuthContext };
+export { catchError, extractErrorMessage, extractErrorMessageSync, RESULTS, classifiedFailure, Command, Option, logger, OutputFormatter, processContext, isGuid, createHiddenDeprecatedTenantOption, getSdkUserAgentToken, addSdkUserAgentHeader, installSdkUserAgentHeader, resolveSessionIdentity, getAuthContext };
 
-//# debugId=F7E91F021C30087964756E2164756E21
+//# debugId=DC8DA3AE9647698264756E2164756E21