@aifabrix/builder 2.44.3 → 2.44.5

package/lib/utils/external-system-system-test-tty.js

@@ -133,8 +133,8 @@ function countByStatus(rows) {
   return counts;
 }
 
-function pickBlockingDatasourceKey(rows) {
-  const keys = rows
+function rollupRowsWithKeys(rows) {
+  return rows
     .map(r => {
       const env = r && r.datasourceTestRun;
       const st = rollupRowStatus(r);
@@ -146,15 +146,37 @@ function pickBlockingDatasourceKey(rows) {
             : '';
       return { key, st };
     })
-    .filter(x => x.key);
-  keys.sort((a, b) => {
-    const d = statusRank(a.st) - statusRank(b.st);
-    if (d !== 0) return d;
-    return a.key.localeCompare(b.key);
-  });
+    .filter(x => x.key)
+    .sort((a, b) => {
+      const d = statusRank(a.st) - statusRank(b.st);
+      if (d !== 0) return d;
+      return a.key.localeCompare(b.key);
+    });
+}
+
+/**
+ * Worst-first datasource key for suggested CLI drill-down (always returned when any row exists).
+ * @param {Array} rows
+ * @returns {string|null}
+ */
+function pickDrillDownDatasourceKey(rows) {
+  const keys = rollupRowsWithKeys(rows);
   return keys.length ? keys[0].key : null;
 }
 
+/**
+ * Datasource key to label as "blocking" only when at least one row is not fully OK (fail/warn/skipped).
+ * When every row is OK, returns null so we do not imply a blocker when the system is all-green.
+ * @param {Array} rows
+ * @returns {string|null}
+ */
+function pickBlockingDatasourceKey(rows) {
+  const keys = rollupRowsWithKeys(rows);
+  if (keys.length === 0) return null;
+  if (keys.every(x => x.st === 'ok')) return null;
+  return keys[0].key;
+}
+
 function issueKey(issue) {
   const code = issue && issue.code ? String(issue.code) : '';
   const msg = issue && issue.message ? String(issue.message) : '';
@@ -390,6 +412,7 @@ function displaySystemAggregateDatasourceTestRuns(results, opts) {
   const systemStatus = deriveSystemStatus(rows);
   const counts = countByStatus(rows);
   const blocking = pickBlockingDatasourceKey(rows);
+  const drillDownKey = pickDrillDownDatasourceKey(rows);
   logSystemHeader(results, runType, systemStatus);
   logVerdictAndSummary(runType, systemStatus, systemCertStatus(rows), counts);
   logDataQualityAndReadiness(rows);
@@ -400,7 +423,7 @@ function displaySystemAggregateDatasourceTestRuns(results, opts) {
   logCapabilitiesOverviewSection(rows, ttyIo);
   logIntegrationHealthSectionBlock(rows, runType, ttyIo);
   logCertificationSection(rows);
-  logUseAndFooter(results, runType, systemStatus, blocking);
+  logUseAndFooter(results, runType, systemStatus, drillDownKey);
 }
 
 module.exports = {
@@ -410,6 +433,7 @@ module.exports = {
   deriveSystemReadiness,
   rollupRowStatus,
   pickBlockingDatasourceKey,
+  pickDrillDownDatasourceKey,
   collectKeyIssues,
   systemCertStatus,
   drillDownCommand

package/lib/utils/external-system-validators.js

@@ -39,7 +39,21 @@ function validateFieldMappingExpression(expression) {
 
   // Validate transformations (optional)
   const transformations = expression.split('|').slice(1).map(t => t.trim());
-  const validTransformations = ['toUpper', 'toLower', 'trim', 'default', 'toNumber', 'toString'];
+  // Keep in sync with dataplane field-mapping function registry (pipe DSL after {{path}})
+  const validTransformations = [
+    'toUpper',
+    'toLower',
+    'trim',
+    'default',
+    'toNumber',
+    'toString',
+    'coalesce',
+    'substring',
+    'replace',
+    'join',
+    'split',
+    'normalizeWhitespace'
+  ];
   for (const trans of transformations) {
     const transName = trans.split('(')[0].trim();
     if (!validTransformations.includes(transName)) {
@@ -67,6 +81,40 @@ function validateFieldMappingExpression(expression) {
  * @param {Object} payloadTemplate - Payload template
  * @param {Object} results - Results object to update
  */
+/**
+ * Root object used to verify {{...}} paths exist in the test payload.
+ * HubSpot-style configs map from `{{raw.id}}` while `payloadTemplate` often holds the
+ * API record at the top level; wrap virtually so path checks match CIP input shape
+ * without duplicating the record under `raw` in JSON (metadataSchema validation still
+ * uses the unwrapped `payloadTemplate`).
+ * @param {Object} payloadTemplate - testPayload.payloadTemplate
+ * @param {Object} attributes - fieldMappings.attributes
+ * @returns {Object}
+ */
+function fieldMappingPathRoot(payloadTemplate, attributes) {
+  if (!payloadTemplate || typeof payloadTemplate !== 'object') {
+    return payloadTemplate;
+  }
+  if ('raw' in payloadTemplate) {
+    return payloadTemplate;
+  }
+  const usesRawPrefix =
+    attributes &&
+    typeof attributes === 'object' &&
+    !Array.isArray(attributes) &&
+    Object.values(attributes).some(
+      cfg =>
+        cfg &&
+        typeof cfg === 'object' &&
+        typeof cfg.expression === 'string' &&
+        /\{\{\s*raw\./.test(cfg.expression)
+    );
+  if (usesRawPrefix) {
+    return { raw: payloadTemplate };
+  }
+  return payloadTemplate;
+}
+
 function validateSingleFieldMapping(fieldName, fieldConfig, payloadTemplate, results) {
   if (!fieldConfig.expression) {
     results.errors.push(`Field '${fieldName}' missing expression`);
@@ -124,8 +172,13 @@ function checkPathExistsInPayload(fieldPath, payloadTemplate) {
  * @returns {Object} Map suitable for validateDimensions
  */
 function getDimensionsMapForValidation(datasource) {
-  const root = datasource?.dimensions;
-  if (!root || typeof root !== 'object' || Array.isArray(root)) return {};
+  if (!datasource || !Object.prototype.hasOwnProperty.call(datasource, 'dimensions')) {
+    return undefined;
+  }
+  const root = datasource.dimensions;
+  if (!root || typeof root !== 'object' || Array.isArray(root)) {
+    return {};
+  }
   const out = {};
   for (const [dimKey, binding] of Object.entries(root)) {
     if (binding && typeof binding === 'object' && typeof binding.field === 'string') {
@@ -238,7 +291,10 @@ function validateFieldMappings(datasource, testPayload) {
     return results;
   }
 
-  validateDimensions(getDimensionsMapForValidation(datasource), results);
+  const dimensionsForValidation = getDimensionsMapForValidation(datasource);
+  if (dimensionsForValidation !== undefined) {
+    validateDimensions(dimensionsForValidation, results);
+  }
 
   // Validate attributes structure (required in new schema)
   const attributes = validateAttributesStructure(datasource.fieldMappings.attributes, results);
@@ -248,8 +304,9 @@ function validateFieldMappings(datasource, testPayload) {
 
   // Validate each attribute
   const payloadTemplate = testPayload.payloadTemplate || testPayload;
+  const pathCheckRoot = fieldMappingPathRoot(payloadTemplate, attributes);
   for (const [attributeName, attributeConfig] of Object.entries(attributes)) {
-    validateSingleAttribute(attributeName, attributeConfig, payloadTemplate, results);
+    validateSingleAttribute(attributeName, attributeConfig, pathCheckRoot, results);
   }
 
   return results;

package/lib/utils/load-cip-capacity-display-config.js

@@ -0,0 +1,130 @@
+/**
+ * @fileoverview Resolve CIP standard operation order for CLI display from the
+ * same source as `external-datasource.schema.json` ($defs.cipDefinition.properties.operations.properties).
+ * Falls back to `lib/schema/cip-capacity-display.fallback.json` when the schema file is unavailable.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @param {object|null} schema - Parsed external-datasource.schema.json
+ * @returns {string[]|null}
+ */
+function extractStandardOperationOrderFromSchema(schema) {
+  const props =
+    schema &&
+    schema.$defs &&
+    schema.$defs.cipDefinition &&
+    schema.$defs.cipDefinition.properties &&
+    schema.$defs.cipDefinition.properties.operations &&
+    schema.$defs.cipDefinition.properties.operations.properties;
+  if (!props || typeof props !== 'object') return null;
+  return Object.keys(props);
+}
+
+/**
+ * @param {string} p
+ * @returns {object|null}
+ */
+function tryReadJsonFile(p) {
+  try {
+    if (!p || !fs.existsSync(p)) return null;
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve path to dataplane external-datasource.schema.json (monorepo / env).
+ * Set `AIFABRIX_EXTERNAL_DATASOURCE_SCHEMA` to override.
+ * @returns {string|null}
+ */
+function resolveExternalDatasourceSchemaPath() {
+  if (process.env.AIFABRIX_EXTERNAL_DATASOURCE_SCHEMA) {
+    const envPath = String(process.env.AIFABRIX_EXTERNAL_DATASOURCE_SCHEMA).trim();
+    if (envPath && fs.existsSync(envPath)) return envPath;
+  }
+  const candidates = [
+    path.join(process.cwd(), 'app/schemas/json/external-datasource.schema.json'),
+    path.join(process.cwd(), 'aifabrix-dataplane/app/schemas/json/external-datasource.schema.json'),
+    path.join(process.cwd(), '..', 'aifabrix-dataplane', 'app/schemas/json/external-datasource.schema.json'),
+    path.join(__dirname, '../../../aifabrix-dataplane/app/schemas/json/external-datasource.schema.json')
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+const FALLBACK_PATH = path.join(__dirname, '../schema/cip-capacity-display.fallback.json');
+
+/** @type {{ standardOrder: string[], aliases: Record<string, string> }|null} */
+let _cache = null;
+
+/**
+ * @returns {{ standardOrder: string[], aliases: Record<string, string> }}
+ */
+function getCipCapacityDisplayConfig() {
+  if (_cache) return _cache;
+  const schemaPath = resolveExternalDatasourceSchemaPath();
+  const schema = schemaPath ? tryReadJsonFile(schemaPath) : null;
+  const fromSchema = extractStandardOperationOrderFromSchema(schema);
+  const fallback = tryReadJsonFile(FALLBACK_PATH) || {};
+  const fbOrder = Array.isArray(fallback.standardOperationOrder)
+    ? fallback.standardOperationOrder
+    : [];
+  const standardOrder = fromSchema && fromSchema.length ? fromSchema : fbOrder;
+  const aliases =
+    fallback.displayAliases && typeof fallback.displayAliases === 'object'
+      ? fallback.displayAliases
+      : { create: 'insert (create)' };
+  _cache = { standardOrder, aliases };
+  return _cache;
+}
+
+/**
+ * @param {string[]} standardOrder - from schema `cipDefinition.operations.properties` keys
+ * @param {string} op
+ * @returns {number}
+ */
+function standardOperationRank(standardOrder, op) {
+  const idx = standardOrder.indexOf(op);
+  if (idx >= 0) return idx;
+  return 500;
+}
+
+/**
+ * @param {string} capacityKey e.g. capacity:myOp#3 or capacity:update#1
+ * @returns {{ op: string, index: number }|null}
+ */
+function parseCapacityDetailKey(capacityKey) {
+  const s = String(capacityKey);
+  const m = s.match(/^capacity:([^#]+)#(\d+)$/i);
+  if (m) {
+    return { op: String(m[1]).toLowerCase(), index: parseInt(m[2], 10) };
+  }
+  const m2 = s.match(/^capacity:([^#]+)$/i);
+  if (m2) {
+    return { op: String(m2[1]).toLowerCase(), index: 0 };
+  }
+  return null;
+}
+
+function clearCipCapacityDisplayConfigCacheForTests() {
+  _cache = null;
+}
+
+module.exports = {
+  extractStandardOperationOrderFromSchema,
+  resolveExternalDatasourceSchemaPath,
+  getCipCapacityDisplayConfig,
+  standardOperationRank,
+  parseCapacityDetailKey,
+  clearCipCapacityDisplayConfigCacheForTests
+};

package/lib/utils/paths.js

@@ -615,8 +615,10 @@ async function detectAppType(appName, _options = {}) {
 }
 
 /**
- * Resolve-specific app path: prefer integration + env.template only (env-only mode).
- * If integration/<systemKey>/env.template exists, use that directory without requiring application.yaml.
+ * Resolve-specific app path: integration + env.template without application config → env-only mode.
+ * If integration/<systemKey>/env.template exists but there is no application.yaml, application.json,
+ * application.yml, or variables.yaml, use that directory with envOnly true (kv resolve only).
+ * When any application config file exists in that folder, use full resolve (envOnly false).
  * Otherwise fall back to detectAppType (integration or builder with full config).
  *
  * @param {string} appName - Application name
@@ -630,7 +632,12 @@ async function getResolveAppPath(appName) {
   const integrationPath = getIntegrationPath(appName);
   const envTemplatePath = path.join(integrationPath, 'env.template');
   if (fs.existsSync(integrationPath) && fs.existsSync(envTemplatePath)) {
-    return { appPath: integrationPath, envOnly: true };
+    try {
+      resolveApplicationConfigPath(integrationPath);
+      return { appPath: integrationPath, envOnly: false };
+    } catch {
+      return { appPath: integrationPath, envOnly: true };
+    }
   }
   const result = await detectAppType(appName);
   return { appPath: result.appPath, envOnly: false };

package/lib/utils/schema-resolver.js

@@ -175,6 +175,96 @@ function resolveDatasourceFiles(schemaBasePath, datasourceFiles) {
   return datasourceFiles.map(fileName => resolveSingleExternalFile(schemaBasePath, fileName, 'datasource'));
 }
 
+/**
+ * @param {string} schemaBasePath
+ * @param {string[]} systemFileNames
+ * @returns {string[]|null}
+ */
+function readSystemDatasourceKeyOrder(schemaBasePath, systemFileNames) {
+  if (!Array.isArray(systemFileNames) || systemFileNames.length === 0) {
+    return null;
+  }
+  const systemPath = path.join(schemaBasePath, systemFileNames[0]);
+  if (!fs.existsSync(systemPath)) {
+    return null;
+  }
+  try {
+    const systemParsed = loadConfigFile(systemPath);
+    const orderKeys = Array.isArray(systemParsed.dataSources) ? systemParsed.dataSources : null;
+    return orderKeys && orderKeys.length > 0 ? orderKeys : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} schemaBasePath
+ * @param {string[]} datasourceFileNames
+ * @returns {Map<string, string>}
+ */
+function mapDatasourceKeysToFilenames(schemaBasePath, datasourceFileNames) {
+  const byKey = new Map();
+  for (const fileName of datasourceFileNames) {
+    if (typeof fileName !== 'string') {
+      continue;
+    }
+    const fp = path.join(schemaBasePath, fileName);
+    if (!fs.existsSync(fp)) {
+      continue;
+    }
+    try {
+      const d = loadConfigFile(fp);
+      const k = d && typeof d.key === 'string' ? d.key.trim() : '';
+      if (k) {
+        byKey.set(k, fileName);
+      }
+    } catch {
+      /* tail via original list */
+    }
+  }
+  return byKey;
+}
+
+/**
+ * Reorder datasource filenames to match external system JSON `dataSources` key order when present.
+ * Keeps application.yaml list membership but fixes FK-safe sequencing when filenames were sorted or drifted.
+ *
+ * @param {string} schemaBasePath
+ * @param {string[]} systemFileNames - externalIntegration.systems
+ * @param {string[]} datasourceFileNames - externalIntegration.dataSources filenames
+ * @returns {string[]} Same filenames, system-declaration order first, then any leftovers in original order
+ */
+function orderDatasourceFileNamesBySystemKeys(
+  schemaBasePath,
+  systemFileNames,
+  datasourceFileNames
+) {
+  if (!Array.isArray(datasourceFileNames) || datasourceFileNames.length <= 1) {
+    return datasourceFileNames;
+  }
+  const orderKeys = readSystemDatasourceKeyOrder(schemaBasePath, systemFileNames);
+  if (!orderKeys) {
+    return datasourceFileNames;
+  }
+  const byKey = mapDatasourceKeysToFilenames(schemaBasePath, datasourceFileNames);
+  const out = [];
+  const used = new Set();
+  for (const k of orderKeys) {
+    const ks = typeof k === 'string' ? k.trim() : '';
+    const f = ks ? byKey.get(ks) : null;
+    if (f && !used.has(f)) {
+      out.push(f);
+      used.add(f);
+    }
+  }
+  for (const fileName of datasourceFileNames) {
+    if (fileName && !used.has(fileName)) {
+      out.push(fileName);
+    }
+  }
+  return out.length ? out : datasourceFileNames;
+}
+
 /**
  * Loads and validates application config
  * @async
@@ -206,13 +296,19 @@ async function resolveExternalFiles(appName, options = {}) {
 
   const schemaBasePath = await resolveSchemaBasePath(appName, options);
   const systemFiles = resolveSystemFiles(schemaBasePath, variables.externalIntegration.systems);
-  const datasourceFiles = resolveDatasourceFiles(schemaBasePath, variables.externalIntegration.dataSources);
+  const orderedNames = orderDatasourceFileNamesBySystemKeys(
+    schemaBasePath,
+    variables.externalIntegration.systems,
+    variables.externalIntegration.dataSources || []
+  );
+  const datasourceFiles = resolveDatasourceFiles(schemaBasePath, orderedNames);
 
   return [...systemFiles, ...datasourceFiles];
 }
 
 module.exports = {
   resolveSchemaBasePath,
-  resolveExternalFiles
+  resolveExternalFiles,
+  orderDatasourceFileNamesBySystemKeys
 };
 

package/lib/utils/urls-local-registry.js

@@ -175,6 +175,54 @@ function mergeBuilderDirIntoRegistry(merged, builderDir) {
   }
 }
 
+/**
+ * True when getBuilderRoot() resolves to the same path as AIFABRIX_BUILDER_DIR (authoritative override).
+ * @param {string|null} resolvedEffective
+ * @param {string|null} envResolved
+ * @returns {boolean}
+ */
+function effectiveBuilderMatchesEnvVar(resolvedEffective, envResolved) {
+  return Boolean(envResolved && resolvedEffective && resolvedEffective === envResolved);
+}
+
+/**
+ * Builder dirs to scan in order; later merges overwrite registry keys from earlier dirs.
+ * When `AIFABRIX_BUILDER_DIR` is set and differs from projectRoot/builder, env builder root is merged last.
+ * Otherwise projectRoot/builder is merged last so explicit refresh roots override getBuilderRoot().
+ *
+ * @param {string} root - Resolved project root passed to refresh
+ * @param {string|null} effectiveBuilderDir - pathsUtil.getBuilderRoot()
+ * @returns {string[]}
+ */
+function getOrderedBuilderDirsForRegistryScan(root, effectiveBuilderDir) {
+  const legacyBuilderDir = path.join(root, 'builder');
+  let resolvedLegacy;
+  let resolvedEffective;
+  try {
+    resolvedLegacy = path.resolve(legacyBuilderDir);
+    resolvedEffective = effectiveBuilderDir ? path.resolve(effectiveBuilderDir) : null;
+  } catch {
+    return [legacyBuilderDir];
+  }
+  const envRaw = process.env.AIFABRIX_BUILDER_DIR && String(process.env.AIFABRIX_BUILDER_DIR).trim();
+  const envResolved = envRaw ? path.resolve(envRaw) : null;
+  // Only treat env as authoritative when getBuilderRoot() is actually that path. Otherwise a stray
+  // AIFABRIX_BUILDER_DIR on CI (or Jest mocking getBuilderRoot to a temp dir) must not force
+  // [legacy, effective] — that order lets the real checkout builder overwrite the mocked root last.
+  const effectiveMatchesEnvVar = effectiveBuilderMatchesEnvVar(resolvedEffective, envResolved);
+
+  if (effectiveBuilderDir && resolvedEffective && resolvedEffective === resolvedLegacy) {
+    return [legacyBuilderDir];
+  }
+  if (effectiveMatchesEnvVar && effectiveBuilderDir && resolvedEffective && resolvedEffective !== resolvedLegacy) {
+    return [legacyBuilderDir, effectiveBuilderDir];
+  }
+  if (effectiveBuilderDir && resolvedEffective && resolvedEffective !== resolvedLegacy) {
+    return [effectiveBuilderDir, legacyBuilderDir];
+  }
+  return [legacyBuilderDir];
+}
+
 /**
  * Merge scan results into registry (does not remove stale keys).
  * @param {string|null} projectRoot - getProjectRoot() or null (same semantics as projectRoot || getProjectRoot())
@@ -188,19 +236,13 @@ function refreshUrlsLocalRegistryFromBuilder(projectRoot) {
   }
   // Published npm tarball omits builder/ under the package root (.npmignore). Global installs must
   // still refresh from the real builder tree (AIFABRIX_BUILDER_DIR or integration base + builder).
-  const legacyBuilderDir = path.join(root, 'builder');
-  const effectiveBuilderDir = pathsUtil.getBuilderRoot();
-  const builderDirs = [legacyBuilderDir];
+  let effectiveBuilderDir = null;
   try {
-    if (
-      effectiveBuilderDir &&
-      path.resolve(effectiveBuilderDir) !== path.resolve(legacyBuilderDir)
-    ) {
-      builderDirs.push(effectiveBuilderDir);
-    }
+    effectiveBuilderDir = pathsUtil.getBuilderRoot();
   } catch {
-    /* ignore path resolution errors */
+    effectiveBuilderDir = null;
   }
+  const builderDirs = getOrderedBuilderDirsForRegistryScan(root, effectiveBuilderDir);
   for (const builderDir of builderDirs) {
     mergeBuilderDirIntoRegistry(merged, builderDir);
   }

package/lib/utils/validation-run-poll.js

@@ -8,16 +8,25 @@ const chalk = require('chalk');
 const logger = require('./logger');
 const { getValidationRunWithTransportRetry } = require('./validation-run-post-retry');
 
-const INITIAL_INTERVAL_MS = 2000;
+/** Short fixed delay while waiting for async E2E (typically a few seconds). */
+const FAST_POLL_COUNT = 24;
+const FAST_POLL_INTERVAL_MS = 400;
+/** After fast phase, exponential backoff to limit load on long runs. */
+const SLOW_BASE_INTERVAL_MS = 2000;
 const MAX_INTERVAL_MS = 15000;
 
 /**
- * Delay between polls after attempt `n` (0-based): 2s, 4s, 8s, … cap 15s.
+ * Delay between polls after attempt `n` (0-based).
+ * Fast phase (~10s of 400ms gaps) so CLI detects completion quickly; then 2s, 4s, … cap 15s.
  * @param {number} attemptIndex - Zero-based poll index after initial POST
  * @returns {number}
  */
 function nextPollDelayMs(attemptIndex) {
-  const raw = INITIAL_INTERVAL_MS * 2 ** Math.max(0, attemptIndex);
+  if (attemptIndex < FAST_POLL_COUNT) {
+    return FAST_POLL_INTERVAL_MS;
+  }
+  const slowIndex = attemptIndex - FAST_POLL_COUNT;
+  const raw = SLOW_BASE_INTERVAL_MS * 2 ** Math.max(0, slowIndex);
   return Math.min(raw, MAX_INTERVAL_MS);
 }
 
@@ -104,7 +113,9 @@ async function pollValidationRunUntilComplete(opts) {
 }
 
 module.exports = {
-  INITIAL_INTERVAL_MS,
+  FAST_POLL_COUNT,
+  FAST_POLL_INTERVAL_MS,
+  SLOW_BASE_INTERVAL_MS,
   MAX_INTERVAL_MS,
   nextPollDelayMs,
   pollValidationRunUntilComplete,

package/lib/utils/validation-run-request.js

@@ -36,9 +36,8 @@ function assignOptionalNonNegativeInt(e2e, key, raw) {
  * @param {Object} options - CLI-derived options
  * @param {boolean} [options.debug]
  * @param {boolean} [options.verbose]
- * @param {boolean} [options.testCrud]
- * @param {string} [options.recordId]
  * @param {boolean} [options.cleanup]
+ * @param {boolean} [options.runScenarios] - false when --no-run-scenarios
  * @param {string|Object} [options.primaryKeyValue]
  * @param {Object} [options.e2eOptionsExtra] - Shallow-merged last (e.g. server-specific drill-down fields)
  * @returns {Object}
@@ -47,15 +46,14 @@ function buildE2eOptionsFromCli(options = {}) {
   const e2e = {};
   if (options.debug) e2e.includeDebug = true;
   if (options.verbose) e2e.audit = true;
-  if (options.testCrud === true) e2e.testCrud = true;
-  if (options.recordId !== undefined && options.recordId !== null && options.recordId !== '') {
-    e2e.recordId = String(options.recordId);
-  }
   if (options.cleanup === false) e2e.cleanup = false;
   else if (options.cleanup === true) e2e.cleanup = true;
   if (options.primaryKeyValue !== undefined && options.primaryKeyValue !== null) {
     e2e.primaryKeyValue = options.primaryKeyValue;
   }
+  if (options.runScenarios === false) {
+    e2e.runScenarios = false;
+  }
   assignOptionalNonNegativeInt(e2e, 'minVectorHits', options.minVectorHits);
   assignOptionalNonNegativeInt(e2e, 'minProcessed', options.minProcessed);
   assignOptionalNonNegativeInt(e2e, 'minRecordCount', options.minRecordCount);

package/lib/validation/dimension-display-helpers.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Flatten datasource root `dimensions` for validate CLI output.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+/**
+ * @param {Array<{ fk?: string, dimension?: string }>} via - dimensionBinding.via
+ * @returns {string}
+ */
+function formatFkViaChain(via) {
+  return via
+    .map(v =>
+      v && typeof v.fk === 'string' && typeof v.dimension === 'string' ? `${v.fk}→${v.dimension}` : ''
+    )
+    .filter(Boolean)
+    .join(', ');
+}
+
+/**
+ * @param {unknown} actor - dimensionBinding.actor
+ * @returns {string}
+ */
+function formatFkActorSuffix(actor) {
+  return typeof actor === 'string' && actor.length > 0 ? ` (actor: ${actor})` : '';
+}
+
+/**
+ * Flatten root dimensions: local → metadata.<field>, fk → fk:<chain> (actor: ...).
+ * @param {Record<string, unknown>|null|undefined} root - datasource.dimensions
+ * @returns {Record<string, string>}
+ */
+function flattenRootDimensionsForDisplay(root) {
+  const rootFlat = {};
+  if (!root || typeof root !== 'object' || Array.isArray(root)) {
+    return rootFlat;
+  }
+  for (const [dimKey, binding] of Object.entries(root)) {
+    if (!binding || typeof binding !== 'object') {
+      continue;
+    }
+    if (typeof binding.field === 'string') {
+      rootFlat[dimKey] = `metadata.${binding.field}`;
+      continue;
+    }
+    if (binding.type !== 'fk' || !Array.isArray(binding.via)) {
+      continue;
+    }
+    const chain = formatFkViaChain(binding.via);
+    if (!chain) {
+      continue;
+    }
+    rootFlat[dimKey] = `fk:${chain}${formatFkActorSuffix(binding.actor)}`;
+  }
+  return rootFlat;
+}
+
+module.exports = {
+  flattenRootDimensionsForDisplay
+};