@aifabrix/builder 2.44.3 → 2.44.5

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

@@ -6,6 +6,12 @@
 
 const { SEP, appendReferenceLayoutLines } = require('./datasource-test-run-display');
 const { buildDebugEnvelopeSlice } = require('./datasource-test-run-debug-slice');
+const {
+  pushCapacityOperationsSummaryLines,
+  parseCapacityScenarioOp,
+  parseCapacityDetailKey,
+  formatCapacityOperationLabel
+} = require('./datasource-test-run-capacity-operations');
 
 const FULL_MAX_BYTES_PER_STRING = 8192;
 const RAW_MAX_STRING_TTY = 65536;
@@ -74,9 +80,140 @@ function redactDebugText(text) {
     .replace(/("authorization"\s*:\s*")[^"]*(")/g, '$1[REDACTED]$2');
 }
 
+function getBestEffortStepList(envelope) {
+  const v = envelope && envelope.validation;
+  const metrics = v && v.metricsOutput;
+  const steps = metrics && Array.isArray(metrics.steps) ? metrics.steps : [];
+  if (steps.length) return steps;
+  const dbg = envelope && envelope.debug;
+  const stepDebug =
+    dbg && dbg.e2eAsyncDebug && Array.isArray(dbg.e2eAsyncDebug.stepDebug) ? dbg.e2eAsyncDebug.stepDebug : [];
+  return stepDebug;
+}
+
+function findStepByName(steps, name) {
+  return steps.find(s => s && String(s.name || s.step) === name);
+}
+
+function sumNumber(rows, key) {
+  return rows.reduce((acc, r) => acc + (Number(r && r[key]) || 0), 0);
+}
+
+function appendE2eWorkerHeadLine(lines, timing) {
+  const work = timing.durationSeconds;
+  if (work === undefined || work === null || work === '') return;
+  const w = Number(work);
+  if (Number.isNaN(w)) return;
+  let head = `E2E worker: ~${w.toFixed(3)}s`;
+  const wall = timing.wallClockSeconds;
+  if (wall !== undefined && wall !== null && wall !== '') {
+    const wl = Number(wall);
+    if (!Number.isNaN(wl)) {
+      head += ` (wall ~${wl.toFixed(3)}s)`;
+    }
+  }
+  lines.push(head);
+}
+
+function appendE2eStepDurationLines(lines, timing) {
+  const sd = timing.stepDurations;
+  if (!Array.isArray(sd) || !sd.length) return;
+  for (const row of sd) {
+    if (!row || typeof row !== 'object') continue;
+    const step = row.step !== undefined && row.step !== null ? String(row.step) : '?';
+    const sec =
+      row.durationSeconds !== undefined && row.durationSeconds !== null
+        ? Number(row.durationSeconds)
+        : NaN;
+    if (!Number.isNaN(sec)) {
+      lines.push(`  ${step}: ~${sec.toFixed(3)}s`);
+    }
+  }
+}
+
+function getFirstSyncJobPhaseTimings(e2e) {
+  const stepDebug = Array.isArray(e2e.stepDebug) ? e2e.stepDebug : [];
+  const syncStep = stepDebug.find(s => s && String(s.name) === 'sync');
+  const jobs = syncStep && syncStep.evidence && syncStep.evidence.jobs;
+  const first = Array.isArray(jobs) && jobs.length ? jobs[0] : null;
+  const audit = first && first.audit;
+  const pt = audit && typeof audit === 'object' ? audit.phaseTimingsSeconds : null;
+  return pt && typeof pt === 'object' ? pt : null;
+}
+
+function formatPhaseTimingParts(phaseTimings) {
+  const order = ['phase1', 'phase2', 'phase3', 'phase4'];
+  const parts = [];
+  for (const k of order) {
+    const raw = phaseTimings[k];
+    if (raw === undefined || raw === null) continue;
+    const v = Number(raw);
+    if (!Number.isNaN(v)) {
+      parts.push(`${k} ~${v.toFixed(3)}s`);
+    }
+  }
+  return parts;
+}
+
+function appendSyncPhaseTimingsFromE2e(lines, e2e) {
+  const phaseTimings = getFirstSyncJobPhaseTimings(e2e);
+  if (!phaseTimings) return;
+  const parts = formatPhaseTimingParts(phaseTimings);
+  if (parts.length) {
+    lines.push(`Sync phases (first job): ${parts.join(', ')}`);
+  }
+}
+
+/**
+ * E2E poll envelope: `debug.e2eAsyncDebug` from dataplane run store (timing + stepDebug).
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushE2eTimingSummaryLines(lines, envelope) {
+  const dbg = envelope && envelope.debug;
+  const e2e = dbg && dbg.e2eAsyncDebug;
+  if (!e2e || typeof e2e !== 'object') return;
+
+  const timing = e2e.timing;
+  if (timing && typeof timing === 'object') {
+    appendE2eWorkerHeadLine(lines, timing);
+    appendE2eStepDurationLines(lines, timing);
+  }
+  appendSyncPhaseTimingsFromE2e(lines, e2e);
+}
+
+function pushSyncSummaryLines(lines, envelope) {
+  const steps = getBestEffortStepList(envelope);
+  const syncStep = findStepByName(steps, 'sync');
+  const syncStatusStep = findStepByName(steps, 'sync_status');
+  const persistenceStep = findStepByName(steps, 'persistence');
+
+  if (syncStep && syncStep.evidence && Array.isArray(syncStep.evidence.jobs)) {
+    const jobs = syncStep.evidence.jobs;
+    const processed = sumNumber(jobs, 'recordsProcessed');
+    const total = sumNumber(jobs, 'totalRecords');
+    lines.push(`Sync: ${processed}/${total} processed`);
+  }
+  if (syncStatusStep && syncStatusStep.evidence && Array.isArray(syncStatusStep.evidence.datasources)) {
+    const rows = syncStatusStep.evidence.datasources;
+    const total = sumNumber(rows, 'totalRecords');
+    const active = sumNumber(rows, 'activeRecords');
+    lines.push(`Sync status: ${active}/${total} active`);
+  }
+  if (persistenceStep && persistenceStep.evidence && persistenceStep.evidence.recordCount !== undefined) {
+    lines.push(`Persistence: ${persistenceStep.evidence.recordCount} record(s)`);
+  }
+}
+
 function pushSummaryRefLines(lines, envelope) {
   const before = lines.length;
-  appendReferenceLayoutLines(lines, envelope, { maxRefChars: 600 });
+  try {
+    pushSyncSummaryLines(lines, envelope);
+    pushE2eTimingSummaryLines(lines, envelope);
+  } catch {
+    // ignore best-effort debug summary extraction
+  }
+  appendReferenceLayoutLines(lines, envelope, { maxRefChars: 600, includeDebugMeta: true });
   if (lines.length === before) {
     lines.push('(No audit or debug references on this report.)');
   }
@@ -130,6 +267,11 @@ module.exports = {
   resolveDebugDisplayMode,
   truncateUtf8String,
   formatDatasourceTestRunDebugBlock,
+  pushE2eTimingSummaryLines,
+  pushCapacityOperationsSummaryLines,
+  parseCapacityScenarioOp,
+  parseCapacityDetailKey,
+  formatCapacityOperationLabel,
   FULL_MAX_BYTES_PER_STRING,
   RAW_MAX_STRING_TTY,
   RAW_MAX_STRING_PIPE,

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

@@ -7,12 +7,23 @@
 const chalk = require('chalk');
 const { sectionTitle, headerKeyValue, colorAggregateGlyph, successGlyph, failureGlyph } = require('./cli-test-layout-chalk');
 const { appendCertificateTTY } = require('./datasource-test-run-certificate-tty');
+const { buildTtyMetaLines: buildTtyMetaLinesCore } = require('./datasource-test-run-tty-meta-lines');
 
 const SEP = '────────────────────────────────';
 
 /** @type {number} */
 const DEFAULT_MAX_REF_CHARS = 200;
 
+// UI-only: round float seconds tokens like "1.1713749s" -> "1.171s".
+function formatSecondsText(text) {
+  const txt = String(text);
+  return txt.replace(/(\d+\.\d+)(?=s\b)/g, m => {
+    const n = Number(m);
+    if (!Number.isFinite(n)) return m;
+    return n.toFixed(3);
+  });
+}
+
 /**
  * @param {'ok'|'warn'|'fail'|'skipped'} status
  * @returns {string}
@@ -144,23 +155,11 @@ function formatCapabilityFocusSection(envelope, focusKey) {
 
 /**
  * @param {Object} envelope
+ * @param {{ includeDebugExecutionSummary?: boolean }} [ttyOptions]
  * @returns {string[]}
  */
-function buildTtyMetaLines(envelope) {
-  const lines = [];
-  lines.push(
-    headerKeyValue('Datasource:', `${envelope.datasourceKey} (${envelope.systemKey})`)
-  );
-  lines.push(headerKeyValue('Run:', String(envelope.runType)));
-  lines.push(formatEnvelopeStatusLine(envelope));
-  const rid = envelope.runId || envelope.testRunId;
-  if (rid) lines.push(`${chalk.gray('Run ID:')} ${chalk.cyan(String(rid))}`);
-  if (envelope.reportCompleteness && envelope.reportCompleteness !== 'full') {
-    lines.push(
-      `${chalk.gray('Report:')} ${chalk.yellow(String(envelope.reportCompleteness))}`
-    );
-  }
-  return lines;
+function buildTtyMetaLines(envelope, ttyOptions = {}) {
+  return buildTtyMetaLinesCore(envelope, formatEnvelopeStatusLine, ttyOptions);
 }
 
 /**
@@ -236,16 +235,6 @@ 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))}`
@@ -272,6 +261,7 @@ function appendDebugMetaLines(lines, dbg, maxRefChars) {
  */
 function appendReferenceLayoutLines(lines, envelope, opts = {}) {
   const maxRefChars = opts.maxRefChars ?? DEFAULT_MAX_REF_CHARS;
+  const includeDebugMeta = opts.includeDebugMeta === true;
   const audit = envelope && envelope.audit;
   const dbg = envelope && envelope.debug;
   const parts = [];
@@ -287,7 +277,9 @@ function appendReferenceLayoutLines(lines, envelope, opts = {}) {
 
   if (dbg && typeof dbg === 'object') {
     parts.push(appendStringRefBlock(lines, 'debug.executionIds:', dbg.executionIds, maxRefChars));
-    parts.push(appendDebugMetaLines(lines, dbg, maxRefChars));
+    if (includeDebugMeta) {
+      parts.push(appendDebugMetaLines(lines, dbg, maxRefChars));
+    }
   }
 
   return parts.some(Boolean);
@@ -329,6 +321,8 @@ function appendIntegrationStepLines(lines, envelope) {
   const integ = envelope && envelope.integration;
   const steps = integ && Array.isArray(integ.stepResults) ? integ.stepResults : [];
   if (!steps.length) return;
+  lines.push('');
+  lines.push(chalk.gray(SEP));
   lines.push(sectionTitle('Integration steps:'));
   for (const st of steps) {
     lines.push(formatIntegrationStepLine(st));
@@ -422,22 +416,27 @@ function formatDatasourceTestRunSummary(envelope, options = {}) {
 /**
  * Default TTY block (header + verdict line + short summary + optional completeness).
  * @param {Object} envelope
- * @param {{ focusCapabilityKey?: string }} [options] - When set (e.g. --capability), append single-cap block (plan §2.3).
+ * @param {{
+ *   focusCapabilityKey?: string,
+ *   includeRefs?: boolean,
+ *   includeDebugExecutionSummary?: boolean
+ * }} [options] - When focusCapabilityKey set (e.g. --capability), append single-cap block (plan §2.3).
+ *   includeDebugExecutionSummary: show dataplane `debug.executionSummary` in header (TTY debug appendix uses CLI `--debug`).
  * @returns {string}
  */
 function formatDatasourceTestRunTTY(envelope, options = {}) {
   if (!envelope || typeof envelope !== 'object') return '';
-  const lines = [...buildTtyMetaLines(envelope)];
+  const lines = [
+    ...buildTtyMetaLines(envelope, {
+      includeDebugExecutionSummary: options.includeDebugExecutionSummary === true
+    })
+  ];
   appendNoCapabilitiesReportedLine(lines, 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 })) {
-    lines.push('');
-  }
+  appendRefsSectionIfEnabled(lines, envelope, options);
   appendValidationIssueLines(lines, envelope);
   appendIntegrationStepLines(lines, envelope);
   const focus = normalizedFocusCapabilityKey(options.focusCapabilityKey);
@@ -447,6 +446,20 @@ function formatDatasourceTestRunTTY(envelope, options = {}) {
   return lines.join('\n');
 }
 
+function appendRefsSectionIfEnabled(lines, envelope, options) {
+  if (options.includeRefs !== true) return;
+  const before = lines.length;
+  lines.push('');
+  lines.push(chalk.gray(SEP));
+  const added = appendReferenceLayoutLines(lines, envelope, { maxRefChars: 160, includeDebugMeta: false });
+  if (added) {
+    lines.push('');
+    return;
+  }
+  // remove the blank + separator when no refs exist
+  lines.length = before;
+}
+
 module.exports = {
   formatDatasourceTestRunSummary,
   formatDatasourceTestRunTTY,

package/lib/utils/datasource-test-run-tty-log.js

@@ -42,7 +42,12 @@ function emitCapabilityScopeDiagnostics(envelope, opts = {}) {
  * @param {string} [options.requestedCapabilityKey]
  */
 function printDatasourceTestRunForTTY(envelope, options = {}) {
-  const displayOpts = { focusCapabilityKey: options.requestedCapabilityKey };
+  const mode = resolveDebugDisplayMode(options.debug);
+  const displayOpts = {
+    focusCapabilityKey: options.requestedCapabilityKey,
+    includeRefs: Boolean(mode),
+    includeDebugExecutionSummary: Boolean(mode)
+  };
   if (options.json) {
     logger.log(JSON.stringify(envelope));
     return;
@@ -52,7 +57,6 @@ function printDatasourceTestRunForTTY(envelope, options = {}) {
   } else {
     logger.log(formatDatasourceTestRunTTY(envelope, displayOpts));
   }
-  const mode = resolveDebugDisplayMode(options.debug);
   if (mode) {
     const appendix = formatDatasourceTestRunDebugBlock(envelope, mode, process.stdout.isTTY);
     if (appendix) logger.log(appendix);

package/lib/utils/datasource-test-run-tty-meta-lines.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview TTY meta header lines for DatasourceTestRun (extracted for max-lines).
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { headerKeyValue } = require('./cli-test-layout-chalk');
+const { pushCapacityOperationsSummaryLines } = require('./datasource-test-run-capacity-operations');
+
+/** @type {number} */
+const DEFAULT_MAX_REF_CHARS = 200;
+
+// UI-only: round float seconds tokens like "1.1713749s" -> "1.171s".
+function formatSecondsText(text) {
+  const txt = String(text);
+  return txt.replace(/(\d+\.\d+)(?=s\b)/g, m => {
+    const n = Number(m);
+    if (!Number.isFinite(n)) return m;
+    return n.toFixed(3);
+  });
+}
+
+/**
+ * @param {string} str
+ * @param {number} maxChars
+ * @returns {string}
+ */
+function truncateRefLine(str, maxChars) {
+  const s = String(str);
+  if (s.length <= maxChars) return s;
+  return `${s.slice(0, Math.max(0, maxChars - 24))}… [+${s.length - maxChars + 24} chars]`;
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaRunWallLine(lines, envelope) {
+  if (envelope.cliWallSeconds === undefined || envelope.cliWallSeconds === null) return;
+  const n = Number(envelope.cliWallSeconds);
+  if (Number.isFinite(n) && n >= 0) {
+    lines.push(`${chalk.gray('Run wall:')} ${chalk.white(`~${n}s`)}`);
+  }
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaCapabilitiesPreviewLine(lines, envelope) {
+  const caps = Array.isArray(envelope.capabilities) ? envelope.capabilities : [];
+  if (caps.length === 0) return;
+  const keys = caps
+    .map(c => (c && c.key !== undefined && c.key !== null ? String(c.key) : ''))
+    .filter(Boolean);
+  if (keys.length === 0) return;
+  const preview = keys.slice(0, 10).join(', ');
+  const more = keys.length > 10 ? ', …' : '';
+  lines.push(`${chalk.gray('Capabilities tested:')} ${chalk.white(`${preview}${more}`)}`);
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaDebugExecutionSummaryLine(lines, envelope) {
+  if (!envelope.debug || typeof envelope.debug !== 'object' || !envelope.debug.executionSummary) return;
+  lines.push(
+    `${chalk.blue.bold('debug.executionSummary:')} ${chalk.white(
+      truncateRefLine(formatSecondsText(envelope.debug.executionSummary), DEFAULT_MAX_REF_CHARS)
+    )}`
+  );
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaRunIdLine(lines, envelope) {
+  const rid = envelope.runId || envelope.testRunId;
+  if (rid) lines.push(`${chalk.gray('Run ID:')} ${chalk.cyan(String(rid))}`);
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function pushTtyMetaReportCompletenessLine(lines, envelope) {
+  if (!envelope.reportCompleteness || envelope.reportCompleteness === 'full') return;
+  lines.push(`${chalk.gray('Report:')} ${chalk.yellow(String(envelope.reportCompleteness))}`);
+}
+
+/**
+ * @param {Object} envelope
+ * @param {(e: Object) => string} formatEnvelopeStatusLine
+ * @param {{ includeDebugExecutionSummary?: boolean }} [options]
+ * @returns {string[]}
+ */
+function buildTtyMetaLines(envelope, formatEnvelopeStatusLine, options = {}) {
+  const includeDebugExecutionSummary = options.includeDebugExecutionSummary === true;
+  const lines = [];
+  lines.push(
+    headerKeyValue('Datasource:', `${envelope.datasourceKey} (${envelope.systemKey})`)
+  );
+  lines.push(headerKeyValue('Run:', String(envelope.runType)));
+  pushTtyMetaRunWallLine(lines, envelope);
+  pushTtyMetaCapabilitiesPreviewLine(lines, envelope);
+  lines.push(formatEnvelopeStatusLine(envelope));
+  pushCapacityOperationsSummaryLines(lines, envelope);
+  if (includeDebugExecutionSummary) {
+    pushTtyMetaDebugExecutionSummaryLine(lines, envelope);
+  }
+  pushTtyMetaRunIdLine(lines, envelope);
+  pushTtyMetaReportCompletenessLine(lines, envelope);
+  return lines;
+}
+
+module.exports = {
+  buildTtyMetaLines
+};

package/lib/utils/error-formatter.js

@@ -265,13 +265,38 @@ function formatSingleError(error, options) {
   return message || `${field}: ${error.message || 'Validation error'}`;
 }
 
+/**
+ * Removes exact duplicate lines while preserving first-seen order (AJV composite schemas often repeat the same message).
+ * @param {string[]} strings
+ * @returns {string[]}
+ */
+function dedupeFormattedMessagesPreserveOrder(strings) {
+  if (!Array.isArray(strings)) {
+    return strings;
+  }
+  const seen = new Set();
+  const out = [];
+  for (const s of strings) {
+    if (typeof s !== 'string') {
+      continue;
+    }
+    if (seen.has(s)) {
+      continue;
+    }
+    seen.add(s);
+    out.push(s);
+  }
+  return out;
+}
+
 /**
  * Formats validation errors into developer-friendly messages
  * Converts technical schema errors into actionable advice
  *
  * @function formatValidationErrors
  * @param {Array} errors - Raw validation errors from Ajv
- * @param {Object} [options] - Optional; pass `{ deploymentManifest }` or `{ rootData }` for RBAC/pattern detail
+ * @param {Object} [options] - Optional; pass `{ deploymentManifest }` or `{ rootData }` for RBAC/pattern detail.
+ *   Pass `{ dedupe: true }` to remove exact duplicate lines (AJV `allOf`/`if-then` often repeats the same message).
  * @returns {Array} Formatted error messages
  *
  * @example
@@ -283,7 +308,11 @@ function formatValidationErrors(errors, options) {
     return ['Unknown validation error'];
   }
 
-  return errors.map((e) => formatSingleError(e, options));
+  const messages = errors.map(e => formatSingleError(e, options));
+  if (options && options.dedupe === true) {
+    return dedupeFormattedMessagesPreserveOrder(messages);
+  }
+  return messages;
 }
 
 /**
@@ -308,6 +337,7 @@ function formatMissingDbPasswordError(appKey, opts = {}) {
 module.exports = {
   formatSingleError,
   formatValidationErrors,
+  dedupeFormattedMessagesPreserveOrder,
   formatMissingDbPasswordError,
   getPatternDescription,
   getValueAtInstancePath,

package/lib/utils/external-readme.js

@@ -137,11 +137,43 @@ function rbacOptionalFilename(normalizedExt) {
   return normalizedExt === '.yaml' || normalizedExt === '.yml' ? 'rbac.yaml' : 'rbac.json';
 }
 
+/**
+ * Word-wraps plain description text for Markdown (MD013 ~80 columns). Keeps blank
+ * lines between paragraphs.
+ * @param {string} text - Raw description
+ * @param {number} [maxLen=80] - Target max line length
+ * @returns {string}
+ */
+function wrapPlainTextForMarkdown(text, maxLen = 80) {
+  if (!text || typeof text !== 'string') return text;
+  const blocks = text.split(/\n\s*\n/);
+  const wrapped = blocks.map((block) => {
+    const flat = block.replace(/\s+/g, ' ').trim();
+    if (!flat) return '';
+    const words = flat.split(' ');
+    const lines = [];
+    let current = '';
+    for (const w of words) {
+      const candidate = current ? `${current} ${w}` : w;
+      if (candidate.length <= maxLen) {
+        current = candidate;
+      } else {
+        if (current) lines.push(current);
+        current = w;
+      }
+    }
+    if (current) lines.push(current);
+    return lines.join('\n');
+  });
+  return wrapped.filter(Boolean).join('\n\n');
+}
+
 function buildExternalReadmeContext(params = {}) {
   const appName = params.appName || params.systemKey || 'external-system';
   const systemKey = params.systemKey || appName;
   const displayName = params.displayName || formatDisplayName(systemKey);
-  const description = params.description || `External system integration for ${systemKey}`;
+  const rawDescription = params.description || `External system integration for ${systemKey}`;
+  const description = wrapPlainTextForMarkdown(rawDescription);
   const systemType = params.systemType || 'openapi';
   const fileExt = params.fileExt !== undefined ? params.fileExt : '.json';
   const normalizedExt = fileExt && fileExt.startsWith('.') ? fileExt : `.${fileExt || 'json'}`;
@@ -186,13 +218,25 @@ function loadExternalReadmeTemplate() {
  * @param {Object} params - Context parameters
  * @returns {string} README content
  */
+/**
+ * Collapses 3+ consecutive newlines to 2 (fixes MD012 from Handlebars spacing).
+ * @param {string} md - Markdown body
+ * @returns {string}
+ */
+function collapseConsecutiveBlankLines(md) {
+  if (!md || typeof md !== 'string') return md;
+  return md.replace(/\n{3,}/g, '\n\n');
+}
+
 function generateExternalReadmeContent(params = {}) {
   const template = loadExternalReadmeTemplate();
   const context = buildExternalReadmeContext(params);
-  return template(context);
+  return collapseConsecutiveBlankLines(template(context));
 }
 
 module.exports = {
   buildExternalReadmeContext,
-  generateExternalReadmeContent
+  generateExternalReadmeContent,
+  wrapPlainTextForMarkdown,
+  collapseConsecutiveBlankLines
 };

package/lib/utils/external-system-readiness-core.js

@@ -214,6 +214,40 @@ function datasourceTestRunToLegacyRow(run) {
   };
 }
 
+/**
+ * Map dataplane **datasourceSummaries** item into legacy probe row shape.
+ * @param {Object} summary
+ * @returns {Object}
+ */
+function datasourceSummaryToLegacyRow(summary) {
+  const key = summary.datasourceKey || summary.datasource_key || 'unknown';
+  const root = String(summary.status || '').toLowerCase();
+  const vStat = String(summary.validationStatus || '').toLowerCase();
+  const issues = Array.isArray(summary.issues) ? summary.issues : [];
+  const { errors, warnings } = partitionDatasourceTestRunIssues(issues);
+  if (vStat === 'warn' && warnings.length === 0) {
+    warnings.push('validation warnings');
+  }
+  const isValid = vStat !== 'fail' && errors.length === 0;
+  const cert = String(summary.certificateStatus || '').toLowerCase();
+  if (cert === 'not_passed' && isValid) {
+    warnings.push('certification not passed');
+  }
+  return {
+    sourceKey: key,
+    key,
+    success: root !== 'fail',
+    skipped: root === 'skipped',
+    validationResults: { isValid, errors, warnings },
+    endpointTestResults: {
+      success: true,
+      endpointReachable: true,
+      message: null,
+      warning: false
+    }
+  };
+}
+
 /**
  * Normalize runtime probe body for Tier B display.
  *
@@ -225,6 +259,7 @@ function datasourceTestRunToLegacyRow(run) {
  * - **Runtime probe (--probe)** uses validation run and returns either:
  *   - legacy `{ results: ExternalDataSourceTestResponse[] }`, or
  *   - canonical **DatasourceTestRun** envelope (single success shape) which we coerce into a legacy row
+ *   - optional **datasourceSummaries** on the envelope for multi-datasource system runs
  *
  * This helper intentionally accepts multiple shapes so the CLI output stays truthful across dataplane versions.
  *
@@ -234,6 +269,10 @@ function datasourceTestRunToLegacyRow(run) {
 function coerceProbeRunToResultRows(probeRaw) {
   if (!probeRaw || typeof probeRaw !== 'object') return [];
   if (Array.isArray(probeRaw.results) && probeRaw.results.length > 0) return probeRaw.results;
+  const summaries = probeRaw.datasourceSummaries;
+  if (Array.isArray(summaries) && summaries.length > 0) {
+    return summaries.map(datasourceSummaryToLegacyRow);
+  }
   if (isDatasourceTestRunEnvelope(probeRaw)) return [datasourceTestRunToLegacyRow(probeRaw)];
   return [];
 }

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

@@ -54,7 +54,7 @@ function logDeployProbeDatasourceSection(probeData) {
   const results = coerceProbeRunToResultRows(probeData);
   const probeSummary = summarizeProbeResults(results);
   logSectionTitle('Runtime Readiness:');
-  logDatasourceTable(probeSummary.rows, probeSummary);
+  logDatasourceTable(probeSummary.rows, probeSummary, 'Per datasource:');
   if (probeSummary.issues.length > 0) {
     logSeparator();
     logSectionTitle('Key Issues:');
@@ -253,10 +253,9 @@ function logDeployReadinessSummary(ctx) {
   logDeployConfigDeploymentRuntime(systemCfg, deploymentOk, probeData, summary, deploymentDetail || null);
 
   logSeparator();
+  logDatasourceTable(summary.rows, summary, probeData ? 'Configured datasources:' : undefined);
   if (probeData) {
     logDeployProbeDatasourceSection(probeData);
-  } else {
-    logDatasourceTable(summary.rows, summary);
   }
 
   logDeployIdentityAndCredentialBlocks(systemCfg, !!probeData);

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

@@ -50,9 +50,10 @@ function verdictLine(v) {
 /**
  * @param {Array<{ key: string, tier: string }>} rows
  * @param {{ ready: number, partial: number, failed: number }} counts
+ * @param {string} [title]
  */
-function logDatasourceTable(rows, counts) {
-  logSectionTitle('Datasources:');
+function logDatasourceTable(rows, counts, title) {
+  logSectionTitle(title && String(title).trim() ? String(title).trim() : 'Datasources:');
   for (const r of rows) {
     const statusLabel = r.tier === 'ready' ? 'Ready' : r.tier === 'failed' ? 'Failed' : 'Partial';
     logger.log(