@aifabrix/builder 2.55.2 → 2.56.0

package/lib/commands/upload-qualification-poll.js

@@ -0,0 +1,143 @@
+/**
+ * @fileoverview Poll a Dataplane qualification (publish) job until terminal (plan 191.0 task 1).
+ * Never invents success and never marks the candidate failed just because the CLI stopped polling —
+ * timing out returns a resumable jobId instead.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getPublishJobStatus } = require('../api/pipeline.api');
+const { formatApiError } = require('../utils/api-error-handler');
+
+const POLL_INTERVAL_MS = 3000;
+const POLL_TIMEOUT_MS = 30 * 60 * 1000;
+const TRANSIENT_HTTP_STATUSES = new Set([502, 503, 504]);
+const MAX_TRANSIENT_POLL_ERRORS = 20;
+
+const GOVERNANCE_SCENARIOS_MISSING = 'GOVERNANCE_SCENARIOS_MISSING';
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Convert repeated server error codes into one user-facing qualification failure.
+ * The raw job remains attached to the thrown error for JSON/programmatic callers.
+ * @param {Object} job
+ * @returns {{ message: string, userFacing: boolean }}
+ */
+function formatQualificationJobFailure(job) {
+  const raw = String(job && job.error ? job.error : '').trim();
+  const parts = raw.split(';').map((part) => part.trim()).filter(Boolean);
+  const missingCount = parts.filter((part) => part === GOVERNANCE_SCENARIOS_MISSING).length;
+  if (missingCount > 0 && missingCount === parts.length) {
+    const scope = `${missingCount} datasource${missingCount === 1 ? '' : 's'}`;
+    return {
+      message: `Governance checks could not run because scenario packs are missing for ${scope}.`,
+      userFacing: true
+    };
+  }
+  const unique = [...new Set(parts)];
+  return {
+    message: unique.join('; ') || `Upload checks failed for job ${job && job.jobId ? job.jobId : ''}`.trim(),
+    userFacing: false
+  };
+}
+
+/**
+ * @param {number|string} status
+ * @returns {boolean}
+ */
+function isTransientQualificationPollError(status) {
+  return TRANSIENT_HTTP_STATUSES.has(Number(status));
+}
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} jobId
+ * @param {Object} [pollUi]
+ * @returns {Promise<Object>} Raw job status data
+ */
+async function fetchQualificationJobWithRetry(dataplaneUrl, authConfig, jobId, pollUi = {}) {
+  const started = Date.now();
+  for (let attempt = 0; attempt <= MAX_TRANSIENT_POLL_ERRORS; attempt += 1) {
+    const res = await getPublishJobStatus(dataplaneUrl, authConfig, jobId);
+    if (res?.success !== false) {
+      return res.data;
+    }
+    if (!isTransientQualificationPollError(res.status)) {
+      const err = new Error(formatApiError(res, dataplaneUrl));
+      const status = Number(res.status);
+      err.statusCode = status >= 400 && status < 600 ? status : 400;
+      throw err;
+    }
+    if (attempt >= MAX_TRANSIENT_POLL_ERRORS) {
+      throw new Error(
+        `The upload service returned HTTP ${res.status} repeatedly while waiting for job ${jobId}.`
+      );
+    }
+    if (typeof pollUi.onTransientError === 'function') {
+      pollUi.onTransientError(res.status, Date.now() - started);
+    }
+    await sleep(POLL_INTERVAL_MS);
+  }
+  throw new Error(`Failed to check upload job ${jobId} after transient retries`);
+}
+
+/**
+ * Poll a Dataplane qualification job to terminal state (completed|failed). The timeout only
+ * bounds how long *this CLI process* waits — Dataplane keeps running the job regardless; timing
+ * out returns a resumable jobId, never a fabricated failure (plan 191.0 task 4).
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} jobId
+ * @param {Object} [pollUi] - { onPollProgress(job), onTransientError(status, elapsedMs) }
+ * @param {number} [timeoutMs] - Defaults to POLL_TIMEOUT_MS (30 min); CLI `--timeout` overrides it.
+ * @returns {Promise<Object>} Terminal job status data (state: 'completed')
+ * @throws {Error} With `.jobId` set, when the job fails or the CLI-side wait times out (resumable).
+ */
+async function pollQualificationJobUntilTerminal(
+  dataplaneUrl,
+  authConfig,
+  jobId,
+  pollUi = {},
+  timeoutMs = POLL_TIMEOUT_MS
+) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const job = await fetchQualificationJobWithRetry(dataplaneUrl, authConfig, jobId, pollUi);
+    if (typeof pollUi.onPollProgress === 'function') {
+      pollUi.onPollProgress(job);
+    }
+    if (job.state === 'failed') {
+      const failure = formatQualificationJobFailure(job);
+      const err = new Error(failure.message);
+      err.jobId = jobId;
+      err.job = job;
+      err.skipDoctor = failure.userFacing;
+      throw err;
+    }
+    if (job.state === 'completed') {
+      return job;
+    }
+    await sleep(POLL_INTERVAL_MS);
+  }
+  const timeoutErr = new Error(
+    `Timed out waiting for upload job ${jobId}. It is still running — resume with: aifabrix upload <systemKey> --resume ${jobId}`
+  );
+  timeoutErr.jobId = jobId;
+  timeoutErr.resumable = true;
+  throw timeoutErr;
+}
+
+module.exports = {
+  POLL_INTERVAL_MS,
+  POLL_TIMEOUT_MS,
+  isTransientQualificationPollError,
+  fetchQualificationJobWithRetry,
+  formatQualificationJobFailure,
+  pollQualificationJobUntilTerminal
+};

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/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
   });
 }