@uipath/rpa-tool 1.199.1 → 1.200.0

package/dist/tool.js

@@ -18503,7 +18503,7 @@ import process43 from "node:process";
 import { execFile as execFile33 } from "node:child_process";
 import process53 from "node:process";
 import { promisify as promisify43 } from "node:util";
-import { execFile as execFile43, execFileSync as execFileSync6 } from "node:child_process";
+import { execFile as execFile43, execFileSync as execFileSync7 } from "node:child_process";
 import { promisify as promisify53 } from "node:util";
 import { execFile as execFile53 } from "node:child_process";
 import process73 from "node:process";
@@ -19319,7 +19319,7 @@ import process44 from "node:process";
 import { execFile as execFile34 } from "node:child_process";
 import process54 from "node:process";
 import { promisify as promisify44 } from "node:util";
-import { execFile as execFile44, execFileSync as execFileSync7 } from "node:child_process";
+import { execFile as execFile44, execFileSync as execFileSync8 } from "node:child_process";
 import { promisify as promisify54 } from "node:util";
 import { execFile as execFile54 } from "node:child_process";
 import process74 from "node:process";
@@ -32272,7 +32272,7 @@ function withTrailingSeparator(p) {
 }
 
 // src/tool.ts
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 
 // node_modules/@uipath/common/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
@@ -40614,6 +40614,9 @@ var filterSlot = singleton("OutputFilter");
 function getOutputFormat() {
   return formatSlot.get("json");
 }
+function getOutputFormatExplicit() {
+  return formatExplicitSlot.get(false) ?? false;
+}
 function getOutputFilter() {
   return filterSlot.get();
 }
@@ -42404,7 +42407,7 @@ var {
 // package.json
 var package_default = {
   name: "@uipath/rpa-tool",
-  version: "1.199.1",
+  version: "1.200.0",
   description: "Tool for creating and managing UiPath RPA projects",
   keywords: [
     "uipcli-tool",
@@ -42414,7 +42417,9 @@ var package_default = {
   type: "module",
   main: "./dist/tool.js",
   exports: {
-    ".": "./dist/tool.js"
+    ".": "./dist/tool.js",
+    "./packager-tool": "./dist/packager-tool.js",
+    "./executor-tool": "./dist/executor-tool.js"
   },
   private: false,
   maintainers: [
@@ -42437,7 +42442,7 @@ var package_default = {
     registry: "https://npm.pkg.github.com"
   },
   scripts: {
-    build: "bunx tsc --noEmit && bun build ./src/packager-tool.ts --outdir dist --format esm --target node --external applicationinsights && bun build ./src/tool.ts --outdir dist --format esm --target node --external '*/packager-tool.js' --external applicationinsights && bun build ./src/index.ts --outdir dist --format esm --target node --external '*/tool.js' --external applicationinsights",
+    build: "bunx tsc --noEmit && bun build ./src/packager-tool.ts --outdir dist --format esm --target node --external applicationinsights && bun build ./src/executor-tool.ts --outdir dist --format esm --target node --external applicationinsights && bun build ./src/tool.ts --outdir dist --format esm --target node --external '*/packager-tool.js' --external applicationinsights && bun build ./src/index.ts --outdir dist --format esm --target node --external '*/tool.js' --external applicationinsights",
     package: "bun run build && bun pm pack",
     "generate-docs": "bun run scripts/generate-docs.ts",
     "bump-uipath-alpha": "bun run scripts/bump-uipath-alpha.ts",
@@ -42452,9 +42457,10 @@ var package_default = {
     "@types/node": "^25.6.0",
     "@uipath/auth": "1.200.0-preview.118",
     "@uipath/common": "1.200.0-preview.118",
-    "@uipath/coreipc": "2.5.1-20260625-01",
+    "@uipath/coreipc": "2.5.2",
     "@uipath/filesystem": "1.200.0-preview.118",
     "@uipath/packager-tool-workflowcompiler": "1.200.0-preview.118",
+    "@uipath/project-executor": "1.200.0-preview.118",
     "@uipath/project-packager": "1.200.0-preview.118",
     "@uipath/solution-sdk": "1.200.0-preview.118",
     "@uipath/solutionpackager-tool-core": "1.200.0-preview.118",
@@ -42683,7 +42689,7 @@ var registerListInstancesCommand = (program3) => {
 };
 
 // src/commands/packager/analyze.ts
-import { isAbsolute as isAbsolute6, join as join13 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join14 } from "node:path";
 
 // src/telemetry/studio-shaped-props.ts
 import { readFileSync } from "node:fs";
@@ -42935,7 +42941,7 @@ import {
   basename as basename6,
   dirname as dirname6,
   isAbsolute as isAbsolute5,
-  join as join12,
+  join as join13,
   relative as relative5,
   resolve as resolve6
 } from "node:path";
@@ -42949,7 +42955,8 @@ async function loadPackagerTool() {
     _warn(...args);
   };
   try {
-    await import("./packager-tool.js");
+    const { registerPackagerFactories } = await import("./packager-tool.js");
+    registerPackagerFactories();
   } catch {} finally {
     console.warn = _warn;
   }
@@ -43021,10 +43028,222 @@ function writeFeedsFile(feeds) {
 }
 
 // src/resolution/robot-bin-resolver.ts
-import { join as join9, posix, win32 } from "node:path";
+import { join as join8, posix, win32 } from "node:path";
+
+// src/resolution/paths.ts
+import { join as join7, normalize } from "node:path";
+var DEFAULT_TIMEOUT_MS2 = 60000;
+var POLL_INTERVAL_MS = 1000;
+var INTEROP_MANIFEST = "interop-manifest.json";
+var STUDIO_EXE = "UiPath.Studio.exe";
+var STUDIO_SUBDIR = "Studio";
+var ROBOT_SUBDIR = "Robot";
+var HELM_EXE = process.platform === "win32" ? "UiPath.Studio.Helm.exe" : "UiPath.Studio.Helm";
+function normalizePath(path4) {
+  return normalize(path4).replace(/[\\/]+$/, "").toLowerCase();
+}
+
+// src/resolution/robot-bin-resolver.ts
+var LOCAL_ROBOT_FEEDS_ENV = "UIPATH_LOCAL_ROBOT_FEEDS";
+function robotNugetConfigPath(robotDir) {
+  return join8(robotDir, "NuGet.config");
+}
+var ROBOT_WINDOWS_MARKER = "UiRobot.exe";
+var ROBOT_MACOS_MARKER = "UiRobot.dll";
+var MACOS_ASSISTANT_ROBOT_PATH = "/Applications/UiPath Assistant.app/Contents/Robot";
+var REGISTRY_HIVES = [
+  "HKCU\\Software\\UiPath\\UiPath Studio",
+  "HKLM\\Software\\UiPath\\UiPath Studio"
+];
+function queryRegistryValue(valueName, deps) {
+  for (const hive of REGISTRY_HIVES) {
+    try {
+      const output = deps.executeCommand("reg", [
+        "query",
+        hive,
+        "/v",
+        valueName
+      ]);
+      const match = output.match(new RegExp(`${valueName}\\s+REG_SZ\\s+(.+)`));
+      if (match)
+        return match[1].trim();
+    } catch {}
+  }
+  return;
+}
+function resolveRobotComponentDir(installRoot, deps) {
+  const nested = win32.join(installRoot, ROBOT_SUBDIR);
+  return deps.fileExists(win32.join(nested, ROBOT_WINDOWS_MARKER)) ? nested : installRoot;
+}
+function resolveRobotDir(cliPath, deps) {
+  if (cliPath) {
+    deps.log(`Using --robot-dir: ${cliPath}`);
+    return cliPath;
+  }
+  const envPath = process.env.UIPATH_ROBOT_DIR;
+  if (envPath) {
+    deps.log(`Using UIPATH_ROBOT_DIR: ${envPath}`);
+    return envPath;
+  }
+  if (process.platform === "win32") {
+    const robotDir = queryRegistryValue("RobotDir", deps);
+    if (robotDir) {
+      deps.log(`Resolved robot dir from registry: ${robotDir}`);
+      return robotDir;
+    }
+    const installRoot = queryRegistryValue("InstallDir", deps);
+    if (installRoot) {
+      const dir = resolveRobotComponentDir(installRoot, deps);
+      deps.log(`Resolved robot dir from registry: ${dir}`);
+      return dir;
+    }
+  }
+  if (process.platform === "darwin") {
+    if (deps.fileExists(posix.join(MACOS_ASSISTANT_ROBOT_PATH, ROBOT_MACOS_MARKER))) {
+      deps.log(`Found robot at well-known path: ${MACOS_ASSISTANT_ROBOT_PATH}`);
+      return MACOS_ASSISTANT_ROBOT_PATH;
+    }
+  }
+  deps.log("Robot dir not resolved — Robot must already be running");
+  return null;
+}
+var DOTNET_ROLL_FORWARD_ENV = {
+  DOTNET_ROLL_FORWARD: "Major"
+};
+var MIN_BUNDLED_DOTNET_MAJOR = 8;
+var DOTNET_ROOT_ENV = "UIPATH_DOTNET_ROOT";
+var RUNTIMES_SUBDIR = "Runtimes";
+var dotnetExeName = () => process.platform === "win32" ? "dotnet.exe" : "dotnet";
+var layoutPath = () => process.platform === "win32" ? win32 : posix;
+function detectDotnetRuntimeMajor(dotnetRoot, deps) {
+  let entries;
+  try {
+    entries = deps.readDir(layoutPath().join(dotnetRoot, "shared", "Microsoft.NETCore.App"));
+  } catch {
+    return;
+  }
+  let max;
+  for (const entry of entries) {
+    const match = /^(\d+)\./.exec(entry);
+    if (!match)
+      continue;
+    const major = Number.parseInt(match[1], 10);
+    if (!Number.isNaN(major) && (max === undefined || major > max)) {
+      max = major;
+    }
+  }
+  return max;
+}
+function* rootsAtOrUnder(dir, deps) {
+  if (deps.fileExists(layoutPath().join(dir, dotnetExeName()))) {
+    yield dir;
+    return;
+  }
+  let entries;
+  try {
+    entries = deps.readDir(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries.sort((a, b) => b.localeCompare(a, undefined, { numeric: true }))) {
+    yield layoutPath().join(dir, entry);
+  }
+}
+function* dotnetRootCandidates(robotDir, deps) {
+  const declaredRoot = process.env[DOTNET_ROOT_ENV];
+  if (declaredRoot) {
+    deps.log(`Using ${DOTNET_ROOT_ENV}: ${declaredRoot}`);
+    yield* rootsAtOrUnder(declaredRoot, deps);
+  }
+  if (process.platform !== "win32") {
+    yield layoutPath().join(robotDir, "dotnet");
+    return;
+  }
+  yield robotDir;
+  yield* rootsAtOrUnder(win32.resolve(robotDir, "..", "..", RUNTIMES_SUBDIR), deps);
+}
+function resolveBundledDotnet(robotDir, deps) {
+  if (!robotDir)
+    return;
+  for (const dotnetRoot of dotnetRootCandidates(robotDir, deps)) {
+    const exePath = layoutPath().join(dotnetRoot, dotnetExeName());
+    if (!deps.fileExists(exePath))
+      continue;
+    const runtimeMajor = detectDotnetRuntimeMajor(dotnetRoot, deps);
+    if (runtimeMajor === undefined || runtimeMajor < MIN_BUNDLED_DOTNET_MAJOR) {
+      const reason = runtimeMajor === undefined ? "could not determine its .NET runtime version" : `highest .NET runtime major ${runtimeMajor} is below the required ${MIN_BUNDLED_DOTNET_MAJOR}`;
+      deps.log(`Ignoring bundled dotnet at ${exePath}: ${reason}.`);
+      continue;
+    }
+    return {
+      exePath,
+      env: {
+        DOTNET_ROOT: dotnetRoot,
+        DOTNET_MULTILEVEL_LOOKUP: "0",
+        ...DOTNET_ROLL_FORWARD_ENV
+      }
+    };
+  }
+  deps.log("No usable delivered dotnet found. Falling back to the system dotnet on PATH.");
+  return;
+}
+
+// src/resolution/feed-control.ts
+function resolveBundledFeedEnv(robotDir) {
+  if (!robotDir || process.env[LOCAL_ROBOT_FEEDS_ENV]) {
+    return {};
+  }
+  return { [LOCAL_ROBOT_FEEDS_ENV]: robotNugetConfigPath(robotDir) };
+}
+async function composeOrchestratorFeedsEnv(compose, log) {
+  if (process.env[ORCHESTRATOR_RESTORE_FEEDS_ENV] || !compose) {
+    return {};
+  }
+  const feedsPath = await compose(log);
+  if (!feedsPath) {
+    return {};
+  }
+  return { [ORCHESTRATOR_RESTORE_FEEDS_ENV]: feedsPath };
+}
+function toSessionConnection(status) {
+  if (status.loginStatus !== "Logged in" || !status.accessToken || !status.baseUrl) {
+    return;
+  }
+  let base = status.baseUrl;
+  while (base.endsWith("/")) {
+    base = base.slice(0, -1);
+  }
+  const segments = [];
+  if (status.organizationName) {
+    segments.push(status.organizationName);
+    if (status.tenantName) {
+      segments.push(status.tenantName);
+    }
+  }
+  const cloudUrl = segments.length ? `${base}/${segments.join("/")}` : base;
+  return {
+    accessToken: status.accessToken,
+    cloudUrl,
+    tenantId: status.tenantId
+  };
+}
+async function resolveSessionConnection() {
+  try {
+    const auth = await Promise.resolve().then(() => (init_dist(), exports_dist));
+    const status = await auth.getLoginStatusAsync({
+      ensureTokenValidityMinutes: 5
+    });
+    if (status.loginStatus && status.loginStatus !== "Logged in" && status.loginStatus !== "Logged out") {
+      logger.warn(`Tenant Orchestrator feeds skipped: the login session is '${status.loginStatus}' — run 'uip login' to restore it.`);
+    }
+    return toSessionConnection(status);
+  } catch {
+    return;
+  }
+}
 
 // src/resolution/resolver-deps.ts
-import { execFileSync as execFileSync5, spawn } from "node:child_process";
+import { execFileSync as execFileSync6, spawn } from "node:child_process";
 import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync5 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 
@@ -43466,20 +43685,51 @@ function adaptRemoteDebugConfigServiceProxy(proxy) {
   };
 }
 
+class RemoteUiaSessionConfigServiceProxy {
+  EnsureRemoteUiaSession() {
+    throw null;
+  }
+  StopRemoteUiaSession() {
+    throw null;
+  }
+}
+__legacyDecorateClassTS([
+  import_coreipc2.ipc.$operation
+], RemoteUiaSessionConfigServiceProxy.prototype, "EnsureRemoteUiaSession", null);
+__legacyDecorateClassTS([
+  import_coreipc2.ipc.$operation
+], RemoteUiaSessionConfigServiceProxy.prototype, "StopRemoteUiaSession", null);
+RemoteUiaSessionConfigServiceProxy = __legacyDecorateClassTS([
+  import_coreipc2.ipc.$service({ endpoint: "IRemoteUiaSessionConfigService" })
+], RemoteUiaSessionConfigServiceProxy);
+function adaptRemoteUiaSessionConfigServiceProxy(proxy) {
+  return {
+    ensureRemoteUiaSession: () => proxy.EnsureRemoteUiaSession(),
+    stopRemoteUiaSession: () => proxy.StopRemoteUiaSession()
+  };
+}
+
 class RunServiceProxy {
   ExecuteCommand(command, filePath, inputArgumentsJson, inputVariablesJson, logLevel, profiling) {
     throw null;
   }
+  ApplyFileChanges(fileChangesJson) {
+    throw null;
+  }
 }
 __legacyDecorateClassTS([
   import_coreipc2.ipc.$operation
 ], RunServiceProxy.prototype, "ExecuteCommand", null);
+__legacyDecorateClassTS([
+  import_coreipc2.ipc.$operation
+], RunServiceProxy.prototype, "ApplyFileChanges", null);
 RunServiceProxy = __legacyDecorateClassTS([
   import_coreipc2.ipc.$service({ endpoint: "IRunService" })
 ], RunServiceProxy);
 function adaptRunServiceProxy(proxy) {
   return {
-    executeCommand: (command, filePath, inputArgumentsJson, inputVariablesJson, logLevel, profiling) => proxy.ExecuteCommand(command, filePath, inputArgumentsJson, inputVariablesJson, logLevel, profiling)
+    executeCommand: (command, filePath, inputArgumentsJson, inputVariablesJson, logLevel, profiling) => proxy.ExecuteCommand(command, filePath, inputArgumentsJson, inputVariablesJson, logLevel, profiling),
+    applyFileChanges: (fileChangesJson) => proxy.ApplyFileChanges(fileChangesJson)
   };
 }
 
@@ -43605,6 +43855,7 @@ class StudioServices {
   objectRepository;
   package;
   remoteDebugConfig;
+  remoteUiaSessionConfig;
   run;
   studioLifecycle;
   testing;
@@ -43623,6 +43874,7 @@ class StudioServices {
     this.objectRepository = adaptObjectRepositoryServiceProxy(import_coreipc2.ipc.proxy.withAddress(addr).withService(ObjectRepositoryServiceProxy));
     this.package = adaptPackageServiceProxy(import_coreipc2.ipc.proxy.withAddress(addr).withService(PackageServiceProxy));
     this.remoteDebugConfig = adaptRemoteDebugConfigServiceProxy(import_coreipc2.ipc.proxy.withAddress(addr).withService(RemoteDebugConfigServiceProxy));
+    this.remoteUiaSessionConfig = adaptRemoteUiaSessionConfigServiceProxy(import_coreipc2.ipc.proxy.withAddress(addr).withService(RemoteUiaSessionConfigServiceProxy));
     this.run = adaptRunServiceProxy(import_coreipc2.ipc.proxy.withAddress(addr).withService(RunServiceProxy));
     this.studioLifecycle = adaptStudioLifecycleServiceProxy(import_coreipc2.ipc.proxy.withAddress(addr).withService(StudioLifecycleServiceProxy));
     this.testing = adaptTestingServiceProxy(import_coreipc2.ipc.proxy.withAddress(addr).withService(TestingServiceProxy));
@@ -43783,6 +44035,9 @@ class HelmRunCallbackProxy {
   OnDebugStateChanged(state, localsJson) {
     throw null;
   }
+  OnProfilingEntry(entryJson) {
+    throw null;
+  }
 }
 __legacyDecorateClassTS([
   import_coreipc4.ipc.$operation
@@ -43790,6 +44045,9 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   import_coreipc4.ipc.$operation
 ], HelmRunCallbackProxy.prototype, "OnDebugStateChanged", null);
+__legacyDecorateClassTS([
+  import_coreipc4.ipc.$operation
+], HelmRunCallbackProxy.prototype, "OnProfilingEntry", null);
 HelmRunCallbackProxy = __legacyDecorateClassTS([
   import_coreipc4.ipc.$service({ endpoint: "IHelmRunCallback" })
 ], HelmRunCallbackProxy);
@@ -43797,16 +44055,23 @@ class HelmRunServiceProxy {
   ExecuteCommand(request) {
     throw null;
   }
+  ApplyFileChanges(request) {
+    throw null;
+  }
 }
 __legacyDecorateClassTS([
   import_coreipc4.ipc.$operation
 ], HelmRunServiceProxy.prototype, "ExecuteCommand", null);
+__legacyDecorateClassTS([
+  import_coreipc4.ipc.$operation
+], HelmRunServiceProxy.prototype, "ApplyFileChanges", null);
 HelmRunServiceProxy = __legacyDecorateClassTS([
   import_coreipc4.ipc.$service({ endpoint: "IHelmRunService" })
 ], HelmRunServiceProxy);
 function adaptHelmRunServiceProxy(proxy) {
   return {
-    executeCommand: (request) => proxy.ExecuteCommand({ Payload: request })
+    executeCommand: (request) => proxy.ExecuteCommand({ Payload: request }),
+    applyFileChanges: (request) => proxy.ApplyFileChanges(request)
   };
 }
 
@@ -43865,6 +44130,30 @@ function adaptRemoteDebugConfigServiceProxy2(proxy) {
   };
 }
 
+class RemoteUiaSessionConfigServiceProxy2 {
+  EnsureRemoteUiaSession() {
+    throw null;
+  }
+  StopRemoteUiaSession() {
+    throw null;
+  }
+}
+__legacyDecorateClassTS([
+  import_coreipc4.ipc.$operation
+], RemoteUiaSessionConfigServiceProxy2.prototype, "EnsureRemoteUiaSession", null);
+__legacyDecorateClassTS([
+  import_coreipc4.ipc.$operation
+], RemoteUiaSessionConfigServiceProxy2.prototype, "StopRemoteUiaSession", null);
+RemoteUiaSessionConfigServiceProxy2 = __legacyDecorateClassTS([
+  import_coreipc4.ipc.$service({ endpoint: "IRemoteUiaSessionConfigService" })
+], RemoteUiaSessionConfigServiceProxy2);
+function adaptRemoteUiaSessionConfigServiceProxy2(proxy) {
+  return {
+    ensureRemoteUiaSession: () => proxy.EnsureRemoteUiaSession(),
+    stopRemoteUiaSession: () => proxy.StopRemoteUiaSession()
+  };
+}
+
 class HelmServices {
   authContext;
   build;
@@ -43873,6 +44162,7 @@ class HelmServices {
   run;
   validation;
   remoteDebugConfig;
+  remoteUiaSessionConfig;
   constructor(pipeName) {
     trackPipe(pipeName);
     const addr = import_coreipc4.ipc.namedPipe(pipeName);
@@ -43883,6 +44173,7 @@ class HelmServices {
     this.run = adaptHelmRunServiceProxy(import_coreipc4.ipc.proxy.withAddress(addr).withService(HelmRunServiceProxy));
     this.validation = adaptHelmValidationServiceProxy(import_coreipc4.ipc.proxy.withAddress(addr).withService(HelmValidationServiceProxy));
     this.remoteDebugConfig = adaptRemoteDebugConfigServiceProxy2(import_coreipc4.ipc.proxy.withAddress(addr).withService(RemoteDebugConfigServiceProxy2));
+    this.remoteUiaSessionConfig = adaptRemoteUiaSessionConfigServiceProxy2(import_coreipc4.ipc.proxy.withAddress(addr).withService(RemoteUiaSessionConfigServiceProxy2));
   }
 }
 
@@ -43897,7 +44188,7 @@ import {
   unlinkSync as unlinkSync3,
   writeSync as writeSync2
 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/resolution/helm-run-slot.ts
 import {
@@ -43916,62 +44207,35 @@ import {
   writeSync
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join7 } from "node:path";
-
-// src/resolution/instance-matching.ts
-import { normalize } from "node:path";
-function normalizePath(path4) {
-  return normalize(path4).replace(/[\\/]+$/, "").toLowerCase();
-}
-function matchByProject(instances, projectDir) {
-  const target = normalizePath(projectDir);
-  return instances.find((i) => i.projectDirectory && normalizePath(i.projectDirectory) === target);
-}
-function findAvailableInstance(instances) {
-  return instances.find((i) => i.ipcEndpointName && i.executionStatus === "Available" /* Available */);
-}
-function findIdleInstance(instances) {
-  return instances.find((i) => i.ipcEndpointName && !i.projectDirectory && i.executionStatus === "Available" /* Available */);
-}
-function filterByBackend(instances, preference) {
-  switch (preference) {
-    case "helm" /* Helm */:
-      return instances.filter((i) => i.backendType === "Helm" /* Helm */);
-    case "studio" /* Studio */:
-      return instances.filter((i) => i.backendType !== "Helm" /* Helm */);
-    case "any" /* Any */:
-      return instances;
-  }
-}
-
-// src/resolution/helm-run-slot.ts
+import { join as join9 } from "node:path";
 var DEFAULT_MAX_SLOTS = 3;
 var READY_MARKER = ".ready";
 var STAGING_DIR = ".staging";
 var STALE_LOCK_MS = 5 * 60000;
 var RECENT_USE_MS = 60000;
 var STALE_STAGING_MS = 10 * 60000;
-var POLL_INTERVAL_MS = 250;
+var POLL_INTERVAL_MS2 = 250;
 var MAX_WAIT_MS = 180000;
 function resolveHelmCacheRoot() {
   const override = process.env.UIPATH_HELM_CACHE_DIR;
   if (override)
     return override;
   if (process.platform === "win32") {
-    const base = process.env.LOCALAPPDATA ?? join7(homedir3(), "AppData", "Local");
-    return join7(base, "UiPath", "Helm");
+    const base = process.env.LOCALAPPDATA ?? join9(homedir3(), "AppData", "Local");
+    return join9(base, "UiPath", "Helm");
   }
   if (process.platform === "darwin") {
-    return join7(homedir3(), "Library", "Caches", "UiPath", "Helm");
+    return join9(homedir3(), "Library", "Caches", "UiPath", "Helm");
   }
-  const xdg = process.env.XDG_CACHE_HOME ?? join7(homedir3(), ".cache");
-  return join7(xdg, "uipath", "helm");
+  const xdg = process.env.XDG_CACHE_HOME ?? join9(homedir3(), ".cache");
+  return join9(xdg, "uipath", "helm");
 }
 function slotName(version) {
-  return version.replace(/[\\/]/g, "_");
+  const safeVersion = version.replace(/[\\/]/g, "_");
+  return `${safeVersion}-${process.platform}-${process.arch}`;
 }
 function helmSlotDir(root, version) {
-  return join7(root, slotName(version));
+  return join9(root, slotName(version));
 }
 function touch(path4) {
   try {
@@ -44006,14 +44270,14 @@ function releaseLock(lockPath) {
   } catch {}
 }
 function publishSlot(sourceToolsDir, slot, root, version, log) {
-  const stagingRoot = join7(root, STAGING_DIR);
+  const stagingRoot = join9(root, STAGING_DIR);
   mkdirSync2(stagingRoot, { recursive: true });
-  const staging = join7(stagingRoot, `${slotName(version)}-${process.pid}-${Date.now().toString(36)}`);
+  const staging = join9(stagingRoot, `${slotName(version)}-${process.pid}-${Date.now().toString(36)}`);
   rmSync2(staging, { recursive: true, force: true });
   log(`Materializing Helm slot ${slot} from ${sourceToolsDir}`);
   cpSync(sourceToolsDir, staging, { recursive: true });
   const now = new Date;
-  const markerFd = openSync2(join7(staging, READY_MARKER), "w");
+  const markerFd = openSync2(join9(staging, READY_MARKER), "w");
   writeSync(markerFd, now.getTime().toString());
   closeSync2(markerFd);
   rmSync2(slot, { recursive: true, force: true });
@@ -44024,14 +44288,14 @@ function publishSlot(sourceToolsDir, slot, root, version, log) {
   }
 }
 function evictSlots(root, targetSlot, liveBinDirs, maxSlots, log) {
-  const entries = readdirSync3(root, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== STAGING_DIR).map((e) => join7(root, e.name)).filter((dir) => existsSync3(join7(dir, READY_MARKER)));
+  const entries = readdirSync3(root, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== STAGING_DIR).map((e) => join9(root, e.name)).filter((dir) => existsSync3(join9(dir, READY_MARKER)));
   if (entries.length <= maxSlots)
     return;
   const targetNorm = normalizePath(targetSlot);
   const now = Date.now();
   const readyMtime = (dir) => {
     try {
-      return statSync2(join7(dir, READY_MARKER)).mtimeMs;
+      return statSync2(join9(dir, READY_MARKER)).mtimeMs;
     } catch {
       return 0;
     }
@@ -44056,7 +44320,7 @@ function evictSlots(root, targetSlot, liveBinDirs, maxSlots, log) {
   }
 }
 function cleanupStale(root) {
-  const stagingRoot = join7(root, STAGING_DIR);
+  const stagingRoot = join9(root, STAGING_DIR);
   let entries;
   try {
     entries = readdirSync3(stagingRoot);
@@ -44065,7 +44329,7 @@ function cleanupStale(root) {
   }
   const now = Date.now();
   for (const name of entries) {
-    const dir = join7(stagingRoot, name);
+    const dir = join9(stagingRoot, name);
     const parts = name.split("-");
     const pid = Number.parseInt(parts[parts.length - 2] ?? "", 10);
     try {
@@ -44083,14 +44347,14 @@ async function ensureHelmSlot(opts) {
   const root = opts.cacheRoot ?? resolveHelmCacheRoot();
   const maxSlots = opts.maxSlots ?? DEFAULT_MAX_SLOTS;
   const slot = helmSlotDir(root, opts.version);
-  const readyPath = join7(slot, READY_MARKER);
+  const readyPath = join9(slot, READY_MARKER);
   const fromSource = () => ({
     toolsDir: opts.sourceToolsDir,
-    helmExePath: join7(opts.sourceToolsDir, opts.helmExeName)
+    helmExePath: join9(opts.sourceToolsDir, opts.helmExeName)
   });
   const fromSlot = () => {
     touch(readyPath);
-    return { toolsDir: slot, helmExePath: join7(slot, opts.helmExeName) };
+    return { toolsDir: slot, helmExePath: join9(slot, opts.helmExeName) };
   };
   if (existsSync3(readyPath)) {
     log(`Using cached Helm slot: ${slot}`);
@@ -44102,7 +44366,7 @@ async function ensureHelmSlot(opts) {
     log(`Cannot create Helm cache root ${root}; running from source.`);
     return fromSource();
   }
-  const lockPath = join7(root, `${slotName(opts.version)}.lock`);
+  const lockPath = join9(root, `${slotName(opts.version)}.lock`);
   const deadline = Date.now() + MAX_WAIT_MS;
   while (true) {
     if (existsSync3(readyPath))
@@ -44124,7 +44388,7 @@ async function ensureHelmSlot(opts) {
       log("Timed out waiting for Helm slot; running from source.");
       return fromSource();
     }
-    await sleep(POLL_INTERVAL_MS);
+    await sleep(POLL_INTERVAL_MS2);
   }
   if (!existsSync3(readyPath))
     return fromSource();
@@ -44141,10 +44405,10 @@ async function ensureHelmSlot(opts) {
 var LOCK_SUBDIR = "project-locks";
 var STALE_LOCK_MS2 = 5 * 60000;
 var DEFAULT_MAX_WAIT_MS = 120000;
-var POLL_INTERVAL_MS2 = 250;
+var POLL_INTERVAL_MS3 = 250;
 function lockFilePath(root, lockKey) {
   const hash = createHash2("sha256").update(lockKey).digest("hex").slice(0, 32);
-  return join8(root, LOCK_SUBDIR, `${hash}.lock`);
+  return join10(root, LOCK_SUBDIR, `${hash}.lock`);
 }
 function tryAcquireLock2(lockPath, log) {
   let fd;
@@ -44195,7 +44459,7 @@ async function withProjectSpawnLock(lockKey, fn, options = {}) {
   const root = options.cacheRoot ?? resolveHelmCacheRoot();
   const maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
   try {
-    mkdirSync3(join8(root, LOCK_SUBDIR), { recursive: true });
+    mkdirSync3(join10(root, LOCK_SUBDIR), { recursive: true });
   } catch {
     log(`Cannot create project-lock directory under ${root}; proceeding without cross-process lock.`);
     return fn();
@@ -44208,7 +44472,7 @@ async function withProjectSpawnLock(lockKey, fn, options = {}) {
         log("Timed out waiting for the project spawn lock; proceeding without it.");
         return fn();
       }
-      await sleep(POLL_INTERVAL_MS2);
+      await sleep(POLL_INTERVAL_MS3);
     }
   } catch (err) {
     log(`Project spawn lock unavailable (${err instanceof Error ? err.message : String(err)}); proceeding without it.`);
@@ -44221,6 +44485,72 @@ async function withProjectSpawnLock(lockKey, fn, options = {}) {
   }
 }
 
+// src/resolution/runtime-arch.ts
+import { execFileSync as execFileSync5 } from "node:child_process";
+var PROBE_TIMEOUT_MS = 1e4;
+var DOTNET_TO_NODE_ARCH = {
+  x64: "x64",
+  arm64: "arm64",
+  x86: "ia32",
+  arm: "arm"
+};
+var PATH_DOTNET = "dotnet";
+function parseRuntimeArch(info) {
+  const rid = /\b(?:win\d*|osx|linux|freebsd)(?:-musl)?-(x64|arm64|x86|arm)\b/.exec(info);
+  const label = /^\s*Architecture:\s*(\S+)/m.exec(info);
+  const arch3 = rid?.[1] ?? label?.[1];
+  return arch3 ? DOTNET_TO_NODE_ARCH[arch3] ?? arch3 : undefined;
+}
+function probeDotnetInfo(dotnetPath = PATH_DOTNET) {
+  return execFileSync5(dotnetPath, ["--info"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: PROBE_TIMEOUT_MS,
+    env: { ...process.env, DOTNET_CLI_UI_LANGUAGE: "en" }
+  });
+}
+var pinnedDotnetPath;
+function getPinnedDotnetPath() {
+  return pinnedDotnetPath;
+}
+var NODE_LOOKUP_HINT = process.platform === "win32" ? "where.exe node" : "command -v -a node";
+var REMEDY = "npm selects the Helm binaries from the architecture of the node that " + "installs the CLI, and that install is usually automatic — so start from " + `the node your PATH resolves (\`${NODE_LOOKUP_HINT}\`) and make sure the ` + "CLI is installed by a node whose architecture matches your dotnet " + "(`npm uninstall -g @uipath/rpa-tool && npm install -g @uipath/rpa-tool`). " + "Installing a .NET runtime that matches the Helm binaries works too.";
+function measure(origin, path4, probe) {
+  try {
+    return { origin, path: path4, arch: parseRuntimeArch(probe(path4)) };
+  } catch {
+    return { origin, path: path4 };
+  }
+}
+function findRuntimeArchMismatch(opts) {
+  if (process.env.HELM_LOCAL_DIR) {
+    return null;
+  }
+  const probe = opts?.probe ?? probeDotnetInfo;
+  const pinned = opts?.dotnetPath;
+  const helmArch = process.arch;
+  const hosting = pinned ? measure("bundled with the Robot install", pinned, probe) : measure("on PATH", PATH_DOTNET, probe);
+  if (hosting.arch === helmArch) {
+    return null;
+  }
+  const others = pinned ? [measure("on PATH", PATH_DOTNET, probe)] : [];
+  const alsoProbed = others.length ? ` Also probed: ${others.map((r) => `dotnet ${r.origin} (${r.arch ?? "could not be read"})`).join(", ")}.` : "";
+  const resolved = `The Helm binaries this CLI resolved are ${process.platform}-${helmArch}`;
+  const host = `the dotnet hosting them (${hosting.origin}: ${hosting.path})`;
+  return hosting.arch === undefined ? {
+    helmArch,
+    hosting,
+    probed: [hosting, ...others],
+    summary: `${resolved}, and ${host} could not be interrogated. Their ` + "assemblies are ReadyToRun images, which only a runtime of " + "the same architecture can load, so an architecture " + `mismatch is the likeliest cause.${alsoProbed}`,
+    remedy: "Compare the two: `dotnet --info` reports the runtime's " + `architecture, which must be ${helmArch}. ${REMEDY}`
+  } : {
+    helmArch,
+    hosting,
+    probed: [hosting, ...others],
+    summary: `${resolved}, but ${host} is ${hosting.arch}. Their ` + "assemblies are ReadyToRun images, so a runtime of another " + `architecture cannot load them.${alsoProbed}`,
+    remedy: REMEDY
+  };
+}
 // src/resolution/resolver-deps.ts
 var defaultResolverDeps = {
   readInstanceStatus(processId) {
@@ -44240,7 +44570,7 @@ var defaultResolverDeps = {
   isProcessAlive,
   discoverInstances,
   executeCommand(command, args) {
-    return execFileSync5(command, args, {
+    return execFileSync6(command, args, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -44291,179 +44621,11 @@ var defaultResolverDeps = {
   },
   withProjectSpawnLock(lockKey, fn, log) {
     return withProjectSpawnLock(lockKey, fn, { log });
+  },
+  probeDotnetInfo(dotnetPath) {
+    return probeDotnetInfo(dotnetPath);
   }
 };
-var DEFAULT_TIMEOUT_MS2 = 60000;
-var POLL_INTERVAL_MS3 = 1000;
-var INTEROP_MANIFEST = "interop-manifest.json";
-var STUDIO_EXE = "UiPath.Studio.exe";
-var STUDIO_SUBDIR = "Studio";
-var ROBOT_SUBDIR = "Robot";
-var HELM_EXE = process.platform === "win32" ? "UiPath.Studio.Helm.exe" : "UiPath.Studio.Helm";
-
-// src/resolution/robot-bin-resolver.ts
-var LOCAL_ROBOT_FEEDS_ENV = "UIPATH_LOCAL_ROBOT_FEEDS";
-function robotNugetConfigPath(robotDir) {
-  return join9(robotDir, "NuGet.config");
-}
-var ROBOT_WINDOWS_MARKER = "UiRobot.exe";
-var ROBOT_MACOS_MARKER = "UiRobot.dll";
-var MACOS_ASSISTANT_ROBOT_PATH = "/Applications/UiPath Assistant.app/Contents/Robot";
-var REGISTRY_HIVES = [
-  "HKCU\\Software\\UiPath\\UiPath Studio",
-  "HKLM\\Software\\UiPath\\UiPath Studio"
-];
-function queryRegistryValue(valueName, deps) {
-  for (const hive of REGISTRY_HIVES) {
-    try {
-      const output = deps.executeCommand("reg", [
-        "query",
-        hive,
-        "/v",
-        valueName
-      ]);
-      const match = output.match(new RegExp(`${valueName}\\s+REG_SZ\\s+(.+)`));
-      if (match)
-        return match[1].trim();
-    } catch {}
-  }
-  return;
-}
-function resolveRobotComponentDir(installRoot, deps) {
-  const nested = win32.join(installRoot, ROBOT_SUBDIR);
-  return deps.fileExists(win32.join(nested, ROBOT_WINDOWS_MARKER)) ? nested : installRoot;
-}
-function resolveRobotDir(cliPath, deps) {
-  if (cliPath) {
-    deps.log(`Using --robot-dir: ${cliPath}`);
-    return cliPath;
-  }
-  const envPath = process.env.UIPATH_ROBOT_DIR;
-  if (envPath) {
-    deps.log(`Using UIPATH_ROBOT_DIR: ${envPath}`);
-    return envPath;
-  }
-  if (process.platform === "win32") {
-    const robotDir = queryRegistryValue("RobotDir", deps);
-    if (robotDir) {
-      deps.log(`Resolved robot dir from registry: ${robotDir}`);
-      return robotDir;
-    }
-    const installRoot = queryRegistryValue("InstallDir", deps);
-    if (installRoot) {
-      const dir = resolveRobotComponentDir(installRoot, deps);
-      deps.log(`Resolved robot dir from registry: ${dir}`);
-      return dir;
-    }
-  }
-  if (process.platform === "darwin") {
-    if (deps.fileExists(posix.join(MACOS_ASSISTANT_ROBOT_PATH, ROBOT_MACOS_MARKER))) {
-      deps.log(`Found robot at well-known path: ${MACOS_ASSISTANT_ROBOT_PATH}`);
-      return MACOS_ASSISTANT_ROBOT_PATH;
-    }
-  }
-  deps.log("Robot dir not resolved — Robot must already be running");
-  return null;
-}
-var DOTNET_ROLL_FORWARD_ENV = {
-  DOTNET_ROLL_FORWARD: "Major"
-};
-var MIN_BUNDLED_DOTNET_MAJOR = 8;
-function detectDotnetRuntimeMajor(dotnetRoot, deps) {
-  let entries;
-  try {
-    entries = deps.readDir(join9(dotnetRoot, "shared", "Microsoft.NETCore.App"));
-  } catch {
-    return;
-  }
-  let max;
-  for (const entry of entries) {
-    const match = /^(\d+)\./.exec(entry);
-    if (!match)
-      continue;
-    const major = Number.parseInt(match[1], 10);
-    if (!Number.isNaN(major) && (max === undefined || major > max)) {
-      max = major;
-    }
-  }
-  return max;
-}
-function resolveBundledDotnet(robotDir, deps) {
-  if (!robotDir)
-    return;
-  const exePath = process.platform === "win32" ? join9(robotDir, "dotnet.exe") : join9(robotDir, "dotnet", "dotnet");
-  if (!deps.fileExists(exePath))
-    return;
-  const dotnetRoot = process.platform === "win32" ? robotDir : join9(robotDir, "dotnet");
-  const runtimeMajor = detectDotnetRuntimeMajor(dotnetRoot, deps);
-  if (runtimeMajor === undefined || runtimeMajor < MIN_BUNDLED_DOTNET_MAJOR) {
-    const reason = runtimeMajor === undefined ? "could not determine its .NET runtime version" : `highest .NET runtime major ${runtimeMajor} is below the required ${MIN_BUNDLED_DOTNET_MAJOR}`;
-    deps.log(`Ignoring bundled dotnet at ${exePath}: ${reason}. ` + `Falling back to the system dotnet so Helm can find a compatible runtime.`);
-    return;
-  }
-  return {
-    exePath,
-    env: {
-      DOTNET_ROOT: dotnetRoot,
-      DOTNET_MULTILEVEL_LOOKUP: "0",
-      ...DOTNET_ROLL_FORWARD_ENV
-    }
-  };
-}
-
-// src/resolution/feed-control.ts
-function resolveBundledFeedEnv(robotDir) {
-  if (!robotDir || process.env[LOCAL_ROBOT_FEEDS_ENV]) {
-    return {};
-  }
-  return { [LOCAL_ROBOT_FEEDS_ENV]: robotNugetConfigPath(robotDir) };
-}
-async function composeOrchestratorFeedsEnv(compose, log) {
-  if (process.env[ORCHESTRATOR_RESTORE_FEEDS_ENV] || !compose) {
-    return {};
-  }
-  const feedsPath = await compose(log);
-  if (!feedsPath) {
-    return {};
-  }
-  return { [ORCHESTRATOR_RESTORE_FEEDS_ENV]: feedsPath };
-}
-function toSessionConnection(status) {
-  if (status.loginStatus !== "Logged in" || !status.accessToken || !status.baseUrl) {
-    return;
-  }
-  let base = status.baseUrl;
-  while (base.endsWith("/")) {
-    base = base.slice(0, -1);
-  }
-  const segments = [];
-  if (status.organizationName) {
-    segments.push(status.organizationName);
-    if (status.tenantName) {
-      segments.push(status.tenantName);
-    }
-  }
-  const cloudUrl = segments.length ? `${base}/${segments.join("/")}` : base;
-  return {
-    accessToken: status.accessToken,
-    cloudUrl,
-    tenantId: status.tenantId
-  };
-}
-async function resolveSessionConnection() {
-  try {
-    const auth = await Promise.resolve().then(() => (init_dist(), exports_dist));
-    const status = await auth.getLoginStatusAsync({
-      ensureTokenValidityMinutes: 5
-    });
-    if (status.loginStatus && status.loginStatus !== "Logged in" && status.loginStatus !== "Logged out") {
-      logger.warn(`Tenant Orchestrator feeds skipped: the login session is '${status.loginStatus}' — run 'uip login' to restore it.`);
-    }
-    return toSessionConnection(status);
-  } catch {
-    return;
-  }
-}
 
 // src/telemetry/failure-classification.ts
 var NUGET_MISSING = /\bNU110[12]\b/;
@@ -44518,6 +44680,27 @@ function asTypeName(value) {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
+// src/commands/packager/runtime-arch-mismatch.ts
+var STARTUP_CRASH = /Unhandled exception\./;
+var LOADER_FAULT = /BadImageFormatException|FileLoadException/;
+var HOST_ARCH_FAULT = /Bad CPU type in executable|ENOEXEC|EBADARCH|spawn\S*\s+\S.*\sUNKNOWN/;
+function looksLikeStartupFailure(rawMessage) {
+  return STARTUP_CRASH.test(rawMessage) && LOADER_FAULT.test(rawMessage) || HOST_ARCH_FAULT.test(rawMessage);
+}
+function detectRuntimeArchMismatchFailure(label, rawMessage, probe = probeDotnetInfo) {
+  if (!looksLikeStartupFailure(rawMessage)) {
+    return null;
+  }
+  const mismatch = findRuntimeArchMismatch({
+    dotnetPath: getPinnedDotnetPath(),
+    probe
+  });
+  if (mismatch === null) {
+    return null;
+  }
+  return new FailureOutput("ConfigError", `${label} failed: ${mismatch.summary.charAt(0).toLowerCase()}${mismatch.summary.slice(1)} ` + "The loader error above is that mismatch, not a problem with the project.", mismatch.remedy, undefined, "configuration_error", "RetryWillNotFix");
+}
+
 // src/commands/packager/packager-shared.ts
 var LOG_LEVEL_NAMES = ["Debug", "Info", "Warn", "Error"];
 var GOVERNANCE_FILE_TYPES = ["Default", "AutomationOps", "Studio"];
@@ -44530,7 +44713,7 @@ var OUTPUT_TYPES = [
   "Template"
 ];
 function addCommonPackagerOptions(cmd) {
-  return cmd.addOption(new Option2("--log-level <level>", "Log level").choices(LOG_LEVEL_NAMES).default("Warn")).option("--exclude-configured-sources", "Exclude user/machine configured NuGet sources").option("--nuget-sources-config-path <path>", "Path to NuGet sources configuration file").addOption(new Option2("--format <format>", "Output format").choices(["table", "json", "yaml", "plain"]).argParser((val) => val.toLowerCase()).default("json"));
+  return cmd.option("--project-dir <path>", "Path to the UiPath project directory. Alternative to the positional argument; defaults to the current directory.").addOption(new Option2("--log-level <level>", "Log level").choices(LOG_LEVEL_NAMES).default("Warn")).option("--exclude-configured-sources", "Exclude user/machine configured NuGet sources").option("--nuget-sources-config-path <path>", "Path to NuGet sources configuration file").addOption(new Option2("--format <format>", "Output format").choices(["table", "json", "yaml", "plain"]).argParser((val) => val.toLowerCase()).default("json"));
 }
 async function createPackager() {
   await loadPackagerTool();
@@ -44563,6 +44746,9 @@ function emitAnalyzerFailureResult(projectDir, action, result) {
   }
   emitAnalyzeResult(projectDir, action, { errorCount: summary.errorCount }, summary.ruleIds);
 }
+function resolvePackagerProjectDir(positional, option, defaultProjectDir) {
+  return positional ?? option ?? defaultProjectDir ?? process.cwd();
+}
 function resolveProjectInput(projectDir) {
   const abs = resolve6(projectDir);
   let stats;
@@ -44613,8 +44799,8 @@ function createTemporaryFeedsConfig(feeds) {
   if (feeds.length === 0) {
     return;
   }
-  const directory = mkdtempSync2(join12(tmpdir7(), "rpa-tool-nuget-"));
-  const path4 = join12(directory, "nuget-feeds.json");
+  const directory = mkdtempSync2(join13(tmpdir7(), "rpa-tool-nuget-"));
+  const path4 = join13(directory, "nuget-feeds.json");
   try {
     writeFileSync2(path4, JSON.stringify(feeds));
   } catch (error) {
@@ -44699,14 +44885,14 @@ async function runPackagerCommand(opts, config) {
     return false;
   }
   const projectDir = resolve6(rawProjectDir);
-  opts = { ...opts, projectDir };
+  const resolvedOpts = { ...opts, projectDir };
   const LOGGER_LEVELS = {
     Debug: LogLevel.DEBUG,
     Info: LogLevel.INFO,
     Warn: LogLevel.WARN,
     Error: LogLevel.ERROR
   };
-  const requestedLevel = LOGGER_LEVELS[opts.logLevel];
+  const requestedLevel = LOGGER_LEVELS[resolvedOpts.logLevel];
   if (requestedLevel !== undefined && requestedLevel < logger.getLevel()) {
     configureLogger({ level: requestedLevel });
   }
@@ -44717,17 +44903,17 @@ async function runPackagerCommand(opts, config) {
   }
   try {
     const packager = await createPackager();
-    const setupInput = resolveProjectInput(opts.projectDir);
+    const setupInput = resolveProjectInput(projectDir);
     const inputPath = await packager.setupAsync(setupInput);
-    const options = await buildBaseOptions(opts);
+    const options = await buildBaseOptions(resolvedOpts);
     options.inputPath = inputPath;
     options.connection = await resolveSessionConnection();
-    const { path: feedsPath, temp } = await assembleFeedsConfig(opts);
+    const { path: feedsPath, temp } = await assembleFeedsConfig(resolvedOpts);
     temporaryFeedsConfig = temp;
     if (feedsPath) {
       options.nuGetSourcesConfigPath = feedsPath;
     }
-    const result = await config.execute(packager, options, opts);
+    const result = await config.execute(packager, options, resolvedOpts);
     const succeeded = config.isSuccessfulResult ? config.isSuccessfulResult(result) : result.isSuccess;
     if (succeeded) {
       const data = config.formatSuccess?.(result) ?? { Success: true };
@@ -44739,7 +44925,7 @@ async function runPackagerCommand(opts, config) {
     } catch {}
     const rawFailure = result.message ?? (result.errorCode ? `Error code: ${result.errorCode}` : "Unknown error");
     const lockFailure = detectLockedProjectFilesFailure(config.label, rawFailure);
-    const failure = lockFailure ?? new FailureOutput("Failure", `${config.label} failed: ${rawFailure}`, config.hint);
+    const failure = lockFailure ?? detectRuntimeArchMismatchFailure(config.label, rawFailure) ?? new FailureOutput("Failure", `${config.label} failed: ${rawFailure}`, config.hint);
     failure.TelemetryErrorClass = classifyFailure({
       errorCode: result.errorCode,
       message: rawFailure,
@@ -44750,7 +44936,7 @@ async function runPackagerCommand(opts, config) {
   } catch (error) {
     const rawFailure = error instanceof Error ? error.message : String(error);
     const lockFailure = detectLockedProjectFilesFailure(config.label, rawFailure);
-    const failure = lockFailure ?? new FailureOutput("Failure", `${config.label} failed: ${rawFailure}`, config.hint);
+    const failure = lockFailure ?? detectRuntimeArchMismatchFailure(config.label, rawFailure) ?? new FailureOutput("Failure", `${config.label} failed: ${rawFailure}`, config.hint);
     failure.TelemetryErrorClass = classifyFailure({
       message: rawFailure,
       isFileLock: lockFailure !== null
@@ -44763,11 +44949,12 @@ async function runPackagerCommand(opts, config) {
 }
 
 // src/commands/packager/analyze.ts
-function registerAnalyzeCommand(program4) {
+function registerAnalyzeCommand(program4, defaultProjectDir) {
   const cmd = program4.command("analyze").description("Validate and analyze a UiPath project");
-  cmd.argument("<project-dir>", "Path to the UiPath project directory, project.json file, or .uip archive");
-  addCommonPackagerOptions(cmd).option("--skip-analyze", "Skip the analysis step").option("--default-severity <level>", "Default severity for analysis rules").option("--governance-file-path <path>", "Path to governance/policy rules file").addOption(new Option2("--governance-file-type <type>", "Type of governance file").choices(GOVERNANCE_FILE_TYPES)).option("--detailed-log-path <path>", "Path where detailed log file is written").option("--repository-path <path>", "Repository root for resolving relative project paths (Pipeline Analyze parity)").option("--policy-file <path>", "Analyzer policy file. Alias for --governance-file-path (Pipeline Analyze parity).").addOption(new Option2("--policy-file-type <type>", "Policy file type. Alias for --governance-file-type. " + "Defaults to AutomationOps when a policy/governance file is provided; otherwise the packager default is used.").choices(GOVERNANCE_FILE_TYPES)).trackedAction(processContext, async (projectDir, opts) => {
-    opts.projectDir = resolveProjectDir(projectDir, opts);
+  cmd.argument("[project-dir]", "Path to the UiPath project directory, project.json file, or .uip archive. Defaults to --project-dir, or the current directory.");
+  addCommonPackagerOptions(cmd).option("--skip-analyze", "Skip the analysis step").option("--default-severity <level>", "Default severity for analysis rules").option("--governance-file-path <path>", "Path to governance/policy rules file").addOption(new Option2("--governance-file-type <type>", "Type of governance file").choices(GOVERNANCE_FILE_TYPES)).option("--detailed-log-path <path>", "Path where detailed log file is written").option("--repository-path <path>", "Repository root for resolving relative project paths (Pipeline Analyze parity)").option("--policy-file <path>", "Analyzer policy file. Alias for --governance-file-path (Pipeline Analyze parity).").addOption(new Option2("--policy-file-type <type>", "Policy file type. Alias for --governance-file-type. " + "Defaults to AutomationOps when a policy/governance file is provided; otherwise the packager default is used.").choices(GOVERNANCE_FILE_TYPES)).trackedAction(processContext, async (projectDirArg, opts) => {
+    const projectDir = resolveProjectDir(projectDirArg, opts, defaultProjectDir);
+    opts.projectDir = projectDir;
     const success = await runPackagerCommand(opts, {
       label: "Analyze",
       hint: "Check project path and governance configuration.",
@@ -44795,7 +44982,7 @@ function registerAnalyzeCommand(program4) {
       formatSuccess: (result) => {
         const findings = extractFindings(result);
         const summary = summarizeFindings(findings);
-        emitAnalyzeResult(opts.projectDir, "analyze", {
+        emitAnalyzeResult(projectDir, "analyze", {
           errorCount: summary.Critical + summary.Error,
           findingCount: findings.length,
           warningCount: summary.Warning,
@@ -44810,19 +44997,20 @@ function registerAnalyzeCommand(program4) {
     });
     if (!success)
       processContext.exit(1);
-  }, (projectDir, opts) => {
-    const dir = resolveProjectDir(projectDir, opts);
+  }, (projectDirArg, opts) => {
+    const dir = resolveProjectDir(projectDirArg, opts, defaultProjectDir);
     return buildStudioShapedProps(dir, {
       action: "analyze",
       ...getProjectShapeProps(dir)
     });
   });
 }
-function resolveProjectDir(projectDir, opts) {
-  if (!opts.repositoryPath || isAbsolute6(projectDir)) {
-    return projectDir;
+function resolveProjectDir(projectDir, opts, defaultProjectDir) {
+  const dir = resolvePackagerProjectDir(projectDir, opts.projectDir, defaultProjectDir);
+  if (!opts.repositoryPath || isAbsolute6(dir)) {
+    return dir;
   }
-  return join13(opts.repositoryPath, projectDir);
+  return join14(opts.repositoryPath, dir);
 }
 function resolveGovernanceFileType(opts) {
   if (opts.policyFileType)
@@ -44958,10 +45146,11 @@ function isRecord3(value) {
 }
 
 // src/commands/packager/build.ts
-function registerBuildCommand(program4) {
+function registerBuildCommand(program4, defaultProjectDir) {
   const cmd = program4.command("build").description("Build (compile) a UiPath project");
-  cmd.argument("<project-dir>", "Path to the UiPath project directory");
-  addCommonPackagerOptions(cmd).option("--skip-analyze", "Skip the analysis step").option("--governance-file-path <path>", "Path to governance/policy rules file").addOption(new Option2("--governance-file-type <type>", "Type of governance file").choices(GOVERNANCE_FILE_TYPES)).option("--detailed-log-path <path>", "Path where detailed log file is written").trackedAction(processContext, async (projectDir, opts) => {
+  cmd.argument("[project-dir]", "Path to the UiPath project directory. Defaults to --project-dir, or the current directory.");
+  addCommonPackagerOptions(cmd).option("--skip-analyze", "Skip the analysis step").option("--governance-file-path <path>", "Path to governance/policy rules file").addOption(new Option2("--governance-file-type <type>", "Type of governance file").choices(GOVERNANCE_FILE_TYPES)).option("--detailed-log-path <path>", "Path where detailed log file is written").trackedAction(processContext, async (projectDirArg, opts) => {
+    const projectDir = resolvePackagerProjectDir(projectDirArg, opts.projectDir, defaultProjectDir);
     opts.projectDir = projectDir;
     const success = await runPackagerCommand(opts, {
       label: "Build",
@@ -44981,14 +45170,17 @@ function registerBuildCommand(program4) {
         }
         return packager.buildProjectAsync(options);
       },
-      onFailure: (result) => emitAnalyzerFailureResult(opts.projectDir, "build", result)
+      onFailure: (result) => emitAnalyzerFailureResult(projectDir, "build", result)
     });
     if (!success)
       processContext.exit(1);
-  }, (projectDir) => buildStudioShapedProps(projectDir, {
-    action: "build",
-    ...getProjectShapeProps(projectDir)
-  }));
+  }, (projectDirArg, opts) => {
+    const dir = resolvePackagerProjectDir(projectDirArg, opts.projectDir, defaultProjectDir);
+    return buildStudioShapedProps(dir, {
+      action: "build",
+      ...getProjectShapeProps(dir)
+    });
+  });
 }
 
 // src/commands/packager/cleanup.ts
@@ -45004,16 +45196,17 @@ function isUipArchive(projectDir) {
     return false;
   }
 }
-function registerCleanupCommand(program4) {
+function registerCleanupCommand(program4, defaultProjectDir) {
   const cmd = program4.command("cleanup").description("Remove unused items from a UiPath project (modifies the project sources in place). Pass --dry-run to only detect unused items.");
-  cmd.argument("<project-dir>", "Path to the UiPath project directory, project.json file, or .uip archive (archives require --dry-run)");
+  cmd.argument("[project-dir]", "Path to the UiPath project directory, project.json file, or .uip archive (archives require --dry-run). Defaults to --project-dir, or the current directory.");
   addCommonPackagerOptions(cmd).option("--dry-run", "Detect unused items but do not modify any project files.").option("--skip-imports", "Do not clean up now-unused references to removed items in the project's files.").trackedAction(processContext, async (projectDir, opts) => {
-    if (!opts.dryRun && isUipArchive(projectDir)) {
-      OutputFormatter.error(new FailureOutput("Failure", `Cleanup failed: in-place cleanup of a .uip archive is not supported — changes would be written to a temporary extraction and then discarded, leaving '${projectDir}' unchanged.`, "Re-run with --dry-run to only detect unused items, or point at the project directory to modify it in place."));
+    const dir = resolvePackagerProjectDir(projectDir, opts.projectDir, defaultProjectDir);
+    if (!opts.dryRun && isUipArchive(dir)) {
+      OutputFormatter.error(new FailureOutput("Failure", `Cleanup failed: in-place cleanup of a .uip archive is not supported — changes would be written to a temporary extraction and then discarded, leaving '${dir}' unchanged.`, "Re-run with --dry-run to only detect unused items, or point at the project directory to modify it in place."));
       processContext.exit(1);
       return;
     }
-    opts.projectDir = projectDir;
+    opts.projectDir = dir;
     const success = await runPackagerCommand(opts, {
       label: "Cleanup",
       hint: "Check the project path and that the current login has access to the tenant.",
@@ -45044,10 +45237,17 @@ function registerCleanupCommand(program4) {
 
 // src/commands/packager/pack.ts
 import { isAbsolute as isAbsolute7, resolve as resolve8 } from "node:path";
-function registerPackCommand(program4) {
+function registerPackCommand(program4, defaultProjectDir) {
   const cmd = program4.command("pack").description("Pack a UiPath project into a .nupkg (compiles, validates, and bundles).");
-  cmd.argument("<project-dir>", "Path to the UiPath project directory, project.json file, or .uip archive").argument("<output-path>", "Directory where .nupkg is written.");
-  addCommonPackagerOptions(cmd).option("--package-id <id>", "NuGet package ID").option("--package-version <version>", "NuGet package version").option("--package-author <author>", "NuGet package author").option("--package-description <desc>", "NuGet package description").option("--skip-analyze", "Skip the analysis step").option("--skip-dependency-optimization", "Skip dependency optimization").option("--include-sources", "Include source files in the package").option("--split-packages", "Split into multiple packages").option("--governance-file-path <path>", "Path to governance/policy rules file").addOption(new Option2("--governance-file-type <type>", "Type of governance file").choices(GOVERNANCE_FILE_TYPES)).option("--detailed-log-path <path>", "Path where detailed log file is written").option("--signing-certificate-path <path>", "Path to .pfx certificate file").option("--signing-certificate-password <password>", "Certificate password").option("--signing-timestamp-server <url>", "Timestamp server URL").addOption(new Option2("--output-type <type>", "Package output type (Pipeline Build parity)").choices(OUTPUT_TYPES)).option("--project-url <url>", "Project URL package metadata").option("--repository-type <type>", "Repository type package metadata").option("--repository-url <url>", "Repository URL package metadata").option("--repository-branch <branch>", "Repository branch package metadata").option("--repository-commit <commit>", "Repository commit package metadata").option("--release-notes <text>", "Package release notes").trackedAction(processContext, async (projectDir, outputPath, opts) => {
+  cmd.argument("[project-dir]", "Path to the UiPath project directory, project.json file, or .uip archive. Defaults to --project-dir, or the current directory.").argument("[output-path]", "Directory where .nupkg is written. Required — pass it here or as --output-path.");
+  addCommonPackagerOptions(cmd).option("--output-path <path>", "Directory where .nupkg is written. Alternative to the positional argument; required when the positional is omitted.").option("--package-id <id>", "NuGet package ID").option("--package-version <version>", "NuGet package version").option("--package-author <author>", "NuGet package author").option("--package-description <desc>", "NuGet package description").option("--skip-analyze", "Skip the analysis step").option("--skip-dependency-optimization", "Skip dependency optimization").option("--include-sources", "Include source files in the package").option("--split-packages", "Split into multiple packages").option("--governance-file-path <path>", "Path to governance/policy rules file").addOption(new Option2("--governance-file-type <type>", "Type of governance file").choices(GOVERNANCE_FILE_TYPES)).option("--detailed-log-path <path>", "Path where detailed log file is written").option("--signing-certificate-path <path>", "Path to .pfx certificate file").option("--signing-certificate-password <password>", "Certificate password").option("--signing-timestamp-server <url>", "Timestamp server URL").addOption(new Option2("--output-type <type>", "Package output type (Pipeline Build parity)").choices(OUTPUT_TYPES)).option("--project-url <url>", "Project URL package metadata").option("--repository-type <type>", "Repository type package metadata").option("--repository-url <url>", "Repository URL package metadata").option("--repository-branch <branch>", "Repository branch package metadata").option("--repository-commit <commit>", "Repository commit package metadata").option("--release-notes <text>", "Package release notes").trackedAction(processContext, async (projectDirArg, outputPathArg, opts) => {
+    const outputPath = outputPathArg ?? opts.outputPath;
+    if (!outputPath) {
+      OutputFormatter.error(new FailureOutput("Failure", "Pack failed: an output path is required.", "Pass it as the second argument (`pack <project-dir> <output-path>`) or as `--output-path <path>`. It must be a directory outside the project tree."));
+      processContext.exit(1);
+      return;
+    }
+    const projectDir = resolvePackagerProjectDir(projectDirArg, opts.projectDir, defaultProjectDir);
     opts.projectDir = projectDir;
     opts.outputPath = outputPath;
     const absoluteOutputPath = absolutePath(outputPath);
@@ -45110,7 +45310,7 @@ function registerPackCommand(program4) {
         const firstPackage = packages[0] ?? "";
         const packagePath = firstPackage ? absolutePath(firstPackage) : "";
         const packageMetadata = inferPackageMetadata(packagePath, opts.packageVersion);
-        emitPackResult(opts.projectDir, packageMetadata);
+        emitPackResult(projectDir, packageMetadata);
         return {
           Success: true,
           Packages: packages,
@@ -45121,14 +45321,17 @@ function registerPackCommand(program4) {
           OutputType: opts.outputType ?? ""
         };
       },
-      onFailure: (result) => emitAnalyzerFailureResult(opts.projectDir, "pack", result)
+      onFailure: (result) => emitAnalyzerFailureResult(projectDir, "pack", result)
     });
     if (!success)
       processContext.exit(1);
-  }, (projectDir) => buildStudioShapedProps(projectDir, {
-    action: "pack",
-    ...getProjectShapeProps(projectDir)
-  }));
+  }, (projectDirArg, _outputPathArg, opts) => {
+    const dir = resolvePackagerProjectDir(projectDirArg, opts.projectDir, defaultProjectDir);
+    return buildStudioShapedProps(dir, {
+      action: "pack",
+      ...getProjectShapeProps(dir)
+    });
+  });
 }
 function absolutePath(filePath) {
   return isAbsolute7(filePath) ? filePath : resolve8(filePath);
@@ -45170,22 +45373,23 @@ function packageFileStem(packagePath) {
 // src/commands/packager/restore.ts
 import { mkdtempSync as mkdtempSync3 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
-import { join as join14 } from "node:path";
-function registerRestoreCommand(program4) {
+import { join as join15 } from "node:path";
+function registerRestoreCommand(program4, defaultProjectDir) {
   const cmd = program4.command("restore").description("Restore NuGet dependencies for a UiPath project. " + "With outputPath, additionally assembles " + "dependencies in that directory for CI/CD and air-gapped workflows where " + "dependencies must be shipped across an isolation boundary. " + "When provided, outputPath must be OUTSIDE the project directory tree.");
-  cmd.argument("<project-dir>", "Path to the UiPath project directory").argument("[output-path]", "Optional target directory for assembled dependencies. Must be OUTSIDE the project directory tree. Omit to restore into the shared NuGet cache only.");
+  cmd.argument("[project-dir]", "Path to the UiPath project directory. Defaults to --project-dir, or the current directory.").argument("[output-path]", "Optional target directory for assembled dependencies. Must be OUTSIDE the project directory tree. Omit to restore into the shared NuGet cache only. A single positional binds to project-dir, so pass both to set an output path.");
   addCommonPackagerOptions(cmd).trackedAction(processContext, async (projectDir, outputPath, opts) => {
-    if (outputPath !== undefined && isWithinOrEqual(projectDir, outputPath)) {
+    const dir = resolvePackagerProjectDir(projectDir, opts.projectDir, defaultProjectDir);
+    if (outputPath !== undefined && isWithinOrEqual(dir, outputPath)) {
       OutputFormatter.error(new FailureOutput("Failure", `Restore failed: outputPath ('${outputPath}') must not be the project directory or a descendant of it.`, "Choose a target directory outside the project tree — e.g. a sibling folder used as an air-gap cache. Omit outputPath entirely to restore into the shared NuGet cache only."));
       processContext.exit(1);
       return;
     }
-    opts.projectDir = projectDir;
+    opts.projectDir = dir;
     const success = await runPackagerCommand(opts, {
       label: "Restore",
       hint: "Check project path and NuGet configuration.",
       execute: async (packager, options) => {
-        options.outputPath = outputPath ?? mkdtempSync3(join14(tmpdir8(), "rpa-tool-restore-"));
+        options.outputPath = outputPath ?? mkdtempSync3(join15(tmpdir8(), "rpa-tool-restore-"));
         return packager.restoreProjectAsync(options);
       }
     });
@@ -45907,6 +46111,7 @@ var CLI_DERIVED_COMMANDS = [
       "logLevel",
       "skipBuild",
       "profiling",
+      "profilingMode",
       "remote"
     ]
   },
@@ -45921,6 +46126,7 @@ var CLI_DERIVED_COMMANDS = [
       "logLevel",
       "skipBuild",
       "profiling",
+      "profilingMode",
       "remote",
       "breakpoints"
     ]
@@ -45934,7 +46140,8 @@ var CLI_DERIVED_COMMANDS = [
       "inputArguments",
       "inputVariables",
       "logLevel",
-      "profiling"
+      "profiling",
+      "profilingMode"
     ]
   },
   {
@@ -45946,7 +46153,8 @@ var CLI_DERIVED_COMMANDS = [
       "inputArguments",
       "inputVariables",
       "logLevel",
-      "profiling"
+      "profiling",
+      "profilingMode"
     ]
   },
   {
@@ -46008,7 +46216,7 @@ var CLI_DERIVED_COMMANDS = [
   {
     path: ["debug", "state"],
     baseTool: ToolName.RunFile,
-    description: "State of the active debug session — Running, Paused, Suspended, Completed, or None. " + "Pass --wait-timeout-seconds to long-poll a running session for its next stable state. Helm backend only.",
+    description: "State of the active debug session — Running, Paused, Suspended, Completed, or None. " + "Pass --wait-timeout-seconds to long-poll a running session for its next stable state " + "(Helm backend only; on the Studio backend this is always an instant probe).",
     lockedArgs: { command: "GetDebugState", filePath: "" },
     visibleArgs: ["waitTimeoutSeconds"]
   },
@@ -46019,6 +46227,13 @@ var CLI_DERIVED_COMMANDS = [
     lockedArgs: { command: "SetBreakpoints", filePath: "" },
     visibleArgs: ["breakpoints"]
   },
+  {
+    path: ["debug", "apply-file-changes"],
+    baseTool: ToolName.RunFile,
+    description: "Apply on-disk activity-property edits to the paused debug session via hot-reload, so the " + "current execution picks them up without a restart. Edit the workflow file first, then name what " + "you changed with --file-changes. Returns { applied, rejected, debugState }: applied edits are live " + "(continue-retry re-runs a faulted activity with the fix), rejected ones need a session restart.",
+    lockedArgs: { command: "ApplyFileChanges", filePath: "" },
+    visibleArgs: ["fileChanges"]
+  },
   {
     path: ["debug", "toggle-breakpoint"],
     baseTool: ToolName.RunFile,
@@ -46269,7 +46484,7 @@ function addFlagToCommand(sub3, flag) {
 }
 
 // src/resolution/helm-npm-resolver.ts
-import { dirname as dirname7, join as join15 } from "node:path";
+import { dirname as dirname7, join as join16 } from "node:path";
 function helmPackageName() {
   const key = `${process.platform}-${process.arch}`;
   switch (key) {
@@ -46292,7 +46507,7 @@ function helmPackageName() {
 function resolveHelmFromNpm(deps) {
   const localDir = process.env.HELM_LOCAL_DIR;
   if (localDir) {
-    const helmExePath2 = join15(localDir, HELM_EXE);
+    const helmExePath2 = join16(localDir, HELM_EXE);
     if (deps.fileExists(helmExePath2)) {
       deps.log(`Using local Helm from HELM_LOCAL_DIR: ${localDir}`);
       return { toolsDir: localDir, helmExePath: helmExePath2 };
@@ -46306,10 +46521,10 @@ function resolveHelmFromNpm(deps) {
     packageJsonPath = deps.resolveModule(`${packageName}/package.json`);
   } catch (err2) {
     const detail = err2 instanceof Error ? err2.message : String(err2);
-    throw new Error(`Helm binary package '${packageName}' is not installed. It installs ` + "automatically as an optionalDependency of @uipath/rpa-tool for " + `${process.platform}/${process.arch}. If you installed with ` + "--omit=optional or --no-optional, reinstall without that flag, or " + `set HELM_LOCAL_DIR to a Helm tools directory. (${detail})`);
+    throw new Error(`Helm binary package '${packageName}' is not installed. It installs ` + "automatically as an optionalDependency of @uipath/rpa-tool, gated " + "on the platform and architecture of the node that runs the " + `install — this process is ${process.platform}/${process.arch}, so ` + "a CLI installed by a node of another architecture leaves a package " + "this lookup cannot see. Check which node your PATH resolves " + `(\`${NODE_LOOKUP_HINT}\`) and reinstall the CLI with the same one ` + "you run it with. Otherwise, if you installed with --omit=optional or " + "--no-optional, reinstall without that flag, or " + `set HELM_LOCAL_DIR to a Helm tools directory. (${detail})`);
   }
-  const toolsDir = join15(dirname7(packageJsonPath), "tools");
-  const helmExePath = join15(toolsDir, HELM_EXE);
+  const toolsDir = join16(dirname7(packageJsonPath), "tools");
+  const helmExePath = join16(toolsDir, HELM_EXE);
   if (!deps.fileExists(helmExePath)) {
     throw new Error(`Helm binary not found at ${helmExePath} inside package ` + `'${packageName}'. The package may be corrupt or incomplete.`);
   }
@@ -46320,8 +46535,29 @@ function resolveHelmFromNpm(deps) {
   deps.log(`Resolved Helm from npm package: ${toolsDir} (v${version ?? "?"})`);
   return { toolsDir, helmExePath, version };
 }
+// src/resolution/instance-matching.ts
+function matchByProject(instances, projectDir) {
+  const target = normalizePath(projectDir);
+  return instances.find((i2) => i2.projectDirectory && normalizePath(i2.projectDirectory) === target);
+}
+function findAvailableInstance(instances) {
+  return instances.find((i2) => i2.ipcEndpointName && i2.executionStatus === "Available" /* Available */);
+}
+function findIdleInstance(instances) {
+  return instances.find((i2) => i2.ipcEndpointName && !i2.projectDirectory && i2.executionStatus === "Available" /* Available */);
+}
+function filterByBackend(instances, preference) {
+  switch (preference) {
+    case "helm" /* Helm */:
+      return instances.filter((i2) => i2.backendType === "Helm" /* Helm */);
+    case "studio" /* Studio */:
+      return instances.filter((i2) => i2.backendType !== "Helm" /* Helm */);
+    case "any" /* Any */:
+      return instances;
+  }
+}
 // src/resolution/studio-bin-resolver.ts
-import { join as join16, win32 as win322 } from "node:path";
+import { join as join17, win32 as win322 } from "node:path";
 function getProcessExecutablePath(pid, deps) {
   const exePath = deps.executeCommand("powershell", [
     "-NoProfile",
@@ -46416,7 +46652,7 @@ function getStudioFileVersion(binDir, deps) {
   }
 }
 function readManifest(binDir, filename, deps) {
-  const manifestPath = join16(binDir, filename);
+  const manifestPath = join17(binDir, filename);
   try {
     const content = deps.readFile(manifestPath);
     return JSON.parse(content);
@@ -46429,7 +46665,7 @@ function readInteropManifest(binDir, deps) {
   return readManifest(binDir, INTEROP_MANIFEST, deps);
 }
 function validateInteropSupport(binDir, deps) {
-  const manifestPath = join16(binDir, INTEROP_MANIFEST);
+  const manifestPath = join17(binDir, INTEROP_MANIFEST);
   if (!deps.fileExists(manifestPath)) {
     const version = getStudioFileVersion(binDir, deps);
     throw new Error(`Studio ${version} does not support rpa-tool. Please upgrade to the latest version of UiPath Studio.`);
@@ -46438,7 +46674,7 @@ function validateInteropSupport(binDir, deps) {
 
 // src/resolution/studio-startup.ts
 import { chmodSync, statSync as statSync6 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 async function waitForInstanceAvailability(processId, deps, timeoutMs = DEFAULT_TIMEOUT_MS2) {
   const deadline = Date.now() + timeoutMs;
   let pollCount = 0;
@@ -46460,20 +46696,20 @@ async function waitForInstanceAvailability(processId, deps, timeoutMs = DEFAULT_
         wasStarted: false
       };
     }
-    await deps.sleep(POLL_INTERVAL_MS3);
+    await deps.sleep(POLL_INTERVAL_MS);
   }
   throw new Error(`Studio instance (PID ${processId}) did not become Available within ${timeoutMs / 1000}s after ${pollCount} polls`);
 }
 async function startStudioAndWait(binDir, deps, timeoutMs = DEFAULT_TIMEOUT_MS2) {
   const existingPids = new Set(deps.discoverInstances().instances.map((i2) => i2.processId));
   deps.log(`Existing Studio PIDs: [${[...existingPids].join(", ")}]`);
-  const exePath = join17(binDir, STUDIO_EXE);
+  const exePath = join18(binDir, STUDIO_EXE);
   deps.log(`Starting Studio: ${exePath}`);
   deps.spawnDetached(exePath, []);
   const deadline = Date.now() + timeoutMs;
   let pollCount = 0;
   while (Date.now() < deadline) {
-    await deps.sleep(POLL_INTERVAL_MS3);
+    await deps.sleep(POLL_INTERVAL_MS);
     pollCount++;
     const { instances } = deps.discoverInstances();
     const allPids = instances.map((i2) => i2.processId);
@@ -46519,7 +46755,7 @@ async function startHelmAndWait(deps, timeoutMs = DEFAULT_TIMEOUT_MS2, options)
   const bundledDotnet = resolveBundledDotnet(robotDir, deps);
   const dotnetEnv = bundledDotnet?.env ?? DOTNET_ROLL_FORWARD_ENV;
   if (bundledDotnet) {
-    deps.log(`Bundled dotnet found in Robot dir, setting DOTNET_ROOT=${bundledDotnet.env.DOTNET_ROOT}`);
+    deps.log(`Bundled dotnet found, setting DOTNET_ROOT=${bundledDotnet.env.DOTNET_ROOT}`);
   } else {
     deps.log("No bundled dotnet; launching Helm on PATH dotnet with DOTNET_ROLL_FORWARD=Major.");
   }
@@ -46541,7 +46777,7 @@ async function startHelmAndWait(deps, timeoutMs = DEFAULT_TIMEOUT_MS2, options)
   const deadline = Date.now() + timeoutMs;
   let pollCount = 0;
   while (Date.now() < deadline) {
-    await deps.sleep(POLL_INTERVAL_MS3);
+    await deps.sleep(POLL_INTERVAL_MS);
     pollCount++;
     const { instances } = deps.discoverInstances();
     const allPids = instances.map((i2) => i2.processId);
@@ -46564,10 +46800,20 @@ async function startHelmAndWait(deps, timeoutMs = DEFAULT_TIMEOUT_MS2, options)
       };
     }
   }
-  throw new Error(`Helm did not become ready within ${timeoutMs / 1000}s after ${pollCount} polls. ` + "Check that UiPath.Studio.Helm.exe can start successfully.");
+  const archMismatch = deps.probeDotnetInfo ? findRuntimeArchMismatch({
+    dotnetPath: bundledDotnet?.exePath,
+    probe: deps.probeDotnetInfo
+  }) : null;
+  throw new Error(`Helm did not become ready within ${timeoutMs / 1000}s after ${pollCount} polls. ` + (archMismatch ? `${archMismatch.summary} ${archMismatch.remedy}` : `Check that ${exePath} can start successfully.`));
 }
 
 // src/resolution/resolve.ts
+var DEBUG_SESSION_TOOLS = new Set([
+  "StartDebugging",
+  "StepInto",
+  "StepOver",
+  "StepOut"
+]);
 async function tryMatchInstance(instances, options, requiresProject, deps) {
   if (!requiresProject) {
     const available = findAvailableInstance(instances);
@@ -46585,7 +46831,7 @@ async function tryMatchInstance(instances, options, requiresProject, deps) {
     const projectMatch = matchByProject(instances, options.projectDir);
     if (projectMatch) {
       const isAvailable = projectMatch.ipcEndpointName && projectMatch.executionStatus === "Available" /* Available */;
-      const isDebugging = projectMatch.ipcEndpointName && projectMatch.executionStatus === "ToolExecution" /* ToolExecution */ && projectMatch.activeToolName === "StartDebugging";
+      const isDebugging = projectMatch.ipcEndpointName && projectMatch.executionStatus === "ToolExecution" /* ToolExecution */ && DEBUG_SESSION_TOOLS.has(projectMatch.activeToolName ?? "");
       if (isAvailable || isDebugging) {
         deps.log(`Matched by project directory (${isDebugging ? "Debugging" : "Available"}): PID ${projectMatch.processId}`);
         return {
@@ -46740,14 +46986,32 @@ async function startFresh(options, allInstances, deps) {
   });
 }
 var DEFAULT_MAX_ATTEMPTS = 3;
+var PIPE_RECONNECT_ATTEMPTS = 5;
+var PIPE_RECONNECT_DELAY_MS = 200;
+function isPipeMissingError(err2) {
+  return err2?.code === "ENOENT";
+}
+async function invokeWithPipeReconnect(operation, instance, deps) {
+  for (let attempt = 1;; attempt++) {
+    try {
+      return await operation(instance);
+    } catch (err2) {
+      const isTransient = isPipeMissingError(err2) && attempt < PIPE_RECONNECT_ATTEMPTS && deps.isProcessAlive(instance.processId);
+      if (!isTransient)
+        throw err2;
+      deps.log(`Pipe ${instance.ipcEndpointName} not accepting yet (ENOENT) but ` + `PID ${instance.processId} is alive; reconnecting ` + `(attempt ${attempt}/${PIPE_RECONNECT_ATTEMPTS})`);
+      await deps.sleep(PIPE_RECONNECT_DELAY_MS);
+    }
+  }
+}
 async function withStaleInstanceRetry(operation, options, deps = defaultResolverDeps, maxAttempts = DEFAULT_MAX_ATTEMPTS) {
   const excludePids = new Set(options.excludePids);
   for (let attempt = 1;attempt <= maxAttempts; attempt++) {
     const instance = await resolveStudioInstance({ ...options, excludePids }, deps);
     try {
-      return await operation(instance);
+      return await invokeWithPipeReconnect(operation, instance, deps);
     } catch (err2) {
-      const isRetryable = err2.code === "ENOENT" || isStaleDependenciesError(err2);
+      const isRetryable = isPipeMissingError(err2) || isStaleDependenciesError(err2);
       if (isRetryable && attempt < maxAttempts) {
         const reason = err2.code === "ENOENT" ? "ENOENT" : "stale dependencies";
         excludePids.add(instance.processId);
@@ -46769,6 +47033,7 @@ function isStaleDependenciesError(err2) {
 }
 // src/studio_interop/HelmAuthContextProvider.ts
 var DISABLE_AUTH_PUSH_ENV = "UIPATH_HELM_DISABLE_AUTH_PUSH";
+var ORG_SCOPED_SERVICES = ["studio", "apps", "authz"];
 function isAuthPushDisabled() {
   const value = process.env[DISABLE_AUTH_PUSH_ENV];
   return value != null && value !== "" && value !== "0" && value.toLowerCase() !== "false";
@@ -46823,7 +47088,8 @@ class HelmAuthContextProvider {
         organizationName: status.organizationName ?? "",
         tenantId: status.tenantId ?? "",
         tenantName,
-        serviceUrls
+        serviceUrls,
+        orgScopedServices: ORG_SCOPED_SERVICES
       });
     } catch (err2) {
       console.error(`[HelmAuthContextProvider] failed to push auth context: ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -46901,8 +47167,13 @@ var interop_manifest_default = {
       "setRemoteDebuggingEnabled",
       "getRemoteDebugConfig"
     ],
+    IRemoteUiaSessionConfigService: [
+      "ensureRemoteUiaSession",
+      "stopRemoteUiaSession"
+    ],
     IRunService: [
-      "executeCommand"
+      "executeCommand",
+      "applyFileChanges"
     ],
     IStudioInteropService: [
       "listTools",
@@ -47200,7 +47471,7 @@ function createInterpolator(values) {
 
 // src/external-cli/discovery.ts
 import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 class MissingAllDependenciesError extends Error {
   projectDir;
@@ -47235,7 +47506,7 @@ var defaultDeps = {
   readFile: (path4) => readFileSync8(path4, "utf-8")
 };
 function discoverPackageRoot(params, deps = defaultDeps) {
-  const depsFile = join18(params.projectDir, ".local", "AllDependencies.json");
+  const depsFile = join19(params.projectDir, ".local", "AllDependencies.json");
   if (!deps.fileExists(depsFile)) {
     throw new MissingAllDependenciesError(params.projectDir, depsFile);
   }
@@ -47245,7 +47516,7 @@ function discoverPackageRoot(params, deps = defaultDeps) {
   if (packageFolders.length === 0) {
     throw new Error("No packageFolders found in AllDependencies.json.");
   }
-  const packageRoot = join18(packageFolders[0], library.path);
+  const packageRoot = join19(packageFolders[0], library.path);
   if (!deps.fileExists(packageRoot)) {
     throw new PackageRootMissingError(packageRoot);
   }
@@ -47271,7 +47542,7 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { dirname as dirname8, join as join19 } from "node:path";
+import { dirname as dirname8, join as join20 } from "node:path";
 var defaultDeps2 = {
   fileExists: existsSync8,
   readFile: (path4) => readFileSync9(path4, "utf-8"),
@@ -47282,8 +47553,8 @@ var defaultDeps2 = {
   getModifiedTime: (path4) => statSync7(path4).mtimeMs
 };
 function discoverPackageRootCached(params, deps = defaultDeps2) {
-  const cacheFilePath = join19(params.projectDir, ".local", "rpa-tool", `${params.commandName}.json`);
-  const allDepsPath = join19(params.projectDir, ".local", "AllDependencies.json");
+  const cacheFilePath = join20(params.projectDir, ".local", "rpa-tool", `${params.commandName}.json`);
+  const allDepsPath = join20(params.projectDir, ".local", "AllDependencies.json");
   let entry;
   if (deps.fileExists(cacheFilePath)) {
     try {
@@ -47379,9 +47650,9 @@ function spawnCapture(exePath, args, env) {
 }
 
 // src/external-cli/manifest-reader.ts
-import { execFileSync as execFileSync8 } from "node:child_process";
+import { execFileSync as execFileSync9 } from "node:child_process";
 import { existsSync as existsSync9, readFileSync as readFileSync10 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 
 // src/external-cli/manifest-platform.ts
 function isOnPlatform(entry, platformKey) {
@@ -47432,7 +47703,7 @@ var defaultDeps3 = {
 };
 function isRosettaTranslated() {
   try {
-    return execFileSync8("sysctl", ["-in", "sysctl.proc_translated"], {
+    return execFileSync9("sysctl", ["-in", "sysctl.proc_translated"], {
       encoding: "utf-8"
     }).trim() === "1";
   } catch {
@@ -47480,7 +47751,7 @@ function resolveExecutableRelativePath(manifest, manifestPath, platformKey) {
   throw new Error(`Manifest ${manifestPath} declares neither 'tool.executable' nor 'tool.executables'.`);
 }
 function readCliManifest(packageRoot, deps = defaultDeps3) {
-  const manifestPath = join20(packageRoot, MANIFEST_FILENAME);
+  const manifestPath = join21(packageRoot, MANIFEST_FILENAME);
   if (!deps.fileExists(manifestPath)) {
     throw new Error(`CLI manifest not found at ${manifestPath}. ` + `Ensure the package includes a ${MANIFEST_FILENAME} file.`);
   }
@@ -47495,7 +47766,7 @@ function readCliManifest(packageRoot, deps = defaultDeps3) {
   }
   const platformKey = (deps.getPlatformKey ?? getCurrentPlatformKey)();
   const relExe = resolveExecutableRelativePath(manifest, manifestPath, platformKey);
-  const exePath = join20(packageRoot, relExe);
+  const exePath = join21(packageRoot, relExe);
   if (!deps.fileExists(exePath)) {
     throw new Error(`Executable not found at ${exePath} as declared in ${manifestPath}.`);
   }
@@ -47593,6 +47864,10 @@ function registerCommand(parent, exePath, projectDir, cmd, config, deps, command
     addFlagToCommand2(sub3, flag, interpolate);
   }
   attachWrapperOptions(sub3);
+  const manifestDeclaresRemote = sub3.options.some((o) => o.long === "--remote");
+  if (config.supportsRemote && !manifestDeclaresRemote) {
+    sub3.addOption(new Option2("--remote", "Run against the remote unattended robot configured with `rpa remote configure` " + "instead of the local machine. The remote design-experience session is started on first use and reused."));
+  }
   const usagePattern = buildUsagePattern(flags, positionals);
   if (usagePattern)
     sub3.usage(usagePattern);
@@ -47601,15 +47876,27 @@ function registerCommand(parent, exePath, projectDir, cmd, config, deps, command
     const opts = actionArgs[actionArgs.length - 2] ?? {};
     const positionalValues = actionArgs.slice(0, actionArgs.length - 2);
     const effectiveProjectDir = opts.projectDir ?? projectDir;
-    const effectiveFormat = opts.format ?? defaultFormat;
-    if (effectiveFormat && !supportsFormat) {
-      throw new Error(`Command '${currentPath.join(" ")}' does not support --format.`);
+    const argvFormat = opts.format ?? defaultFormat;
+    const requestedFormat = argvFormat ?? hostRequestedFormat();
+    if (requestedFormat && !supportsFormat) {
+      const flag = argvFormat ? "--format" : "--output";
+      OutputFormatter.error(new FailureOutput("Failure", `Command '${currentPath.join(" ")}' does not support ${flag}.`, `'${config.commandName}' relays this command's output from the external CLI ` + `unchanged, so its format cannot be changed. Re-run without ${flag}.`));
+      processContext.exit(1);
+      return;
+    }
+    if (opts.remote === true) {
+      if (!deps.setupRemoteSession) {
+        throw new Error("'--remote' is not available in this context (no Studio/Helm session).");
+      }
+      await deps.setupRemoteSession(effectiveProjectDir);
     }
     const run = async () => {
       const env = deps.resolveEnv?.();
       if (supportsFormat) {
         const { format: _stripped, ...forwardOpts } = opts;
         const args = buildArgs(currentPath, positionalValues, forwardOpts, cmd, config, effectiveProjectDir, "json");
+        if (opts.remote === true && !manifestDeclaresRemote)
+          args.push("--remote");
         const result = await deps.spawnCapture(exePath, args, env);
         renderCapturedOutput(result);
         if (result.exitCode !== 0) {
@@ -47617,6 +47904,8 @@ function registerCommand(parent, exePath, projectDir, cmd, config, deps, command
         }
       } else {
         const args = buildArgs(currentPath, positionalValues, opts, cmd, config, effectiveProjectDir);
+        if (opts.remote === true && !manifestDeclaresRemote)
+          args.push("--remote");
         const exitCode = await deps.spawnForward(exePath, args, env);
         if (exitCode !== 0) {
           processContext.exit(exitCode);
@@ -47730,6 +48019,9 @@ function addFlagToCommand2(sub3, flag, interpolate) {
     opt.hideHelp();
   sub3.addOption(opt);
 }
+function hostRequestedFormat() {
+  return getOutputFormatExplicit() ? getOutputFormat() : undefined;
+}
 function commandSupportsFormat(cmd, config) {
   if (!config.injectFormat)
     return false;
@@ -47773,7 +48065,17 @@ function resolveDeps(_projectDir, config, partial, session, runtime) {
     openProject: partial?.openProject ?? (session ? (dir, operation) => session.execute(async () => {
       await operation();
     }, { projectDir: dir, backend: "helm" /* Helm */ }) : undefined),
-    resolveEnv: partial?.resolveEnv ?? buildBundledDotnetEnvResolver(runtime)
+    resolveEnv: partial?.resolveEnv ?? buildBundledDotnetEnvResolver(runtime),
+    setupRemoteSession: partial?.setupRemoteSession ?? (session ? (dir) => session.execute(async (instance) => {
+      if (instance.backendType !== "Helm" /* Helm */) {
+        throw new Error("'--remote' for this tool is only supported on the Helm backend.");
+      }
+      const json3 = await instance.helmServices.remoteUiaSessionConfig.ensureRemoteUiaSession();
+      const result = JSON.parse(json3);
+      if (result.success !== true) {
+        throw new Error(result.error ?? "Failed to set up the remote UIA session.");
+      }
+    }, { projectDir: dir, backend: "helm" /* Helm */ }) : undefined)
   };
 }
 function buildBundledDotnetEnvResolver(runtime) {
@@ -47871,7 +48173,10 @@ class CloudClient {
           auth.getTenantName()
         ]);
         return `${environment}/${organizationName}/${tenantName}`;
-      }, { requiresProject: false }).catch((e) => {
+      }, {
+        requiresProject: false,
+        backend: "helm" /* Helm */
+      }).catch((e) => {
         this._cachedBaseUrl = null;
         throw e;
       });
@@ -47894,7 +48199,10 @@ class CloudClient {
           Authorization: accessToken,
           "X-Uipath-Tenantid": tenantId
         };
-      }, { requiresProject: false }).then((headers2) => {
+      }, {
+        requiresProject: false,
+        backend: "helm" /* Helm */
+      }).then((headers2) => {
         this._authExpiresAt = parseJwtExpiration(headers2.Authorization);
         return headers2;
       }).catch((e) => {
@@ -48290,6 +48598,7 @@ function configureRemoteRobotTool(session) {
 
 // src/tools/local/create-project.ts
 init_dist3();
+import { resolve as resolve10 } from "node:path";
 
 // node_modules/@uipath/solution-sdk/dist/index.js
 import { createRequire as createRequire7 } from "node:module";
@@ -48310,7 +48619,7 @@ import process45 from "node:process";
 import { execFile as execFile35 } from "node:child_process";
 import process55 from "node:process";
 import { promisify as promisify45 } from "node:util";
-import { execFile as execFile45, execFileSync as execFileSync9 } from "node:child_process";
+import { execFile as execFile45, execFileSync as execFileSync10 } from "node:child_process";
 import { promisify as promisify55 } from "node:util";
 import { execFile as execFile55 } from "node:child_process";
 import { promisify as promisify65 } from "node:util";
@@ -59379,7 +59688,7 @@ function createProjectTool(session) {
         },
         location: {
           type: "string",
-          description: "Parent directory where the project folder will be created"
+          description: "Parent directory where the project folder will be created. " + "Relative paths resolve against the CLI's working directory."
         },
         description: {
           type: "string",
@@ -59420,7 +59729,7 @@ function createProjectTool(session) {
     const request = {
       templateId: args.templateId ?? "BlankTemplate",
       name: args.name,
-      location: args.location ?? process.cwd(),
+      location: resolve10(args.location ?? process.cwd()),
       description: args.description ?? undefined,
       expressionLanguage: args.expressionLanguage ?? undefined,
       targetFramework: args.targetFramework ?? undefined,
@@ -59479,12 +59788,12 @@ function createProjectTool(session) {
 }
 
 // src/tools/local/diff.ts
-import { isAbsolute as isAbsolute9, resolve as resolve10 } from "node:path";
+import { isAbsolute as isAbsolute9, resolve as resolve11 } from "node:path";
 function toAbsoluteFilePath(filePath, projectDir) {
   if (isAbsolute9(filePath)) {
     return filePath;
   }
-  return projectDir ? resolve10(projectDir, filePath) : resolve10(filePath);
+  return projectDir ? resolve11(projectDir, filePath) : resolve11(filePath);
 }
 function diffTool(session) {
   return createToolHandler(session, {
@@ -60027,7 +60336,7 @@ function getDefaultActivityXamlTool(session) {
 
 // src/tools/local/get-errors.ts
 import { existsSync as existsSync11 } from "node:fs";
-import { isAbsolute as isAbsolute10, resolve as resolve11 } from "node:path";
+import { isAbsolute as isAbsolute10, resolve as resolve12 } from "node:path";
 var SEVERITIES = ["error", "warning", "info", "verbose"];
 var LEVEL_BY_NAME = Object.fromEntries(SEVERITIES.map((name, i3) => [name, i3 + 1]));
 var NAME_BY_LEVEL = Object.fromEntries(SEVERITIES.map((name, i3) => [i3 + 1, name]));
@@ -60085,7 +60394,7 @@ function resolveTargetedFile(filePath, projectDir) {
   if (isAbsolute10(filePath)) {
     return filePath;
   }
-  return projectDir !== undefined ? resolve11(projectDir, filePath) : undefined;
+  return projectDir !== undefined ? resolve12(projectDir, filePath) : undefined;
 }
 function getErrorsTool(session) {
   return createToolHandler(session, {
@@ -61079,7 +61388,7 @@ function listWorkflowExamplesTool(client) {
     definition: {
       name: ToolName.ListWorkflowExamples,
       title: "List Workflow Examples",
-      description: "List RPA workflow examples matching one or more service tags " + "(e.g. confluence, jira, salesforce, outlook, gmail, slack). " + "Each match can be retrieved by key via `workflow-examples get`.",
+      description: "List RPA workflow examples, optionally narrowed by service tags " + "(e.g. confluence, jira, salesforce, outlook, gmail, slack) or by path " + "prefix. With no filters it returns the first `limit` examples in the " + "catalogue. Each match can be retrieved by key via `workflow-examples get`.",
       requiresProject: false,
       inputSchema: {
         type: "object",
@@ -61087,7 +61396,7 @@ function listWorkflowExamplesTool(client) {
           tags: {
             type: "array",
             items: { type: "string" },
-            description: "Service tags to filter examples by. " + 'Use lowercase service names, e.g. ["web"] or ["confluence"] or ["salesforce", "outlook"].' + "The more tags provided, the more narrowed-down the search results will be (AND logic)."
+            description: "Service tags to filter examples by; omit to list without a tag filter. " + 'Use lowercase service names, e.g. ["web"] or ["confluence"] or ["salesforce", "outlook"].' + "The more tags provided, the more narrowed-down the search results will be (AND logic)."
           },
           prefix: {
             type: "string",
@@ -61098,28 +61407,13 @@ function listWorkflowExamplesTool(client) {
             description: "Maximum number of examples to return. Defaults to 10, max 100.",
             default: 10
           }
-        },
-        required: ["tags"]
+        }
       }
     },
     async execute(args) {
-      const tags = args.tags;
+      const tags = args.tags ?? [];
       const prefix = args.prefix;
       const limit = args.limit || 10;
-      if (!tags || tags.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                success: false,
-                errorMessage: "At least one tag is required."
-              })
-            }
-          ],
-          isError: true
-        };
-      }
       try {
         const params = buildSearchQueryParams(tags, prefix, limit);
         const response = await client.get(`${AGENTIC_LOOP_PATH}/v1/blobs/${CONTAINER_NAME}?${params}`);
@@ -61128,7 +61422,7 @@ function listWorkflowExamplesTool(client) {
             content: [
               {
                 type: "text",
-                text: `No workflow examples found for tags: ${tags.join(", ")}`
+                text: `No workflow examples found${describeFilters(tags, prefix)}`
               }
             ]
           };
@@ -61168,6 +61462,13 @@ function listWorkflowExamplesTool(client) {
     }
   };
 }
+function describeFilters(tags, prefix) {
+  const filters = [
+    tags.length > 0 ? `tags: ${tags.join(", ")}` : null,
+    prefix ? `prefix: ${prefix}` : null
+  ].filter((filter) => filter !== null);
+  return filters.length > 0 ? ` for ${filters.join(", ")}` : ".";
+}
 function buildSearchQueryParams(tags, prefix, limit) {
   const params = new URLSearchParams;
   for (const tag of tags) {
@@ -61240,11 +61541,221 @@ function openProjectTool(session) {
   });
 }
 
+// src/executor/RpaExecutorService.ts
+init_dist3();
+
+// node_modules/@uipath/project-executor/dist/index.js
+var RunTarget;
+((RunTarget2) => {
+  RunTarget2["Online"] = "Online";
+  RunTarget2["Local"] = "Local";
+})(RunTarget ||= {});
+var RunStatus;
+((RunStatus2) => {
+  RunStatus2["Pending"] = "Pending";
+  RunStatus2["Running"] = "Running";
+  RunStatus2["Succeeded"] = "Succeeded";
+  RunStatus2["Faulted"] = "Faulted";
+  RunStatus2["Cancelled"] = "Cancelled";
+  RunStatus2["Suspended"] = "Suspended";
+  RunStatus2["Unknown"] = "Unknown";
+})(RunStatus ||= {});
+var TERMINAL_RUN_STATUSES = [
+  "Succeeded",
+  "Faulted",
+  "Cancelled"
+];
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+var RunErrorCode;
+((RunErrorCode2) => {
+  RunErrorCode2["None"] = "None";
+  RunErrorCode2["InvalidInput"] = "InvalidInput";
+  RunErrorCode2["UnsupportedProjectType"] = "UnsupportedProjectType";
+  RunErrorCode2["Unauthorized"] = "Unauthorized";
+  RunErrorCode2["PrepareFailed"] = "PrepareFailed";
+  RunErrorCode2["StartFailed"] = "StartFailed";
+  RunErrorCode2["ExecutionFailed"] = "ExecutionFailed";
+  RunErrorCode2["Timeout"] = "Timeout";
+  RunErrorCode2["Cancelled"] = "Cancelled";
+  RunErrorCode2["Unknown"] = "Unknown";
+})(RunErrorCode ||= {});
+
+class RunResult {
+  status;
+  errorCode;
+  rawStatus;
+  message;
+  jobKey;
+  instanceId;
+  runId;
+  traceId;
+  steps;
+  output;
+  url;
+  details;
+  constructor(status, errorCode2 = "None", message) {
+    this.status = status;
+    this.errorCode = errorCode2;
+    this.message = message;
+  }
+  get isSuccess() {
+    return this.status === "Succeeded" && this.errorCode === "None";
+  }
+  get isTerminal() {
+    return isTerminalRunStatus(this.status);
+  }
+  static succeeded(init = {}) {
+    return Object.assign(new RunResult("Succeeded", "None"), init);
+  }
+  static failed(errorCode2, message, init = {}) {
+    return Object.assign(new RunResult("Faulted", errorCode2, message), init);
+  }
+}
+var noopExecutorLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+class ExecutorsFactoryRepository {
+  factoryMap = new Map;
+  onConflict;
+  constructor(onConflict) {
+    this.onConflict = onConflict ?? ((message) => console.warn(message));
+  }
+  registerProjectExecutorFactory(factory) {
+    for (const projectType of factory.supportedTypes) {
+      const existing = this.factoryMap.get(projectType);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          this.onConflict(`Executor factory conflict for project type '${projectType}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
+        continue;
+      }
+      this.factoryMap.set(projectType, factory);
+    }
+  }
+  canHandleProject(projectType) {
+    return this.factoryMap.has(projectType);
+  }
+  getProjectExecutorFactory(projectType) {
+    const factory = this.factoryMap.get(projectType);
+    if (!factory) {
+      throw new Error(`No executor is registered for project type '${projectType}'. ` + `Registered types: ${this.registeredTypes.join(", ") || "none"}.`);
+    }
+    return factory;
+  }
+  get registeredTypes() {
+    return [...this.factoryMap.keys()];
+  }
+  reset() {
+    this.factoryMap.clear();
+  }
+}
+var REGISTRY_KEY2 = Symbol.for("@uipath/project-executor/executorsFactoryRepository");
+var _global2 = globalThis;
+if (!_global2[REGISTRY_KEY2]) {
+  _global2[REGISTRY_KEY2] = new ExecutorsFactoryRepository;
+}
+var executorsFactoryRepository = _global2[REGISTRY_KEY2];
+
+class ProjectExecutor {
+  fileSystem;
+  logger;
+  constructor(fileSystem, logger4) {
+    this.fileSystem = fileSystem;
+    this.logger = logger4;
+  }
+  runAsync(_options, _cancellationToken) {
+    return Promise.resolve(RunResult.failed("UnsupportedProjectType", `${this.constructor.name} does not support run.`));
+  }
+  async resolveDefaultEntryPoint(projectPath) {
+    const entryPointsFile = this.fileSystem.path.join(projectPath, ENTRY_POINTS_FILE_NAME);
+    try {
+      const raw = await this.fileSystem.readFile(entryPointsFile, "utf-8");
+      if (!raw) {
+        return;
+      }
+      const declared = JSON.parse(raw).entryPoints;
+      return this.firstDeclaredEntryPoint(declared);
+    } catch (error) {
+      this.logger.warn(`Could not read the default entry point from ${entryPointsFile}: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+  }
+  asEntryPoint(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+  }
+  firstDeclaredEntryPoint(entryPoints) {
+    if (!Array.isArray(entryPoints)) {
+      return;
+    }
+    for (const entry of entryPoints) {
+      const filePath = this.asEntryPoint(entry?.filePath);
+      if (filePath) {
+        return filePath;
+      }
+    }
+    return;
+  }
+  dispose() {
+    return Promise.resolve();
+  }
+}
+var ENTRY_POINTS_FILE_NAME = "entry-points.json";
+
+class ProjectRunner {
+  fileSystem;
+  logger;
+  registry;
+  constructor(deps) {
+    this.fileSystem = deps.fileSystem;
+    this.logger = deps.logger ?? noopExecutorLogger;
+    this.registry = deps.registry ?? executorsFactoryRepository;
+  }
+  canRun(projectType) {
+    return this.registry.canHandleProject(projectType);
+  }
+  get runnableTypes() {
+    return this.registry.registeredTypes;
+  }
+  async runAsync(options, cancellationToken) {
+    const { projectType, name } = options.project;
+    if (!this.canRun(projectType)) {
+      const known = this.runnableTypes.join(", ") || "none";
+      return RunResult.failed("UnsupportedProjectType", `No executor is registered for project type '${projectType}' ` + `(project '${name}'). Runnable types: ${known}.`);
+    }
+    let executor;
+    try {
+      const factory = this.registry.getProjectExecutorFactory(projectType);
+      executor = await factory.createAsync(this.logger, this.fileSystem);
+      this.logger.info(`Running ${name} (${projectType}) on ${options.target}.`);
+      return await executor.runAsync(options, cancellationToken);
+    } catch (error) {
+      return RunResult.failed("Unknown", messageOf(error));
+    } finally {
+      try {
+        await executor?.dispose();
+      } catch (error) {
+        this.logger.warn(`Failed to dispose the ${projectType} executor: ${messageOf(error)}`);
+      }
+    }
+  }
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/studio_interop/HelmRunService.ts
 var import_coreipc6 = __toESM(require_coreipc(), 1);
 
 // src/studio_interop/HelmRunCallbackHandler.ts
+var FILE_MARKER_REFRESH_INTERVAL = 50;
+
 class HelmRunCallbackHandler {
+  lastMarkedFile;
+  entriesSinceFileMarker = 0;
   OnLogEntry(_source, level, message) {
     const formatted = tryFormatLogMessage(message);
     getOutputSink().writeOut(`[${level}] ${formatted}
@@ -61274,6 +61785,36 @@ class HelmRunCallbackHandler {
     }
     return true;
   }
+  OnProfilingEntry(entryJson) {
+    getOutputSink().writeOut(`[Profiling] ${this.formatProfilingEntry(entryJson)}
+`);
+    return true;
+  }
+  formatProfilingEntry(entryJson) {
+    try {
+      const entry = JSON.parse(entryJson);
+      const name = entry.displayName ?? entry.id ?? "activity";
+      const idRef = entry.idRef ? ` (${entry.idRef})` : "";
+      const duration = typeof entry.duration === "number" ? ` ${entry.duration}ms` : "";
+      const failed = entry.failed ? " [failed]" : "";
+      const file = this.fileMarker(entry.workflowFile);
+      return `${name}${idRef}${duration}${failed}${file}`;
+    } catch {
+      return entryJson;
+    }
+  }
+  fileMarker(workflowFile) {
+    if (typeof workflowFile !== "string" || workflowFile.length === 0) {
+      return "";
+    }
+    if (workflowFile !== this.lastMarkedFile || this.entriesSinceFileMarker >= FILE_MARKER_REFRESH_INTERVAL) {
+      this.lastMarkedFile = workflowFile;
+      this.entriesSinceFileMarker = 0;
+      return ` [${workflowFile}]`;
+    }
+    this.entriesSinceFileMarker++;
+    return "";
+  }
 }
 function tryFormatLogMessage(message) {
   try {
@@ -61292,14 +61833,13 @@ class HelmRunService {
   constructor(session) {
     this.session = session;
   }
-  async runFile(filePath, inputArguments, logLevel, command = "StartExecution", skipBuild = false, profiling = false, folderPath, waitTimeoutSeconds, breakpointsJson) {
+  async runFile(filePath, inputArguments, logLevel, command = "StartExecution", skipBuild = false, profiling = false, profilingMode, folderPath, waitTimeoutSeconds, breakpointsJson) {
     const isStartCommand = START_COMMANDS.has(command);
-    this.session.log(`[helm-run] ${isStartCommand ? "Starting pipeline" : "Sending debug command"}: ${command}${skipBuild ? " [skip-build]" : ""}${profiling ? " [profiling]" : ""}${folderPath ? ` [folder=${folderPath}]` : ""}`);
+    const streaming = profilingMode === "stream";
+    this.session.log(`[helm-run] ${isStartCommand ? "Starting pipeline" : "Sending debug command"}: ${command}${skipBuild ? " [skip-build]" : ""}${profiling ? " [profiling]" : ""}${streaming ? " [profiling-stream]" : ""}${folderPath ? ` [folder=${folderPath}]` : ""}`);
     const t0 = performance.now();
     const rawResult = await this.session.execute((inst) => {
-      if (isStartCommand) {
-        import_coreipc6.ipc.callback.forAddress(import_coreipc6.ipc.namedPipe(inst.ipcEndpointName)).forService("IHelmRunCallback").is(new HelmRunCallbackHandler);
-      }
+      import_coreipc6.ipc.callback.forAddress(import_coreipc6.ipc.namedPipe(inst.ipcEndpointName)).forService("IHelmRunCallback").is(new HelmRunCallbackHandler);
       return inst.helmServices.run.executeCommand({
         command,
         filePath,
@@ -61307,6 +61847,7 @@ class HelmRunService {
         logLevel,
         skipBuild,
         profiling,
+        profilingMode,
         folderPath,
         waitTimeoutSeconds,
         breakpointsJson
@@ -61318,6 +61859,290 @@ class HelmRunService {
   }
 }
 
+// src/executor/rpa-run-contract.ts
+var RPA_PROJECT_TYPES = [
+  "Process",
+  "Library",
+  "Tests",
+  "WebApp"
+];
+var HELM_LOG_LEVELS = [
+  "Verbose",
+  "Trace",
+  "Information",
+  "Warning",
+  "Error",
+  "Critical"
+];
+var HELM_PROFILING_MODES = ["endOfRun", "stream"];
+var DEFAULT_LOG_LEVEL4 = "Information";
+function readProviderOptions(raw) {
+  const source = raw ?? {};
+  const logLevel = source.logLevel;
+  const profilingMode = source.profilingMode;
+  return {
+    logLevel: HELM_LOG_LEVELS.includes(logLevel) ? logLevel : DEFAULT_LOG_LEVEL4,
+    skipBuild: source.skipBuild === true,
+    profiling: source.profiling === true,
+    profilingMode: HELM_PROFILING_MODES.includes(profilingMode) ? profilingMode : undefined,
+    runner: isHelmRunner(source.runner) ? source.runner : undefined,
+    inputArgumentsJson: typeof source.inputArgumentsJson === "string" ? source.inputArgumentsJson : undefined
+  };
+}
+function isHelmRunner(value) {
+  return typeof value === "object" && value !== null && typeof value.runFile === "function";
+}
+function parseHelmRunPayload(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return;
+  }
+  const fields = parsed;
+  return {
+    hasErrors: resultHasErrors(raw),
+    errorMessage: asString2(fields.errorMessage ?? fields.ErrorMessage),
+    output: asString2(fields.output ?? fields.Output),
+    profiling: fields.profiling ?? fields.Profiling
+  };
+}
+function asString2(value) {
+  return typeof value === "string" ? value : undefined;
+}
+
+// src/executor/rpa-project-executor.ts
+var FALLBACK_ENTRY_POINT = "Main.xaml";
+var START_EXECUTION = "StartExecution";
+var defaultRunnerFactory = (projectDir, timeoutMs) => new HelmRunService(new StudioSession({
+  projectDir,
+  timeoutMs,
+  requiresProject: true
+}));
+
+class RpaProjectExecutor extends ProjectExecutor {
+  createRunner;
+  constructor(fileSystem, logger4, createRunner = defaultRunnerFactory) {
+    super(fileSystem, logger4);
+    this.createRunner = createRunner;
+  }
+  async runAsync(options, cancellationToken) {
+    const { project } = options;
+    if (options.target !== RunTarget.Local) {
+      return RunResult.failed(RunErrorCode.InvalidInput, `RPA projects execute on this machine through Studio, so they need target '${RunTarget.Local}'; got '${options.target}'.`);
+    }
+    if (!project.projectPath) {
+      return RunResult.failed(RunErrorCode.InvalidInput, "Running an RPA project requires the project directory.");
+    }
+    if (cancellationToken?.aborted) {
+      return RunResult.failed(RunErrorCode.Cancelled, "Run cancelled before it started.");
+    }
+    const entryPoint = options.entryPoint ?? await this.resolveDefaultEntryPoint(project.projectPath) ?? FALLBACK_ENTRY_POINT;
+    const knobs = readProviderOptions(options.providerOptions);
+    this.logger.info(`Running '${project.name}' (${project.projectType}) locally: ${entryPoint}`);
+    const runner = knobs.runner ?? this.createRunner(project.projectPath, options.timeoutMs);
+    options.callbacks?.onStatusChange?.(RunStatus.Running);
+    let outcome;
+    try {
+      outcome = await this.withCancellation(runner, entryPoint, cancellationToken, () => runner.runFile(entryPoint, knobs.inputArgumentsJson ?? serializeInputArguments(options.inputArguments), knobs.logLevel, START_EXECUTION, knobs.skipBuild, knobs.profiling, knobs.profilingMode, options.connection?.folderPath));
+    } catch (error) {
+      if (cancellationToken?.aborted) {
+        return RunResult.failed(RunErrorCode.Cancelled, "Run cancelled.");
+      }
+      return RunResult.failed(RunErrorCode.StartFailed, `Could not run '${project.name}' locally: ${messageOf2(error)}`, { details: { runnerError: messageOf2(error), entryPoint } });
+    }
+    if (cancellationToken?.aborted) {
+      return RunResult.failed(RunErrorCode.Cancelled, "Run cancelled.");
+    }
+    return this.toRunResult(outcome, entryPoint);
+  }
+  async withCancellation(runner, entryPoint, cancellationToken, start) {
+    if (!cancellationToken) {
+      return start();
+    }
+    const onAbort = () => {
+      runner.runFile(entryPoint, "", "Information", "Stop", true, false).catch((error) => {
+        this.logger.warn(`Could not stop the run after cancellation: ${messageOf2(error)}`);
+      });
+    };
+    cancellationToken.addEventListener("abort", onAbort, { once: true });
+    try {
+      return await start();
+    } finally {
+      cancellationToken.removeEventListener("abort", onAbort);
+    }
+  }
+  async resolveDefaultEntryPoint(projectPath) {
+    return await this.mainFromProjectFile(projectPath) ?? await super.resolveDefaultEntryPoint(projectPath);
+  }
+  async mainFromProjectFile(projectPath) {
+    const projectFile = this.fileSystem.path.join(projectPath, "project.json");
+    try {
+      const raw = await this.fileSystem.readFile(projectFile, "utf-8");
+      if (!raw) {
+        return;
+      }
+      const main = JSON.parse(raw).main;
+      return typeof main === "string" && main.length > 0 ? main : undefined;
+    } catch (error) {
+      this.logger.warn(`Could not read the entry point from ${projectFile}: ${messageOf2(error)}`);
+      return;
+    }
+  }
+  toRunResult(outcome, entryPoint) {
+    const payload = outcome.runResult;
+    const passthrough = { rawResult: payload };
+    if (outcome.error !== undefined) {
+      passthrough.runnerError = outcome.error;
+    }
+    if (payload === null) {
+      return RunResult.failed(RunErrorCode.Unknown, outcome.error ?? "Studio returned no result for the run.", { details: { ...passthrough, entryPoint } });
+    }
+    const parsed = parseHelmRunPayload(payload);
+    if (!parsed) {
+      return RunResult.failed(RunErrorCode.Unknown, `Studio returned an unreadable run result: ${payload}`, { details: { ...passthrough, entryPoint } });
+    }
+    const details = { ...passthrough, entryPoint };
+    if (parsed.profiling != null) {
+      details.profiling = parsed.profiling;
+    }
+    if (parsed.output) {
+      details.output = parsed.output;
+    }
+    if (parsed.hasErrors) {
+      const message = parsed.errorMessage ?? "The run finished with errors.";
+      const result2 = RunResult.failed(isPreExecutionFailure(message) ? RunErrorCode.PrepareFailed : RunErrorCode.ExecutionFailed, message, { details });
+      result2.rawStatus = "Faulted";
+      return result2;
+    }
+    const result = RunResult.succeeded({ details });
+    result.rawStatus = "Completed";
+    result.output = parseOutputArguments(parsed.output);
+    return result;
+  }
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function serializeInputArguments(inputArguments) {
+  return inputArguments && Object.keys(inputArguments).length > 0 ? JSON.stringify(inputArguments) : "";
+}
+function parseOutputArguments(output) {
+  if (!output) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(output);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function isPreExecutionFailure(message) {
+  return /^(Validation failed|Build failed)/i.test(message);
+}
+
+// src/executor/rpa-executor-factory.ts
+class RpaExecutorFactory {
+  supportedTypes = RPA_PROJECT_TYPES;
+  createAsync(logger4, fileSystem) {
+    return Promise.resolve(new RpaProjectExecutor(fileSystem, logger4));
+  }
+}
+
+// src/executor-tool.ts
+var createExecutorFactory = () => new RpaExecutorFactory;
+
+// src/executor/register-rpa-executor.ts
+function ensureRpaExecutorRegistered(registry = executorsFactoryRepository) {
+  registry.registerProjectExecutorFactory(createExecutorFactory());
+}
+
+// src/executor/RpaExecutorService.ts
+class RpaExecutorService {
+  helmRunner;
+  fileSystem;
+  logger;
+  constructor(helmRunner, deps = {}) {
+    this.helmRunner = helmRunner;
+    this.fileSystem = deps.fileSystem ?? new NodeFileSystem3;
+    this.logger = deps.logger ?? logger;
+  }
+  async runAsync(request) {
+    ensureRpaExecutorRegistered();
+    const projectRunner = new ProjectRunner({
+      fileSystem: this.fileSystem,
+      logger: this.logger
+    });
+    const result = await projectRunner.runAsync({
+      project: {
+        name: this.fileSystem.path.basename(request.projectDir),
+        projectType: await this.resolveProjectType(request.projectDir),
+        projectPath: request.projectDir
+      },
+      entryPoint: request.filePath,
+      target: RunTarget.Local,
+      connection: {
+        baseUrl: "",
+        accessToken: "",
+        organizationId: "",
+        organizationName: "",
+        folderPath: request.folderPath
+      },
+      providerOptions: {
+        logLevel: request.logLevel,
+        skipBuild: request.skipBuild,
+        profiling: request.profiling,
+        profilingMode: request.profilingMode,
+        runner: this.helmRunner,
+        inputArgumentsJson: request.inputArgumentsJson
+      }
+    });
+    const rawResult = asRawResult(result.details?.rawResult);
+    const error = asText(result.details?.runnerError);
+    return {
+      toolResult: this.toToolResult(rawResult, error),
+      rawResult,
+      error
+    };
+  }
+  toToolResult(rawResult, error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: rawResult ?? JSON.stringify({
+            success: false,
+            errorMessage: error ?? "Helm run returned no result"
+          })
+        }
+      ],
+      isError: rawResult === null || resultHasErrors(rawResult)
+    };
+  }
+  async resolveProjectType(projectDir) {
+    const fallback = RPA_PROJECT_TYPES[0];
+    try {
+      const raw = await this.fileSystem.readFile(this.fileSystem.path.join(projectDir, "project.json"), "utf-8");
+      if (!raw)
+        return fallback;
+      const outputType = JSON.parse(raw).designOptions?.outputType;
+      return RPA_PROJECT_TYPES.includes(outputType) ? outputType : fallback;
+    } catch {
+      return fallback;
+    }
+  }
+}
+function asRawResult(value) {
+  return typeof value === "string" ? value : null;
+}
+function asText(value) {
+  return typeof value === "string" ? value : undefined;
+}
+
 // src/telemetry/run-result-telemetry.ts
 var TERMINAL_RUN_COMMAND = "StartExecution";
 function buildRunResultTelemetry(input) {
@@ -61423,7 +62248,7 @@ function runFileTool(session) {
         },
         command: {
           type: "string",
-          description: "The actual command to run. Can be either one of the following: " + '- StartExecution: runs the workflow specified by the "filePath" and with the specified "inputArguments".' + '- StartDebugging: starts a debugging session for the workflow specified by the "filePath" and with the specified "inputArguments". ' + "Returns at the first stable state instead of blocking until the run ends: check the DebugState field of the result — " + "'Paused' (stopped at an activity; DebugDetails has the activity and locals), " + "'Suspended' (stopped on an exception; DebugDetails has the exception and locals — choose Continue/ContinueRetry/ContinueIgnore/Stop), " + "or 'Completed' (ran to the end; normal run result)." + "- Break: during debugging, breaks/pauses execution at the next activity and returns the paused state with locals." + "- Continue: during debugging, resumes execution if in a paused state." + "- Resume: during debugging, resumes execution if in a suspended state." + "- ContinueRetry: during debugging, resumes execution if in a paused state. If paused on exception, retry current activity execution." + "- ContinueIgnore: during debugging, resumes execution if in a paused state. If paused on exception, ignore the exception." + '- StepInto: when execution is paused and in debug mode, resumes debugging in a step-by-step fashion with the "Step Into" behavior.' + '- StepOver: when execution is paused and in debug mode, resumes debugging in a step-by-step fashion with the "Step Over" behavior.' + '- StepOut: when execution is paused and in debug mode, resumes debugging in a step-by-step fashion with the "Step Out" behavior.' + "All resume/step commands return at the NEXT stable state (Paused/Suspended/Completed), so each call tells you where execution now " + "stands via DebugState/DebugDetails; if no stable state is reached within waitTimeoutSeconds, they return DebugState 'Running' instead of hanging." + "- GetDebugState: reports the current debug session state without side effects ('None' when no session is active). " + "Pass waitTimeoutSeconds to long-poll a running session for its next stable state." + `- SetBreakpoints: replaces the active debug session's whole breakpoint set with the "breakpoints" parameter. ` + 'To set breakpoints for a new session, pass "breakpoints" directly on StartDebugging instead.' + "- Stop: stops the current debugging or execution session." + "- ToggleBreakpoint: toggles a breakpoint at the currently focused activity (if .xaml workflow) or line (if .cs coded workflow). " + "If no activity or line is in focus, toggles a breakpoint at the entire currently opened workflow." + "IMPORTANT: " + "- For .xaml workflows, the toggle cycles through three states: enabled breakpoint -> disabled breakpoint -> no breakpoint." + "- For .cs coded workflows, the toggle cycles through two states: breakpoint -> no breakpoint." + "- RestartFromTop: during debugging, restarts execution." + "- ForceSessionEnded: forces the current session to end." + "- TestActivity: isolates and executes the currently focused activity. " + 'Use "inputVariables" to set workflow variable expressions and "inputArguments" to set project argument expressions.' + "- StartDebuggingFromHere: starts a debugging session from the currently focused activity, " + 'skipping all preceding activities. Use "inputVariables" to set workflow variable expressions and "inputArguments" to set project argument expressions.' + "Defaults to StartExecution if not specified.",
+          description: "The actual command to run. Can be either one of the following: " + '- StartExecution: runs the workflow specified by the "filePath" and with the specified "inputArguments".' + '- StartDebugging: starts a debugging session for the workflow specified by the "filePath" and with the specified "inputArguments". ' + "Returns at the first stable state instead of blocking until the run ends: check the DebugState field of the result — " + "'Paused' (stopped at an activity; DebugDetails has the activity and locals), " + "'Suspended' (stopped on an exception; DebugDetails has the exception and locals — choose Continue/ContinueRetry/ContinueIgnore/Stop), " + "or 'Completed' (ran to the end; normal run result)." + "- Break: during debugging, breaks/pauses execution at the next activity and returns the paused state with locals." + "- Continue: during debugging, resumes execution if in a paused state." + "- Resume: during debugging, resumes execution if in a suspended state." + "- ContinueRetry: during debugging, resumes execution if in a paused state. If paused on exception, retry current activity execution." + "- ContinueIgnore: during debugging, resumes execution if in a paused state. If paused on exception, ignore the exception." + '- StepInto: with no active session, starts a debug session paused before the first activity; when a session is already paused or suspended, resumes debugging in a step-by-step fashion with the "Step Into" behavior.' + '- StepOver: with no active session, starts a debug session paused before the first activity; when a session is already paused or suspended, resumes debugging in a step-by-step fashion with the "Step Over" behavior.' + '- StepOut: with no active session, starts a debug session paused before the first activity; when a session is already paused or suspended, resumes debugging in a step-by-step fashion with the "Step Out" behavior.' + "All resume/step commands return at the NEXT stable state (Paused/Suspended/Completed), so each call tells you where execution now " + "stands via DebugState/DebugDetails; if no stable state is reached within waitTimeoutSeconds, they return DebugState 'Running' instead of hanging." + "- GetDebugState: reports the current debug session state without side effects ('None' when no session is active). " + "Pass waitTimeoutSeconds to long-poll a running session for its next stable state (Helm backend only; " + "on the Studio backend GetDebugState is always an instant probe)." + `- SetBreakpoints: replaces the active debug session's whole breakpoint set with the "breakpoints" parameter. ` + 'To set breakpoints for a new session, pass "breakpoints" directly on StartDebugging instead. ' + "Helm backend only — the Studio backend debugs against the breakpoints held in the designer, so use " + "ToggleBreakpoint there." + "- ApplyFileChanges: while paused/suspended in a debug session, reconciles your on-disk activity-property edits " + "into the running session via hot-reload, so the paused execution picks them up without a restart (e.g. the faulted " + "activity re-executes on ContinueRetry with your fix). Edit the workflow file on disk first, then call " + 'ApplyFileChanges naming what you changed via the "fileChanges" parameter. Returns { applied, rejected, debugState } ' + "instead of a run result: 'applied' edits are live in the session; 'rejected' edits (each with a reason) need a " + "session restart to take effect — structural (non-hot-reloadable) changes are rejected." + "- Stop: stops the current debugging or execution session." + "- ToggleBreakpoint: toggles a breakpoint at the currently focused activity (if .xaml workflow) or line (if .cs coded workflow). " + "If no activity or line is in focus, toggles a breakpoint at the entire currently opened workflow." + "IMPORTANT: " + "- For .xaml workflows, the toggle cycles through three states: enabled breakpoint -> disabled breakpoint -> no breakpoint." + "- For .cs coded workflows, the toggle cycles through two states: breakpoint -> no breakpoint." + "- RestartFromTop: during debugging, restarts execution." + "- ForceSessionEnded: forces the current session to end." + "- TestActivity: isolates and executes the currently focused activity. " + 'Use "inputVariables" to set workflow variable expressions and "inputArguments" to set project argument expressions.' + "- StartDebuggingFromHere: starts a debugging session from the currently focused activity, " + 'skipping all preceding activities. Use "inputVariables" to set workflow variable expressions and "inputArguments" to set project argument expressions.' + "Defaults to StartExecution if not specified.",
           enum: [
             "StartExecution",
             "StartDebugging",
@@ -61437,6 +62262,7 @@ function runFileTool(session) {
             "StepOut",
             "GetDebugState",
             "SetBreakpoints",
+            "ApplyFileChanges",
             "Stop",
             "ToggleBreakpoint",
             "RestartFromTop",
@@ -61480,6 +62306,12 @@ function runFileTool(session) {
           description: "When true, collect per-activity profiling data for the run and return it as a " + "Profiling field on the result. Only effective for start commands (StartExecution, " + "StartDebugging, TestActivity, StartDebuggingFromHere); ignored for stepping/breakpoint " + "commands. Requires a Studio Develop profile with the 'EnableProfiling' flag set; if " + "profiling is unavailable, the run still completes and the Profiling field is omitted.",
           default: false
         },
+        profilingMode: {
+          type: "string",
+          enum: ["endOfRun", "stream"],
+          description: "Real-time profiling delivery for start commands. Profiling data is collected " + "only when --profiling is set or when this is 'stream' (stream turns collection " + "on). 'endOfRun' (default) affects delivery only: when profiling is enabled it " + "returns the summary once at completion. 'stream' additionally forwards each " + "per-activity entry live as a [Profiling] line showing the activity display name, " + "its stable design-time idRef, timings, and the source workflow file whenever it " + "changes (ids/idRefs are only unique within one file); the exhaustive per-activity " + "data is also written to the run's *.uistat file. Helm backend only; ignored for " + "non-start commands and when running remote.",
+          default: "endOfRun"
+        },
         remote: {
           type: "boolean",
           description: "Run/debug on the configured remote agent (Orchestrator unattended robot) " + "instead of locally. Configure the target first with `rpa remote configure`. " + "Only affects start commands (StartExecution, StartDebugging, " + "StartDebuggingFromHere, TestActivity). Works with both Studio and Helm backends.",
@@ -61491,9 +62323,15 @@ function runFileTool(session) {
           contentSchema: { type: "array" },
           description: "Activity breakpoints for XAML debugging (a JSON array; one object per " + "breakpoint). Used by StartDebugging (initial set) and SetBreakpoints " + "(replaces the running session's whole set). Each breakpoint has: " + "workflowFile (required; workflow path relative to the project root), " + "activityIdRef (the target activity's sap2010:WorkflowViewState.IdRef " + "attribute value from the XAML — the stable way to address an activity) " + "or activityId (runtime id), plus optional condition (VB/C# expression; " + "breaks only when True), hitCount (break only on exactly the Nth hit), " + "and enabled (defaults to true). May be supplied as repeatable " + "comma-separated key=value items — one array item per occurrence: " + "--breakpoints 'workflowFile=Main.xaml,activityIdRef=Assign_1' " + "--breakpoints 'workflowFile=Main.xaml,activityIdRef=Click_2,hitCount:=3' " + "— or from a JSON file using '@breakpoints.json' or --breakpoints-file. " + "When execution pauses at a breakpoint, the result carries DebugState " + "'Paused' with the activity and locals in DebugDetails. Helm backend only."
         },
+        fileChanges: {
+          type: "string",
+          contentMediaType: "application/json",
+          contentSchema: { type: "array" },
+          description: "Activity-property edits to reconcile into a paused debug session (a JSON array; one " + "object per edited property). Only used by the ApplyFileChanges command. Each entry has: " + "workflowFile (required; workflow path relative to the project root), activityIdRef (the " + "target activity's sap2010:WorkflowViewState.IdRef attribute value from the XAML — the " + "stable way to address an activity), and propertyName (the edited property, e.g. Target). " + "Edit the workflow file on disk first, then call ApplyFileChanges naming what you changed. " + "May be supplied as repeatable comma-separated key=value items — one array item per " + "occurrence: --file-changes 'workflowFile=Main.xaml,activityIdRef=Click_2,propertyName=Target' " + "— or from a JSON file using '@changes.json' or --file-changes-file."
+        },
         waitTimeoutSeconds: {
           type: "number",
-          description: "Maximum seconds a mid-session debug command (Continue, Step*, Break, " + "GetDebugState) waits for the next stable state before returning " + "DebugState 'Running'. Defaults to 120 (0 for GetDebugState, making it " + "an instant probe). Ignored for start commands. Helm backend only."
+          description: "Maximum seconds a mid-session debug command (Continue, Step*, Break, " + "GetDebugState) waits for the next stable state before returning " + "DebugState 'Running'. Defaults to 120 (0 for GetDebugState, making it " + "an instant probe). Ignored for start commands, which wait for the run. " + "Helm backend only: the Studio backend applies its own fixed 120s bound " + "to mid-session commands and ignores an explicit value."
         },
         folderPath: {
           type: "string",
@@ -61510,10 +62348,13 @@ function runFileTool(session) {
     const logLevel = args.logLevel ?? "Trace";
     const skipBuild = args.skipBuild ?? false;
     const profiling = args.profiling ?? false;
+    const profilingMode = args.profilingMode;
     const remote = args.remote ?? false;
     const folderPath = args.folderPath;
     const waitTimeoutSeconds = args.waitTimeoutSeconds;
     const breakpoints = toJsonText(args.breakpoints);
+    const fileChanges = toJsonText(args.fileChanges);
+    const runInputArguments = inputArguments ?? "";
     for (const [name, value] of [
       ["inputArguments", inputArguments],
       ["inputVariables", inputVariables]
@@ -61531,6 +62372,16 @@ function runFileTool(session) {
         }
       }
     }
+    if (command === "ApplyFileChanges" && !fileChanges) {
+      return invalidInputResult("ApplyFileChanges requires --file-changes: one or more " + "workflowFile=...,activityIdRef=...,propertyName=... descriptors.");
+    }
+    if (fileChanges) {
+      try {
+        JSON.parse(fileChanges);
+      } catch {
+        return invalidInputResult("Invalid JSON for fileChanges");
+      }
+    }
     try {
       let isHelm = false;
       await session2.execute((instance) => {
@@ -61540,6 +62391,18 @@ function runFileTool(session) {
         requiresProject: true,
         backend: remote ? "any" /* Any */ : "helm" /* Helm */
       });
+      if (command === "ApplyFileChanges") {
+        const applyJson = isHelm ? await session2.execute((instance) => instance.helmServices.run.applyFileChanges({
+          fileChangesJson: fileChanges ?? ""
+        }), {
+          requiresProject: true,
+          backend: "helm" /* Helm */
+        }) : await session2.execute((instance) => instance.services.run.applyFileChanges(fileChanges ?? ""), { requiresProject: true });
+        return {
+          content: [{ type: "text", text: applyJson }],
+          isError: false
+        };
+      }
       if (isHelm) {
         if (START_COMMANDS2.has(command)) {
           try {
@@ -61554,7 +62417,21 @@ function runFileTool(session) {
           }
         }
         const helmRun = new HelmRunService(session2);
-        const helmResult = await helmRun.runFile(filePath, inputArguments ?? "", logLevel, command, skipBuild, profiling, folderPath, waitTimeoutSeconds, breakpoints);
+        if (command === "StartExecution" && projectDir) {
+          const outcome = await new RpaExecutorService(helmRun).runAsync({
+            projectDir,
+            filePath,
+            inputArgumentsJson: runInputArguments,
+            logLevel,
+            skipBuild,
+            profiling,
+            profilingMode,
+            folderPath
+          });
+          emitRunResult(command, outcome.rawResult, outcome.error, projectDir);
+          return outcome.toolResult;
+        }
+        const helmResult = await helmRun.runFile(filePath, runInputArguments, logLevel, command, skipBuild, profiling, profilingMode, folderPath, waitTimeoutSeconds, breakpoints);
         emitRunResult(command, helmResult.runResult, helmResult.error, projectDir);
         return {
           content: [
@@ -61581,7 +62458,7 @@ function runFileTool(session) {
           }
         }
       }
-      const result = await session2.execute((instance) => instance.services.run.executeCommand(command, filePath, inputArguments ?? "", inputVariables ?? "", logLevel, profiling), { requiresProject: true });
+      const result = await session2.execute((instance) => instance.services.run.executeCommand(command, filePath, runInputArguments, inputVariables ?? "", logLevel, profiling), { requiresProject: true });
       emitRunResult(command, result, undefined, projectDir);
       return {
         content: [
@@ -61770,18 +62647,18 @@ function stopExecutionTool(hostStudioPid) {
 // src/tools/local/tm-config.ts
 import { existsSync as existsSync12 } from "node:fs";
 import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname10, join as join22, resolve as resolve12 } from "node:path";
+import { dirname as dirname10, join as join23, resolve as resolve13 } from "node:path";
 var TM_DATA_DIR = ".tmh";
 var TM_CONFIG_FILE = "config.json";
 var PROJECT_FILE2 = "project.json";
 function resolveProjectDir2(projectDir) {
-  return resolve12(projectDir ?? process.cwd());
+  return resolve13(projectDir ?? process.cwd());
 }
 function tmConfigPath(projectDir) {
-  return join22(projectDir, TM_DATA_DIR, TM_CONFIG_FILE);
+  return join23(projectDir, TM_DATA_DIR, TM_CONFIG_FILE);
 }
 function assertIsProject(projectDir) {
-  if (!existsSync12(join22(projectDir, PROJECT_FILE2))) {
+  if (!existsSync12(join23(projectDir, PROJECT_FILE2))) {
     throw new Error(`No UiPath project found at '${projectDir}' (missing ${PROJECT_FILE2}). ` + `Pass --project-dir pointing at the project root.`);
   }
 }
@@ -61813,7 +62690,7 @@ function isSameTestManagerServer(a, b) {
 }
 var TM_LIVE_RELOAD_STUDIO_VERSION = "26.0.197";
 function normalizeDir(path4) {
-  return resolve12(path4).replace(/[\\/]+$/, "").toLowerCase();
+  return resolve13(path4).replace(/[\\/]+$/, "").toLowerCase();
 }
 function findOpenStudioInstance(projectDir, instances) {
   const target = normalizeDir(projectDir);
@@ -62296,7 +63173,7 @@ var registerCommands = async (program5, options) => {
     hostStudioPid: process.env.UIPATH_STUDIO_PID ? parseInt(process.env.UIPATH_STUDIO_PID, 10) : undefined,
     timeoutSeconds: parseInt(extractArg(process.argv, "timeout", "300") ?? "300", 10)
   };
-  resolved.projectDir = resolve13(resolved.projectDir);
+  resolved.projectDir = resolve14(resolved.projectDir);
   mirrorRobotDirToEnv(resolved.robotDir);
   if (!options) {
     const displayDefaults = {
@@ -62322,11 +63199,11 @@ var registerCommands = async (program5, options) => {
   const session = createSession(resolved, resolverDeps);
   registerListInstancesCommand(program5);
   registerStartStudioCommand(program5, resolved);
-  registerRestoreCommand(program5);
-  registerAnalyzeCommand(program5);
-  registerBuildCommand(program5);
-  registerPackCommand(program5);
-  registerCleanupCommand(program5);
+  registerRestoreCommand(program5, resolved.projectDir);
+  registerAnalyzeCommand(program5, resolved.projectDir);
+  registerBuildCommand(program5, resolved.projectDir);
+  registerPackCommand(program5, resolved.projectDir);
+  registerCleanupCommand(program5, resolved.projectDir);
   const format = extractArg(process.argv, "format");
   await registerExternalCliCommands(program5, resolved.projectDir, {
     commandName: "uia",
@@ -62334,7 +63211,8 @@ var registerCommands = async (program5, options) => {
     packageId: "UiPath.UIAutomation.CLI",
     minVersion: "26.4.1-preview",
     injectProjectDir: "project-dir",
-    injectFormat: "format"
+    injectFormat: "format",
+    supportsRemote: true
   }, undefined, session, format, { resolverDeps, robotDir: resolved.robotDir });
   const toolProvider = resolveToolProvider(resolved, session);
   await registerMcpCommands(program5, toolProvider);