@aifabrix/builder 2.52.0 → 2.53.0

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

@@ -0,0 +1,278 @@
+/**
+ * Suite BID load / discovery emit for Work Hub apply waits (512.4 GP).
+ * @fileoverview Case BID template + discovery compile + suite stamp
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('../internal/fs-real-sync');
+
+/**
+ * @param {Object} testCase
+ * @returns {string}
+ */
+function resolveTargetSystemKey(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  for (const key of ['targetSystemKey', 'integrationSystemKey', 'systemKey']) {
+    const value = input[key];
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return '';
+}
+
+/**
+ * @param {Object} testCase
+ * @returns {boolean}
+ */
+function shouldStampSuiteBid(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  if (input.stampSuiteBid === true) {
+    return true;
+  }
+  if (input.stampSuiteBid === false) {
+    return false;
+  }
+  const expected =
+    testCase && typeof testCase.expected === 'object' && testCase.expected
+      ? testCase.expected
+      : {};
+  return expected.soft === false;
+}
+
+/**
+ * @param {Object} testCase
+ * @returns {string}
+ */
+function resolveSuiteRunId(testCase) {
+  const fromActive = String(testCase?._activeProcessExecutionId || '').trim();
+  if (fromActive) {
+    return fromActive;
+  }
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  return String(input.suiteRunId || '').trim();
+}
+
+/**
+ * @param {Object} testCase
+ * @param {Object} bid
+ */
+function maybePersistEmittedBid(testCase, bid) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  const outPath = typeof input.emittedBidPath === 'string' ? input.emittedBidPath.trim() : '';
+  if (!outPath || !bid) {
+    return;
+  }
+  const baseDir =
+    typeof testCase.sourceFile === 'string' && testCase.sourceFile.trim()
+      ? path.dirname(testCase.sourceFile)
+      : process.cwd();
+  const abs = path.isAbsolute(outPath) ? outPath : path.resolve(baseDir, outPath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, `${JSON.stringify(bid, null, 2)}\n`, 'utf8');
+}
+
+/**
+ * @param {Object} testCase
+ * @returns {Object|undefined}
+ */
+function loadBidTemplate(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  const bidPath = typeof input.bidPath === 'string' ? input.bidPath.trim() : '';
+  if (!bidPath) {
+    return undefined;
+  }
+  const baseDir =
+    typeof testCase.sourceFile === 'string' && testCase.sourceFile.trim()
+      ? path.dirname(testCase.sourceFile)
+      : process.cwd();
+  const abs = path.isAbsolute(bidPath) ? bidPath : path.resolve(baseDir, bidPath);
+  if (!fs.existsSync(abs)) {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(abs, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : undefined;
+  } catch (_err) {
+    return undefined;
+  }
+}
+
+/**
+ * @param {Object} testCase
+ * @returns {boolean}
+ */
+function shouldEmitBidFromAnswers(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  if (input.emitBidFromAnswers === false) {
+    return false;
+  }
+  if (!shouldStampSuiteBid(testCase) && input.emitBidFromAnswers !== true) {
+    return false;
+  }
+  const answers = Array.isArray(testCase.answers) ? testCase.answers : [];
+  return answers.some((entry) => {
+    const key = String(entry?.when?.questionKey || '')
+      .trim()
+      .toLowerCase();
+    return key === 'system.apigroups';
+  });
+}
+
+/**
+ * @param {Object} testCase
+ * @returns {string|undefined}
+ */
+function resolveAssistantKey(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  if (typeof input.digitalWorkerKey === 'string' && input.digitalWorkerKey.trim()) {
+    return input.digitalWorkerKey.trim();
+  }
+  if (typeof input.businessRoleRef === 'string' && input.businessRoleRef.trim()) {
+    return input.businessRoleRef.trim();
+  }
+  return undefined;
+}
+
+function resolveConnectionRefs(input, template) {
+  if (input.connectionRefs && typeof input.connectionRefs === 'object') {
+    return input.connectionRefs;
+  }
+  if (template && template.system && template.system.connectionRefs) {
+    return template.system.connectionRefs;
+  }
+  return undefined;
+}
+
+function packageField(template, field, fallback) {
+  const identity = template && template.packageIdentity;
+  if (identity && identity[field]) {
+    return identity[field];
+  }
+  return fallback;
+}
+
+function buildDiscoveryEmitOptions(testCase, suiteRunId, template, systemKey) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  const openapiSourceRefs =
+    input.openapiSourceRefs && typeof input.openapiSourceRefs === 'object'
+      ? input.openapiSourceRefs
+      : undefined;
+  const knowledgePackRefs =
+    template && template.meta && Array.isArray(template.meta.knowledgePackRefs)
+      ? template.meta.knowledgePackRefs
+      : undefined;
+  return {
+    answers: testCase.answers,
+    systemKey,
+    displayName: packageField(template, 'displayName', systemKey),
+    packageVersion: packageField(template, 'packageVersion', '0.1.0'),
+    systemKind: (template && template.system && template.system.systemKind) || 'crm',
+    connectionRefs: resolveConnectionRefs(input, template),
+    openapiSourceRefs,
+    suiteRunId,
+    definitionId: template && template.definitionId,
+    btAssistantKey: resolveAssistantKey(testCase),
+    knowledgePackRefs
+  };
+}
+
+/**
+ * @param {Object} testCase
+ * @param {string} suiteRunId
+ * @param {Object|undefined} template
+ * @returns {Object|undefined}
+ */
+function emitBidFromCaseAnswers(testCase, suiteRunId, template) {
+  const systemKey = resolveTargetSystemKey(testCase);
+  if (!systemKey) {
+    return undefined;
+  }
+  const { bidFromDiscovery } = require('../integration-definition/from-discovery');
+  return bidFromDiscovery(buildDiscoveryEmitOptions(testCase, suiteRunId, template, systemKey));
+}
+
+function cachedEmittedBid(testCase, suiteRunId) {
+  if (
+    testCase._emittedBid &&
+    typeof testCase._emittedBid === 'object' &&
+    testCase._emittedBid.meta &&
+    testCase._emittedBid.meta.suiteRunId === suiteRunId
+  ) {
+    return testCase._emittedBid;
+  }
+  return null;
+}
+
+function tryEmitFromAnswers(testCase, suiteRunId, template) {
+  if (!shouldEmitBidFromAnswers(testCase)) {
+    return null;
+  }
+  try {
+    const emitted = emitBidFromCaseAnswers(testCase, suiteRunId, template);
+    if (emitted) {
+      testCase._emittedBid = emitted;
+      maybePersistEmittedBid(testCase, emitted);
+      return emitted;
+    }
+  } catch (_err) {
+    // Fall through to template stamp.
+  }
+  return null;
+}
+
+/**
+ * Load BID for apply: discovery-compiled (preferred) or stamped template.
+ * @param {Object} testCase
+ * @returns {Object|undefined}
+ */
+function loadCaseBidDocument(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  const template = loadBidTemplate(testCase);
+  if (!shouldStampSuiteBid(testCase) && input.emitBidFromAnswers !== true) {
+    return template;
+  }
+  const suiteRunId = resolveSuiteRunId(testCase);
+  if (!suiteRunId) {
+    return template;
+  }
+  const cached = cachedEmittedBid(testCase, suiteRunId);
+  if (cached) {
+    return cached;
+  }
+  const fromAnswers = tryEmitFromAnswers(testCase, suiteRunId, template);
+  if (fromAnswers) {
+    return fromAnswers;
+  }
+  if (!template) {
+    return undefined;
+  }
+  const { emitSuiteBid } = require('../integration-definition/emit-suite-bid');
+  const emitted = emitSuiteBid(template, {
+    suiteRunId,
+    btAssistantKey: resolveAssistantKey(testCase),
+    answers: testCase.answers
+  });
+  testCase._emittedBid = emitted;
+  maybePersistEmittedBid(testCase, emitted);
+  return emitted;
+}
+
+module.exports = {
+  resolveTargetSystemKey,
+  shouldStampSuiteBid,
+  resolveSuiteRunId,
+  loadCaseBidDocument,
+  shouldEmitBidFromAnswers
+};

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

@@ -0,0 +1,96 @@
+/**
+ * Build work.start Intent payload for role-assistant cases.
+ * @fileoverview Extracted from test-runner.js (file-size) + 517.1 attachments
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const { buildStartAttachments } = require('./test-runner-attachments');
+
+function buildRuntimeId(prefix) {
+  if (typeof crypto.randomUUID === 'function') {
+    return `${prefix}-${crypto.randomUUID()}`;
+  }
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function applyOptionalStringField(payload, value, key) {
+  if (typeof value === 'string' && value.trim()) {
+    payload[key] = value.trim();
+  }
+}
+
+function resolveInputObject(testCase) {
+  const input = testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  return Array.isArray(input) ? {} : input;
+}
+
+function resolveInputMessage(testCase) {
+  const input = resolveInputObject(testCase);
+  const candidates = [input.message, input.text, input.prompt];
+  for (const row of candidates) {
+    if (typeof row === 'string' && row.trim()) {
+      return row.trim();
+    }
+  }
+  return '';
+}
+
+function applyStartPayloadOptionalFields(payload, input) {
+  const mappedFields = [
+    ['activationId', 'activationId'],
+    ['workerTaskId', 'workerTaskId'],
+    ['principalRef', 'principalRef'],
+    ['businessRoleRef', 'businessRoleRef']
+  ];
+  for (const [inputKey, payloadKey] of mappedFields) {
+    applyOptionalStringField(payload, input[inputKey], payloadKey);
+  }
+}
+
+function buildStartPayloadSourceMetadata(roleKey, testCase, input) {
+  return {
+    roleKey,
+    caseId: testCase.caseId,
+    runner: 'aifabrix-role-assistant-test',
+    ...(input.sourceMetadata && typeof input.sourceMetadata === 'object' ? input.sourceMetadata : {})
+  };
+}
+
+function buildStartIntentPayload(roleKey, testCase) {
+  const input = resolveInputObject(testCase);
+  const message = resolveInputMessage(testCase);
+  const hasContent = typeof input.content !== 'undefined';
+  if (!hasContent && !message) {
+    throw new Error(
+      `Role assistant test case "${testCase.caseId}" is missing input.message or input.content for runtime execution.`
+    );
+  }
+  const payload = {
+    submissionId: String(input.submissionId || buildRuntimeId(`ra-${roleKey}`)),
+    content: hasContent ? input.content : message,
+    comModelRef: String(input.comModelRef || 'aifabrix.com/intent/default'),
+    comModelVersion: String(input.comModelVersion || '1.0'),
+    comVocabulary:
+      Array.isArray(input.comVocabulary) && input.comVocabulary.length > 0
+        ? input.comVocabulary.map((row) => String(row))
+        : ['objective', 'entity', 'action'],
+    sourceType: String(input.sourceType || 'api'),
+    sourceLanguage: String(input.sourceLanguage || 'en'),
+    responseLanguage: String(input.responseLanguage || input.sourceLanguage || 'en'),
+    sourceMetadata: buildStartPayloadSourceMetadata(roleKey, testCase, input)
+  };
+  applyStartPayloadOptionalFields(payload, input);
+  const attachments = buildStartAttachments(testCase);
+  if (attachments && attachments.length > 0) {
+    payload.attachments = attachments;
+  }
+  return payload;
+}
+
+module.exports = {
+  buildStartIntentPayload,
+  resolveInputObject,
+  resolveInputMessage
+};

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

@@ -5,6 +5,13 @@
 
 'use strict';
 
+const {
+  resolveTargetSystemKey,
+  shouldStampSuiteBid,
+  resolveSuiteRunId,
+  loadCaseBidDocument
+} = require('./test-runner-bid-document');
+
 function resolveWorkHubAnswerValue(answer) {
   if (answer === null || answer === undefined) {
     return undefined;
@@ -69,25 +76,159 @@ function extractObjectiveHints(objective) {
   return { email, domain, name, address };
 }
 
-function fillFieldsFromHints(fields, hints) {
+function resolveCaseSystemKey(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  for (const key of ['digitalWorkerKey', 'systemKey', 'businessRoleRef']) {
+    const value = input[key];
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return '';
+}
+
+/**
+ * Target Connected System key for workspace/template lifecycle (not the RA package key).
+ */
+/**
+ * Capability identity for a wait. Prefer structured keys; fall back to prompt
+ * text so "Missing … for project.runupload (fields: systemKey)" still routes
+ * to the target integration key (not the Role Assistant package key).
+ * @param {Object} wait
+ * @returns {string}
+ */
+function resolveWaitCapabilityText(wait) {
+  return String(
+    wait?.questionKey ||
+      wait?.objectRef?.capabilityKey ||
+      wait?.requestKey ||
+      wait?.prompt ||
+      ''
+  ).toLowerCase();
+}
+
+function isTargetIntegrationLifecycleCapability(capability) {
+  const text = String(capability || '').toLowerCase();
+  return (
+    text.includes('workspace') ||
+    text.includes('createsystem') ||
+    text.includes('template') ||
+    text.includes('applyintegrationdefinition') ||
+    text.includes('wizard') ||
+    text.includes('repair') ||
+    text.includes('validate') ||
+    text.includes('upload') ||
+    text.includes('project.') ||
+    text.includes('document.') ||
+    text.includes('certifypillar') ||
+    text.includes('approval.')
+  );
+}
+
+function resolveCaseCertifyPillar(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  const raw = input.certifyPillar || input.pillar;
+  if (typeof raw === 'string' && raw.trim()) {
+    return raw.trim();
+  }
+  return 'operations';
+}
+
+/**
+ * @param {Object} wait
+ * @param {Object} testCase
+ * @param {string} systemKey
+ * @returns {Object|undefined}
+ */
+function synthesizeCertifyAnswer(wait, testCase, systemKey) {
+  if (!systemKey) {
+    return undefined;
+  }
+  const capability = resolveWaitCapabilityText(wait);
+  if (!capability.includes('certifypillar') && !capability.includes('certify')) {
+    return undefined;
+  }
+  return { systemKey, pillar: resolveCaseCertifyPillar(testCase) };
+}
+
+function isBidApplyWait(wait) {
+  const capability = resolveWaitCapabilityText(wait);
+  return (
+    capability.includes('applyintegrationdefinition') ||
+    capability.includes('integrationdefinition') ||
+    capability.includes('integration-definition')
+  );
+}
+
+function resolveSystemKeyForWait(testCase, wait) {
+  const capability = resolveWaitCapabilityText(wait);
+  const target = resolveTargetSystemKey(testCase);
+  if (target && isTargetIntegrationLifecycleCapability(capability)) {
+    return target;
+  }
+  return resolveCaseSystemKey(testCase);
+}
+
+function valueFromHintField(lower, hints, testCase, systemKey) {
+  if (hints[lower]) {
+    return hints[lower];
+  }
+  if (lower === 'systemkey' && systemKey) {
+    return systemKey;
+  }
+  if (lower === 'pillar') {
+    return resolveCaseCertifyPillar(testCase);
+  }
+  if (lower === 'force') {
+    return true;
+  }
+  if (lower.includes('mail') && hints.email) {
+    return hints.email;
+  }
+  if (lower.includes('name') && hints.name) {
+    return hints.name;
+  }
+  if (lower.includes('domain') && hints.domain) {
+    return hints.domain;
+  }
+  if (lower.includes('address') && hints.address) {
+    return hints.address;
+  }
+  return undefined;
+}
+
+function fillFieldsFromHints(fields, hints, testCase, wait) {
   const out = {};
+  const systemKey = resolveSystemKeyForWait(testCase, wait);
   for (const key of fields) {
-    const lower = key.toLowerCase();
-    if (hints[lower]) {
-      out[key] = hints[lower];
-    } else if (lower.includes('mail') && hints.email) {
-      out[key] = hints.email;
-    } else if (lower.includes('name') && hints.name) {
-      out[key] = hints.name;
-    } else if (lower.includes('domain') && hints.domain) {
-      out[key] = hints.domain;
-    } else if (lower.includes('address') && hints.address) {
-      out[key] = hints.address;
+    const value = valueFromHintField(key.toLowerCase(), hints, testCase, systemKey);
+    if (value !== undefined) {
+      out[key] = value;
     }
   }
   return Object.keys(out).length > 0 ? out : undefined;
 }
 
+/**
+ * Soft-loop upload often rewrites BID-shaped schemas over prior packages.
+ * Include force so project.runupload can replace non-overlapping attributes.
+ * @param {Object} wait
+ * @param {string} systemKey
+ * @returns {Object|undefined}
+ */
+function synthesizeUploadAnswer(wait, systemKey) {
+  if (!systemKey || !isTargetIntegrationLifecycleCapability(resolveWaitCapabilityText(wait))) {
+    return undefined;
+  }
+  const capability = resolveWaitCapabilityText(wait);
+  if (!capability.includes('upload') && !capability.includes('project.runupload')) {
+    return undefined;
+  }
+  return { systemKey, force: true };
+}
+
 function _synthContactFields(hints) {
   const out = {};
   if (hints.email) {
@@ -144,14 +285,87 @@ function synthesizeFromCapability(capability, hints) {
   return Object.keys(out).length > 0 ? out : undefined;
 }
 
-function synthesizeWaitAnswer(wait, statusRow, objective) {
+function synthesizeFieldAnswer(wait, statusRow, objective, testCase) {
   const prompt = String(wait.prompt || statusRow?.message || '').trim();
   const hints = extractObjectiveHints(objective);
   const fields = parseFieldsFromPrompt(prompt);
-  if (fields.length > 0) {
-    return fillFieldsFromHints(fields, hints);
+  const filled = fields.length > 0 ? fillFieldsFromHints(fields, hints, testCase, wait) : undefined;
+  if (filled === undefined) {
+    return undefined;
+  }
+  const targetKey = filled.systemKey || resolveTargetSystemKey(testCase);
+  const uploadExtra = synthesizeUploadAnswer(wait, targetKey);
+  const certifyExtra = synthesizeCertifyAnswer(wait, testCase, targetKey);
+  return uploadExtra || certifyExtra ? { ...filled, ...(uploadExtra || {}), ...(certifyExtra || {}) } : filled;
+}
+
+function synthesizePathParameterAnswer(wait, prompt, kind, testCase) {
+  if (kind !== 'missingPathParams' && !/missing required path params/i.test(prompt)) {
+    return undefined;
+  }
+  const targetSystemKey = resolveTargetSystemKey(testCase);
+  if (targetSystemKey && isTargetIntegrationLifecycleCapability(resolveWaitCapabilityText(wait))) {
+    return (
+      synthesizeUploadAnswer(wait, targetSystemKey) ||
+      synthesizeCertifyAnswer(wait, testCase, targetSystemKey) ||
+      { systemKey: targetSystemKey }
+    );
   }
+  const pathSystemKey = resolveCaseSystemKey(testCase);
+  return pathSystemKey ? { systemKey: pathSystemKey } : undefined;
+}
+
+function synthesizeBidApplyAnswer(wait, prompt, kind, testCase) {
+  if (!isBidApplyWait(wait)) {
+    return undefined;
+  }
+  const wantsBody = kind === 'missingRequestBody' || /missing required request body/i.test(prompt);
+  const wantsPath = kind === 'missingPathParams' || /missing required path params/i.test(prompt);
+  const bid = loadCaseBidDocument(testCase);
+  // Always attach the full BID for apply waits (path or body). Path-only responds
+  // that send only systemKey let CIP POST an empty definition → Invalid BID.
+  if (!bid || (!wantsBody && !wantsPath)) {
+    return undefined;
+  }
+  const out = { integrationDefinition: bid };
+  const targetSystemKey = resolveTargetSystemKey(testCase);
+  if (targetSystemKey) {
+    out.systemKey = targetSystemKey;
+  }
+  return out;
+}
+
+function synthesizeTargetSystemKeyAnswer(wait, prompt, kind, testCase) {
+  const targetSystemKey = resolveTargetSystemKey(testCase);
+  const needsBody = kind === 'missingRequestBody' || /missing required request body/i.test(prompt);
+  if (!targetSystemKey || (!needsBody && !/systemKey is required/i.test(prompt))) {
+    return undefined;
+  }
+  const capability = resolveWaitCapabilityText(wait);
+  const supportsTarget =
+    capability.includes('workspace') ||
+    capability.includes('createsystem') ||
+    (capability.includes('template') && !isBidApplyWait(wait)) ||
+    capability.includes('wizard') ||
+    capability.includes('upload') ||
+    capability.includes('project.') ||
+    /systemkey is required/i.test(prompt);
+  return supportsTarget ? { systemKey: targetSystemKey } : undefined;
+}
+
+function synthesizeWaitAnswer(wait, statusRow, objective, testCase) {
+  const prompt = String(wait.prompt || statusRow?.message || '').trim();
   const kind = String(wait.objectRef?.kind || '').trim();
+  // BID apply before field/path synthesis — "(fields: systemKey)" must not
+  // drop integrationDefinition and let CIP POST an empty BID.
+  const bidAnswer = synthesizeBidApplyAnswer(wait, prompt, kind, testCase);
+  if (bidAnswer !== undefined) {
+    return bidAnswer;
+  }
+  const fieldAnswer = synthesizeFieldAnswer(wait, statusRow, objective, testCase);
+  if (fieldAnswer !== undefined) {
+    return fieldAnswer;
+  }
   const isMissingInput =
     kind === 'missingRequestBody' ||
     kind === 'missingPathParams' ||
@@ -159,18 +373,25 @@ function synthesizeWaitAnswer(wait, statusRow, objective) {
   if (!isMissingInput) {
     return undefined;
   }
-  const capability = String(wait.questionKey || wait.objectRef?.capabilityKey || '').toLowerCase();
-  return synthesizeFromCapability(capability, hints);
+  const pathAnswer = synthesizePathParameterAnswer(wait, prompt, kind, testCase);
+  if (pathAnswer !== undefined) {
+    return pathAnswer;
+  }
+  const targetAnswer = synthesizeTargetSystemKeyAnswer(wait, prompt, kind, testCase);
+  return targetAnswer || synthesizeFromCapability(resolveWaitCapabilityText(wait), extractObjectiveHints(objective));
 }
 
 function resolveRespondValue(testCase, wait, statusRow, objective) {
   const answers = Array.isArray(testCase.answers) ? testCase.answers : [];
-  const matched = pickAnswerForWait(answers, wait) || answers[0] || null;
+  // Only use an answer whose when.questionKey matches this wait.
+  // Never fall back to answers[0] — that poisons capability waits (e.g. task.runtest)
+  // with unrelated discovery payloads (system.apiGroups).
+  const matched = pickAnswerForWait(answers, wait);
   const fromCase = matched ? resolveWorkHubAnswerValue(matched) : undefined;
   if (fromCase !== undefined) {
     return fromCase;
   }
-  return synthesizeWaitAnswer(wait, statusRow, objective);
+  return synthesizeWaitAnswer(wait, statusRow, objective, testCase);
 }
 
 function waitRespondFingerprint(wait) {
@@ -181,7 +402,10 @@ function waitRespondFingerprint(wait) {
 
 function alreadyResponded(interactions, fingerprint) {
   return interactions.some(
-    (row) => row && row.type === 'respond' && row.fingerprint === fingerprint
+    (row) =>
+      row &&
+      (row.type === 'respond' || row.type === 'respond-skipped') &&
+      row.fingerprint === fingerprint
   );
 }
 
@@ -214,6 +438,11 @@ module.exports = {
   pickAnswerForWait,
   synthesizeWaitAnswer,
   extractObjectiveHints,
+  resolveCaseSystemKey,
+  resolveTargetSystemKey,
+  shouldStampSuiteBid,
+  resolveSuiteRunId,
+  loadCaseBidDocument,
   resolveRespondValue,
   waitRespondFingerprint,
   alreadyResponded,