@aifabrix/builder 2.44.0 → 2.44.1

package/lib/utils/datasource-test-run-display.js

@@ -6,6 +6,7 @@
 
 const chalk = require('chalk');
 const { sectionTitle, headerKeyValue, colorAggregateGlyph, successGlyph, failureGlyph } = require('./cli-test-layout-chalk');
+const { appendCertificateTTY } = require('./datasource-test-run-certificate-tty');
 
 const SEP = '────────────────────────────────';
 
@@ -235,6 +236,16 @@ function appendDebugPayloadRefLines(lines, dbg, maxRefChars) {
  */
 function appendDebugMetaLines(lines, dbg, maxRefChars) {
   let added = false;
+  function formatSecondsText(s) {
+    const txt = String(s);
+    // UI-only: reduce noisy float seconds to 3 decimals, e.g. "1.1713749s" -> "1.171s".
+    // Applies only to number tokens immediately followed by "s".
+    return txt.replace(/(\d+\.\d+)(?=s\b)/g, m => {
+      const n = Number(m);
+      if (!Number.isFinite(n)) return m;
+      return n.toFixed(3);
+    });
+  }
   if (dbg.mode) {
     lines.push(
       `${chalk.blue.bold('debug.mode:')} ${chalk.white(String(dbg.mode))}`
@@ -244,7 +255,7 @@ function appendDebugMetaLines(lines, dbg, maxRefChars) {
   if (dbg.executionSummary) {
     lines.push(
       `${chalk.blue.bold('debug.executionSummary:')} ${chalk.white(
-        truncateRefLine(String(dbg.executionSummary), maxRefChars)
+        truncateRefLine(formatSecondsText(dbg.executionSummary), maxRefChars)
       )}`
     );
     added = true;
@@ -326,9 +337,14 @@ function appendIntegrationStepLines(lines, envelope) {
 
 function pickExecutiveVerdictLine(envelope) {
   const dev = envelope.developer;
+  const cert = envelope.certificate;
+  if (envelope.runType === 'e2e' && cert && typeof cert === 'object') {
+    const cs = cert.summary;
+    if (cs && String(cs).trim()) return String(cs).trim();
+  }
   return (
     (dev && dev.executiveSummary) ||
-    (envelope.certificate && envelope.certificate.summary) ||
+    (cert && cert.summary) ||
     (envelope.validation && envelope.validation.summary) ||
     (envelope.integration && envelope.integration.summary) ||
     `Run finished with status ${envelope.status}.`
@@ -416,6 +432,7 @@ function formatDatasourceTestRunTTY(envelope, options = {}) {
   lines.push('');
   lines.push(sectionTitle('Verdict:'));
   lines.push(chalk.white(pickExecutiveVerdictLine(envelope)));
+  appendCertificateTTY(lines, envelope);
   lines.push('');
   lines.push(chalk.gray(SEP));
   if (appendReferenceLayoutLines(lines, envelope, { maxRefChars: 160 })) {

package/lib/utils/datasource-test-run-exit.js

@@ -52,7 +52,32 @@ function exitCodeForPollTimeout(lastBody) {
   return 3;
 }
 
+const {
+  deriveSystemStatus,
+  systemCertStatus
+} = require('./external-system-system-test-tty');
+
+/**
+ * System-level exit code from per-datasource result rows (same matrix as §3.1 on synthetic rollup).
+ * @param {Array<{ skipped?: boolean, success?: boolean, datasourceTestRun?: Object|null }>} rows
+ * @param {Object} [opts]
+ * @param {boolean} [opts.warningsAsErrors]
+ * @param {boolean} [opts.requireCert]
+ * @returns {number}
+ */
+function computeSystemExitCodeFromDatasourceRows(rows, opts = {}) {
+  const list = Array.isArray(rows) ? rows : [];
+  const status = deriveSystemStatus(list);
+  const certAgg = systemCertStatus(list);
+  const body = {
+    status,
+    certificate: certAgg ? { status: certAgg === 'passed' ? 'passed' : 'not_passed' } : undefined
+  };
+  return computeExitCodeFromDatasourceTestRun(body, opts);
+}
+
 module.exports = {
   computeExitCodeFromDatasourceTestRun,
+  computeSystemExitCodeFromDatasourceRows,
   exitCodeForPollTimeout
 };

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

@@ -24,6 +24,7 @@ const {
   successGlyph,
   failureGlyph
 } = require('./cli-test-layout-chalk');
+const { displaySystemAggregateDatasourceTestRuns } = require('./external-system-system-test-tty');
 
 /**
  * Displays formatted test results (local external `aifabrix test` — structured report layout).
@@ -269,6 +270,13 @@ function displayServerDatasourceTestRunResults(results, verbose, opts = {}) {
     return;
   }
 
+  // Plan §17: system-level overview for multi-datasource results (no full §16 dump per datasource by default).
+  // Keep legacy per-datasource full envelope available only via datasource commands.
+  if (integrationResultsHaveEnvelope(results)) {
+    displaySystemAggregateDatasourceTestRuns(results, { runType, verbose: Boolean(verbose) });
+    return;
+  }
+
   const agg = deriveAggregateServerStatus(results);
   logServerDatasourceTestRunHeader(results, runType, agg);
 

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

@@ -0,0 +1,120 @@
+/**
+ * @fileoverview Plan §17 blocks: capabilities overview and integration health (split for file-size limits).
+ */
+
+'use strict';
+
+/**
+ * @param {Object|null|undefined} env
+ * @returns {'ok'|'warn'|'fail'}
+ */
+function integrationRollupStatus(env) {
+  const integ = env && env.integration;
+  if (!integ || typeof integ !== 'object') return 'ok';
+  if (typeof integ.status === 'string') {
+    const s = integ.status.toLowerCase();
+    if (s === 'fail' || s === 'failed' || s === 'error') return 'fail';
+    if (s === 'warn' || s === 'warning') return 'warn';
+    if (s === 'ok' || s === 'passed' || s === 'success') return 'ok';
+  }
+  const steps = Array.isArray(integ.stepResults) ? integ.stepResults : [];
+  if (steps.some(s => s && (s.success === false || s.error))) return 'fail';
+  return 'ok';
+}
+
+function buildCapabilityBlocks(rows, statusGlyph) {
+  const blocks = [];
+  for (const r of rows) {
+    if (r && r.skipped) continue;
+    const env = r && r.datasourceTestRun;
+    if (!env || !Array.isArray(env.capabilities) || env.capabilities.length === 0) continue;
+    const dkey = env.datasourceKey || r.key || 'datasource';
+    const caps = [...env.capabilities]
+      .filter(c => c && c.key)
+      .sort((a, b) => String(a.key).localeCompare(String(b.key)))
+      .slice(0, 4);
+    const parts = caps.map(c => `${statusGlyph(c.status)} ${c.key}`);
+    if (parts.length === 0) continue;
+    blocks.push({ dkey: String(dkey), line: parts.join(' ') });
+  }
+  return blocks;
+}
+
+function emitSectionHeader(io, title) {
+  const { log, metaGray, sectionTitle, SEP } = io;
+  log('');
+  log(metaGray(SEP));
+  log('');
+  log(sectionTitle(title));
+  log('');
+}
+
+/**
+ * @param {Array} rows
+ * @param {{ log: Function, chalk: object, metaGray: Function, sectionTitle: Function, statusGlyph: Function, SEP: string }} io
+ * @returns {boolean}
+ */
+function logCapabilitiesOverview(rows, io) {
+  const blocks = buildCapabilityBlocks(rows, io.statusGlyph);
+  if (blocks.length === 0) return false;
+  emitSectionHeader(io, 'Capabilities overview:');
+  for (const b of blocks) {
+    io.log(io.chalk.white(`${b.dkey}:`));
+    io.log(io.chalk.white(`  ${b.line}`));
+  }
+  return true;
+}
+
+function badIntegrationSteps(integ) {
+  if (!integ || !Array.isArray(integ.stepResults)) return [];
+  return integ.stepResults.filter(s => s && (s.success === false || s.error)).slice(0, 2);
+}
+
+function buildIntegrationBlocks(rows) {
+  const blocks = [];
+  for (const r of rows) {
+    if (r && r.skipped) continue;
+    const env = r && r.datasourceTestRun;
+    if (!env) continue;
+    const dkey = env.datasourceKey || r.key || 'datasource';
+    const st = integrationRollupStatus(env);
+    const integ = env.integration && typeof env.integration === 'object' ? env.integration : null;
+    blocks.push({ dkey: String(dkey), st, badSteps: badIntegrationSteps(integ) });
+  }
+  return blocks;
+}
+
+function emitFailedSteps(block, io) {
+  if (block.st !== 'fail' && block.st !== 'warn') return;
+  const { log, chalk, statusGlyph } = io;
+  for (const stp of block.badSteps) {
+    const nm = stp.name || stp.step || 'step';
+    const hint = stp.error || stp.message || '';
+    log(chalk.white(`  ${statusGlyph('fail')} ${nm}${hint ? `: ${hint}` : ''}`));
+  }
+}
+
+/**
+ * @param {Array} rows
+ * @param {'integration'|'e2e'} runType
+ * @param {{ log: Function, chalk: object, metaGray: Function, sectionTitle: Function, statusGlyph: Function, SEP: string }} io
+ * @returns {boolean}
+ */
+function logIntegrationHealthSection(rows, runType, io) {
+  if (runType !== 'integration') return false;
+  const blocks = buildIntegrationBlocks(rows);
+  if (blocks.length === 0) return false;
+  emitSectionHeader(io, 'Integration health:');
+  const { log, chalk, statusGlyph } = io;
+  for (const b of blocks) {
+    log(chalk.white(`${b.dkey}: ${statusGlyph(b.st)} ${b.st}`));
+    emitFailedSteps(b, io);
+  }
+  return true;
+}
+
+module.exports = {
+  integrationRollupStatus,
+  logCapabilitiesOverview,
+  logIntegrationHealthSection
+};

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

@@ -0,0 +1,417 @@
+/**
+ * @fileoverview System-level TTY renderer for DatasourceTestRun fan-out results (plan §17).
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('./logger');
+const {
+  SEP,
+  statusGlyph
+} = require('./datasource-test-run-display');
+const {
+  sectionTitle,
+  headerKeyValue,
+  formatStatusKeyValue,
+  integrationFooterLine,
+  colorRollupPrefixedLine,
+  metadata: metaGray
+} = require('./cli-test-layout-chalk');
+const {
+  formatDataQualityLines,
+  readinessLineFromDataReadiness,
+  verdictLineFromEnvelope
+} = require('./validation-report-tty-kit');
+const {
+  logCapabilitiesOverview: logCapabilitiesOverviewSection,
+  logIntegrationHealthSection: logIntegrationHealthSectionBlock
+} = require('./external-system-system-test-tty-overview');
+
+/**
+  * @param {'ok'|'warn'|'fail'|'skipped'|null} st
+  * @returns {number}
+  */
+function statusRank(st) {
+  if (st === 'fail') return 0;
+  if (st === 'warn') return 1;
+  if (st === 'ok') return 2;
+  if (st === 'skipped') return 3;
+  return 4;
+}
+
+/**
+ * Per-row status for system rollup and tables: CLI/transport failure overrides envelope-only OK.
+ * @param {{ skipped?: boolean, success?: boolean, datasourceTestRun?: { status?: string }|null }} r
+ * @returns {'ok'|'warn'|'fail'|'skipped'}
+ */
+function rollupRowStatus(r) {
+  if (r && r.skipped) return 'skipped';
+  if (r && r.success === false) return 'fail';
+  const env = r && r.datasourceTestRun;
+  return env && typeof env.status === 'string' ? env.status : 'ok';
+}
+
+/**
+  * @param {Array<{ key: string, skipped?: boolean, datasourceTestRun?: Object|null, success?: boolean }>} rows
+  * @returns {'ok'|'warn'|'fail'|'skipped'}
+  */
+function deriveSystemStatus(rows) {
+  if (!Array.isArray(rows) || rows.length === 0) return 'ok';
+  const statuses = rows.map(rollupRowStatus);
+  if (statuses.some(s => s === 'fail')) return 'fail';
+  if (statuses.some(s => s === 'warn')) return 'warn';
+  if (statuses.every(s => s === 'skipped')) return 'skipped';
+  // Mixed ok/skipped => warn per plan.
+  return statuses.every(s => s === 'ok') ? 'ok' : 'warn';
+}
+
+function bucketIssueSeverity(issue) {
+  const sev = issue && issue.severity ? String(issue.severity).toLowerCase() : '';
+  if (sev === 'error' || sev === 'critical' || sev === 'high' || sev === 'fatal') return 'fail';
+  if (sev === 'warn' || sev === 'warning' || sev === 'medium') return 'warn';
+  return null;
+}
+
+/**
+  * Minimal heuristic rollups backed by envelope fields (no engine codenames).
+  * @param {Object|null|undefined} env
+  * @returns {'ok'|'warn'|'fail'}
+  */
+function dqFromEnvelope(env) {
+  const v = env && env.validation;
+  const st = v && typeof v.status === 'string' ? String(v.status) : null;
+  if (st === 'fail') return 'fail';
+  if (st === 'warn') return 'warn';
+
+  const issues = v && Array.isArray(v.issues) ? v.issues : [];
+  if (issues.some(i => bucketIssueSeverity(i) === 'fail')) return 'fail';
+  if (issues.some(i => bucketIssueSeverity(i) === 'warn')) return 'warn';
+  return 'ok';
+}
+
+/**
+  * @param {Array} rows
+  * @returns {{ schema: 'ok'|'warn'|'fail', consistency: 'ok'|'warn'|'fail', reliability: 'ok'|'warn'|'fail' }}
+  */
+function deriveSystemDataQuality(rows) {
+  const envs = rows
+    .map(r => (r && r.datasourceTestRun && typeof r.datasourceTestRun === 'object' ? r.datasourceTestRun : null))
+    .filter(Boolean);
+  if (envs.length === 0) {
+    return { schema: 'warn', consistency: 'warn', reliability: 'warn' };
+  }
+
+  const picks = envs.map(dqFromEnvelope);
+  const agg = picks.some(x => x === 'fail') ? 'fail' : picks.some(x => x === 'warn') ? 'warn' : 'ok';
+  return { schema: agg, consistency: agg, reliability: agg };
+}
+
+/**
+  * @param {Array} rows
+  * @returns {'ready'|'partial'|'not_ready'|null}
+  */
+function deriveSystemReadiness(rows) {
+  const envs = rows
+    .map(r => (r && r.datasourceTestRun && typeof r.datasourceTestRun === 'object' ? r.datasourceTestRun : null))
+    .filter(Boolean);
+  const drs = envs
+    .map(e => e.validation && e.validation.dataReadiness)
+    .filter(Boolean);
+  if (drs.length === 0) return null;
+  if (drs.some(x => x === 'not_ready')) return 'not_ready';
+  if (drs.some(x => x === 'partial')) return 'partial';
+  return 'ready';
+}
+
+function countByStatus(rows) {
+  const counts = { ok: 0, warn: 0, fail: 0, skipped: 0 };
+  for (const r of rows) {
+    const s = rollupRowStatus(r);
+    if (counts[s] !== undefined) counts[s] += 1;
+  }
+  return counts;
+}
+
+function pickBlockingDatasourceKey(rows) {
+  const keys = rows
+    .map(r => {
+      const env = r && r.datasourceTestRun;
+      const st = rollupRowStatus(r);
+      const key =
+        env && env.datasourceKey
+          ? String(env.datasourceKey)
+          : r && r.key
+            ? String(r.key)
+            : '';
+      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);
+  });
+  return keys.length ? keys[0].key : null;
+}
+
+function issueKey(issue) {
+  const code = issue && issue.code ? String(issue.code) : '';
+  const msg = issue && issue.message ? String(issue.message) : '';
+  return `${code}::${msg}`.toLowerCase();
+}
+
+function issueSortKey(it) {
+  return `${statusRank(it.severity)}::${it.datasourceKey}::${it.message}`.toLowerCase();
+}
+
+function extractRowIssues(row) {
+  const env = row && row.datasourceTestRun;
+  const datasourceKey = (env && env.datasourceKey) || (row && row.key) || 'datasource';
+  const issues = env && env.validation && Array.isArray(env.validation.issues) ? env.validation.issues : [];
+  const envStatus = env && typeof env.status === 'string' ? env.status : null;
+  return { datasourceKey: String(datasourceKey), issues, envStatus };
+}
+
+function toIssueItem(datasourceKey, envStatus, iss) {
+  const sev =
+    bucketIssueSeverity(iss) ||
+    (envStatus === 'fail' ? 'fail' : envStatus === 'warn' ? 'warn' : 'ok');
+  const msg = iss && iss.message ? String(iss.message) : iss && iss.code ? String(iss.code) : 'Issue';
+  return { datasourceKey, message: msg, severity: sev };
+}
+
+function collectKeyIssues(rows, cap) {
+  /** @type {{ datasourceKey: string, message: string, severity: 'fail'|'warn'|'ok' }[]} */
+  const out = [];
+  const seen = new Set();
+  for (const row of rows) {
+    const { datasourceKey, issues, envStatus } = extractRowIssues(row);
+    for (const iss of issues) {
+      const k = `${datasourceKey}::${issueKey(iss)}`;
+      if (seen.has(k)) continue;
+      seen.add(k);
+      out.push(toIssueItem(datasourceKey, envStatus, iss));
+    }
+  }
+  out.sort((a, b) => issueSortKey(a).localeCompare(issueSortKey(b)));
+  return out.slice(0, Math.max(0, cap));
+}
+
+function certificateBucket(env) {
+  const cert = env && env.certificate;
+  if (!cert || typeof cert !== 'object') return { status: null, level: null };
+  return {
+    status: cert.status ? String(cert.status) : null,
+    level: cert.level ? String(cert.level) : null
+  };
+}
+
+function systemCertStatus(rows) {
+  const certs = rows
+    .map(r => (r && r.datasourceTestRun ? certificateBucket(r.datasourceTestRun) : { status: null, level: null }))
+    .filter(c => c.status !== null);
+  if (certs.length === 0) return null;
+  if (certs.some(c => c.status === 'not_passed')) return 'not_passed';
+  return 'passed';
+}
+
+function drillDownCommand(runType, datasourceKey) {
+  if (!datasourceKey) return null;
+  if (runType === 'e2e') return `aifabrix datasource test-e2e ${datasourceKey}`;
+  if (runType === 'integration') return `aifabrix datasource test-integration ${datasourceKey}`;
+  return `aifabrix datasource test ${datasourceKey}`;
+}
+
+function logSystemHeader(results, runType, systemStatus) {
+  logger.log('');
+  logger.log(sectionTitle('Server test results'));
+  logger.log('');
+  logger.log(headerKeyValue('System:', results.systemKey));
+  logger.log(
+    headerKeyValue(
+      'Run:',
+      runType === 'e2e' ? 'test-e2e (dataplane)' : 'test-integration (dataplane)'
+    )
+  );
+  logger.log(formatStatusKeyValue(systemStatus, statusGlyph(systemStatus)));
+  logger.log('');
+}
+
+function logVerdictAndSummary(runType, systemStatus, certStatus, counts) {
+  logger.log(sectionTitle('Verdict:'));
+  logger.log(chalk.white(verdictLineFromEnvelope(systemStatus, certStatus, runType)));
+  logger.log('');
+  logger.log(sectionTitle('Summary:'));
+  logger.log(
+    chalk.white(
+      `${counts.ok + counts.warn + counts.fail} datasource(s): ${counts.ok} ok, ${counts.warn} warn, ${counts.fail} fail${counts.skipped ? `, ${counts.skipped} skipped` : ''}`
+    )
+  );
+  logger.log('');
+  logger.log(metaGray(SEP));
+  logger.log('');
+}
+
+function logDataQualityAndReadiness(rows) {
+  logger.log(sectionTitle('Data Quality:'));
+  const dq = deriveSystemDataQuality(rows);
+  const dqLines = formatDataQualityLines(dq, {
+    schema: 'structural coverage aggregated across datasources.',
+    consistency: 'issues aggregated across datasources.',
+    reliability: 'issues aggregated across datasources.'
+  });
+  dqLines.map(colorRollupPrefixedLine).forEach(l => logger.log(l));
+
+  const readiness = deriveSystemReadiness(rows);
+  const readinessLine = readinessLineFromDataReadiness(readiness);
+  if (readinessLine) {
+    logger.log('');
+    logger.log(colorRollupPrefixedLine(readinessLine));
+  }
+
+  logger.log('');
+  logger.log(metaGray(SEP));
+  logger.log('');
+}
+
+function logDatasourceTable(rows, counts, verbose) {
+  logger.log(sectionTitle('Datasources:'));
+  logger.log('');
+  if (!verbose && counts.ok > 0) {
+    logger.log(chalk.gray(`✔ ${counts.ok} datasource(s) fully ready`));
+  }
+
+  function rowStatus(r) {
+    return rollupRowStatus(r);
+  }
+
+  function readinessLabel(env, st) {
+    const ready = env && env.validation ? env.validation.dataReadiness : null;
+    if (ready === 'not_ready') return 'Not ready';
+    if (ready === 'partial') return 'Partial';
+    if (ready === 'ready') return 'Ready';
+    if (st === 'fail') return 'Not ready';
+    if (st === 'warn') return 'Partial';
+    return 'Ready';
+  }
+
+  function shouldListRow(r) {
+    if (verbose) return true;
+    const st = rowStatus(r);
+    return st === 'warn' || st === 'fail';
+  }
+
+  const listRows = rows.filter(shouldListRow);
+  for (const r of listRows) {
+    const env = r && r.datasourceTestRun;
+    const key = (env && env.datasourceKey) || (r && r.key) || 'datasource';
+    const st = rowStatus(r);
+    const readyLabel = readinessLabel(env, st);
+    logger.log(`${statusGlyph(st)} ${chalk.white(String(key).padEnd(22))} (${readyLabel})`);
+  }
+}
+
+function logBlockingDatasource(blocking) {
+  if (!blocking) return;
+  logger.log('');
+  logger.log(chalk.white(`Blocking datasource: ${blocking}`));
+}
+
+function logKeyIssuesSection(rows) {
+  const issues = collectKeyIssues(rows, 5);
+  if (issues.length === 0) return false;
+  logger.log('');
+  logger.log(metaGray(SEP));
+  logger.log('');
+  logger.log(sectionTitle('Key issues:'));
+  logger.log('');
+  let cur = null;
+  for (const it of issues) {
+    if (cur !== it.datasourceKey) {
+      cur = it.datasourceKey;
+      logger.log(chalk.white(cur));
+    }
+    logger.log(chalk.white(`- ${it.message}`));
+  }
+  return true;
+}
+
+function logCertificationSection(rows) {
+  const certSt = systemCertStatus(rows);
+  if (!certSt) return;
+  logger.log('');
+  logger.log(metaGray(SEP));
+  logger.log('');
+  logger.log(sectionTitle('Certification:'));
+  logger.log('');
+  logger.log(chalk.white(`System level: ${certSt === 'passed' ? '✔ Achieved' : '✖ Not achieved'}`));
+  logger.log('');
+  logger.log(chalk.white('Breakdown:'));
+  for (const r of rows) {
+    const env = r && r.datasourceTestRun;
+    if (!env) continue;
+    const cert = certificateBucket(env);
+    if (!cert.status) continue;
+    const g = cert.status === 'passed' ? '✔' : '✖';
+    const tier = cert.level ? cert.level : '(no level)';
+    logger.log(chalk.white(`- ${env.datasourceKey}: ${g} ${tier}`));
+  }
+}
+
+function logUseAndFooter(results, runType, systemStatus, blocking) {
+  logger.log('');
+  logger.log(metaGray(SEP));
+  logger.log('');
+  logger.log(sectionTitle('Use:'));
+  const cmd = drillDownCommand(runType, blocking);
+  logger.log(chalk.white(cmd || 'aifabrix datasource test <datasourceKey>'));
+  logger.log(
+    integrationFooterLine(
+      results.success,
+      systemStatus,
+      'All server tests passed.',
+      'Server tests completed with warnings.',
+      'Some server tests failed.'
+    )
+  );
+}
+
+/**
+  * Render system-level aggregate (plan §17) for DatasourceTestRun wrapper results.
+  * @param {Object} results
+  * @param {Object} opts
+  * @param {'integration'|'e2e'} opts.runType
+  * @param {boolean} opts.verbose
+  */
+function displaySystemAggregateDatasourceTestRuns(results, opts) {
+  const rows = Array.isArray(results.datasourceResults) ? results.datasourceResults : [];
+  const runType = opts.runType === 'e2e' ? 'e2e' : 'integration';
+  const systemStatus = deriveSystemStatus(rows);
+  const counts = countByStatus(rows);
+  const blocking = pickBlockingDatasourceKey(rows);
+  logSystemHeader(results, runType, systemStatus);
+  logVerdictAndSummary(runType, systemStatus, systemCertStatus(rows), counts);
+  logDataQualityAndReadiness(rows);
+  logDatasourceTable(rows, counts, Boolean(opts.verbose));
+  logBlockingDatasource(blocking);
+  logKeyIssuesSection(rows);
+  const ttyIo = { log: logger.log.bind(logger), chalk, metaGray, sectionTitle, statusGlyph, SEP };
+  logCapabilitiesOverviewSection(rows, ttyIo);
+  logIntegrationHealthSectionBlock(rows, runType, ttyIo);
+  logCertificationSection(rows);
+  logUseAndFooter(results, runType, systemStatus, blocking);
+}
+
+module.exports = {
+  displaySystemAggregateDatasourceTestRuns,
+  deriveSystemStatus,
+  deriveSystemDataQuality,
+  deriveSystemReadiness,
+  rollupRowStatus,
+  pickBlockingDatasourceKey,
+  collectKeyIssues,
+  systemCertStatus,
+  drillDownCommand
+};
+

package/lib/utils/paths.js

@@ -332,9 +332,23 @@ function getAppPath(appName, appType) {
 
 /**
  * Base directory for integration/builder: project root when cwd is inside project, else cwd.
+ * When `aifabrix-work` / `AIFABRIX_WORK` points at a repo that contains `integration/`, use that
+ * root even if cwd is elsewhere (e.g. global CLI install + cwd under `integration/<app>/`).
  * @returns {string} Directory to resolve integration/ and builder/ from
  */
 function getIntegrationBuilderBaseDir() {
+  const work = getAifabrixWork();
+  if (work) {
+    const workNorm = path.resolve(work);
+    const integrationUnderWork = path.join(workNorm, 'integration');
+    try {
+      if (fs.existsSync(integrationUnderWork)) {
+        return workNorm;
+      }
+    } catch {
+      // ignore fs errors
+    }
+  }
   const root = getProjectRoot();
   const cwd = path.resolve(process.cwd());
   const rootNorm = path.resolve(root);