@uipath/solution-tool 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/{packager-tool-a9jx8gf4.js → packager-tool-2vmsh5pt.js}

@@ -1,81 +1,85 @@
+import {
+  ACKNOWLEDGE_PERMANENT_DELETION_FLAG,
+  NO_SERVER_REASON,
+  acknowledgedButNotRunHint,
+  activateDeployment,
+  describeDeploymentFailureAsync,
+  describeValidationFailureAsync,
+  formatPermanentDeletionResources,
+  isPermanentDeletionRefusal,
+  pollPipelineDeploymentAsync,
+  remainingTimeoutMs,
+  resolveFolderInfo,
+  resolveParentFolder,
+  settlePermanentDeletionRefusalAsync,
+  stillRequiresConfirmation
+} from "./packager-tool-frr2xmkr.js";
 import {
   appendDeploymentStateInstructions,
   deploymentNextSteps,
-  explainRefusal,
   needsPendingResources,
-  readPendingResourcesAsync
-} from "./packager-tool-jq9zw82w.js";
+  pendingResourceApis,
+  readPendingResourcesAsync,
+  reportedActivationStatus
+} from "./packager-tool-5n6jsn41.js";
 import {
-  INCOMPLETE_SWEEP_ADVICE,
-  findDeploymentAcrossFeeds,
-  isNameOrFeedRefusal,
-  reportIncompleteSweepAsync,
-  retryAdvice
-} from "./packager-tool-9qgmwy21.js";
+  DRAFT_VERSION_MISMATCH_CODE,
+  explainPipelineStatusAfterInstall,
+  formatDeploymentFailureDetails,
+  hasServerErrorCode,
+  installLandedDespiteStatus,
+  leavesPendingDraft
+} from "./packager-tool-act5r386.js";
 import {
   DeploymentSearchNeedsUserSessionError,
   MAX_LISTED_DEPLOYMENTS,
   blocksRedeploy,
-  deploymentToTerminalPipelineResult,
   findDeploymentBestEffort,
-  findDeploymentByName,
   findDeploymentsByName,
   findDeploymentsByPackageName,
   formatExistingDeployments,
   interpretFailedDeployPoll,
   isAuthRefusal,
-  isCompletedUninstall,
-  isPipelineDeploymentNotFoundError,
-  mapOperationStatusToPipelineStatus,
   newestDeploymentRow,
-  resolveInstalledFolder,
-  searchDeploymentsPage
-} from "./packager-tool-tv9c1e80.js";
-import {
-  Configuration as Configuration2,
-  DeploymentOperation,
-  DeploymentStatus,
-  PipelinesApi
-} from "./packager-tool-7gr2nphb.js";
+  readDeploymentByKeyAsync,
+  resolveInstalledFolder
+} from "./packager-tool-d6rrfd46.js";
 import {
-  describeFeedResolutionFailureAsync,
   feedScopeInitOverride,
   feedSelectorFlag,
-  folderKeyInitOverride,
-  resolveFeedScope,
-  resolvePersonalWorkspace
-} from "./packager-tool-tgw5x6vx.js";
+  resolveFeedScope
+} from "./packager-tool-rvt68c1t.js";
 import {
   Configuration,
+  PipelinesApi
+} from "./packager-tool-97rcgwvv.js";
+import {
+  Configuration as Configuration2,
   DeploymentsApi,
-  SearchApi,
-  SolutionDeploymentAction,
-  WorkflowAction
-} from "./packager-tool-83m6ns0r.js";
+  SolutionDeploymentAction
+} from "./packager-tool-9t26kde1.js";
 import {
   classifyFeedSession,
-  feedReadRefusalForApplication,
   feedSessionRefusal
-} from "./packager-tool-bqre28m1.js";
+} from "./packager-tool-qw47eyw7.js";
 import {
   getSolutionAuthContext
-} from "./packager-tool-f5gq77m5.js";
+} from "./packager-tool-61pwb567.js";
 import {
   resolveFolder
-} from "./packager-tool-zdfn32bc.js";
+} from "./packager-tool-8ptbmmmp.js";
 import {
-  DEFAULT_PAGE_SIZE,
   PollOutcome,
-  catchError,
-  extractErrorDetails,
   logger,
-  mapPollFailure,
-  pollUntil,
-  processContext
-} from "./packager-tool-kswwd3hp.js";
+  mapPollFailure
+} from "./packager-tool-tx834spe.js";
+import {
+  catchError,
+  extractErrorDetails
+} from "./packager-tool-6ybywxxn.js";
 import {
   getFileSystem
-} from "./packager-tool-zf3929se.js";
+} from "./packager-tool-v1f5e8t9.js";
 import {
   __commonJS,
   __require
@@ -7022,550 +7026,6 @@ var require_public_api = __commonJS(function(exports) {
   exports.stringify = stringify;
 });
 
-// src/utils/deployment-errors.ts
-function coerceWorkflowErrorMessages(raw) {
-  if (Array.isArray(raw)) {
-    return raw.map(coerceWorkflowErrorMessage).filter((error) => error !== undefined);
-  }
-  const coerced = coerceWorkflowErrorMessage(raw);
-  if (coerced) {
-    return [coerced];
-  }
-  return [];
-}
-function coerceWorkflowErrorMessage(raw) {
-  if (raw === null || raw === undefined) {
-    return;
-  }
-  if (typeof raw === "string") {
-    const trimmed = raw.trim();
-    return trimmed ? { errorMessage: trimmed } : undefined;
-  }
-  if (!isRecord(raw)) {
-    return { errorMessage: String(raw) };
-  }
-  if (typeof raw.errorMessage === "string" && raw.errorMessage.trim()) {
-    return {
-      errorMessage: raw.errorMessage.trim(),
-      serviceMessage: typeof raw.serviceMessage === "string" ? raw.serviceMessage : undefined,
-      exceptionTrace: typeof raw.exceptionTrace === "string" ? raw.exceptionTrace : undefined,
-      serviceName: typeof raw.serviceName === "string" ? raw.serviceName : undefined
-    };
-  }
-  return { errorMessage: stringifyUnexpectedWorkflowError(raw) };
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function stringifyUnexpectedWorkflowError(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (error) {
-    return String(error);
-  }
-}
-function formatSummaryValidationError(e) {
-  return e.errorType ? `[${e.errorType}] ${e.errorText}` : e.errorText;
-}
-function formatSummaryScheduleError(e) {
-  return e.errorCode ? `[${e.errorCode}] ${e.errorText}` : e.errorText;
-}
-function formatSummaryWorkflowError(e) {
-  const parts = [e.errorMessage];
-  const details = [];
-  if (e.serviceName) {
-    details.push(`service: ${e.serviceName}`);
-  }
-  if (e.serviceMessage) {
-    details.push(`reason: ${e.serviceMessage}`);
-  }
-  if (details.length > 0) {
-    parts.push(`(${details.join(", ")})`);
-  }
-  return parts.join(" ");
-}
-function nonEmpty(arr) {
-  return arr && arr.length > 0 ? arr : undefined;
-}
-function extractDeploymentErrors(result) {
-  const validationErrors = nonEmpty(result.validationResult?.validationErrors?.map(formatSummaryValidationError));
-  const conflictSources = [
-    ...result.validationResult?.conflictErrors ?? [],
-    ...result.conflictFixingErrors ?? []
-  ];
-  const conflictErrors = nonEmpty(conflictSources.map(formatSummaryValidationError));
-  const scheduleErrors = nonEmpty(result.deploymentScheduleErrors?.map(formatSummaryScheduleError));
-  const deploymentErrors = nonEmpty(coerceWorkflowErrorMessages(result.deploymentResult?.errorMessage).map(formatSummaryWorkflowError));
-  if (!validationErrors && !conflictErrors && !scheduleErrors && !deploymentErrors) {
-    return;
-  }
-  return {
-    ValidationErrors: validationErrors,
-    ConflictErrors: conflictErrors,
-    ScheduleErrors: scheduleErrors,
-    DeploymentErrors: deploymentErrors
-  };
-}
-function formatDeploymentErrorsAsText(summary) {
-  const lines = [];
-  if (summary.ValidationErrors) {
-    lines.push(`Validation: ${summary.ValidationErrors.join("; ")}`);
-  }
-  if (summary.ConflictErrors) {
-    lines.push(`Conflicts: ${summary.ConflictErrors.join("; ")}`);
-  }
-  if (summary.ScheduleErrors) {
-    lines.push(`Schedule: ${summary.ScheduleErrors.join("; ")}`);
-  }
-  if (summary.DeploymentErrors) {
-    lines.push(`Deployment: ${summary.DeploymentErrors.join("; ")}`);
-  }
-  return lines.join(`
-`);
-}
-function formatErrorCode(errorCode) {
-  return errorCode ? `[${errorCode}] ` : "";
-}
-function formatDetailedValidationError(error) {
-  const resource = [error.kind, error.name].filter(Boolean).join(" ");
-  const prefix = resource ? `${resource}: ` : "";
-  return `${formatErrorCode(error.errorCode)}${prefix}${error.errorText}`;
-}
-function formatDetailedConflictError(error) {
-  const actions = error.conflictFixingActions?.length ? ` (fix: ${error.conflictFixingActions.join(", ")})` : "";
-  return `${formatDetailedValidationError(error)}${actions}`;
-}
-function formatDetailedScheduleError(error) {
-  return `${formatErrorCode(error.errorCode)}${error.errorText}`;
-}
-function formatDetailedWorkflowError(error) {
-  const parts = [
-    error.serviceName && error.errorMessage ? `${error.serviceName}: ${error.errorMessage}` : error.errorMessage ?? error.serviceName,
-    error.serviceMessage,
-    error.exceptionTrace
-  ].filter(Boolean);
-  return parts.join(" | ");
-}
-function formatResourceInstallError(error) {
-  const context = [error.kind, error.type, error.name].filter(Boolean).join(" ");
-  return context ? `${context}: ${error.text}` : error.text;
-}
-function formatServiceError(service) {
-  const servicePrefix = service.serviceName ? `${service.serviceName} (${service.status})` : service.status;
-  const errors = [];
-  if (service.errorMessage) {
-    errors.push(`${servicePrefix}: ${service.errorMessage}`);
-  }
-  if (service.serviceErrorMessages?.length) {
-    errors.push(...service.serviceErrorMessages.map((error) => `${servicePrefix}: ${formatResourceInstallError(error)}`));
-  }
-  return errors;
-}
-function formatDeploymentIdentifiers(pipelineDeploymentId, status) {
-  const identifiers = [
-    `pipelineDeploymentId=${pipelineDeploymentId}`,
-    status.deploymentKey ? `deploymentKey=${status.deploymentKey}` : "",
-    status.configurationKey ? `configurationKey=${status.configurationKey}` : "",
-    status.instanceId ? `instanceId=${status.instanceId}` : ""
-  ].filter(Boolean);
-  return `Operation: ${identifiers.join(", ")}`;
-}
-function formatDeploymentFailureDetails(pipelineDeploymentId, status) {
-  return [
-    ...formatPipelineErrors(status),
-    formatDeploymentIdentifiers(pipelineDeploymentId, status)
-  ].join(`
-`);
-}
-function formatPipelineErrors(status) {
-  const errorParts = [];
-  const validationErrors = status.validationResult?.validationErrors;
-  if (validationErrors?.length) {
-    errorParts.push(`Validation: ${validationErrors.map(formatDetailedValidationError).join("; ")}`);
-  }
-  const conflictErrors = status.validationResult?.conflictErrors;
-  if (conflictErrors?.length) {
-    errorParts.push(`Conflicts: ${conflictErrors.map(formatDetailedConflictError).join("; ")}`);
-  }
-  if (status.conflictFixingErrors?.length) {
-    errorParts.push(`Conflict fixing: ${status.conflictFixingErrors.map(formatDetailedValidationError).join("; ")}`);
-  }
-  if (status.deploymentScheduleErrors?.length) {
-    errorParts.push(`Schedule: ${status.deploymentScheduleErrors.map(formatDetailedScheduleError).join("; ")}`);
-  }
-  const workflowErrors = coerceWorkflowErrorMessages(status.deploymentResult?.errorMessage);
-  if (workflowErrors.length) {
-    errorParts.push(`Deployment: ${workflowErrors.map(formatDetailedWorkflowError).join("; ")}`);
-  }
-  const serviceErrors = status.deploymentResult?.services?.flatMap(formatServiceError);
-  if (serviceErrors?.length) {
-    errorParts.push(`Services: ${serviceErrors.join("; ")}`);
-  }
-  return errorParts;
-}
-function hasServerErrorCode(details, code) {
-  return new RegExp(`"errorCode"\\s*:\\s*"${code}"`).test(details);
-}
-function isBareResponse(details) {
-  return !/^\s*[{[]/.test(details);
-}
-var DRAFT_VERSION_MISMATCH_CODE = "DraftDeploymentHasDifferentPackageVersion";
-function leavesPendingDraft(status) {
-  return status === "ValidationFailed" || status === "ConflictFixingError" || status === "DeploymentScheduleError";
-}
-function installLandedDespiteStatus(status) {
-  const record = status.deploymentResult?.status;
-  return status.status !== "DeploymentSucceeded" && (record === "SuccessfulInstall" || record === "SuccessfulActivate");
-}
-function explainPipelineStatusAfterInstall(status) {
-  const lines = formatPipelineErrors(status);
-  const errors = lines.length > 0 ? ` ${lines.join(" ")}` : "";
-  return `The deploy pipeline ended at ${status.status} although the install landed (the deployment record reports ${status.deploymentResult?.status}): the errors it attached come from the activation validation the pipeline runs after the install, not from the install.${errors}`;
-}
-
-// src/services/activation.ts
-var TERMINAL_STATUSES = new Set([
-  "SuccessfulActivate",
-  "FailedActivate"
-]);
-async function activateDeployment(auth, deploymentName, options) {
-  const api = new PipelinesApi(new Configuration2({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  }));
-  const [stepsError, steps] = await catchError(api.pipelinesGetPreActivateSteps({ deploymentName }, options.scope));
-  if (stepsError) {
-    const { message, details, errorCode, retry, context } = await extractErrorDetails(stepsError);
-    const deployment = await findDeploymentBestEffort(auth, deploymentName, options.scope);
-    return {
-      kind: "RequestFailed",
-      phase: "preActivateSteps",
-      message,
-      details,
-      errorCode,
-      retry,
-      httpStatus: context?.httpStatus,
-      deployment
-    };
-  }
-  if (steps.steps.length > 0) {
-    logger.info(`Pre-activate steps for ${deploymentName}:`);
-    for (const step of steps.steps) {
-      logger.info(`  [${step.serviceName}] ${step.step}: ${step.description}`);
-    }
-  }
-  const [activateError, activateResult] = await catchError(api.pipelinesActivate({ deploymentName }, options.scope));
-  if (activateError) {
-    const { message, details, errorCode, retry, context } = await extractErrorDetails(activateError);
-    const deployment = await findDeploymentBestEffort(auth, deploymentName, options.scope);
-    return {
-      kind: "RequestFailed",
-      phase: "activate",
-      message,
-      details,
-      errorCode,
-      retry,
-      httpStatus: context?.httpStatus,
-      deployment
-    };
-  }
-  const instanceId = activateResult.instanceId;
-  if (!instanceId) {
-    return { kind: "NoInstance" };
-  }
-  const pollResult = await pollUntil({
-    fn: () => api.pipelinesGetDeploymentInstanceStatus({ instanceId }, options.scope),
-    until: (result) => TERMINAL_STATUSES.has(result.status),
-    getStatus: (result) => result.status,
-    label: `activate ${deploymentName}`,
-    logPrefix: "activate",
-    timeoutMs: options.timeoutSeconds * 1000,
-    intervalMs: options.pollIntervalMs,
-    signal: options.signal ?? processContext.pollSignal
-  });
-  if (pollResult.outcome !== PollOutcome.Completed || !pollResult.data) {
-    return { kind: "PollFailed", poll: pollResult };
-  }
-  const finalStatus = pollResult.data;
-  if (finalStatus.status !== "SuccessfulActivate") {
-    const errorMessage = coerceWorkflowErrorMessages(finalStatus.errorMessage).map((e) => e.errorMessage).join(", ") || "Unknown error";
-    return {
-      kind: "ActivationFailed",
-      status: finalStatus.status,
-      instanceId,
-      errorMessage
-    };
-  }
-  return {
-    kind: "Success",
-    status: finalStatus.status,
-    instanceId
-  };
-}
-
-// src/services/deploy-activate-service.ts
-var fail = (reason, message, instructions, exitCode = 1) => ({
-  ok: false,
-  reason,
-  message,
-  instructions,
-  exitCode
-});
-var AUTH_INSTRUCTIONS = "Run 'uip login' to refresh credentials, then retry activation. If the deployment is in a different tenant, switch with 'uip login tenant set <tenant>'.";
-async function incompleteSweepRefusalAsync(deploymentName, skipped, result) {
-  const details = `Details: ${result.details}`;
-  if (!isNameOrFeedRefusal(result.errorCode, result.httpStatus)) {
-    return {
-      ...fail("request_failed", result.message, `The activation request failed. ${retryAdvice(result.errorCode, result.retry, "Orchestrator")} ${details}`),
-      errorCode: result.errorCode,
-      retry: result.retry
-    };
-  }
-  const report = await reportIncompleteSweepAsync(deploymentName, skipped);
-  return {
-    ...fail("request_failed", report.message, `${INCOMPLETE_SWEEP_ADVICE} Without its feed the activation went to the tenant feed, which refused it. ${report.nextStep} ${details} (feed search: ${report.details})`),
-    errorCode: report.errorCode,
-    retry: report.retry
-  };
-}
-async function activateDeploymentAsync(deploymentName, options = {}) {
-  const [authError, auth] = await catchError(getSolutionAuthContext({
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (authError) {
-    return fail("auth_failed", authError.message, AUTH_INSTRUCTIONS);
-  }
-  const sweep = await findDeploymentAcrossFeeds(auth, deploymentName, {
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  });
-  const location = sweep.location;
-  const result = await activateDeployment(auth, deploymentName, {
-    timeoutSeconds: options.timeout ?? 360,
-    pollIntervalMs: options.pollInterval ?? 5000,
-    signal: options.signal,
-    scope: location?.scope
-  });
-  if (result.kind === "RequestFailed") {
-    const details = `Details: ${result.details}`;
-    const known = result.deployment ?? location?.deployment;
-    if (!known && !sweep.complete) {
-      return incompleteSweepRefusalAsync(deploymentName, sweep.skipped, result);
-    }
-    const pendingResources = known && needsPendingResources(known) ? await readPendingResourcesAsync(new DeploymentsApi(new Configuration({
-      basePath: auth.basePath,
-      accessToken: auth.accessToken
-    })), known.key, location?.scope) : undefined;
-    const feedSelector = feedSelectorFlag(location?.feed);
-    const explanation = known ? explainRefusal(known, pendingResources, feedSelector) : undefined;
-    const instructions = explanation ? [...explanation, details].join(`
-`) : known ? `Deployment '${known.name}' exists (Operation: ${known.operation}, OperationStatus: ${known.operationStatus}, ActivationStatus: ${known.activationStatus}) but the service refused to activate it. Check it with: uip solution deploy status ${known.key}${feedSelector}. ${details}` : result.phase === "preActivateSteps" ? `Check deployment name. Deploy first with: uip solution deploy run. ${details}` : `Check deployment name matches an existing deployment. ${details}`;
-    return fail("request_failed", result.message, instructions);
-  }
-  if (result.kind === "NoInstance") {
-    return {
-      ok: true,
-      status: "Activation completed (no instance to poll)",
-      deploymentName
-    };
-  }
-  if (result.kind === "PollFailed") {
-    const { reason, message, exitCode } = mapPollFailure(result.poll, "Activation");
-    return fail(reason, message, "Activation may still be in progress.", exitCode);
-  }
-  if (result.kind === "ActivationFailed") {
-    return fail("activation_failed", `Activation failed with status: ${result.status}`, result.errorMessage);
-  }
-  return {
-    ok: true,
-    status: result.status,
-    deploymentName,
-    instanceId: result.instanceId
-  };
-}
-
-// src/services/folder-helper.ts
-async function resolveParentFolder(options) {
-  if (!options.folderPath && !options.folderKey && !options.personalWorkspace) {
-    return;
-  }
-  if (options.personalWorkspace) {
-    const [pwError, pw] = await catchError(resolvePersonalWorkspace({
-      tenant: options.tenant,
-      loginValidity: options.loginValidity,
-      envFilePath: options.envFilePath
-    }));
-    if (pwError) {
-      throw new Error(`Failed to resolve Personal Workspace: ${pwError.message}`);
-    }
-    return pw.name;
-  }
-  if (options.folderPath) {
-    return options.folderPath;
-  }
-  const [resolveError, resolved] = await catchError(resolveFolder({ folderKey: options.folderKey }, {
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (resolveError) {
-    throw new Error(`Failed to resolve folder key '${options.folderKey}': ${resolveError.message}`);
-  }
-  if (!resolved) {
-    throw new Error(`Folder not found for key '${options.folderKey}'.`);
-  }
-  return resolved.path;
-}
-async function resolveFolderInfo(options) {
-  if (!options.folderPath && !options.folderKey) {
-    return;
-  }
-  const [resolveError, resolved] = await catchError(resolveFolder({ folderPath: options.folderPath, folderKey: options.folderKey }, {
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (resolveError) {
-    throw new Error(`Failed to resolve folder '${options.folderPath ?? options.folderKey}': ${resolveError.message}`);
-  }
-  if (!resolved) {
-    throw new Error(`Folder not found: '${options.folderPath ?? options.folderKey}'.`);
-  }
-  return { key: resolved.key, path: resolved.path };
-}
-
-// src/services/search-failure.ts
-async function describeSearchFailureAsync(error, what, session, { userSessionsOnly }) {
-  const details = await extractErrorDetails(error);
-  if (userSessionsOnly && details.context?.httpStatus === 401 && classifyFeedSession(session) === "application") {
-    return {
-      message: `Failed to list ${what}: Solution Search accepts user sessions only, and this session is an external app.`,
-      instructions: `Run it with a user session ('uip login'). A client-credentials login cannot list solution ${what}.`,
-      errorCode: "permission_denied",
-      retry: "RetryWillNotFix",
-      context: details.context
-    };
-  }
-  return {
-    message: `Failed to list ${what}: ${details.message}`,
-    instructions: searchFailureInstructions(details.errorCode, details.retry),
-    errorCode: details.errorCode,
-    retry: details.retry,
-    context: details.context
-  };
-}
-function searchFailureInstructions(errorCode, retry) {
-  if (errorCode === "authentication_required") {
-    return "Run 'uip login' to refresh the session, then run the command again.";
-  }
-  if (errorCode === "permission_denied") {
-    return "Use an account that can read Automation Solutions in this tenant.";
-  }
-  if (retry === "RetryLater") {
-    return "Wait a moment, then run the command again.";
-  }
-  return "Check the options and the session ('uip login status --detailed'), then run the command again.";
-}
-
-// src/services/deploy-list-service.ts
-var fail2 = (reason, message, instructions, extras = {}) => ({
-  ok: false,
-  reason,
-  message,
-  instructions,
-  exitCode: 1,
-  ...extras
-});
-var refuseFeedRead = (refusal) => fail2("feed_requires_user_session", refusal.message, refusal.instructions, {
-  errorCode: "permission_denied",
-  retry: "RetryWillNotFix"
-});
-async function listDeploymentsAsync(options = {}) {
-  const limit = options.limit ?? DEFAULT_PAGE_SIZE;
-  const offset = options.offset ?? 0;
-  const [authError, auth] = await catchError(getSolutionAuthContext({
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (authError) {
-    return fail2("auth_failed", authError.message, authError.message);
-  }
-  if (options.personalWorkspace) {
-    const refusal = feedReadRefusalForApplication(auth, "Listing the Personal Workspace's deployments");
-    if (refusal) {
-      return refuseFeedRead(refusal);
-    }
-  }
-  const [folderError, folderPathFilter] = await catchError(resolveParentFolder({
-    folderPath: options.folderPath,
-    folderKey: options.folderKey,
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (folderError) {
-    return fail2("folder_resolution_failed", folderError.message, "Provide a valid --folder-path or --folder-key to filter by folder.");
-  }
-  const [scopeError, scope] = await catchError(resolveFeedScope({
-    personalWorkspace: options.personalWorkspace,
-    feed: options.feed,
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (scopeError) {
-    const { message, instructions, ...extras } = await describeFeedResolutionFailureAsync(scopeError, options, auth);
-    return fail2("feed_resolution_failed", message, instructions, extras);
-  }
-  if (scope.kind !== "tenant") {
-    const refusal = feedReadRefusalForApplication(auth, `Listing the deployments of the feed '${scope.name ?? scope.folderKey}'`);
-    if (refusal) {
-      return refuseFeedRead(refusal);
-    }
-  }
-  const [listError, result] = await catchError(searchDeploymentsPage(auth, {
-    take: limit,
-    skip: offset,
-    orderByColumn: options.sortBy ?? "startTime",
-    orderByDirection: options.sortOrder ?? "Descending",
-    operationStatuses: options.operationStatuses ?? [],
-    activationStatuses: options.activationStatuses ?? [],
-    ...folderPathFilter ? { targetFolderName: folderPathFilter } : {}
-  }, feedScopeInitOverride(scope)));
-  if (listError instanceof DeploymentSearchNeedsUserSessionError) {
-    return fail2("list_request_failed", `Failed to list deployments: ${listError.message}`, "Run it with a user session ('uip login'). A client-credentials login cannot list deployments on this server.", { errorCode: "permission_denied", retry: "RetryWillNotFix" });
-  }
-  if (listError) {
-    const { message, instructions, ...extras } = await describeSearchFailureAsync(listError, "deployments", auth, {
-      userSessionsOnly: false
-    });
-    return fail2("list_request_failed", message, instructions, extras);
-  }
-  const values = result.values ?? [];
-  const deployments = values.map((d) => ({
-    key: d.key,
-    installDeploymentKey: d.installDeploymentKey,
-    name: d.name,
-    packageName: d.packageName,
-    packageVersion: d.packageVersion,
-    currentPackageVersion: d.currentPackageVersion,
-    targetPackageVersion: d.targetPackageVersion,
-    newPackageVersionAvailable: d.newPackageVersionAvailable,
-    operation: d.operation,
-    operationStatus: d.operationStatus,
-    activationStatus: d.activationStatus,
-    folderPath: d.folderPath,
-    installedRootFolderKey: d.installedRootFolderKey,
-    deploymentCreationTime: d.deploymentCreationTime,
-    actions: d.actions ?? []
-  }));
-  return { ok: true, deployments, limit, offset, total: result.count };
-}
-
 // ../../node_modules/yaml/dist/index.js
 var composer = require_composer();
 var Document = require_Document();
@@ -7612,132 +7072,6 @@ var $stringify = publicApi.stringify;
 var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
-// src/services/deployment-validation.ts
-var NO_SERVER_REASON = "the server reported no reason.";
-var LOOKUP_TIMEOUT_MS = 15000;
-function boundedScope(scope, signal) {
-  const deadline = AbortSignal.timeout(LOOKUP_TIMEOUT_MS);
-  const abort = signal ? AbortSignal.any([signal, deadline]) : deadline;
-  return async (requestContext) => ({
-    ...await scope?.(requestContext),
-    signal: abort
-  });
-}
-async function describeValidationFailureAsync(deploymentsApi, deploymentKey, deploymentAction, scope, signal) {
-  const [error, validation] = await catchError(deploymentsApi.deploymentsGetValidationResult({ deploymentKey, deploymentAction }, boundedScope(scope, signal)));
-  if (error || !validation) {
-    return NO_SERVER_REASON;
-  }
-  const messages = [
-    ...validation.validationErrors.map((item) => item.text || item.resource),
-    ...validation.resourceValidationErrors.flatMap((resource) => resource.errors.map((item) => item.text || item.resource))
-  ].filter(Boolean);
-  return messages.length > 0 ? messages.join("; ") : NO_SERVER_REASON;
-}
-async function describeDeploymentFailureAsync(auth, deployment, deploymentAction, scope, signal) {
-  const deploymentsApi = new DeploymentsApi(new Configuration({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  }));
-  const keys = [deployment.key, deployment.installDeploymentKey].filter((key, index, all) => Boolean(key) && all.indexOf(key) === index);
-  for (const key of keys) {
-    const reason = await describeValidationFailureAsync(deploymentsApi, key, deploymentAction, scope, signal);
-    if (reason !== NO_SERVER_REASON) {
-      return reason;
-    }
-  }
-  return NO_SERVER_REASON;
-}
-
-// src/services/pipeline-deploy-poll.ts
-var PIPELINE_TERMINAL_STATUSES = new Set([
-  "DeploymentSucceeded",
-  "DeploymentFailed",
-  "ValidationFailed",
-  "ConflictFixingError",
-  "DeploymentScheduleError"
-]);
-var NO_ERRORS = {
-  validationResult: { validationErrors: [], conflictErrors: [] },
-  conflictFixingErrors: [],
-  deploymentScheduleErrors: []
-};
-function stillInFlight(deploymentKey) {
-  return {
-    status: "DeploymentInProgress",
-    deploymentKey: deploymentKey ?? "",
-    configurationKey: "",
-    ...NO_ERRORS
-  };
-}
-async function readOutcomeByKeyAsync(api, deploymentKey) {
-  const [error, info] = await catchError(() => api.pipelinesGetDeploymentByKey({ key: deploymentKey }));
-  if (error || !info) {
-    return;
-  }
-  if (info.deploymentKey !== deploymentKey) {
-    return;
-  }
-  if (info.operation === "Uninstall" || info.operationStatus === "Draft") {
-    return stillInFlight(deploymentKey);
-  }
-  const status = mapOperationStatusToPipelineStatus(info.operationStatus);
-  if (!status) {
-    return stillInFlight(deploymentKey);
-  }
-  return {
-    status,
-    deploymentKey: info.deploymentKey,
-    configurationKey: "",
-    ...NO_ERRORS,
-    synthesizedOperation: info.operation
-  };
-}
-async function pollPipelineDeploymentAsync(api, auth, options) {
-  let observedDeploymentKey;
-  return pollUntil({
-    fn: async () => {
-      try {
-        const status = await api.pipelinesGetPipelineDeploymentStatus({ pipelineDeploymentId: options.pipelineDeploymentId }, options.scope);
-        if (status.deploymentKey) {
-          observedDeploymentKey = status.deploymentKey;
-        }
-        return status;
-      } catch (err) {
-        if (!await isPipelineDeploymentNotFoundError(err)) {
-          throw err;
-        }
-        if (!observedDeploymentKey) {
-          return stillInFlight(undefined);
-        }
-        const byKey = await readOutcomeByKeyAsync(api, observedDeploymentKey);
-        if (byKey) {
-          return byKey;
-        }
-        const deployment = await findDeploymentBestEffort(auth, options.deploymentName, options.scope, { deploymentKey: observedDeploymentKey });
-        if (!deployment || deployment.operationStatus === "Draft") {
-          return stillInFlight(observedDeploymentKey);
-        }
-        const synthesized = deploymentToTerminalPipelineResult(deployment);
-        if (!synthesized) {
-          return stillInFlight(observedDeploymentKey);
-        }
-        return {
-          ...synthesized,
-          synthesizedOperation: deployment.operation
-        };
-      }
-    },
-    until: (result) => PIPELINE_TERMINAL_STATUSES.has(result.status),
-    getStatus: (result) => result.status,
-    label: `deployment ${options.pipelineDeploymentId}`,
-    logPrefix: options.logPrefix,
-    timeoutMs: options.timeoutMs,
-    intervalMs: options.intervalMs,
-    signal: options.signal
-  });
-}
-
 // src/services/deploy-run-service.ts
 var PROCESS_RESOURCE_MAPPING_ERROR = /(?:AgentProcessResource|FlowProcessResource)\s*->\s*ReleaseDto/;
 var PROCESS_KEY_MAPPING_ERROR = /Destination Member:\s*ProcessKey|Invalid argument 'Key'/;
@@ -7766,7 +7100,7 @@ function parseConfiguration(content) {
   }
   return yamlConfiguration;
 }
-var fail3 = (reason, message, instructions, extras = {}) => ({
+var fail = (reason, message, instructions, extras = {}) => ({
   ok: false,
   reason,
   message,
@@ -7774,8 +7108,34 @@ var fail3 = (reason, message, instructions, extras = {}) => ({
   exitCode: extras.exitCode ?? 1,
   pipelineDeploymentId: extras.pipelineDeploymentId,
   errorCode: extras.errorCode,
-  retry: extras.retry
+  retry: extras.retry,
+  ...extras.deploymentKey !== undefined && {
+    deploymentKey: extras.deploymentKey
+  },
+  ...extras.permanentDeletionResources !== undefined && {
+    permanentDeletionResources: extras.permanentDeletionResources
+  },
+  ...extras.permanentlyDeletedResources !== undefined && {
+    permanentlyDeletedResources: extras.permanentlyDeletedResources
+  }
 });
+var failPermanentDeletion = (refusal, pipelineDeploymentId, deploymentKey) => fail(refusal.reason, refusal.message, refusal.instructions, {
+  ...refusal.classification,
+  pipelineDeploymentId,
+  deploymentKey,
+  permanentDeletionResources: refusal.resources
+});
+async function readInstalledFolderAsync(auth, deploymentName, deploymentKey, scope) {
+  if (deploymentKey) {
+    const [, info] = await catchError(readDeploymentByKeyAsync(auth, deploymentKey, { scope }));
+    if (info?.deploymentKey === deploymentKey && info.installedRootFolderKey) {
+      return { installedRootFolderKey: info.installedRootFolderKey };
+    }
+  }
+  return findDeploymentBestEffort(auth, deploymentName, scope, {
+    deploymentKey
+  });
+}
 function makeFolderKeyResolver(options) {
   return async (folderKey) => {
     const folder = await resolveFolder({ folderKey }, {
@@ -7793,7 +7153,7 @@ async function deployRunAsync(options) {
     envFilePath: options.envFilePath
   }));
   if (authError) {
-    return fail3("auth_failed", authError.message, authError.message);
+    return fail("auth_failed", authError.message, authError.message);
   }
   let feedScope = { kind: "tenant" };
   if (options.personalWorkspace || options.feed !== undefined) {
@@ -7811,7 +7171,7 @@ async function deployRunAsync(options) {
       envFilePath: options.envFilePath
     }));
     if (scopeError) {
-      return fail3(options.feed !== undefined ? "feed_resolution_failed" : "personal_workspace_deploy_failed", scopeError.message, "List the feeds you can deploy from with: uip solution feeds list.");
+      return fail(options.feed !== undefined ? "feed_resolution_failed" : "personal_workspace_deploy_failed", scopeError.message, "List the feeds you can deploy from with: uip solution feeds list.");
     }
     feedScope = scope2;
     if (feedScope.kind !== "tenant") {
@@ -7829,7 +7189,7 @@ async function deployRunAsync(options) {
   if (feedScope.kind !== "tenant") {
     const [locationError, location] = await catchError(resolveFeedDeployLocation(feedScope, options));
     if (locationError) {
-      return fail3("location_outside_feed", locationError.message, "Pass a --parent-folder-path / --parent-folder-key inside the feed folder, or omit it to deploy into the feed folder itself.");
+      return fail("location_outside_feed", locationError.message, "Pass a --parent-folder-path / --parent-folder-key inside the feed folder, or omit it to deploy into the feed folder itself.");
     }
     parentFolderPath = location.folderFQN || undefined;
   } else {
@@ -7842,7 +7202,7 @@ async function deployRunAsync(options) {
       envFilePath: options.envFilePath
     }));
     if (folderError) {
-      return fail3("folder_resolution_failed", folderError.message, "Provide a valid --parent-folder-path, --parent-folder-key, or --personal-workspace.");
+      return fail("folder_resolution_failed", folderError.message, "Provide a valid --parent-folder-path, --parent-folder-key, or --personal-workspace.");
     }
     parentFolderPath = resolved;
   }
@@ -7853,7 +7213,7 @@ async function deployRunAsync(options) {
     packageName: options.packageName,
     packageVersion: options.packageVersion
   };
-  const configuration = new Configuration2({
+  const configuration = new Configuration({
     basePath: auth.basePath,
     accessToken: auth.accessToken
   });
@@ -7864,45 +7224,87 @@ async function deployRunAsync(options) {
     const configPath = fs.path.resolve(options.configFile);
     const [readError, configContent] = await catchError(fs.readFile(configPath, "utf-8"));
     if (readError) {
-      return fail3("config_file_read_failed", `Failed to read config file: ${configPath}`, readError.message);
+      return fail("config_file_read_failed", `Failed to read config file: ${configPath}`, readError.message);
     }
     if (configContent === null) {
-      return fail3("config_file_not_found", `Failed to read config file: ${configPath}`, `File not found at ${configPath}. Check the --config-file path; generate a default config with: uip solution deploy config get <name> -d config.json.`);
+      return fail("config_file_not_found", `Failed to read config file: ${configPath}`, `File not found at ${configPath}. Check the --config-file path; generate a default config with: uip solution deploy config get <name> -d config.json.`);
     }
     const [parseError, parsed] = catchError(() => parseConfiguration(configContent));
     if (parseError) {
-      return fail3("config_file_parse_failed", `Invalid JSON or YAML in config file: ${configPath}`, parseError.message);
+      return fail("config_file_parse_failed", `Invalid JSON or YAML in config file: ${configPath}`, parseError.message);
     }
     configBody = parsed;
   }
-  const [installError, installResult] = await catchError(api.pipelinesInstall({
-    deploymentName: options.deploymentName,
-    packageName: options.packageName,
-    packageVersion: options.packageVersion,
-    solutionRootFolderName: options.folderName,
-    folderFullyQualifiedName: parentFolderPath,
-    body: configBody
-  }, scope));
-  if (installError || !installResult?.pipelineDeploymentId) {
-    if (!installError) {
-      return fail3(installFailureReason(feedScope), "The install request returned no pipeline deployment.", installFailureHint(feedScope, options));
-    }
-    const detail = await extractErrorDetails(installError);
-    if (hasServerErrorCode(detail.details, DRAFT_VERSION_MISMATCH_CODE)) {
-      return fail3("pending_draft", detail.message, `${pendingDraftHint(feedScope, options)} Details: ${detail.details}`, { errorCode: detail.errorCode, retry: detail.retry });
-    }
-    return fail3(installFailureReason(feedScope), detail.message, `${installFailureHint(feedScope, options)} Details: ${detail.details}`, { errorCode: detail.errorCode, retry: detail.retry });
-  }
-  const pipelineDeploymentId = installResult.pipelineDeploymentId;
-  const pollResult = await pollPipelineDeploymentAsync(api, auth, {
-    pipelineDeploymentId,
-    deploymentName: options.deploymentName,
-    scope,
-    timeoutMs: (options.timeout ?? 360) * 1000,
-    intervalMs: options.pollInterval ?? 5000,
-    signal: options.signal,
-    logPrefix: "deploy"
-  });
+  const timeoutMs = (options.timeout ?? 360) * 1000;
+  let deadline;
+  const installAndPollAsync = async () => {
+    const [installError, installResult] = await catchError(api.pipelinesInstall({
+      deploymentName: options.deploymentName,
+      packageName: options.packageName,
+      packageVersion: options.packageVersion,
+      solutionRootFolderName: options.folderName,
+      folderFullyQualifiedName: parentFolderPath,
+      body: configBody
+    }, scope));
+    if (installError || !installResult?.pipelineDeploymentId) {
+      if (!installError) {
+        return fail(installFailureReason(feedScope), "The install request returned no pipeline deployment.", installFailureHint(feedScope, options));
+      }
+      const detail = await extractErrorDetails(installError);
+      if (hasServerErrorCode(detail.details, DRAFT_VERSION_MISMATCH_CODE)) {
+        return fail("pending_draft", detail.message, `${pendingDraftHint(feedScope, options)} Details: ${detail.details}`, { errorCode: detail.errorCode, retry: detail.retry });
+      }
+      return fail(installFailureReason(feedScope), detail.message, `${installFailureHint(feedScope, options)} Details: ${detail.details}`, { errorCode: detail.errorCode, retry: detail.retry });
+    }
+    const pipelineDeploymentId2 = installResult.pipelineDeploymentId;
+    deadline ??= Date.now() + timeoutMs;
+    const pollResult2 = await pollPipelineDeploymentAsync(api, auth, {
+      pipelineDeploymentId: pipelineDeploymentId2,
+      deploymentName: options.deploymentName,
+      scope,
+      timeoutMs: remainingTimeoutMs(timeoutMs, deadline),
+      intervalMs: options.pollInterval ?? 5000,
+      signal: options.signal,
+      logPrefix: "deploy"
+    });
+    return { ok: true, pipelineDeploymentId: pipelineDeploymentId2, pollResult: pollResult2 };
+  };
+  let attempt = await installAndPollAsync();
+  if (!attempt.ok) {
+    return attempt;
+  }
+  let permanentlyDeletedResources;
+  if (attempt.pollResult.outcome === PollOutcome.Completed && isPermanentDeletionRefusal(attempt.pollResult.data)) {
+    const refused = attempt.pollResult.data;
+    const keepCopiesHint = "remove those links from the --config-file (uip solution deploy config unlink <file> <resource>) and re-run";
+    const consent = await settlePermanentDeletionRefusalAsync({
+      api,
+      deploymentName: options.deploymentName,
+      scope,
+      signal: options.signal,
+      acknowledge: options.acknowledgePermanentDeletion === true,
+      status: refused,
+      verb: "Deploying",
+      confirmHint: `re-run the same command with ${ACKNOWLEDGE_PERMANENT_DELETION_FLAG}`,
+      keepCopiesHint
+    });
+    if (!consent.ok) {
+      return failPermanentDeletion(consent, attempt.pipelineDeploymentId, refused.deploymentKey || undefined);
+    }
+    attempt = await installAndPollAsync();
+    if (!attempt.ok) {
+      return {
+        ...attempt,
+        instructions: `${attempt.instructions} ${acknowledgedButNotRunHint(consent.resources, keepCopiesHint)}`
+      };
+    }
+    if (attempt.pollResult.outcome === PollOutcome.Completed && isPermanentDeletionRefusal(attempt.pollResult.data)) {
+      const deploymentKey = attempt.pollResult.data?.deploymentKey || undefined;
+      return failPermanentDeletion(stillRequiresConfirmation(options.deploymentName, consent.resources, deploymentKey), attempt.pipelineDeploymentId, deploymentKey);
+    }
+    permanentlyDeletedResources = consent.resources.map((resource) => formatPermanentDeletionResources([resource]));
+  }
+  const { pipelineDeploymentId, pollResult } = attempt;
   const folderPath = parentFolderPath ? `${parentFolderPath}/${options.folderName}` : options.folderName;
   if (pollResult.outcome !== PollOutcome.Completed || !pollResult.data) {
     const recoveryKey = pollResult.data?.deploymentKey || undefined;
@@ -7917,6 +7319,9 @@ async function deployRunAsync(options) {
       return {
         ok: true,
         ...feedFields,
+        ...permanentlyDeletedResources && {
+          permanentlyDeletedResources
+        },
         status: "DeploymentSucceeded",
         deploymentKey: recoveryDeployment?.key,
         pipelineDeploymentId,
@@ -7939,18 +7344,18 @@ async function deployRunAsync(options) {
       };
     }
     if (recovery?.kind === "ActivationFailed") {
-      return fail3("activation_failed_post_deploy", `Deployment '${options.deploymentName}' completed but activation failed.`, `Inspect activation details in Orchestrator, then retry with: uip solution deploy activate ${options.deploymentName}.`, { pipelineDeploymentId });
+      return fail("activation_failed_post_deploy", `Deployment '${options.deploymentName}' completed but activation failed.`, `Inspect activation details in Orchestrator, then retry with: uip solution deploy activate ${options.deploymentName}${feedSelectorFlag(feedScope)}.`, { pipelineDeploymentId });
     }
     if (recovery?.kind === "DeployFailed") {
       const reason2 = recoveryDeployment ? await describeDeploymentFailureAsync(auth, recoveryDeployment, SolutionDeploymentAction.Install, scope, options.signal) : NO_SERVER_REASON;
-      return fail3("deploy_failed", `Deployment '${options.deploymentName}' failed (OperationStatus: ${recovery.operationStatus}): ${reason2}`, `${inspectHint(pipelineDeploymentId, feedScope)} Fix the underlying issue and retry: uip solution deploy run.`, { pipelineDeploymentId });
+      return fail("deploy_failed", `Deployment '${options.deploymentName}' failed (OperationStatus: ${recovery.operationStatus}): ${reason2}`, `${inspectHint(pipelineDeploymentId, feedScope)} Fix the underlying issue and retry: uip solution deploy run.`, { pipelineDeploymentId });
     }
     const { reason, message, exitCode, errorCode, retry } = mapPollFailure(pollResult, "Deployment");
-    return fail3(reason, message, `Deployment may still be in progress. ${followHint(pipelineDeploymentId, feedScope)}`, { exitCode, pipelineDeploymentId, errorCode, retry });
+    return fail(reason, message, `Deployment may still be in progress. ${followHint(pipelineDeploymentId, feedScope)}`, { exitCode, pipelineDeploymentId, errorCode, retry });
   }
   const finalStatus = pollResult.data;
   if (!finalStatus) {
-    return fail3("no_final_status", "Deployment did not return a final status.", followHint(pipelineDeploymentId, feedScope), { pipelineDeploymentId });
+    return fail("no_final_status", "Deployment did not return a final status.", followHint(pipelineDeploymentId, feedScope), { pipelineDeploymentId });
   }
   const landedDespiteStatus = installLandedDespiteStatus(finalStatus);
   if (finalStatus.status !== "DeploymentSucceeded" && !landedDespiteStatus) {
@@ -7962,11 +7367,9 @@ async function deployRunAsync(options) {
     const details = finalStatus.synthesizedOperation !== undefined && finalStatus.deploymentKey ? await describeSynthesizedFailureAsync(auth, finalStatus.deploymentKey, scope, options.signal, fromPipeline) : fromPipeline;
     const draftNote = leavesPendingDraft(finalStatus.status) ? `
 Nothing was installed. The rejected attempt is kept as a pending draft${finalStatus.deploymentKey ? ` (${finalStatus.deploymentKey})` : ""}: fix the configuration and re-run this command, and the server re-validates that draft with the new file (settings and resource links the file does not name keep the values the draft was rejected with).${finalStatus.deploymentKey ? ` When this was an update of an existing deployment, you can discard the draft and upgrade the live version instead: uip solution deploy upgrade ${finalStatus.deploymentKey} --discard-draft --version ${options.packageVersion}` : ""}` : "";
-    return fail3("deploy_failed", `Deployment failed with status: ${finalStatus.status}`, `${buildDeploymentFailureInstructions(details, pipelineDeploymentId)}${draftNote}`, { pipelineDeploymentId, ...classification });
+    return fail("deploy_failed", `Deployment failed with status: ${finalStatus.status}`, `${buildDeploymentFailureInstructions(details, pipelineDeploymentId)}${draftNote}`, { pipelineDeploymentId, ...classification });
   }
-  const resolvedFolder = await resolveInstalledFolder(await findDeploymentBestEffort(auth, options.deploymentName, scope, {
-    deploymentKey: finalStatus.deploymentKey || undefined
-  }), {
+  const resolvedFolder = await resolveInstalledFolder(await readInstalledFolderAsync(auth, options.deploymentName, finalStatus.deploymentKey || undefined, scope), {
     folderName: options.folderName,
     folderPath,
     parentFolderPath
@@ -7974,6 +7377,7 @@ Nothing was installed. The rejected attempt is kept as a pending draft${finalSta
   const baseSuccess = {
     ok: true,
     ...feedFields,
+    ...permanentlyDeletedResources && { permanentlyDeletedResources },
     status: finalStatus.status,
     deploymentKey: finalStatus.deploymentKey,
     pipelineDeploymentId,
@@ -7996,6 +7400,12 @@ Nothing was installed. The rejected attempt is kept as a pending draft${finalSta
   if (options.skipActivate) {
     return { ...baseSuccess, activationStatus: "Skipped" };
   }
+  if (reportedActivationStatus(finalStatus.deploymentResult) === "NeedsSetupToActivate") {
+    return {
+      ...baseSuccess,
+      ...await describeInstalledRunAsync(auth, options.deploymentName, finalStatus, scope, feedScope)
+    };
+  }
   const activationResult = await activateDeployment(auth, options.deploymentName, {
     timeoutSeconds: options.timeout ?? 360,
     pollIntervalMs: options.pollInterval ?? 5000,
@@ -8010,19 +7420,22 @@ Nothing was installed. The rejected attempt is kept as a pending draft${finalSta
         ...await describeInstalledNotLiveAsync(auth, refused, scope, feedScope)
       };
     }
-    const fallback = activationResult.phase === "preActivateSteps" ? `Deployment '${options.deploymentName}' was deployed successfully but pre-activate steps lookup failed. Retry activation with: uip solution deploy activate ${options.deploymentName}. Details: ${activationResult.details}` : `Deployment '${options.deploymentName}' was deployed successfully but activation failed. Retry activation with: uip solution deploy activate ${options.deploymentName}. Details: ${activationResult.details}`;
-    const pendingResources = refused && needsPendingResources(refused) ? await readPendingResourcesAsync(new DeploymentsApi(new Configuration({
-      basePath: auth.basePath,
-      accessToken: auth.accessToken
-    })), refused.key, scope) : undefined;
-    return fail3("activation_request_failed", activationResult.message, appendDeploymentStateInstructions(fallback, refused, pendingResources, feedSelectorFlag(feedScope)), { pipelineDeploymentId });
+    const fallback = activationResult.phase === "preActivateSteps" ? `Deployment '${options.deploymentName}' was deployed successfully but pre-activate steps lookup failed. Retry activation with: uip solution deploy activate ${options.deploymentName}${feedSelectorFlag(feedScope)}. Details: ${activationResult.details}` : `Deployment '${options.deploymentName}' was deployed successfully but activation failed. Retry activation with: uip solution deploy activate ${options.deploymentName}${feedSelectorFlag(feedScope)}. Details: ${activationResult.details}`;
+    const pendingResources = refused && needsPendingResources(refused) ? await readPendingResourcesAsync(pendingResourceApis(auth), refused, scope) : undefined;
+    return fail("activation_request_failed", activationResult.message, appendDeploymentStateInstructions(fallback, refused, pendingResources, feedSelectorFlag(feedScope)), { pipelineDeploymentId, permanentlyDeletedResources });
   }
   if (activationResult.kind === "PollFailed") {
     const { message, exitCode, errorCode, retry } = mapPollFailure(activationResult.poll, "Activation");
-    return fail3("activation_poll_failed", message, `Deployment '${options.deploymentName}' was deployed successfully but activation polling did not complete. Activation may still be in progress; check with: ${listCommand(feedScope)}.`, { exitCode, pipelineDeploymentId, errorCode, retry });
+    return fail("activation_poll_failed", message, `Deployment '${options.deploymentName}' was deployed successfully but activation polling did not complete. Activation may still be in progress; check with: ${listCommand(feedScope)}.`, {
+      exitCode,
+      pipelineDeploymentId,
+      errorCode,
+      retry,
+      permanentlyDeletedResources
+    });
   }
   if (activationResult.kind === "ActivationFailed") {
-    return fail3("activation_failed", `Activation failed with status: ${activationResult.status}`, activationResult.errorMessage, { pipelineDeploymentId });
+    return fail("activation_failed", `Activation failed with status: ${activationResult.status}`, activationResult.errorMessage, { pipelineDeploymentId, permanentlyDeletedResources });
   }
   const activationStatus = activationResult.kind === "Success" ? activationResult.status : "NoInstance";
   const activationInstanceId = activationResult.kind === "Success" ? activationResult.instanceId : undefined;
@@ -8031,33 +7444,31 @@ Nothing was installed. The rejected attempt is kept as a pending draft${finalSta
 }
 async function describeInstalledRunAsync(auth, deploymentName, finalStatus, scope, feedScope) {
   const key = finalStatus.deploymentKey || undefined;
-  const row = key ? await findDeploymentBestEffort(auth, deploymentName, scope, {
+  const record = finalStatus.deploymentResult;
+  const reported = reportedActivationStatus(record);
+  const row = key && !reported ? await findDeploymentBestEffort(auth, deploymentName, scope, {
     deploymentKey: key
   }) : undefined;
   if (row) {
     return describeInstalledNotLiveAsync(auth, row, scope, feedScope);
   }
-  const record = finalStatus.deploymentResult;
   if (record?.status === "SuccessfulActivate") {
     return { activationStatus: "SuccessfulActivate" };
   }
   const actions = record?.actions ?? [];
-  const activationStatus = actions.includes("SetupActivation") ? "NeedsSetupToActivate" : actions.includes("Activate") ? "ReadyToActivate" : "Inactive";
+  const activationStatus = reported ?? (actions.includes("SetupActivation") ? "NeedsSetupToActivate" : actions.includes("Activate") ? "ReadyToActivate" : "Inactive");
   return describeInstalledNotLiveAsync(auth, {
     name: deploymentName,
     key,
     operation: record?.operation ?? finalStatus.synthesizedOperation,
-    operationStatus: "Successful",
+    operationStatus: record?.operationStatus ?? "Successful",
     activationStatus,
     packageVersion: record?.packageVersion,
     currentPackageVersion: record?.packageVersion
   }, scope, feedScope);
 }
 async function describeInstalledNotLiveAsync(auth, deployment, scope, feedScope) {
-  const pendingResources = needsPendingResources(deployment) && deployment.key ? await readPendingResourcesAsync(new DeploymentsApi(new Configuration({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  })), deployment.key, scope) : undefined;
+  const pendingResources = needsPendingResources(deployment) && deployment.key ? await readPendingResourcesAsync(pendingResourceApis(auth), { name: deployment.name, key: deployment.key }, scope) : undefined;
   const nextSteps = deploymentNextSteps(deployment, pendingResources, feedSelectorFlag(feedScope));
   return {
     activationStatus: deployment.activationStatus ?? "Inactive",
@@ -8099,13 +7510,13 @@ function refuseFeedForSession(session, action) {
     return;
   }
   const { message, instructions } = feedSessionRefusal(verdict, action, "deploy the package to the tenant feed");
-  return fail3("feed_requires_user_session", message, instructions, {
+  return fail("feed_requires_user_session", message, instructions, {
     errorCode: "permission_denied",
     retry: "RetryWillNotFix"
   });
 }
 async function describeSynthesizedFailureAsync(auth, deploymentKey, scope, signal, fromPipeline) {
-  const deploymentsApi = new DeploymentsApi(new Configuration({
+  const deploymentsApi = new DeploymentsApi(new Configuration2({
     basePath: auth.basePath,
     accessToken: auth.accessToken
   }));
@@ -8163,10 +7574,10 @@ function buildDeploymentExistsInstructions(options) {
   } else {
     parts.push(first?.key ? `To update the existing deployment instead, upgrade it in place — running deploy again does not upgrade it: uip solution deploy upgrade ${first.key}.` : "To update the existing deployment instead, upgrade it in place with 'uip solution deploy upgrade <deployment-key>' — running deploy again does not upgrade it.");
     if (first?.name) {
-      parts.push(`To remove it first, run: uip solution deploy uninstall '${first.name}' --yes.`);
+      parts.push(`To remove it first, run: uip solution deploy uninstall '${first.name}'${feedSelectorFlag(scope)} --yes.`);
     }
   }
-  parts.push("To see every deployment and its state, run: uip solution deploy list.");
+  parts.push(`To see every deployment and its state, run: uip solution deploy list${feedSelectorFlag(scope)}.`);
   parts.push(scope.kind === "tenant" ? "To create a second, separate deployment anyway, re-run this command with --yes and a different --name: re-using an existing deployment's name updates that deployment in place instead." : "To create a second, separate deployment anyway, re-run with --yes and a different --name (re-using an existing deployment's name updates that deployment in place) — Orchestrator may still refuse it while the existing deployment is running or in a failed state.");
   if (existing.length === 0) {
     parts.unshift(`A deployment of '${packageName}' already exists in ${scopeLabel(scope)}.`);
@@ -8205,14 +7616,14 @@ async function guardPendingDraft(auth, options, scope) {
   }
   const draftVersion = draft.targetPackageVersion ?? draft.packageVersion;
   if (draft.operation === "ActivationSetup") {
-    return fail3("pending_draft", `Deployment '${options.deploymentName}' has an unfinished Setup activation (${draft.key}): the Orchestrator "Setup activation" wizard was started on version ${draftVersion ?? "<version>"} and not completed.`, `While that draft exists the server would run it in place of this deploy, or refuse a different version. Finish the setup in Orchestrator (Solutions, the deployment, Setup activation); or discard it — in Orchestrator (Delete draft), or with uip solution deploy upgrade ${draft.key} --discard-draft${draft.currentPackageVersion ? ` --version ${draft.currentPackageVersion}` : ""} — then re-run this command.`, { errorCode: "invalid_argument", retry: "RetryWillNotFix" });
+    return fail("pending_draft", `Deployment '${options.deploymentName}' has an unfinished Setup activation (${draft.key}): the Orchestrator "Setup activation" wizard was started on version ${draftVersion ?? "<version>"} and not completed.`, `While that draft exists the server would run it in place of this deploy, or refuse a different version. Finish the setup in Orchestrator (Solutions, the deployment, Setup activation); or discard it — in Orchestrator (Delete draft), or with uip solution deploy upgrade ${draft.key} --discard-draft${draft.currentPackageVersion ? ` --version ${draft.currentPackageVersion}` : ""} — then re-run this command.`, { errorCode: "invalid_argument", retry: "RetryWillNotFix" });
   }
   if (!draftVersion || draftVersion.toLowerCase() === options.packageVersion.toLowerCase()) {
     return;
   }
   const liveVersion = draft.currentPackageVersion;
   const discard = draft.operation === "Install" || !liveVersion ? "delete it in Orchestrator (Delete draft)" : `discard it — in Orchestrator (Delete draft), or with uip solution deploy upgrade ${draft.key} --discard-draft --version ${liveVersion}, which also re-applies the live version unchanged —`;
-  return fail3("pending_draft", `Deployment '${options.deploymentName}' has a pending draft (${draft.key}) for version ${draftVersion}: an earlier attempt that never completed, usually one rejected by validation, or one still running.`, `The server reuses that draft for the name, so this request would not deploy ${options.packageVersion}: asking for the live version installs the draft's ${draftVersion} instead, and any other version is refused. To retry the draft with a corrected configuration, re-run with --package-version ${draftVersion}.
+  return fail("pending_draft", `Deployment '${options.deploymentName}' has a pending draft (${draft.key}) for version ${draftVersion}: an earlier attempt that never completed, usually one rejected by validation, or one still running.`, `The server reuses that draft for the name, so this request would not deploy ${options.packageVersion}: asking for the live version installs the draft's ${draftVersion} instead, and any other version is refused. To retry the draft with a corrected configuration, re-run with --package-version ${draftVersion}.
 To deploy ${options.packageVersion} instead, ${discard} then re-run this command.`, { errorCode: "invalid_argument", retry: "RetryWillNotFix" });
 }
 async function guardExistingDeployment(auth, options, scope) {
@@ -8234,7 +7645,7 @@ async function guardExistingDeployment(auth, options, scope) {
   if (existing.length === 0) {
     return;
   }
-  return fail3("deployment_exists", buildDeploymentExistsMessage(options.packageName, scope, existing, await resolveDeploymentFolders(existing, options)), buildDeploymentExistsInstructions({
+  return fail("deployment_exists", buildDeploymentExistsMessage(options.packageName, scope, existing, await resolveDeploymentFolders(existing, options)), buildDeploymentExistsInstructions({
     packageName: options.packageName,
     scope,
     existing,
@@ -8266,740 +7677,6 @@ async function resolveFeedDeployLocation(scope, options) {
   return { folderKey: resolved.key, folderFQN: resolved.path };
 }
 
-// src/services/deploy-uninstall-service.ts
-var TERMINAL_STATUSES2 = new Set([
-  "SuccessfulUninstall",
-  "FailedUninstall"
-]);
-var fail4 = (reason, message, instructions, extras = {}) => ({
-  ok: false,
-  reason,
-  message,
-  instructions,
-  exitCode: extras.exitCode ?? 1,
-  errorCode: extras.errorCode,
-  retry: extras.retry
-});
-function requestErrorInstructions(deploymentName, errorCode, details) {
-  switch (errorCode) {
-    case "authentication_required":
-      return `Your session may have expired. Run 'uip login' and retry. Details: ${details}`;
-    case "permission_denied":
-      return `Your account lacks permission to uninstall this deployment. Check your Orchestrator roles, then retry. Details: ${details}`;
-    case "rate_limited":
-      return `Too many requests. Wait a moment and retry. Details: ${details}`;
-    case "network_error":
-      return `Could not reach Orchestrator. Check your connection and retry. Details: ${details}`;
-    case "server_error":
-      return `Orchestrator returned a server error. Wait and retry; if it persists, check Orchestrator status. Details: ${details}`;
-    case "not_found":
-      return `No deployment named '${deploymentName}' was found. Run 'uip solution deploy list' to see valid deployment names. Details: ${details}`;
-    default:
-      return `Uninstall request failed. Run 'uip solution deploy list' to check the deployment's state, then retry. Details: ${details}`;
-  }
-}
-function buildDeploymentStateInstructions(deployment, details) {
-  const availableActions = deployment.actions?.length ? deployment.actions.join(", ") : "none";
-  const status = `(ActivationStatus: ${deployment.activationStatus}, OperationStatus: ${deployment.operationStatus})`;
-  if (deployment.operationStatus === "InProgress") {
-    return `Deployment '${deployment.name}' has an operation in progress ${status}, so it can't be uninstalled yet. Wait for it to finish — run 'uip solution deploy list' to recheck — then retry. Available actions: ${availableActions}. Details: ${details}`;
-  }
-  if (deployment.actions?.includes("Uninstall")) {
-    return `Deployment '${deployment.name}' lists uninstall as available but Orchestrator rejected the request ${status}. Run 'uip solution deploy list' to recheck its state, then retry. If it stays stuck, uninstall it from the Orchestrator Solutions UI. Details: ${details}`;
-  }
-  const removalAdvice = deployment.actions?.includes(WorkflowAction.Delete) ? `Delete it with: uip solution deploy delete '${deployment.name}' --yes.` : "Remove it from the Orchestrator Solutions UI.";
-  if (deployment.activationStatus === "Inactive") {
-    return `Deployment '${deployment.name}' cannot be uninstalled in its current state ${status}. Available actions: ${availableActions}. Superseded or inactive deployments are never uninstallable. ${removalAdvice} Details: ${details}`;
-  }
-  return `Deployment '${deployment.name}' cannot be uninstalled in its current state ${status}. Available actions: ${availableActions}. Run 'uip solution deploy list' to recheck its state. ${removalAdvice} Details: ${details}`;
-}
-async function waitForOperationToFinishAsync(auth, deploymentName, opts) {
-  let last;
-  const poll = await pollUntil({
-    fn: async () => {
-      last = await findDeploymentByName(auth, deploymentName, opts.scope);
-      return last;
-    },
-    until: (deployment) => deployment !== undefined && deployment.operationStatus !== "InProgress",
-    getStatus: (deployment) => deployment?.operationStatus ?? "Unknown",
-    label: `deployment '${deploymentName}' to finish its current operation`,
-    logPrefix: "uninstall",
-    timeoutMs: opts.remainingMs(),
-    intervalMs: opts.intervalMs,
-    signal: opts.signal
-  });
-  return { outcome: poll.outcome, state: last, error: poll.error };
-}
-async function requestUninstallAsync(api, auth, deploymentName, ctx) {
-  const { options, sweep, intervalMs, remainingMs } = ctx;
-  const { location } = sweep;
-  const sweepIncomplete = !location && !sweep.complete;
-  let state = location?.deployment;
-  let waited = false;
-  let rechecked = false;
-  for (;; ) {
-    const [uninstallError, result] = await catchError(api.pipelinesUninstall({ deploymentName }, location?.scope));
-    if (!uninstallError) {
-      return { ok: true, result };
-    }
-    const { message, details, errorCode, retry, context } = await extractErrorDetails(uninstallError);
-    if (errorCode !== "invalid_argument") {
-      if (errorCode === "not_found" && sweepIncomplete) {
-        return incompleteSweepFailureAsync(deploymentName, sweep, details);
-      }
-      return fail4("uninstall_request_failed", message, requestErrorInstructions(deploymentName, errorCode, details), { errorCode, retry });
-    }
-    if (!rechecked && !waited && state?.operationStatus !== "InProgress") {
-      rechecked = true;
-      const [readError, fresh] = await catchError(findDeploymentByName(auth, deploymentName, location?.scope));
-      if (!readError) {
-        state = fresh;
-      }
-    }
-    if (!waited && state?.operationStatus === "InProgress") {
-      waited = true;
-      const wait = await waitForOperationToFinishAsync(auth, deploymentName, {
-        scope: location?.scope,
-        intervalMs,
-        remainingMs,
-        signal: options.signal
-      });
-      if (wait.outcome === PollOutcome.Timeout) {
-        return fail4("uninstall_blocked", `Deployment '${deploymentName}' still had an operation running after ${options.timeout ?? 360}s, so it could not be uninstalled.`, buildDeploymentStateInstructions(wait.state ?? state, details), { exitCode: 2, errorCode: "timeout", retry: "RetryLater" });
-      }
-      if (wait.outcome !== PollOutcome.Completed) {
-        const {
-          reason,
-          message: pollMessage,
-          exitCode,
-          errorCode: pollErrorCode,
-          retry: pollRetry
-        } = mapPollFailure(wait, "Deployment");
-        return fail4(reason, pollMessage, `The deployment may still be installing. Check it with: uip solution deploy list, then retry the uninstall.`, { exitCode, errorCode: pollErrorCode, retry: pollRetry });
-      }
-      state = wait.state;
-      continue;
-    }
-    if (sweepIncomplete && (!state || isCompletedUninstall(state))) {
-      if (isNameOrFeedRefusal(errorCode, context?.httpStatus)) {
-        return incompleteSweepFailureAsync(deploymentName, sweep, details);
-      }
-      return fail4("uninstall_request_failed", message, requestErrorInstructions(deploymentName, errorCode, details), { errorCode, retry });
-    }
-    const instructions = state ? buildDeploymentStateInstructions(state, details) : `No deployment named '${deploymentName}' was found in any feed you can reach (tenant, Personal Workspace, or a folder feed). Check the name with 'uip solution deploy list'. Details: ${details}`;
-    return fail4("uninstall_request_failed", message, instructions, {
-      errorCode,
-      retry
-    });
-  }
-}
-async function incompleteSweepFailureAsync(deploymentName, sweep, refusalDetails) {
-  const report = await reportIncompleteSweepAsync(deploymentName, sweep.skipped);
-  return fail4("uninstall_request_failed", report.message, `${INCOMPLETE_SWEEP_ADVICE} Without its feed the uninstall request went to the tenant feed, which refused it. ${report.nextStep} Details: ${refusalDetails} (feed search: ${report.details})`, { errorCode: report.errorCode, retry: report.retry });
-}
-async function uninstallDeploymentAsync(deploymentName, options = {}) {
-  const [authError, auth] = await catchError(getSolutionAuthContext({
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (authError) {
-    return fail4("auth_failed", authError.message, authError.message);
-  }
-  const api = new PipelinesApi(new Configuration2({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  }));
-  const deadline = Date.now() + (options.timeout ?? 360) * 1000;
-  const intervalMs = options.pollInterval ?? 5000;
-  const remainingMs = () => Math.max(deadline - Date.now(), 1);
-  const sweep = await findDeploymentAcrossFeeds(auth, deploymentName, options);
-  const location = sweep.location;
-  const [requestError, requested] = await catchError(requestUninstallAsync(api, auth, deploymentName, {
-    options,
-    sweep,
-    intervalMs,
-    remainingMs
-  }));
-  if (requestError) {
-    throw requestError;
-  }
-  if (!requested.ok) {
-    return requested;
-  }
-  const uninstallResult = requested.result;
-  if (uninstallResult.complete) {
-    return {
-      ok: true,
-      status: "Uninstall completed immediately",
-      deploymentName
-    };
-  }
-  const instanceId = uninstallResult.instanceId;
-  if (!instanceId) {
-    return {
-      ok: true,
-      status: "Uninstall scheduled",
-      deploymentName,
-      scheduled: uninstallResult.scheduled
-    };
-  }
-  const pollResult = await pollUntil({
-    fn: () => api.pipelinesGetDeploymentInstanceStatus({ instanceId }, location?.scope),
-    until: (result) => TERMINAL_STATUSES2.has(result.status),
-    getStatus: (result) => result.status,
-    label: `uninstall ${deploymentName}`,
-    logPrefix: "uninstall",
-    timeoutMs: remainingMs(),
-    intervalMs,
-    signal: options.signal
-  });
-  if (pollResult.outcome !== PollOutcome.Completed || !pollResult.data) {
-    const { reason, message, exitCode, errorCode, retry } = mapPollFailure(pollResult, "Uninstall");
-    return fail4(reason, message, "Uninstall may still be in progress.", {
-      exitCode,
-      errorCode,
-      retry
-    });
-  }
-  const finalStatus = pollResult.data;
-  if (finalStatus.status !== "SuccessfulUninstall") {
-    const errors2 = coerceWorkflowErrorMessages(finalStatus.errorMessage).map((e) => e.errorMessage).join(", ");
-    return fail4("uninstall_failed", `Uninstall failed with status: ${finalStatus.status}`, errors2 || `Orchestrator ended the uninstall in a FailedUninstall state without an error detail. Run 'uip solution deploy list' to recheck the deployment's state and retry. If it stays in a failed state and that listing shows Delete among its actions, remove the record with: uip solution deploy delete '${deploymentName}' --yes. Remove it from the Orchestrator Solutions UI when it does not.`);
-  }
-  return {
-    ok: true,
-    status: finalStatus.status,
-    deploymentName,
-    instanceId
-  };
-}
-
-// src/services/deploy-upgrade-service.ts
-var fail5 = (reason, message, instructions, extras = {}) => ({
-  ok: false,
-  reason,
-  message,
-  instructions,
-  exitCode: extras.exitCode ?? 1,
-  errorCode: extras.errorCode,
-  retry: extras.retry
-});
-var DEFAULT_TIMEOUT_SECONDS = 300;
-var DEFAULT_POLL_INTERVAL_MS = 5000;
-var AUTH_INSTRUCTIONS2 = "Run 'uip login' to refresh credentials, then retry. If the deployment is in a different tenant, switch with 'uip login tenant set <tenant>'.";
-var PACKAGE_INSTRUCTIONS = "Confirm the version is published to the tenant (or Personal Workspace) feed: uip solution packages list.";
-var TARGET_INSTRUCTIONS = "Address the deployment either by key — uip solution deploy upgrade <deployment-key> — or by name with its package: uip solution deploy upgrade --name <deployment-name> --package-name <package>. 'uip solution deploy list' reports all three.";
-var DEPLOYMENT_NOT_FOUND_INSTRUCTIONS = "Check the key with 'uip solution deploy list'. A server without the Pipelines deployment lookup answers 404 to every key for an external app; on one of those, address the deployment with --name and --package-name instead.";
-var LOOKUP_FAILED_INSTRUCTIONS = "The deployment lookup failed before any upgrade was requested. Retry, or address the deployment with --name and --package-name.";
-var INVALID_TARGET = {
-  errorCode: "invalid_argument",
-  retry: "RetryWillNotFix"
-};
-var GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var UPGRADE_REFUSED_INSTRUCTIONS = "The server refused to start the upgrade. The deployment name may not exist, or may belong to a different package — check both with 'uip solution deploy list'. Another operation may still be running on it (wait, then retry), or it may be in a state the platform does not offer upgrades for.";
-async function upgradeDeploymentAsync(first, second) {
-  const options = typeof first === "string" ? { ...second, deploymentKey: first } : first;
-  const targetError = validateTarget(options);
-  if (targetError) {
-    return targetError;
-  }
-  const [authError, auth] = await catchError(getSolutionAuthContext({
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (authError) {
-    return fail5("auth_failed", authError.message, AUTH_INSTRUCTIONS2);
-  }
-  const pipelinesApi = new PipelinesApi(new Configuration2({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  }));
-  const target = options.deploymentKey ? await resolveTargetByKeyAsync(pipelinesApi, auth, options, options.deploymentKey) : await resolveTargetByNameAsync(pipelinesApi, auth, options);
-  if (!target.ok) {
-    return target;
-  }
-  const { deploymentName, packageName, scope } = target;
-  let targetVersion = options.version;
-  if (targetVersion === undefined) {
-    const [versionError, latest] = await catchError(pipelinesApi.pipelinesGetPackageVersion({ packageName, packageVersion: null }, scope));
-    if (versionError || !latest) {
-      const detail = versionError && await extractErrorDetails(versionError);
-      if (!detail || detail.context?.httpStatus === 404) {
-        return fail5("package_not_found", detail?.details ? `Package '${packageName}' was not found in the feed: ${detail.details}` : `Package '${packageName}' was not found in the feed.`, PACKAGE_INSTRUCTIONS, { errorCode: "not_found", retry: "RetryWillNotFix" });
-      }
-      return fail5("lookup_failed", detail.details ? `${detail.message}: ${detail.details}` : detail.message, `The version lookup for '${packageName}' failed before any upgrade was requested. Retry, or pass --version explicitly to skip the lookup.`, { errorCode: detail.errorCode, retry: detail.retry });
-    }
-    targetVersion = latest.packageVersion;
-  }
-  const [installError, installResult] = await catchError(pipelinesApi.pipelinesInstall({
-    deploymentName,
-    packageName,
-    packageVersion: targetVersion,
-    solutionRootFolderName: deploymentName
-  }, scope));
-  if (installError || !installResult?.pipelineDeploymentId) {
-    let message = "The upgrade request returned no pipeline deployment.";
-    let classification = {};
-    let instructions = UPGRADE_REFUSED_INSTRUCTIONS;
-    if (installError) {
-      const detail = await extractErrorDetails(installError);
-      message = detail.details ? `${detail.message}: ${detail.details}` : detail.message;
-      classification = {
-        errorCode: detail.errorCode,
-        retry: detail.retry
-      };
-      if (detail.context?.httpStatus === 404) {
-        instructions = `The server knows no such version of '${packageName}' in this feed. ${PACKAGE_INSTRUCTIONS} 'uip solution deploy list' shows the deployment's package and current version.`;
-      }
-      if (hasServerErrorCode(detail.details, DRAFT_VERSION_MISMATCH_CODE)) {
-        return fail5("pending_draft", message, `'${deploymentName}' has a pending draft for another version: an earlier attempt that never completed, usually one rejected by validation, and the server will not upgrade past it. Discard it and upgrade the live version: ${discardRetryCommand(options, target)}${options.deploymentKey ? "" : `
-Under an external app the name form cannot find the draft; pass the deployment's key instead (InstallDeploymentKey from the original deploy, or Key from 'uip solution deploy list').`}`, INVALID_TARGET);
-      }
-    }
-    return fail5("request_failed", message, instructions, classification);
-  }
-  const pipelineDeploymentId = installResult.pipelineDeploymentId;
-  const base = {
-    deploymentName,
-    toVersion: targetVersion,
-    pipelineDeploymentId,
-    ...target.fromVersion !== undefined && {
-      fromVersion: target.fromVersion
-    },
-    ...target.installDeploymentKey !== undefined && {
-      installDeploymentKey: target.installDeploymentKey
-    },
-    ...target.discardedDraftKey !== undefined && {
-      discardedDraftKey: target.discardedDraftKey
-    }
-  };
-  if (options.noWait) {
-    return { ok: true, ...base, status: "Accepted" };
-  }
-  const timeoutSeconds = Number.isFinite(options.timeout) ? options.timeout : DEFAULT_TIMEOUT_SECONDS;
-  const poll = await pollPipelineDeploymentAsync(pipelinesApi, auth, {
-    pipelineDeploymentId,
-    deploymentName,
-    scope,
-    timeoutMs: timeoutSeconds * 1000,
-    intervalMs: Number.isFinite(options.pollInterval) ? options.pollInterval : DEFAULT_POLL_INTERVAL_MS,
-    signal: options.signal,
-    logPrefix: "deploy upgrade"
-  });
-  if (poll.outcome !== PollOutcome.Completed) {
-    const failure = mapPollFailure(poll, `Upgrade ${pipelineDeploymentId}`);
-    const isTimeout = poll.outcome === PollOutcome.Timeout;
-    const lastStatus = poll.data?.status ?? "unknown";
-    return fail5(isTimeout ? "install_timeout" : failure.reason, isTimeout ? `The upgrade of '${deploymentName}' to ${targetVersion} did not finish within ${timeoutSeconds}s (last status: ${lastStatus}).` : `${failure.message} while upgrading '${deploymentName}' to ${targetVersion} (last status: ${lastStatus}).`, isTimeout ? `It may still be running. ${trackingHint(pipelineDeploymentId, target.listFlag)} Or pass a longer --timeout.` : `The upgrade may still be running. ${trackingHint(pipelineDeploymentId, target.listFlag)}`, {
-      exitCode: failure.exitCode,
-      errorCode: failure.errorCode,
-      retry: failure.retry
-    });
-  }
-  const finalStatus = poll.data;
-  if (!finalStatus) {
-    return fail5("deploy_failed", `The upgrade of '${deploymentName}' returned no final status.`, trackingHint(pipelineDeploymentId, target.listFlag));
-  }
-  const landedDespiteStatus = installLandedDespiteStatus(finalStatus);
-  if (finalStatus.status !== "DeploymentSucceeded" && !landedDespiteStatus) {
-    return fail5("deploy_failed", `The upgrade of '${deploymentName}' to ${targetVersion} ended in ${finalStatus.status}.`, `${await describeUpgradeFailureAsync(auth.basePath, auth.accessToken, pipelineDeploymentId, finalStatus, scope, options.signal)}
-${leavesPendingDraft(finalStatus.status) ? `Nothing was installed; the deployment stays on the version it was already running. The rejected attempt is kept as a pending draft${finalStatus.deploymentKey ? ` (${finalStatus.deploymentKey})` : ""}, which a plain retry would run into, so once the cause is fixed discard it and retry: ${discardRetryCommand(options, target, finalStatus.deploymentKey || undefined)}` : "Fix the reported problem, then retry the upgrade. The deployment stays on the version it was already running."}`, classifyTerminalFailure(finalStatus.status));
-  }
-  const described = await describeUpgradedDeploymentAsync(auth, deploymentName, finalStatus, scope, target.listFlag);
-  return {
-    ok: true,
-    ...base,
-    deploymentKey: finalStatus.deploymentKey,
-    operation: finalStatus.deploymentResult?.operation ?? finalStatus.synthesizedOperation,
-    status: finalStatus.status,
-    ...finalStatus.deploymentResult?.status && {
-      deploymentStatus: finalStatus.deploymentResult.status,
-      actions: finalStatus.deploymentResult.actions ?? []
-    },
-    ...described,
-    ...landedDespiteStatus && {
-      nextSteps: [
-        explainPipelineStatusAfterInstall(finalStatus),
-        ...described.nextSteps ?? []
-      ]
-    }
-  };
-}
-async function describeUpgradedDeploymentAsync(auth, deploymentName, finalStatus, scope, listFlag) {
-  const record = finalStatus.deploymentResult;
-  const actions = record?.actions ?? [];
-  if (record?.status === "SuccessfulActivate") {
-    return { activationStatus: "Active" };
-  }
-  const [, rows] = await catchError(findDeploymentsByName(auth, deploymentName, scope));
-  const row = rows?.find((candidate) => candidate.key === finalStatus.deploymentKey);
-  const activationStatus = row?.activationStatus ?? (actions.includes("SetupActivation") ? "NeedsSetupToActivate" : actions.includes("Activate") ? "ReadyToActivate" : undefined);
-  if (!activationStatus) {
-    return {};
-  }
-  const state = {
-    name: deploymentName,
-    operation: row?.operation ?? record?.operation ?? finalStatus.synthesizedOperation,
-    operationStatus: row?.operationStatus ?? "Successful",
-    activationStatus,
-    packageVersion: row?.packageVersion ?? record?.packageVersion,
-    currentPackageVersion: row?.currentPackageVersion ?? record?.packageVersion
-  };
-  const pendingResources = needsPendingResources(state) && finalStatus.deploymentKey ? await readPendingResourcesAsync(new DeploymentsApi(new Configuration({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  })), finalStatus.deploymentKey, scope) : undefined;
-  const nextSteps = deploymentNextSteps(state, pendingResources, listFlag ? ` ${listFlag}` : "");
-  return {
-    activationStatus,
-    ...pendingResources ? { pendingResources } : {},
-    ...nextSteps && nextSteps.length > 0 ? { nextSteps } : {}
-  };
-}
-function trackingHint(pipelineDeploymentId, listFlag) {
-  return listFlag ? `Track it with: uip solution deploy list ${listFlag} (deploy status reads the tenant feed and cannot see this run).` : `Track it with: uip solution deploy status ${pipelineDeploymentId}, or uip solution deploy list.`;
-}
-function discardRetryCommand(options, target, draftKey) {
-  const version = options.version ? ` --version ${options.version}` : "";
-  const key = draftKey ?? options.deploymentKey;
-  if (key) {
-    return `uip solution deploy upgrade ${key} --discard-draft${version}`;
-  }
-  const workspace = options.personalWorkspace ? " --personal-workspace" : "";
-  return `uip solution deploy upgrade --name ${target.deploymentName} --package-name ${target.packageName}${workspace} --discard-draft${version}`;
-}
-function validateTarget(options) {
-  const byKey = options.deploymentKey !== undefined;
-  const byName = options.deploymentName !== undefined || options.packageName !== undefined;
-  if (options.version !== undefined && options.version.trim() === "") {
-    return fail5("invalid_target", "--version was given but is empty.", "Pass the version to upgrade to (uip solution packages list shows the published ones), or omit --version to upgrade to the newest.", INVALID_TARGET);
-  }
-  if (byKey && byName) {
-    return fail5("invalid_target", "Pass either a deployment key or --name with --package-name, not both.", TARGET_INSTRUCTIONS, INVALID_TARGET);
-  }
-  if (byKey) {
-    return GUID_PATTERN.test(options.deploymentKey) ? undefined : fail5("invalid_target", `'${options.deploymentKey}' is not a deployment key.`, `A deployment key is a GUID, reported as Key by 'uip solution deploy list'. To address the deployment by name instead: ${TARGET_INSTRUCTIONS}`, INVALID_TARGET);
-  }
-  if (!options.deploymentName || !options.packageName) {
-    return fail5("invalid_target", "--name and --package-name go together: the Pipelines install route needs both.", TARGET_INSTRUCTIONS, INVALID_TARGET);
-  }
-  return;
-}
-async function resolveTargetByNameAsync(pipelinesApi, auth, options) {
-  const deploymentName = options.deploymentName;
-  let scope;
-  if (options.personalWorkspace) {
-    const verdict = classifyFeedSession(auth);
-    if (verdict !== "user") {
-      const { message, instructions } = feedSessionRefusal(verdict, `Upgrading the Personal Workspace deployment '${deploymentName}'`, "address the deployment by key");
-      return fail5("feed_requires_user_session", message, instructions, {
-        errorCode: "permission_denied",
-        retry: "RetryWillNotFix"
-      });
-    }
-    const [pwError, pw] = await catchError(resolvePersonalWorkspace({
-      tenant: options.tenant,
-      loginValidity: options.loginValidity,
-      envFilePath: options.envFilePath
-    }));
-    if (pwError || !pw) {
-      return fail5("personal_workspace_failed", pwError?.message ?? "Personal Workspace could not be resolved.", "Ensure your user has a Personal Workspace, then retry.");
-    }
-    scope = folderKeyInitOverride(pw.key);
-  }
-  const [existsError] = await catchError(pipelinesApi.pipelinesGetPreActivateSteps({ deploymentName }, scope));
-  if (existsError) {
-    const detail = await extractErrorDetails(existsError);
-    const where = scope ? "your Personal Workspace feed" : `the tenant feed of '${auth.tenantName}'`;
-    if (isDeploymentNotFound(detail)) {
-      return fail5("deployment_not_found", `Deployment '${deploymentName}' was not found in ${where}. 'deploy upgrade' never creates a deployment.`, `Check the name with 'uip solution deploy list'${scope ? "" : " (add --personal-workspace for a Personal Workspace deployment)"}. For a first deployment use 'uip solution deploy run'.`, { errorCode: "not_found", retry: "RetryWillNotFix" });
-    }
-    return fail5("lookup_failed", detail.details ? `${detail.message}: ${detail.details}` : detail.message, `The existence check for '${deploymentName}' failed before any upgrade was requested. Retry, or address the deployment by key: uip solution deploy upgrade <deployment-key>.`, { errorCode: detail.errorCode, retry: detail.retry });
-  }
-  const [rowsError, rows] = await catchError(findDeploymentsByName(auth, deploymentName, scope));
-  if (rowsError) {
-    const unreadable = rowsError instanceof DeploymentSearchNeedsUserSessionError || classifyFeedSession(auth) === "application" && isAuthRefusal(rowsError);
-    if (!unreadable) {
-      const detail = await extractErrorDetails(rowsError);
-      return fail5("lookup_failed", `The status check for '${deploymentName}' failed: ${detail.message}`, "The deployment exists, but whether it is still installed could not be confirmed, and upgrading an uninstalled name would deploy the package afresh under it. Retry, or address the deployment by key: uip solution deploy upgrade <deployment-key>.", { errorCode: detail.errorCode, retry: detail.retry });
-    }
-  }
-  if (isCompletedUninstall(rows ? newestDeploymentRow(rows) : undefined)) {
-    return fail5("deployment_uninstalled", `Deployment '${deploymentName}' has been uninstalled, so there is nothing to upgrade.`, "The install route would create a new deployment under that name rather than upgrade this one. Deploy the package afresh with 'uip solution deploy run', or pick a live deployment from 'uip solution deploy list'.", INVALID_TARGET);
-  }
-  const resolved = {
-    deploymentName,
-    packageName: options.packageName,
-    listFlag: scope ? "--personal-workspace" : undefined
-  };
-  let discardedDraftKey;
-  const newest = rows ? newestDeploymentRow(rows) : undefined;
-  if (newest?.operationStatus === "Draft") {
-    const draft = {
-      key: newest.key,
-      firstInstall: newest.operation === "Install",
-      activationSetup: newest.operation === "ActivationSetup",
-      targetVersion: newest.targetPackageVersion ?? newest.packageVersion,
-      liveVersion: newest.currentPackageVersion
-    };
-    const refusal = refusePendingDraft(options, resolved, draft);
-    if (refusal) {
-      return refusal;
-    }
-    const discarded = await discardDraftAsync(pipelinesApi, deploymentName, draft.key, scope);
-    if (discarded) {
-      return discarded;
-    }
-    discardedDraftKey = draft.key;
-  }
-  return {
-    ok: true,
-    ...resolved,
-    scope,
-    discardedDraftKey
-  };
-}
-function isDeploymentNotFound(detail) {
-  const status = detail.context?.httpStatus;
-  if (status === 404) {
-    return true;
-  }
-  return status === 400 && (/"errorCode"\s*:\s*"4004"/.test(detail.details) || (detail.parsedErrors?.deploymentName ?? []).some((message) => /not found/i.test(message)));
-}
-async function resolveTargetByKeyAsync(pipelinesApi, auth, options, deploymentKey) {
-  const [lookupError, info] = await catchError(pipelinesApi.pipelinesGetDeploymentByKey({ key: deploymentKey }));
-  if (lookupError || !info) {
-    const detail = lookupError ? await extractErrorDetails(lookupError) : undefined;
-    if (detail?.context?.httpStatus === 404 && classifyFeedSession(auth) === "user") {
-      return resolveTargetByKeyViaSolutionsAsync(pipelinesApi, auth, options, deploymentKey);
-    }
-    if (!detail || detail.context?.httpStatus === 404) {
-      return fail5("deployment_not_found", `Deployment '${deploymentKey}' was not found in tenant '${auth.tenantName}'.`, DEPLOYMENT_NOT_FOUND_INSTRUCTIONS, { errorCode: "not_found", retry: "RetryWillNotFix" });
-    }
-    return fail5("lookup_failed", detail.details ? `${detail.message}: ${detail.details}` : detail.message, LOOKUP_FAILED_INSTRUCTIONS, { errorCode: detail.errorCode, retry: detail.retry });
-  }
-  if (info.status === DeploymentStatus.SuccessfulUninstall) {
-    return fail5("deployment_uninstalled", `Deployment '${info.deploymentName}' (${deploymentKey}) has been uninstalled, so there is nothing to upgrade.`, "The install route would create a new deployment under that name rather than upgrade this one. Deploy the package afresh with 'uip solution deploy run', or pick a live deployment from 'uip solution deploy list'.", INVALID_TARGET);
-  }
-  let scope;
-  if (info.locationKey) {
-    const verdict = classifyFeedSession(auth);
-    if (verdict !== "user") {
-      const { message, instructions } = feedSessionRefusal(verdict, `Upgrading deployment '${info.deploymentName}', which is in a Personal Workspace or folder feed (folder key ${info.locationKey}),`, "run the upgrade from the Orchestrator UI");
-      return fail5("feed_requires_user_session", message, instructions, {
-        errorCode: "permission_denied",
-        retry: "RetryWillNotFix"
-      });
-    }
-    scope = folderKeyInitOverride(info.locationKey);
-  } else if (options.personalWorkspace) {
-    return fail5("invalid_target", `Deployment '${info.deploymentName}' (${deploymentKey}) is on the tenant feed, not in a Personal Workspace.`, "Drop --personal-workspace: with a deployment key the feed is read from the deployment itself.", INVALID_TARGET);
-  }
-  const listFlag = info.locationKey ? `--feed ${info.locationKey}` : undefined;
-  let live = info;
-  let discardedDraftKey;
-  if (info.status === DeploymentStatus.Draft) {
-    const draft = {
-      key: info.deploymentKey,
-      firstInstall: info.operation === DeploymentOperation.Install,
-      activationSetup: info.operation === DeploymentOperation.ActivationSetup,
-      targetVersion: info.targetPackageVersion ?? info.packageVersion,
-      liveVersion: info.packageVersion
-    };
-    const refusal = refusePendingDraft(options, {
-      deploymentName: info.deploymentName,
-      packageName: info.packageName,
-      listFlag
-    }, draft);
-    if (refusal) {
-      return refusal;
-    }
-    const discarded = await discardDraftAsync(pipelinesApi, info.deploymentName, draft.key, scope);
-    if (discarded) {
-      return discarded;
-    }
-    const [relookupError, current] = await catchError(pipelinesApi.pipelinesGetDeploymentByKey({
-      key: info.installDeploymentKey
-    }));
-    if (relookupError || !current) {
-      const detail = relookupError ? await extractErrorDetails(relookupError) : undefined;
-      return fail5("lookup_failed", `The pending draft ${draft.key} of '${info.deploymentName}' was discarded, but the live deployment could not be looked up again${detail ? `: ${detail.message}` : "."}`, `Nothing was upgraded. Retry the upgrade: uip solution deploy upgrade ${info.installDeploymentKey}${options.version ? ` --version ${options.version}` : ""}`, detail ? { errorCode: detail.errorCode, retry: detail.retry } : {});
-    }
-    if (current.status === DeploymentStatus.Draft || current.status === DeploymentStatus.SuccessfulUninstall) {
-      return fail5("pending_draft", `The pending draft ${draft.key} of '${info.deploymentName}' was discarded, but the deployment's newest generation is now ${current.status === DeploymentStatus.Draft ? `another draft (${current.deploymentKey})` : "an uninstall"}.`, "Nothing was upgraded. Another operation on this deployment ran in between; check it with 'uip solution deploy list', then retry.", INVALID_TARGET);
-    }
-    live = current;
-    discardedDraftKey = draft.key;
-  }
-  return {
-    ok: true,
-    deploymentName: live.deploymentName,
-    packageName: live.packageName,
-    scope,
-    listFlag,
-    fromVersion: live.packageVersion ?? undefined,
-    installDeploymentKey: live.installDeploymentKey,
-    discardedDraftKey
-  };
-}
-async function resolveTargetByKeyViaSolutionsAsync(pipelinesApi, auth, options, deploymentKey) {
-  let scope;
-  if (options.personalWorkspace) {
-    const [pwError, pw] = await catchError(resolvePersonalWorkspace({
-      tenant: options.tenant,
-      loginValidity: options.loginValidity,
-      envFilePath: options.envFilePath
-    }));
-    if (pwError || !pw) {
-      return fail5("personal_workspace_failed", pwError?.message ?? "Personal Workspace could not be resolved.", "Ensure your user has a Personal Workspace, then retry.");
-    }
-    scope = folderKeyInitOverride(pw.key);
-  }
-  const deploymentsApi = new DeploymentsApi(new Configuration({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  }));
-  const [readError, row] = await catchError(deploymentsApi.deploymentsGetByKey({ deploymentKey }, scope));
-  if (readError || !row) {
-    const detail = readError ? await extractErrorDetails(readError) : undefined;
-    if (!detail || detail.context?.httpStatus === 404) {
-      return fail5("deployment_not_found", `Deployment '${deploymentKey}' was not found in ${scope ? "your Personal Workspace feed" : `the tenant feed of '${auth.tenantName}'`}.`, `Check the key with 'uip solution deploy list'. Neither the Pipelines deployment lookup nor the Solutions read found it; the latter reads a key on the tenant feed, or with --personal-workspace in your workspace, so address a folder-feed deployment with --name and --package-name instead.`, { errorCode: "not_found", retry: "RetryWillNotFix" });
-    }
-    return fail5("lookup_failed", detail.details ? `${detail.message}: ${detail.details}` : detail.message, LOOKUP_FAILED_INSTRUCTIONS, { errorCode: detail.errorCode, retry: detail.retry });
-  }
-  if (row.status === "SuccessfulUninstall") {
-    return fail5("deployment_uninstalled", `Deployment '${row.name}' (${deploymentKey}) has been uninstalled, so there is nothing to upgrade.`, "The install route would create a new deployment under that name rather than upgrade this one. Deploy the package afresh with 'uip solution deploy run', or pick a live deployment from 'uip solution deploy list'.", INVALID_TARGET);
-  }
-  const target = await resolveTargetByNameAsync(pipelinesApi, auth, {
-    ...options,
-    deploymentName: row.name,
-    packageName: row.packageName
-  });
-  if (!target.ok) {
-    return target;
-  }
-  return { ...target, installDeploymentKey: row.installDeploymentKey };
-}
-function refusePendingDraft(options, target, draft) {
-  const targetVersion = draft.targetVersion ?? "<version>";
-  const feed = target.listFlag ? ` ${target.listFlag}` : "";
-  const retryDraft = `uip solution deploy run --name ${target.deploymentName} --package-name ${target.packageName} --package-version ${targetVersion} --config-file <fixed-config>${feed} --yes`;
-  if (draft.firstInstall) {
-    return fail5("pending_draft", `Deployment '${target.deploymentName}' was never installed: its first install (${draft.key}) is still a pending draft, so there is nothing to upgrade.`, `The draft is an attempt that never completed, usually one rejected by validation, or one still running. To retry it with a corrected configuration: ${retryDraft} (the server re-validates the draft with the new file). To abandon it, delete it in Orchestrator.`, INVALID_TARGET);
-  }
-  if (options.discardDraft) {
-    return;
-  }
-  if (draft.activationSetup) {
-    return fail5("pending_draft", `Deployment '${target.deploymentName}' has an unfinished Setup activation (${draft.key}): the Orchestrator "Setup activation" wizard was started on version ${targetVersion} and not completed.`, `While that draft exists the server would run it in place of this upgrade, or refuse a different version. Finish the setup in Orchestrator (Solutions, the deployment, Setup activation), then retry; or discard it and upgrade the live version: ${discardRetryCommand(options, target, draft.key)}`, INVALID_TARGET);
-  }
-  const live = draft.liveVersion ? ` ${draft.liveVersion}` : "";
-  return fail5("pending_draft", `Deployment '${target.deploymentName}' has a pending draft (${draft.key}) for version ${targetVersion}: an earlier attempt that never completed, usually one rejected by validation, or one still running.`, `The server would run that draft, with the configuration it was built with, in place of this upgrade, or refuse a different version. To discard it and upgrade the live version${live}: ${discardRetryCommand(options, target, draft.key)}
-To retry the draft itself with a corrected configuration instead: ${retryDraft}`, INVALID_TARGET);
-}
-async function discardDraftAsync(pipelinesApi, deploymentName, draftKey, scope) {
-  const [error] = await catchError(pipelinesApi.pipelinesDeleteDeploymentByKey({ deploymentKey: draftKey }, scope));
-  if (!error) {
-    return;
-  }
-  const detail = await extractErrorDetails(error);
-  const status = detail.context?.httpStatus;
-  const hasBody = !isBareResponse(detail.details);
-  if (hasServerErrorCode(detail.details, "DeploymentNotFound") || status === 404 && hasBody) {
-    return;
-  }
-  const message = `The pending draft ${draftKey} of '${deploymentName}' could not be discarded: ${hasBody ? `${detail.message}: ${detail.details}` : detail.message}`;
-  if (status === 405 || status === 404 && !hasBody) {
-    return fail5("discard_draft_failed", message, "This server cannot discard drafts through the Pipelines API yet. Nothing was upgraded. Delete the draft in Orchestrator, then retry the upgrade.", {
-      errorCode: status === 405 ? "method_not_allowed" : "not_found",
-      retry: "RetryWillNotFix"
-    });
-  }
-  if (hasServerErrorCode(detail.details, "DeploymentAlreadyInProgress")) {
-    return fail5("discard_draft_failed", message, "The draft is still being validated. Nothing was upgraded. Wait for its run to finish (uip solution deploy list shows it), then retry.", { errorCode: "invalid_argument", retry: "RetryLater" });
-  }
-  if (hasServerErrorCode(detail.details, "DeploymentInvalidState")) {
-    return fail5("discard_draft_failed", message, "The draft is no longer one that can be discarded: it moved on (it was promoted, or it is a rollback). Nothing was upgraded. Check the deployment with 'uip solution deploy list', then retry.", INVALID_TARGET);
-  }
-  return fail5("discard_draft_failed", message, "Nothing was upgraded. Retry, or delete the draft in Orchestrator and then retry the upgrade.", { errorCode: detail.errorCode, retry: detail.retry });
-}
-function classifyTerminalFailure(status) {
-  return status === "ValidationFailed" || status === "ConflictFixingError" ? { errorCode: "invalid_argument", retry: "RetryWillNotFix" } : {};
-}
-async function describeUpgradeFailureAsync(basePath, accessToken, pipelineDeploymentId, finalStatus, scope, signal) {
-  const fromPipeline = formatDeploymentFailureDetails(pipelineDeploymentId, finalStatus);
-  const explained = finalStatus.validationResult?.validationErrors?.length || finalStatus.validationResult?.conflictErrors?.length || finalStatus.conflictFixingErrors?.length || finalStatus.deploymentScheduleErrors?.length || finalStatus.deploymentResult?.errorMessage;
-  if (explained || !finalStatus.deploymentKey) {
-    return fromPipeline;
-  }
-  const deploymentsApi = new DeploymentsApi(new Configuration({ basePath, accessToken }));
-  const reason = await describeValidationFailureAsync(deploymentsApi, finalStatus.deploymentKey, SolutionDeploymentAction.Upgrade, scope, signal);
-  return reason === NO_SERVER_REASON ? fromPipeline : `Validation: ${reason}
-${fromPipeline}`;
-}
-
-// src/services/packages-list-service.ts
-var fail6 = (reason, message, instructions, extras = {}) => ({
-  ok: false,
-  reason,
-  message,
-  instructions,
-  exitCode: 1,
-  ...extras
-});
-async function listPackagesAsync(options = {}) {
-  const limit = options.limit ?? DEFAULT_PAGE_SIZE;
-  const offset = options.offset ?? 0;
-  const [authError, auth] = await catchError(getSolutionAuthContext({
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (authError) {
-    return fail6("auth_failed", authError.message, authError.message);
-  }
-  const [scopeError, scope] = await catchError(resolveFeedScope({
-    personalWorkspace: options.personalWorkspace,
-    feed: options.feed,
-    tenant: options.tenant,
-    loginValidity: options.loginValidity,
-    envFilePath: options.envFilePath
-  }));
-  if (scopeError) {
-    const { message, instructions, ...extras } = await describeFeedResolutionFailureAsync(scopeError, options, auth);
-    return fail6("feed_resolution_failed", message, instructions, extras);
-  }
-  const searchApi = new SearchApi(new Configuration({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  }));
-  const [listError, result] = await catchError(searchApi.searchSearchPackages({
-    searchFilter: {
-      orderByColumn: options.sortBy ?? "publishDate",
-      orderByDirection: options.sortOrder ?? "Descending",
-      take: limit,
-      skip: offset,
-      searchTerm: options.name
-    }
-  }, feedScopeInitOverride(scope)));
-  if (listError) {
-    const { message, instructions, ...extras } = await describeSearchFailureAsync(listError, "packages", auth, {
-      userSessionsOnly: true
-    });
-    return fail6("list_request_failed", message, instructions, extras);
-  }
-  const packages = result.values ?? [];
-  return {
-    ok: true,
-    packages,
-    limit,
-    offset,
-    total: result.count
-  };
-}
-
-export { extractDeploymentErrors, formatDeploymentErrorsAsText, activateDeploymentAsync, listDeploymentsAsync, deployRunAsync, uninstallDeploymentAsync, upgradeDeploymentAsync, listPackagesAsync };
+export { deployRunAsync };
 
-//# debugId=3F2F38B7889B837064756E2164756E21
+//# debugId=01897782E2F73B9764756E2164756E21