@aifabrix/builder 2.44.3 → 2.44.4

package/.npmrc.token

@@ -1 +1 @@
-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
+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

package/integration/roundtrip-test-local/README.md

@@ -123,8 +123,7 @@ Options:
   -e, --env <env>                    Environment: dev, tst, or pro
   -v, --verbose                      Show detailed step output and poll progress
   --debug                            Include debug output and write log to integration/roundtrip-test-local/logs/
-  --test-crud                        Enable CRUD lifecycle test (body testCrud: true)
-  --record-id <id>                   Record ID for test (body recordId)
+  --no-run-scenarios                 Skip expanding testPayload.scenarios in capacity step
   --no-cleanup                       Disable cleanup after test (body cleanup: false)
   --primary-key-value <value|@path>  Primary key value or path to JSON file (e.g. @pk.json) for body primaryKeyValue
   --no-async                         Use sync mode (no polling); single POST, no asyncRun

package/integration/roundtrip-test-local2/README.md

@@ -123,8 +123,7 @@ Options:
   -e, --env <env>                    Environment: dev, tst, or pro
   -v, --verbose                      Show detailed step output and poll progress
   --debug                            Include debug output and write log to integration/roundtrip-test-local2/logs/
-  --test-crud                        Enable CRUD lifecycle test (body testCrud: true)
-  --record-id <id>                   Record ID for test (body recordId)
+  --no-run-scenarios                 Skip expanding testPayload.scenarios in capacity step
   --no-cleanup                       Disable cleanup after test (body cleanup: false)
   --primary-key-value <value|@path>  Primary key value or path to JSON file (e.g. @pk.json) for body primaryKeyValue
   --no-async                         Use sync mode (no polling); single POST, no asyncRun

package/jest.projects.js

@@ -72,6 +72,9 @@ const defaultProject = {
       '/tests/lib/datasource/log-viewer.test.js',
       '\\\\tests\\\\lib\\\\datasource\\\\log-viewer.test.js',
       'lib/datasource/log-viewer.test.js',
+      '/tests/lib/datasource/log-viewer-structural.test.js',
+      '\\\\tests\\\\lib\\\\datasource\\\\log-viewer-structural.test.js',
+      'lib/datasource/log-viewer-structural.test.js',
       '/tests/lib/commands/parameters-validate.test.js',
       '\\\\tests\\\\lib\\\\commands\\\\parameters-validate.test.js',
       'lib/commands/parameters-validate.test.js',
@@ -190,6 +193,10 @@ const defaultProject = {
       '\\\\tests\\\\lib\\\\validation\\\\schema-241-alignment.test.js',
       'lib/validation/schema-241-alignment.test.js',
       'schema-241-alignment\\.test\\.js',
+      '/tests/lib/utils/schema-resolver-order.test.js',
+      '\\\\tests\\\\lib\\\\utils\\\\schema-resolver-order.test.js',
+      'lib/utils/schema-resolver-order.test.js',
+      'schema-resolver-order\\.test\\.js',
       '/tests/lib/app/app.test.js',
       '\\\\tests\\\\lib\\\\app\\\\app.test.js',
       'lib/app/app.test.js',
@@ -222,7 +229,10 @@ const isolatedProjects = [
   makeIsolatedProject('datasource-validation-watch', [
     '**/tests/lib/utils/datasource-validation-watch.test.js'
   ]),
-  makeIsolatedProject('log-viewer', ['**/tests/lib/datasource/log-viewer.test.js']),
+  makeIsolatedProject('log-viewer', [
+    '**/tests/lib/datasource/log-viewer.test.js',
+    '**/tests/lib/datasource/log-viewer-structural.test.js'
+  ]),
   makeIsolatedProject('datasource-test-run-schema-sync', [
     '**/tests/lib/utils/datasource-test-run-schema-sync.test.js'
   ]),
@@ -285,6 +295,7 @@ const isolatedProjects = [
   makeIsolatedProject('generator-validation', ['**/tests/lib/generator/generator-validation.test.js']),
   makeIsolatedProject('secrets-databaselog', ['**/tests/lib/core/secrets-databaselog.test.js']),
   makeIsolatedProject('schema-241-alignment', ['**/tests/lib/validation/schema-241-alignment.test.js']),
+  makeIsolatedProject('schema-resolver-order', ['**/tests/lib/utils/schema-resolver-order.test.js']),
   makeIsolatedProject('app-module', ['**/tests/lib/app/app.test.js']),
   makeIsolatedProject('admin-secrets', ['**/tests/lib/core/admin-secrets.test.js'])
 ];

package/lib/api/certificates.api.js

@@ -5,6 +5,24 @@
  */
 
 const { ApiClient } = require('./index');
+const { normalizeDataplaneAuth } = require('./validation-run.api');
+
+/**
+ * @param {Object} authConfig
+ * @returns {Object}
+ */
+function dataplaneAuthForBearerGet(authConfig) {
+  if (!authConfig || typeof authConfig !== 'object') {
+    return authConfig;
+  }
+  if (authConfig.token || authConfig.clientId) {
+    return authConfig;
+  }
+  if (authConfig.apiKey) {
+    return { ...authConfig, token: authConfig.apiKey, type: authConfig.type || 'bearer' };
+  }
+  return normalizeDataplaneAuth(authConfig);
+}
 
 /**
  * Get active trusted integration certificate for a datasource.
@@ -18,7 +36,7 @@ const { ApiClient } = require('./index');
  * @returns {Promise<Object>} API envelope `{ success, data?, status, ... }`
  */
 async function getActiveIntegrationCertificate(dataplaneUrl, authConfig, systemKey, datasourceKey) {
-  const client = new ApiClient(dataplaneUrl, authConfig);
+  const client = new ApiClient(dataplaneUrl, dataplaneAuthForBearerGet(authConfig));
   const path = `/api/v1/systems/${encodeURIComponent(systemKey)}/datasources/${encodeURIComponent(
     datasourceKey
   )}/certificates/active`;
@@ -36,7 +54,7 @@ async function getActiveIntegrationCertificate(dataplaneUrl, authConfig, systemK
  * @returns {Promise<Object>}
  */
 async function listIntegrationCertificates(dataplaneUrl, authConfig, params = {}) {
-  const client = new ApiClient(dataplaneUrl, authConfig);
+  const client = new ApiClient(dataplaneUrl, dataplaneAuthForBearerGet(authConfig));
   return await client.get('/api/v1/certificates', { params });
 }
 
@@ -51,7 +69,7 @@ async function listIntegrationCertificates(dataplaneUrl, authConfig, params = {}
  * @returns {Promise<Object>}
  */
 async function verifyIntegrationCertificate(dataplaneUrl, authConfig, body) {
-  const client = new ApiClient(dataplaneUrl, authConfig);
+  const client = new ApiClient(dataplaneUrl, dataplaneAuthForBearerGet(authConfig));
   return await client.post('/api/v1/certificates/verify', { body: body || {} });
 }
 

package/lib/certification/post-unified-cert-sync.js

@@ -10,6 +10,7 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { trySyncCertificationFromDataplaneForExternalApp } = require('./sync-after-external-command');
 const { cliOptsSkipCertSync } = require('./cli-cert-sync-skip');
+const { resolveDebugDisplayMode } = require('../utils/datasource-test-run-debug-display');
 
 /**
  * @async
@@ -17,14 +18,24 @@ const { cliOptsSkipCertSync } = require('./cli-cert-sync-skip');
  * @param {string} datasourceKey
  * @param {Object} options - CLI flags (app, noCertSync)
  * @param {string} label - Log label
+ * @param {Object|null} [envelope] - Last DatasourceTestRun (optional); used for certificateIssuance failed hint
  * @returns {Promise<void>}
  */
-async function afterUnifiedValidationCertSync(exitCode, datasourceKey, options, label) {
+async function afterUnifiedValidationCertSync(exitCode, datasourceKey, options, label, envelope = null) {
   if (exitCode !== 0 || cliOptsSkipCertSync(options)) return;
   try {
     const { resolveAppKeyForDatasource } = require('../datasource/resolve-app');
     const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
-    await trySyncCertificationFromDataplaneForExternalApp(appKey, label);
+    let issuanceFailureHint = null;
+    if (envelope && envelope.certificateIssuance && envelope.certificateIssuance.status === 'failed') {
+      const ci = envelope.certificateIssuance;
+      issuanceFailureHint = [ci.reasonCode, ci.message].filter(Boolean).join(': ');
+    }
+    const verboseCertHints = resolveDebugDisplayMode(options.debug) !== null;
+    await trySyncCertificationFromDataplaneForExternalApp(appKey, label, {
+      issuanceFailureHint,
+      verboseCertHints
+    });
   } catch (e) {
     logger.log(chalk.yellow(`⚠ Certification sync (${label}) skipped: ${e.message}`));
   }

package/lib/certification/sync-after-external-command.js

@@ -16,9 +16,10 @@ const logger = require('../utils/logger');
  * @async
  * @param {string} appKey - Integration / system key
  * @param {string} label - Short label for logs (e.g. "validate", "datasource test")
+ * @param {Object} [extra] - Optional `{ issuanceFailureHint }` from last DatasourceTestRun.certificateIssuance (failed)
  * @returns {Promise<void>}
  */
-async function trySyncCertificationFromDataplaneForExternalApp(appKey, label) {
+async function trySyncCertificationFromDataplaneForExternalApp(appKey, label, extra = {}) {
   try {
     const { detectAppType } = require('../utils/paths');
     const t = await detectAppType(appKey).catch(() => null);
@@ -29,7 +30,7 @@ async function trySyncCertificationFromDataplaneForExternalApp(appKey, label) {
     const { maybeSyncSystemCertificationFromDataplane } = require('./sync-system-certification');
 
     validateSystemKeyFormat(appKey);
-    const { dataplaneUrl, authConfig } = await resolveDataplaneAndAuth(appKey);
+    const { dataplaneUrl, authConfig } = await resolveDataplaneAndAuth(appKey, { silent: true });
     if (!authConfig.token) {
       logger.log(chalk.gray(`Certification sync (${label}) skipped: no Bearer token (run aifabrix login).`));
       return;
@@ -42,7 +43,9 @@ async function trySyncCertificationFromDataplaneForExternalApp(appKey, label) {
       systemKey: manifest.key,
       dataplaneUrl,
       authConfig,
-      datasourceKeys: dsKeys
+      datasourceKeys: dsKeys,
+      issuanceFailureHint: extra && extra.issuanceFailureHint ? String(extra.issuanceFailureHint).trim() : null,
+      verboseCertHints: extra && extra.verboseCertHints === true
     });
   } catch (e) {
     logger.log(chalk.yellow(`⚠ Certification sync (${label}) skipped: ${e.message}`));

package/lib/certification/sync-system-certification.js

@@ -84,15 +84,43 @@ function tryWriteSystemCertification(systemFilePath, systemObj, nextCert) {
 /**
  * @param {Object|null} chosen
  * @param {'no_active'|'no_public_key'} detail
+ * @param {string|null} [issuanceFailureHint] - From last DatasourceTestRun.certificateIssuance when status failed
+ * @param {boolean} [verboseCertHints] - Extra gray lines and auto-issue detail (CLI `--debug`)
  */
-function logSkippedCertification(chosen, detail) {
+function logSkippedCertification(chosen, detail, issuanceFailureHint, verboseCertHints = false) {
   if (detail === 'no_active' || !chosen) {
-    logger.log(
-      chalk.yellow(
-        '⚠ Certification not written: dataplane has no active trusted certificate for this system/datasource scope yet. ' +
-          'Run a successful validation or E2E that issues a certificate, then upload or run cert sync again.'
-      )
-    );
+    const hint = issuanceFailureHint && String(issuanceFailureHint).trim();
+    const certNotPassed =
+      hint &&
+      (hint.includes('CERTIFICATION_NOT_PASSED') ||
+        hint.toLowerCase().includes('certification did not pass'));
+    if (certNotPassed) {
+      logger.log(
+        chalk.yellow(
+          '⚠ Certification not written: no active integration certificate because certification did not pass on the dataplane issuance validation pass.'
+        )
+      );
+      if (verboseCertHints) {
+        logger.log(
+          chalk.gray(
+            '  E2E can be green for every datasource while auto-issue still fails: issuance re-validates the whole system before signing.'
+          )
+        );
+        if (hint) {
+          logger.log(chalk.gray(`  Auto-issue detail: ${hint}`));
+        }
+      }
+    } else {
+      logger.log(
+        chalk.yellow(
+          '⚠ Certification not written: dataplane has no active trusted certificate for this system/datasource scope yet. ' +
+            'Fix auto-issue or signing (see hint), or run unified validation then upload or run cert sync again.'
+        )
+      );
+      if (hint && verboseCertHints) {
+        logger.log(chalk.gray(`  Auto-issue detail: ${hint}`));
+      }
+    }
     return;
   }
   logger.log(
@@ -111,13 +139,19 @@ function logSkippedCertification(chosen, detail) {
  * @param {string} params.dataplaneUrl
  * @param {Object} params.authConfig
  * @param {string[]} params.datasourceKeys
+ * @param {boolean} [params.verboseCertHints]
  * @returns {Promise<{ written: boolean, reason?: string }>}
  */
 async function syncSystemCertificationFromDataplane(params) {
-  const { systemKey, dataplaneUrl, authConfig, datasourceKeys } = params;
+  const { systemKey, dataplaneUrl, authConfig, datasourceKeys, issuanceFailureHint, verboseCertHints } = params;
   const resolved = resolvePrimarySystemFilePath(systemKey);
   if (!resolved) return { written: false, reason: 'no_system_file' };
-  if (!dataplaneUrl || !authConfig || !authConfig.token) {
+  const hasBearerLike =
+    authConfig &&
+    typeof authConfig === 'object' &&
+    ((typeof authConfig.token === 'string' && authConfig.token.trim()) ||
+      (typeof authConfig.apiKey === 'string' && authConfig.apiKey.trim()));
+  if (!dataplaneUrl || !authConfig || !hasBearerLike) {
     return { written: false, reason: 'no_auth' };
   }
 
@@ -137,7 +171,7 @@ async function syncSystemCertificationFromDataplane(params) {
   const nextCert = buildCertificationFromArtifact(chosen, existing);
   if (!nextCert) {
     const detail = chosen ? 'no_public_key' : 'no_active';
-    logSkippedCertification(chosen, detail);
+    logSkippedCertification(chosen, detail, issuanceFailureHint, verboseCertHints === true);
     return { written: false, reason: 'incomplete_certification', detail };
   }
 
@@ -154,7 +188,8 @@ async function syncSystemCertificationFromDataplane(params) {
  * @param {boolean} [params.noCertSync]
  * @returns {Promise<void>}
  */
-function logCertificationSyncNotWritten(r, label) {
+function logCertificationSyncNotWritten(r, label, verboseCertHints = false) {
+  if (r && r.reason === 'incomplete_certification' && !verboseCertHints) return;
   const prefix = label ? ` (${label})` : '';
   const map = {
     no_system_file: `No *-system* file found under integration folder for this key${prefix}.`,
@@ -168,21 +203,32 @@ function logCertificationSyncNotWritten(r, label) {
 }
 
 async function maybeSyncSystemCertificationFromDataplane(params) {
-  const { label, noCertSync, systemKey, dataplaneUrl, authConfig, datasourceKeys } = params;
+  const {
+    label,
+    noCertSync,
+    systemKey,
+    dataplaneUrl,
+    authConfig,
+    datasourceKeys,
+    issuanceFailureHint,
+    verboseCertHints
+  } = params;
   if (noCertSync === true) return;
   try {
     const r = await syncSystemCertificationFromDataplane({
       systemKey,
       dataplaneUrl,
       authConfig,
-      datasourceKeys
+      datasourceKeys,
+      issuanceFailureHint,
+      verboseCertHints
     });
     if (r.written) {
       logger.log(
         chalk.gray(`Updated certification block from dataplane${label ? ` (${label})` : ''} in system file.`)
       );
     } else if (r.reason) {
-      logCertificationSyncNotWritten(r, label);
+      logCertificationSyncNotWritten(r, label, verboseCertHints === true);
     }
   } catch (e) {
     logger.log(chalk.yellow(`⚠ Certification sync skipped: ${e.message}`));

package/lib/cli/setup-app.test-commands.js

@@ -54,6 +54,70 @@ function setupTestCommand(program) {
     });
 }
 
+/**
+ * First failed `certificateIssuance` across E2E datasource rows (for cert-sync hint).
+ * @param {Array<{ key?: string, datasourceTestRun?: { certificateIssuance?: { status?: string, reasonCode?: string, message?: string } } }>} results
+ * @returns {string|null}
+ */
+function firstIssuanceFailureHintFromE2eResults(results) {
+  const failed = [];
+  for (const row of results || []) {
+    const ci = row.datasourceTestRun && row.datasourceTestRun.certificateIssuance;
+    if (ci && ci.status === 'failed') {
+      failed.push({ key: row.key, ci });
+    }
+  }
+  if (failed.length === 0) return null;
+  const firstRc = failed[0].ci.reasonCode;
+  const sameAll = failed.every(f => f.ci.reasonCode === firstRc);
+  if (sameAll && failed.length > 1) {
+    const parts = [firstRc, failed[0].ci.message].filter(Boolean);
+    return `${parts.join(': ')} (${failed.length} datasource scopes; first: ${failed[0].key})`;
+  }
+  const parts = [failed[0].ci.reasonCode, failed[0].ci.message].filter(Boolean);
+  return `[${failed[0].key}] ${parts.join(': ')}`.trim();
+}
+
+/**
+ * External integration E2E: run, display, exit on aggregate, optional cert sync.
+ * @param {string} appName
+ * @param {Object} options
+ * @returns {Promise<void>}
+ */
+async function runExternalIntegrationE2EAndCertSync(appName, options) {
+  const { runTestE2EForExternalSystem } = require('../commands/test-e2e-external');
+  const { success, results } = await runTestE2EForExternalSystem(appName, {
+    env: options.env,
+    debug: options.debug,
+    verbose: options.verbose,
+    async: options.async !== false,
+    sync: options.sync === true
+  });
+  const { displayIntegrationTestResults } = require('../utils/external-system-display');
+  const datasourceResults = results.map(r => ({
+    key: r.key,
+    success: r.success,
+    error: r.error,
+    skipped: false,
+    datasourceTestRun: r.datasourceTestRun
+  }));
+  displayIntegrationTestResults(
+    { systemKey: appName, success, datasourceResults },
+    options.verbose,
+    { debug: options.debug, runType: 'e2e' }
+  );
+  const { computeSystemExitCodeFromDatasourceRows } = require('../utils/datasource-test-run-exit');
+  const exitCode = computeSystemExitCodeFromDatasourceRows(datasourceResults, {
+    warningsAsErrors: options.warningsAsErrors === true,
+    requireCert: options.requireCert === true
+  });
+  if (exitCode !== 0) process.exit(exitCode);
+  if (cliOptsSkipCertSync(options)) return;
+  const { trySyncCertificationFromDataplaneForExternalApp } = require('../certification/sync-after-external-command');
+  const issuanceFailureHint = firstIssuanceFailureHintFromE2eResults(results);
+  await trySyncCertificationFromDataplaneForExternalApp(appName, 'test-e2e', { issuanceFailureHint });
+}
+
 async function runTestE2ECommand(appName, options) {
   const pathsUtil = require('../utils/paths');
   const appType = await pathsUtil.detectAppType(appName).catch(() => null);
@@ -64,40 +128,7 @@ async function runTestE2ECommand(appName, options) {
     );
   }
   if (appType && appType.baseDir === 'integration') {
-    const { runTestE2EForExternalSystem } = require('../commands/test-e2e-external');
-    const { success, results } = await runTestE2EForExternalSystem(appName, {
-      env: options.env,
-      debug: options.debug,
-      verbose: options.verbose,
-      async: options.async !== false,
-      sync: options.sync === true
-    });
-    const { displayIntegrationTestResults } = require('../utils/external-system-display');
-    const datasourceResults = results.map(r => ({
-      key: r.key,
-      success: r.success,
-      error: r.error,
-      skipped: false,
-      datasourceTestRun: r.datasourceTestRun
-    }));
-    displayIntegrationTestResults(
-      {
-        systemKey: appName,
-        success,
-        datasourceResults
-      },
-      options.verbose,
-      { debug: options.debug, runType: 'e2e' }
-    );
-    const { computeSystemExitCodeFromDatasourceRows } = require('../utils/datasource-test-run-exit');
-    const exitCode = computeSystemExitCodeFromDatasourceRows(datasourceResults, {
-      warningsAsErrors: options.warningsAsErrors === true,
-      requireCert: options.requireCert === true
-    });
-    if (exitCode !== 0) process.exit(exitCode);
-    if (cliOptsSkipCertSync(options)) return;
-    const { trySyncCertificationFromDataplaneForExternalApp } = require('../certification/sync-after-external-command');
-    await trySyncCertificationFromDataplaneForExternalApp(appName, 'test-e2e');
+    await runExternalIntegrationE2EAndCertSync(appName, options);
     return;
   }
   const { runAppTestE2e } = require('../commands/app-test');
@@ -190,6 +221,7 @@ function setupInstallTestE2eLintCommands(program) {
 }
 
 module.exports = {
-  setupInstallTestE2eLintCommands
+  setupInstallTestE2eLintCommands,
+  firstIssuanceFailureHintFromE2eResults
 };
 

package/lib/cli/setup-utility.js

@@ -118,7 +118,7 @@ function setupResolveCommand(program) {
         );
         logger.log(`✔ Generated .env file: ${envPath}`);
         if (envOnly) {
-          logger.log(chalk.gray('  (env-only mode: validation skipped; no application.yaml)'));
+          logger.log(chalk.gray('  (env-only mode: validation skipped; no application config file)'));
         } else if (!options.skipValidation) {
           const validate = require('../validation/validate');
           const result = await validate.validateAppOrFile(appName);

package/lib/commands/datasource-unified-test-cli.js

@@ -94,7 +94,7 @@ async function runDatasourceUnifiedTestOnceForWatch(datasourceKey, runOpts, disp
   try {
     const result = await runUnifiedDatasourceValidation(datasourceKey, runOpts);
     const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, certCliOptions, 'datasource test');
+    await afterUnifiedValidationCertSync(exitCode, datasourceKey, certCliOptions, 'datasource test', result.envelope);
     return {
       exitCode,
       envelope: result.envelope
@@ -121,7 +121,7 @@ async function datasourceTestCommandAction(datasourceKey, options) {
           const result = await runUnifiedDatasourceValidation(datasourceKey, runOpts);
           await writeDatasourceTestDebugLogIfRequested(appKey, datasourceKey, result, options);
           const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-          await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test (watch)');
+          await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test (watch)', result.envelope);
           return {
             exitCode,
             envelope: result.envelope
@@ -140,7 +140,7 @@ async function datasourceTestCommandAction(datasourceKey, options) {
       }
     }
     const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test');
+    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test', result.envelope);
     process.exit(exitCode);
   } catch (error) {
     logger.error(formatBlockingError('Datasource test failed:'), error.message);
@@ -195,7 +195,13 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
     if (unifiedModes) {
       const uni = unifiedCliResultFromIntegrationReturn(result);
       const exitCode = finalizeUnifiedValidationResult(uni, unifiedDisplayOpts);
-      await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration (watch)');
+      await afterUnifiedValidationCertSync(
+        exitCode,
+        datasourceKey,
+        options,
+        'datasource test-integration (watch)',
+        uni.envelope
+      );
       return { exitCode, envelope: uni.envelope };
     }
     displayIntegrationTestResults(
@@ -211,7 +217,13 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
       warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
       requireCert: unifiedDisplayOpts.requireCert === true
     });
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration (watch)');
+    await afterUnifiedValidationCertSync(
+      exitCode,
+      datasourceKey,
+      options,
+      'datasource test-integration (watch)',
+      result.datasourceTestRun || null
+    );
     return { exitCode, envelope: result.datasourceTestRun || null };
   } catch (err) {
     logger.error(formatBlockingError('Integration test failed:'), err.message);
@@ -219,49 +231,67 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
   }
 }
 
+async function integrationTestCommandActionWatch(datasourceKey, options, integOpts, unifiedDisplayOpts) {
+  const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
+  await runDatasourceValidationWatchLoop({
+    appKey,
+    extraPaths: options.watchPath || [],
+    includeApplicationYaml: options.watchApplicationYaml === true,
+    watchCi: options.watchCi === true,
+    watchFullDiff: options.watchFullDiff === true,
+    runOnce: () => runIntegrationOnceForWatch(datasourceKey, integOpts, options, unifiedDisplayOpts)
+  });
+}
+
+async function integrationTestCommandActionNonWatch(datasourceKey, integOpts, options, unifiedDisplayOpts) {
+  const result = await runDatasourceTestIntegration(datasourceKey, integOpts);
+  const unifiedModes =
+    options.json || options.summary || options.warningsAsErrors || options.requireCert;
+  if (unifiedModes) {
+    const uni = unifiedCliResultFromIntegrationReturn(result);
+    const exitCode = finalizeUnifiedValidationResult(uni, unifiedDisplayOpts);
+    await afterUnifiedValidationCertSync(
+      exitCode,
+      datasourceKey,
+      options,
+      'datasource test-integration',
+      uni.envelope
+    );
+    process.exit(exitCode);
+    return;
+  }
+  displayIntegrationTestResults(
+    {
+      systemKey: result.systemKey || 'unknown',
+      datasourceResults: [result],
+      success: result.success
+    },
+    options.verbose,
+    { debug: options.debug, runType: 'integration' }
+  );
+  const integExit = finalizeAfterIntegrationDisplay(result, {
+    warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
+    requireCert: unifiedDisplayOpts.requireCert === true
+  });
+  await afterUnifiedValidationCertSync(
+    integExit,
+    datasourceKey,
+    options,
+    'datasource test-integration',
+    result.datasourceTestRun || null
+  );
+  process.exit(integExit);
+}
+
 async function integrationTestCommandAction(datasourceKey, options) {
   const integOpts = buildIntegrationTestOpts(options);
   const unifiedDisplayOpts = buildIntegrationUnifiedDisplayOpts(options);
   try {
     if (options.watch) {
-      const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
-      await runDatasourceValidationWatchLoop({
-        appKey,
-        extraPaths: options.watchPath || [],
-        includeApplicationYaml: options.watchApplicationYaml === true,
-        watchCi: options.watchCi === true,
-        watchFullDiff: options.watchFullDiff === true,
-        runOnce: () => runIntegrationOnceForWatch(datasourceKey, integOpts, options, unifiedDisplayOpts)
-      });
-      return;
-    }
-    const result = await runDatasourceTestIntegration(datasourceKey, integOpts);
-    const unifiedModes =
-      options.json || options.summary || options.warningsAsErrors || options.requireCert;
-    if (unifiedModes) {
-      const exitCode = finalizeUnifiedValidationResult(
-        unifiedCliResultFromIntegrationReturn(result),
-        unifiedDisplayOpts
-      );
-      await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration');
-      process.exit(exitCode);
+      await integrationTestCommandActionWatch(datasourceKey, options, integOpts, unifiedDisplayOpts);
       return;
     }
-    displayIntegrationTestResults(
-      {
-        systemKey: result.systemKey || 'unknown',
-        datasourceResults: [result],
-        success: result.success
-      },
-      options.verbose,
-      { debug: options.debug, runType: 'integration' }
-    );
-    const integExit = finalizeAfterIntegrationDisplay(result, {
-      warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
-      requireCert: unifiedDisplayOpts.requireCert === true
-    });
-    await afterUnifiedValidationCertSync(integExit, datasourceKey, options, 'datasource test-integration');
-    process.exit(integExit);
+    await integrationTestCommandActionNonWatch(datasourceKey, integOpts, options, unifiedDisplayOpts);
   } catch (error) {
     logger.error(formatBlockingError('Integration test failed:'), error.message);
     process.exit(4);
@@ -296,9 +326,8 @@ async function runDatasourceTestE2ECliOnce(datasourceKey, options) {
     debug: options.debug,
     verbose: options.verbose,
     async: options.async !== false,
-    testCrud: options.testCrud,
-    recordId: options.recordId,
     cleanup: options.cleanup,
+    runScenarios: options.runScenarios,
     primaryKeyValue: options.primaryKeyValue,
     minVectorHits: options.minVectorHits,
     minProcessed: options.minProcessed,
@@ -340,8 +369,8 @@ async function runDatasourceTestE2ECliOnce(datasourceKey, options) {
 }
 
 async function runDatasourceTestE2ECliAction(datasourceKey, options) {
-  const { exitCode } = await runDatasourceTestE2ECliOnce(datasourceKey, options);
-  await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-e2e');
+  const { exitCode, envelope } = await runDatasourceTestE2ECliOnce(datasourceKey, options);
+  await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-e2e', envelope);
   process.exit(exitCode);
 }
 
@@ -371,7 +400,13 @@ async function e2eTestCommandAction(datasourceKey, capabilityKey, options) {
         runOnce: async() => {
           try {
             const r = await runDatasourceTestE2ECliOnce(datasourceKey, mergedOptions);
-            await afterUnifiedValidationCertSync(r.exitCode, datasourceKey, mergedOptions, 'datasource test-e2e (watch)');
+            await afterUnifiedValidationCertSync(
+              r.exitCode,
+              datasourceKey,
+              mergedOptions,
+              'datasource test-e2e (watch)',
+              r.envelope
+            );
             return r;
           } catch (err) {
             logger.error(formatBlockingError('E2E test failed:'), err.message);

package/lib/commands/datasource-unified-test-cli.options.js

@@ -166,8 +166,10 @@ function attachDatasourceTestE2eExclusiveOptions(cmd) {
       'Minimum record count assertion (e2eOptions.minRecordCount)',
       (v) => parseInt(String(v), 10)
     )
-    .option('--test-crud', 'Enable CRUD lifecycle test (e2eOptions.testCrud)')
-    .option('--record-id <id>', 'Record ID for test (e2eOptions.recordId)')
+    .option(
+      '--no-run-scenarios',
+      'Do not expand testPayload.scenarios in capacity step (e2eOptions.runScenarios: false)'
+    )
     .option('--no-cleanup', 'Disable cleanup after test (e2eOptions.cleanup: false)')
     .option(
       '--primary-key-value <value|@path>',