@aifabrix/builder 2.53.1 → 2.55.0

package/lib/role-assistant/test-cases-search-graph.js

@@ -0,0 +1,122 @@
+/**
+ * Graph hop assertions for expected.search (one-level related records).
+ *
+ * @fileoverview Evaluate graphDepth, relatedTypes, and related.minRows
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function relatedRows(payload, resourceType) {
+  const related = asObject(asObject(payload).related);
+  if (!Object.prototype.hasOwnProperty.call(related, resourceType)) {
+    return null;
+  }
+  const bundle = related[resourceType];
+  if (Array.isArray(bundle)) {
+    return bundle;
+  }
+  if (bundle && Array.isArray(bundle.data)) {
+    return bundle.data;
+  }
+  return [];
+}
+
+function relatedMeta(payload, resourceType) {
+  const bundle = asObject(asObject(payload).related)[resourceType];
+  return asObject(asObject(bundle).meta);
+}
+
+function evaluateGraphDepth(expectedSearch, meta) {
+  if (!Number.isFinite(Number(expectedSearch.graphDepth))) {
+    return null;
+  }
+  const expected = Number(expectedSearch.graphDepth);
+  const actual = Number(meta.graphDepth);
+  const passed = actual === expected;
+  return {
+    id: 'expected.search.graphDepth',
+    passed,
+    message: passed
+      ? `Search graphDepth matched ${expected}.`
+      : `Search graphDepth expected ${expected} but got ${Number.isFinite(actual) ? actual : 'none'}.`
+  };
+}
+
+function evaluateRelatedTypes(expectedTypes, meta) {
+  if (!Array.isArray(expectedTypes) || expectedTypes.length === 0) {
+    return [];
+  }
+  const observed = Array.isArray(meta.relatedTypes) ? meta.relatedTypes.map(String) : [];
+  return expectedTypes.map((item) => {
+    const key = String(item || '').trim();
+    const passed = Boolean(key && observed.includes(key));
+    return {
+      id: `expected.search.relatedTypes:${key}`,
+      passed,
+      message: passed
+        ? `Search relatedTypes included "${key}".`
+        : `Search relatedTypes did not include "${key}".`
+    };
+  });
+}
+
+function evaluateRelatedHop(resourceType, spec, payload) {
+  const assertions = [];
+  const rows = relatedRows(payload, resourceType);
+  if (Number.isFinite(Number(spec.minRows))) {
+    const minRows = Number(spec.minRows);
+    if (rows === null) {
+      assertions.push({
+        id: `expected.search.related.${resourceType}.minRows`,
+        passed: false,
+        message: `Related "${resourceType}" was omitted from the search graph.`
+      });
+    } else {
+      const passed = rows.length >= minRows;
+      assertions.push({
+        id: `expected.search.related.${resourceType}.minRows`,
+        passed,
+        message: passed
+          ? `Related "${resourceType}" returned at least ${minRows} row(s).`
+          : `Related "${resourceType}" returned ${rows.length} row(s); expected at least ${minRows}.`
+      });
+    }
+  }
+  if (spec.resultMode) {
+    const actual = String(relatedMeta(payload, resourceType).resultMode || '');
+    const passed = rows !== null && actual === String(spec.resultMode);
+    assertions.push({
+      id: `expected.search.related.${resourceType}.resultMode`,
+      passed,
+      message: passed
+        ? `Related "${resourceType}" resultMode matched "${spec.resultMode}".`
+        : `Related "${resourceType}" resultMode expected "${spec.resultMode}" but got "${actual || 'omitted'}".`
+    });
+  }
+  return assertions;
+}
+
+function evaluateSearchGraphExpectations(expectedSearch, payload, meta) {
+  const assertions = [];
+  const depth = evaluateGraphDepth(expectedSearch, meta);
+  if (depth) {
+    assertions.push(depth);
+  }
+  assertions.push(...evaluateRelatedTypes(expectedSearch.relatedTypes, meta));
+  const related = asObject(expectedSearch.related);
+  for (const resourceType of Object.keys(related)) {
+    const spec = asObject(related[resourceType]);
+    assertions.push(...evaluateRelatedHop(resourceType, spec, payload));
+  }
+  return assertions;
+}
+
+module.exports = {
+  evaluateSearchGraphExpectations
+};

package/lib/role-assistant/test-cases-search.js

@@ -0,0 +1,247 @@
+/**
+ * Assertions for work.skills / work.search role-assistant cases.
+ *
+ * @fileoverview Evaluate expected.search and expected.skills against Layer B results
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { operationKeys } = require('./test-runner-search');
+const { skillsEnvelope } = require('../search/search-skills');
+const { evaluateSearchGraphExpectations } = require('./test-cases-search-graph');
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function searchRows(payload) {
+  const body = asObject(payload);
+  if (Array.isArray(body.data)) {
+    return body.data;
+  }
+  return [];
+}
+
+function searchMeta(payload) {
+  const body = asObject(payload);
+  return asObject(body.meta);
+}
+
+function errorHaystack(searchObs) {
+  const payload = asObject(searchObs.payload);
+  return [
+    searchObs.errorText,
+    payload.error,
+    payload.detail,
+    payload.title,
+    payload.message
+  ]
+    .filter((row) => typeof row === 'string')
+    .join(' ');
+}
+
+function evaluateStatusCode(expectedCode, actualCode) {
+  if (!Number.isFinite(Number(expectedCode))) {
+    return null;
+  }
+  const expected = Number(expectedCode);
+  const actual = Number(actualCode);
+  const passed = actual === expected;
+  return {
+    id: 'expected.search.statusCode',
+    passed,
+    message: passed
+      ? `Search HTTP status matched ${expected}.`
+      : `Search HTTP status expected ${expected} but got ${actual}.`
+  };
+}
+
+function evaluateErrorContains(needle, haystack) {
+  if (typeof needle !== 'string' || !needle.trim()) {
+    return null;
+  }
+  const passed = String(haystack || '').toLowerCase().includes(needle.trim().toLowerCase());
+  return {
+    id: 'expected.search.errorContains',
+    passed,
+    message: passed
+      ? `Search error contained "${needle.trim()}".`
+      : `Search error did not contain "${needle.trim()}".`
+  };
+}
+
+function evaluateSearchShape(expectedSearch, searchObs) {
+  const assertions = [];
+  const meta = searchMeta(searchObs.payload);
+  const rows = searchRows(searchObs.payload);
+  if (expectedSearch.resultMode) {
+    const actual = String(meta.resultMode || '');
+    const passed = actual === String(expectedSearch.resultMode);
+    assertions.push({
+      id: 'expected.search.resultMode',
+      passed,
+      message: passed
+        ? `Search resultMode matched "${expectedSearch.resultMode}".`
+        : `Search resultMode expected "${expectedSearch.resultMode}" but got "${actual}".`
+    });
+  }
+  if (expectedSearch.operation) {
+    const actual = String(meta.operation || searchObs.arguments?.operation || '');
+    const passed = actual === String(expectedSearch.operation);
+    assertions.push({
+      id: 'expected.search.operation',
+      passed,
+      message: passed
+        ? `Search operation matched "${expectedSearch.operation}".`
+        : `Search operation expected "${expectedSearch.operation}" but got "${actual}".`
+    });
+  }
+  if (Number.isFinite(Number(expectedSearch.minRows))) {
+    const minRows = Number(expectedSearch.minRows);
+    const passed = rows.length >= minRows;
+    assertions.push({
+      id: 'expected.search.minRows',
+      passed,
+      message: passed
+        ? `Search returned at least ${minRows} row(s).`
+        : `Search returned ${rows.length} row(s); expected at least ${minRows}.`
+    });
+  }
+  return assertions;
+}
+
+function evaluateSearchExpectations(expectedSearch, observation) {
+  if (!expectedSearch || typeof expectedSearch !== 'object' || Array.isArray(expectedSearch)) {
+    return [];
+  }
+  const searchObs = asObject(observation.search);
+  const assertions = [];
+  const statusAssertion = evaluateStatusCode(expectedSearch.statusCode, searchObs.status);
+  if (statusAssertion) {
+    assertions.push(statusAssertion);
+  }
+  const errorAssertion = evaluateErrorContains(
+    expectedSearch.errorContains,
+    errorHaystack(searchObs)
+  );
+  if (errorAssertion) {
+    assertions.push(errorAssertion);
+  }
+  assertions.push(...evaluateSearchShape(expectedSearch, searchObs));
+  assertions.push(
+    ...evaluateSearchGraphExpectations(
+      expectedSearch,
+      searchObs.payload,
+      searchMeta(searchObs.payload)
+    )
+  );
+  return assertions;
+}
+
+function skillsResourceEntry(skillsPayload, resourceType) {
+  const root = skillsEnvelope(skillsPayload) || asObject(skillsPayload);
+  const rts = asObject(asObject(root).search).resourceTypes;
+  return asObject(asObject(rts)[resourceType]);
+}
+
+function evaluateSkillsOperations(expectedOps, spec) {
+  if (!Array.isArray(expectedOps) || expectedOps.length === 0) {
+    return [];
+  }
+  const observed = new Set(operationKeys(spec));
+  return expectedOps.map((operation) => {
+    const key = String(operation || '').trim();
+    const passed = observed.has(key);
+    return {
+      id: `expected.skills.operations:${key}`,
+      passed,
+      message: passed
+        ? `Search grammar published operation "${key}".`
+        : `Search grammar did not publish operation "${key}".`
+    };
+  });
+}
+
+function publishedFilterNames(spec) {
+  const names = new Set(Object.keys(asObject(spec.fields)));
+  const operations = Array.isArray(spec.operations) ? spec.operations : [];
+  for (const item of operations) {
+    const filters = item && typeof item === 'object' ? item.filters : null;
+    if (!Array.isArray(filters)) {
+      continue;
+    }
+    for (const name of filters) {
+      if (typeof name === 'string' && name.trim()) {
+        names.add(name.trim());
+      }
+    }
+  }
+  return names;
+}
+
+function evaluateSkillsFilterFields(expectedFields, spec) {
+  if (!Array.isArray(expectedFields) || expectedFields.length === 0) {
+    return [];
+  }
+  const published = publishedFilterNames(spec);
+  return expectedFields.map((name) => {
+    const key = String(name || '').trim();
+    const passed = Boolean(key && published.has(key));
+    return {
+      id: `expected.skills.filterFields:${key}`,
+      passed,
+      message: passed
+        ? `Search grammar published filter field "${key}".`
+        : `Search grammar did not publish filter field "${key}".`
+    };
+  });
+}
+
+function evaluateSkillsExpectations(expectedSkills, observation) {
+  if (!expectedSkills || typeof expectedSkills !== 'object' || Array.isArray(expectedSkills)) {
+    return [];
+  }
+  const skillsObs = asObject(observation.skills);
+  const payload = skillsObs.payload;
+  const resourceType = String(expectedSkills.resourceType || '').trim();
+  const spec = resourceType ? skillsResourceEntry(payload, resourceType) : {};
+  const assertions = [];
+  if (resourceType) {
+    const passed = Object.keys(spec).length > 0;
+    assertions.push({
+      id: 'expected.skills.resourceType',
+      passed,
+      message: passed
+        ? `work.skills published resourceType "${resourceType}".`
+        : `work.skills did not publish resourceType "${resourceType}".`
+    });
+  }
+  if (expectedSkills.operationRequired === false) {
+    assertions.push({
+      id: 'expected.skills.operationRequired',
+      passed: true,
+      skip: true,
+      kind: 'skip',
+      message: 'operationRequired is false — check skipped.'
+    });
+  } else if (expectedSkills.operationRequired === true) {
+    const passed = spec.operationRequired === true;
+    assertions.push({
+      id: 'expected.skills.operationRequired',
+      passed,
+      message: passed
+        ? 'work.skills marked operationRequired for this resourceType.'
+        : 'work.skills did not mark operationRequired for this resourceType.'
+    });
+  }
+  assertions.push(...evaluateSkillsOperations(expectedSkills.operations, spec));
+  assertions.push(...evaluateSkillsFilterFields(expectedSkills.filterFields, spec));
+  return assertions;
+}
+
+module.exports = {
+  evaluateSearchExpectations,
+  evaluateSkillsExpectations
+};

package/lib/role-assistant/test-cases.js

@@ -8,11 +8,14 @@ const path = require('path');
 const fs = require('../internal/fs-real-sync');
 const yaml = require('js-yaml');
 const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
-const { VERDICT } = require('../lifecycle/product-model');
 const {
   buildHonestyObservation,
   evaluateHonestyExpectations
 } = require('./test-cases-honesty');
+const {
+  SUPPORTED_LIFECYCLE_STATES,
+  deriveLifecycleState
+} = require('./test-cases-lifecycle');
 function loadNodeFsSnapshot() {
   if (global.__AIFABRIX_NODE_FS_UNMOCKED__) {
     return global.__AIFABRIX_NODE_FS_UNMOCKED__;
@@ -22,32 +25,6 @@ function loadNodeFsSnapshot() {
     : require('node:fs');
 }
 const nodeFs = loadNodeFsSnapshot();
-const SUPPORTED_LIFECYCLE_STATES = new Set(['completed', 'question', 'approval-required', 'dependency', 'safe-stop', 'rejected', 'failed']);
-const LIFECYCLE_STATE_ALIASES = Object.freeze({
-  completed: ['completed', 'complete', 'done', 'success', 'verified'],
-  question: ['question', 'question_required', 'awaiting_question', 'pending_question'],
-  'approval-required': ['approval_required', 'awaiting_approval', 'pending_approval', 'requires_approval'],
-  dependency: ['dependency', 'dependency_wait', 'dependency_blocked', 'awaiting_dependency'],
-  'safe-stop': ['safe_stop', 'safe_stopped', 'policy_blocked', 'halted', 'paused'],
-  rejected: ['rejected', 'denied', 'declined', 'policy_rejected'],
-  failed: ['failed', 'error', 'errored', 'timeout', 'cancelled', 'canceled']
-});
-
-const WORK_STATUS_TO_LIFECYCLE = Object.freeze({
-  completed: 'completed', waiting: 'question', running: 'dependency', stopped: 'safe-stop'
-});
-const WAIT_REASON_TO_LIFECYCLE = Object.freeze({
-  ask: 'question', approval: 'approval-required', ownerroute: 'dependency',
-  realityconfirm: 'question', knowledgeconfirm: 'question'
-});
-const WORKER_TASK_STATUS_TO_LIFECYCLE = Object.freeze({
-  draft: 'dependency', pendingapproval: 'approval-required', approved: 'dependency',
-  running: 'dependency', completed: 'completed', failed: 'failed',
-  cancelled: 'rejected', canceled: 'rejected'
-});
-const WORKER_APPROVAL_STATE_TO_LIFECYCLE = Object.freeze({
-  pending: 'approval-required', approved: 'dependency', rejected: 'rejected'
-});
 function safeExistsSync(filePath) {
   // Prefer unmocked node:fs so Jest worker fs mocks cannot hide real temp files.
   return nodeFs.existsSync(filePath) || fs.existsSync(filePath);
@@ -98,21 +75,55 @@ function normalizeCaseFromFile(filePath, parsed) {
   }
   return {
     caseId,
+    executionPath: parsed.executionPath,
+    roleRef: parsed.roleRef,
+    businessRoleRef: parsed.businessRoleRef,
     input: parsed.input || {},
     answers: Array.isArray(parsed.answers) ? parsed.answers : [],
     approvals: Array.isArray(parsed.approvals) ? parsed.approvals : [],
     expected,
+    metadata: parsed.metadata && typeof parsed.metadata === 'object' ? parsed.metadata : {},
+    preflight: parsed.preflight && typeof parsed.preflight === 'object' ? parsed.preflight : {},
     sourceFile: filePath
   };
 }
 
-function listTestCaseFiles(testsDir) {
-  if (!safeExistsSync(testsDir)) {
+function listYamlFileNames(dirPath) {
+  if (!safeExistsSync(dirPath)) {
     return [];
   }
-  return safeReaddirSync(testsDir)
+  return safeReaddirSync(dirPath)
     .filter((entry) => /\.(ya?ml)$/i.test(entry))
-    .map((entry) => path.join(testsDir, entry));
+    .map((entry) => path.join(dirPath, entry));
+}
+
+function safeIsDirectory(dirPath) {
+  try {
+    if (nodeFs.existsSync(dirPath)) {
+      return nodeFs.statSync(dirPath).isDirectory();
+    }
+    return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function listTestCaseFiles(testsDir) {
+  const files = listYamlFileNames(testsDir);
+  if (!safeExistsSync(testsDir)) {
+    return files;
+  }
+  for (const entry of safeReaddirSync(testsDir)) {
+    if (String(entry).startsWith('.')) {
+      continue;
+    }
+    const child = path.join(testsDir, entry);
+    if (!safeIsDirectory(child)) {
+      continue;
+    }
+    files.push(...listYamlFileNames(child));
+  }
+  return files;
 }
 
 function looksLikePathSelector(selector) {
@@ -169,150 +180,11 @@ function loadRoleAssistantTestCase(roleKey, selector, options = {}) {
     throw new Error(`Role assistant test case ${lookup} not found in ${testsDir}`);
   }
   const parsed = parseCaseYamlFile(filePath);
+  const { assertTestCaseDocument } = require('./test-case-validate');
+  assertTestCaseDocument(parsed, filePath);
   return normalizeCaseFromFile(filePath, parsed);
 }
 
-function normalizeLifecycleStateToken(value) {
-  if (typeof value !== 'string') {
-    return '';
-  }
-  return value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '_')
-    .replace(/^_+|_+$/g, '');
-}
-
-function lifecycleStateFromToken(token) {
-  if (!token) {
-    return null;
-  }
-  for (const [state, aliases] of Object.entries(LIFECYCLE_STATE_ALIASES)) {
-    for (const alias of aliases) {
-      if (token === alias || token.startsWith(`${alias}_`)) {
-        return state;
-      }
-    }
-  }
-  return null;
-}
-
-function lifecycleStateFromSignalValue(value) {
-  if (value === null || value === undefined) {
-    return null;
-  }
-  if (typeof value === 'string') {
-    return lifecycleStateFromToken(normalizeLifecycleStateToken(value));
-  }
-  if (Array.isArray(value)) {
-    for (const row of value) {
-      const state = lifecycleStateFromSignalValue(row);
-      if (state) {
-        return state;
-      }
-    }
-    return null;
-  }
-  if (typeof value === 'object') {
-    const fields = [
-      'lifecycleState',
-      'state',
-      'status',
-      'code',
-      'type',
-      'reason',
-      'kind',
-      'category',
-      'errorCode'
-    ];
-    for (const field of fields) {
-      const state = lifecycleStateFromSignalValue(value[field]);
-      if (state) {
-        return state;
-      }
-    }
-  }
-  return null;
-}
-
-function mapWorkStatusFromResult(result) {
-  const rawStatus = normalizeLifecycleStateToken(result?.status);
-  if (rawStatus && WORK_STATUS_TO_LIFECYCLE[rawStatus]) {
-    const waitReason = normalizeLifecycleStateToken(result?.wait?.waitReason || '');
-    if (rawStatus === 'waiting' && waitReason && WAIT_REASON_TO_LIFECYCLE[waitReason]) {
-      return WAIT_REASON_TO_LIFECYCLE[waitReason];
-    }
-    return WORK_STATUS_TO_LIFECYCLE[rawStatus];
-  }
-  return null;
-}
-
-function mapWorkerTaskStateFromResult(result) {
-  const statusCandidates = [result?.task?.status, result?.status, result?.workerTask?.status];
-  for (const row of statusCandidates) {
-    const token = normalizeLifecycleStateToken(row);
-    if (token && WORKER_TASK_STATUS_TO_LIFECYCLE[token]) {
-      return WORKER_TASK_STATUS_TO_LIFECYCLE[token];
-    }
-  }
-  const approvalCandidates = [result?.task?.approvalState, result?.approvalState, result?.workerTask?.approvalState];
-  for (const row of approvalCandidates) {
-    const token = normalizeLifecycleStateToken(row);
-    if (token && WORKER_APPROVAL_STATE_TO_LIFECYCLE[token]) {
-      return WORKER_APPROVAL_STATE_TO_LIFECYCLE[token];
-    }
-  }
-  return null;
-}
-
-function resolveLifecycleStateFromResult(result) {
-  const workState = mapWorkStatusFromResult(result);
-  if (workState) {
-    return workState;
-  }
-  const workerTaskState = mapWorkerTaskStateFromResult(result);
-  if (workerTaskState) {
-    return workerTaskState;
-  }
-  const topLevelCandidates = [
-    result?.lifecycleState, result?.state, result?.status, result?.lifecycle?.state,
-    result?.report?.lifecycleState, result?.report?.state, result?.report?.status,
-    result?.report?.lifecycle?.state, result?.report?.runtime?.state, result?.report?.work?.state
-  ];
-  for (const candidate of topLevelCandidates) {
-    const state = lifecycleStateFromSignalValue(candidate);
-    if (state) {
-      return state;
-    }
-  }
-  const steps = Array.isArray(result?.stepsRun) ? result.stepsRun : [];
-  for (const row of steps) {
-    const stepCandidates = [
-      row?.lifecycleState, row?.state, row?.status, row?.code, row?.errorCode, row?.reason,
-      row?.kind, row?.type, row?.error, row?.failure, row?.details, row?.result
-    ];
-    for (const candidate of stepCandidates) {
-      const state = lifecycleStateFromSignalValue(candidate);
-      if (state) {
-        return state;
-      }
-    }
-  }
-  return null;
-}
-
-function deriveLifecycleState(result, lifecycleVerdict) {
-  if (lifecycleVerdict === VERDICT.VERIFIED) {
-    return 'completed';
-  }
-  const structuredState = resolveLifecycleStateFromResult(result);
-  if (structuredState) {
-    return structuredState;
-  }
-  if (lifecycleVerdict === VERDICT.NOT_VERIFIED) return 'safe-stop';
-  return 'failed';
-}
-
 function addCapabilityToken(set, value) {
   if (typeof value === 'string' && value.trim()) set.add(value.trim());
 }
@@ -328,9 +200,34 @@ function collectCapabilitiesFromWorkSteps(out, steps) {
       addCapabilityToken(out, row.executionOutcome.capabilityKey);
       addCapabilityToken(out, row.executionOutcome.capability);
     }
+    const execution = row.capabilityExecution;
+    if (execution && typeof execution === 'object') {
+      addCapabilityToken(out, execution.capabilityKey);
+      addCapabilityToken(out, execution.capability);
+    }
   }
 }
 
+/**
+ * Identity-preflight CIP fallback uses operationId "operation" (or omits it).
+ * That is a Reality probe log, not an observed write capability.
+ * @param {object} row
+ * @returns {boolean}
+ */
+function cipArtifactIsUnspecifiedOperation(row) {
+  const fingerprint = typeof row.fingerprint === 'string' ? row.fingerprint : '';
+  const opMatch = fingerprint.match(/(?:^|[|,])operationId=([^|,]+)/);
+  if (opMatch) {
+    const operationId = opMatch[1].trim();
+    return !operationId || operationId === 'operation';
+  }
+  const artifactRef = typeof row.artifactRef === 'string' ? row.artifactRef : '';
+  if (/^cip-log:[^:]+:[^:]+:operation:/.test(artifactRef)) {
+    return true;
+  }
+  return /(?:^|[|,])capabilityKey=/.test(fingerprint);
+}
+
 /**
  * Work-result artifactIndex often carries CIP fingerprints like
  * `capabilityKey=customer.createBasic|operationId=createbasic` when steps[] is empty.
@@ -341,6 +238,7 @@ function collectCapabilitiesFromArtifactIndex(out, artifacts) {
   if (!Array.isArray(artifacts)) return;
   for (const row of artifacts) {
     if (!row || typeof row !== 'object') continue;
+    if (cipArtifactIsUnspecifiedOperation(row)) continue;
     addCapabilityToken(out, row.capabilityKey);
     addCapabilityToken(out, row.capability);
     const fingerprint = typeof row.fingerprint === 'string' ? row.fingerprint : '';
@@ -381,6 +279,7 @@ function collectObservedCapabilities(result) {
 module.exports = {
   SUPPORTED_LIFECYCLE_STATES,
   roleAssistantTestsDir,
+  listTestCaseFiles,
   loadRoleAssistantTestCase,
   deriveLifecycleState,
   collectObservedCapabilities,