fix: bound candidate identity before self-check comparison

The identity-set scan in computeTargetEvidence compared an untruncated
candidate identity against the 256-byte-bounded recorded identity, so a
node whose own id/label exceeds the field cap could fail to match itself,
corrupting the record-time self-check. Compare through the same bounding
on both sides instead.

Author: thymikee

src/daemon/__tests__/session-target-evidence.test.ts

@@ -319,3 +319,29 @@ test('computeTargetEvidence: real-capture-shaped tree (undefined hittable, anony
   const json = serializeTargetAnnotationV1(evidence);
   assert.deepEqual(parseTargetAnnotationV1Payload(json), evidence);
 });
+
+// ---------------------------------------------------------------------------
+// Self-consistency: a node whose own id/label exceeds the 256-byte field cap
+// must still match ITSELF during the identity-set scan. The recorded
+// identity is truncated (writer-parser invariant); comparing an untruncated
+// candidate against it would spuriously exclude the winner from its own
+// identity set and produce a false 'unverifiable'.
+// ---------------------------------------------------------------------------
+
+test('computeTargetEvidence: a node with an over-cap id still matches itself and is verified', () => {
+  const overCapId = 'save-'.repeat(100); // 500 bytes, well over the 256-byte field cap
+  const nodes = toSnapshotNodes([
+    {
+      index: 0,
+      type: 'Button',
+      identifier: overCapId,
+      label: 'Save',
+      rect: { x: 0, y: 0, width: 10, height: 10 },
+      depth: 0,
+    },
+  ]);
+  const evidence = computeTargetEvidence({ node: nodes[0]!, nodes });
+  assert.ok(evidence);
+  assert.equal(evidence.id, overCapId.slice(0, TARGET_ANNOTATION_MAX_FIELD_BYTES));
+  assert.equal(evidence.verification, 'verified');
+});

src/daemon/session-target-evidence.ts

@@ -235,7 +235,13 @@ function computeDisambiguationDomain(params: {
   // Step 2: all nodes sharing the winner's local identity with a matching
   // leaf-anchored ancestry prefix.
   const identitySet = nodes.filter((candidate) => {
-    if (!matchesLocalIdentity(computeLocalIdentity(candidate), identity)) return false;
+    // Compare through the SAME 256-byte bounding the recorded `identity` and
+    // ancestry entries already went through — otherwise a node whose own
+    // id/label exceeds the field cap would spuriously fail to match ITSELF
+    // (the recorded value is truncated; the raw candidate value is not),
+    // corrupting both this self-check and, if the replay-time matcher ever
+    // skipped the same bounding, a real node's identity check later.
+    if (!matchesLocalIdentity(boundedLocalIdentity(candidate), identity)) return false;
     const observedAncestry = buildAncestryChain(candidate, byIndex, Math.max(ancestry.length, 1));
     return matchesAncestryPrefix(observedAncestry, ancestry);
   });