@gakim-digital/dexter-bridge 0.11.13 → 0.11.15

package/src/framerBehaviorContract.js

@@ -1,118 +1,12 @@
 import crypto from 'node:crypto';
 
-export const BEHAVIOR_ACTIVATIONS = [
-  'tap',
-  'hover',
-  'submit',
-  'appear',
-  'key',
-];
+// Dexter does not model Framer's interaction features. The model decides how
+// to build a behavior from Framer's own documentation; this module only checks
+// that the properties the model says carry the behavior exist on the live
+// nodes it names.
 
-export const BEHAVIOR_PRESENTATIONS = [
-  'none',
-  'inline',
-  'floating',
-  'modal',
-  'navigation',
-];
-
-export const BEHAVIOR_LAYOUT_EFFECTS = [
-  'none',
-  'reflow',
-  'overlay',
-  'navigation',
-];
-
-export const BEHAVIOR_MECHANISMS = [
-  'native_link',
-  'native_event',
-  'native_effect',
-  'native_overlay',
-  'native_component_variants',
-  'existing_component_control',
-  'code_component',
-];
-
-const MECHANISM_CAPABILITIES = {
-  native_link: {
-    activations: new Set(['tap', 'key']),
-    presentations: new Set(['navigation']),
-    layoutEffects: new Set(['navigation']),
-    stateChange: false,
-    reversible: false,
-    repeatable: true,
-  },
-  native_event: {
-    activations: new Set(['tap', 'hover', 'appear', 'key']),
-    presentations: new Set(['none', 'navigation']),
-    layoutEffects: new Set(['none', 'navigation']),
-    stateChange: false,
-    reversible: false,
-    repeatable: true,
-  },
-  native_effect: {
-    activations: new Set(['tap', 'hover', 'appear']),
-    presentations: new Set(['none']),
-    layoutEffects: new Set(['none']),
-    stateChange: false,
-    reversible: true,
-    repeatable: true,
-  },
-  native_overlay: {
-    activations: new Set(['tap', 'hover', 'appear', 'key']),
-    presentations: new Set(['floating', 'modal']),
-    layoutEffects: new Set(['overlay']),
-    stateChange: true,
-    reversible: true,
-    repeatable: true,
-  },
-  native_component_variants: {
-    activations: new Set(['tap', 'hover', 'appear', 'key']),
-    presentations: new Set(['none', 'inline']),
-    layoutEffects: new Set(['none', 'reflow']),
-    stateChange: true,
-    reversible: true,
-    repeatable: true,
-  },
-  existing_component_control: {
-    activations: new Set(BEHAVIOR_ACTIVATIONS),
-    presentations: new Set(BEHAVIOR_PRESENTATIONS),
-    layoutEffects: new Set(BEHAVIOR_LAYOUT_EFFECTS),
-    stateChange: true,
-    reversible: true,
-    repeatable: true,
-  },
-  code_component: {
-    activations: new Set(BEHAVIOR_ACTIVATIONS),
-    presentations: new Set(BEHAVIOR_PRESENTATIONS),
-    layoutEffects: new Set(BEHAVIOR_LAYOUT_EFFECTS),
-    stateChange: true,
-    reversible: true,
-    repeatable: true,
-  },
-};
-
-const FRAME_EVENT_NODE_TYPES = new Set([
-  'FrameNode',
-  'RichTextNode',
-  'IconNode',
-  'ComponentInstanceNode',
-]);
-
-const FRAME_EFFECT_NODE_TYPES = new Set([
-  'ComponentInstanceNode',
-  'FrameNode',
-  'IconNode',
-  'RelativeOverlayNode',
-  'RichTextNode',
-  'ShaderNode',
-]);
-
-const NATIVE_EFFECT_BY_ACTIVATION = {
-  tap: 'tapEffect',
-  hover: 'hoverEffect',
-  appear: 'appearEffect',
-};
+const MAX_SEARCH_DEPTH = 6;
+const MAX_OBSERVED_CHARS = 1000;
 
 function isRecord(value) {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value));
@@ -132,1291 +26,195 @@ function uniqueStrings(values, maximum = 50) {
   )).slice(0, maximum);
 }
 
-function integer(value, fallback = 1, minimum = 1, maximum = 50) {
-  const parsed = Number(value);
-  return Number.isFinite(parsed)
-    ? Math.min(maximum, Math.max(minimum, Math.floor(parsed)))
-    : fallback;
-}
-
 function contractError(code, message) {
   return Object.assign(new Error(message), { code, statusCode: 400 });
 }
 
-export function behaviorSignature(behavior) {
-  return crypto
-    .createHash('sha256')
-    .update(JSON.stringify({
-      activation: behavior.activation,
-      presentation: behavior.presentation,
-      stateChange: behavior.stateChange,
-      layoutEffect: behavior.layoutEffect,
-      reversible: behavior.reversible,
-      repeatable: behavior.repeatable,
-      expectedTargets: behavior.expectedTargets,
-      initialState: behavior.initialState,
-      activatedState: behavior.activatedState,
-      expectedDestinations: behavior.expectedDestinations,
-    }))
-    .digest('hex');
-}
-
 function normalizeBehavior(rawBehavior, index) {
-  if (!isRecord(rawBehavior)) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_CONTRACT_INVALID',
-      `Behavior ${index + 1} must be an object.`,
-    );
-  }
-  const id = text(rawBehavior.id, 120);
-  const description = text(rawBehavior.description, 500);
-  const triggerDescription = text(rawBehavior.triggerDescription, 300);
-  const activation = text(rawBehavior.activation, 40);
-  const presentation = text(rawBehavior.presentation, 40);
-  const layoutEffect = text(rawBehavior.layoutEffect, 40);
-  const initialState = text(rawBehavior.initialState, 300);
-  const activatedState = text(rawBehavior.activatedState, 300);
-  if (
-    !id
-    || description.length < 5
-    || triggerDescription.length < 3
-    || !BEHAVIOR_ACTIVATIONS.includes(activation)
-    || !BEHAVIOR_PRESENTATIONS.includes(presentation)
-    || !BEHAVIOR_LAYOUT_EFFECTS.includes(layoutEffect)
-    || !initialState
-    || !activatedState
-  ) {
+  const id = text(rawBehavior?.id, 120);
+  const description = text(rawBehavior?.description, 500);
+  if (!isRecord(rawBehavior) || !id || description.length < 5) {
     throw contractError(
       'FRAMER_BEHAVIOR_CONTRACT_INVALID',
-      `Behavior ${index + 1} must declare its identity, trigger, activation, presentation, initial state, activated state, and layout effect.`,
+      `Behavior ${index + 1} needs an id and a description of what the user should experience.`,
     );
   }
-  const behavior = {
+  return {
     id,
     description,
-    triggerDescription,
-    activation,
-    presentation,
-    stateChange: rawBehavior.stateChange === true,
-    layoutEffect,
-    reversible: rawBehavior.reversible === true,
-    repeatable: rawBehavior.repeatable === true,
-    expectedTargets: integer(rawBehavior.expectedTargets),
-    expectedContent: uniqueStrings(rawBehavior.expectedContent, 20),
-    expectedDestinations: uniqueStrings(rawBehavior.expectedDestinations, 20),
-    initialState,
-    activatedState,
-  };
-  if (
-    (behavior.presentation === 'navigation'
-      || behavior.layoutEffect === 'navigation')
-    && behavior.expectedDestinations.length === 0
-  ) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_CONTRACT_INVALID',
-      `Behavior ${index + 1} must declare expectedDestinations for navigation.`,
-    );
-  }
-  return {
-    ...behavior,
-    signature: behaviorSignature(behavior),
-  };
-}
-
-function normalizeMechanism(rawMechanism, index) {
-  if (!isRecord(rawMechanism)) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_MECHANISM_INVALID',
-      `Mechanism ${index + 1} must be an object.`,
-    );
-  }
-  const behaviorId = text(rawMechanism.behaviorId, 120);
-  const mechanism = text(rawMechanism.mechanism, 80);
-  const rationale = text(rawMechanism.rationale, 800);
-  if (
-    !behaviorId
-    || !BEHAVIOR_MECHANISMS.includes(mechanism)
-    || rationale.length < 10
-  ) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_MECHANISM_INVALID',
-      `Mechanism ${index + 1} must identify a behavior, a supported mechanism, and a concrete rationale.`,
-    );
-  }
-  return {
-    behaviorId,
-    mechanism,
-    rationale,
-    representativeFirst: rawMechanism.representativeFirst !== false,
-    targetNodeIds: uniqueStrings(rawMechanism.targetNodeIds, 50),
-    representativeTargetNodeId: text(
-      rawMechanism.representativeTargetNodeId,
-      200,
-    ),
-  };
-}
-
-export function normalizeRejectedMechanisms(values) {
-  return (Array.isArray(values) ? values : [])
-    .slice(0, 30)
-    .flatMap((raw, index) => {
-      if (!isRecord(raw)) return [];
-      const behaviorId = text(raw.behaviorId, 120);
-      const behaviorSignatureValue = text(raw.behaviorSignature, 128);
-      const mechanism = text(raw.mechanism, 80);
-      const reason = text(raw.reason, 800);
-      if (
-        (!behaviorId && !behaviorSignatureValue)
-        || !BEHAVIOR_MECHANISMS.includes(mechanism)
-        || reason.length < 5
-      ) {
-        throw contractError(
-          'FRAMER_REJECTED_MECHANISM_INVALID',
-          `Rejected mechanism ${index + 1} must identify a behavior or signature, a supported mechanism, and a reason.`,
-        );
-      }
-      return [{
-        ...(behaviorId ? { behaviorId } : {}),
-        ...(behaviorSignatureValue
-          ? { behaviorSignature: behaviorSignatureValue }
-          : {}),
-        mechanism,
-        reason,
-        source:
-          raw.source === 'user_reported_failure'
-          || raw.source === 'verification_failure'
-            ? raw.source
-            : 'verification_failure',
-      }];
-    });
-}
-
-export function mechanismCompatibility(behavior, mechanism) {
-  const capabilities = MECHANISM_CAPABILITIES[mechanism];
-  if (!capabilities) {
-    return {
-      compatible: false,
-      failures: [`Unknown behavior mechanism ${mechanism}.`],
-    };
-  }
-  const failures = [];
-  if (!capabilities.activations.has(behavior.activation)) {
-    failures.push(`${mechanism} does not support ${behavior.activation} activation`);
-  }
-  if (!capabilities.presentations.has(behavior.presentation)) {
-    failures.push(`${mechanism} does not support ${behavior.presentation} presentation`);
-  }
-  if (!capabilities.layoutEffects.has(behavior.layoutEffect)) {
-    failures.push(`${mechanism} does not support ${behavior.layoutEffect} layout behavior`);
-  }
-  if (behavior.stateChange && !capabilities.stateChange) {
-    failures.push(`${mechanism} cannot provide state changes`);
-  }
-  if (behavior.reversible && !capabilities.reversible) {
-    failures.push(`${mechanism} cannot provide reversible behavior`);
-  }
-  if (behavior.repeatable && !capabilities.repeatable) {
-    failures.push(`${mechanism} cannot be repeated across targets`);
-  }
-  return {
-    compatible: failures.length === 0,
-    failures,
+    targetNodeIds: uniqueStrings(rawBehavior.targetNodeIds, 50),
   };
 }
 
-export function normalizeBehaviorPlan(rawArguments, inheritedRejected = []) {
-  const behaviors = (Array.isArray(rawArguments.behaviors)
+export function normalizeBehaviorPlan(rawArguments) {
+  const behaviors = (Array.isArray(rawArguments?.behaviors)
     ? rawArguments.behaviors
     : []).slice(0, 20).map(normalizeBehavior);
-  const mechanisms = (Array.isArray(rawArguments.mechanisms)
-    ? rawArguments.mechanisms
-    : []).slice(0, 20).map(normalizeMechanism);
-  const rejectedMechanisms = [
-    ...normalizeRejectedMechanisms(inheritedRejected),
-    ...normalizeRejectedMechanisms(rawArguments.rejectedMechanisms),
-  ];
-  const behaviorIds = new Set();
+  const ids = new Set();
   for (const behavior of behaviors) {
-    if (behaviorIds.has(behavior.id)) {
+    if (ids.has(behavior.id)) {
       throw contractError(
         'FRAMER_BEHAVIOR_CONTRACT_INVALID',
         `Behavior IDs must be unique; "${behavior.id}" is duplicated.`,
       );
     }
-    behaviorIds.add(behavior.id);
+    ids.add(behavior.id);
   }
-  const mechanismByBehavior = new Map();
-  for (const decision of mechanisms) {
-    if (!behaviorIds.has(decision.behaviorId)) {
-      throw contractError(
-        'FRAMER_BEHAVIOR_MECHANISM_INVALID',
-        `Mechanism references unknown behavior "${decision.behaviorId}".`,
-      );
-    }
-    if (mechanismByBehavior.has(decision.behaviorId)) {
-      throw contractError(
-        'FRAMER_BEHAVIOR_MECHANISM_INVALID',
-        `Behavior "${decision.behaviorId}" has more than one selected mechanism.`,
-      );
-    }
-    const behavior = behaviors.find((item) => item.id === decision.behaviorId);
-    if (
-      behavior?.expectedTargets > 1
-      && decision.representativeFirst
-      && (
-        decision.targetNodeIds.length !== behavior.expectedTargets
-        || !decision.representativeTargetNodeId
-        || !decision.targetNodeIds.includes(decision.representativeTargetNodeId)
-      )
-    ) {
-      throw contractError(
-        'FRAMER_BEHAVIOR_REPRESENTATIVE_TARGETS_REQUIRED',
-        `Repeated behavior "${decision.behaviorId}" must declare all targetNodeIds and one representativeTargetNodeId before mutation.`,
-      );
-    }
-    mechanismByBehavior.set(decision.behaviorId, decision);
-  }
-  const compatibility = behaviors.map((behavior) => {
-    const decision = mechanismByBehavior.get(behavior.id);
-    if (!decision) {
-      throw contractError(
-        'FRAMER_BEHAVIOR_MECHANISM_REQUIRED',
-        `Behavior "${behavior.id}" requires one explicit implementation mechanism.`,
-      );
-    }
-    const rejected = rejectedMechanisms.find((item) =>
-      item.mechanism === decision.mechanism
-      && (
-        item.behaviorId === behavior.id
-        || item.behaviorSignature === behavior.signature
-      ));
-    if (rejected) {
-      throw contractError(
-        'FRAMER_BEHAVIOR_MECHANISM_REJECTED',
-        `${decision.mechanism} was already rejected for behavior "${behavior.id}": ${rejected.reason}`,
-      );
-    }
-    const result = mechanismCompatibility(behavior, decision.mechanism);
-    if (!result.compatible) {
-      throw contractError(
-        'FRAMER_BEHAVIOR_MECHANISM_INCOMPATIBLE',
-        `The selected mechanism for behavior "${behavior.id}" is incompatible: ${result.failures.join('; ')}.`,
-      );
-    }
-    return {
-      behaviorId: behavior.id,
-      behaviorSignature: behavior.signature,
-      mechanism: decision.mechanism,
-      compatible: true,
-      requiredCapabilities: behaviorCapabilities(behavior),
-    };
-  });
-  return {
-    behaviors,
-    mechanisms,
-    rejectedMechanisms,
-    compatibility,
-  };
-}
-
-export function behaviorCapabilities(behavior) {
-  return [
-    `activation:${behavior.activation}`,
-    `presentation:${behavior.presentation}`,
-    `layout:${behavior.layoutEffect}`,
-    ...(behavior.stateChange ? ['state-change'] : []),
-    ...(behavior.reversible ? ['reversible'] : []),
-    ...(behavior.repeatable ? ['repeatable'] : []),
-  ];
+  return { behaviors };
 }
 
 export function mergeBehaviorPlans(current, next) {
   if (!current) return next;
   const byId = new Map(current.behaviors.map((item) => [item.id, item]));
   next.behaviors.forEach((item) => byId.set(item.id, item));
-  const mechanisms = new Map(
-    current.mechanisms.map((item) => [item.behaviorId, item]),
-  );
-  next.mechanisms.forEach((item) => mechanisms.set(item.behaviorId, item));
-  const merged = {
-    behaviors: [...byId.values()],
-    mechanisms: [...mechanisms.values()],
-    rejectedMechanisms: [
-      ...current.rejectedMechanisms,
-      ...next.rejectedMechanisms,
-    ],
-  };
-  return normalizeBehaviorPlan(merged);
-}
-
-function normalizedEvidenceText(value) {
-  try {
-    return JSON.stringify(value).toLowerCase();
-  } catch {
-    return '';
-  }
-}
-
-function eventEvidenceValues(value, event) {
-  const matches = [];
-  const expected = event.toLowerCase();
-  const visit = (current) => {
-    if (Array.isArray(current)) {
-      current.forEach(visit);
-      return;
-    }
-    if (!isRecord(current)) return;
-    for (const [key, nested] of Object.entries(current)) {
-      const normalizedKey = key.toLowerCase();
-      if (
-        normalizedKey === expected
-        || normalizedKey.startsWith(`${expected}.`)
-      ) {
-        matches.push(nested);
-      }
-      visit(nested);
-    }
-  };
-  visit(value);
-  return matches;
-}
-
-function snapshotFor(snapshots, id) {
-  if (!id) return null;
-  if (snapshots instanceof Map) return snapshots.get(id) || null;
-  return snapshots?.[id] || null;
-}
-
-function nodeFromSnapshot(snapshot) {
-  return isRecord(snapshot?.node) ? snapshot.node : snapshot;
-}
-
-function nodeType(snapshot) {
-  const node = nodeFromSnapshot(snapshot);
-  return text(node?.type || node?.nodeType, 80);
-}
-
-function parentId(snapshot) {
-  const node = nodeFromSnapshot(snapshot);
-  return text(
-    snapshot?.parentId
-    || node?.parentId
-    || node?.parent?.id,
-    200,
-  );
-}
-
-function ancestorIds(snapshot) {
-  const node = nodeFromSnapshot(snapshot);
-  return uniqueStrings([
-    ...(Array.isArray(snapshot?.ancestorIds) ? snapshot.ancestorIds : []),
-    ...(Array.isArray(node?.ancestorIds) ? node.ancestorIds : []),
-    ...(Array.isArray(node?.ancestors)
-      ? node.ancestors.map((ancestor) =>
-          typeof ancestor === 'string' ? ancestor : ancestor?.id)
-      : []),
-  ], 100);
-}
-
-function belongsTo(snapshot, expectedAncestorId) {
-  if (!snapshot || !expectedAncestorId) return false;
-  return (
-    parentId(snapshot) === expectedAncestorId
-    || ancestorIds(snapshot).includes(expectedAncestorId)
-  );
-}
-
-function referencesComponent(snapshot, componentNodeId) {
-  const node = nodeFromSnapshot(snapshot);
-  if (!node || !componentNodeId) return false;
-  const component = isRecord(node.component) ? node.component : {};
-  const references = [
-    typeof node.component === 'string' ? node.component : '',
-    node.componentId,
-    node.componentIdentifier,
-    component.id,
-    component.nodeId,
-    component.componentId,
-    component.componentIdentifier,
-  ];
-  const normalizedReferences = new Set(
-    references.flatMap((value) => {
-      const reference = text(value, 500);
-      if (!reference) return [];
-      const withoutCodePrefix = reference
-        .replace(/^codefile\//i, '')
-        .replace(/^code:/i, '');
-      const withoutExport = withoutCodePrefix.split(':')[0];
-      return [
-        reference,
-        withoutCodePrefix,
-        withoutExport,
-        withoutExport.split('/').pop(),
-      ].filter(Boolean);
-    }),
-  );
-  return normalizedReferences.has(componentNodeId);
-}
-
-function nodeVisible(snapshot) {
-  const node = nodeFromSnapshot(snapshot);
-  if (!node) return null;
-  const visible = Object.prototype.hasOwnProperty.call(node, 'visible')
-    ? node.visible
-    : isRecord(node.attributes)
-      ? node.attributes.visible
-      : undefined;
-  const hidden = Object.prototype.hasOwnProperty.call(node, 'hidden')
-    ? node.hidden
-    : isRecord(node.attributes)
-      ? node.attributes.hidden
-      : undefined;
-  if (visible === false || hidden === true) return false;
-  if (visible === true || hidden === false) return true;
-  return null;
-}
-
-function eventText(snapshot, event) {
-  const node = nodeFromSnapshot(snapshot);
-  if (!node) return '';
-  const values = eventEvidenceValues(node, event);
-  return values.length > 0 ? normalizedEvidenceText(values) : '';
-}
-
-function directNodeProperty(snapshot, property) {
-  const node = nodeFromSnapshot(snapshot);
-  if (!node) return undefined;
-  if (Object.prototype.hasOwnProperty.call(node, property)) {
-    return node[property];
-  }
-  if (
-    isRecord(node.attributes)
-    && Object.prototype.hasOwnProperty.call(node.attributes, property)
-  ) {
-    return node.attributes[property];
-  }
-  return undefined;
-}
-
-function expectedEvents(activation) {
-  if (activation === 'tap') return ['onTap', 'onTapStart'];
-  if (activation === 'hover') return ['onMouseEnter', 'onMouseLeave'];
-  if (activation === 'appear') return ['onAppear'];
-  if (activation === 'key') return ['onKeyDown'];
-  return [];
-}
-
-function normalizeEvidence(raw, behaviorById) {
-  if (!isRecord(raw)) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_EVIDENCE_INVALID',
-      'Interaction evidence must be an object.',
-    );
-  }
-  const behaviorId = text(raw.behaviorId, 120);
-  const behavior = behaviorById.get(behaviorId);
-  if (!behavior) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_EVIDENCE_INVALID',
-      `Interaction evidence references unknown behavior "${behaviorId}".`,
-    );
-  }
-  const expectedDestination = text(raw.expectedDestination, 500);
-  if (
-    expectedDestination
-    && !behavior.expectedDestinations.some((planned) =>
-      destinationCandidates(planned).some((candidate) =>
-        destinationCandidates(expectedDestination).includes(candidate)))
-  ) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_EVIDENCE_INVALID',
-      `Interaction evidence for "${behaviorId}" must use a destination declared in the behavior plan.`,
-    );
-  }
-  return {
-    behaviorId,
-    description: text(raw.description, 300),
-    triggerNodeId: text(raw.triggerNodeId, 200),
-    event: text(raw.event, 80),
-    expectedDestination,
-    targetNodeId: text(raw.targetNodeId, 200),
-    componentNodeId: text(raw.componentNodeId, 200),
-    instanceNodeIds: uniqueStrings(raw.instanceNodeIds, 50),
-    openVariantNodeId: text(raw.openVariantNodeId, 200),
-    closedVariantNodeId: text(raw.closedVariantNodeId, 200),
-    openAnswerNodeId: text(raw.openAnswerNodeId, 200),
-    closedAnswerNodeId: text(raw.closedAnswerNodeId, 200),
-    semanticAssessment: isRecord(raw.semanticAssessment)
-      && ['verified', 'contradicted', 'unknown']
-        .includes(raw.semanticAssessment.verdict)
-      && text(raw.semanticAssessment.rationale, 1200).length >= 10
-      ? {
-          verdict: raw.semanticAssessment.verdict,
-          rationale: text(raw.semanticAssessment.rationale, 1200),
-          evidenceNodeIds: uniqueStrings(
-            raw.semanticAssessment.evidenceNodeIds,
-            50,
-          ),
-        }
-      : null,
-  };
+  return { behaviors: [...byId.values()] };
 }
 
 export function normalizeBehaviorEvidence(rawChecks, plan) {
-  const behaviorById = new Map(
-    (plan?.behaviors || []).map((behavior) => [behavior.id, behavior]),
-  );
+  const behaviorIds = new Set((plan?.behaviors || []).map((item) => item.id));
   const checks = (Array.isArray(rawChecks) ? rawChecks : []).slice(0, 50);
   if (!checks.length) {
     throw contractError(
       'FRAMER_BEHAVIOR_EVIDENCE_REQUIRED',
-      'Declare evidence for at least one planned behavior.',
+      'Name at least one node and the Framer property that carries a planned behavior.',
     );
   }
-  return checks.map((raw) => normalizeEvidence(raw, behaviorById));
-}
-
-export function evidenceNodeIds(checks) {
-  return uniqueStrings(checks.flatMap((check) => [
-    check.triggerNodeId,
-    check.targetNodeId,
-    check.componentNodeId,
-    check.openVariantNodeId,
-    check.closedVariantNodeId,
-    check.openAnswerNodeId,
-    check.closedAnswerNodeId,
-    ...check.instanceNodeIds,
-  ]), 200);
-}
-
-function evidenceState() {
-  return {
-    contradictions: [],
-    unknowns: [],
-    observations: [],
-  };
-}
-
-function contradict(state, message) {
-  state.contradictions.push(message);
-}
-
-function unknown(state, message) {
-  state.unknowns.push(message);
-}
-
-function observe(state, kind, detail = {}) {
-  state.observations.push({ kind, ...detail });
-}
-
-function verifyTrigger(check, behavior, trigger, state) {
-  if (!check.triggerNodeId || !trigger) {
-    unknown(state, 'trigger node was not found');
-    return '';
-  }
-  observe(state, 'node_found', {
-    nodeId: check.triggerNodeId,
-    nodeType: nodeType(trigger),
-  });
-  const allowedEvents = expectedEvents(behavior.activation);
-  if (
-    allowedEvents.length > 0
-    && !allowedEvents.includes(check.event)
-  ) {
-    contradict(
-      state,
-      `${check.event || 'the supplied event'} does not match ${behavior.activation} activation`,
-    );
-  }
-  if (!check.event) {
-    unknown(state, 'the trigger event was not supplied');
-    return '';
-  }
-  if (!FRAME_EVENT_NODE_TYPES.has(nodeType(trigger))) {
-    contradict(
-      state,
-      `${nodeType(trigger) || 'the trigger node'} does not support verified frame events`,
-    );
-  }
-  const evidence = eventText(trigger, check.event);
-  if (!evidence) {
-    unknown(state, `${check.event} was not visible in the serialized trigger`);
-  } else {
-    observe(state, 'event_binding', {
-      nodeId: check.triggerNodeId,
-      event: check.event,
-      value: evidence.slice(0, 1000),
-    });
-  }
-  return evidence;
-}
-
-function verifyExpectedContent(behavior, snapshots, nodeIds, state) {
-  const combined = normalizedEvidenceText(
-    nodeIds.map((id) => nodeFromSnapshot(snapshotFor(snapshots, id))),
-  );
-  for (const expected of behavior.expectedContent) {
-    if (!combined.includes(expected.toLowerCase())) {
-      unknown(state, `expected content was not visible in the evidence: ${expected}`);
-    } else {
-      observe(state, 'expected_content', { value: expected });
-    }
-  }
-}
-
-function verifyOverlay(check, behavior, snapshots, state) {
-  const trigger = snapshotFor(snapshots, check.triggerNodeId);
-  const target = snapshotFor(snapshots, check.targetNodeId);
-  const triggerEvent = verifyTrigger(check, behavior, trigger, state);
-  if (!check.targetNodeId || !target) {
-    unknown(state, 'overlay target node was not found');
-    return;
-  }
-  observe(state, 'node_found', {
-    nodeId: check.targetNodeId,
-    nodeType: nodeType(target),
-  });
-  if (triggerEvent && !triggerEvent.includes('show_overlay')) {
-    contradict(state, `${check.event} does not contain SHOW_OVERLAY`);
-  }
-  if (
-    triggerEvent
-    && !triggerEvent.includes(check.targetNodeId.toLowerCase())
-  ) {
-    contradict(state, `${check.event} does not reference target ${check.targetNodeId}`);
-  }
-  const expectedType =
-    behavior.presentation === 'modal'
-      ? 'FixedOverlayNode'
-      : 'RelativeOverlayNode';
-  if (nodeType(target) !== expectedType) {
-    contradict(state, `the behavior requires a ${expectedType}`);
-  }
-  const actualParentId = parentId(target);
-  if (!actualParentId) {
-    unknown(state, 'the overlay parent was not visible in the evidence');
-  } else if (actualParentId !== check.triggerNodeId) {
-    contradict(state, 'the overlay is not parented to its actual trigger');
-  }
-  verifyExpectedContent(behavior, snapshots, [check.targetNodeId], state);
-}
-
-function verifyComponentInstances(
-  check,
-  behavior,
-  snapshots,
-  state,
-  context,
-  { requireDefinition = true } = {},
-) {
-  const component = snapshotFor(snapshots, check.componentNodeId);
-  if (requireDefinition && !component) {
-    unknown(state, 'component definition was not found');
-  } else if (
-    requireDefinition
-    && nodeType(component) !== 'ComponentNode'
-  ) {
-    contradict(state, 'the declared component definition is not a ComponentNode');
-  }
-  const instances = check.instanceNodeIds.map((id) => ({
-    id,
-    snapshot: snapshotFor(snapshots, id),
-  }));
-  for (const instance of instances) {
-    if (!instance.snapshot) {
-      unknown(state, `component instance ${instance.id} was not found`);
-    } else if (nodeType(instance.snapshot) !== 'ComponentInstanceNode') {
-      contradict(state, `${instance.id} is not a ComponentInstanceNode`);
-    } else if (!referencesComponent(instance.snapshot, check.componentNodeId)) {
-      contradict(
-        state,
-        `component instance ${instance.id} does not reference ${check.componentNodeId}`,
+  return checks.map((raw, index) => {
+    const behaviorId = text(raw?.behaviorId, 120);
+    const nodeId = text(raw?.nodeId, 200);
+    const property = text(raw?.property, 120);
+    if (!isRecord(raw) || !behaviorIds.has(behaviorId) || !nodeId || !property) {
+      throw contractError(
+        'FRAMER_BEHAVIOR_EVIDENCE_INVALID',
+        `Check ${index + 1} must reference a planned behavior (${[...behaviorIds].join(', ') || 'none planned'}), a node ID, and the Framer property to inspect.`,
       );
-    } else {
-      observe(state, 'component_instance', {
-        nodeId: instance.id,
-        componentNodeId: check.componentNodeId,
-      });
     }
-    const authorizedContainerIds = uniqueStrings(
-      context?.authorizedInstanceContainerIds,
-      100,
-    );
-    if (instance.snapshot && authorizedContainerIds.length > 0) {
-      const ancestry = new Set([
-        instance.id,
-        parentId(instance.snapshot),
-        ...(Array.isArray(instance.snapshot.ancestorIds)
-          ? instance.snapshot.ancestorIds
-          : []),
-      ].filter(Boolean));
-      if (!authorizedContainerIds.some((id) => ancestry.has(id))) {
-        contradict(
-          state,
-          `component instance ${instance.id} is outside the authorized write scope`,
-        );
-      }
-    }
-  }
+    return {
+      behaviorId,
+      nodeId,
+      property,
+      contains: text(raw.contains, 500),
+    };
+  });
 }
 
-function verifyComponentVariants(
-  check,
-  behavior,
-  snapshots,
-  state,
-  context,
-) {
-  const trigger = snapshotFor(snapshots, check.triggerNodeId);
-  const component = snapshotFor(snapshots, check.componentNodeId);
-  const openVariant = snapshotFor(snapshots, check.openVariantNodeId);
-  const closedVariant = snapshotFor(snapshots, check.closedVariantNodeId);
-  const openAnswer = snapshotFor(snapshots, check.openAnswerNodeId);
-  const closedAnswer = snapshotFor(snapshots, check.closedAnswerNodeId);
-  const triggerEvent = verifyTrigger(check, behavior, trigger, state);
-  verifyComponentInstances(check, behavior, snapshots, state, context);
-  if (component && trigger && !belongsTo(trigger, check.componentNodeId)) {
-    contradict(state, 'the trigger is not inside the component definition');
-  }
-  if (
-    !openVariant
-    || !closedVariant
-  ) {
-    unknown(state, 'open and closed variants were not both found');
-  } else if (check.openVariantNodeId === check.closedVariantNodeId) {
-    contradict(state, 'open and closed variants must be distinct');
-  } else {
-    if (!belongsTo(openVariant, check.componentNodeId)) {
-      contradict(state, 'the open variant does not belong to the component');
-    }
-    if (!belongsTo(closedVariant, check.componentNodeId)) {
-      contradict(state, 'the closed variant does not belong to the component');
-    }
-  }
-  if (triggerEvent && !triggerEvent.includes('set_variant')) {
-    contradict(state, `${check.event} does not contain SET_VARIANT`);
-  }
-  if (
-    triggerEvent
-    && !triggerEvent.includes('cycle')
-    && !triggerEvent.includes(check.openVariantNodeId.toLowerCase())
-    && !triggerEvent.includes(check.closedVariantNodeId.toLowerCase())
-  ) {
-    contradict(state, 'SET_VARIANT does not reference cycle or a declared variant');
-  }
-  if (!openAnswer || !closedAnswer) {
-    unknown(state, 'open and closed answer-state nodes were not found');
-  } else {
-    if (!belongsTo(openAnswer, check.openVariantNodeId)) {
-      contradict(state, 'the visible answer does not belong to the open variant');
-    }
-    if (!belongsTo(closedAnswer, check.closedVariantNodeId)) {
-      contradict(state, 'the hidden answer does not belong to the closed variant');
-    }
-    const openVisibility = nodeVisible(openAnswer);
-    const closedVisibility = nodeVisible(closedAnswer);
-    observe(state, 'visibility', {
-      nodeId: check.openAnswerNodeId,
-      value:
-        openVisibility === null
-          ? 'unknown'
-          : openVisibility
-            ? 'visible'
-            : 'hidden',
-    });
-    observe(state, 'visibility', {
-      nodeId: check.closedAnswerNodeId,
-      value:
-        closedVisibility === null
-          ? 'unknown'
-          : closedVisibility
-            ? 'visible'
-            : 'hidden',
-    });
-    if (openVisibility === false) {
-      contradict(state, 'the answer is hidden in the open variant');
-    } else if (openVisibility === null) {
-      unknown(state, 'the open answer visibility was not exposed');
-    }
-    if (closedVisibility === true) {
-      contradict(state, 'the answer is not hidden in the closed variant');
-    } else if (closedVisibility === null) {
-      unknown(state, 'the closed answer visibility was not exposed');
-    }
-  }
+export function evidenceNodeIds(checks) {
+  return uniqueStrings(checks.map((check) => check.nodeId), 200);
 }
 
-function destinationCandidates(value) {
-  const candidate = text(value, 2000);
-  if (!candidate) return [];
-  const normalized = candidate.toLowerCase().replace(/\/+$/, '') || '/';
-  const candidates = new Set([normalized]);
-  try {
-    const parsed = new URL(candidate, 'https://dexter.local');
-    candidates.add(
-      `${parsed.pathname}${parsed.search}${parsed.hash}`
-        .toLowerCase()
-        .replace(/\/+$/, '') || '/',
-    );
-  } catch {
-    // Non-URL control values are ignored unless the raw value matches.
-  }
-  return [...candidates];
+function hasContent(value) {
+  if (value === undefined || value === null || value === '') return false;
+  if (Array.isArray(value)) return value.length > 0;
+  if (isRecord(value)) return Object.keys(value).length > 0;
+  return true;
 }
 
-function linkFacts(value) {
-  const facts = [];
-  const visit = (current, path = []) => {
+// Finds the property on the node itself. Child nodes are skipped so a
+// descendant cannot satisfy a claim about its parent.
+function propertyValues(node, property) {
+  const values = [];
+  const visit = (current, depth) => {
+    if (depth > MAX_SEARCH_DEPTH || values.length >= 10) return;
     if (Array.isArray(current)) {
-      current.forEach((nested, index) => visit(nested, [...path, String(index)]));
+      current.forEach((item) => visit(item, depth + 1));
       return;
     }
     if (!isRecord(current)) return;
     for (const [key, nested] of Object.entries(current)) {
-      const nextPath = [...path, key];
-      if (
-        typeof nested === 'string'
-        && /(?:href|url|link|destination|route|path)$/i.test(key)
-      ) {
-        facts.push({
-          path: nextPath.join('.'),
-          value: nested,
-          candidates: destinationCandidates(nested),
-        });
+      if (key === 'children') continue;
+      if (key === property) {
+        if (hasContent(nested)) values.push(nested);
+      } else {
+        visit(nested, depth + 1);
       }
-      visit(nested, nextPath);
     }
   };
-  visit(value);
-  return facts.filter((fact) => fact.candidates.length > 0);
+  visit(node, 0);
+  return values;
 }
 
-function verifyNativeLink(check, behavior, snapshots, state, context) {
-  const targetIds = check.instanceNodeIds.length > 0
-    ? check.instanceNodeIds
-    : [check.triggerNodeId].filter(Boolean);
-  const expectedValues = check.expectedDestination
-    ? [check.expectedDestination]
-    : behavior.expectedDestinations;
-  const expected = new Set(expectedValues.flatMap(destinationCandidates));
-  if (targetIds.length === 0) {
-    unknown(state, 'no navigation target node was supplied');
-    return;
+function serialized(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return '';
   }
-  for (const nodeId of targetIds) {
-    const snapshot = snapshotFor(snapshots, nodeId);
-    if (!snapshot) {
-      unknown(state, `navigation node ${nodeId} was not found`);
-      continue;
+}
+
+export function verifyBehaviorChecks({ checks, nodes }) {
+  return checks.map((check) => {
+    const node = nodes instanceof Map ? nodes.get(check.nodeId) : nodes?.[check.nodeId];
+    if (!node) {
+      return { ...check, verdict: 'unknown', reason: `node ${check.nodeId} was not found` };
     }
-    const facts = linkFacts([
-      nodeFromSnapshot(snapshot),
-      snapshot?.controls,
-    ]);
-    if (facts.length === 0) {
-      const controlFacts = linkFacts(context?.componentControls);
-      if (controlFacts.length > 0) {
-        observe(state, 'component_link_control_available', {
-          nodeId,
-          sources: controlFacts.map((fact) => fact.path).slice(0, 20),
-        });
-      }
-      unknown(
-        state,
-        `no native link or component-control destination was visible for ${nodeId}`,
-      );
-      continue;
+    const values = propertyValues(node, check.property);
+    if (values.length === 0) {
+      return {
+        ...check,
+        verdict: 'unknown',
+        reason: `${check.property} is not set on ${check.nodeId}`,
+      };
     }
-    const matchingFact = facts.find((fact) =>
-      fact.candidates.some((candidate) => expected.has(candidate)));
-    if (matchingFact) {
-      observe(state, 'navigation_destination', {
-        nodeId,
-        source: matchingFact.path,
-        value: matchingFact.value,
-      });
-      continue;
+    const observed = serialized(values.length === 1 ? values[0] : values);
+    if (check.contains && !observed.toLowerCase().includes(check.contains.toLowerCase())) {
+      return {
+        ...check,
+        verdict: 'contradicted',
+        reason: `${check.property} on ${check.nodeId} does not contain ${check.contains}`,
+        observedValue: observed.slice(0, MAX_OBSERVED_CHARS),
+      };
     }
-    contradict(
-      state,
-      `${nodeId} points to ${facts.map((fact) => fact.value).join(', ')} instead of ${expectedValues.join(' or ')}`,
-    );
-  }
-}
-
-function verifyExistingComponent(
-  check,
-  behavior,
-  snapshots,
-  state,
-  context,
-) {
-  const trigger = snapshotFor(snapshots, check.triggerNodeId);
-  verifyComponentInstances(check, behavior, snapshots, state, context);
-  if (
-    behavior.presentation === 'navigation'
-    || behavior.layoutEffect === 'navigation'
-  ) {
-    verifyNativeLink(check, behavior, snapshots, state, context);
-    return;
-  }
-  const triggerEvent = verifyTrigger(check, behavior, trigger, state);
-  if (trigger && !belongsTo(trigger, check.componentNodeId)) {
-    contradict(state, 'the trigger is not inside the existing component definition');
-  }
-  const permittedActions =
-    behavior.presentation === 'floating' || behavior.presentation === 'modal'
-      ? ['show_overlay', 'trigger_event']
-      : behavior.stateChange
-        ? ['set_variant', 'trigger_event']
-        : [];
-  if (
-    permittedActions.length > 0
-    && triggerEvent
-    && !permittedActions.some((action) => triggerEvent.includes(action))
-  ) {
-    contradict(
-      state,
-      'the component trigger does not expose an action capable of the declared behavior',
-    );
-  }
-  verifyExpectedContent(
-    behavior,
-    snapshots,
-    [check.componentNodeId, ...check.instanceNodeIds],
-    state,
-  );
-}
-
-function hasCodeComponentEvidence(snapshot) {
-  const node = nodeFromSnapshot(snapshot);
-  if (!node) return false;
-  const serialized = normalizedEvidenceText(node);
-  return (
-    serialized.includes('codecomponent')
-    || serialized.includes('code_file')
-    || serialized.includes('codefile')
-    || serialized.includes('componentidentifier')
-  );
-}
-
-function verifyCodeComponent(check, behavior, snapshots, state, context) {
-  // Code files are not native canvas ComponentNodes. Their durable structural
-  // proof is an installed ComponentInstanceNode whose component reference
-  // resolves to the authored code-file ID.
-  verifyComponentInstances(
-    check,
-    behavior,
-    snapshots,
-    state,
-    context,
-    { requireDefinition: false },
-  );
-  const nodes = check.instanceNodeIds.map((id) => snapshotFor(snapshots, id));
-  if (
-    !nodes.some(hasCodeComponentEvidence)
-    && Number(context?.lowLevelWriteCalls || 0) < 1
-  ) {
-    unknown(
-      state,
-      'no code-component source or installed code-component evidence was found',
-    );
-  }
-  // Content is covered by the mandatory structural and visual checks. Behavior
-  // plans may describe content semantically rather than quote literal canvas
-  // text, so treating that prose as an exact interaction assertion creates
-  // false failures for otherwise valid code components.
-}
-
-function verifyNativeEvent(check, behavior, snapshots, state) {
-  verifyTrigger(
-    check,
-    behavior,
-    snapshotFor(snapshots, check.triggerNodeId),
-    state,
-  );
-}
-
-function verifyNativeEffect(check, behavior, snapshots, state) {
-  const trigger = snapshotFor(snapshots, check.triggerNodeId);
-  if (!check.triggerNodeId || !trigger) {
-    unknown(state, 'effect target node was not found');
-    return null;
-  }
-  observe(state, 'node_found', {
-    nodeId: check.triggerNodeId,
-    nodeType: nodeType(trigger),
-  });
-  if (!FRAME_EFFECT_NODE_TYPES.has(nodeType(trigger))) {
-    contradict(
-      state,
-      `${nodeType(trigger) || 'the target node'} does not support verified Framer effects`,
-    );
-  }
-  const effectName = NATIVE_EFFECT_BY_ACTIVATION[behavior.activation];
-  if (!effectName) {
-    contradict(
-      state,
-      `native_effect does not support ${behavior.activation} activation`,
-    );
-    return null;
-  }
-  if (check.event !== effectName) {
-    contradict(
-      state,
-      `${check.event || 'the supplied effect'} does not match ${effectName}`,
-    );
-  }
-  const effect = directNodeProperty(trigger, effectName);
-  if (!isRecord(effect) || Object.keys(effect).length === 0) {
-    unknown(state, `${effectName} is not visible on the serialized target`);
-    return null;
-  }
-  observe(state, 'native_effect', {
-    nodeId: check.triggerNodeId,
-    effectName,
-    value: effect,
-  });
-  if (
-    effectName === 'appearEffect'
-    && !['onInView', 'onMount', 'onScrollTarget', 'onScrollDirection']
-      .includes(effect.trigger)
-  ) {
-    contradict(state, 'appearEffect does not declare a supported trigger');
-  }
-  return {
-    effectName,
-    observedEffect: effect,
-  };
-}
-
-function verdictFor(state) {
-  if (state.contradictions.length > 0) return 'contradicted';
-  if (state.unknowns.length > 0) return 'unknown';
-  return 'verified';
-}
-
-function applySemanticAssessment(
-  check,
-  result,
-  mode,
-  liveEvidenceNodeIds = new Set(),
-) {
-  const assessment = check.semanticAssessment;
-  const base = {
-    ...result,
-    deterministicVerdict: result.verdict,
-    semanticAssessment: assessment
-      ? {
-          ...assessment,
-          mode,
-          accepted: false,
-        }
-      : null,
-  };
-  if (
-    mode !== 'enforce'
-    || result.verdict !== 'unknown'
-    || !assessment
-    || assessment.verdict === 'unknown'
-  ) return base;
-  if (
-    assessment.evidenceNodeIds.length === 0
-    || !assessment.evidenceNodeIds.every((nodeId) =>
-      liveEvidenceNodeIds.has(nodeId))
-  ) {
     return {
-      ...base,
-      unknowns: uniqueStrings([
-        ...base.unknowns,
-        'semantic verification was not accepted because its evidence IDs were not backed by live observations',
-      ]),
-    };
-  }
-  return {
-    ...base,
-    verdict: assessment.verdict,
-    contradictions:
-      assessment.verdict === 'contradicted'
-        ? uniqueStrings([
-            ...base.contradictions,
-            `Semantic assessment contradicted the behavior: ${assessment.rationale}`,
-          ], 30)
-        : base.contradictions,
-    semanticAssessment: {
-      ...base.semanticAssessment,
-      accepted: true,
-    },
-  };
-}
-
-export function verifyBehaviorEvidence({
-  plan,
-  checks,
-  snapshots,
-  context = {},
-}) {
-  const behaviorById = new Map(
-    (plan?.behaviors || []).map((behavior) => [behavior.id, behavior]),
-  );
-  const mechanismByBehavior = new Map(
-    (plan?.mechanisms || []).map((decision) => [
-      decision.behaviorId,
-      decision,
-    ]),
-  );
-  const liveEvidenceNodeIds = new Set(
-    snapshots instanceof Map
-      ? [...snapshots.entries()]
-          .filter(([, snapshot]) => Boolean(snapshot))
-          .map(([nodeId]) => nodeId)
-      : Object.entries(snapshots || {})
-          .filter(([, snapshot]) => Boolean(snapshot))
-          .map(([nodeId]) => nodeId),
-  );
-  const verifiedChecks = checks.map((check) => {
-    const behavior = behaviorById.get(check.behaviorId);
-    const decision = mechanismByBehavior.get(check.behaviorId);
-    const state = evidenceState();
-    let nativeEffectEvidence = null;
-    if (!behavior || !decision) {
-      contradict(state, 'the planned behavior or mechanism was not found');
-    } else if (decision.mechanism === 'native_link') {
-      verifyNativeLink(check, behavior, snapshots, state, context);
-    } else if (decision.mechanism === 'native_overlay') {
-      verifyOverlay(check, behavior, snapshots, state);
-    } else if (decision.mechanism === 'native_component_variants') {
-      verifyComponentVariants(check, behavior, snapshots, state, context);
-    } else if (decision.mechanism === 'existing_component_control') {
-      verifyExistingComponent(check, behavior, snapshots, state, context);
-    } else if (decision.mechanism === 'code_component') {
-      verifyCodeComponent(check, behavior, snapshots, state, context);
-    } else if (decision.mechanism === 'native_effect') {
-      nativeEffectEvidence = verifyNativeEffect(
-        check,
-        behavior,
-        snapshots,
-        state,
-      );
-    } else {
-      verifyNativeEvent(check, behavior, snapshots, state);
-    }
-    const result = {
       ...check,
-      mechanism: decision?.mechanism,
-      ...(nativeEffectEvidence || {}),
-      verdict: verdictFor(state),
-      contradictions: uniqueStrings(state.contradictions, 30),
-      unknowns: uniqueStrings(state.unknowns, 30),
-      observations: state.observations.slice(0, 50),
-      repairAllowed: state.contradictions.length > 0,
-      nextSafeActions:
-        state.contradictions.length > 0
-          ? ['Repair only the observed contradictory properties, then verify once.']
-          : state.unknowns.length > 0
-            ? ['Collect a different live evidence source or provide a grounded semantic assessment; do not mutate based only on unknown evidence.']
-            : [],
+      verdict: 'verified',
+      observedValue: observed.slice(0, MAX_OBSERVED_CHARS),
     };
-    return applySemanticAssessment(
-      check,
-      result,
-      ['off', 'shadow', 'enforce'].includes(context?.semanticVerifierMode)
-        ? context.semanticVerifierMode
-        : 'shadow',
-      liveEvidenceNodeIds,
-    );
   });
+}
 
-  const behaviorResults = (plan?.behaviors || []).map((behavior) => {
-    const decision = mechanismByBehavior.get(behavior.id);
-    const matching = verifiedChecks.filter((check) =>
-      check.behaviorId === behavior.id);
-    const targetIdsFor = (check) =>
-      decision?.mechanism === 'native_component_variants'
-      || decision?.mechanism === 'existing_component_control'
-      || decision?.mechanism === 'code_component'
-      || (
-        decision?.mechanism === 'native_link'
-        && check.instanceNodeIds.length > 0
-      )
-        ? check.instanceNodeIds
-        : [check.triggerNodeId].filter(Boolean);
-    const observedTargets = new Set(matching.flatMap(targetIdsFor));
-    const verifiedTargets = new Set(
-      matching
-        .filter((check) => check.verdict === 'verified')
-        .flatMap(targetIdsFor),
-    );
-    const contradictedTargets = new Set(
-      matching
-        .filter((check) => check.verdict === 'contradicted')
-        .flatMap(targetIdsFor),
+// Summarizes the current check results for every planned behavior. A behavior
+// is verified once each of its declared target nodes has a verified check.
+// status: missing (a behavior or target was never checked), contradicted (a
+// property holds a different value), unverified (some properties could not be
+// found, so the behavior is unconfirmed), or verified.
+export function summarizeBehaviorVerification(plan, checkResults) {
+  const behaviors = (plan?.behaviors || []).map((behavior) => {
+    const results = checkResults.filter((result) => result.behaviorId === behavior.id);
+    const verifiedNodeIds = new Set(
+      results.filter((result) => result.verdict === 'verified').map((result) => result.nodeId),
     );
-    const contradictions = matching
-      .filter((check) => check.verdict === 'contradicted')
-      .flatMap((check) => check.contradictions);
-    const unknowns = matching
-      .filter((check) => check.verdict === 'unknown')
-      .flatMap((check) => check.unknowns);
-    if (matching.length === 0) unknowns.push('no evidence was supplied');
-    if (verifiedTargets.size < behavior.expectedTargets) {
-      unknowns.push(
-        `verified ${verifiedTargets.size} of ${behavior.expectedTargets} expected targets`,
-      );
-    }
-    const verdict =
-      matching.some((check) => check.verdict === 'contradicted')
-        ? 'contradicted'
-        : matching.some((check) => check.verdict === 'unknown')
-          || unknowns.length > 0
-          ? 'unknown'
-          : 'verified';
+    const contradictions = results
+      .filter((result) => result.verdict === 'contradicted')
+      .map((result) => result.reason);
+    const checkedNodeIds = new Set(results.map((result) => result.nodeId));
+    const uncheckedTargets = behavior.targetNodeIds.filter((nodeId) => !checkedNodeIds.has(nodeId));
+    const unverifiedTargets = behavior.targetNodeIds.filter((nodeId) => !verifiedNodeIds.has(nodeId));
+    const covered = behavior.targetNodeIds.length > 0
+      ? unverifiedTargets.length === 0
+      : verifiedNodeIds.size > 0;
     return {
       behaviorId: behavior.id,
-      behaviorSignature: behavior.signature,
-      mechanism: decision?.mechanism,
-      expectedTargets: behavior.expectedTargets,
-      observedTargets: observedTargets.size,
-      verifiedTargets: verifiedTargets.size,
-      contradictedTargets: contradictedTargets.size,
-      unknownTargets: Math.max(
-        0,
-        behavior.expectedTargets
-          - verifiedTargets.size
-          - contradictedTargets.size,
+      checked: results.length > 0 && uncheckedTargets.length === 0,
+      verdict: contradictions.length > 0 ? 'contradicted' : covered ? 'verified' : 'unknown',
+      verifiedTargets: verifiedNodeIds.size,
+      expectedTargets: behavior.targetNodeIds.length,
+      unverifiedTargets,
+      uncheckedTargets,
+      contradictions: uniqueStrings(contradictions, 20),
+      unknowns: uniqueStrings(
+        results.filter((result) => result.verdict === 'unknown').map((result) => result.reason),
+        20,
       ),
-      verdict,
-      contradictions: uniqueStrings(contradictions, 50),
-      unknowns: uniqueStrings(unknowns, 50),
     };
   });
-  const representativeBehaviorIds = behaviorResults
-    .filter((result) =>
-      verifiedChecks.some((check) =>
-        check.behaviorId === result.behaviorId
-        && check.verdict === 'verified'))
-    .map((result) => result.behaviorId);
-  const completed =
-    behaviorResults.length > 0
-    && behaviorResults.every((result) => result.verdict === 'verified');
-  const hasContradictions = behaviorResults.some((result) =>
-    result.verdict === 'contradicted');
-  const usedSemanticAssessment = verifiedChecks.some((check) =>
-    check.semanticAssessment?.accepted === true);
-  return {
-    completed,
-    verificationLevel:
-      completed && usedSemanticAssessment
-        ? 'semantically_verified'
-        : completed
-          ? 'structurally_verified'
-          : hasContradictions
-            ? 'contradicted'
-            : 'unknown',
-    checks: verifiedChecks,
-    behaviors: behaviorResults,
-    representativeBehaviorIds,
-  };
+  const status = behaviors.some((behavior) => !behavior.checked)
+    ? 'missing'
+    : behaviors.some((behavior) => behavior.verdict === 'contradicted')
+      ? 'contradicted'
+      : behaviors.some((behavior) => behavior.verdict === 'unknown')
+        ? 'unverified'
+        : 'verified';
+  return { status, behaviors };
 }
 
 export function summarizeFramerChanges(changes) {