@moretea-labs/forge 1.7.1 → 1.8.0

package/src/runtime/control-plane/execution/work-validation-reconciler.ts

@@ -1,8 +1,13 @@
 import {
+  failWorkContract,
   getWorkContract,
+  recordWorkEvidenceState,
+  requestWorkImplementationReview,
   transitionWorkContractPhase,
   updateWorkContract,
-} from '../facade/work-contract-store';
+  workRequiresImplementationReview,
+  latestImplementationReview,
+} from '../../../../packages/kernel/work/api/index';
 import {
   listValidatingWorkHandles,
   transitionWorkHandle,
@@ -53,7 +58,26 @@ export function markWorkValidationPending(controllerHome: string, handle: WorkHa
   const evidenceState = contract.evidenceState === 'valid' || contract.evidenceState === 'stale'
     ? 'stale'
     : 'partial';
-  if (contract.evidenceState !== evidenceState) updateWorkContract(options, contractId, { evidenceState });
+  if (contract.evidenceState !== evidenceState) recordWorkEvidenceState(options, contractId, evidenceState);
+}
+
+/**
+ * Re-bind aggregate validation authority after the physical Work validator has
+ * proved that every requested check is satisfied by an exact-current persisted
+ * valid_pass receipt. This is not a new validation run: no check was executed
+ * and source/workspace/check identity did not change, so an already-approved
+ * implementation review remains authoritative.
+ */
+export function markWorkValidationCurrentFromReusedEvidence(controllerHome: string, handle: WorkHandleState): void {
+  if (handle.finalization.validation !== 'done' || !handle.validatedInputFingerprint) {
+    throw new Error('WORK_REUSED_VALIDATION_AUTHORITY_INCOMPLETE');
+  }
+  const contractId = handle.workContractId;
+  if (!contractId) return;
+  const options = { controllerHome, repoId: handle.repositoryId };
+  const contract = getWorkContract(options, contractId);
+  if (!contract || contract.completionReceipt) return;
+  if (contract.evidenceState !== 'valid') recordWorkEvidenceState(options, contractId, 'valid');
 }
 
 /**
@@ -61,11 +85,17 @@ export function markWorkValidationPending(controllerHome: string, handle: WorkHa
  * Process and Check records contribute evidence only; they never become a
  * second completion or lifecycle authority.
  */
+export interface WorkValidationProjectionCandidate {
+  sourceRevision: string;
+  workspaceFingerprint: string;
+}
+
 export function projectWorkValidationOutcome(
   controllerHome: string,
   handle: WorkHandleState,
   outcome: Exclude<WorkValidationOutcome, 'not_validating' | 'running'>,
   summary?: string,
+  candidate?: WorkValidationProjectionCandidate,
 ): void {
   const contractId = handle.workContractId;
   if (!contractId) return;
@@ -74,26 +104,63 @@ export function projectWorkValidationOutcome(
   if (!contract || contract.completionReceipt) return;
 
   if (outcome === 'passed') {
+    // Validation reconciliation may be replayed during finalization. A receipt
+    // that is already current must not rewind an active or explicitly approved
+    // review. A genuinely new validation first marks evidence stale/partial, so
+    // only that path may re-enter verification/review. No-check commit transfer
+    // can preserve an approved review before evidenceState itself is projected.
+    const validationWasRearmed = contract.evidenceState === 'stale' || contract.evidenceState === 'partial';
+    const currentReviewIsAuthoritative = contract.phase === 'review' && contract.evidenceState === 'valid';
+    const latestReview = latestImplementationReview(contract.implementationReviews);
+    const approvedReviewMatchesCurrentCandidate = Boolean(
+      candidate
+      && contract.phase === 'delivery'
+      && contract.phaseEvidence.review.state === 'satisfied'
+      && latestReview?.decision === 'approved'
+      && latestReview.sourceRevision === candidate.sourceRevision
+      && latestReview.verificationWorkspaceFingerprint === candidate.workspaceFingerprint
+    );
+    const approvedDeliveryIsAuthoritative = contract.phase === 'delivery'
+      && contract.phaseEvidence.review.state === 'satisfied'
+      && (!validationWasRearmed || approvedReviewMatchesCurrentCandidate);
+    if (currentReviewIsAuthoritative || approvedDeliveryIsAuthoritative) {
+      if (approvedReviewMatchesCurrentCandidate && contract.evidenceState !== 'valid') {
+        recordWorkEvidenceState(options, contractId, 'valid');
+      }
+      return;
+    }
+    const verified = transitionWorkContractPhase(options, contractId, {
+      phase: 'verification',
+      status: 'running',
+      state: 'satisfied',
+      summary: summary ?? 'All requested validation receipts passed.',
+      evidenceRefs: contract.evidenceRefs,
+    });
+    recordWorkEvidenceState(options, contractId, 'valid');
+    if (workRequiresImplementationReview(verified.workKind, verified.scopeEvidence?.actualChangedPaths ?? [])) {
+      requestWorkImplementationReview(
+        options,
+        contractId,
+        'Validation receipts passed; explicit Controller implementation review is required before delivery.',
+      );
+      return;
+    }
     transitionWorkContractPhase(options, contractId, {
       phase: 'delivery',
       status: 'running',
       state: 'active',
-      summary: summary ?? 'All requested validation receipts passed; delivery is next.',
-      evidenceRefs: contract.evidenceRefs,
+      summary: 'Validation receipts passed and this Work kind does not require implementation review; delivery is next.',
+      evidenceRefs: verified.evidenceRefs,
     });
-    updateWorkContract(options, contractId, { evidenceState: 'valid' });
     return;
   }
 
   if (outcome === 'failed') {
-    transitionWorkContractPhase(options, contractId, {
-      phase: 'cleanup',
-      status: 'failed',
-      state: 'failed',
-      summary: summary ?? 'A requested validation check failed; terminal cleanup is next.',
+    failWorkContract(options, contractId, {
+      phase: contract.phase,
+      summary: summary ?? `A requested validation check failed while Work was in ${contract.phase}.`,
       evidenceRefs: contract.evidenceRefs,
     });
-    updateWorkContract(options, contractId, { evidenceState: 'failed' });
     return;
   }
 
@@ -101,12 +168,15 @@ export function projectWorkValidationOutcome(
     phase: 'verification',
     status: 'running',
     state: 'blocked',
+    dispatchState: 'blocked',
     summary: summary ?? 'Validation infrastructure failed; retain the finite Work for retry without treating this as an acceptance failure.',
     evidenceRefs: contract.evidenceRefs,
   });
-  updateWorkContract(options, contractId, {
-    evidenceState: contract.evidenceState === 'valid' || contract.evidenceState === 'stale' ? 'stale' : 'partial',
-  });
+  recordWorkEvidenceState(
+    options,
+    contractId,
+    contract.evidenceState === 'valid' || contract.evidenceState === 'stale' ? 'stale' : 'partial',
+  );
 }
 
 function settleInfrastructureFailure(
@@ -115,7 +185,7 @@ function settleInfrastructureFailure(
   summary: string,
 ): WorkValidationReconciliation {
   const next = transitionWorkHandle(controllerHome, handle, 'failed', {
-    finalization: { ...handle.finalization, validation: 'failed', lastError: summary },
+    finalization: { ...handle.finalization, validation: 'failed', failureCode: undefined, lastError: summary },
     validationRun: undefined,
     failureReason: summary,
   });
@@ -141,7 +211,7 @@ export function reconcileWorkValidation(
 
   if (run.requestedChecks.length === 0) {
     const next = transitionWorkHandle(controllerHome, handle, run.resumeState, {
-      finalization: { ...handle.finalization, validation: 'done', lastError: undefined },
+      finalization: { ...handle.finalization, validation: 'done', failureCode: undefined, lastError: undefined },
       validationRun: undefined,
       validatedInputFingerprint: run.fingerprint,
       failureReason: undefined,
@@ -203,7 +273,7 @@ export function reconcileWorkValidation(
           return settleInfrastructureFailure(controllerHome, handle, receipt.summary);
         }
         const next = transitionWorkHandle(controllerHome, handle, 'failed', {
-          finalization: { ...handle.finalization, validation: 'failed', lastError: receipt.summary },
+          finalization: { ...handle.finalization, validation: 'failed', failureCode: undefined, lastError: receipt.summary },
           validationRun: undefined,
           failureReason: receipt.summary,
         });
@@ -217,7 +287,7 @@ export function reconcileWorkValidation(
   }
 
   const next = transitionWorkHandle(controllerHome, handle, run.resumeState, {
-    finalization: { ...handle.finalization, validation: 'done', lastError: undefined },
+    finalization: { ...handle.finalization, validation: 'done', failureCode: undefined, lastError: undefined },
     validationRun: undefined,
     validatedInputFingerprint: run.fingerprint,
     failureReason: undefined,

package/src/runtime/control-plane/execution/work-verification-context.ts

@@ -1,7 +1,7 @@
 import { listControllerChecks, type ControllerCheck } from '../../../cli/controller/check-runner';
 import { selectRepositoryCheckout } from '../../../cli/repositories/registry';
 import type { RepositoryRecord } from '../../../cli/repositories/types';
-import { getWorkContract } from '../facade/work-contract-store';
+import { getWorkContract } from '../../../../packages/kernel/work/api/index';
 import type { WorkContract } from '../facade/types';
 
 export interface WorkVerificationContext {

package/src/runtime/control-plane/execution/work-verification-service.ts

@@ -1,4 +1,5 @@
-import { readLatestControllerCheckEvidence } from '../../../cli/controller/check-runner';
+import { createHash } from 'crypto';
+import { controllerCheckExecutionIdentity, listControllerChecks, readLatestControllerCheckEvidence } from '../../../cli/controller/check-runner';
 import { repositoryGitStatus } from '../../../cli/repositories/structured-git';
 import type { RepositoryRecord } from '../../../cli/repositories/types';
 import {
@@ -10,12 +11,14 @@ import {
   runPersistedCheckViaProcessRuntime,
 } from '../../execution/process-runtime';
 import { classifyPersistedCheckTerminalEvidence } from '../../execution/process-runtime/check-result';
+import { buildCheckExecutionSchedule } from '../../execution/process-runtime/check-scheduling';
+import { ingestCheckCompletionGraceProcess } from '../persistence/operational-prior-store';
 import { buildFacadeResult } from '../facade/facade-result';
 import { classifyVerificationOutcome, normalizeCheckIds } from '../facade/check-normalization';
 import { verifyGoalWorkloop } from '../facade/goal-workloop';
-import type { FacadeResult, WorkContract } from '../facade/types';
+import type { FacadeResult, VerificationRecord, WorkContract } from '../facade/types';
 import { executionIdentityForRepository } from './execution-identity';
-import { commandFingerprint, verificationInputFingerprint, workspaceValidationFingerprint } from './verification-evidence';
+import { commandFingerprint, effectiveVerificationEvidence, verificationInputFingerprint, workspaceValidationFingerprint } from './verification-evidence';
 import { resolveWorkVerificationContext } from './work-verification-context';
 
 export interface ExecuteWorkVerificationInput {
@@ -45,6 +48,244 @@ function result(facade: FacadeResult, isError = false): ExecuteWorkVerificationR
   return { facade, isError };
 }
 
+export interface ContentEquivalentWorkVerificationTransferPlan {
+  transferredRecords: VerificationRecord[];
+  reusableCheckIds: string[];
+  invalidatedCheckIds: string[];
+}
+
+/**
+ * Pure verification-transfer planner for a Forge-owned representation-only
+ * commit. It never mutates Work authority. The caller must persist the complete
+ * verification + derived-review + lifecycle transfer atomically.
+ */
+export function planWorkVerificationAcrossContentEquivalentCommit(input: {
+  controllerHome: string;
+  repository: RepositoryRecord;
+  workId: string;
+  preCommitSourceRevision: string;
+  preCommitWorkspaceFingerprint: string;
+  postCommitSourceRevision: string;
+  postCommitWorkspaceFingerprint: string;
+  recordedAt?: string;
+}): ContentEquivalentWorkVerificationTransferPlan {
+  const resolved = resolveWorkVerificationContext({
+    controllerHome: input.controllerHome,
+    repository: input.repository,
+    workId: input.workId,
+  });
+  if (!resolved.ok || !resolved.context.workContract) {
+    throw new Error(`WORK_VERIFICATION_TRANSFER_CONTEXT_REQUIRED: ${input.workId}`);
+  }
+  const { workContract, repository, checks } = resolved.context;
+  if (workContract.completionReceipt) throw new Error(`WORK_VERIFICATION_TRANSFER_WORK_TERMINAL: ${input.workId}`);
+  const requestedChecks = workContract.checks;
+  const checkById = new Map(listControllerChecks(repository.canonicalRoot).map((check) => [check.id, check] as const));
+  const transferredRecords: VerificationRecord[] = [];
+  const reusableCheckIds: string[] = [];
+  const invalidatedCheckIds: string[] = [];
+  const recordedAt = input.recordedAt ?? new Date().toISOString();
+
+  for (const checkId of requestedChecks) {
+    const check = checkById.get(checkId) ?? checks.find((entry) => entry.id === checkId);
+    const sourcePass = effectiveVerificationEvidence(workContract.checkRefs, {
+      sourceRevision: input.preCommitSourceRevision,
+      workspaceFingerprint: input.preCommitWorkspaceFingerprint,
+      checkId,
+      requestedChecks,
+    }).find((entry) => entry.current && entry.record.outcome === 'valid_pass' && Boolean(entry.record.receipt))?.record;
+    if (!check || !sourcePass?.receipt || check.effects?.git !== undefined) {
+      invalidatedCheckIds.push(checkId);
+      continue;
+    }
+    let currentExecutionIdentity;
+    try {
+      currentExecutionIdentity = controllerCheckExecutionIdentity(repository.canonicalRoot, checkId);
+    } catch {
+      invalidatedCheckIds.push(checkId);
+      continue;
+    }
+    const receipt = sourcePass.receipt;
+    const definitionUnchanged = Boolean(receipt.checkDefinitionDigest)
+      && receipt.checkDefinitionDigest === currentExecutionIdentity.definitionDigest;
+    const contentInputsUnchanged = Boolean(receipt.checkRevision)
+      && receipt.checkRevision === currentExecutionIdentity.revision;
+    const environmentUnchanged = Boolean(receipt.checkEnvironmentFingerprint)
+      && receipt.checkEnvironmentFingerprint === currentExecutionIdentity.environmentFingerprint;
+    if (!definitionUnchanged || !contentInputsUnchanged || !environmentUnchanged) {
+      invalidatedCheckIds.push(checkId);
+      continue;
+    }
+    const transferred: VerificationRecord = {
+      ...sourcePass,
+      summary: `Verification authority transferred across a content-equivalent Forge commit for ${checkId}.`,
+      recordedAt,
+      sourceRevision: input.postCommitSourceRevision,
+      workspaceFingerprint: input.postCommitWorkspaceFingerprint,
+      verificationInputFingerprint: verificationInputFingerprint({
+        sourceRevision: input.postCommitSourceRevision,
+        workspaceFingerprint: input.postCommitWorkspaceFingerprint,
+        checkId,
+        requestedChecks,
+      }),
+      evidenceRef: {
+        title: checkId,
+        summary: 'Reused the exact persisted Process receipt after proving check definition, content inputs, environment, and non-Git read semantics are unchanged across the commit.',
+        detailLevel: 'summary',
+      },
+    };
+    transferredRecords.push(transferred);
+    reusableCheckIds.push(checkId);
+  }
+
+  return { transferredRecords, reusableCheckIds, invalidatedCheckIds };
+}
+
+const MAX_WORK_VERIFY_BATCH_CHECKS = 32;
+
+export interface ExecuteWorkVerificationBatchInput extends Omit<ExecuteWorkVerificationInput, 'checkId'> {
+  checkIds: string[];
+}
+
+function boundedCheckSchedulingPayload(schedule: ReturnType<typeof buildCheckExecutionSchedule>) {
+  return {
+    waveCount: schedule.waves.length,
+    maxParallel: schedule.maxParallel,
+    waves: schedule.waves,
+    conflicts: schedule.conflicts,
+    invalidCheckIds: schedule.invalidCheckIds,
+    guidance: schedule.guidance,
+  };
+}
+
+/**
+ * Canonical batch wrapper for rh_work verification. Scheduling remains advisory
+ * and Process Runtime resource claims remain the execution/lease authority.
+ * Every member still executes through executeWorkVerification so Work snapshot,
+ * Failure Contract, VerificationRecord, and lifecycle semantics stay singular.
+ */
+export async function executeWorkVerificationBatch(input: ExecuteWorkVerificationBatchInput): Promise<ExecuteWorkVerificationResult> {
+  const workId = input.workId?.trim() ?? '';
+  const requestedCheckIds = [...new Set(input.checkIds.map((value) => value.trim()).filter(Boolean))];
+  if (requestedCheckIds.length === 0) {
+    return result(buildFacadeResult({
+      status: 'blocked',
+      summary: 'Work batch verification requires a non-empty check_ids array.',
+      data: { batch: true, checkIds: [], verificationStarted: false },
+      warnings: ['CHECK_IDS_REQUIRED: pass between 1 and 32 registered check ids.'],
+    }), true);
+  }
+  if (requestedCheckIds.length > MAX_WORK_VERIFY_BATCH_CHECKS) {
+    return result(buildFacadeResult({
+      status: 'blocked',
+      summary: `Work batch verification accepts at most ${MAX_WORK_VERIFY_BATCH_CHECKS} distinct check ids.`,
+      data: { batch: true, checkIds: requestedCheckIds.slice(0, MAX_WORK_VERIFY_BATCH_CHECKS), verificationStarted: false },
+      warnings: ['CHECK_IDS_LIMIT_EXCEEDED'],
+    }), true);
+  }
+
+  const resolvedVerification = resolveWorkVerificationContext({
+    controllerHome: input.controllerHome,
+    repository: input.repository,
+    workId,
+  });
+  if (!resolvedVerification.ok) {
+    return result(buildFacadeResult({
+      status: 'blocked',
+      summary: `${resolvedVerification.code}: ${resolvedVerification.detail}`,
+      data: { batch: true, checkIds: requestedCheckIds, verificationStarted: false },
+      warnings: ['Work batch verification never falls back to a different checkout or check registry.'],
+    }), true);
+  }
+
+  const { repository: verificationRepository, checks } = resolvedVerification.context;
+  const checksById = new Map(checks.map((check) => [check.id, check] as const));
+  const schedule = buildCheckExecutionSchedule({
+    checks,
+    requestedCheckIds,
+    repoId: verificationRepository.repoId,
+    checkoutId: verificationRepository.activeCheckoutId,
+  });
+  const checkScheduling = boundedCheckSchedulingPayload(schedule);
+  if (schedule.invalidCheckIds.length > 0) {
+    return result(buildFacadeResult({
+      status: 'blocked',
+      summary: `Work batch verification contains unregistered checks: ${schedule.invalidCheckIds.join(', ')}`,
+      data: { batch: true, checkIds: requestedCheckIds, checkScheduling, verificationStarted: false },
+      warnings: ['INVALID_CHECK_IDS'],
+    }), true);
+  }
+  const durableCheckIds = requestedCheckIds.filter((checkId) => checkRequiresDurableWorkflow(checksById.get(checkId)));
+  if (durableCheckIds.length > 0) {
+    return result(buildFacadeResult({
+      status: 'blocked',
+      summary: 'Work batch verification only launches ordinary focused checks; durable release or multi-phase checks must be verified individually.',
+      data: { batch: true, checkIds: requestedCheckIds, durableCheckIds, checkScheduling, verificationStarted: false },
+      warnings: ['BATCH_CONTAINS_DURABLE_CHECK'],
+    }), true);
+  }
+  if (schedule.waves.length !== 1 || schedule.waves[0]?.checkIds.length !== requestedCheckIds.length) {
+    return result(buildFacadeResult({
+      status: 'blocked',
+      summary: 'Requested Work checks span multiple resource-conflicting waves; submit one returned wave per verify call.',
+      data: { batch: true, checkIds: requestedCheckIds, checkScheduling, verificationStarted: false },
+      warnings: ['BATCH_SPANS_MULTIPLE_CHECK_WAVES'],
+    }), true);
+  }
+
+  const baseRequestId = input.requestId?.trim() ?? '';
+  const batchDigest = createHash('sha256').update(JSON.stringify(requestedCheckIds)).digest('hex').slice(0, 8);
+  const executions = await Promise.all(requestedCheckIds.map((checkId, index) => executeWorkVerification({
+    ...input,
+    checkId,
+    requestId: baseRequestId ? `${baseRequestId}:batch:${index + 1}:${batchDigest}` : undefined,
+  })));
+  const verifications: Array<Record<string, unknown> & { checkId: string; facadeStatus: FacadeResult['status']; isError: boolean }> = executions.map((execution, index) => {
+    const data = execution.facade.data as Record<string, unknown>;
+    const verification = data.verification && typeof data.verification === 'object' && !Array.isArray(data.verification)
+      ? data.verification as Record<string, unknown>
+      : {};
+    return {
+      checkId: requestedCheckIds[index],
+      ...verification,
+      facadeStatus: execution.facade.status,
+      isError: execution.isError,
+    };
+  });
+  const completed = verifications.every((verification) => verification.completed === true);
+  const allPassed = completed && verifications.every((verification) => verification.outcome === 'valid_pass');
+  const anyAcceptanceFailure = verifications.some((verification) => verification.outcome === 'valid_fail');
+  const anyInfrastructureFailure = verifications.some((verification) => verification.outcome === 'infrastructure_failure');
+  const anyBlocked = executions.some((execution) => execution.facade.status === 'blocked');
+  const processIds = verifications
+    .map((verification) => typeof verification.processId === 'string' ? verification.processId : '')
+    .filter(Boolean);
+  const facade = buildFacadeResult({
+    status: anyAcceptanceFailure ? 'failed' : anyBlocked ? 'blocked' : 'ok',
+    summary: completed
+      ? allPassed
+        ? `Work verification batch passed ${requestedCheckIds.length} checks.`
+        : anyAcceptanceFailure
+          ? 'Work verification batch completed with an acceptance failure.'
+          : anyInfrastructureFailure
+            ? 'Work verification batch completed with an infrastructure failure.'
+            : 'Work verification batch completed.'
+      : `Work verification batch launched ${requestedCheckIds.length} resource-compatible checks through Process Runtime.`,
+    data: {
+      batch: true,
+      checkIds: requestedCheckIds,
+      checkScheduling,
+      verifications,
+      processIds,
+      completed,
+      ...(completed ? { ok: allPassed } : {}),
+    },
+    warnings: anyInfrastructureFailure ? ['infrastructure_failure is distinct from acceptance failure'] : [],
+    rawAvailable: false,
+  });
+  return result(facade, anyAcceptanceFailure || executions.some((execution) => execution.isError && execution.facade.status !== 'ok'));
+}
+
 /**
  * Canonical Work verification application service.
  *
@@ -166,7 +407,7 @@ export async function executeWorkVerification(input: ExecuteWorkVerificationInpu
       requestedChecks,
     }) : undefined;
     const registeredCheck = checks.find((entry) => entry.id === normalizedCheckId);
-    const durableClassCheck = checkRequiresDurableWorkflow(normalizedCheckId, registeredCheck);
+    const durableClassCheck = checkRequiresDurableWorkflow(registeredCheck);
     const allowDurableCheckExecution = Boolean(
       durableClassCheck
       && workContract
@@ -283,6 +524,18 @@ export async function executeWorkVerification(input: ExecuteWorkVerificationInpu
       || evidenceState.state !== 'matched'
       || (!receipt.ok && failureClass !== 'acceptance_failure');
     const checkFailed = !receipt.ok && !infrastructureFailed;
+    if (receipt.ok && evidenceState.state === 'matched') {
+      try {
+        ingestCheckCompletionGraceProcess({
+          controllerHome: input.controllerHome,
+          repoId: verificationRepository.repoId,
+          processId: receipt.processId,
+        });
+      } catch {
+        // Operational Memory is a disposable derived optimization. Its failure
+        // must never change Check/Work correctness or lifecycle truth.
+      }
+    }
     const commonVerification = {
       checkId: normalizedCheckId,
       outcome: infrastructureFailed ? 'infrastructure_failure' : receipt.ok ? 'valid_pass' : 'valid_fail',
@@ -304,6 +557,7 @@ export async function executeWorkVerification(input: ExecuteWorkVerificationInpu
       evidenceArtifactPath: record.origin?.workVerificationSnapshot ? undefined : receipt.artifactPath,
       evidenceReceiptId: receipt.receiptId,
       checkResultReceiptId: structuredCheckResult?.receiptId,
+      ...(evidenceState.failureEvidence ? { failureEvidence: evidenceState.failureEvidence } : {}),
       verificationIsolation: record.origin?.workVerificationSnapshot ? 'work_snapshot' : 'shared_checkout',
       boundedStatus: receipt.ok ? 'pass' : infrastructureFailed ? 'infrastructure_failure' : 'fail',
       evidenceState: evidenceState.state,