@open-agent-toolkit/cli 0.2.54 → 0.2.55

package/assets/skills/recon/scripts/lib/contracts.mjs

@@ -6,8 +6,6 @@ export const artifactKinds = new Set([
   'recon.raw-dossier',
   'recon.review-brief',
   'recon.review-result',
-  'recon.stage-result',
-  'recon.dispatch-receipt',
 ]);
 
 export const profiles = ['quick', 'standard', 'thorough'];
@@ -36,11 +34,17 @@ export const workerModes = [
   'coverage',
   'reconcile',
 ];
-export const stageModes = [
+export const evidenceRelations = [
+  'supports',
+  'contradicts',
+  'qualifies',
+  'context',
+];
+export const authorityLevels = ['provider-enforced', 'contract-enforced'];
+export const waveModes = [
   'map',
   'gather',
   'compile',
-  'locator-validation',
   'semantic-verification',
   'adversarial',
   'coverage',
@@ -176,44 +180,6 @@ function requiredArray(value, key, errors, path = '$') {
   }
 }
 
-function requiredCanonicalStringSet(value, key, errors, path = '$') {
-  requiredArray(value, key, errors, path);
-  if (!Array.isArray(value?.[key])) return;
-  const entries = value[key];
-  for (const [index, entry] of entries.entries()) {
-    if (typeof entry !== 'string' || entry.trim().length === 0) {
-      errors.push(
-        issue(
-          'INVALID_ARRAY_ENTRY',
-          `${key} entries must be non-empty strings`,
-          `${path}.${key}[${index}]`,
-        ),
-      );
-    }
-  }
-  if (new Set(entries).size !== entries.length) {
-    errors.push(
-      issue(
-        'DUPLICATE_ARRAY_ENTRY',
-        `${key} entries must be unique`,
-        `${path}.${key}`,
-      ),
-    );
-  }
-  const sorted = entries.every((entry) => typeof entry === 'string')
-    ? [...entries].sort()
-    : null;
-  if (sorted && entries.some((entry, index) => entry !== sorted[index])) {
-    errors.push(
-      issue(
-        'NON_CANONICAL_ARRAY_ORDER',
-        `${key} entries must use stable sorted order`,
-        `${path}.${key}`,
-      ),
-    );
-  }
-}
-
 function requiredObject(value, key, errors, path = '$') {
   if (!isObject(value?.[key])) {
     errors.push(
@@ -254,401 +220,181 @@ function duplicateIds(values, path, errors) {
   }
 }
 
-const projectionKeys = new Set([
-  'schema',
-  'prepared_record_version',
-  'run_id',
-  'prepared_at',
-  'request',
-  'selection',
-  'execution',
-  'catalog_observation',
-]);
-const requestKeys = new Set([
-  'request_id',
-  'caller',
-  'objective',
-  'action',
-  'expected_output',
-  'verification_evidence',
-  'escalate_when',
-]);
-const selectionKeys = new Set([
-  'provider',
-  'dispatch_context',
-  'dispatch_policy',
-  'dispatch_ceiling',
-  'selected_route',
-  'selection_source',
-  'candidates_considered',
-  'selection_reason',
-  'role_name',
-  'role_class',
-  'role_selector',
-  'model_selector',
-  'model_selector_granularity',
-  'effort_selector',
-  'reasoning_mode_selector',
-  'service_tier_selector',
-  'guidance_reference',
-  'guidance_version',
-  'guidance_verified_at',
-  'guidance_status',
-]);
-const pinnedTargetKeys = new Set([
+const executionKeys = new Set([
   'provider',
-  'dispatch_context',
-  'selected_route',
-  'role_selector',
-  'model_selector',
-  'model_selector_granularity',
-  'effort_selector',
-  'reasoning_mode_selector',
-  'service_tier_selector',
-]);
-const waveKeys = new Set([
-  'wave_id',
-  'conditional',
-  'task_class',
-  'model_class_floor',
-  'scope',
-  'lanes',
+  'route',
+  'role',
+  'model',
+  'effort',
+  'reasoningMode',
+  'serviceTier',
   'authority',
-  'authorization_scope',
-  'writable_roots',
-  'deadline_seconds',
-  'retry_limit',
-  'fallback',
-  'dispatch_mode',
-  'context_fork_controls',
-  'concurrency',
-  'lane_cap',
-  'payload_digest',
-]);
-const catalogKeys = new Set([
-  'id',
-  'source',
-  'dispatch_context',
-  'observed_at',
-  'relevant_catalog_fingerprint',
+  'maxConcurrency',
+  'deadlineSeconds',
+  'retryLimit',
+  'waves',
+  'approval',
 ]);
 
-export function validateApprovalProjection(value, errors, path) {
+export function approvalFingerprintInput(execution) {
+  const { approval: _approval, ...approved } = execution;
+  return approved;
+}
+
+function validateApprovalEvidence(value, errors, path) {
   if (!isObject(value)) return;
-  closedObject(value, projectionKeys, errors, path);
-  if (value.schema !== 'oat-dispatch-approval/v1') {
+  closedObject(
+    value,
+    new Set(['type', 'approvedAt', 'fingerprint']),
+    errors,
+    path,
+  );
+  if (value.type !== 'explicit-user-approval') {
     errors.push(
       issue(
-        'INVALID_APPROVAL_SCHEMA',
-        'Approval projection must use oat-dispatch-approval/v1',
-        `${path}.schema`,
+        'INVALID_APPROVAL_EVIDENCE',
+        'Approval evidence must record explicit user approval',
+        `${path}.type`,
       ),
     );
   }
-  if (value.prepared_record_version !== 1) {
+  requiredTimestamp(value, 'approvedAt', errors, path);
+  if (!isDigest(value.fingerprint)) {
     errors.push(
       issue(
-        'INVALID_PREPARED_RECORD_VERSION',
-        'Prepared record version must be 1',
-        `${path}.prepared_record_version`,
+        'INVALID_APPROVAL_FINGERPRINT',
+        'Approval evidence fingerprint must be sha256',
+        `${path}.fingerprint`,
       ),
     );
   }
-  requiredString(value, 'run_id', errors, path);
-  requiredString(value, 'prepared_at', errors, path);
-  requiredObject(value, 'request', errors, path);
-  requiredObject(value, 'selection', errors, path);
-  requiredObject(value, 'execution', errors, path);
-  requiredObject(value, 'catalog_observation', errors, path);
+}
 
-  closedObject(value.request, requestKeys, errors, `${path}.request`);
-  for (const key of [
-    'request_id',
-    'caller',
-    'objective',
-    'action',
-    'expected_output',
-    'verification_evidence',
-  ]) {
-    requiredString(value.request, key, errors, `${path}.request`);
+export function validateExecution(value, errors, path = '$.execution') {
+  if (!isObject(value)) return;
+  closedObject(value, executionKeys, errors, path);
+  for (const key of ['provider', 'route', 'role', 'model', 'effort']) {
+    requiredString(value, key, errors, path);
   }
-  requiredCanonicalStringSet(
-    value.request,
-    'escalate_when',
-    errors,
-    `${path}.request`,
-  );
-
-  closedObject(value.selection, selectionKeys, errors, `${path}.selection`);
-  for (const key of [...selectionKeys].filter(
-    (item) => item !== 'candidates_considered',
-  )) {
-    if (
-      key === 'reasoning_mode_selector' &&
-      value.selection?.reasoning_mode_selector === null
-    ) {
-      continue;
+  for (const key of ['reasoningMode', 'serviceTier']) {
+    if (value[key] !== null && typeof value[key] !== 'string') {
+      errors.push(
+        issue(
+          'MISSING_REQUIRED_FIELD',
+          `${key} must be a string or null`,
+          `${path}.${key}`,
+        ),
+      );
     }
-    requiredString(value.selection, key, errors, `${path}.selection`);
   }
-  requiredCanonicalStringSet(
-    value.selection,
-    'candidates_considered',
-    errors,
-    `${path}.selection`,
-  );
-
-  closedObject(
-    value.execution,
-    new Set(['waves', 'run_maximum_floor', 'pinned_target']),
-    errors,
-    `${path}.execution`,
-  );
-  requiredArray(value.execution, 'waves', errors, `${path}.execution`);
-  requiredString(
-    value.execution,
-    'run_maximum_floor',
-    errors,
-    `${path}.execution`,
-  );
-  requiredObject(value.execution, 'pinned_target', errors, `${path}.execution`);
+  if (!authorityLevels.includes(value.authority)) {
+    errors.push(
+      issue(
+        'INVALID_AUTHORITY_LEVEL',
+        'Approved authority must be provider-enforced or contract-enforced',
+        `${path}.authority`,
+      ),
+    );
+  }
+  requiredInteger(value, 'maxConcurrency', errors, path, 1);
+  requiredInteger(value, 'deadlineSeconds', errors, path, 1);
+  requiredInteger(value, 'retryLimit', errors, path, 0);
+  requiredArray(value, 'waves', errors, path);
+  requiredObject(value, 'approval', errors, path);
+  validateApprovalEvidence(value.approval, errors, `${path}.approval`);
   const waveIds = new Set();
   const laneIds = new Set();
-  for (const [waveIndex, wave] of (value.execution?.waves ?? []).entries()) {
-    const wavePath = `${path}.execution.waves[${waveIndex}]`;
-    closedObject(wave, waveKeys, errors, wavePath);
-    for (const key of [
-      'wave_id',
-      'task_class',
-      'model_class_floor',
-      'scope',
-      'authority',
-      'authorization_scope',
-      'dispatch_mode',
-    ]) {
-      requiredString(wave, key, errors, wavePath);
-    }
+  for (const [waveIndex, wave] of (value.waves ?? []).entries()) {
+    const wavePath = `${path}.waves[${waveIndex}]`;
+    closedObject(
+      wave,
+      new Set(['waveId', 'mode', 'taskClass', 'lanes', 'conditional']),
+      errors,
+      wavePath,
+    );
+    requiredString(wave, 'waveId', errors, wavePath);
     requiredArray(wave, 'lanes', errors, wavePath);
-    requiredCanonicalStringSet(wave, 'writable_roots', errors, wavePath);
-    requiredObject(wave, 'fallback', errors, wavePath);
-    requiredObject(wave, 'context_fork_controls', errors, wavePath);
-    requiredInteger(wave, 'deadline_seconds', errors, wavePath, 1);
-    requiredInteger(wave, 'retry_limit', errors, wavePath);
-    requiredInteger(wave, 'concurrency', errors, wavePath, 1);
-    requiredInteger(wave, 'lane_cap', errors, wavePath, 1);
-    if (typeof wave.conditional !== 'boolean') {
+    if (Array.isArray(wave?.lanes) && wave.lanes.length === 0) {
       errors.push(
         issue(
           'MISSING_REQUIRED_FIELD',
-          'conditional must be a boolean',
-          `${wavePath}.conditional`,
+          'Every approved wave needs at least one lane',
+          `${wavePath}.lanes`,
         ),
       );
     }
-    if (!taskClasses.includes(wave.task_class)) {
+    if (!waveModes.includes(wave?.mode)) {
       errors.push(
-        issue(
-          'INVALID_TASK_CLASS',
-          'Unknown wave task class',
-          `${wavePath}.task_class`,
-        ),
+        issue('INVALID_WAVE_MODE', 'Unknown wave mode', `${wavePath}.mode`),
       );
     }
-    if (wave.model_class_floor !== wave.task_class) {
+    if (!taskClasses.includes(wave?.taskClass)) {
       errors.push(
         issue(
-          'MODEL_CLASS_FLOOR_MISMATCH',
-          'Wave model class floor must equal its task class',
-          `${wavePath}.model_class_floor`,
+          'INVALID_TASK_CLASS',
+          'Unknown wave task class',
+          `${wavePath}.taskClass`,
         ),
       );
     }
-    if (!isDigest(wave.payload_digest)) {
+    if (typeof wave?.conditional !== 'boolean') {
       errors.push(
         issue(
-          'INVALID_PAYLOAD_DIGEST',
-          'Wave payload digest must be sha256',
-          `${wavePath}.payload_digest`,
+          'MISSING_REQUIRED_FIELD',
+          'conditional must be a boolean',
+          `${wavePath}.conditional`,
         ),
       );
     }
-    if (waveIds.has(wave.wave_id)) {
+    if (waveIds.has(wave?.waveId)) {
       errors.push(
         issue(
           'DUPLICATE_ID',
-          `Duplicate wave ${wave.wave_id}`,
-          `${wavePath}.wave_id`,
+          `Duplicate wave ${wave.waveId}`,
+          `${wavePath}.waveId`,
         ),
       );
     }
-    waveIds.add(wave.wave_id);
-    closedObject(
-      wave.fallback,
-      new Set(['mode']),
-      errors,
-      `${wavePath}.fallback`,
-    );
-    requiredString(wave.fallback, 'mode', errors, `${wavePath}.fallback`);
-    closedObject(
-      wave.context_fork_controls,
-      new Set(['fork_turns']),
-      errors,
-      `${wavePath}.context_fork_controls`,
-    );
-    requiredString(
-      wave.context_fork_controls,
-      'fork_turns',
-      errors,
-      `${wavePath}.context_fork_controls`,
-    );
-    for (const [laneIndex, lane] of (wave.lanes ?? []).entries()) {
+    waveIds.add(wave?.waveId);
+    for (const [laneIndex, lane] of (Array.isArray(wave?.lanes)
+      ? wave.lanes
+      : []
+    ).entries()) {
       const lanePath = `${wavePath}.lanes[${laneIndex}]`;
-      closedObject(lane, new Set(['lane_id', 'scope']), errors, lanePath);
-      requiredString(lane, 'lane_id', errors, lanePath);
-      requiredString(lane, 'scope', errors, lanePath);
-      if (laneIds.has(lane.lane_id)) {
+      closedObject(
+        lane,
+        new Set(['laneId', 'scope', 'writeRoot']),
+        errors,
+        lanePath,
+      );
+      for (const key of ['laneId', 'scope', 'writeRoot']) {
+        requiredString(lane, key, errors, lanePath);
+      }
+      if (
+        typeof lane?.writeRoot === 'string' &&
+        (lane.writeRoot.startsWith('/') ||
+          lane.writeRoot.split('/').some((segment) => segment === '..'))
+      ) {
+        errors.push(
+          issue(
+            'INVALID_WRITE_ROOT',
+            'Lane write root must be a packet-relative path',
+            `${lanePath}.writeRoot`,
+          ),
+        );
+      }
+      if (laneIds.has(lane?.laneId)) {
         errors.push(
           issue(
             'DUPLICATE_ID',
-            `Duplicate lane ${lane.lane_id}`,
-            `${lanePath}.lane_id`,
+            `Duplicate lane ${lane.laneId}`,
+            `${lanePath}.laneId`,
           ),
         );
       }
-      laneIds.add(lane.lane_id);
-    }
-  }
-
-  const floors = (value.execution?.waves ?? [])
-    .map((wave) => taskClasses.indexOf(wave.model_class_floor))
-    .filter((index) => index >= 0);
-  const maximumFloor = taskClasses[Math.max(...floors)];
-  if (maximumFloor && value.execution?.run_maximum_floor !== maximumFloor) {
-    errors.push(
-      issue(
-        'RUN_MAXIMUM_FLOOR_MISMATCH',
-        'Run maximum floor does not equal the strongest wave floor',
-        `${path}.execution.run_maximum_floor`,
-      ),
-    );
-  }
-  if (!taskClasses.includes(value.execution?.run_maximum_floor)) {
-    errors.push(
-      issue(
-        'INVALID_TASK_CLASS',
-        'Unknown run maximum floor',
-        `${path}.execution.run_maximum_floor`,
-      ),
-    );
-  }
-  closedObject(
-    value.execution?.pinned_target,
-    pinnedTargetKeys,
-    errors,
-    `${path}.execution.pinned_target`,
-  );
-  for (const key of pinnedTargetKeys) {
-    if (
-      key === 'reasoning_mode_selector' &&
-      value.execution?.pinned_target?.reasoning_mode_selector === null
-    ) {
-      continue;
-    }
-    requiredString(
-      value.execution?.pinned_target,
-      key,
-      errors,
-      `${path}.execution.pinned_target`,
-    );
-  }
-  for (const key of pinnedTargetKeys) {
-    if (value.execution?.pinned_target?.[key] !== value.selection?.[key]) {
-      errors.push(
-        issue(
-          'PINNED_TARGET_MISMATCH',
-          `${key} differs from the approved selection`,
-          `${path}.execution.pinned_target.${key}`,
-        ),
-      );
+      laneIds.add(lane?.laneId);
     }
   }
-
-  closedObject(
-    value.catalog_observation,
-    catalogKeys,
-    errors,
-    `${path}.catalog_observation`,
-  );
-  for (const key of ['id', 'source', 'dispatch_context', 'observed_at']) {
-    requiredString(
-      value.catalog_observation,
-      key,
-      errors,
-      `${path}.catalog_observation`,
-    );
-  }
-  if (!isDigest(value.catalog_observation?.relevant_catalog_fingerprint)) {
-    errors.push(
-      issue(
-        'INVALID_CATALOG_FINGERPRINT',
-        'Catalog fingerprint must be sha256',
-        `${path}.catalog_observation.relevant_catalog_fingerprint`,
-      ),
-    );
-  }
-  if (
-    value.catalog_observation?.dispatch_context !==
-    value.selection?.dispatch_context
-  ) {
-    errors.push(
-      issue(
-        'CATALOG_CONTEXT_MISMATCH',
-        'Catalog context differs from the approved selection',
-        `${path}.catalog_observation.dispatch_context`,
-      ),
-    );
-  }
-}
-
-function validateApprovalEvidence(value, errors, path) {
-  if (!isObject(value)) return;
-  closedObject(value, new Set(['type', 'fingerprint']), errors, path);
-  if (value.type !== 'explicit-user-approval') {
-    errors.push(
-      issue(
-        'INVALID_APPROVAL_EVIDENCE',
-        'Approval evidence must record explicit user approval',
-        `${path}.type`,
-      ),
-    );
-  }
-  if (!isDigest(value.fingerprint)) {
-    errors.push(
-      issue(
-        'INVALID_APPROVAL_FINGERPRINT',
-        'Approval evidence fingerprint must be sha256',
-        `${path}.fingerprint`,
-      ),
-    );
-  }
-}
-
-function validateCatalogRecheck(value, errors, path) {
-  if (!isObject(value)) return;
-  closedObject(value, catalogKeys, errors, path);
-  for (const key of ['id', 'source', 'dispatch_context']) {
-    requiredString(value, key, errors, path);
-  }
-  requiredTimestamp(value, 'observed_at', errors, path);
-  if (!isDigest(value.relevant_catalog_fingerprint)) {
-    errors.push(
-      issue(
-        'INVALID_CATALOG_FINGERPRINT',
-        'Catalog recheck fingerprint must be sha256',
-        `${path}.relevant_catalog_fingerprint`,
-      ),
-    );
-  }
 }
 
 function validateManifest(value, errors) {
@@ -661,7 +407,6 @@ function validateManifest(value, errors) {
       'request',
       'sources',
       'execution',
-      'stages',
       'artifacts',
       'gaps',
     ]),
@@ -725,7 +470,6 @@ function validateManifest(value, errors) {
     }
   }
   requiredArray(value, 'sources', errors);
-  requiredArray(value, 'stages', errors);
   requiredArray(value, 'artifacts', errors);
   requiredArray(value, 'gaps', errors);
   requiredObject(value, 'request', errors);
@@ -755,61 +499,9 @@ function validateManifest(value, errors) {
       requiredArray(value.request, key, errors, '$.request');
     }
   }
-  if (isObject(value.execution)) {
-    closedObject(
-      value.execution,
-      new Set([
-        'approvalProjection',
-        'approvalCanonicalJson',
-        'approvalFingerprint',
-        'approvedAt',
-        'approvalEvidence',
-        'catalogRecheck',
-      ]),
-      errors,
-      '$.execution',
-    );
-    requiredObject(
-      value.execution,
-      'approvalProjection',
-      errors,
-      '$.execution',
-    );
-    requiredString(
-      value.execution,
-      'approvalCanonicalJson',
-      errors,
-      '$.execution',
-    );
-    requiredString(
-      value.execution,
-      'approvalFingerprint',
-      errors,
-      '$.execution',
-    );
-    requiredTimestamp(value.execution, 'approvedAt', errors, '$.execution');
-    requiredObject(value.execution, 'approvalEvidence', errors, '$.execution');
-    requiredObject(value.execution, 'catalogRecheck', errors, '$.execution');
-    validateApprovalProjection(
-      value.execution.approvalProjection,
-      errors,
-      '$.execution.approvalProjection',
-    );
-    validateApprovalEvidence(
-      value.execution.approvalEvidence,
-      errors,
-      '$.execution.approvalEvidence',
-    );
-    validateCatalogRecheck(
-      value.execution.catalogRecheck,
-      errors,
-      '$.execution.catalogRecheck',
-    );
-  }
+  validateExecution(value.execution, errors, '$.execution');
   if (Array.isArray(value.sources))
     duplicateIds(value.sources, '$.sources', errors);
-  if (Array.isArray(value.stages))
-    duplicateIds(value.stages, '$.stages', errors);
   if (Array.isArray(value.gaps)) duplicateIds(value.gaps, '$.gaps', errors);
   for (const [index, reference] of (value.artifacts ?? []).entries()) {
     validateExactReference(reference, `$.artifacts[${index}]`, errors);
@@ -951,62 +643,6 @@ function validateManifest(value, errors) {
       `$.gaps[${index}]`,
     );
   }
-  for (const [index, stage] of (value.stages ?? []).entries()) {
-    requiredString(stage, 'id', errors, `$.stages[${index}]`);
-    requiredString(stage, 'waveId', errors, `$.stages[${index}]`);
-    requiredString(stage, 'mode', errors, `$.stages[${index}]`);
-    requiredString(stage, 'status', errors, `$.stages[${index}]`);
-    requiredArray(stage, 'artifactIds', errors, `$.stages[${index}]`);
-    requiredArray(stage, 'dispatchReceiptIds', errors, `$.stages[${index}]`);
-    requiredString(stage, 'laneId', errors, `$.stages[${index}]`);
-    if (!stageModes.includes(stage.mode)) {
-      errors.push(
-        issue(
-          'INVALID_STAGE_MODE',
-          'Unknown stage mode',
-          `$.stages[${index}].mode`,
-        ),
-      );
-    }
-    if (!['complete', 'failed', 'omitted'].includes(stage.status)) {
-      errors.push(
-        issue(
-          'INVALID_STAGE_STATUS',
-          'Unknown stage status',
-          `$.stages[${index}].status`,
-        ),
-      );
-    }
-    if (
-      stage.kind !== 'recon.stage-result' ||
-      stage.schemaVersion !== SCHEMA_VERSION
-    ) {
-      errors.push(
-        issue(
-          'INVALID_STAGE_RESULT',
-          'Expected recon.stage-result version 1',
-          `$.stages[${index}]`,
-        ),
-      );
-    }
-    closedObject(
-      stage,
-      new Set([
-        'kind',
-        'schemaVersion',
-        'id',
-        'waveId',
-        'mode',
-        'status',
-        'artifactIds',
-        'dispatchReceiptIds',
-        'laneId',
-        'message',
-      ]),
-      errors,
-      `$.stages[${index}]`,
-    );
-  }
 }
 
 function validateLedger(value, errors) {
@@ -1116,6 +752,11 @@ function validateLedger(value, errors) {
   for (const key of ['evidence', 'claims', 'unresolvedQuestions']) {
     if (Array.isArray(value[key])) duplicateIds(value[key], `$.${key}`, errors);
   }
+  const evidenceIds = new Set(
+    Array.isArray(value.evidence)
+      ? value.evidence.map((item) => item?.id).filter(Boolean)
+      : [],
+  );
   for (const [index, reference] of (value.inputArtifacts ?? []).entries()) {
     validateExactReference(reference, `$.inputArtifacts[${index}]`, errors);
   }
@@ -1252,6 +893,53 @@ function validateLedger(value, errors) {
     ]) {
       requiredArray(claim, key, errors, `$.claims[${index}]`);
     }
+    const linkedEvidenceIds = new Set();
+    for (const [linkIndex, link] of (claim.evidence ?? []).entries()) {
+      const linkPath = `$.claims[${index}].evidence[${linkIndex}]`;
+      if (!isObject(link)) {
+        errors.push(
+          issue(
+            'INVALID_EVIDENCE_LINK',
+            'Claim evidence links must be { evidenceId, relation } objects',
+            linkPath,
+          ),
+        );
+        continue;
+      }
+      closedObject(link, new Set(['evidenceId', 'relation']), errors, linkPath);
+      requiredString(link, 'evidenceId', errors, linkPath);
+      if (!evidenceRelations.includes(link.relation)) {
+        errors.push(
+          issue(
+            'INVALID_EVIDENCE_RELATION',
+            'Claim evidence relation is not supported',
+            `${linkPath}.relation`,
+          ),
+        );
+      }
+      if (
+        typeof link.evidenceId === 'string' &&
+        !evidenceIds.has(link.evidenceId)
+      ) {
+        errors.push(
+          issue(
+            'UNRESOLVED_EVIDENCE_LINK',
+            `Claim evidence link ${link.evidenceId} does not resolve in this ledger`,
+            `${linkPath}.evidenceId`,
+          ),
+        );
+      }
+      if (linkedEvidenceIds.has(link.evidenceId)) {
+        errors.push(
+          issue(
+            'DUPLICATE_EVIDENCE_LINK',
+            `Claim links evidence ${link.evidenceId} more than once`,
+            linkPath,
+          ),
+        );
+      }
+      linkedEvidenceIds.add(link.evidenceId);
+    }
     for (const [referenceIndex, reference] of (
       claim.derivedFrom ?? []
     ).entries()) {
@@ -2190,11 +1878,7 @@ function validateReviewResult(value, errors) {
         `$.evidenceAssociations[${index}]`,
       );
     }
-    if (
-      !['supports', 'contradicts', 'qualifies', 'context'].includes(
-        association.relation,
-      )
-    ) {
+    if (!evidenceRelations.includes(association.relation)) {
       errors.push(
         issue(
           'INVALID_EVIDENCE_RELATION',
@@ -2249,180 +1933,6 @@ function validateReviewResult(value, errors) {
   );
 }
 
-function validateDispatchReceipt(value, errors) {
-  for (const key of ['id', 'runId', 'stageId', 'laneId', 'state']) {
-    requiredString(value, key, errors);
-  }
-  requiredObject(value, 'approvalProjection', errors);
-  requiredString(value, 'approvalCanonicalJson', errors);
-  requiredString(value, 'approvalFingerprint', errors);
-  validateApprovalProjection(
-    value.approvalProjection,
-    errors,
-    '$.approvalProjection',
-  );
-  if (
-    !['prepared', 'approved', 'accepted', 'completed', 'failed'].includes(
-      value.state,
-    )
-  ) {
-    errors.push(
-      issue('INVALID_DISPATCH_STATE', 'Unknown dispatch state', '$.state'),
-    );
-  }
-  const approved = ['approved', 'accepted', 'completed', 'failed'].includes(
-    value.state,
-  );
-  const launched = ['accepted', 'completed', 'failed'].includes(value.state);
-  if (approved) {
-    requiredTimestamp(value, 'approvedAt', errors);
-    requiredObject(value, 'approvalEvidence', errors);
-    validateApprovalEvidence(
-      value.approvalEvidence,
-      errors,
-      '$.approvalEvidence',
-    );
-  } else if (value.approvedAt !== null || value.approvalEvidence !== null) {
-    errors.push(
-      issue(
-        'INVALID_DISPATCH_STATE_EVIDENCE',
-        'Prepared receipt cannot contain approval evidence',
-        '$.approvalEvidence',
-      ),
-    );
-  }
-  if (launched) {
-    requiredObject(value, 'catalogRecheck', errors);
-    requiredObject(value, 'launchAcceptance', errors);
-    validateCatalogRecheck(value.catalogRecheck, errors, '$.catalogRecheck');
-    if (isObject(value.launchAcceptance)) {
-      closedObject(
-        value.launchAcceptance,
-        new Set(['status', 'acceptedAt', 'handle']),
-        errors,
-        '$.launchAcceptance',
-      );
-      if (value.launchAcceptance.status !== 'accepted') {
-        errors.push(
-          issue(
-            'INVALID_LAUNCH_ACCEPTANCE',
-            'Launch was not accepted',
-            '$.launchAcceptance.status',
-          ),
-        );
-      }
-      requiredTimestamp(
-        value.launchAcceptance,
-        'acceptedAt',
-        errors,
-        '$.launchAcceptance',
-      );
-      requiredString(
-        value.launchAcceptance,
-        'handle',
-        errors,
-        '$.launchAcceptance',
-      );
-    }
-  } else if (value.catalogRecheck !== null || value.launchAcceptance !== null) {
-    errors.push(
-      issue(
-        'INVALID_DISPATCH_STATE_EVIDENCE',
-        'Pre-launch receipt cannot contain catalog or acceptance evidence',
-        '$.catalogRecheck',
-      ),
-    );
-  }
-  if (value.state === 'completed') {
-    requiredArray(value, 'artifactIds', errors);
-    requiredObject(value, 'terminalOutcome', errors);
-    if (isObject(value.terminalOutcome)) {
-      closedObject(
-        value.terminalOutcome,
-        new Set(['status', 'completedAt']),
-        errors,
-        '$.terminalOutcome',
-      );
-      if (value.terminalOutcome.status !== 'completed') {
-        errors.push(
-          issue(
-            'INVALID_TERMINAL_OUTCOME',
-            'Terminal outcome is not completed',
-            '$.terminalOutcome.status',
-          ),
-        );
-      }
-      requiredTimestamp(
-        value.terminalOutcome,
-        'completedAt',
-        errors,
-        '$.terminalOutcome',
-      );
-    }
-  } else if (value.terminalOutcome !== null) {
-    errors.push(
-      issue(
-        'INVALID_DISPATCH_STATE_EVIDENCE',
-        'Non-completed receipt cannot contain a terminal outcome',
-        '$.terminalOutcome',
-      ),
-    );
-  }
-  closedObject(
-    value,
-    new Set([
-      'kind',
-      'schemaVersion',
-      'id',
-      'runId',
-      'stageId',
-      'laneId',
-      'state',
-      'approvalProjection',
-      'approvalCanonicalJson',
-      'approvalFingerprint',
-      'approvedAt',
-      'approvalEvidence',
-      'catalogRecheck',
-      'launchAcceptance',
-      'terminalOutcome',
-      'artifactIds',
-    ]),
-    errors,
-  );
-}
-
-function validateStageResult(value, errors) {
-  for (const key of ['id', 'waveId', 'mode', 'laneId', 'status'])
-    requiredString(value, key, errors);
-  requiredArray(value, 'artifactIds', errors);
-  requiredArray(value, 'dispatchReceiptIds', errors);
-  if (!stageModes.includes(value.mode)) {
-    errors.push(issue('INVALID_STAGE_MODE', 'Unknown stage mode', '$.mode'));
-  }
-  if (!['complete', 'failed', 'omitted'].includes(value.status)) {
-    errors.push(
-      issue('INVALID_STAGE_STATUS', 'Unknown stage status', '$.status'),
-    );
-  }
-  closedObject(
-    value,
-    new Set([
-      'kind',
-      'schemaVersion',
-      'id',
-      'waveId',
-      'mode',
-      'laneId',
-      'status',
-      'artifactIds',
-      'dispatchReceiptIds',
-      'message',
-    ]),
-    errors,
-  );
-}
-
 export function validateArtifactShape(value) {
   const errors = [];
   if (!isObject(value)) {
@@ -2455,8 +1965,5 @@ export function validateArtifactShape(value) {
   if (value.kind === 'recon.review-brief')
     validateReviewBriefArtifact(value, errors);
   if (value.kind === 'recon.review-result') validateReviewResult(value, errors);
-  if (value.kind === 'recon.dispatch-receipt')
-    validateDispatchReceipt(value, errors);
-  if (value.kind === 'recon.stage-result') validateStageResult(value, errors);
   return { valid: errors.length === 0, errors };
 }