@uipath/cli 1.197.0-preview.64 → 1.197.0-preview.66

package/dist/index.js

@@ -8216,11 +8216,234 @@ var init_output_format_context = __esm(() => {
   filterSlot = singleton("OutputFilter");
 });
 
+// ../common/src/telemetry/command-terminal.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function stringField(value, field) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const raw = value[field];
+  return typeof raw === "string" ? raw : undefined;
+}
+function numberField(value, field) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const raw = value[field];
+  return typeof raw === "number" ? raw : undefined;
+}
+function findStringInCauseChain(error, field) {
+  let current = error;
+  for (let depth = 0;depth < 5 && current !== null && typeof current === "object"; depth++) {
+    const value = stringField(current, field);
+    if (value) {
+      return value;
+    }
+    current = current.cause;
+  }
+  return;
+}
+function findCodeInCauseChain(error) {
+  return findStringInCauseChain(error, "code");
+}
+function isSpawnEnoent(error) {
+  const code = findCodeInCauseChain(error);
+  if (code !== "ENOENT") {
+    return false;
+  }
+  const syscall = findStringInCauseChain(error, "syscall");
+  return syscall?.startsWith("spawn") === true;
+}
+function isCancellationError(error, exitCode, pollSignal) {
+  if (exitCode === 130) {
+    return true;
+  }
+  if (!isRecord(error)) {
+    return false;
+  }
+  if (numberField(error, "exitCode") === 130) {
+    return true;
+  }
+  const name = stringField(error, "name");
+  if (name === "ExitPromptError") {
+    return true;
+  }
+  if (name === "AbortError" && pollSignal?.aborted) {
+    return true;
+  }
+  const message = stringField(error, "message");
+  return message?.includes("SIGINT") === true;
+}
+function terminalSignalFor(input, outcome) {
+  if (input.recordedFailure?.terminalSignal) {
+    return input.recordedFailure.terminalSignal;
+  }
+  const explicit = findStringInCauseChain(input.error, "terminalSignal") ?? findStringInCauseChain(input.error, "signal");
+  if (explicit) {
+    return explicit;
+  }
+  return outcome === "cancelled" ? "SIGINT" : undefined;
+}
+function classifyHttpStatus(status) {
+  if (status === 401 || status === 403) {
+    return "auth";
+  }
+  if (status === 400 || status === 409 || status === 422) {
+    return "validation";
+  }
+  if (status === 408) {
+    return "timeout";
+  }
+  return "network_http";
+}
+function classifyFromResult(result) {
+  switch (result) {
+    case "AuthenticationError":
+      return "auth";
+    case "ValidationError":
+      return "validation";
+    case "TimeoutError":
+      return "timeout";
+    default:
+      return;
+  }
+}
+function classifyFromErrorCode(errorCode) {
+  if (!errorCode) {
+    return;
+  }
+  if (AUTH_ERROR_CODES.has(errorCode)) {
+    return "auth";
+  }
+  if (VALIDATION_ERROR_CODES.has(errorCode)) {
+    return "validation";
+  }
+  if (TIMEOUT_ERROR_CODES.has(errorCode)) {
+    return "timeout";
+  }
+  if (NETWORK_HTTP_ERROR_CODES.has(errorCode)) {
+    return "network_http";
+  }
+  return;
+}
+function classifyFromError(error) {
+  const code = findCodeInCauseChain(error);
+  if (code) {
+    if (code.startsWith("commander.")) {
+      return "validation";
+    }
+    if (NETWORK_OS_ERROR_CODES.has(code) || TLS_ERROR_CODES2.has(code)) {
+      return "network_http";
+    }
+    if (TIMEOUT_OS_ERROR_CODES.has(code)) {
+      return "timeout";
+    }
+    if (MISSING_DEPENDENCY_CODES.has(code) || isSpawnEnoent(error)) {
+      return "missing_dependency";
+    }
+  }
+  const message = stringField(error, "message");
+  if (message?.includes("fetch failed") === true) {
+    return "network_http";
+  }
+  const name = stringField(error, "name");
+  if (name && INTERNAL_ERROR_NAMES.has(name)) {
+    return "internal";
+  }
+  return;
+}
+function classifyError(input) {
+  const recorded = input.recordedFailure;
+  if (recorded?.errorClass) {
+    return recorded.errorClass;
+  }
+  const status = recorded?.context?.httpStatus;
+  if (status !== undefined) {
+    return classifyHttpStatus(status);
+  }
+  return classifyFromResult(recorded?.result) ?? classifyFromErrorCode(recorded?.errorCode) ?? classifyFromError(input.error) ?? "unknown";
+}
+function recordCommandFailureTelemetry(failure) {
+  recordedFailureSlot.set(failure);
+}
+function clearRecordedCommandFailureTelemetry() {
+  recordedFailureSlot.clear();
+}
+function takeRecordedCommandFailureTelemetry() {
+  const failure = recordedFailureSlot.get();
+  recordedFailureSlot.clear();
+  return failure;
+}
+function buildCommandTerminalTelemetryProperties(input) {
+  const cancelled = isCancellationError(input.error, input.exitCode, input.pollSignal);
+  const outcome = input.recordedFailure?.terminalOutcome ?? (input.exitCode === 0 ? "success" : cancelled ? "cancelled" : "failure");
+  const errorClass = outcome === "success" || outcome === "no_op" ? undefined : outcome === "cancelled" ? "user_cancelled" : classifyError(input);
+  const terminalSignal = terminalSignalFor(input, outcome);
+  return {
+    exit_code: input.exitCode,
+    terminal_outcome: outcome,
+    ...errorClass ? { error_class: errorClass } : {},
+    ...terminalSignal ? { terminal_signal: terminalSignal } : {}
+  };
+}
+var recordedFailureSlot, AUTH_ERROR_CODES, VALIDATION_ERROR_CODES, NETWORK_HTTP_ERROR_CODES, TIMEOUT_ERROR_CODES, NETWORK_OS_ERROR_CODES, TIMEOUT_OS_ERROR_CODES, TLS_ERROR_CODES2, MISSING_DEPENDENCY_CODES, INTERNAL_ERROR_NAMES;
+var init_command_terminal = __esm(() => {
+  init_singleton();
+  recordedFailureSlot = singleton("CommandTelemetryFailure");
+  AUTH_ERROR_CODES = new Set([
+    "authentication_required",
+    "permission_denied"
+  ]);
+  VALIDATION_ERROR_CODES = new Set(["invalid_argument"]);
+  NETWORK_HTTP_ERROR_CODES = new Set([
+    "network_error",
+    "rate_limited",
+    "server_error",
+    "not_found",
+    "method_not_allowed"
+  ]);
+  TIMEOUT_ERROR_CODES = new Set(["timeout"]);
+  NETWORK_OS_ERROR_CODES = new Set([
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EAI_FAIL"
+  ]);
+  TIMEOUT_OS_ERROR_CODES = new Set(["ETIMEDOUT", "ESOCKETTIMEDOUT"]);
+  TLS_ERROR_CODES2 = new Set([
+    "SELF_SIGNED_CERT_IN_CHAIN",
+    "DEPTH_ZERO_SELF_SIGNED_CERT",
+    "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+    "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+    "UNABLE_TO_GET_ISSUER_CERT",
+    "CERT_HAS_EXPIRED",
+    "CERT_UNTRUSTED",
+    "ERR_TLS_CERT_ALTNAME_INVALID"
+  ]);
+  MISSING_DEPENDENCY_CODES = new Set([
+    "MODULE_NOT_FOUND",
+    "ERR_MODULE_NOT_FOUND"
+  ]);
+  INTERNAL_ERROR_NAMES = new Set([
+    "TypeError",
+    "ReferenceError",
+    "SyntaxError",
+    "RangeError"
+  ]);
+});
+
 // ../common/src/telemetry/telemetry-events.ts
 var CommonTelemetryEvents;
 var init_telemetry_events = __esm(() => {
   CommonTelemetryEvents = {
-    Error: "uip.error"
+    Error: "uip.error",
+    ShipSucceeded: "ship_succeeded"
   };
 });
 
@@ -8301,8 +8524,21 @@ var init_debug_telemetry_provider = __esm(() => {
 
 // ../common/src/telemetry/detect-agent.ts
 function detectAgent() {
+  return detectAgentFromEnv(process.env);
+}
+function detectAgentVersion() {
+  return detectAgentVersionFromEnv(process.env);
+}
+function detectAgentVersionFromEnv(env) {
+  const raw = env.AI_AGENT;
+  if (!raw || raw.length > 64)
+    return;
+  const version = AI_AGENT_PATTERN.exec(raw)?.[1];
+  return version?.replace(/-/g, ".");
+}
+function detectAgentFromEnv(env) {
   for (const agent of KNOWN_AGENTS) {
-    const envValue = process.env[agent.envVar];
+    const envValue = env[agent.envVar];
     if (agent.value !== undefined) {
       if (envValue === agent.value)
         return agent.id;
@@ -8311,7 +8547,7 @@ function detectAgent() {
         return agent.id;
     }
   }
-  const agentEnv = process.env.AGENT;
+  const agentEnv = env.AGENT;
   if (agentEnv) {
     if (agentEnv === "1" || agentEnv === "true")
       return "unknown";
@@ -8320,7 +8556,7 @@ function detectAgent() {
   }
   return;
 }
-var KNOWN_AGENTS;
+var KNOWN_AGENTS, AI_AGENT_PATTERN;
 var init_detect_agent = __esm(() => {
   KNOWN_AGENTS = [
     { envVar: "CLAUDECODE", value: "1", id: "claude-code" },
@@ -8331,6 +8567,173 @@ var init_detect_agent = __esm(() => {
     { envVar: "AUGMENT_AGENT", value: "1", id: "augment" },
     { envVar: "CLINE_ACTIVE", value: "true", id: "cline" }
   ];
+  AI_AGENT_PATTERN = /^[a-z0-9-]+_([0-9]+(?:-[0-9]+)*)_agent$/;
+});
+
+// ../common/src/telemetry/environment-info.ts
+function parseHost(baseUrl) {
+  if (!baseUrl)
+    return;
+  try {
+    return new URL(baseUrl).hostname.toLowerCase();
+  } catch {
+    return;
+  }
+}
+function normalizeEnvironment(baseUrl) {
+  const host = parseHost(baseUrl);
+  if (!host)
+    return "unknown";
+  if (LOCAL_HOSTS.has(host) || host.endsWith(".local"))
+    return "local";
+  if (host.includes("alpha"))
+    return "alpha";
+  if (host.includes("staging") || host.includes("stage"))
+    return "staging";
+  if (host === "cloud.uipath.com" || host.endsWith(".uipath.us")) {
+    return "prod";
+  }
+  return "unknown";
+}
+function normalizeBaseUrl(baseUrl) {
+  if (!baseUrl)
+    return;
+  try {
+    return new URL(baseUrl).origin;
+  } catch {
+    return;
+  }
+}
+function deriveRegion(baseUrl) {
+  const host = parseHost(baseUrl);
+  if (host?.endsWith(".uipath.us"))
+    return "gov";
+  return;
+}
+function buildEnvironmentProperties(baseUrl) {
+  const props = {
+    environment: normalizeEnvironment(baseUrl)
+  };
+  const normalized = normalizeBaseUrl(baseUrl);
+  if (normalized)
+    props.base_url = normalized;
+  const region = deriveRegion(baseUrl);
+  if (region)
+    props.region = region;
+  return props;
+}
+var LOCAL_HOSTS;
+var init_environment_info = __esm(() => {
+  LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+});
+
+// ../common/src/telemetry/execution-context.ts
+function currentEnv() {
+  return typeof process === "undefined" ? {} : process.env;
+}
+function currentTtyState() {
+  if (typeof process === "undefined")
+    return false;
+  return Boolean(process.stdout?.isTTY || process.stdin?.isTTY || process.stderr?.isTTY);
+}
+function detectCi(env) {
+  const signature = CI_SIGNATURES.find((candidate) => candidate.matches(env));
+  if (!signature)
+    return;
+  return {
+    executionContext: signature.isScheduler?.(env) ? "scheduler" : "ci",
+    ciProvider: signature.provider
+  };
+}
+function setExecutionContextAuthSignal(signal) {
+  if (signal === undefined) {
+    authSignalSlot.clear();
+    return;
+  }
+  authSignalSlot.set(signal);
+}
+function detectExecutionContext(options = {}) {
+  const env = options.env ?? currentEnv();
+  const ci = detectCi(env);
+  if (ci)
+    return ci;
+  const agent = options.agent ?? detectAgentFromEnv(env);
+  if (agent) {
+    return { executionContext: "agent" };
+  }
+  const authSignal = options.authSignal ?? authSignalSlot.get();
+  if (authSignal === "service_account") {
+    return { executionContext: "service_account" };
+  }
+  const isTty = options.isTty ?? currentTtyState();
+  if (isTty) {
+    return { executionContext: "manual" };
+  }
+  return { executionContext: "unknown" };
+}
+function getExecutionContextTelemetryProperties() {
+  const detected = detectExecutionContext();
+  return {
+    execution_context: detected.executionContext,
+    ...detected.ciProvider ? { ci_provider: detected.ciProvider } : {}
+  };
+}
+var authSignalSlot, isTruthy = (value) => value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false", isEqual = (value, expected) => value?.toLowerCase() === expected, CI_SIGNATURES;
+var init_execution_context = __esm(() => {
+  init_singleton();
+  init_detect_agent();
+  authSignalSlot = singleton("TelemetryExecutionContextAuthSignal");
+  CI_SIGNATURES = [
+    {
+      provider: "github_actions",
+      matches: (env) => isTruthy(env.GITHUB_ACTIONS),
+      isScheduler: (env) => env.GITHUB_EVENT_NAME === "schedule"
+    },
+    {
+      provider: "azure_devops",
+      matches: (env) => isTruthy(env.TF_BUILD),
+      isScheduler: (env) => isEqual(env.BUILD_REASON, "schedule")
+    },
+    {
+      provider: "gitlab",
+      matches: (env) => isTruthy(env.GITLAB_CI),
+      isScheduler: (env) => env.CI_PIPELINE_SOURCE === "schedule"
+    },
+    {
+      provider: "circleci",
+      matches: (env) => isTruthy(env.CIRCLECI),
+      isScheduler: (env) => env.CIRCLE_PIPELINE_TRIGGER_SOURCE === "scheduled_pipeline"
+    },
+    {
+      provider: "jenkins",
+      matches: (env) => isTruthy(env.JENKINS_URL) || isTruthy(env.JENKINS_HOME)
+    },
+    {
+      provider: "teamcity",
+      matches: (env) => isTruthy(env.TEAMCITY_VERSION)
+    },
+    {
+      provider: "buildkite",
+      matches: (env) => isTruthy(env.BUILDKITE),
+      isScheduler: (env) => env.BUILDKITE_SOURCE === "schedule"
+    },
+    {
+      provider: "bitbucket",
+      matches: (env) => isTruthy(env.BITBUCKET_BUILD_NUMBER)
+    },
+    {
+      provider: "travis",
+      matches: (env) => isTruthy(env.TRAVIS)
+    },
+    {
+      provider: "appveyor",
+      matches: (env) => isTruthy(env.APPVEYOR)
+    },
+    {
+      provider: "generic",
+      matches: (env) => isTruthy(env.CI)
+    }
+  ];
 });
 
 // ../common/src/telemetry/node-context-storage.ts
@@ -8347,6 +8750,42 @@ class NodeContextStorage {
 }
 var init_node_context_storage = () => {};
 
+// ../common/src/telemetry/session-id.ts
+function getProcessEnv() {
+  return globalThis.process?.env;
+}
+function normalizeSessionId(value) {
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return;
+  }
+  const trimmed = String(value).trim();
+  return trimmed || undefined;
+}
+function getConfiguredTelemetrySessionId() {
+  return normalizeSessionId(getProcessEnv()?.[TELEMETRY_SESSION_ID_ENV]);
+}
+function getTelemetrySessionId() {
+  const envSessionId = getConfiguredTelemetrySessionId();
+  if (envSessionId) {
+    return envSessionId;
+  }
+  const existing = telemetrySessionIdSlot.get();
+  if (existing) {
+    return existing;
+  }
+  const generated = crypto.randomUUID();
+  telemetrySessionIdSlot.set(generated);
+  return generated;
+}
+function resolveTelemetrySessionId(existingSessionId) {
+  return getConfiguredTelemetrySessionId() ?? normalizeSessionId(existingSessionId);
+}
+var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID", TELEMETRY_SESSION_ID_PROPERTY = "session_id", telemetrySessionIdSlot;
+var init_session_id = __esm(() => {
+  init_singleton();
+  telemetrySessionIdSlot = singleton("TelemetrySessionId");
+});
+
 // ../common/src/telemetry/global-telemetry-properties.ts
 function setGlobalTelemetryProperties(properties) {
   const existing = getGlobalTelemetryProperties();
@@ -8439,26 +8878,41 @@ class TelemetryService {
     return this.contextStorage.getContext();
   }
   enrichPropertiesWithContext(properties, context) {
-    return {
-      ...getGlobalTelemetryProperties(),
+    const globalProperties = getGlobalTelemetryProperties();
+    const existingSessionId = properties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? this.defaultProperties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? globalProperties?.[TELEMETRY_SESSION_ID_PROPERTY];
+    const sessionId = resolveTelemetrySessionId(existingSessionId);
+    const enriched = {
+      ...getExecutionContextTelemetryProperties(),
+      ...globalProperties,
       ...this.defaultProperties,
       ...properties,
       ...context
     };
+    if (sessionId === undefined) {
+      delete enriched[TELEMETRY_SESSION_ID_PROPERTY];
+    } else {
+      enriched[TELEMETRY_SESSION_ID_PROPERTY] = sessionId;
+    }
+    return enriched;
   }
   generateId() {
     return crypto.randomUUID().replaceAll("-", "");
   }
 }
 var init_telemetry_service = __esm(() => {
+  init_execution_context();
   init_global_telemetry_properties();
+  init_session_id();
 });
 
 // ../common/src/telemetry/node.ts
 var init_node2 = __esm(() => {
   init_debug_telemetry_provider();
   init_detect_agent();
+  init_environment_info();
+  init_execution_context();
   init_node_context_storage();
+  init_session_id();
   init_telemetry_service();
 });
 
@@ -43670,7 +44124,7 @@ function toOperationUrn(name) {
   const sanitized = encodeURIComponent(name).replace(/%2F/g, "/");
   return `urn:uip:${sanitized}`;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object";
 }
 function formatFlushJsonError(error) {
@@ -43678,7 +44132,7 @@ function formatFlushJsonError(error) {
     return error.message;
   if (typeof error === "string")
     return error;
-  if (!isRecord(error))
+  if (!isRecord2(error))
     return String(error);
   const parts = [];
   if (error.index !== undefined) {
@@ -43720,7 +44174,7 @@ function normalizeFlushCallbackError(response) {
     return;
   const [parseError, parsed] = catchError(() => JSON.parse(text));
   if (!parseError) {
-    const errors = isRecord(parsed) ? parsed.errors : undefined;
+    const errors = isRecord2(parsed) ? parsed.errors : undefined;
     if (Array.isArray(errors) && errors.length > 0) {
       return errors.map(formatFlushJsonError).join("; ");
     }
@@ -43772,7 +44226,7 @@ class NodeAppInsightsTelemetryProvider {
   initialized = false;
   constructor(connectionString) {
     this.connectionString = connectionString;
-    this._sessionId = crypto.randomUUID();
+    this._sessionId = getTelemetrySessionId();
   }
   async initialize() {
     if (this.initialized)
@@ -43931,6 +44385,7 @@ var init_node_appinsights_telemetry_provider = __esm(() => {
   init_logger();
   init_singleton();
   init_global_telemetry_properties();
+  init_session_id();
   init_global_telemetry_properties();
   providerSlot = singleton("TelemetryProvider");
 });
@@ -44437,6 +44892,7 @@ var init_formatter = __esm(() => {
   init_logger();
   init_output_context();
   init_output_format_context();
+  init_command_terminal();
   init_telemetry_events();
   init_telemetry_init();
   CLI_ERROR_CODES = [
@@ -44511,8 +44967,24 @@ var init_formatter = __esm(() => {
       data.ErrorCode ??= defaultErrorCodeForFailure(data);
       data.Retry ??= defaultRetryForErrorCode(data.ErrorCode);
       process.exitCode = EXIT_CODES[data.Result] ?? 1;
-      const { SuppressTelemetry, ...envelope } = data;
-      if (!SuppressTelemetry) {
+      recordCommandFailureTelemetry({
+        result: data.Result,
+        errorCode: data.ErrorCode,
+        retry: data.Retry,
+        message: data.Message,
+        context: data.Context,
+        exitCode: process.exitCode,
+        errorClass: data.TelemetryErrorClass,
+        terminalOutcome: data.TelemetryTerminalOutcome,
+        terminalSignal: data.TelemetryTerminalSignal
+      });
+      const suppressTelemetry = data.SuppressTelemetry === true;
+      const envelope = { ...data };
+      delete envelope.SuppressTelemetry;
+      delete envelope.TelemetryErrorClass;
+      delete envelope.TelemetryTerminalOutcome;
+      delete envelope.TelemetryTerminalSignal;
+      if (!suppressTelemetry) {
         telemetry.trackEvent(CommonTelemetryEvents.Error, {
           result: data.Result,
           errorCode: data.ErrorCode,
@@ -44576,6 +45048,174 @@ var init_formatter = __esm(() => {
   })(OutputFormatter ||= {});
 });
 
+// ../common/src/telemetry/command-attribution.ts
+function productMode(productArea, mode) {
+  return { product_area: productArea, mode };
+}
+function attributionRecord(groups) {
+  const record = {};
+  for (const [productArea, mode, names] of groups) {
+    const attribution = productMode(productArea, mode);
+    for (const name of names) {
+      record[name] = attribution;
+    }
+  }
+  return record;
+}
+function commandAttribution(groups) {
+  const entries = [];
+  for (const [productArea, mode, prefixes] of groups) {
+    const attribution = productMode(productArea, mode);
+    for (const prefix of prefixes) {
+      entries.push({ prefix, attribution });
+    }
+  }
+  return entries;
+}
+function normalizeCommandPath(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) {
+    return;
+  }
+  const tokens = trimmed.includes(" ") ? trimmed.split(/\s+/).filter((token) => token.length > 0).filter((token) => !token.startsWith("-")) : trimmed.split(".").filter((token) => token.length > 0);
+  if (tokens.length === 0) {
+    return;
+  }
+  const commandTokens = tokens[0] === "uip" ? tokens : ["uip", ...tokens];
+  return commandTokens.join(".");
+}
+function getCommandProductModeAttribution(commandPath) {
+  const normalized = normalizeCommandPath(commandPath);
+  if (!normalized) {
+    return;
+  }
+  return COMMAND_ATTRIBUTION.find(({ prefix }) => normalized === prefix || normalized.startsWith(`${prefix}.`))?.attribution;
+}
+function normalizeSkillNameWithOptions(value, options) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return;
+  }
+  const hasLegacyNamespace = normalized.startsWith(LEGACY_SKILL_NAMESPACE);
+  if (hasLegacyNamespace && !options.allowLegacyNamespace) {
+    return;
+  }
+  const skillName = hasLegacyNamespace ? normalized.slice(LEGACY_SKILL_NAMESPACE.length) : normalized;
+  if (skillName.length > MAX_SKILL_NAME_LENGTH || !SKILL_NAME_PATTERN.test(skillName) || !KNOWN_SKILL_NAMES.has(skillName)) {
+    return;
+  }
+  return skillName;
+}
+function normalizeSkillName(value) {
+  return normalizeSkillNameWithOptions(value, {
+    allowLegacyNamespace: false
+  });
+}
+function normalizeLegacySkillName(value) {
+  return normalizeSkillNameWithOptions(value, {
+    allowLegacyNamespace: true
+  });
+}
+function buildCommandTelemetryAttribution(commandPath, skillSource) {
+  const skillName = normalizeSkillName(skillSource);
+  return {
+    ...skillName ? { skill_name: skillName } : {},
+    ...getCommandProductModeAttribution(commandPath)
+  };
+}
+function buildSkillEventTelemetryAttribution(skillSource, uipSubcommand) {
+  const skillName = normalizeLegacySkillName(skillSource);
+  const skillAttribution = skillName ? SKILL_ATTRIBUTION[skillName] : {};
+  const commandAttribution2 = getCommandProductModeAttribution(uipSubcommand);
+  return {
+    ...skillAttribution,
+    ...commandAttribution2,
+    ...skillName ? { skill_name: skillName } : {}
+  };
+}
+var LEGACY_SKILL_NAMESPACE = "uipath:", MAX_SKILL_NAME_LENGTH = 80, SKILL_NAME_PATTERN, SKILL_ATTRIBUTION, KNOWN_SKILL_NAMES, COMMAND_ATTRIBUTION;
+var init_command_attribution = __esm(() => {
+  SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+  SKILL_ATTRIBUTION = attributionRecord([
+    ["admin", "operate", ["uipath-admin"]],
+    ["agents", "build", ["uipath-agents"]],
+    ["api-workflow", "build", ["uipath-api-workflow"]],
+    ["automation-discovery", "build", ["uipath-automation-discovery"]],
+    ["coded-apps", "build", ["uipath-coded-apps"]],
+    ["data-fabric", "operate", ["uipath-data-fabric"]],
+    ["cli", "troubleshoot", ["uipath-feedback"]],
+    ["governance", "operate", ["uipath-governance"]],
+    ["action-center", "build", ["uipath-human-in-the-loop"]],
+    ["document-understanding", "build", ["uipath-ixp"]],
+    [
+      "maestro",
+      "build",
+      ["uipath-maestro-bpmn", "uipath-maestro-case", "uipath-maestro-flow"]
+    ],
+    ["agenthub", "build", ["uipath-mcp-servers"]],
+    ["solution", "build", ["uipath-planner", "uipath-solution"]],
+    ["platform", "operate", ["uipath-platform"]],
+    ["quality", "troubleshoot", ["uipath-review"]],
+    ["rpa", "build", ["uipath-rpa"]],
+    ["cli", "operate", ["uipath-skill-catalog"]],
+    ["action-center", "operate", ["uipath-tasks"]],
+    ["test-manager", "operate", ["uipath-test"]],
+    ["platform", "troubleshoot", ["uipath-troubleshoot"]]
+  ]);
+  KNOWN_SKILL_NAMES = new Set(Object.keys(SKILL_ATTRIBUTION));
+  COMMAND_ATTRIBUTION = commandAttribution([
+    ["cli", "troubleshoot", ["uip.feedback"]],
+    ["llm-gateway", "operate", ["uip.llm-configuration", "uip.model-hub"]],
+    ["context-grounding", "build", ["uip.context-grounding"]],
+    ["api-workflow", "build", ["uip.api-workflow"]],
+    ["rpa", "build", ["uip.rpa-legacy"]],
+    ["conversational", "operate", ["uip.conversational"]],
+    ["agents", "build", ["uip.codedagent", "uip.agent"]],
+    ["agenthub", "build", ["uip.agenthub"]],
+    ["coded-apps", "build", ["uip.codedapp"]],
+    ["functions", "build", ["uip.functions"]],
+    ["solution", "build", ["uip.solution"]],
+    ["maestro", "build", ["uip.maestro", "uip.case", "uip.flow"]],
+    ["llm-observability", "troubleshoot", ["uip.traces"]],
+    ["platform", "operate", ["uip.platform"]],
+    ["admin", "operate", ["uip.admin"]],
+    ["automation-ops", "operate", ["uip.aops"]],
+    ["documentation", "troubleshoot", ["uip.docsai"]],
+    ["governance", "operate", ["uip.gov"]],
+    ["insights", "operate", ["uip.insights"]],
+    ["document-understanding", "build", ["uip.ixp"]],
+    ["process-mining", "operate", ["uip.pm"]],
+    ["action-center", "operate", ["uip.tasks"]],
+    ["test-manager", "operate", ["uip.tm"]],
+    ["vertical-solutions", "build", ["uip.vss"]],
+    ["data-fabric", "operate", ["uip.df"]],
+    ["integration-service", "build", ["uip.is"]],
+    ["orchestrator", "operate", ["uip.or"]],
+    [
+      "cli",
+      "operate",
+      [
+        "uip.login",
+        "uip.logout",
+        "uip.user",
+        "uip.config",
+        "uip.tools",
+        "uip.skills",
+        "uip.completion",
+        "uip.update",
+        "uip.mcp",
+        "uip.track"
+      ]
+    ]
+  ]).sort((a, b) => b.prefix.length - a.prefix.length);
+});
+
 // ../common/src/telemetry/pii-redactor.ts
 function shortHash(input) {
   let hash = 2166136261;
@@ -44754,12 +45394,20 @@ function commandHelpHint(commandPath) {
   const command = commandPath.replace(/\./g, " ");
   return `An unexpected error occurred. Run '${command} --help' to verify command syntax, or run with --log-level debug for details.`;
 }
+function isPromptCancellation(error) {
+  return error instanceof Error && error.name === "ExitPromptError";
+}
+function exitCodeFromProcess(fallback) {
+  return typeof process.exitCode === "number" ? process.exitCode : fallback;
+}
 var pollSignalSlot, cliErrorCodeValues, retryHintValues, processContext;
 var init_trackedAction = __esm(() => {
   init_esm();
   init_formatter();
   init_logger();
   init_singleton();
+  init_command_attribution();
+  init_command_terminal();
   init_pii_redactor();
   init_telemetry_init();
   pollSignalSlot = singleton("PollSignal");
@@ -44780,6 +45428,8 @@ var init_trackedAction = __esm(() => {
       const props = typeof properties === "function" ? properties(...args) : properties;
       const startTime = performance.now();
       let errorMessage;
+      let fallbackExitCode = EXIT_CODES.Success;
+      clearRecordedCommandFailureTelemetry();
       const [error] = await catchError(fn(...args));
       if (error) {
         errorMessage = error instanceof Error ? error.message : String(error);
@@ -44794,6 +45444,8 @@ var init_trackedAction = __esm(() => {
         const customRetry = isRetryHint(typedRetry) ? typedRetry : undefined;
         const typedContext = typed.context ?? typed.Context;
         const customContext = isErrorContext(typedContext) ? typedContext : undefined;
+        const cancellationExitCode = typed.exitCode === 130 || isPromptCancellation(error) ? 130 : undefined;
+        fallbackExitCode = cancellationExitCode ?? EXIT_CODES[finalResult];
         OutputFormatter.error({
           Result: finalResult,
           ...customErrorCode ? { ErrorCode: customErrorCode } : {},
@@ -44802,16 +45454,26 @@ var init_trackedAction = __esm(() => {
           ...customRetry ? { Retry: customRetry } : {},
           ...customContext ? { Context: customContext } : {}
         });
-        context.exit(EXIT_CODES[finalResult]);
+        context.exit(fallbackExitCode);
       }
       const durationMs = performance.now() - startTime;
-      const success = !error && (process.exitCode === undefined || process.exitCode === 0);
+      const exitCode = fallbackExitCode === 130 ? fallbackExitCode : exitCodeFromProcess(fallbackExitCode);
+      const recordedFailure = takeRecordedCommandFailureTelemetry();
+      const success = !error && exitCode === 0;
+      const terminalTelemetry = buildCommandTerminalTelemetryProperties({
+        error,
+        exitCode,
+        recordedFailure,
+        pollSignal: context.pollSignal
+      });
       telemetry.trackEvent(telemetryName, redactProperties({
         ...extractCommandParams(command),
         ...props,
+        ...buildCommandTelemetryAttribution(telemetryName, process.env.UIPATH_SKILL),
         command: "true",
         duration: String(durationMs),
         success: String(success),
+        ...terminalTelemetry,
         ...errorMessage ? { errorMessage } : {}
       }));
     });
@@ -45141,6 +45803,16 @@ async function readStdin() {
     process.stdin.on("error", reject);
   });
 }
+// ../common/src/telemetry/ship-succeeded.ts
+var shippedKeysSlot;
+var init_ship_succeeded = __esm(() => {
+  init_singleton();
+  init_pii_redactor();
+  init_telemetry_events();
+  init_telemetry_init();
+  shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
+});
+
 // ../common/src/tool-provider.ts
 function setPackagerFactoryProvider(provider) {
   factorySlot.set(provider);
@@ -45155,6 +45827,8 @@ var init_tool_provider = __esm(() => {
 var init_src2 = __esm(() => {
   init_console_guard();
   init_node_appinsights_telemetry_provider();
+  init_pii_redactor();
+  init_ship_succeeded();
   init_attachment_binding();
   init_command_examples();
   init_command_help();
@@ -45177,6 +45851,8 @@ var init_src2 = __esm(() => {
   init_screen_logger();
   init_sdk_user_agent();
   init_singleton();
+  init_command_attribution();
+  init_command_terminal();
   init_node2();
   init_telemetry_events();
   init_telemetry_init();
@@ -45190,7 +45866,7 @@ var init_package = __esm(() => {
   package_default = {
     name: "@uipath/cli",
     license: "MIT",
-    version: "1.197.0-preview.64",
+    version: "1.197.0-preview.66",
     description: "Cross platform CLI for UiPath",
     repository: {
       type: "git",
@@ -80425,6 +81101,9 @@ var init_selectTenant = __esm(() => {
   ]);
 });
 
+// ../auth/src/types.ts
+var AUTH_FLOW_ENV_VAR = "UIPATH_AUTH_FLOW";
+
 // ../auth/src/interactive.ts
 var interactiveLoginWithDeps = async (options, deps) => {
   const {
@@ -80474,6 +81153,7 @@ var interactiveLoginWithDeps = async (options, deps) => {
   if (noBrowser && !resolvedSecret && !onEvent) {
     throw new Error("noBrowser login requires an onEvent subscriber to receive the " + "auth-url event — the authorize URL is delivered through it.");
   }
+  const authFlow = resolvedSecret ? "client_credentials" : "authorization_code";
   const authPromise = resolvedSecret ? (async () => {
     return await clientCredentials({
       clientId: config2.clientId,
@@ -80504,7 +81184,8 @@ var interactiveLoginWithDeps = async (options, deps) => {
   issuerAsserter(tokens.UIPATH_ACCESS_TOKEN, config2.baseUrl);
   const credentials = {
     ...tokens,
-    UIPATH_URL: config2.baseUrl
+    UIPATH_URL: config2.baseUrl,
+    [AUTH_FLOW_ENV_VAR]: authFlow
   };
   try {
     const tokenData = jwtParser(tokens.UIPATH_ACCESS_TOKEN);
@@ -81098,7 +81779,8 @@ __export(exports_src2, {
   DEFAULT_AUTH_FILENAME: () => DEFAULT_AUTH_FILENAME,
   ClientCredentialsAuthenticationError: () => ClientCredentialsAuthenticationError,
   AuthProfileValidationError: () => AuthProfileValidationError,
-  AUTH_TIMEOUT_ERROR_CODE: () => AUTH_TIMEOUT_ERROR_CODE
+  AUTH_TIMEOUT_ERROR_CODE: () => AUTH_TIMEOUT_ERROR_CODE,
+  AUTH_FLOW_ENV_VAR: () => AUTH_FLOW_ENV_VAR
 });
 var authenticate = async ({
   baseUrl,
@@ -81848,7 +82530,7 @@ var init_helpFormatter = __esm(() => {
 });
 
 // src/utils/parseError.ts
-function helpInstructions(cleanedArgs) {
+function commandPartsFromArgs(cleanedArgs) {
   const commandParts = [];
   const userArgs = cleanedArgs.slice(2);
   for (let i = 0;i < userArgs.length; i++) {
@@ -81864,6 +82546,13 @@ function helpInstructions(cleanedArgs) {
     }
     commandParts.push(arg);
   }
+  return commandParts;
+}
+function commandEventNameFromArgs(cleanedArgs) {
+  return ["uip", ...commandPartsFromArgs(cleanedArgs)].join(".");
+}
+function helpInstructions(cleanedArgs) {
+  const commandParts = commandPartsFromArgs(cleanedArgs);
   const command = ["uip", ...commandParts].join(" ");
   return `Run '${command} --help' for usage information.`;
 }
@@ -81875,7 +82564,21 @@ function instructionsForUnknownCommand(cleanedArgs) {
   }
   return "Run 'uip --help' to list available commands.";
 }
-async function handleParseError(error51, cleanedArgs, context) {
+function trackCommandFailure(error51, cleanedArgs, exitCode, context, options) {
+  const recordedFailure = takeRecordedCommandFailureTelemetry();
+  telemetry.trackEvent(options?.eventName ?? commandEventNameFromArgs(cleanedArgs), {
+    command: "true",
+    duration: String(options?.durationMs ?? 0),
+    success: "false",
+    ...buildCommandTerminalTelemetryProperties({
+      error: error51,
+      exitCode,
+      recordedFailure,
+      pollSignal: context.pollSignal
+    })
+  });
+}
+async function handleParseError(error51, cleanedArgs, context, telemetryOptions) {
   const isObj = error51 !== null && typeof error51 === "object";
   const e = isObj ? error51 : {};
   const code = typeof e.code === "string" ? e.code : undefined;
@@ -81898,10 +82601,13 @@ async function handleParseError(error51, cleanedArgs, context) {
       Instructions: instructions,
       Retry: "RetryWillNotFix"
     });
+    const finalExitCode = process.exitCode ? Number(process.exitCode) : 1;
+    trackCommandFailure(error51, cleanedArgs, finalExitCode, context, telemetryOptions);
     await telemetryFlushAndShutdown();
-    context.exit(process.exitCode ? Number(process.exitCode) : 1);
+    context.exit(finalExitCode);
     return;
   }
+  trackCommandFailure(error51, cleanedArgs, process.exitCode ? Number(process.exitCode) : 1, context, telemetryOptions);
   await telemetryFlushAndShutdown();
   context.exit(process.exitCode ? Number(process.exitCode) : 1);
 }
@@ -81935,6 +82641,53 @@ function findUnknownHelpCommand(root, positionals, allArgs) {
 }
 
 // cli.core.ts
+function findSubcommand(command, token) {
+  return command.commands.find((subcommand) => subcommand.name() === token || subcommand.aliases().includes(token));
+}
+function commandEventNameFromProgram(program2, cleanedArgs) {
+  const parts = [];
+  let current = program2;
+  const userArgs = cleanedArgs.slice(2);
+  for (let i = 0;i < userArgs.length; i++) {
+    const token = userArgs[i];
+    if (token === "--") {
+      break;
+    }
+    if (token.startsWith("-")) {
+      if (!token.includes("=") && i + 1 < userArgs.length && !userArgs[i + 1].startsWith("-")) {
+        i++;
+      }
+      continue;
+    }
+    const subcommand = findSubcommand(current, token);
+    if (!subcommand) {
+      if (parts.length === 0) {
+        parts.push(token);
+      }
+      break;
+    }
+    parts.push(subcommand.name());
+    current = subcommand;
+  }
+  return ["uip", ...parts].join(".");
+}
+function trackRecordedCommandFailure(eventName, exitCode, durationMs, context, error51) {
+  const recordedFailure = takeRecordedCommandFailureTelemetry();
+  if (!recordedFailure) {
+    return;
+  }
+  telemetry.trackEvent(eventName, {
+    command: "true",
+    duration: String(durationMs),
+    success: "false",
+    ...buildCommandTerminalTelemetryProperties({
+      error: error51,
+      exitCode,
+      recordedFailure,
+      pollSignal: context.pollSignal
+    })
+  });
+}
 function errorMessage2(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
@@ -82039,10 +82792,20 @@ async function initProgram(context, hooks = {}) {
     }
   })();
   const agent = detectAgent();
+  const defaultTelemetryProperties = {
+    cli_version: package_default.version
+  };
+  if (agent !== undefined) {
+    defaultTelemetryProperties.agent = agent;
+    const agentVersion = detectAgentVersion();
+    if (agentVersion !== undefined) {
+      defaultTelemetryProperties.agent_version = agentVersion;
+    }
+  }
   await Promise.all([
     telemetryInit({
       version: package_default.version,
-      ...agent != null ? { defaultProperties: { agent } } : {}
+      defaultProperties: defaultTelemetryProperties
     }).then(() => logger.debug("Telemetry initialized")).then(async () => {
       if (hooks.afterTelemetryInit) {
         await hooks.afterTelemetryInit();
@@ -82064,22 +82827,35 @@ function finalizeProgram(args) {
 }
 async function parseAndExit(program2, cleanedArgs, context) {
   logger.debug(`Parsing args: ${cleanedArgs.slice(2).join(" ")}`);
+  const startTime = performance.now();
+  const initialCommandEventName = commandEventNameFromProgram(program2, cleanedArgs);
   const userArgs = cleanedArgs.slice(2);
   const firstToken = userArgs.find((a) => !a.startsWith("-"));
   const unknownRoot = firstToken && findUnknownHelpCommand(program2, [firstToken], userArgs);
   if (unknownRoot) {
+    const message = `error: unknown command '${unknownRoot}'`;
     OutputFormatter.error({
       Result: RESULTS.ValidationError,
-      Message: `error: unknown command '${unknownRoot}'`,
+      Message: message,
       Instructions: "Check command arguments and options. Run 'uip --help' for available commands."
     });
+    const exitCode = process.exitCode ? Number(process.exitCode) : 1;
+    trackRecordedCommandFailure(initialCommandEventName, exitCode, performance.now() - startTime, context, { code: "commander.unknownCommand", message });
     await telemetryFlushAndShutdown();
-    context.exit(process.exitCode ? Number(process.exitCode) : 1);
+    context.exit(exitCode);
     return;
   }
   const [parseError] = await catchError(program2.parseAsync(cleanedArgs));
   if (parseError) {
-    await handleParseError(parseError, cleanedArgs, context);
+    await handleParseError(parseError, cleanedArgs, context, {
+      eventName: commandEventNameFromProgram(program2, cleanedArgs),
+      durationMs: performance.now() - startTime
+    });
+  } else {
+    const exitCode = process.exitCode ? Number(process.exitCode) : 0;
+    if (exitCode !== 0) {
+      trackRecordedCommandFailure(commandEventNameFromProgram(program2, cleanedArgs), exitCode, performance.now() - startTime, context);
+    }
   }
   if (!process.exitCode || process.exitCode === 0) {
     logger.debug("Command completed — flushing telemetry");
@@ -89341,7 +90117,12 @@ var promptSelect = async (options, message) => {
     });
   } catch (error51) {
     if (error51 instanceof Error && error51.name === "ExitPromptError") {
-      throw new Error("Selection cancelled by user");
+      const cancellation = Object.assign(new Error("Selection cancelled by user"), {
+        exitCode: 130,
+        terminalSignal: "SIGINT"
+      });
+      cancellation.name = "ExitPromptError";
+      throw cancellation;
     }
     throw error51;
   }
@@ -89426,7 +90207,9 @@ var init_auth = __esm(() => {
 });
 
 // src/services/authTelemetry.ts
-var AuthTelemetryEvents, getUserIdFromToken = (accessToken) => {
+var AuthTelemetryEvents, readAuthFlow = (value) => {
+  return value === "authorization_code" || value === "client_credentials" ? value : undefined;
+}, UIPATH_EMAIL_DOMAIN = "uipath.com", decodeTokenClaims = (accessToken) => {
   try {
     const parts = accessToken.split(".");
     if (parts.length !== 3) {
@@ -89436,11 +90219,23 @@ var AuthTelemetryEvents, getUserIdFromToken = (accessToken) => {
     const base643 = payload.replace(/-/g, "+").replace(/_/g, "/");
     const padded = base643 + "=".repeat((4 - base643.length % 4) % 4);
     const decoded = atob(padded);
-    const claims = JSON.parse(decoded);
-    return claims.sub;
+    return JSON.parse(decoded);
   } catch {
     return;
   }
+}, isInternalUserEmail = (email3) => {
+  const at = email3.lastIndexOf("@");
+  if (at < 0) {
+    return false;
+  }
+  const domain2 = email3.slice(at + 1).trim().toLowerCase();
+  return domain2 === UIPATH_EMAIL_DOMAIN || domain2.endsWith(`.${UIPATH_EMAIL_DOMAIN}`);
+}, getInternalUserFlag = (claims) => {
+  const email3 = claims?.email ?? claims?.preferred_username;
+  if (typeof email3 !== "string" || !email3.includes("@")) {
+    return;
+  }
+  return String(isInternalUserEmail(email3));
 }, readAuthIdentity = async (deps) => {
   const envAuthEnabled = deps.isEnvAuthEnabled ?? isEnvAuthEnabled;
   const readEnv = deps.readAuthFromEnv ?? readAuthFromEnv;
@@ -89454,7 +90249,8 @@ var AuthTelemetryEvents, getUserIdFromToken = (accessToken) => {
     return {
       accessToken: status.accessToken,
       tenantId: status.tenantId,
-      organizationId: status.organizationId
+      organizationId: status.organizationId,
+      baseUrl: status.baseUrl
     };
   }
   const [resolveError, resolved] = await catchError(resolveEnvFilePath(getProfileFilePath() ?? DEFAULT_ENV_FILENAME));
@@ -89465,18 +90261,28 @@ var AuthTelemetryEvents, getUserIdFromToken = (accessToken) => {
     return;
   return {
     accessToken: credentials.UIPATH_ACCESS_TOKEN,
+    authFlow: readAuthFlow(credentials[AUTH_FLOW_ENV_VAR]),
     tenantId: credentials.UIPATH_TENANT_ID,
-    organizationId: credentials.UIPATH_ORGANIZATION_ID
+    organizationId: credentials.UIPATH_ORGANIZATION_ID,
+    baseUrl: credentials.UIPATH_URL
   };
 }, populateTelemetryAuthContext = async (deps = {}) => {
   const identity = await readAuthIdentity(deps);
-  if (!identity)
+  if (!identity) {
+    setExecutionContextAuthSignal(undefined);
     return;
-  const userId = identity.accessToken ? getUserIdFromToken(identity.accessToken) : undefined;
+  }
+  setExecutionContextAuthSignal(identity.authFlow === "client_credentials" ? "service_account" : undefined);
+  const claims = identity.accessToken ? decodeTokenClaims(identity.accessToken) : undefined;
+  const userId = claims?.sub;
+  const isInternalUser = getInternalUserFlag(claims);
+  const envProps = identity.baseUrl ? buildEnvironmentProperties(identity.baseUrl) : {};
   const defaultProps = {
     ...userId ? { CloudUserId: userId } : {},
     ...identity.tenantId ? { CloudTenantId: identity.tenantId } : {},
-    ...identity.organizationId ? { CloudOrganizationId: identity.organizationId } : {}
+    ...identity.organizationId ? { CloudOrganizationId: identity.organizationId } : {},
+    ...envProps,
+    ...isInternalUser !== undefined ? { IsInternalUser: isInternalUser } : {}
   };
   if (Object.keys(defaultProps).length === 0)
     return;
@@ -89624,6 +90430,7 @@ function buildLoginData(credentials) {
   const {
     UIPATH_ACCESS_TOKEN: _token,
     UIPATH_REFRESH_TOKEN: _refresh,
+    [AUTH_FLOW_ENV_VAR]: _authFlow,
     ...safeCredentials
   } = credentials;
   if (getOutputFormat() === "table") {
@@ -89675,6 +90482,13 @@ function emitRefreshFailure(status) {
     ...status.refreshTelemetrySuppressed ? { SuppressTelemetry: true } : {}
   });
 }
+function isUserCancellationError(error51) {
+  if (!(error51 instanceof Error)) {
+    return false;
+  }
+  const exitCode = error51.exitCode;
+  return error51.name === "ExitPromptError" || exitCode === 130 || error51.message === "Selection cancelled by user";
+}
 function defaultRefreshFailureInstructions(status) {
   switch (status.loginStatus) {
     case "Refresh Failed":
@@ -89757,6 +90571,9 @@ Open this URL in a browser to sign in:
       onEvent: handleAuthEvent
     }));
     if (error51) {
+      if (isUserCancellationError(error51)) {
+        throw error51;
+      }
       if (isTenantSelectionError(error51)) {
         trackAuthLogin(authFlow, { success: true });
         trackTenantSelection({
@@ -112888,6 +113705,14 @@ var init_tools = __esm(() => {
 });
 
 // src/commands/track.ts
+function isParsableJson(raw) {
+  try {
+    JSON.parse(raw);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function readStdinWithTimeout(timeoutMs) {
   let timer;
   const timeout = new Promise((resolve2) => {
@@ -112903,6 +113728,21 @@ async function readStdinWithTimeout(timeoutMs) {
       clearTimeout(timer);
   }
 }
+function resolveSkillsEventName(raw) {
+  let token;
+  try {
+    token = JSON.parse(raw)?.eventName;
+  } catch {
+    return null;
+  }
+  if (token === undefined || token === "") {
+    return SKILLS_EVENTS[DEFAULT_EVENT_TOKEN];
+  }
+  if (typeof token !== "string") {
+    return null;
+  }
+  return SKILLS_EVENTS[token] ?? null;
+}
 function buildEventProperties(raw) {
   let payload;
   try {
@@ -112919,10 +113759,26 @@ function buildEventProperties(raw) {
       continue;
     }
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      properties[key] = String(value);
+      const propertyKey = key === LEGACY_SESSION_ID_PROPERTY ? TELEMETRY_SESSION_ID_PROPERTY : key;
+      if (key === LEGACY_SESSION_ID_PROPERTY && properties[TELEMETRY_SESSION_ID_PROPERTY] !== undefined) {
+        continue;
+      }
+      properties[propertyKey] = String(value);
     }
   }
-  return Object.keys(properties).length > 0 ? properties : null;
+  let attribution = buildSkillEventTelemetryAttribution(properties.skill_name ?? properties.skillName, properties.uipSubcommand);
+  if (!attribution.skill_name && properties.skillName !== undefined) {
+    attribution = buildSkillEventTelemetryAttribution(properties.skillName, properties.uipSubcommand);
+  }
+  delete properties.skill_name;
+  Object.assign(properties, attribution);
+  if (Object.keys(properties).length === 0) {
+    return null;
+  }
+  if (process.env[TELEMETRY_SESSION_ID_ENV]?.trim()) {
+    properties[TELEMETRY_SESSION_ID_PROPERTY] = getTelemetrySessionId();
+  }
+  return properties;
 }
 function registerTrackCommand(program2) {
   program2.command("track", { hidden: true }).description("Ingest a skills-plugin telemetry event from stdin").action(async () => {
@@ -112936,39 +113792,53 @@ function registerTrackCommand(program2) {
         logger.debug("[track] no payload on stdin.");
         return;
       }
+      const eventName = resolveSkillsEventName(raw);
+      if (!eventName) {
+        logger.debug(isParsableJson(raw) ? "[track] unknown or invalid eventName; dropping event." : "[track] malformed JSON payload; dropping event.");
+        return;
+      }
       const properties = buildEventProperties(raw);
       if (!properties) {
         logger.debug("[track] no usable fields; dropping event.");
         return;
       }
       properties[SOURCE_DIMENSION_KEY] = SOURCE_DIMENSION_VALUE;
-      telemetry.trackEvent(SKILLS_EVENT_NAME, properties);
+      telemetry.trackEvent(eventName, redactProperties(properties));
     } catch (error52) {
       logger.debug(`[track] dropping event: ${String(error52)}`);
     }
   });
 }
-var SKILLS_EVENT_NAME = "uip.skills.tool-use", SOURCE_DIMENSION_KEY = "source", SOURCE_DIMENSION_VALUE = "skills-plugin", STDIN_TIMEOUT_MS = 1e4, ALLOWED_FIELDS;
+var SKILLS_EVENTS, DEFAULT_EVENT_TOKEN = "tool-use", SOURCE_DIMENSION_KEY = "source", SOURCE_DIMENSION_VALUE = "skills-plugin", LEGACY_SESSION_ID_PROPERTY = "sessionId", STDIN_TIMEOUT_MS = 1e4, ALLOWED_FIELDS;
 var init_track = __esm(() => {
   init_src2();
+  SKILLS_EVENTS = {
+    "tool-use": "uip.skills.tool-use",
+    "session-start": "uip.skills.session-start",
+    "session-end": "uip.skills.session-end",
+    completion: "uip.skills.completion"
+  };
   ALLOWED_FIELDS = new Set([
     "schemaVersion",
     "toolName",
     "skillName",
+    "skill_name",
     "uipSubcommand",
     "fileExtension",
-    "environment",
-    "baseUrl",
     "outcome",
     "permissionMode",
     "effortLevel",
     "skillsVersion",
     "toolUseId",
-    "sessionId",
+    TELEMETRY_SESSION_ID_PROPERTY,
+    LEGACY_SESSION_ID_PROPERTY,
     "subagentModel",
     "subagentType",
     "agentType",
-    "durationMs"
+    "durationMs",
+    "session_source",
+    "reason",
+    "agent_model"
   ]);
 });
 
@@ -113583,6 +114453,38 @@ var init_installPath = __esm(() => {
   init_localWorkspace();
 });
 
+// src/services/installTelemetry.ts
+function shouldPopulateTelemetryInstallContext(args) {
+  const separatorIndex = args.indexOf("--");
+  const parsedArgs = separatorIndex === -1 ? args : args.slice(0, separatorIndex);
+  return !parsedArgs.some((arg) => NO_COMMAND_TELEMETRY_FLAGS.has(arg));
+}
+var INSTALL_ID_TELEMETRY_KEY = "install_id", NO_COMMAND_TELEMETRY_FLAGS, populateTelemetryInstallContext = async (deps = {}) => {
+  const telemetryDisabled = deps.isTelemetryDisabled ?? isTelemetryDisabled;
+  if (telemetryDisabled()) {
+    return;
+  }
+  const resolveDeviceId = deps.getOrCreateDeviceId ?? getOrCreateDeviceId;
+  const [error52, deviceId] = await catchError(resolveDeviceId);
+  if (error52 || !deviceId?.trim()) {
+    if (error52) {
+      logger.debug(`[Telemetry] install context unavailable: ${error52.message}`);
+    }
+    return;
+  }
+  const defaultProps = {
+    [INSTALL_ID_TELEMETRY_KEY]: deviceId.trim()
+  };
+  setGlobalTelemetryProperties(defaultProps);
+  telemetry.setDefaultProperties(defaultProps);
+  logger.debug("[Telemetry] install context populated at startup");
+};
+var init_installTelemetry = __esm(() => {
+  init_src2();
+  init_deviceId();
+  NO_COMMAND_TELEMETRY_FLAGS = new Set(["-h", "--help", "-v", "--version"]);
+});
+
 // src/services/tool-manager.ts
 class ToolManager {
   toolsDirs;
@@ -114122,7 +115024,8 @@ function registerToolCommands(program2, discovered, context) {
         OutputFormatter.error({
           Result: RESULTS.ConfigError,
           Message: `Failed to load tool '${entry.toolName}' (version: ${entry.version || "unknown"}, path: ${entry.toolPath}).`,
-          Instructions: `Try reinstalling with 'uip tools install ${entry.commandPrefix}'.`
+          Instructions: `Try reinstalling with 'uip tools install ${entry.commandPrefix}'.`,
+          TelemetryErrorClass: "missing_dependency"
         });
         return;
       }
@@ -114142,7 +115045,8 @@ function registerToolCommands(program2, discovered, context) {
         OutputFormatter.error({
           Result: RESULTS.Failure,
           Message: `Failed to register commands from tool '${tool.metadata.name}': ${regError.message}`,
-          Instructions: "This might be due to a command name conflict with existing commands."
+          Instructions: "This might be due to a command name conflict with existing commands.",
+          TelemetryErrorClass: "internal"
         });
         return;
       }
@@ -114156,7 +115060,8 @@ function registerToolCommands(program2, discovered, context) {
         OutputFormatter.error({
           Result: RESULTS.ValidationError,
           Message: `error: unknown command '${unknownSub}'`,
-          Instructions: `Check command arguments and options. Run 'uip ${entry.commandPrefix} --help' for available subcommands.`
+          Instructions: `Check command arguments and options. Run 'uip ${entry.commandPrefix} --help' for available subcommands.`,
+          TelemetryErrorClass: "validation"
         });
         context.exit(process.exitCode ? Number(process.exitCode) : 1);
         return;
@@ -114214,6 +115119,9 @@ async function buildNodeProgram(context) {
       logLevelWasExplicit,
       profile
     }) => {
+      if (shouldPopulateTelemetryInstallContext(context.args)) {
+        await populateTelemetryInstallContext();
+      }
       const { setActiveAuthProfile: setActiveAuthProfile2, setAuthFileConfig: setAuthFileConfig2 } = await Promise.resolve().then(() => (init_src3(), exports_src2));
       setActiveAuthProfile2(profile);
       const [configErr, config2] = await catchError(loadConfigAsync());
@@ -114318,6 +115226,7 @@ var init_cli_node = __esm(() => {
   init_loadConfig();
   init_authTelemetry();
   init_installPath();
+  init_installTelemetry();
   init_tool_manager();
   init_versionSync();
   init_autoInstall();
@@ -114452,4 +115361,4 @@ export {
   ready
 };
 
-//# debugId=6A8DD2A74484607364756E2164756E21
+//# debugId=08E496A669D4128264756E2164756E21