fix: record iOS selector target evidence

Author: thymikee

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

@@ -110,6 +110,21 @@ test('computeTargetEvidence: scrollRegion is the nearest scrollable ancestor loc
   assert.equal(evidence.verification, 'verified');
 });
 
+test('computeTargetEvidence: a stable scroll-region ID takes precedence over a changed label', () => {
+  const recordedNodes = scrollableListFixture();
+  recordedNodes[1]!.label = 'Inbox';
+  const recorded = computeTargetEvidence({ node: recordedNodes[2]!, nodes: recordedNodes });
+
+  const currentNodes = scrollableListFixture();
+  currentNodes[1]!.label = 'Messages';
+  const current = computeTargetEvidence({ node: currentNodes[2]!, nodes: currentNodes });
+
+  assert.ok(recorded);
+  assert.ok(current);
+  assert.deepEqual(recorded.scrollRegion, { role: 'scrollview', id: 'editor-scroll' });
+  assert.deepEqual(current.scrollRegion, recorded.scrollRegion);
+});
+
 // ---------------------------------------------------------------------------
 // Duplicate identity resolved by sibling / viewportOrder, still verified
 // (decision 3's self-check succeeds by construction whenever the capture

src/daemon/handlers/interaction-touch.ts

@@ -314,6 +314,7 @@ function readDirectIosSelectorTapTarget(params: {
   const { session, commandLabel, target, flags } = params;
   if (commandLabel !== 'click') return null;
   if (target.kind !== 'selector') return null;
+  if (session.recordSession) return null;
   if (hasNonDefaultClickOptions(flags)) return null;
   if (commandSupportsVerifyEvidence(commandLabel) && flags?.verify === true) return null;
   if (commandSupportsSettleObservation(commandLabel) && flags?.settle === true) return null;
@@ -634,6 +635,7 @@ function readDirectIosSelectorFillTarget(params: {
 }): DirectIosSelectorTarget | null {
   const { session, target, flags } = params;
   if (target.kind !== 'selector') return null;
+  if (session.recordSession) return null;
   if (commandSupportsVerifyEvidence('fill') && flags?.verify === true) return null;
   if (commandSupportsSettleObservation('fill') && flags?.settle === true) return null;
   return readDirectSelectorWithMaestroFallback(session, target.selector, flags);

src/daemon/session-target-evidence.ts

@@ -203,8 +203,11 @@ function computeScrollRegionKey(
   const identity = boundedLocalIdentity(container);
   return {
     role: identity.role,
-    ...(identity.id !== undefined ? { id: identity.id } : {}),
-    ...(identity.label !== undefined ? { label: identity.label } : {}),
+    ...(identity.id !== undefined
+      ? { id: identity.id }
+      : identity.label !== undefined
+        ? { label: identity.label }
+        : {}),
   };
 }
 
@@ -214,7 +217,7 @@ function scrollRegionKeysEqual(
 ): boolean {
   if (!a && !b) return true;
   if (!a || !b) return false;
-  return a.role === b.role && a.id === b.id && a.label === b.label;
+  return matchesLocalIdentity(a, b);
 }
 
 function boundedRect(node: SnapshotNode): TargetAnnotationV1['rect'] {

src/replay/__tests__/target-identity-classification.test.ts

@@ -0,0 +1,79 @@
+import { test } from 'vitest';
+import assert from 'node:assert/strict';
+import { classifyTargetBindingMatch } from '../target-identity.ts';
+
+// Decision 3's replay-time verification paths 2-6 are shared with the
+// writer's record-time self-check and stay isolated from parser coverage.
+
+test('classifyTargetBindingMatch path 2: matchCount 0 is unverifiable (selector-miss)', () => {
+  const result = classifyTargetBindingMatch({
+    winnerRef: 'e1', matchedRefs: [], identitySetRefs: [], siblingMatchRefs: [],
+    regionMemberRefs: undefined, viewportCandidateRef: undefined,
+  });
+  assert.deepEqual(result, { path: 2, outcome: 'unverifiable', reason: 'selector-miss' });
+});
+
+test('classifyTargetBindingMatch path 3: empty identity set is unverifiable', () => {
+  const result = classifyTargetBindingMatch({
+    winnerRef: 'e1', matchedRefs: ['e1'], identitySetRefs: [], siblingMatchRefs: [],
+    regionMemberRefs: undefined, viewportCandidateRef: undefined,
+  });
+  assert.deepEqual(result, { path: 3, outcome: 'unverifiable', reason: 'identity-set-empty' });
+});
+
+test('classifyTargetBindingMatch path 4: unique identity-set member equal to winner is verified', () => {
+  const result = classifyTargetBindingMatch({
+    winnerRef: 'e1', matchedRefs: ['e1'], identitySetRefs: ['e1'], siblingMatchRefs: ['e1'],
+    regionMemberRefs: undefined, viewportCandidateRef: undefined,
+  });
+  assert.deepEqual(result, { path: 4, outcome: 'verified' });
+});
+
+test('classifyTargetBindingMatch path 5: unique identity-set member that is not the winner is unverifiable', () => {
+  const result = classifyTargetBindingMatch({
+    winnerRef: 'e1', matchedRefs: ['e1'], identitySetRefs: ['e9'], siblingMatchRefs: [],
+    regionMemberRefs: undefined, viewportCandidateRef: undefined,
+  });
+  assert.deepEqual(result, { path: 5, outcome: 'unverifiable', reason: 'unique-but-wrong' });
+});
+
+test('classifyTargetBindingMatch path 6: duplicate identity resolved by a unique sibling match', () => {
+  const result = classifyTargetBindingMatch({
+    winnerRef: 'e1', matchedRefs: ['e1', 'e2'], identitySetRefs: ['e1', 'e2'],
+    siblingMatchRefs: ['e1'], regionMemberRefs: undefined, viewportCandidateRef: undefined,
+  });
+  assert.deepEqual(result, { path: 6, outcome: 'verified' });
+});
+
+test('classifyTargetBindingMatch path 6: viewport order resolves repeated sibling ordinals', () => {
+  const result = classifyTargetBindingMatch({
+    winnerRef: 'e1', matchedRefs: ['e1', 'e2'], identitySetRefs: ['e1', 'e2'],
+    siblingMatchRefs: ['e1', 'e2'], regionMemberRefs: ['e2', 'e1'], viewportCandidateRef: 'e1',
+  });
+  assert.deepEqual(result, { path: 6, outcome: 'verified' });
+});
+
+test('classifyTargetBindingMatch path 6: unavailable or out-of-range viewport evidence falls through', () => {
+  for (const [regionMemberRefs, viewportCandidateRef] of [
+    [undefined, undefined],
+    [['e1', 'e2'], undefined],
+  ] as const) {
+    const result = classifyTargetBindingMatch({
+      winnerRef: 'e1', matchedRefs: ['e1', 'e2'], identitySetRefs: ['e1', 'e2'],
+      siblingMatchRefs: ['e1', 'e2'], regionMemberRefs, viewportCandidateRef,
+    });
+    assert.deepEqual(result, { path: 6, outcome: 'unverifiable', reason: 'no-signal-isolation' });
+  }
+});
+
+test('classifyTargetBindingMatch path 6: a signal isolating a different node than the winner is distinct from fall-through', () => {
+  for (const params of [
+    { siblingMatchRefs: ['e1', 'e2'], regionMemberRefs: ['e1', 'e2'], viewportCandidateRef: 'e2' },
+    { siblingMatchRefs: ['e2'], regionMemberRefs: ['e1', 'e2'], viewportCandidateRef: 'e1' },
+  ]) {
+    const result = classifyTargetBindingMatch({
+      winnerRef: 'e1', matchedRefs: ['e1', 'e2'], identitySetRefs: ['e1', 'e2'], ...params,
+    });
+    assert.deepEqual(result, { path: 6, outcome: 'unverifiable', reason: 'signal-isolated-wrong' });
+  }
+});

src/replay/__tests__/target-identity.test.ts

@@ -2,7 +2,6 @@ import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { AppError } from '../../kernel/errors.ts';
 import {
-  classifyTargetBindingMatch,
   formatTargetAnnotationCommentLine,
   matchesAncestryPrefix,
   matchesLocalIdentity,
@@ -365,143 +364,3 @@ test('parser accepts an explicit empty-string role (writer-legal for typeless no
   assert.equal(parsed.role, '');
   assert.deepEqual(parsed.ancestry, [{ role: '' }]);
 });
-
-// ---------------------------------------------------------------------------
-// Classification core (decision 3 "Replay-time verification" paths 2-6):
-// this is the exact function the writer's record-time self-check calls, and
-// what a future replay-enforcement step will reuse — so duplicate/unverifiable
-// evidence is exercised directly and generically here.
-// ---------------------------------------------------------------------------
-
-test('classifyTargetBindingMatch path 2: matchCount 0 is unverifiable (selector-miss)', () => {
-  const result = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: [],
-    identitySetRefs: [],
-    siblingMatchRefs: [],
-    regionMemberRefs: undefined,
-    viewportCandidateRef: undefined,
-  });
-  assert.deepEqual(result, { path: 2, outcome: 'unverifiable', reason: 'selector-miss' });
-});
-
-test('classifyTargetBindingMatch path 3: empty identity set is unverifiable', () => {
-  const result = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1'],
-    identitySetRefs: [],
-    siblingMatchRefs: [],
-    regionMemberRefs: undefined,
-    viewportCandidateRef: undefined,
-  });
-  assert.deepEqual(result, { path: 3, outcome: 'unverifiable', reason: 'identity-set-empty' });
-});
-
-test('classifyTargetBindingMatch path 4: unique identity-set member equal to winner is verified', () => {
-  const result = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1'],
-    identitySetRefs: ['e1'],
-    siblingMatchRefs: ['e1'],
-    regionMemberRefs: undefined,
-    viewportCandidateRef: undefined,
-  });
-  assert.deepEqual(result, { path: 4, outcome: 'verified' });
-});
-
-test('classifyTargetBindingMatch path 5: unique identity-set member that is NOT the winner (unique-but-wrong rebind)', () => {
-  const result = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1'],
-    identitySetRefs: ['e9'],
-    siblingMatchRefs: [],
-    regionMemberRefs: undefined,
-    viewportCandidateRef: undefined,
-  });
-  assert.deepEqual(result, { path: 5, outcome: 'unverifiable', reason: 'unique-but-wrong' });
-});
-
-test('classifyTargetBindingMatch path 6: duplicate identity resolved by a unique sibling match', () => {
-  const verified = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1', 'e2'],
-    identitySetRefs: ['e1', 'e2'],
-    siblingMatchRefs: ['e1'],
-    regionMemberRefs: undefined,
-    viewportCandidateRef: undefined,
-  });
-  assert.deepEqual(verified, { path: 6, outcome: 'verified' });
-});
-
-test('classifyTargetBindingMatch path 6: same child index recurring under different parents falls through sibling, resolved by region-scoped viewportOrder', () => {
-  const result = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1', 'e2'],
-    identitySetRefs: ['e1', 'e2'],
-    // Both members are "child 0" under different parents — sibling alone
-    // does not isolate.
-    siblingMatchRefs: ['e1', 'e2'],
-    regionMemberRefs: ['e2', 'e1'],
-    viewportCandidateRef: 'e1',
-  });
-  assert.deepEqual(result, { path: 6, outcome: 'verified' });
-});
-
-test('classifyTargetBindingMatch path 6: a scroll region that no longer exists falls through to unverifiable, never a silent pick', () => {
-  const result = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1', 'e2'],
-    identitySetRefs: ['e1', 'e2'],
-    siblingMatchRefs: ['e1', 'e2'],
-    regionMemberRefs: undefined, // region unavailable
-    viewportCandidateRef: undefined,
-  });
-  assert.deepEqual(result, { path: 6, outcome: 'unverifiable', reason: 'no-signal-isolation' });
-});
-
-test('classifyTargetBindingMatch path 6: an out-of-range recorded viewportOrder falls through to unverifiable', () => {
-  const result = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1', 'e2'],
-    identitySetRefs: ['e1', 'e2'],
-    siblingMatchRefs: ['e1', 'e2'],
-    regionMemberRefs: ['e1', 'e2'],
-    viewportCandidateRef: undefined, // ordinal was out of range
-  });
-  assert.deepEqual(result, { path: 6, outcome: 'unverifiable', reason: 'no-signal-isolation' });
-});
-
-test('classifyTargetBindingMatch path 6: a signal isolating a DIFFERENT node than the winner is the paths-4/5 comparison class, not fall-through', () => {
-  // Decision 3 path 6.i/6.ii: when a signal denotes exactly one member,
-  // "compare with W as in paths 4/5" — an isolated-but-different member is
-  // the same class as path 5's unique-but-wrong rebind (a future
-  // identity-mismatch), distinct from true no-isolation fall-through (a
-  // future identity-unverifiable with candidates).
-  const viaViewportOrder = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1', 'e2'],
-    identitySetRefs: ['e1', 'e2'],
-    siblingMatchRefs: ['e1', 'e2'],
-    regionMemberRefs: ['e1', 'e2'],
-    viewportCandidateRef: 'e2',
-  });
-  assert.deepEqual(viaViewportOrder, {
-    path: 6,
-    outcome: 'unverifiable',
-    reason: 'signal-isolated-wrong',
-  });
-
-  const viaSibling = classifyTargetBindingMatch({
-    winnerRef: 'e1',
-    matchedRefs: ['e1', 'e2'],
-    identitySetRefs: ['e1', 'e2'],
-    siblingMatchRefs: ['e2'], // sibling isolates e2, not the winner
-    regionMemberRefs: ['e1', 'e2'],
-    viewportCandidateRef: 'e1',
-  });
-  assert.deepEqual(viaSibling, {
-    path: 6,
-    outcome: 'unverifiable',
-    reason: 'signal-isolated-wrong',
-  });
-});

test/integration/interaction-contract/daemon-harness.ts

@@ -30,6 +30,7 @@ const CONTRACT_DEVICE_ID = PROVIDER_SCENARIO_IOS_SIMULATOR.id;
 export async function withIosContractDaemon(
   entries: readonly ProviderScenarioProviderEntry[],
   run: (daemon: ProviderScenarioHarness, transcript: ProviderScenarioTranscript) => Promise<void>,
+  options: { saveScript?: boolean | string } = {},
 ): Promise<void> {
   const transcript = createProviderTranscript(entries);
   const appleRunnerProvider = createAppleRunnerProviderFromTranscript(transcript, 'ios.runner');
@@ -50,6 +51,7 @@ export async function withIosContractDaemon(
       const open = await daemon.callCommand('open', [CONTRACT_APP], {
         platform: 'ios',
         udid: CONTRACT_DEVICE_ID,
+        ...(options.saveScript !== undefined ? { saveScript: options.saveScript } : {}),
       });
       assertRpcOk(open);
       await run(daemon, transcript);

test/integration/interaction-contract/direct-ios-selector.contract.test.ts

@@ -16,6 +16,7 @@ import {
   runnerSnapshotEntry,
   runnerTapEntry,
   runnerTapErrorEntry,
+  runnerTypeEntry,
   withIosContractDaemon,
 } from './daemon-harness.ts';
 
@@ -28,6 +29,30 @@ import {
 const scenario = (guarantee: InteractionGuarantee): string =>
   scenarioName(DIRECT_IOS_SELECTOR_COVERAGE, guarantee);
 
+const RECORDING_TARGET_NODES = [
+  { index: 0, type: 'Application', rect: { x: 0, y: 0, width: 390, height: 844 } },
+  {
+    index: 1,
+    parentIndex: 0,
+    type: 'Button',
+    identifier: 'continue',
+    label: 'Continue',
+    rect: { x: 40, y: 160, width: 120, height: 44 },
+    enabled: true,
+    hittable: true,
+  },
+  {
+    index: 2,
+    parentIndex: 0,
+    type: 'TextField',
+    identifier: 'email',
+    label: 'Email',
+    rect: { x: 40, y: 240, width: 280, height: 44 },
+    enabled: true,
+    hittable: true,
+  },
+] as const;
+
 test(scenario('responseConstruction'), async () => {
   await withIosContractDaemon([runnerTapEntry({ x: 150, y: 200 })], async (daemon, transcript) => {
     const click = await daemon.callCommand('click', ['label=Continue']);
@@ -48,6 +73,49 @@ test(scenario('responseConstruction'), async () => {
   });
 });
 
+test('recorded simple iOS selector click and fill use runtime resolution and persist target-v1 evidence', async () => {
+  await withIosContractDaemon(
+    [
+      runnerSnapshotEntry(RECORDING_TARGET_NODES),
+      runnerTapEntry({ x: 100, y: 182 }),
+      runnerSnapshotEntry(RECORDING_TARGET_NODES),
+      runnerTypeEntry({ x: 180, y: 262 }),
+    ],
+    async (daemon, transcript) => {
+      assertRpcOk(await daemon.callCommand('click', ['id=continue']));
+      assertRpcOk(await daemon.callCommand('fill', ['id=email', 'ada@example.com']));
+
+      assert.equal(transcript.calls[0]?.command, 'ios.runner.snapshot');
+      assert.equal(transcript.calls[1]?.command, 'ios.runner.tap');
+      assert.equal(transcript.calls[2]?.command, 'ios.runner.snapshot');
+      assert.equal(transcript.calls[3]?.command, 'ios.runner.type');
+      for (const call of [transcript.calls[1], transcript.calls[3]]) {
+        const request = call?.request as Record<string, unknown> | undefined;
+        assert.equal(request?.selectorKey, undefined);
+      }
+
+      const actions = daemon
+        .session()
+        ?.actions.filter((action) => action.command === 'click' || action.command === 'fill');
+      assert.deepEqual(actions?.map((action) => action.command), ['click', 'fill']);
+      const targetIdentities = actions?.map((action) => {
+        const evidence = action.targetEvidence as Record<string, unknown> | undefined;
+        return {
+          id: evidence?.id,
+          role: evidence?.role,
+          label: evidence?.label,
+          verification: evidence?.verification,
+        };
+      });
+      assert.deepEqual(targetIdentities, [
+        { id: 'continue', role: 'button', label: 'Continue', verification: 'verified' },
+        { id: 'email', role: 'textfield', label: 'Email', verification: 'verified' },
+      ]);
+    },
+    { saveScript: true },
+  );
+});
+
 test(scenario('offscreen'), async () => {
   await withIosContractDaemon(
     [