@aifabrix/builder 2.53.0 → 2.54.1

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

@@ -0,0 +1,229 @@
+/**
+ * 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');
+
+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));
+  return assertions;
+}
+
+function skillsResourceEntry(skillsPayload, resourceType) {
+  const rts = asObject(asObject(skillsPayload).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 === 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

@@ -98,21 +98,54 @@ 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,
+    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) {

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

@@ -0,0 +1,149 @@
+/**
+ * Role-assistant typed search cases (work.skills / work.search).
+ *
+ * @fileoverview Execute viewpoint and table search cases without Work Hub
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getWorkSkills, searchWork } = require('../api/work-search.api');
+const { roleAssistantSystemKey } = require('../utils/role-assistant-paths');
+const {
+  resolveInput,
+  wantsSearchPath,
+  wantsSkillsOnlyPath
+} = require('./test-runner-workhub-helpers');
+
+function operationKeys(spec) {
+  const raw = Array.isArray(spec && spec.operations) ? spec.operations : [];
+  const keys = [];
+  for (const item of raw) {
+    if (typeof item === 'string' && item.trim()) {
+      keys.push(item.trim());
+      continue;
+    }
+    const key = item && typeof item === 'object' ? String(item.key || '').trim() : '';
+    if (key) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+
+function resourceTypesMap(skillsPayload) {
+  const rts = skillsPayload && skillsPayload.search && skillsPayload.search.resourceTypes;
+  return rts && typeof rts === 'object' && !Array.isArray(rts) ? rts : {};
+}
+
+function pickResourceType(skillsPayload, operation) {
+  const rts = resourceTypesMap(skillsPayload);
+  const keys = Object.keys(rts);
+  const wanted = String(operation || '').trim();
+  if (wanted) {
+    const hits = keys.filter((resourceType) => operationKeys(rts[resourceType]).includes(wanted));
+    if (hits.length === 1) {
+      return hits[0];
+    }
+  }
+  return keys.length === 1 ? keys[0] : '';
+}
+
+function resolveRoleRef(roleKey, testCase) {
+  const input = resolveInput(testCase);
+  const candidates = [
+    input.roleRef,
+    input.businessRoleRef,
+    testCase && testCase.roleRef,
+    testCase && testCase.businessRoleRef,
+    roleAssistantSystemKey(roleKey)
+  ];
+  for (const row of candidates) {
+    if (typeof row === 'string' && row.trim()) {
+      return row.trim();
+    }
+  }
+  return roleAssistantSystemKey(roleKey);
+}
+
+function assignOptionalNumber(args, input, key) {
+  if (Number.isFinite(input[key])) {
+    args[key] = input[key];
+  }
+}
+
+function buildSearchArguments(roleRef, input, skillsPayload) {
+  const args = { roleRef };
+  const resourceType =
+    String(input.resourceType || '').trim() || pickResourceType(skillsPayload, input.operation);
+  if (resourceType) {
+    args.resourceType = resourceType;
+  }
+  if (typeof input.operation === 'string' && input.operation.trim()) {
+    args.operation = input.operation.trim();
+  }
+  if (input.filters && typeof input.filters === 'object' && !Array.isArray(input.filters)) {
+    args.filters = input.filters;
+  }
+  assignOptionalNumber(args, input, 'page');
+  assignOptionalNumber(args, input, 'pageSize');
+  if (Array.isArray(input.fields) && input.fields.length) {
+    args.fields = input.fields;
+  }
+  return args;
+}
+
+function statusToken(statusCode) {
+  return Number(statusCode) === 200 ? 'completed' : 'stopped';
+}
+
+function searchLifecycleResult(roleKey, testCase, roleRef, skillsRes, searchRes, args) {
+  return {
+    kind: searchRes ? 'search' : 'skills',
+    roleKey,
+    caseId: testCase.caseId,
+    roleRef,
+    processExecutionId: null,
+    skills: skillsRes,
+    search: searchRes ? { ...searchRes, arguments: args } : null,
+    finalStatus: {
+      status: statusToken((searchRes || skillsRes).status)
+    },
+    timeline: [],
+    interactions: [],
+    workResult: null,
+    workResultError: null
+  };
+}
+
+async function runSearchCaseLifecycle(roleKey, testCase, runtimeContext) {
+  const dataplaneUrl = runtimeContext && runtimeContext.dataplaneUrl;
+  const authConfig = runtimeContext && runtimeContext.authConfig;
+  if (!dataplaneUrl || !authConfig) {
+    throw new Error('Role assistant search case requires dataplane auth context.');
+  }
+  const roleRef = resolveRoleRef(roleKey, testCase);
+  const skillsRes = await getWorkSkills(dataplaneUrl, authConfig, roleRef);
+  if (wantsSkillsOnlyPath(testCase)) {
+    return searchLifecycleResult(roleKey, testCase, roleRef, skillsRes, null, null);
+  }
+  const args = buildSearchArguments(roleRef, resolveInput(testCase), skillsRes.payload);
+  if (!args.resourceType) {
+    throw new Error(
+      'Search case requires input.resourceType (or exactly one matching type from work.skills).'
+    );
+  }
+  const searchRes = await searchWork(dataplaneUrl, authConfig, args);
+  return searchLifecycleResult(roleKey, testCase, roleRef, skillsRes, searchRes, args);
+}
+
+module.exports = {
+  wantsSearchPath,
+  wantsSkillsOnlyPath,
+  operationKeys,
+  pickResourceType,
+  resolveRoleRef,
+  buildSearchArguments,
+  runSearchCaseLifecycle
+};

package/lib/role-assistant/test-runner-workhub-helpers.js

@@ -34,9 +34,45 @@ function resolveObjective(testCase) {
   return '';
 }
 
-function wantsWorkHubPath(testCase) {
+function firstNonEmptyString(values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return '';
+}
+
+function searchPathToken(testCase) {
   const input = resolveInput(testCase);
-  const pathToken = String(input.executionPath || input.mode || '').trim().toLowerCase();
+  return firstNonEmptyString([
+    input.executionPath,
+    input.execution_path,
+    testCase && testCase.executionPath,
+    input.mode
+  ]).toLowerCase();
+}
+
+function wantsSearchPath(testCase) {
+  const pathToken = searchPathToken(testCase);
+  return (
+    pathToken === 'search' ||
+    pathToken === 'work.search' ||
+    pathToken === 'skills' ||
+    pathToken === 'work.skills'
+  );
+}
+
+function wantsSkillsOnlyPath(testCase) {
+  const pathToken = searchPathToken(testCase);
+  return pathToken === 'skills' || pathToken === 'work.skills';
+}
+
+function wantsWorkHubPath(testCase) {
+  if (wantsSearchPath(testCase)) {
+    return false;
+  }
+  const pathToken = searchPathToken(testCase);
   if (pathToken === 'workhub' || pathToken === 'work-hub' || pathToken === 'plan') {
     return true;
   }
@@ -91,6 +127,8 @@ module.exports = {
   delayMs,
   resolveInput,
   resolveObjective,
+  wantsSearchPath,
+  wantsSkillsOnlyPath,
   wantsWorkHubPath,
   unwrapId,
   extractPeFromTask,

package/lib/role-assistant/test-runner-workhub-soft.js

@@ -1,14 +1,20 @@
 /**
  * Soft Work Hub outcomes for insufficient-info / clarify-first Intent.
- * Soft cases may stop before accept when Intent is not Act-ready — that is a
- * governed fail-closed outcome, not a harness failure.
+ * Soft cases may stop before accept when Intent is not Act-ready or cannot be
+ * classified (unavailable without a next question) — that is a governed
+ * fail-closed outcome, not a harness failure.
  */
 
 'use strict';
 
 function isIntentNotActReadyError(error) {
   const msg = String((error && error.message) || error || '');
-  return /not Act-ready|intentNotActReady/i.test(msg);
+  const type = String((error && (error.errorType || error.type)) || '');
+  return (
+    /not Act-ready|intentNotActReady/i.test(msg) ||
+    /Intent is not available|runtimeIntentUnavailable/i.test(msg) ||
+    /runtimeIntentUnavailable/i.test(type)
+  );
 }
 
 function attachPlanIdToError(error, planId) {

package/lib/role-assistant/test-runner-workhub.js

@@ -302,21 +302,36 @@ function assertTerminalWorkHubTask(last, taskId, timeoutMs, options = {}) {
     throw new Error(`Work Hub task ${taskId} produced no status rows.`);
   }
   const finalStatusToken = String(last?.status || last?.taskStatus || '').trim().toLowerCase();
-  if (!TERMINAL_TASK.has(finalStatusToken)) {
-    if (options.soft === true) {
-      return last;
-    }
-    throw new Error(
-      `Work Hub task ${taskId} did not reach a terminal status within ${timeoutMs}ms (last=${finalStatusToken || 'unknown'}).`
-    );
+  if (!TERMINAL_TASK.has(finalStatusToken) && options.recordTimeout === true) {
+    last = {
+      ...last,
+      pollTimedOut: true,
+      lastStatus: finalStatusToken || 'unknown',
+      pollTimeoutMs: timeoutMs
+    };
   }
   return last;
 }
 
+function shouldStopPendingApprovalPoll(status, ctx) {
+  if (status !== 'pendingapproval' && status !== 'pending_approval') {
+    return false;
+  }
+  return ctx.approveStopped === true && (Number(ctx.pendingApprovalStreak) || 0) >= 3;
+}
+
+function applyWorkHubPollStatus(ctx, last, status) {
+  ctx.status = status;
+  ctx.taskRow = last;
+  ctx.pendingApprovalStreak =
+    status === 'pendingapproval' || status === 'pending_approval'
+      ? (Number(ctx.pendingApprovalStreak) || 0) + 1
+      : 0;
+}
+
 async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, options) {
   const timeoutMs = Number(options.pollTimeoutMs) || 180000;
   const intervalMs = Number(options.pollIntervalMs) || 3000;
-  const soft = testCase?.expected?.soft === true;
   const started = Date.now();
   let last = null;
   const timeline = [];
@@ -324,6 +339,7 @@ async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, optio
     status: '',
     approveAttempts: 0,
     approveStopped: false,
+    pendingApprovalStreak: 0,
     interactions: [],
     taskRow: null
   };
@@ -335,15 +351,17 @@ async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, optio
     if (TERMINAL_TASK.has(status)) {
       break;
     }
-    ctx.status = status;
-    ctx.taskRow = last;
+    applyWorkHubPollStatus(ctx, last, status);
     await maybeApproveTask(dataplaneUrl, authConfig, taskId, ctx);
     await maybeRespondWaiting(dataplaneUrl, authConfig, last, testCase, ctx.interactions);
+    if (shouldStopPendingApprovalPoll(status, ctx)) {
+      break;
+    }
     await delayMs(intervalMs);
   }
 
   return {
-    finalTask: assertTerminalWorkHubTask(last, taskId, timeoutMs, { soft }),
+    finalTask: assertTerminalWorkHubTask(last, taskId, timeoutMs, { recordTimeout: true }),
     timeline,
     interactions: ctx.interactions
   };

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

@@ -18,6 +18,7 @@ const {
   getWorkExecutionResult
 } = require('../api/work.api');
 const { wantsWorkHubPath, runWorkHubCaseLifecycle } = require('./test-runner-workhub');
+const { wantsSearchPath, runSearchCaseLifecycle } = require('./test-runner-search');
 const {
   buildStartIntentPayload,
   resolveInputObject,
@@ -58,6 +59,9 @@ function applyOptionalStringField(payload, value, key) {
 }
 
 function isExecutableRoleAssistantCase(testCase) {
+  if (wantsSearchPath(testCase)) {
+    return true;
+  }
   const input = resolveInputObject(testCase);
   if (typeof input.content !== 'undefined') {
     return true;
@@ -370,6 +374,9 @@ async function runRoleAssistantCaseLifecycle(roleKey, testCase, runtimeContext,
     throw new Error('Role assistant case runtime requires dataplane auth context.');
   }
   const runnerOptions = buildRunnerOptions(options);
+  if (wantsSearchPath(testCase)) {
+    return runSearchCaseLifecycle(roleKey, testCase, runtimeContext, runnerOptions);
+  }
   if (wantsWorkHubPath(testCase)) {
     return runWorkHubCaseLifecycle(roleKey, testCase, runtimeContext, runnerOptions);
   }
@@ -418,11 +425,19 @@ function mergeCaseExecutionIntoLifecycleResult(lifecycleResult, executionResult)
     task: executionResult?.workResult?.task || null,
     steps: Array.isArray(executionResult?.workResult?.steps) ? executionResult.workResult.steps : [],
     workTimeline: executionResult?.timeline || [],
-    workInteractions: executionResult?.interactions || []
+    workInteractions: executionResult?.interactions || [],
+    search: executionResult?.search || null,
+    skills: executionResult?.skills || null,
+    roleRef: executionResult?.roleRef || null
   };
 }
 
 function lifecycleVerdictFromCaseExecution(executionResult, fallbackVerdict) {
+  if (executionResult?.kind === 'search' || executionResult?.kind === 'skills') {
+    return Number.isFinite(Number(executionResult.search?.status || executionResult.skills?.status))
+      ? VERDICT.VERIFIED
+      : VERDICT.FAILED;
+  }
   const statusToken = normalizeToken(executionResult?.finalStatus?.status);
   if (statusToken === 'completed') {
     return VERDICT.VERIFIED;