@aifabrix/builder 2.55.0 → 2.56.0

package/lib/commands/upload.js

@@ -1,6 +1,5 @@
 const {
   formatSuccessLine,
-  formatWarningLine,
   sectionTitle,
   headerKeyValue,
   metadata
@@ -21,8 +20,6 @@ const SEP = chalk.gray('──────────────────
 const { resolveControllerUrl } = require('../utils/controller-url');
 const { getDeploymentAuth } = require('../utils/token-manager');
 const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
-const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
-const { runWithUploadPipelineSpinner } = require('../utils/upload-pipeline-ui');
 const {
   buildResolvedEnvMapForIntegration,
   resolveConfigurationValues
@@ -33,21 +30,16 @@ const { generateControllerManifest } = require('../generator/external-controller
 const {
   validatePipelineConfig
 } = require('../api/pipeline.api');
-const { uploadApplicationViaPipelineWithAuthRetry } = require('../utils/pipeline-upload-auth-retry');
 const { formatApiError } = require('../utils/api-error-handler');
-const { unwrapPublicationResult, unwrapApiData, isPublicationUnchanged } = require('../utils/external-system-readiness-core');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
 const {
   logServerValidationWarnings
 } = require('../utils/external-system-readiness-display');
-const { maybeRunUploadProbe } = require('./upload-probe');
-const { maybeSyncOpenApiFilesForMcp } = require('./repair-openapi-sync');
-const { exportProgrammaticOpenApiForRepair } = require('./repair-openapi-export');
 const { resolveUploadPublishContext } = require('./upload-publish-context');
+const { runQualificationUpload, resumeQualificationUpload } = require('./upload-qualification-client');
+const { completeQualifiedUpload } = require('./upload-qualification-followups');
 const { syncDeployJsonFromSources } = require('../external-system/sync-deploy-manifest');
 const { assertUploadPackageIdentity } = require('../external-system/upload-identity');
-const { handlePublicationAndFollowups } = require('./upload-sidecar-followups');
-const { finalizeUploadPublishResult, finishUnchangedUploadPublication } = require('./upload-data-sync-finalize');
-const { pushAndLogCredentialSecrets } = require('./upload-credential-push-log');
 const {
   SYSTEM_KIND_DIGITAL_WORKER,
   readRoleAssistantSettings,
@@ -129,39 +121,6 @@ async function resolveDataplaneAndAuth(systemKey, opts = {}) {
   return { dataplaneUrl, authConfig, environment };
 }
 
-/**
- * Runs single pipeline upload (upload → validate → publish) on the dataplane.
- * @param {string} dataplaneUrl - Dataplane base URL
- * @param {Object} authConfig - Auth config
- * @param {Object} payload - { version, application, dataSources, status: "draft" }
- * @param {string} systemKey
- * @param {Object} [options]
- * @param {number|string} [options.timeoutMs]
- * @returns {Promise<Object>} Raw API response envelope
- */
-async function runUploadValidatePublish(
-  dataplaneUrl,
-  authConfig,
-  payload,
-  systemKey,
-  options = {}
-) {
-  const res = await uploadApplicationViaPipelineWithAuthRetry(
-    dataplaneUrl,
-    authConfig,
-    payload,
-    systemKey,
-    { timeoutMs: options.timeoutMs }
-  );
-  if (res?.success === false) {
-    const err = new Error(formatApiError(res, dataplaneUrl));
-    const status = Number(res.status || res.statusCode);
-    err.statusCode = status >= 400 && status < 600 ? status : 400;
-    throw err;
-  }
-  return res;
-}
-
 /**
  * @param {Object} validationResult - Result from validateExternalSystemComplete
  * @returns {string}
@@ -269,97 +228,30 @@ async function buildValidatedUploadManifestPayload(systemKey, opts = {}) {
 }
 
 /**
- * Upload local `integration/<systemKey>/openapi/*.json` specs when present so dataplane can store
- * vendor OpenAPI keyed by each datasource `openapi.documentKey` (same behavior as repair --api OpenAPI sync).
- * Call this **after** a successful pipeline publish: list/upload endpoints require the external system row.
- * First publish still succeeds because pipeline materializes internal specs from `openapi.operations` when needed.
- *
+ * Accept (unless --resume) then poll a Dataplane qualification job to terminal state.
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {Object} payload
  * @param {string} systemKey
- * @param {Object} manifest
- * @returns {Promise<void>}
+ * @param {Object} options - { resume?: string, wait?: boolean, json?: boolean, timeoutMs? }
+ * @returns {Promise<{ accepted: Object, terminal: Object|null }>}
  */
-async function logAndSyncLocalOpenApiForUpload(systemKey, manifest, uploadContext = {}) {
-  const pathOptions = uploadContext.pathOptions || {};
-  const appPath = resolveExternalSystemPath(systemKey, pathOptions);
-  const ei = manifest && manifest.externalIntegration;
-  const datasourceFiles = ei && Array.isArray(ei.dataSources) ? ei.dataSources : [];
-  await exportProgrammaticOpenApiForRepair({
-    appPath,
-    systemKey,
-    datasourceFiles,
-    dryRun: false,
-    backupCtx: { dryRun: false, changedFiles: [] }
-  });
-  const openapiSyncLines = await maybeSyncOpenApiFilesForMcp({
-    enabled: true,
-    dryRun: false,
-    appPath,
-    systemKey,
-    datasourceFiles,
-    dataplaneUrl: uploadContext.dataplaneUrl,
-    authConfig: uploadContext.authConfig,
-    // Always replace SpecFile rows keyed by openapi.documentKey so vendor/full
-    // specs are not left missing while only thin internal:* slices remain.
-    force: true
-  });
-  if (!uploadContext.quiet) {
-    for (const line of openapiSyncLines) {
-      logger.log(line.startsWith('Skipped') ? formatWarningLine(line) : formatSuccessLine(line));
-    }
+async function acceptOrResumeQualification(dataplaneUrl, authConfig, payload, systemKey, options) {
+  if (options.resume) {
+    const terminal = await resumeQualificationUpload(dataplaneUrl, authConfig, options.resume, systemKey, options);
+    return {
+      accepted: { jobId: options.resume, candidateFingerprint: terminal.result?.candidateFingerprint },
+      terminal
+    };
   }
+  const result = await runQualificationUpload(dataplaneUrl, authConfig, payload, systemKey, options);
+  return { accepted: result, terminal: result.terminal };
 }
 
 /**
- * @param {string} systemKey
- * @param {Object} options
- * @param {Object} manifest
- * @param {Object} payload
- * @param {{ dataplaneUrl: string, authConfig: Object, environment: string, rawRes: Object }} ctx
- */
-async function completeUploadAfterPublish(systemKey, options, manifest, payload, ctx) {
-  const quietCompact = options.minimal === true && options.verbose !== true;
-  const pushMeta = await pushAndLogCredentialSecrets(ctx.dataplaneUrl, ctx.authConfig, systemKey, payload, {
-    json: options.json === true,
-    pathOptions: options.pathOptions,
-    suppressCredentialLog: quietCompact,
-    excludeSecretKeys: options.excludeSecretKeys
-  });
-  await logAndSyncLocalOpenApiForUpload(systemKey, manifest, {
-    dataplaneUrl: ctx.dataplaneUrl,
-    authConfig: ctx.authConfig,
-    pathOptions: options.pathOptions,
-    quiet: quietCompact
-  });
-  const followupResult = await handlePublicationAndFollowups(
-    {
-      systemKey,
-      options,
-      manifest,
-      payload,
-      environment: ctx.environment,
-      dataplaneUrl: ctx.dataplaneUrl,
-      authConfig: ctx.authConfig,
-      rawRes: ctx.rawRes,
-      credentialPush: pushMeta.credentialPush,
-      configPush: pushMeta.configPush
-    },
-    maybeRunUploadProbe
-  );
-  return finalizeUploadPublishResult(
-    {
-      dataplaneUrl: ctx.dataplaneUrl,
-      authConfig: ctx.authConfig,
-      environment: ctx.environment,
-      uploadSkipped: false,
-      sidecar: followupResult?.sidecar || null
-    },
-    payload,
-    options
-  );
-}
-
-/**
- * Upload path after dry-run check.
+ * Upload path after dry-run check: submit for durable Dataplane qualification (async, no
+ * request-lifetime failure), then — unless `--no-wait` — poll to terminal and run the same
+ * downstream follow-ups (credential push, OpenAPI sync, sidecar, probe) as before.
  * @param {string} systemKey
  * @param {Object} options
  * @param {Object} manifest
@@ -373,40 +265,28 @@ async function runUploadPublishAndSummary(systemKey, options, manifest, payload)
     options,
     payload
   );
-  const rawRes = await runWithUploadPipelineSpinner(
-    async() =>
-      runUploadValidatePublish(dataplaneUrl, authConfig, payload, systemKey, {
-        timeoutMs: options.timeoutMs
-      }),
-    {
-      systemKey,
-      json: options.json === true,
-      syncMode: options.syncMode === true,
-      suppressPipelineSpinner: options.suppressPipelineSpinner === true
-    }
+  const { accepted, terminal } = await acceptOrResumeQualification(
+    dataplaneUrl,
+    authConfig,
+    payload,
+    systemKey,
+    options
   );
-  const publication = unwrapPublicationResult(rawRes);
-  if (isPublicationUnchanged(publication)) {
-    return finishUnchangedUploadPublication({
-      systemKey,
-      options,
-      payload,
-      dataplaneUrl,
-      authConfig,
-      environment
-    });
+  if (!terminal) {
+    return accepted;
   }
-
-  return completeUploadAfterPublish(systemKey, options, manifest, payload, {
+  return completeQualifiedUpload(systemKey, options, manifest, payload, {
     dataplaneUrl,
     authConfig,
     environment,
-    rawRes
+    accepted,
+    job: terminal
   });
 }
 
 /**
- * Uploads external system: publishes to dataplane and registers with controller (draft).
+ * Uploads external system: durably qualifies on dataplane (async ladder, no request-lifetime
+ * failure) then registers with controller (draft).
  * @param {string} systemKey - External system key (integration/<systemKey>/)
  * @param {Object} [options] - Options
  * @param {boolean} [options.dryRun] - Validate and build payload only; no API calls
@@ -415,7 +295,9 @@ async function runUploadPublishAndSummary(systemKey, options, manifest, payload)
  * @param {number} [options.probeTimeout] - Probe timeout ms (default 120000)
  * @param {number} [options.timeoutMs] - Pipeline publish timeout ms (HTTP + dataplane; default 300000)
  * @param {boolean} [options.minimal] - Short summary (default: compact unless --verbose)
- * @returns {Promise<{ dataplaneUrl: string, authConfig: Object, environment: string }|void>}
+ * @param {boolean} [options.wait=true] - Poll the qualification job to terminal state; --no-wait returns the job id immediately
+ * @param {string} [options.resume] - Poll an existing qualification job id instead of submitting a new candidate
+ * @returns {Promise<Object|void>} Terminal result when waited, `{jobId, candidateFingerprint}` when `--no-wait`, or `undefined` on dry-run
  * @throws {Error} If validation or API calls fail
  */
 async function uploadExternalSystem(systemKey, options = {}) {
@@ -461,6 +343,5 @@ module.exports = {
   buildValidatedUploadManifestPayload,
   buildUploadPayload,
   resolveDataplaneAndAuth,
-  runUploadValidatePublish,
   validateSystemKeyFormat
 };

package/lib/commands/verify-governance-command-action.js

@@ -6,6 +6,7 @@
 
 const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
+const { writeJsonEnvelopeAndExit } = require('../utils/cli-json-exit');
 const { runVerifyGovernanceCombined } = require('./verify-governance-combined-external');
 const { normalizeTestGovernanceCliOptions } = require('./test-governance-cli-options');
 const { displayVerifyGovernanceTTY } = require('../lifecycle/report-display');
@@ -33,16 +34,17 @@ async function runVerifyGovernanceCommandAction(appName, options, cmd) {
   const opts = normalizeVerifyGovernanceCliOptions(options, cmd);
   const result = await runVerifyGovernanceCombined(appName, opts);
 
+  const exitCode = exitCodeFromVerdict(result.verdict);
+
   if (opts.json) {
-    logger.log(JSON.stringify(buildJsonEnvelope(result, opts.verbose), null, 2));
-  } else {
-    if (opts.verbose && !opts.pack && typeof result.generated === 'number' && result.generated > 0) {
-      logger.log(formatSuccessLine(`Generated packs for ${result.generated} datasource(s)`));
-    }
-    displayVerifyGovernanceTTY(result.systemKey, result, { details: opts.verbose });
+    await writeJsonEnvelopeAndExit(buildJsonEnvelope(result, opts.verbose), exitCode);
+    return;
   }
 
-  const exitCode = exitCodeFromVerdict(result.verdict);
+  if (opts.verbose && !opts.pack && typeof result.generated === 'number' && result.generated > 0) {
+    logger.log(formatSuccessLine(`Generated packs for ${result.generated} datasource(s)`));
+  }
+  displayVerifyGovernanceTTY(result.systemKey, result, { details: opts.verbose });
   if (exitCode !== 0) {
     process.exit(exitCode);
   }

package/lib/commands/verify-operations-command-action.js

@@ -6,8 +6,8 @@
 
 'use strict';
 
-const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
+const { writeJsonEnvelopeAndExit } = require('../utils/cli-json-exit');
 const { cliOptsSkipPublish } = require('../utils/cli-sync-options');
 const { runVerifyOperationsForExternalSystem } = require('./verify-operations-external');
 const { displayVerifyOperationsTTY } = require('../lifecycle/report-display');
@@ -37,16 +37,17 @@ async function runVerifyOperationsCommandAction(appName, options, cmd) {
   const opts = normalizeVerifyOperationsCliOptions(options, cmd);
   const result = await runVerifyOperationsForExternalSystem(appName, opts);
 
+  const exitCode = exitCodeFromVerdict(result.verdict);
+
   if (opts.json) {
-    logger.log(JSON.stringify(buildJsonEnvelope(result, opts.verbose), null, 2));
-  } else {
-    displayVerifyOperationsTTY(appName, result, {
-      details: opts.verbose,
-      warnings: result.warnings
-    });
+    await writeJsonEnvelopeAndExit(buildJsonEnvelope(result, opts.verbose), exitCode);
+    return;
   }
 
-  const exitCode = exitCodeFromVerdict(result.verdict);
+  displayVerifyOperationsTTY(appName, result, {
+    details: opts.verbose,
+    warnings: result.warnings
+  });
   if (exitCode !== 0) {
     process.exit(exitCode);
   }

package/lib/commands/verify-trust-command-action.js

@@ -6,8 +6,8 @@
 
 'use strict';
 
-const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
+const { writeJsonEnvelopeAndExit } = require('../utils/cli-json-exit');
 const { runVerifyTrustForExternalSystem } = require('./verify-trust-external');
 const { normalizeTestTrustCliOptions } = require('./test-trust-cli-options');
 const { displayVerifyTrustTTY } = require('../lifecycle/report-display');
@@ -30,6 +30,8 @@ async function runVerifyTrustCommandAction(appName, options, cmd) {
     timeout: opts.timeout
   });
 
+  const exitCode = exitCodeFromVerdict(result.verdict);
+
   if (opts.json) {
     const envelope = buildJsonEnvelope(
       {
@@ -44,12 +46,11 @@ async function runVerifyTrustCommandAction(appName, options, cmd) {
       },
       opts.details || opts.verbose
     );
-    logger.log(JSON.stringify(envelope, null, 2));
-  } else {
-    displayVerifyTrustTTY(result.systemKey, result, { details: opts.verbose || opts.details });
+    await writeJsonEnvelopeAndExit(envelope, exitCode);
+    return;
   }
 
-  const exitCode = exitCodeFromVerdict(result.verdict);
+  displayVerifyTrustTTY(result.systemKey, result, { details: opts.verbose || opts.details });
   if (exitCode !== 0) {
     process.exit(exitCode);
   }

package/lib/deployment/deploy-poll-ui.js

@@ -23,7 +23,10 @@ function shouldUseDeployPollSpinner() {
  * @returns {{ onPollProgress: Function, finish: () => void }}
  */
 function createDeployPollHandlers(maxAttempts, options = {}) {
+  void maxAttempts;
   const silent = options && options.silent === true;
+  const startedAt = Date.now();
+  const elapsedMs = () => Date.now() - startedAt;
   const noop = () => {};
   if (silent) {
     return {
@@ -49,11 +52,11 @@ function createDeployPollHandlers(maxAttempts, options = {}) {
       setText(text) {
         ensureSpinner(text);
       },
-      onPollProgress: (deploymentData, attempt, maxA) => {
-        ensureSpinner(buildDeployPollSpinnerText(deploymentData, attempt, maxA));
+      onPollProgress: (deploymentData) => {
+        ensureSpinner(buildDeployPollSpinnerText(deploymentData, elapsedMs()));
       },
-      onPollWait: (attempt, maxA) => {
-        ensureSpinner(buildDeployPollWaitText(attempt, maxA));
+      onPollWait: () => {
+        ensureSpinner(buildDeployPollWaitText(elapsedMs()));
       },
       finish: () => {
         if (spinner) {
@@ -64,13 +67,14 @@ function createDeployPollHandlers(maxAttempts, options = {}) {
   }
   return {
     setText: noop,
-    onPollProgress: (deploymentData, attempt, maxA) => {
+    onPollProgress: (deploymentData) => {
       const status = deploymentData?.status ?? 'pending';
       const progress =
         deploymentData && Number.isFinite(Number(deploymentData.progress))
           ? Number(deploymentData.progress)
           : 0;
-      logger.log(chalk.gray(`Status: ${status} (${progress}%) (attempt ${attempt + 1}/${maxA})`));
+      const elapsedSeconds = Math.max(0, Math.floor(elapsedMs() / 1000));
+      logger.log(chalk.gray(`Status: ${status} (${progress}%) — ${elapsedSeconds}s elapsed`));
     },
     onPollWait: noop,
     finish: noop
@@ -79,12 +83,12 @@ function createDeployPollHandlers(maxAttempts, options = {}) {
 
 /**
  * Plain progress while awaiting the next status poll (HTTP in flight).
- * @param {number} attempt
- * @param {number} maxAttempts
+ * @param {number} elapsedMs
  * @returns {string}
  */
-function buildDeployPollWaitText(attempt, maxAttempts) {
-  return `Deploying application... Checking status (attempt ${attempt + 1}/${maxAttempts})`;
+function buildDeployPollWaitText(elapsedMs) {
+  const elapsedSeconds = Math.max(0, Math.floor(Number(elapsedMs || 0) / 1000));
+  return `Deploying application — ${elapsedSeconds}s elapsed`;
 }
 
 /**

package/lib/deployment/deployer-status.js

@@ -89,14 +89,14 @@ function logDeploymentProgress(deploymentData, attempt, maxAttempts) {
 /**
  * Single-line ora text for deploy polling (updates in place; same style as guided infra spinners).
  * @param {Object|null|undefined} deploymentData - Latest deployment payload (optional before first response)
- * @param {number} attempt - Zero-based attempt index
- * @param {number} maxAttempts - Max polling attempts
+ * @param {number} elapsedMs - Time elapsed since deployment polling began
  * @returns {string}
  */
-function buildDeployPollSpinnerText(deploymentData, attempt, maxAttempts) {
+function buildDeployPollSpinnerText(deploymentData, elapsedMs) {
   const status = deploymentData?.status ?? 'pending';
   const progress = deploymentData && Number.isFinite(Number(deploymentData.progress)) ? Number(deploymentData.progress) : 0;
-  return `Deploying application... Status: ${status} (${progress}%) (attempt ${attempt + 1}/${maxAttempts})`;
+  const elapsedSeconds = Math.max(0, Math.floor(Number(elapsedMs || 0) / 1000));
+  return `Deploying application — ${elapsedSeconds}s elapsed · ${status} (${progress}%)`;
 }
 
 /**

package/lib/external-system/deploy.js

@@ -28,7 +28,6 @@ const { generateControllerManifest } = require('../generator/external-controller
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { displayValidationResults } = require('../validation/validate-display');
 const { syncDeployJsonFromSources } = require('./sync-deploy-manifest');
-const { runDeployGateOrchestrator } = require('../commands/deploy-gate-orchestrator');
 const { runPostPublishDataSync } = require('../commands/run-post-publish-data-sync');
 const { uploadDigitalWorkerIfNeeded, deployRoleAssistantShellIfNeeded } = require('./deploy-helpers');
 const { createDataplanePublishedCheck } = require('./deploy-dataplane-published');
@@ -199,7 +198,9 @@ function buildExternalDeployPollOpts(options, extra = {}) {
   return {
     ...options,
     ...extra,
-    poll: true,
+    // Default true (CLI blocks and shows a spinner); explicit false (builder-api web path,
+    // plan 191.0 task 3) accepts and returns immediately — the caller polls its own status route.
+    poll: options.poll !== false,
     pollInterval:
       options.pollInterval !== undefined ? options.pollInterval : EXTERNAL_DEPLOY_POLL_INTERVAL_MS,
     pollMaxAttempts:
@@ -210,28 +211,15 @@ function buildExternalDeployPollOpts(options, extra = {}) {
   };
 }
 
-async function promoteExternalSystemLifecycleAfterDeploy(manifest, dataplaneUrl, authConfig) {
-  const { buildUploadPayload } = require('../commands/upload');
-  const { uploadApplicationViaPipelineWithAuthRetry } = require('../utils/pipeline-upload-auth-retry');
-  const payload = buildUploadPayload(manifest, { status: 'published' });
-  const res = await uploadApplicationViaPipelineWithAuthRetry(
-    dataplaneUrl,
-    authConfig,
-    payload,
-    manifest.key
-  );
-  if (res?.success === false) {
-    throw new Error(
-      res.formattedError || res.error || 'Failed to promote external system lifecycle after deploy'
-    );
-  }
-  return res;
-}
-
+/**
+ * Reads back dataplane readiness after Miso's deploy call. Miso (226.0/191.0 addendum) already
+ * decided and executed fast-qualified promotion or the legacy full ladder server-side — Builder
+ * never re-publishes here; that was the duplicate work this task removes.
+ */
 async function finalizeExternalDeployDataplaneWork(manifest, controllerUrl, environment, authConfig, options) {
   const compact = options.verbose !== true;
   const silent = compact;
-  const ctx = await fetchDataplaneDeployReadiness(
+  const refreshedCtx = await fetchDataplaneDeployReadiness(
     controllerUrl,
     environment,
     authConfig,
@@ -239,21 +227,6 @@ async function finalizeExternalDeployDataplaneWork(manifest, controllerUrl, envi
     { dataplaneUrl: options.knownDataplaneUrl, silent }
   );
 
-  if (ctx.dataplaneUrl && !ctx.error) {
-    await promoteExternalSystemLifecycleAfterDeploy(manifest, ctx.dataplaneUrl, authConfig);
-  }
-
-  const refreshedCtx =
-    ctx.dataplaneUrl && !ctx.error
-      ? await fetchDataplaneDeployReadiness(
-        controllerUrl,
-        environment,
-        authConfig,
-        manifest.key,
-        { dataplaneUrl: ctx.dataplaneUrl, silent: true }
-      )
-      : ctx;
-
   const probeData = await runOptionalExternalDeployProbe(refreshedCtx, manifest.key, authConfig, options);
   return { refreshedCtx, probeData };
 }
@@ -294,6 +267,21 @@ async function runPostDeployExternalSystemSteps(manifest, controllerUrl, environ
   });
 }
 
+// Builder-api web path (plan 191.0 task 3): accept-only, raw controller accept response
+// (deploymentId, not-yet-terminal status) — caller polls getDeployStatus for terminal truth.
+function logCompactDeployFailure(manifest, environment, deploymentOutcome, options, result) {
+  logDeployReadinessSummary({
+    environment,
+    dataplaneUrl: null,
+    manifest,
+    deploymentOk: false,
+    deploymentDetail: deploymentOutcome,
+    verbose: false,
+    gateOutcomes: options.gateOutcomes || null,
+    draftDeploymentId: result?.deploymentId || null
+  });
+}
+
 async function executeDeployAndDisplay(manifest, controllerUrl, environment, authConfig, options) {
   const compact = options.verbose !== true;
   const deployer = require('../deployment/deployer');
@@ -313,6 +301,10 @@ async function executeDeployAndDisplay(manifest, controllerUrl, environment, aut
     })
   );
 
+  if (options.poll === false) {
+    return result;
+  }
+
   const deploymentOutcome = parseControllerDeploymentOutcome(result);
   if (!compact) {
     logImmediateControllerDeploymentOutcome(deploymentOutcome);
@@ -320,16 +312,7 @@ async function executeDeployAndDisplay(manifest, controllerUrl, environment, aut
 
   if (!deploymentOutcome.ok) {
     if (compact) {
-      logDeployReadinessSummary({
-        environment,
-        dataplaneUrl: null,
-        manifest,
-        deploymentOk: false,
-        deploymentDetail: deploymentOutcome,
-        verbose: false,
-        gateOutcomes: options.gateOutcomes || null,
-        draftDeploymentId: result?.deploymentId || null
-      });
+      logCompactDeployFailure(manifest, environment, deploymentOutcome, options, result);
     }
     return result;
   }
@@ -422,15 +405,28 @@ async function validateDataplaneManifestForDeploy(manifest, authConfig, dataplan
   }
 }
 
+/**
+ * Deploy no longer runs local unit/integration tests or optional --gate certification steps
+ * (plan 191.0 task 2): that ladder now runs once, durably, during `aifabrix upload`. A caller
+ * still passing --gate gets an actionable notice instead of a silently-ignored flag.
+ */
+function warnIfDeployGateFlagIsNowNoop(systemKey, options) {
+  if (!options.gate) {
+    return;
+  }
+  logger.log(
+    chalk.yellow(
+      `⚠ --gate is no longer run during deploy; it runs once during "aifabrix upload ${systemKey}".`
+    )
+  );
+}
+
 async function runConnectedSystemDeployAfterDetect(appName, options, compact) {
   if (!compact) {
     logger.log(chalk.blue(`\n🚀 Deploying external system: ${appName}`));
   }
   await validateExternalSystemForDeploy(appName, options, compact);
-  const gateOutcomes = await runDeployGateOrchestrator(appName, {
-    ...options,
-    quietDeployUi: options.json === true
-  });
+  warnIfDeployGateFlagIsNowNoop(appName, options);
   await syncDeployJsonFromSources(appName);
   const manifest = await generateControllerManifest(appName, options);
   const digitalWorkerResult = await uploadDigitalWorkerIfNeeded(
@@ -454,7 +450,6 @@ async function runConnectedSystemDeployAfterDetect(appName, options, compact) {
   await validateDataplaneManifestForDeploy(manifest, authConfig, dataplaneUrl, compact);
   return executeDeployAndDisplay(manifest, controllerUrl, environment, authConfig, {
     ...options,
-    gateOutcomes,
     knownDataplaneUrl: dataplaneUrl
   });
 }

package/lib/external-system/download.js

@@ -74,9 +74,8 @@ async function setupAuthenticationAndDataplane(systemKey, _options, _config) {
   }
 
   const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
-  logger.log(formatProgress('Resolving dataplane URL…'));
+  // discoverDataplaneUrl already logs progress and success
   const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
-  logger.log(formatSuccessLine(`Dataplane URL: ${dataplaneUrl}`));
 
   return { authConfig, dataplaneUrl };
 }