@aifabrix/builder 2.53.1 → 2.55.0

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

@@ -0,0 +1,175 @@
+/**
+ * Role Assistant case Evidence preflight — live dataplane rows only.
+ * @fileoverview Hard-stop when required Evidence keys are missing or not active
+ */
+
+'use strict';
+
+const { listEvidence } = require('../api/evidence.api');
+const { bareRoleKey } = require('../utils/role-assistant-paths');
+
+function asStringList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => String(item || '').trim()).filter(Boolean);
+}
+
+function evidenceSpecFromCase(testCase) {
+  const preflight = testCase?.preflight?.evidence;
+  const expected = testCase?.expected?.evidence;
+  const requiredKeys = asStringList(preflight?.requiredKeys).concat(
+    asStringList(expected?.requiredKeys)
+  );
+  const unique = [...new Set(requiredKeys)];
+  if (unique.length === 0) {
+    return null;
+  }
+  const roleKey =
+    String(preflight?.roleKey || expected?.roleKey || '').trim() ||
+    bareRoleKey(testCase?.input?.businessRoleRef || '') ||
+    '';
+  const resourceType = String(preflight?.resourceType || expected?.resourceType || '').trim();
+  return {
+    requiredKeys: unique,
+    roleKey,
+    resourceType,
+    requireStatus: String(preflight?.requireStatus || expected?.requireStatus || 'active')
+      .trim()
+      .toLowerCase() || 'active'
+  };
+}
+
+function rowKey(row) {
+  return String(row?.key || row?.evidenceKey || '').trim();
+}
+
+function rowStatus(row) {
+  return String(row?.status || '').trim().toLowerCase();
+}
+
+function isActiveStatus(status, requiredStatus) {
+  if (requiredStatus === 'active') {
+    return !status || status === 'active';
+  }
+  return status === requiredStatus;
+}
+
+function findMissingEvidenceKeys(spec, rows) {
+  const byKey = new Map();
+  for (const row of rows) {
+    const key = rowKey(row);
+    if (key) {
+      byKey.set(key, row);
+    }
+  }
+  const missing = [];
+  for (const key of spec.requiredKeys) {
+    const row = byKey.get(key);
+    if (!row) {
+      missing.push(`${key} (not in dataplane)`);
+      continue;
+    }
+    const status = rowStatus(row);
+    if (!isActiveStatus(status, spec.requireStatus)) {
+      missing.push(`${key} (status=${status || 'unknown'}, need ${spec.requireStatus})`);
+    }
+  }
+  return missing;
+}
+
+async function loadLiveEvidenceRows(authContext, spec) {
+  const dataplaneUrl = authContext?.dataplaneUrl;
+  const authConfig = authContext?.authConfig;
+  if (!dataplaneUrl || !authConfig) {
+    throw new Error(
+      'Evidence preflight failed: dataplane URL or auth is missing. Run aifabrix login and retry.'
+    );
+  }
+  const params = {
+    roleKey: spec.roleKey || undefined,
+    resourceType: spec.resourceType || undefined,
+    status: spec.requireStatus === 'active' ? 'active' : spec.requireStatus,
+    page: 1,
+    pageSize: 100
+  };
+  try {
+    return await listEvidence(dataplaneUrl, authConfig, params);
+  } catch (error) {
+    const detail = error && error.message ? error.message : String(error);
+    throw new Error(`Evidence preflight failed: could not read Evidence from the dataplane (${detail}).`);
+  }
+}
+
+/**
+ * Hard-stop before work.start when the case requires live Evidence.
+ * @returns {Promise<{ skipped: boolean, requiredKeys: string[], rows: Object[] }>}
+ */
+async function assertRoleAssistantEvidencePreflight(testCase, authContext) {
+  const spec = evidenceSpecFromCase(testCase);
+  if (!spec) {
+    return { skipped: true, requiredKeys: [], rows: [] };
+  }
+  if (!spec.roleKey) {
+    throw new Error(
+      'Evidence preflight failed: roleKey is required (preflight.evidence.roleKey or input.businessRoleRef).'
+    );
+  }
+  const rows = await loadLiveEvidenceRows(authContext, spec);
+  const missing = findMissingEvidenceKeys(spec, rows);
+  if (missing.length > 0) {
+    throw new Error(
+      'Evidence preflight failed: required Evidence is not active in the dataplane: ' +
+        `${missing.join('; ')}. Upload the Role Assistant package to the target dataplane, ` +
+        'then retry. Hard stop.'
+    );
+  }
+  return { skipped: false, requiredKeys: spec.requiredKeys, rows };
+}
+
+function evaluateEvidenceExpectations(evidenceSpec, observation) {
+  const requiredKeys = asStringList(evidenceSpec?.requiredKeys);
+  if (requiredKeys.length === 0) {
+    return [];
+  }
+  const preflight = observation?.evidencePreflight || {};
+  const liveKeys = new Set(
+    (Array.isArray(preflight.rows) ? preflight.rows : []).map(rowKey).filter(Boolean)
+  );
+  return requiredKeys.map((key) => {
+    const passed = liveKeys.has(key);
+    return {
+      id: `expected.evidence.requiredKeys:${key}`,
+      passed,
+      message: passed
+        ? `Evidence key "${key}" was active in the dataplane at test start.`
+        : `Evidence key "${key}" was not active in the dataplane at test start.`
+    };
+  });
+}
+
+function evaluateForbiddenCapabilities(forbiddenList, observedCapabilities) {
+  if (!Array.isArray(forbiddenList) || forbiddenList.length === 0) {
+    return [];
+  }
+  const observedSet = new Set(observedCapabilities);
+  return forbiddenList.map((capability) => {
+    const key = String(capability || '').trim();
+    const passed = !observedSet.has(key);
+    return {
+      id: `expected.capabilities.forbidden:${key}`,
+      passed,
+      message: passed
+        ? `Forbidden capability "${key}" was not observed.`
+        : `Forbidden capability "${key}" was observed.`
+    };
+  });
+}
+
+module.exports = {
+  evidenceSpecFromCase,
+  findMissingEvidenceKeys,
+  assertRoleAssistantEvidencePreflight,
+  evaluateEvidenceExpectations,
+  evaluateForbiddenCapabilities
+};

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

@@ -4,6 +4,8 @@
 
 'use strict';
 
+const { skipRow, notesRow } = require('./test-case-assertion-row');
+
 const HONESTY_COMPLETION_STATES = new Set([
   'notEvaluated',
   'waiting',
@@ -26,6 +28,14 @@ const HONESTY_CONTRIB_STATUSES = new Set([
   'notRealized',
   'partial'
 ]);
+const OBJECTIVE_TEXT_KEYS = new Set([
+  'objective',
+  'goal',
+  'planObjective',
+  'objectiveSummary',
+  'acceptedObjective'
+]);
+const FORBIDDEN_BUILDER_TOKEN = /\b(?:knownPlatform|gold-package|[a-z][a-z0-9-]*\.[a-z][a-zA-Z0-9]+)\b/i;
 
 function emptyHonestyObservation() {
   return {
@@ -83,7 +93,59 @@ function pushHonestyAssertion(assertions, id, passed, message, options = {}) {
   assertions.push({ id, passed, message });
 }
 
-function assertWorkResultPresent(assertions, honesty, observation) {
+function collectObjectiveStrings(value, acc) {
+  if (Array.isArray(value)) {
+    value.forEach((item) => collectObjectiveStrings(item, acc));
+    return;
+  }
+  if (!value || typeof value !== 'object') {
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (OBJECTIVE_TEXT_KEYS.has(key) && typeof child === 'string') {
+      acc.push(child);
+    } else if (child && typeof child === 'object') {
+      collectObjectiveStrings(child, acc);
+    }
+  }
+}
+
+function interactionObjectiveText(row) {
+  if (!row || typeof row !== 'object') {
+    return '';
+  }
+  const role = String(row.role || row.type || '').toLowerCase();
+  if (role === 'user' || role === 'human') {
+    return '';
+  }
+  return [row.message, row.content, row.text, row.objective]
+    .filter((item) => typeof item === 'string')
+    .join('\n');
+}
+
+function governedObjectiveHaystack(observation) {
+  const parts = [];
+  collectObjectiveStrings(observation.workResult || {}, parts);
+  collectObjectiveStrings(observation.emittedBid || {}, parts);
+  for (const row of Array.isArray(observation.interactions) ? observation.interactions : []) {
+    const text = interactionObjectiveText(row);
+    if (text) {
+      parts.push(text);
+    }
+  }
+  return parts.join('\n');
+}
+
+function assertWorkResultPresent(assertions, honestySpec, honesty, observation, soft) {
+  if (honestySpec.requireWorkResult === false) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.requireWorkResult',
+        'requireWorkResult is false — work.result is not required.'
+      )
+    );
+    return;
+  }
   const present = honesty.present === true;
   const missingSuffix = observation.workResultError
     ? `: ${observation.workResultError}`
@@ -94,7 +156,8 @@ function assertWorkResultPresent(assertions, honesty, observation) {
     present,
     present
       ? 'work.result Output was present.'
-      : `work.result Output missing${missingSuffix}`
+      : `work.result Output missing${missingSuffix}`,
+    { soft }
   );
 }
 
@@ -102,6 +165,15 @@ function assertSchemaVersion(assertions, honestySpec, honesty, soft) {
   if (!honestySpec.schemaVersion) {
     return;
   }
+  if (!honesty.present) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.schemaVersion',
+        'schemaVersion skipped because work.result is absent.'
+      )
+    );
+    return;
+  }
   const expected = String(honestySpec.schemaVersion);
   const passed = String(honesty.schemaVersion || '') === expected;
   pushHonestyAssertion(
@@ -117,6 +189,12 @@ function assertSchemaVersion(assertions, honestySpec, honesty, soft) {
 
 function assertCompletion(assertions, honestySpec, honesty, soft) {
   if (honestySpec.requireCompletion === false) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.requireCompletion',
+        'requireCompletion is false — completion check skipped.'
+      )
+    );
     return;
   }
   const stateOk = HONESTY_COMPLETION_STATES.has(String(honesty.completionState || ''));
@@ -134,6 +212,12 @@ function assertCompletion(assertions, honestySpec, honesty, soft) {
 
 function assertContribution(assertions, honestySpec, honesty, soft) {
   if (honestySpec.requireContributionObservation === false) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.requireContributionObservation',
+        'requireContributionObservation is false — contribution check skipped.'
+      )
+    );
     return;
   }
   const ok = HONESTY_CONTRIB_STATUSES.has(String(honesty.contributionStatus || ''));
@@ -149,9 +233,28 @@ function assertContribution(assertions, honestySpec, honesty, soft) {
 }
 
 function assertMinResourceChanges(assertions, honestySpec, honesty, soft) {
+  if (typeof honestySpec.softResourceChanges === 'boolean') {
+    assertions.push(
+      notesRow(
+        'expected.honesty.softResourceChanges',
+        honestySpec.softResourceChanges
+          ? 'softResourceChanges: true — minResourceChanges misses are warnings.'
+          : 'softResourceChanges: false — minResourceChanges misses are blocking.'
+      )
+    );
+  }
   if (typeof honestySpec.minResourceChanges !== 'number') {
     return;
   }
+  if (!honesty.present) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.minResourceChanges',
+        'minResourceChanges skipped because work.result is absent.'
+      )
+    );
+    return;
+  }
   const count = Number(honesty.resourceChangeCount || 0);
   const passed = count >= honestySpec.minResourceChanges;
   const softChange = soft || honestySpec.softResourceChanges === true;
@@ -171,6 +274,53 @@ function assertMinResourceChanges(assertions, honestySpec, honesty, soft) {
   }
 }
 
+function assertForbidBuilderKeys(assertions, honestySpec, observation, soft) {
+  if (honestySpec.forbidBuilderKeysInObjective === false) {
+    assertions.push(
+      skipRow(
+        'expected.honesty.forbidBuilderKeysInObjective',
+        'forbidBuilderKeysInObjective is false — Builder-key check skipped.'
+      )
+    );
+    return;
+  }
+  if (honestySpec.forbidBuilderKeysInObjective !== true) {
+    return;
+  }
+  const haystack = governedObjectiveHaystack(observation);
+  const match = haystack.match(FORBIDDEN_BUILDER_TOKEN);
+  const passed = !match;
+  pushHonestyAssertion(
+    assertions,
+    'expected.honesty.forbidBuilderKeysInObjective',
+    passed,
+    passed
+      ? 'Objective text has no Builder capability keys or generation tokens.'
+      : `Objective text contains forbidden token "${match[0]}".`,
+    { soft }
+  );
+}
+
+function emitPresentFlagRows(assertions, honestySpec, honesty, observation, soft) {
+  if (honestySpec.requireCompletion === false || honestySpec.requireCompletion === true) {
+    assertCompletion(assertions, honestySpec, honesty, soft);
+  }
+  if (
+    honestySpec.requireContributionObservation === false ||
+    honestySpec.requireContributionObservation === true
+  ) {
+    assertContribution(assertions, honestySpec, honesty, soft);
+  }
+  if (
+    typeof honestySpec.minResourceChanges === 'number' ||
+    typeof honestySpec.softResourceChanges === 'boolean'
+  ) {
+    assertMinResourceChanges(assertions, honestySpec, honesty, soft);
+  }
+  assertSchemaVersion(assertions, honestySpec, honesty, soft);
+  assertForbidBuilderKeys(assertions, honestySpec, observation, soft);
+}
+
 function evaluateHonestyExpectations(honestySpec, observation, options = {}) {
   if (!honestySpec || typeof honestySpec !== 'object' || Array.isArray(honestySpec)) {
     return [];
@@ -178,17 +328,16 @@ function evaluateHonestyExpectations(honestySpec, observation, options = {}) {
   const soft = options.soft === true;
   const honesty = observation.honesty || {};
   const assertions = [];
-  if (honestySpec.requireWorkResult !== false) {
-    assertWorkResultPresent(assertions, honesty, observation);
-  }
+  assertWorkResultPresent(assertions, honestySpec, honesty, observation, soft);
   if (!honesty.present) {
-    // Missing Output is always a hard failure when required — soft does not waive it.
+    emitPresentFlagRows(assertions, honestySpec, honesty, observation, soft);
     return assertions;
   }
   assertSchemaVersion(assertions, honestySpec, honesty, soft);
   assertCompletion(assertions, honestySpec, honesty, soft);
   assertContribution(assertions, honestySpec, honesty, soft);
   assertMinResourceChanges(assertions, honestySpec, honesty, soft);
+  assertForbidBuilderKeys(assertions, honestySpec, observation, soft);
   return assertions;
 }
 

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

@@ -0,0 +1,291 @@
+/**
+ * Map role-assistant test results to expected lifecycleState tokens.
+ * @fileoverview Prefer work.result completion over coarse work.status.
+ */
+
+'use strict';
+
+const { VERDICT } = require('../lifecycle/product-model');
+
+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'
+});
+const COMPLETION_STATE_TO_LIFECYCLE = Object.freeze({
+  safestopped: 'safe-stop',
+  safe_stopped: 'safe-stop',
+  cancelled: 'rejected',
+  canceled: 'rejected',
+  completed: 'completed',
+  waiting: 'question'
+});
+const STEP_SIGNAL_FIELDS = [
+  'lifecycleState',
+  'state',
+  'status',
+  'code',
+  'errorCode',
+  'reason',
+  'kind',
+  'type',
+  'error',
+  'failure',
+  'details',
+  'result'
+];
+const OBJECT_SIGNAL_FIELDS = [
+  'lifecycleState',
+  'state',
+  'status',
+  'code',
+  'type',
+  'reason',
+  'kind',
+  'category',
+  'errorCode'
+];
+const TOP_LEVEL_SIGNAL_PATHS = [
+  'lifecycleState',
+  'state',
+  'status',
+  'lifecycle.state',
+  'report.lifecycleState',
+  'report.state',
+  'report.status',
+  'report.lifecycle.state',
+  'report.runtime.state',
+  'report.work.state'
+];
+
+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)) {
+    return firstLifecycleFromValues(value);
+  }
+  if (typeof value === 'object') {
+    return firstLifecycleFromValues(OBJECT_SIGNAL_FIELDS.map((field) => value[field]));
+  }
+  return null;
+}
+
+function firstLifecycleFromValues(values) {
+  for (const candidate of values) {
+    const state = lifecycleStateFromSignalValue(candidate);
+    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 workResultCompletionObject(result) {
+  const workResult =
+    result?.workResult && typeof result.workResult === 'object' ? result.workResult : null;
+  const completion =
+    workResult?.completion && typeof workResult.completion === 'object'
+      ? workResult.completion
+      : null;
+  return { workResult, completion };
+}
+
+function mapWorkResultCompletionToLifecycle(result) {
+  const { workResult, completion } = workResultCompletionObject(result);
+  const state = normalizeLifecycleStateToken(completion?.state);
+  if (!workResult || !completion || !state) {
+    return null;
+  }
+  if (state === 'failed') {
+    return workResultSignalsRejected(workResult) ? 'rejected' : 'failed';
+  }
+  return COMPLETION_STATE_TO_LIFECYCLE[state] || lifecycleStateFromToken(state);
+}
+
+function completionReasonBag(processExecution) {
+  const pe = processExecution && typeof processExecution === 'object' ? processExecution : {};
+  if (pe.completionReason && typeof pe.completionReason === 'object') {
+    return pe.completionReason;
+  }
+  if (pe.completion_reason && typeof pe.completion_reason === 'object') {
+    return pe.completion_reason;
+  }
+  return {};
+}
+
+function workResultSignalsRejected(workResult) {
+  const reasonBag = completionReasonBag(workResult?.processExecution);
+  const kind = normalizeLifecycleStateToken(reasonBag.kind || reasonBag.Kind);
+  if (kind === 'rejected' || kind === 'denied' || kind === 'unauthorized') {
+    return true;
+  }
+  const text = [
+    reasonBag.summary,
+    workResult?.completion?.businessLanguage?.reason,
+    workResult?.completion?.businessLanguage?.summary,
+    workResult?.completion?.businessLanguage?.outcomeState,
+    workResult?.task?.resultSummary
+  ]
+    .filter((row) => typeof row === 'string' && row.trim())
+    .join(' ')
+    .toLowerCase();
+  return /\b(trust|authority|denied|rejected|unauthorized|not authorized)\b/.test(text);
+}
+
+function valueAtDottedPath(source, dottedPath) {
+  return dottedPath.split('.').reduce((cursor, key) => {
+    if (!cursor || typeof cursor !== 'object') {
+      return undefined;
+    }
+    return cursor[key];
+  }, source);
+}
+
+function lifecycleStateFromStepsRun(result) {
+  const steps = Array.isArray(result?.stepsRun) ? result.stepsRun : [];
+  for (const row of steps) {
+    const state = firstLifecycleFromValues(STEP_SIGNAL_FIELDS.map((field) => row?.[field]));
+    if (state) {
+      return state;
+    }
+  }
+  return null;
+}
+
+function resolveLifecycleStateFromResult(result) {
+  // Prefer governed work.result completion over coarse work.status "stopped"
+  // (which collapses failed + safeStopped + cancelled into safe-stop).
+  return (
+    mapWorkResultCompletionToLifecycle(result) ||
+    mapWorkStatusFromResult(result) ||
+    mapWorkerTaskStateFromResult(result) ||
+    firstLifecycleFromValues(TOP_LEVEL_SIGNAL_PATHS.map((path) => valueAtDottedPath(result, path))) ||
+    lifecycleStateFromStepsRun(result)
+  );
+}
+
+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';
+}
+
+module.exports = {
+  SUPPORTED_LIFECYCLE_STATES,
+  deriveLifecycleState
+};