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

package/dist/{tool-z9y4f8vc.js → tool-pza7kpcz.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"];
@@ -2076,32 +2077,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.Command = Command;
   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;
-});
 // package.json
 var package_default = {
   name: "@uipath/traces-tool",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.205.0-preview.281",
+  version: "1.206.0-preview.282",
   description: "Query execution traces for UiPath jobs",
   private: false,
   publishConfig: {
@@ -2123,6 +2104,7 @@ var package_default = {
   ],
   scripts: {
     build: "bun ../../tools/build-tool.ts",
+    typecheck: "tsc --noEmit",
     package: "bun run build && bun pm pack",
     lint: "biome check .",
     "lint:fix": "biome check --write .",
@@ -2141,7 +2123,7 @@ var package_default = {
 };
 
 // ../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";
@@ -2152,6 +2134,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 = {
@@ -2170,7 +2155,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);
     }
   };
@@ -2209,6 +2194,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);
@@ -2216,7 +2210,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))
@@ -2330,6 +2325,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);
@@ -2380,6 +2411,208 @@ class NodeFileSystem {
 var fsInstance = new NodeFileSystem;
 var getFileSystem = () => fsInstance;
 
+// ../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:";
 var PSEUDONYM_HEX_LENGTH = 32;
@@ -2748,8 +2981,8 @@ function redactValueDetectors(value, maxLength = MAX_VALUE_LENGTH) {
     return `${redactUrl(core)}${trailing}`;
   });
   out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
-  out = out.replace(UNC_PATH_PATTERN, (_match, before, path2) => {
-    const [core, trailing] = peelTrailingPunctuation(path2);
+  out = out.replace(UNC_PATH_PATTERN, (_match, before, path) => {
+    const [core, trailing] = peelTrailingPunctuation(path);
     return `${before}unc#${pseudonymize(core)}${trailing}`;
   });
   out = out.replace(EMAIL_PATTERN, (match) => `email#${pseudonymize(match)}`);
@@ -2843,6 +3076,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;
   }
@@ -2917,6 +3152,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];
@@ -2961,18 +3253,54 @@ function findHttpStatusInGraph(error) {
   return;
 }
 
-// ../common/src/local-permission-codes.ts
-var LOCAL_PERMISSION_ERROR_CODES = new Set([
-  "EACCES",
-  "EPERM",
-  "EROFS"
-]);
-
-// ../common/src/error-handler.ts
-var DEFAULT_401 = "Unauthorized (401). The session is missing or expired, or its token carries no scope for this API. Run `uip login status --detailed` to see the session and its scopes.";
-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.";
+// ../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",
+  "EPERM",
+  "EROFS"
+]);
+
+// ../common/src/error-handler.ts
+var DEFAULT_401 = "Unauthorized (401). The session is missing or expired, or its token carries no scope for this API. Run `uip login status --detailed` to see the session and its scopes.";
+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",
@@ -2998,8 +3326,8 @@ var TLS_ERROR_CODES = new Set([
 var TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most often a " + "corporate proxy/firewall re-signs HTTPS with a root CA that Node does " + "not trust — set NODE_EXTRA_CA_CERTS to that CA's PEM file (and HTTPS_PROXY " + "if you connect through a proxy). If the certificate is instead expired or " + "its hostname does not match, fix the endpoint URL or the system clock. " + "Then retry.";
 var NETWORK_INSTRUCTIONS = "Could not reach the UiPath service. Check your network connection and " + "VPN, confirm any HTTP_PROXY/HTTPS_PROXY/NO_PROXY settings are correct, " + "then retry.";
 var LOCAL_PERMISSION_MESSAGE_PATTERN = new RegExp(`\\b(${[...LOCAL_PERMISSION_ERROR_CODES].join("|")})\\b`);
-function localPermissionInstructions(code, path2) {
-  const target = path2 !== undefined ? `'${path2}'` : "a local file or resource";
+function localPermissionInstructions(code, path) {
+  const target = path !== undefined ? `'${path}'` : "a local file or resource";
   if (code === "EROFS") {
     return `The filesystem containing ${target} is read-only (EROFS), so the ` + "CLI could not write to it. This is a local environment problem, " + "not a UiPath service error — retrying will not help. Use a " + "writable location, or give this environment write access to the " + "path.";
   }
@@ -3036,12 +3364,12 @@ function describePermissionError(error) {
     const code = matchLocalPermissionCode(cur.code, message);
     if (!code)
       continue;
-    const path2 = localPermissionPath(cur.path, message);
+    const path = localPermissionPath(cur.path, message);
     return {
       code,
       message: message ?? code,
-      ...path2 !== undefined ? { path: path2 } : {},
-      instructions: localPermissionInstructions(code, path2)
+      ...path !== undefined ? { path } : {},
+      instructions: localPermissionInstructions(code, path)
     };
   }
   return;
@@ -3053,11 +3381,25 @@ function matchLocalPermissionCode(code, message) {
   const match = message ? LOCAL_PERMISSION_MESSAGE_PATTERN.exec(message) : null;
   return match ? match[1] : undefined;
 }
-function localPermissionPath(path2, message) {
-  if (typeof path2 === "string")
-    return path2;
+function localPermissionPath(path, message) {
+  if (typeof path === "string")
+    return path;
   return message ? /'([^']+)'/.exec(message)?.[1] : undefined;
 }
+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);
 }
@@ -3074,36 +3416,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",
@@ -3119,6 +3434,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}`;
@@ -3174,9 +3500,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";
@@ -3224,7 +3555,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)
@@ -3258,6 +3591,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;
@@ -3266,16 +3601,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)) {
@@ -3309,9 +3635,8 @@ async function extractErrorDetails(error, options) {
   }
   return {
     result,
-    errorCode: classification.errorCode,
+    ...withCarriedClass({ errorCode: classification.errorCode, retry }, error),
     message,
-    retry,
     details,
     ...hasContext ? { context } : {},
     ...parsedErrors ? { parsedErrors } : {}
@@ -3321,10 +3646,169 @@ async function extractErrorMessage(error, options) {
   const { message } = await extractErrorDetails(error, options);
   return message;
 }
-// ../common/src/exit-code.ts
-function setExitCode(code) {
-  process.exitCode = code;
+// ../common/src/error-instructions.ts
+function extractHttpStatus(err) {
+  if (!err || typeof err !== "object")
+    return;
+  const e = err;
+  const structured = e.response?.status ?? e.status ?? e.statusCode;
+  if (structured !== undefined)
+    return structured;
+  return typeof e.message === "string" ? parseHttpStatusFromMessage(e.message) : undefined;
+}
+var GENERIC = "Check authentication and parameters";
+function hasIdentityInstructionContext(err) {
+  return err !== null && typeof err === "object" && "instructionContext" in err && err.instructionContext === "identity";
+}
+function instructionsFor(ctx, err) {
+  if (ctx === "auth" && hasIdentityInstructionContext(err)) {
+    return instructionsFor("identity");
+  }
+  switch (ctx) {
+    case "auth":
+      return "Run 'uip login' to authenticate. To inspect the current session, run 'uip whoami'.";
+    case "auth-configuration":
+      return "Fix the authentication settings named in Message, then retry.";
+    case "identity":
+      return "Select an active tenant with 'uip login tenant set <tenant>' and ensure your login includes an organization";
+    case "input-parse":
+      return "Ensure --inputs is valid JSON or pipe JSON via stdin";
+    case "input-validate":
+      return "Fix the flagged input fields to match the process's input schema";
+    case "flag-format":
+      return "Check the flag value format — see --help for the expected shape";
+    case "permissions":
+      return "Confirm your user has the required permissions in this folder/tenant, or re-authenticate with 'uip login' if your session has lapsed";
+    case "backend": {
+      const status = extractHttpStatus(err);
+      if (status === 401) {
+        return "Re-authenticate with 'uip login' — your session is invalid or expired";
+      }
+      if (status === 403) {
+        return "Confirm your user has access to the resource, and the required permissions in this folder or tenant";
+      }
+      if (status === 404) {
+        return "Verify the resource exists in the current folder/tenant";
+      }
+      if (status === 400 || status === 422) {
+        return "Request was rejected — check flag values and inputs";
+      }
+      if (status === 405) {
+        return "Check the command name and the base URL in use — the endpoint may not exist";
+      }
+      if (status === 408) {
+        return "The request timed out — retry; if it persists, narrow the request (e.g. --limit on list commands)";
+      }
+      if (status === 409) {
+        return "The resource already exists, or changed since it was read — list it to see the current state";
+      }
+      if (status === 413) {
+        return "The upload is over the size limit — exclude unused dependencies or drop large files, then retry";
+      }
+      if (status === 429) {
+        return "Rate limit reached — wait and retry; when the service suggests a delay, Retry and Context.retryAfter carry it";
+      }
+      if (status !== undefined && status >= 500 && status < 600) {
+        return "The service returned a server error — retry; if it persists, check service status";
+      }
+      const permission = describePermissionError(err);
+      if (permission) {
+        return permission.instructions;
+      }
+      const connectivity = describeConnectivityError(err);
+      if (connectivity) {
+        return connectivity.instructions;
+      }
+      return GENERIC;
+    }
+  }
+}
+
+// ../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 } = require_option();
+var $program = new Command2;
+var $createCommand = (name) => new Command2(name);
+var $createOption = (flags, description) => new Option(flags, description);
+var $createArgument = (name, description) => new Argument(name, description);
+var $Command = Command2;
+var $Option = Option;
+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: Option2,
+  Help: Help2
+} = exports_commander;
+
+// ../common/src/command-examples.ts
+var examplesByCommand = new WeakMap;
+Command.prototype.examples = function(examples) {
+  examplesByCommand.set(this, examples);
+  return this;
+};
+// ../common/src/preview.ts
+var previewSlot = singleton("PreviewBuild");
+function isPreviewBuild() {
+  return previewSlot.get(false) ?? false;
 }
+Command.prototype.previewCommand = function(nameAndArgs, opts) {
+  if (isPreviewBuild()) {
+    return this.command(nameAndArgs, opts);
+  }
+  return new Command(nameAndArgs.split(/\s+/)[0] ?? nameAndArgs);
+};
 
 // ../common/src/output-context.ts
 function createStorage() {
@@ -3359,8 +3843,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("");
@@ -3428,14 +3912,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()) {
@@ -3485,17 +3969,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;
@@ -3543,189 +4027,133 @@ function getLogFilePath() {
   return logger.getLogFilePath();
 }
 
-// ../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) => {
-      yamlSlot.set(mod);
-    }));
+// ../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()
+    };
   }
-  if (needed.filter && jmespathSlot.get() === undefined) {
-    loads.push(import("./jmespath-231m3hyn.js").then((m)=>__toESM(m.default,1)).then((mod) => {
-      jmespathSlot.set(mod);
-    }));
+  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;
   }
-  await Promise.all(loads);
+  const pinned = livePinnedState();
+  if (pinned !== undefined) {
+    return pinned;
+  }
+  return newState(processStartIsInvocationStart() ? 0 : performance.now());
 }
-function getYamlCodec() {
-  return yamlSlot.get();
+function livePinnedState() {
+  const pinned = stateSlot.get();
+  return pinned !== undefined && "httpCalls" in pinned && !pinned.finished ? pinned : undefined;
 }
-function getJmespathCodec() {
-  return jmespathSlot.get();
+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/output-format-context.ts
-var formatSlot = singleton("OutputFormat");
-var formatExplicitSlot = singleton("OutputFormatExplicit");
-var helpRequestedSlot = singleton("HelpRequested");
-var filterSlot = singleton("OutputFilter");
-function getOutputFormat() {
-  return formatSlot.get("json");
+// ../common/src/exit-code.ts
+function setExitCode(code) {
+  process.exitCode = code;
+  recordExitCode(code);
 }
-function getOutputFilter() {
-  return filterSlot.get();
+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/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;
-    }
+// ../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-a2bk27p6.js").then((mod) => {
+      yamlSlot.set(mod);
+    }));
   }
-  return changed ? result : properties;
+  if (needed.filter && jmespathSlot.get() === undefined) {
+    loads.push(import("./jmespath-ab6tdc42.js").then((m)=>__toESM(m.default,1)).then((mod) => {
+      jmespathSlot.set(mod);
+    }));
+  }
+  await Promise.all(loads);
+}
+function getYamlCodec() {
+  return yamlSlot.get();
+}
+function getJmespathCodec() {
+  return jmespathSlot.get();
+}
+
+// ../common/src/output-format-context.ts
+var formatSlot = singleton("OutputFormat");
+var formatExplicitSlot = singleton("OutputFormatExplicit");
+var helpRequestedSlot = singleton("HelpRequested");
+var filterSlot = singleton("OutputFilter");
+function getOutputFormat() {
+  return formatSlot.get("json");
+}
+function getOutputFilter() {
+  return filterSlot.get();
 }
 
 // ../common/src/telemetry/command-terminal.ts
@@ -3846,17 +4274,8 @@ function terminalSignalFor(input, outcome) {
   }
   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";
-  }
-  return "network_http";
+function classifyFailingHttpStatus(status) {
+  return classifyFromErrorCode(classifyHttpStatus(status)?.errorCode) ?? "network_http";
 }
 function classifyFromResult(result) {
   switch (result) {
@@ -3936,7 +4355,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";
 }
@@ -3968,6 +4387,7 @@ function buildCommandTerminalTelemetryProperties(input) {
 var CommonTelemetryEvents = {
   Start: "Application.Start",
   Error: "Application.Error",
+  ProjectActivity: "Cli.ProjectActivity",
   ShipSucceeded: "Cli.ShipSucceeded"
 };
 
@@ -4485,87 +4905,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;
@@ -4601,7 +4955,6 @@ var telemetry = new Proxy({}, {
     return typeof value === "function" ? value.bind(instance) : value;
   }
 });
-
 // ../common/src/formatter.ts
 var ANSI_STYLES = {
   red: "\x1B[31m",
@@ -4611,46 +4964,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,
@@ -4659,6 +4972,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");
@@ -5334,8 +5650,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` : "");
 }
@@ -5472,40 +5788,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))) {
@@ -5514,17 +5801,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) {
@@ -5556,7 +5832,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,66 +5899,255 @@ var OutputFormatter;
       }
     }
   }
-  OutputFormatter.log = log;
-  function formatToString(data) {
-    const filter = getOutputFilter();
-    const envelope = data;
-    if ("Data" in data && data.Data != null) {
-      data.Data = normalizeDataKeys(data.Data);
-      if (filter) {
-        let note;
-        data.Data = normalizeDataKeys(applyFilter(data.Data, filter, (n) => {
-          note = n;
-        }));
-        if (note) {
-          envelope.Warning = appendWarning(envelope.Warning, note);
-        }
+  OutputFormatter.log = log;
+  function formatToString(data) {
+    const filter = getOutputFilter();
+    const envelope = data;
+    if ("Data" in data && data.Data != null) {
+      data.Data = normalizeDataKeys(data.Data);
+      if (filter) {
+        let note;
+        data.Data = normalizeDataKeys(applyFilter(data.Data, filter, (n) => {
+          note = n;
+        }));
+        if (note) {
+          envelope.Warning = appendWarning(envelope.Warning, note);
+        }
+      }
+    }
+    const output = normalizeOutputKeys(envelope);
+    const lines = [];
+    const sink = getOutputSink();
+    printOutput(output, getOutputFormat(), (msg) => {
+      lines.push(msg);
+    }, needsAsciiSafeJson(sink));
+    return lines.join(`
+`);
+  }
+  OutputFormatter.formatToString = formatToString;
+})(OutputFormatter ||= {});
+
+// ../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);
     }
-    const output = normalizeOutputKeys(envelope);
-    const lines = [];
-    const sink = getOutputSink();
-    printOutput(output, getOutputFormat(), (msg) => {
-      lines.push(msg);
-    }, needsAsciiSafeJson(sink));
-    return lines.join(`
-`);
   }
-  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/command-examples.ts
-var examplesByCommand = new WeakMap;
-Command.prototype.examples = function(examples) {
-  examplesByCommand.set(this, examples);
-  return this;
-};
-// ../common/src/preview.ts
-var previewSlot = singleton("PreviewBuild");
-function isPreviewBuild() {
-  return previewSlot.get(false) ?? false;
 }
-Command.prototype.previewCommand = function(nameAndArgs, opts) {
-  if (isPreviewBuild()) {
-    return this.command(nameAndArgs, opts);
-  }
-  return new Command(nameAndArgs.split(/\s+/)[0] ?? nameAndArgs);
-};
 
 // ../common/src/telemetry/command-attribution.ts
 var LEGACY_SKILL_NAMESPACE = "uipath:";
@@ -5928,8 +6393,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();
@@ -5954,6 +6418,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;
   });
@@ -5969,7 +6435,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));
@@ -5984,6 +6451,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 = [];
@@ -6045,6 +6577,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 {
@@ -6057,6 +6591,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) {
@@ -6065,22 +6605,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);
       }
@@ -6089,6 +6633,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,
@@ -6106,6 +6658,7 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       }
       const baseProperties = redactProperties({
         ...commandParams,
+        ...projectSession?.properties(),
         ...props,
         ...buildCommandTelemetryAttribution(commandPath, process.env.UIPATH_SKILL),
         ...buildAgentSessionTelemetry(process.env),
@@ -6116,6 +6669,8 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       });
       emitInvocationRequest(telemetryName, success, baseProperties);
     } finally {
+      if (projectSession)
+        attachProjectTelemetryCapture(command, undefined);
       releaseSuppliedArgumentValues(supplied);
     }
   });
@@ -6420,7 +6975,7 @@ function warnDeprecatedOptionAlias(deprecatedFlag, preferredFlag) {
 }
 var TENANT_SWITCH_COMMAND = "uip login tenant set <tenant>";
 function createHiddenDeprecatedTenantOption(flags = "-t, --tenant <tenant-name>") {
-  return new Option(flags, `Tenant name. Deprecated; use ${TENANT_SWITCH_COMMAND} to switch active tenants.`).hideHelp().argParser((tenant) => {
+  return new Option2(flags, `Tenant name. Deprecated; use ${TENANT_SWITCH_COMMAND} to switch active tenants.`).hideHelp().argParser((tenant) => {
     warnDeprecatedTenantOption(tenant);
     return tenant;
   });
@@ -6706,9 +7261,9 @@ function getProfileStorage() {
   if (isAuthProfileStorage(existing)) {
     return existing;
   }
-  const storage2 = createProfileStorage();
-  globalSlot2[AUTH_PROFILE_STORAGE_KEY] = storage2;
-  return storage2;
+  const storage = createProfileStorage();
+  globalSlot2[AUTH_PROFILE_STORAGE_KEY] = storage;
+  return storage;
 }
 var profileStorage = getProfileStorage();
 
@@ -6739,8 +7294,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();
@@ -6913,6 +7468,8 @@ var ENV_AUTH_VARS = {
 };
 
 class EnvAuthConfigError extends Error {
+  errorCode = "configuration_error";
+  retry = "RetryWillNotFix";
   constructor(message) {
     super(message);
     this.name = "EnvAuthConfigError";
@@ -6951,11 +7508,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,
@@ -6996,8 +7553,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);
@@ -7006,9 +7563,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);
@@ -7019,20 +7576,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 {}
 }
@@ -7053,13 +7610,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") {
@@ -7069,20 +7626,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);
@@ -7255,9 +7812,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") {
@@ -7289,9 +7849,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 };
     }
@@ -7318,36 +7878,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" };
   }
@@ -7390,12 +7950,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}`);
   }
@@ -7406,10 +7966,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 {}
@@ -7427,11 +7987,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
@@ -7555,11 +8115,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 });
@@ -7976,26 +8536,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,
@@ -8017,27 +8589,44 @@ var TENANT_SELECTION_CODES = new Set([
 // src/services/feedback-service.ts
 var GUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var ZERO_GUID = "00000000-0000-0000-0000-000000000000";
-async function resolveAuth(tenant) {
-  const [loginError, loginStatus2] = await catchError(getLoginStatusAsync());
-  if (loginError) {
-    throw new Error(loginError.message);
-  }
-  if (loginStatus2.loginStatus !== "Logged in" || !loginStatus2.baseUrl) {
-    throw new Error("Not authenticated. Run 'uip auth login' first.");
+
+class FeedbackApiError extends Error {
+  errorCode;
+  retry = "RetryWillNotFix";
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
+    this.name = "FeedbackApiError";
   }
-  const tenantName = tenant ?? loginStatus2.tenantName;
-  if (!tenantName || !loginStatus2.organizationId) {
-    throw new Error("Missing tenant or organization info.");
+}
+var NOT_AUTHENTICATED = "Not authenticated. Run 'uip login' first.";
+async function resolveAuth(tenant) {
+  const [authError, auth] = await catchError(getAuthContext({
+    tenant,
+    requireOrganizationId: true,
+    requireTenantName: true
+  }));
+  if (authError) {
+    if (carriedErrorCode(authError) === "authentication_required") {
+      if (hasIdentityInstructionContext(authError)) {
+        throw authError;
+      }
+      if (typeof authError === "object" && "sessionHint" in authError && typeof authError.sessionHint === "string") {
+        throw authError;
+      }
+      throw new FeedbackApiError(NOT_AUTHENTICATED, "authentication_required");
+    }
+    throw authError;
   }
   return {
-    baseUrl: loginStatus2.baseUrl,
-    orgId: loginStatus2.organizationId,
-    tenantName,
-    token: loginStatus2.accessToken ?? ""
+    baseUrl: auth.baseUrl,
+    orgId: auth.organizationId,
+    tenantName: auth.tenantName,
+    token: auth.accessToken
   };
 }
 function feedbackBaseUrl(baseUrl, orgId, tenantName) {
-  return `${baseUrl}/${orgId}/${encodeURIComponent(tenantName)}/llmopstenant_/api/Feedback`;
+  return `${baseUrl}/${encodeURIComponent(orgId)}/${encodeURIComponent(tenantName)}/llmopstenant_/api/Feedback`;
 }
 async function apiFetch(url, token, folderKey, method = "GET", body) {
   const headers = {
@@ -8056,13 +8645,13 @@ async function apiFetch(url, token, folderKey, method = "GET", body) {
 }
 async function handleErrorResponse(response, context) {
   if (response.status === 401) {
-    throw new Error("Not authenticated. Run 'uip auth login' first.");
+    throw new FeedbackApiError(NOT_AUTHENTICATED, "authentication_required");
   }
   if (response.status === 403) {
-    throw new Error("Insufficient permissions. Ensure you have Logs.View / Logs.Create / Logs.Delete on this folder.");
+    throw new FeedbackApiError("Insufficient permissions. Ensure you have Logs.View / Logs.Create / Logs.Delete on this folder.", "permission_denied");
   }
   if (response.status === 404) {
-    throw new Error(`${context} not found.`);
+    throw new FeedbackApiError(`${context} not found.`, "not_found");
   }
   const text = await response.text();
   throw new Error(`Feedback API failed: ${response.status} ${response.statusText} - ${text}`);
@@ -8236,8 +8825,8 @@ async function readTextFile(filePath, label = "Comment") {
     }
     return Buffer.concat(chunks).toString("utf8");
   }
-  const fs2 = getFileSystem();
-  const content = await fs2.readFile(filePath, "utf-8");
+  const fs = getFileSystem();
+  const content = await fs.readFile(filePath, "utf-8");
   if (content === null) {
     throw new Error(`${label} file not found: ${filePath}`);
   }
@@ -8298,6 +8887,35 @@ async function resolveFeedbackText(code, sources) {
   }
   return values;
 }
+async function feedbackApiFailure(code, error, { permissions, fallback }) {
+  const details = await extractErrorDetails(error);
+  return {
+    Result: RESULTS.Failure,
+    Code: code,
+    ErrorCode: details.errorCode,
+    Message: details.message,
+    Instructions: instructionsForFeedbackFailure(details.errorCode, error, {
+      permissions,
+      fallback
+    }),
+    Retry: details.retry,
+    ...details.context ? { Context: details.context } : {}
+  };
+}
+function instructionsForFeedbackFailure(errorCode, error, { permissions, fallback }) {
+  switch (errorCode) {
+    case "authentication_required":
+      return instructionsFor("auth", error);
+    case "permission_denied":
+      return `Ask a tenant admin to grant ${permissions} on this folder.`;
+    case "configuration_error":
+      return instructionsFor("auth-configuration");
+    case "local_permission_denied":
+      return "Check access to the local file named in Message, then retry.";
+    default:
+      return fallback;
+  }
+}
 
 // src/commands/feedback/create.ts
 var FEEDBACK_CREATE_EXAMPLES = [
@@ -8310,8 +8928,8 @@ var FEEDBACK_CREATE_EXAMPLES = [
     }
   }
 ];
-function registerCreateCommand(program2) {
-  program2.command("create").description("Create feedback for a trace").examples(FEEDBACK_CREATE_EXAMPLES).option("--trace-id <id>", "Trace ID (32-char hex or GUID)").option("--positive", "Mark as positive feedback").option("--negative", "Mark as negative feedback").option("--span-id <id>", "Span ID (defaults to root span of trace)").option("--comment <text>", "Free-text annotation (max 1048576 chars)").option("--comment-file <file>", "Read comment from file; use '-' for stdin").option("--category <tag>", 'Category tag, repeatable. Built-in defaults: "Output", "Agent Error", "Agent Plan Execution"', collect, []).option("--agent-id <guid>", "Agent reference ID").option("--agent-version <str>", "Agent version (max 100 chars)").option("--folder-key <guid>", "Folder key (required for write ops)").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (opts) => {
+function registerCreateCommand(program) {
+  program.command("create").description("Create feedback for a trace").examples(FEEDBACK_CREATE_EXAMPLES).option("--trace-id <id>", "Trace ID (32-char hex or GUID)").option("--positive", "Mark as positive feedback").option("--negative", "Mark as negative feedback").option("--span-id <id>", "Span ID (defaults to root span of trace)").option("--comment <text>", "Free-text annotation (max 1048576 chars)").option("--comment-file <file>", "Read comment from file; use '-' for stdin").option("--category <tag>", 'Category tag, repeatable. Built-in defaults: "Output", "Agent Error", "Agent Plan Execution"', collect, []).option("--agent-id <guid>", "Agent reference ID").option("--agent-version <str>", "Agent version (max 100 chars)").option("--folder-key <guid>", "Folder key (required for write ops)").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (opts) => {
     if (!opts.traceId) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -8372,11 +8990,10 @@ function registerCreateCommand(program2) {
       }))
     }, { tenant: opts.tenant, folderKey: opts.folderKey }));
     if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Code: "FeedbackCreate",
-        Message: error.message
-      });
+      OutputFormatter.error(await feedbackApiFailure("FeedbackCreate", error, {
+        permissions: "Logs.Create",
+        fallback: "Verify --trace-id, --span-id and --folder-key, then retry."
+      }));
       processContext.exit(1);
       return;
     }
@@ -8399,8 +9016,8 @@ var FEEDBACK_DELETE_EXAMPLES = [
     }
   }
 ];
-function registerDeleteCommand(program2) {
-  program2.command("delete [id]").description("Delete feedback by ID").examples(FEEDBACK_DELETE_EXAMPLES).option("--folder-key <guid>", "Folder key (required)").option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (id, opts) => {
+function registerDeleteCommand(program) {
+  program.command("delete [id]").description("Delete feedback by ID").examples(FEEDBACK_DELETE_EXAMPLES).option("--folder-key <guid>", "Folder key (required)").option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (id, opts) => {
     if (!id) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -8429,11 +9046,10 @@ function registerDeleteCommand(program2) {
       folderKey: opts.folderKey
     }));
     if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Code: "FeedbackDelete",
-        Message: error.message
-      });
+      OutputFormatter.error(await feedbackApiFailure("FeedbackDelete", error, {
+        permissions: "Logs.Delete",
+        fallback: "Verify the feedback ID and --folder-key, then retry."
+      }));
       processContext.exit(1);
       return;
     }
@@ -8459,8 +9075,8 @@ var FEEDBACK_GET_EXAMPLES = [
     }
   }
 ];
-function registerGetCommand(program2) {
-  program2.command("get [id]").description("Get feedback by ID").examples(FEEDBACK_GET_EXAMPLES).option("--folder-key <guid>", "Folder key (required)").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (id, opts) => {
+function registerGetCommand(program) {
+  program.command("get [id]").description("Get feedback by ID").examples(FEEDBACK_GET_EXAMPLES).option("--folder-key <guid>", "Folder key (required)").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (id, opts) => {
     if (!id) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -8476,11 +9092,10 @@ function registerGetCommand(program2) {
       folderKey: opts.folderKey
     }));
     if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Code: "FeedbackGet",
-        Message: error.message
-      });
+      OutputFormatter.error(await feedbackApiFailure("FeedbackGet", error, {
+        permissions: "Logs.View",
+        fallback: "Verify the feedback ID and --folder-key, then retry."
+      }));
       processContext.exit(1);
       return;
     }
@@ -8508,8 +9123,8 @@ var FEEDBACK_LIST_EXAMPLES = [
     }
   }
 ];
-function registerListCommand(program2) {
-  program2.command("list").enablePositionalOptions().description("List feedback entries").examples(FEEDBACK_LIST_EXAMPLES).option("--agent-id <guid>", "Filter by agent ID").option("--agent-version <str>", "Filter by agent version").option("--trace-id <id>", "Filter by trace ID").option("--span-id <id>", "Filter by span ID").option("--status <value>", "Filter by status: Pending, Approved, Dismissed (repeatable)", collect, []).option("--positive", "Return positive feedback only").option("--negative", "Return negative feedback only").option("--limit <n>", "Max results (default: 20, max: 100)", parseInt).option("--offset <n>", "Results to skip (default: 0)", parseInt).addOption(new Option("--skip <n>").hideHelp().argParser(parseInt)).option("--folder-key <guid>", "Folder key").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (opts) => {
+function registerListCommand(program) {
+  program.command("list").enablePositionalOptions().description("List feedback entries").examples(FEEDBACK_LIST_EXAMPLES).option("--agent-id <guid>", "Filter by agent ID").option("--agent-version <str>", "Filter by agent version").option("--trace-id <id>", "Filter by trace ID").option("--span-id <id>", "Filter by span ID").option("--status <value>", "Filter by status: Pending, Approved, Dismissed (repeatable)", collect, []).option("--positive", "Return positive feedback only").option("--negative", "Return negative feedback only").option("--limit <n>", "Max results (default: 20, max: 100)", parseInt).option("--offset <n>", "Results to skip (default: 0)", parseInt).addOption(new Option2("--skip <n>").hideHelp().argParser(parseInt)).option("--folder-key <guid>", "Folder key").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (opts) => {
     if (opts.positive && opts.negative) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -8551,11 +9166,10 @@ function registerListCommand(program2) {
       skip: offset.value
     }, { tenant: opts.tenant, folderKey: opts.folderKey }));
     if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Code: "FeedbackList",
-        Message: error.message
-      });
+      OutputFormatter.error(await feedbackApiFailure("FeedbackList", error, {
+        permissions: "Logs.View",
+        fallback: "Verify --folder-key and the filters, then retry."
+      }));
       processContext.exit(1);
       return;
     }
@@ -8582,13 +9196,13 @@ var FEEDBACK_LIST_DETAILED_EXAMPLES = [
     }
   }
 ];
-function registerListDetailedCommand(program2) {
-  const listCmd = program2.commands.find((c) => c.name() === "list");
+function registerListDetailedCommand(program) {
+  const listCmd = program.commands.find((c) => c.name() === "list");
   if (!listCmd) {
     throw new Error("registerListDetailedCommand must be called after registerListCommand");
   }
   listCmd.passThroughOptions();
-  listCmd.command("detailed").description("List feedback with span context and extended filters (max 200 items)").examples(FEEDBACK_LIST_DETAILED_EXAMPLES).option("--agent-id <guid>", "Filter by agent ID").option("--agent-version <str>", "Filter by agent version").option("--trace-id <id>", "Filter by trace ID").option("--span-id <id>", "Filter by span ID").option("--status <value>", "Filter by status: Pending, Approved, Dismissed (repeatable)", collect, []).option("--positive", "Return positive feedback only").option("--negative", "Return negative feedback only").option("--category-id <guid>", "Filter by category ID (repeatable)", collect, []).option("--after <iso>", "Created after this time (ISO 8601)").option("--before <iso>", "Created before this time (ISO 8601)").option("--since <duration>", "Relative lookback: 1h, 24h, 7d (shorthand for --after)").option("--sort-by <field>", "Sort field: createdAt, updatedAt (default: createdAt)").option("--sort-order <direction>", "Sort direction: asc, desc (default: desc)").option("--limit <n>", "Max results (default: 20, max: 200)", parseInt).option("--offset <n>", "Results to skip (default: 0)", parseInt).addOption(new Option("--skip <n>").hideHelp().argParser(parseInt)).option("--folder-key <guid>", "Folder key").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (opts) => {
+  listCmd.command("detailed").description("List feedback with span context and extended filters (max 200 items)").examples(FEEDBACK_LIST_DETAILED_EXAMPLES).option("--agent-id <guid>", "Filter by agent ID").option("--agent-version <str>", "Filter by agent version").option("--trace-id <id>", "Filter by trace ID").option("--span-id <id>", "Filter by span ID").option("--status <value>", "Filter by status: Pending, Approved, Dismissed (repeatable)", collect, []).option("--positive", "Return positive feedback only").option("--negative", "Return negative feedback only").option("--category-id <guid>", "Filter by category ID (repeatable)", collect, []).option("--after <iso>", "Created after this time (ISO 8601)").option("--before <iso>", "Created before this time (ISO 8601)").option("--since <duration>", "Relative lookback: 1h, 24h, 7d (shorthand for --after)").option("--sort-by <field>", "Sort field: createdAt, updatedAt (default: createdAt)").option("--sort-order <direction>", "Sort direction: asc, desc (default: desc)").option("--limit <n>", "Max results (default: 20, max: 200)", parseInt).option("--offset <n>", "Results to skip (default: 0)", parseInt).addOption(new Option2("--skip <n>").hideHelp().argParser(parseInt)).option("--folder-key <guid>", "Folder key").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (opts) => {
     if (opts.positive && opts.negative) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -8650,11 +9264,10 @@ function registerListDetailedCommand(program2) {
       skip: offset.value
     }, { tenant: opts.tenant, folderKey: opts.folderKey }));
     if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Code: "FeedbackListDetailed",
-        Message: error.message
-      });
+      OutputFormatter.error(await feedbackApiFailure("FeedbackListDetailed", error, {
+        permissions: "Logs.View",
+        fallback: "Verify --folder-key and the filters, then retry."
+      }));
       processContext.exit(1);
       return;
     }
@@ -8701,17 +9314,8 @@ var FEEDBACK_UPDATE_EXAMPLES = [
     }
   }
 ];
-function updateInstructions(message) {
-  if (message.startsWith("Not authenticated")) {
-    return "Run 'uip auth login', then run this command again.";
-  }
-  if (message.startsWith("Insufficient permissions")) {
-    return "Ask a tenant admin to grant Logs.View and Logs.Create on this folder.";
-  }
-  return "Verify the feedback ID and --folder-key, then retry.";
-}
-function registerUpdateCommand(program2) {
-  program2.command("update [id]").description("Update feedback (isPositive, comment, metadata, categories)").examples(FEEDBACK_UPDATE_EXAMPLES).option("--positive", "Change to positive feedback").option("--negative", "Change to negative feedback").option("--comment <text>", "Updated comment (max 1048576 chars)").option("--comment-file <file>", "Read updated comment from file; use '-' for stdin").option("--metadata <json>", "Updated metadata; must be valid JSON (max 1048576 chars)").option("--metadata-file <file>", "Read updated metadata from file; use '-' for stdin").option("--category <tag>", "Replacement category tags (repeatable)", collect, []).option("--folder-key <guid>", "Folder key (required)").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (id, opts) => {
+function registerUpdateCommand(program) {
+  program.command("update [id]").description("Update feedback (isPositive, comment, metadata, categories)").examples(FEEDBACK_UPDATE_EXAMPLES).option("--positive", "Change to positive feedback").option("--negative", "Change to negative feedback").option("--comment <text>", "Updated comment (max 1048576 chars)").option("--comment-file <file>", "Read updated comment from file; use '-' for stdin").option("--metadata <json>", "Updated metadata; must be valid JSON (max 1048576 chars)").option("--metadata-file <file>", "Read updated metadata from file; use '-' for stdin").option("--category <tag>", "Replacement category tags (repeatable)", collect, []).option("--folder-key <guid>", "Folder key (required)").addOption(createHiddenDeprecatedTenantOption("--tenant <name>")).trackedAction(processContext, async (id, opts) => {
     if (!id) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -8770,12 +9374,10 @@ function registerUpdateCommand(program2) {
       })) : undefined
     }, { tenant: opts.tenant, folderKey: opts.folderKey }));
     if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Code: "FeedbackUpdate",
-        Message: error.message,
-        Instructions: updateInstructions(error.message)
-      });
+      OutputFormatter.error(await feedbackApiFailure("FeedbackUpdate", error, {
+        permissions: "Logs.View and Logs.Create",
+        fallback: "Verify the feedback ID and --folder-key, then retry."
+      }));
       processContext.exit(1);
       return;
     }
@@ -8788,8 +9390,8 @@ function registerUpdateCommand(program2) {
 }
 
 // src/commands/feedback/index.ts
-function registerFeedbackCommand(program2) {
-  const feedback = program2.command("feedback").enablePositionalOptions().description("Manage LLM Observability feedback for traces and spans");
+function registerFeedbackCommand(program) {
+  const feedback = program.command("feedback").enablePositionalOptions().description("Manage LLM Observability feedback for traces and spans");
   registerCreateCommand(feedback);
   registerGetCommand(feedback);
   registerListCommand(feedback);
@@ -9052,7 +9654,7 @@ var package_default2 = {
   name: "@uipath/orchestrator-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.205.0",
+  version: "1.206.0",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -9079,6 +9681,10 @@ var package_default2 = {
         types: "./dist/src/index.d.ts",
         default: "./dist/index.js"
       }
+    },
+    "./folder-feed": {
+      types: "./dist/src/folder-feed.d.ts",
+      default: "./dist/folder-feed.js"
     }
   },
   files: [
@@ -9086,11 +9692,12 @@ var package_default2 = {
   ],
   private: true,
   scripts: {
-    build: "bun build ./src/index.ts --outdir dist --format esm --target node --sourcemap=linked && bun build ./src/index.browser.ts --outdir dist --format esm --target browser --external @uipath/auth --external @uipath/common --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    build: "bun build ./src/index.ts ./src/folder-feed.ts --outdir dist --format esm --target node --sourcemap=linked && bun build ./src/index.browser.ts --outdir dist --format esm --target browser --external @uipath/auth --external @uipath/common --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
     generate: "bun run src/scripts/generate-sdk.ts",
     lint: "biome check .",
     test: "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    typecheck: "tsc --noEmit"
   },
   devDependencies: {
     "@uipath/auth": "workspace:*",
@@ -10220,6 +10827,39 @@ function ODataValueOfIEnumerableOfMachineFolderDtoFromJSONTyped(json, ignoreDisc
     value: json["value"] == null ? undefined : json["value"].map(MachineFolderDtoFromJSON)
   };
 }
+// ../orchestrator-sdk/generated/src/models/PersonalWorkspaceDto.ts
+function PersonalWorkspaceDtoFromJSON(json) {
+  return PersonalWorkspaceDtoFromJSONTyped(json, false);
+}
+function PersonalWorkspaceDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["Key"] == null ? undefined : json["Key"],
+    name: json["Name"] == null ? undefined : json["Name"],
+    isActive: json["IsActive"] == null ? undefined : json["IsActive"],
+    ownerId: json["OwnerId"] == null ? undefined : json["OwnerId"],
+    ownerKey: json["OwnerKey"] == null ? undefined : json["OwnerKey"],
+    ownerName: json["OwnerName"] == null ? undefined : json["OwnerName"],
+    lastLogin: json["LastLogin"] == null ? undefined : new Date(json["LastLogin"]),
+    exploringUserIds: json["ExploringUserIds"] == null ? undefined : json["ExploringUserIds"],
+    id: json["Id"] == null ? undefined : json["Id"]
+  };
+}
+
+// ../orchestrator-sdk/generated/src/models/ODataValueOfIEnumerableOfPersonalWorkspaceDto.ts
+function ODataValueOfIEnumerableOfPersonalWorkspaceDtoFromJSON(json) {
+  return ODataValueOfIEnumerableOfPersonalWorkspaceDtoFromJSONTyped(json, false);
+}
+function ODataValueOfIEnumerableOfPersonalWorkspaceDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    value: json["value"] == null ? undefined : json["value"].map(PersonalWorkspaceDtoFromJSON)
+  };
+}
 // ../orchestrator-sdk/generated/src/models/SearchUserDto.ts
 function SearchUserDtoFromJSON(json) {
   return SearchUserDtoFromJSONTyped(json, false);
@@ -11317,6 +11957,74 @@ class JobsApi extends BaseAPI {
     return await response.value();
   }
 }
+// ../orchestrator-sdk/generated/src/apis/PersonalWorkspacesApi.ts
+class PersonalWorkspacesApi extends BaseAPI {
+  async personalWorkspacesGetRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["$select"] != null) {
+      queryParameters["$select"] = requestParameters["$select"];
+    }
+    if (requestParameters["$expand"] != null) {
+      queryParameters["$expand"] = requestParameters["$expand"];
+    }
+    if (requestParameters["$filter"] != null) {
+      queryParameters["$filter"] = requestParameters["$filter"];
+    }
+    if (requestParameters["$orderby"] != null) {
+      queryParameters["$orderby"] = requestParameters["$orderby"];
+    }
+    if (requestParameters["$top"] != null) {
+      queryParameters["$top"] = requestParameters["$top"];
+    }
+    if (requestParameters["$skip"] != null) {
+      queryParameters["$skip"] = requestParameters["$skip"];
+    }
+    if (requestParameters["$count"] != null) {
+      queryParameters["$count"] = requestParameters["$count"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
+    }
+    let urlPath = `/odata/PersonalWorkspaces`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ODataValueOfIEnumerableOfPersonalWorkspaceDtoFromJSON(jsonValue));
+  }
+  async personalWorkspacesGet(requestParameters = {}, initOverrides) {
+    const response = await this.personalWorkspacesGetRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async personalWorkspacesGetPersonalWorkspaceRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["$select"] != null) {
+      queryParameters["$select"] = requestParameters["$select"];
+    }
+    if (requestParameters["$expand"] != null) {
+      queryParameters["$expand"] = requestParameters["$expand"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
+    }
+    let urlPath = `/odata/PersonalWorkspaces/UiPath.Server.Configuration.OData.GetPersonalWorkspace`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PersonalWorkspaceDtoFromJSON(jsonValue));
+  }
+  async personalWorkspacesGetPersonalWorkspace(requestParameters = {}, initOverrides) {
+    const response = await this.personalWorkspacesGetPersonalWorkspaceRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
 // ../common/src/session-kind.ts
 var SESSION_KIND_KEY = Symbol.for("@uipath/common/SessionKind");
 function attachSessionKind(carrier, kind) {
@@ -11396,7 +12104,7 @@ async function resolveFolder(input, options) {
     }
     return resolveByKey(foldersApi, input.folderKey);
   }
-  return resolveByPath(foldersApi, input.folderPath);
+  return resolveByPath(config, foldersApi, input.folderPath);
 }
 async function resolveByKey(foldersApi, folderKey) {
   const folder = await foldersApi.foldersGetByKeyByIdentifier({
@@ -11413,12 +12121,12 @@ async function resolveByKey(foldersApi, folderKey) {
     feedType: folder.feedType
   };
 }
-async function resolveByPath(foldersApi, folderPath) {
+async function resolveByPath(config, foldersApi, folderPath) {
   const response = await foldersApi.foldersGet({
     $filter: `FullyQualifiedName eq '${folderPath.replace(/'/g, "''")}'`,
     $top: 1
   });
-  const folder = response.value?.[0];
+  const folder = response.value?.[0] ?? await resolveInPersonalWorkspace(config, foldersApi, folderPath);
   if (!folder?.id || !folder.key || !folder.fullyQualifiedName || !folder.displayName) {
     throw new Error(`Folder not found: '${folderPath}'.`);
   }
@@ -11430,6 +12138,66 @@ async function resolveByPath(foldersApi, folderPath) {
     feedType: folder.feedType
   };
 }
+var CURRENT_USER_FOLDER_PAGE_SIZE = 1000;
+var CURRENT_USER_FOLDER_PAGE_LIMIT = 50;
+async function resolveInPersonalWorkspace(config, foldersApi, folderPath) {
+  const workspace = await lookupOrMiss("GetPersonalWorkspace", folderPath, () => new PersonalWorkspacesApi(config).personalWorkspacesGetPersonalWorkspace());
+  if (!workspace?.key || !workspace.name) {
+    return;
+  }
+  const wanted = folderPath.toLowerCase();
+  const root = workspace.name.toLowerCase();
+  let key;
+  if (wanted === root) {
+    key = workspace.key;
+  } else if (wanted.startsWith(`${root}/`)) {
+    key = await findKeyInCurrentUserFolders(foldersApi, folderPath);
+  }
+  if (!key) {
+    return;
+  }
+  const folder = await foldersApi.foldersGetByKeyByIdentifier({
+    identifier: key
+  });
+  return folder?.fullyQualifiedName?.toLowerCase() === wanted ? folder : undefined;
+}
+async function findKeyInCurrentUserFolders(foldersApi, folderPath) {
+  const wanted = folderPath.toLowerCase();
+  let skip = 0;
+  for (let page = 0;page < CURRENT_USER_FOLDER_PAGE_LIMIT; page++) {
+    const result = await lookupOrMiss("GetAllForCurrentUser", folderPath, () => foldersApi.foldersGetAllForCurrentUser({
+      take: CURRENT_USER_FOLDER_PAGE_SIZE,
+      skip
+    }));
+    const rows = result?.pageItems ?? [];
+    const match = rows.find((row) => row.fullyQualifiedName?.toLowerCase() === wanted);
+    if (match) {
+      return match.key;
+    }
+    skip += rows.length;
+    if (rows.length === 0 || typeof result?.count === "number" && skip >= result.count) {
+      return;
+    }
+  }
+  logger.debug(`GetAllForCurrentUser: stopped after ${CURRENT_USER_FOLDER_PAGE_LIMIT} pages without finding '${folderPath}'.`);
+  return;
+}
+async function lookupOrMiss(endpoint, folderPath, call) {
+  const [error, value] = await catchError(call());
+  if (!error) {
+    return value;
+  }
+  if (!isLookupMiss(error)) {
+    throw error;
+  }
+  logger.debug(`${endpoint} lookup for '${folderPath}' failed: ${await extractErrorMessage(error)}`);
+  return;
+}
+function isLookupMiss(error) {
+  const failure = error;
+  const status = failure?.response?.status ?? failure?.status;
+  return typeof status === "number" && status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
 // ../orchestrator-sdk/src/knowledge-bundles.ts
 var KB_INLINE_LIMITS = {
   maxObjectBytes: 16 * 1024 * 1024,
@@ -11467,26 +12235,21 @@ async function getTraceIdForJob(jobKey, options) {
   return jobTraceId ?? resolvedJobKey;
 }
 async function getSpansForTrace(traceId, options) {
-  const [loginError, loginStatus2] = await catchError(getLoginStatusAsync());
-  if (loginError) {
-    throw new Error(loginError.message);
-  }
-  if (loginStatus2.loginStatus !== "Logged in" || !loginStatus2.baseUrl) {
-    throw new Error("Not logged in. Run 'uip login' first.");
-  }
-  const tenantName = options.tenant || loginStatus2.tenantName;
-  if (!tenantName || !loginStatus2.organizationId) {
-    throw new Error("Missing tenant or organization info.");
-  }
+  const auth = await getAuthContext({
+    tenant: options.tenant,
+    requireOrganizationId: true,
+    requireTenantName: true
+  });
+  const { tenantName } = auth;
   if (!TRACE_ID_RE.test(traceId)) {
     throw new Error(`Invalid trace ID format: ${traceId}. Must be a 32-char hex string or GUID.`);
   }
   const traceIdNoHyphens = traceId.replaceAll("-", "");
-  const url = `${loginStatus2.baseUrl}/${encodeURIComponent(loginStatus2.organizationId)}/${encodeURIComponent(tenantName)}/llmopstenant_/api/Traces/v2/spans/otel?traceId=${encodeURIComponent(traceIdNoHyphens)}`;
+  const url = `${auth.baseUrl}/${encodeURIComponent(auth.organizationId)}/${encodeURIComponent(tenantName)}/llmopstenant_/api/Traces/v2/spans/otel?traceId=${encodeURIComponent(traceIdNoHyphens)}`;
   const response = await fetch(url, {
     method: "GET",
     headers: {
-      Authorization: `Bearer ${loginStatus2.accessToken ?? ""}`,
+      Authorization: `Bearer ${auth.accessToken}`,
       "Content-Type": "application/json",
       Accept: "application/json"
     }
@@ -11522,8 +12285,8 @@ var SPANS_GET_EXAMPLES = [
     }
   }
 ];
-var registerSpansCommand = (program2) => {
-  const spans = program2.command("spans").description("Manage LLM Observability spans");
+var registerSpansCommand = (program) => {
+  const spans = program.command("spans").description("Manage LLM Observability spans");
   spans.command("get").description("Get all spans by trace ID, or by job key as an alternative").argument("[trace-id]", "Trace ID (32-char hex or GUID format)").option("--job-key <guid>", "Orchestrator job key (GUID) — alternative to trace-id").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <name>")).option("--folder-path <path>", "Orchestrator folder path").option("--folder-key <guid>", "Orchestrator folder key (GUID)").examples(SPANS_GET_EXAMPLES).trackedAction(processContext, async (traceId, options) => {
     let resolvedTraceId;
     if (options.jobKey) {
@@ -11549,7 +12312,7 @@ var registerSpansCommand = (program2) => {
       processContext.exit(1);
       return;
     }
-    const [spansError, spans2] = await catchError(getSpansForTrace(resolvedTraceId, options));
+    const [spansError, spans] = await catchError(getSpansForTrace(resolvedTraceId, options));
     if (spansError) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -11562,23 +12325,23 @@ var registerSpansCommand = (program2) => {
     OutputFormatter.success({
       Result: RESULTS.Success,
       Code: "TraceSpans",
-      Data: spans2
+      Data: spans
     });
   });
 };
 
 // src/tool.ts
-var metadata = {
+var metadata2 = {
   name: "traces-tool",
   version: package_default.version,
   description: "Fetch LLM Observability traces for UiPath jobs",
   commandPrefix: "traces"
 };
-var registerCommands = async (program2) => {
-  registerSpansCommand(program2);
-  registerFeedbackCommand(program2);
+var registerCommands2 = async (program) => {
+  registerSpansCommand(program);
+  registerFeedbackCommand(program);
 };
 
-export { Command, metadata, registerCommands };
+export { Command, metadata2, registerCommands2 };
 
-//# debugId=FE7CEA37F238615D64756E2164756E21
+//# debugId=30D8D71D6CD20D2164756E2164756E21