@aifabrix/builder 2.54.1 → 2.55.2

package/lib/agent-kit/workspace-skeleton.js

@@ -0,0 +1,103 @@
+/**
+ * Copy product-neutral workspace skeleton for agent-kit init.
+ * @fileoverview templates/agent-kit/workspace → target
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('../internal/fs-real-sync');
+const { getKitRoot } = require('./kit-root');
+
+/**
+ * @returns {string}
+ */
+function getWorkspaceTemplateRoot() {
+  return path.join(getKitRoot(), 'workspace');
+}
+
+/**
+ * @param {string} text
+ * @param {{ workspaceName: string, year?: number, copyrightHolder?: string }} vars
+ * @returns {string}
+ */
+function applyPlaceholders(text, vars) {
+  return String(text)
+    .replace(/\{\{workspaceName\}\}/g, vars.workspaceName)
+    .replace(/\{\{year\}\}/g, String(vars.year || new Date().getFullYear()))
+    .replace(/\{\{copyrightHolder\}\}/g, vars.copyrightHolder || 'Copyright Holder');
+}
+
+/**
+ * @param {string} absDir
+ * @param {string} relPrefix
+ * @returns {{ rel: string, abs: string }[]}
+ */
+function listTemplateFiles(absDir, relPrefix) {
+  if (!fs.existsSync(absDir)) {
+    return [];
+  }
+  const out = [];
+  for (const ent of fs.readdirSync(absDir, { withFileTypes: true })) {
+    const rel = relPrefix ? `${relPrefix}/${ent.name}` : ent.name;
+    const abs = path.join(absDir, ent.name);
+    if (ent.isDirectory()) {
+      out.push(...listTemplateFiles(abs, rel));
+    } else if (ent.name !== 'LICENSE.mit') {
+      out.push({ rel, abs });
+    }
+  }
+  return out;
+}
+
+/**
+ * @param {string} targetAbs
+ * @param {{ workspaceName: string, license?: string, dryRun?: boolean }} options
+ * @returns {string[]} written relative paths
+ */
+function writeWorkspaceSkeleton(targetAbs, options) {
+  const written = [];
+  const vars = { workspaceName: options.workspaceName };
+  const root = getWorkspaceTemplateRoot();
+  for (const file of listTemplateFiles(root, '')) {
+    const dest = path.join(targetAbs, file.rel);
+    if (!options.dryRun) {
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      const body = applyPlaceholders(fs.readFileSync(file.abs, 'utf8'), vars);
+      fs.writeFileSync(dest, body, 'utf8');
+    }
+    written.push(file.rel);
+  }
+  if (options.license === 'mit') {
+    const src = path.join(root, 'LICENSE.mit');
+    const dest = path.join(targetAbs, 'LICENSE');
+    if (!options.dryRun && fs.existsSync(src)) {
+      fs.writeFileSync(dest, applyPlaceholders(fs.readFileSync(src, 'utf8'), vars), 'utf8');
+    }
+    written.push('LICENSE');
+  }
+  if (!options.dryRun) {
+    fs.mkdirSync(path.join(targetAbs, 'integration'), { recursive: true });
+    fs.mkdirSync(path.join(targetAbs, 'role-assistant'), { recursive: true });
+  }
+  return written;
+}
+
+/**
+ * @param {string} targetAbs
+ * @returns {boolean}
+ */
+function isNonEmptyDirectory(targetAbs) {
+  if (!fs.existsSync(targetAbs)) {
+    return false;
+  }
+  const entries = fs.readdirSync(targetAbs).filter((name) => name !== '.git');
+  return entries.length > 0;
+}
+
+module.exports = {
+  getWorkspaceTemplateRoot,
+  applyPlaceholders,
+  writeWorkspaceSkeleton,
+  isNonEmptyDirectory
+};

package/lib/api/role-assistant-test-pack.api.js

@@ -0,0 +1,86 @@
+/**
+ * Dataplane Role Assistant test pack CRUD + case status.
+ *
+ * @fileoverview PUT/GET pack and PATCH case status
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { createDataplaneApiClient } = require('./index');
+const { throwIfApiFailed } = require('./api-response-errors');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+
+function packEndpoint(dataplaneUrl, systemIdOrKey, suffix) {
+  const base = String(dataplaneUrl || '').replace(/\/$/, '');
+  const key = encodeURIComponent(systemIdOrKey);
+  return `${base}/api/v1/external/systems/${key}/role-assistant-tests${suffix || ''}`;
+}
+
+function packPath(systemIdOrKey, suffix) {
+  const key = encodeURIComponent(systemIdOrKey);
+  return `/api/v1/external/systems/${key}/role-assistant-tests${suffix || ''}`;
+}
+
+function isMissingPackResponse(res) {
+  return Boolean(res && res.success === false && Number(res.status) === 404);
+}
+
+/**
+ * PUT /api/v1/external/systems/{systemIdOrKey}/role-assistant-tests
+ * @requiresPermission {Dataplane} external-system:update
+ * @async
+ */
+async function upsertRoleAssistantTestPack(dataplaneUrl, authConfig, systemIdOrKey, pack) {
+  const client = createDataplaneApiClient(dataplaneUrl, authConfig);
+  const res = await client.put(packPath(systemIdOrKey), { body: { pack } });
+  throwIfApiFailed(res, {
+    endpointUrl: packEndpoint(dataplaneUrl, systemIdOrKey, '')
+  });
+  return unwrapApiData(res);
+}
+
+/**
+ * GET /api/v1/external/systems/{systemIdOrKey}/role-assistant-tests
+ * @requiresPermission {Dataplane} external-system:read
+ * @async
+ */
+async function getRoleAssistantTestPack(dataplaneUrl, authConfig, systemIdOrKey, options = {}) {
+  const client = createDataplaneApiClient(dataplaneUrl, authConfig);
+  const res = await client.get(packPath(systemIdOrKey));
+  if (options.allowMissing === true && isMissingPackResponse(res)) {
+    return null;
+  }
+  throwIfApiFailed(res, {
+    endpointUrl: packEndpoint(dataplaneUrl, systemIdOrKey, '')
+  });
+  return unwrapApiData(res);
+}
+
+/**
+ * PATCH /api/v1/external/systems/{systemIdOrKey}/role-assistant-tests/cases/{caseId}/status
+ * @requiresPermission {Dataplane} external-system:update
+ * @async
+ */
+async function patchRoleAssistantTestCaseStatus(
+  dataplaneUrl,
+  authConfig,
+  systemIdOrKey,
+  caseId,
+  body
+) {
+  const suffix = `/cases/${encodeURIComponent(caseId)}/status`;
+  const client = createDataplaneApiClient(dataplaneUrl, authConfig);
+  const res = await client.patch(packPath(systemIdOrKey, suffix), { body });
+  throwIfApiFailed(res, {
+    endpointUrl: packEndpoint(dataplaneUrl, systemIdOrKey, suffix)
+  });
+  return unwrapApiData(res);
+}
+
+module.exports = {
+  upsertRoleAssistantTestPack,
+  getRoleAssistantTestPack,
+  patchRoleAssistantTestCaseStatus
+};

package/lib/api/work-search.api.js

@@ -14,6 +14,7 @@ const { unwrapApiData } = require('../utils/external-system-readiness-core');
 const SEARCH_TIMEOUT_MS = 120000;
 const LAYER_B_SYSTEM_KEY = process.env.RUNTIME_ORCHESTRATION_SYSTEM_KEY || 'runtime-orchestration';
 const LAYER_B_TOOLS = Object.freeze({
+  roles: { resourceType: 'work-roles', toolName: 'work_roles.list' },
   skills: { resourceType: 'work-skills', toolName: 'work_skills.get' },
   search: { resourceType: 'work-search', toolName: 'work_search.create' }
 });
@@ -45,19 +46,31 @@ function extractErrorText(res) {
   return parts.join(' ');
 }
 
+/**
+ * MCP execute sometimes wraps a single JSON object as a one-element array.
+ * @param {*} value
+ * @returns {*}
+ */
+function unwrapSingletonObject(value) {
+  if (Array.isArray(value) && value.length === 1 && value[0] && typeof value[0] === 'object') {
+    return value[0];
+  }
+  return value;
+}
+
 function unwrapExecutePayload(res) {
-  const body = unwrapApiData(res);
+  const body = unwrapSingletonObject(unwrapApiData(res));
   if (!body || typeof body !== 'object') {
     return body;
   }
   if (body.result && typeof body.result === 'object') {
-    return body.result;
+    return unwrapSingletonObject(body.result);
   }
   if (body.json && typeof body.json === 'object') {
-    return body.json;
+    return unwrapSingletonObject(body.json);
   }
   if (body.root && typeof body.root === 'object') {
-    return body.root;
+    return unwrapSingletonObject(body.root);
   }
   return body;
 }
@@ -94,6 +107,18 @@ async function executeLayerBTool(dataplaneUrl, authConfig, tool, args = {}) {
   return normalizeLayerBResult(res);
 }
 
+/**
+ * GET-equivalent work.roles for the current caller.
+ * @requiresPermission {Dataplane} Authenticated (oauth2: [])
+ * @async
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @returns {Promise<{ status: number, payload: Object|null, errorText: string, raw: Object }>}
+ */
+async function getWorkRoles(dataplaneUrl, authConfig) {
+  return executeLayerBTool(dataplaneUrl, authConfig, LAYER_B_TOOLS.roles, {});
+}
+
 /**
  * GET-equivalent work.skills for one roleRef.
  * Requests detail=full so search.resourceTypes (executable grammar) is present.
@@ -128,9 +153,11 @@ module.exports = {
   SEARCH_TIMEOUT_MS,
   buildLayerBExecutePath,
   extractErrorText,
+  unwrapSingletonObject,
   unwrapExecutePayload,
   normalizeLayerBResult,
   executeLayerBTool,
+  getWorkRoles,
   getWorkSkills,
   searchWork
 };

package/lib/api/work.api.js

@@ -7,7 +7,9 @@
 'use strict';
 
 const { createDataplaneApiClient } = require('./index');
+const { throwIfApiFailed } = require('./api-response-errors');
 const { unwrapApiData } = require('../utils/external-system-readiness-core');
+const { pickHumanRespondBody } = require('../role-assistant/test-runner-respond-body');
 
 /** Work Hub plan create runs LLM planning; 30s default is too short under load/reload. */
 const WORK_PLAN_TIMEOUT_MS = 120000;
@@ -59,7 +61,10 @@ function assertObjectShape(value, fallbackMessage) {
  */
 async function startWorkIntent(dataplaneUrl, authConfig, body) {
   const client = createDataplaneApiClient(dataplaneUrl, authConfig);
-  const res = await client.post('/api/v1/work/start', { body });
+  const res = await client.post('/api/v1/work/start', {
+    body,
+    timeoutMs: WORK_PLAN_TIMEOUT_MS
+  });
   if (res && res.success === false) {
     throw new Error(extractApiErrorMessage(res, 'work.start request failed'));
   }
@@ -70,7 +75,7 @@ async function startWorkIntent(dataplaneUrl, authConfig, body) {
 
 /**
  * GET /api/v1/work/executions/{processExecutionId}
- * @requiresPermission {Dataplane} worker-task:read
+ * @requiresPermission {Dataplane} worker:read
  * @async
  * @param {string} dataplaneUrl
  * @param {Object} authConfig
@@ -80,12 +85,13 @@ async function startWorkIntent(dataplaneUrl, authConfig, body) {
 async function getWorkExecutionStatus(dataplaneUrl, authConfig, processExecutionId) {
   const client = createDataplaneApiClient(dataplaneUrl, authConfig);
   const encodedId = encodeURIComponent(String(processExecutionId));
-  const res = await client.get(`/api/v1/work/executions/${encodedId}`, {
+  const endpoint = `/api/v1/work/executions/${encodedId}`;
+  const res = await client.get(endpoint, {
     timeoutMs: WORK_TASK_TIMEOUT_MS
   });
-  if (res && res.success === false) {
-    throw new Error(extractApiErrorMessage(res, 'work.status request failed'));
-  }
+  throwIfApiFailed(res, {
+    endpointUrl: `${String(dataplaneUrl || '').replace(/\/$/, '')}${endpoint}`
+  });
   const unwrapped = unwrapWorkPayload(res);
   assertObjectShape(unwrapped, 'work.status returned an unexpected response shape');
   return unwrapped;
@@ -105,7 +111,7 @@ async function respondWorkExecution(dataplaneUrl, authConfig, processExecutionId
   const client = createDataplaneApiClient(dataplaneUrl, authConfig);
   const encodedId = encodeURIComponent(String(processExecutionId));
   const res = await client.post(`/api/v1/work/executions/${encodedId}/respond`, {
-    body,
+    body: pickHumanRespondBody(body),
     timeoutMs: WORK_TASK_TIMEOUT_MS
   });
   if (res && res.success === false) {
@@ -143,7 +149,7 @@ async function continueWorkExecution(dataplaneUrl, authConfig, processExecutionI
 
 /**
  * GET /api/v1/work/executions/{processExecutionId}/result
- * @requiresPermission {Dataplane} worker-task:read
+ * @requiresPermission {Dataplane} worker:read
  * @async
  * @param {string} dataplaneUrl
  * @param {Object} authConfig
@@ -154,6 +160,7 @@ async function continueWorkExecution(dataplaneUrl, authConfig, processExecutionI
 async function getWorkExecutionResult(dataplaneUrl, authConfig, processExecutionId, query = {}) {
   const client = createDataplaneApiClient(dataplaneUrl, authConfig);
   const encodedId = encodeURIComponent(String(processExecutionId));
+  const endpoint = `/api/v1/work/executions/${encodedId}/result`;
   const params = {};
   if (query && typeof query === 'object') {
     if (query.requestedDepth) {
@@ -166,13 +173,13 @@ async function getWorkExecutionResult(dataplaneUrl, authConfig, processExecution
       params.projection = String(query.projection);
     }
   }
-  const res = await client.get(`/api/v1/work/executions/${encodedId}/result`, {
+  const res = await client.get(endpoint, {
     params,
     timeoutMs: WORK_TASK_TIMEOUT_MS
   });
-  if (res && res.success === false) {
-    throw new Error(extractApiErrorMessage(res, 'work.result request failed'));
-  }
+  throwIfApiFailed(res, {
+    endpointUrl: `${String(dataplaneUrl || '').replace(/\/$/, '')}${endpoint}`
+  });
   const unwrapped = unwrapWorkPayload(res);
   assertObjectShape(unwrapped, 'work.result returned an unexpected response shape');
   return unwrapped;

package/lib/app/deploy.js

@@ -23,6 +23,7 @@ const pushUtils = require('../deployment/push');
 const SEP = chalk.gray('────────────────────────────────────────');
 const logger = require('../utils/logger');
 const { detectAppType, getBuilderPath, getIntegrationPath } = require('../utils/paths');
+const { offerCreateFromTemplateIfMissing } = require('./offer-create-from-template');
 const { checkApplicationExists } = require('../utils/app-existence');
 const { loadDeploymentConfig } = require('./deploy-config');
 const { logOfflinePathWhenType } = require('../utils/cli-utils');
@@ -462,7 +463,7 @@ async function executeDeployPipeline(appName, options) {
  * @param {boolean} [options.poll] - Poll for deployment status
  * @param {number} [options.pollInterval] - Polling interval in milliseconds
  * @param {number} [options.pollMaxAttempts] - Max polling attempts
- * @returns {Promise<{ result: Object, usedExternalDeploy: boolean }>} Deployment result and whether external deploy was used
+ * @returns {Promise<{ result: Object, usedExternalDeploy: boolean, appKey: string }>} Deployment result and whether external deploy was used
  * @throws {Error} If deployment fails
  *
  * Controller and environment come from config.yaml (set via aifabrix login or aifabrix auth config).
@@ -473,16 +474,18 @@ async function executeDeployPipeline(appName, options) {
 async function deployApp(appName, options = {}) {
   let controllerUrl = null;
   let usedExternalDeploy = false;
+  let resolvedName = appName;
 
   try {
     assertDeployNotProtectionScope(appName);
     validateAppName(appName);
-    const pipeline = await executeDeployPipeline(appName, options);
+    resolvedName = await offerCreateFromTemplateIfMissing(appName, options);
+    const pipeline = await executeDeployPipeline(resolvedName, options);
     controllerUrl = pipeline.controllerUrl ?? null;
     usedExternalDeploy = pipeline.usedExternalDeploy;
-    return { result: pipeline.result, usedExternalDeploy };
+    return { result: pipeline.result, usedExternalDeploy, appKey: resolvedName };
   } catch (error) {
-    await handleDeploymentError(error, appName, controllerUrl, usedExternalDeploy);
+    await handleDeploymentError(error, resolvedName, controllerUrl, usedExternalDeploy);
   }
 }
 

package/lib/app/list-external-systems.js

@@ -15,6 +15,7 @@ const { listExternalSystems } = require('../api/external-systems.api');
 const { formatApiError } = require('../utils/api-error-handler');
 const { getListAuthToken } = require('./list');
 const logger = require('../utils/logger');
+const { formatLifecycleLabel } = require('../utils/external-system-readiness-compact-display');
 
 /**
  * Normalize list response shapes from the dataplane API client.
@@ -56,7 +57,7 @@ function displayExternalSystems(systems, environment, dataplaneUrl, json) {
   systems.forEach((system) => {
     const key = system.key || system.systemKey || system.id || '—';
     const displayName = system.displayName || key;
-    const status = system.status || 'unknown';
+    const status = formatLifecycleLabel(system.status || 'unknown');
     logger.log(`✔ ${chalk.cyan(key)} - ${displayName} (${status})`);
   });
   logger.log(chalk.gray('  To show details: aifabrix show <systemKey> --online\n'));

package/lib/app/offer-create-from-template.js

@@ -0,0 +1,184 @@
+/**
+ * Offer to materialize a missing app from shipped application templates.
+ *
+ * @fileoverview Interactive create-from-template before deploy when the app is not on disk
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { metadata } = require('../utils/cli-test-layout-chalk');
+const { listAvailableTemplates } = require('../validation/template');
+const { findExistingAppType } = require('../utils/paths');
+const { ensureAppFromTemplate } = require('../commands/up-common');
+
+/**
+ * @param {Object} [options]
+ * @returns {boolean}
+ */
+function assumeYesCreate(options = {}) {
+  return options.yes === true || options.assumeYes === true;
+}
+
+/**
+ * @param {Object} [deps]
+ * @returns {boolean}
+ */
+function isInteractiveCreate(deps = {}) {
+  if (process.env.CI === 'true' || process.env.CI === '1') {
+    return false;
+  }
+  if (typeof deps.isTty === 'function') {
+    return Boolean(deps.isTty());
+  }
+  return Boolean(process.stdin && process.stdin.isTTY);
+}
+
+/**
+ * @param {string[]} templates
+ * @returns {string}
+ */
+function formatTemplateNames(templates) {
+  return templates.join(', ');
+}
+
+/**
+ * @param {string} appName
+ * @param {string[]} templates
+ * @returns {Error}
+ */
+function buildMissingAppError(appName, templates) {
+  const listed = templates.length > 0
+    ? `Shipped templates: ${formatTemplateNames(templates)}.`
+    : 'No shipped application templates were found.';
+  const hint = templates.includes(appName)
+    ? `Create it with: aifabrix deploy ${appName} --yes`
+    : 'Pass a matching template name, or create the app first.';
+  return new Error(
+    `App '${appName}' was not found under integration/ or builder/. ${listed} ${hint}`
+  );
+}
+
+/**
+ * @param {string} appName
+ * @param {Function} promptFn
+ * @returns {Promise<boolean>}
+ */
+async function confirmCreateMatchingTemplate(appName, promptFn) {
+  const ask = promptFn || ((qs) => require('inquirer').prompt(qs));
+  const { create } = await ask([{
+    type: 'confirm',
+    name: 'create',
+    message: `App '${appName}' is not available. Create it from the shipped '${appName}' template?`,
+    default: true
+  }]);
+  return Boolean(create);
+}
+
+/**
+ * @param {string[]} templates
+ * @param {Function} promptFn
+ * @returns {Promise<string|null>}
+ */
+async function pickShippedTemplate(templates, promptFn) {
+  const ask = promptFn || ((qs) => require('inquirer').prompt(qs));
+  const { template } = await ask([{
+    type: 'list',
+    name: 'template',
+    message: 'App was not found. Create from which shipped application template?',
+    choices: [
+      ...templates.map((name) => ({ name, value: name })),
+      { name: 'Cancel', value: null }
+    ]
+  }]);
+  return template || null;
+}
+
+/**
+ * @param {string} appName
+ * @param {Object} [deps]
+ * @returns {Promise<string>}
+ */
+async function materializeShippedTemplate(appName, deps = {}) {
+  const copy = deps.ensureAppFromTemplate || ensureAppFromTemplate;
+  await copy(appName);
+  return appName;
+}
+
+/**
+ * @param {string} appName
+ * @param {string[]} templates
+ * @param {Object} options
+ * @param {Object} deps
+ * @returns {Promise<string>}
+ */
+async function createMatchingTemplateApp(appName, templates, options, deps) {
+  if (assumeYesCreate(options)) {
+    return materializeShippedTemplate(appName, deps);
+  }
+  if (!isInteractiveCreate(deps)) {
+    throw buildMissingAppError(appName, templates);
+  }
+  const ok = await confirmCreateMatchingTemplate(appName, deps.prompt);
+  if (!ok) {
+    throw buildMissingAppError(appName, templates);
+  }
+  return materializeShippedTemplate(appName, deps);
+}
+
+/**
+ * @param {string} appName
+ * @param {string[]} templates
+ * @param {Object} options
+ * @param {Object} deps
+ * @returns {Promise<string>}
+ */
+async function createPickedTemplateApp(appName, templates, options, deps) {
+  if (assumeYesCreate(options) || !isInteractiveCreate(deps) || templates.length === 0) {
+    throw buildMissingAppError(appName, templates);
+  }
+  const chosen = await pickShippedTemplate(templates, deps.prompt);
+  if (!chosen) {
+    throw buildMissingAppError(appName, templates);
+  }
+  if (chosen !== appName) {
+    logger.log(metadata(
+      `Creating '${chosen}' from shipped template (requested '${appName}' was not found).`
+    ));
+  }
+  await materializeShippedTemplate(chosen, deps);
+  return chosen;
+}
+
+/**
+ * If the app is missing locally, offer to create it from shipped templates.
+ *
+ * @async
+ * @function offerCreateFromTemplateIfMissing
+ * @param {string} appName - Requested app or system key
+ * @param {Object} [options] - CLI options (`yes` skips the confirm when the name matches a template)
+ * @param {Object} [deps] - Test seams (prompt, isTty, listTemplates, findExisting, ensureAppFromTemplate)
+ * @returns {Promise<string>} App key to continue with (may differ if the user picked another template)
+ * @throws {Error} When the app is missing and the user declines or cannot be prompted
+ */
+async function offerCreateFromTemplateIfMissing(appName, options = {}, deps = {}) {
+  const findExisting = deps.findExisting || findExistingAppType;
+  if (findExisting(appName, options)) {
+    return appName;
+  }
+  const listTemplates = deps.listTemplates || listAvailableTemplates;
+  const templates = await listTemplates();
+  if (templates.includes(appName)) {
+    return createMatchingTemplateApp(appName, templates, options, deps);
+  }
+  return createPickedTemplateApp(appName, templates, options, deps);
+}
+
+module.exports = {
+  offerCreateFromTemplateIfMissing,
+  buildMissingAppError,
+  assumeYesCreate,
+  isInteractiveCreate
+};

package/lib/app/show-display.js

@@ -11,6 +11,11 @@
 
 const chalk = require('chalk');
 const logger = require('../utils/logger');
+const { formatCredentialShowLine } = require('../utils/authentication-slot-show');
+const {
+  formatConnectedSystemLifecycleLabel,
+  formatLifecycleLabel
+} = require('../utils/external-system-readiness-compact-display');
 
 function logSourceAndHeader(summary) {
   const isOffline = summary.source === 'offline';
@@ -93,14 +98,36 @@ function logApplicationFields(a) {
   logApplicationOptional(a);
 }
 
+/**
+ * Draft / Published / Archived only — never controller `active`.
+ * @param {Object} a
+ * @param {Object} [summary]
+ * @returns {string|null}
+ */
+function resolveExternalApplicationStatusLabel(a, summary) {
+  const ext = summary && summary.externalSystem;
+  const fromDataplane = ext && !ext.error ? (ext.status || ext.dataplaneStatus) : null;
+  return formatConnectedSystemLifecycleLabel(fromDataplane || a.status);
+}
+
+function logExternalApplicationStatus(a, summary) {
+  const label = resolveExternalApplicationStatusLabel(a, summary);
+  if (label) logger.log(`  Status:        ${label}`);
+}
+
+function formatDataplaneStatusDisplay(status) {
+  if (status === undefined || status === null || status === '' || status === '—') return '—';
+  return formatConnectedSystemLifecycleLabel(status) || formatLifecycleLabel(status);
+}
+
 /** Application section for online + external: Key, Display name, Description, Deployment, Status (no Type; Dataplane block follows). */
-function logApplicationFieldsOnlineExternal(a) {
+function logApplicationFieldsOnlineExternal(a, summary) {
   logger.log('🧷 Application - external');
   logger.log(`  Key:           ${a.key ?? '—'}`);
   logger.log(`  Display name:  ${a.displayName ?? '—'}`);
   logger.log(`  Description:   ${a.description ?? '—'}`);
   logger.log('  Deployment:    —');
-  if (a.status !== undefined && a.status !== '—') logger.log(`  Status:        ${a.status}`);
+  logExternalApplicationStatus(a, summary);
 }
 
 /** Application section for offline + external: Key, Display name, Description, Deployment, Status, Version when present. */
@@ -110,7 +137,7 @@ function logApplicationFieldsOfflineExternal(a) {
   logger.log(`  Display name:  ${a.displayName ?? '—'}`);
   logger.log(`  Description:   ${a.description ?? '—'}`);
   logger.log('  Deployment:    —');
-  if (a.status !== undefined && a.status !== '—') logger.log(`  Status:        ${a.status}`);
+  logExternalApplicationStatus(a);
   if (a.version !== undefined && a.version !== null) logger.log(`  Version:       ${a.version}`);
 }
 
@@ -129,7 +156,7 @@ function logApplicationSection(a, summary) {
   const onlineExternal = summary.source === 'online' && isExternal;
   const offlineExternal = summary.source === 'offline' && isExternal;
   if (onlineExternal) {
-    logApplicationFieldsOnlineExternal(a);
+    logApplicationFieldsOnlineExternal(a, summary);
   } else if (offlineExternal) {
     logApplicationFieldsOfflineExternal(a);
   } else {
@@ -205,8 +232,8 @@ function logDatabasesSection(dbNames) {
 function logExternalSystemMain(ext) {
   logger.log('🧩 Dataplane');
   logger.log(`  Version:       ${ext.version ?? '—'}`);
-  logger.log(`  Credential:    ${ext.credentialId ?? '—'}`);
-  logger.log(`  Status:        ${ext.status ?? '—'}`);
+  logger.log(`  Credential:    ${formatCredentialShowLine(ext)}`);
+  logger.log(`  Status:        ${formatDataplaneStatusDisplay(ext.status)}`);
   logger.log(`  API docs:      ${ext.openApiDocsPageUrl ?? ext.apiDocumentUrl ?? '—'}`);
   logger.log(`  MCP server:    ${ext.mcpServerUrl ?? '—'}`);
   logger.log(`  OpenAPI spec:  ${ext.apiDocumentUrl ?? '—'}`);