@gakim-digital/dexter-bridge 0.11.4 → 0.11.6

package/src/framerAgentTools.js

@@ -24,6 +24,8 @@ const DEFAULT_COMMAND_TIMEOUT_MS = 5 * 60_000;
 const SESSION_TIMEOUT_MS = 10 * 60_000;
 const MAX_UNSAFE_WRITE_FAILURES = 2;
 const MAX_LOW_LEVEL_WRITE_FAILURES = 3;
+const MAX_INTERACTION_VERIFICATION_ATTEMPTS_PER_BEHAVIOR = 3;
+const MAX_INTERACTION_REPAIRS_PER_BEHAVIOR = 1;
 const MAX_GUIDANCE_BYTES = 180 * 1024;
 const MAX_GUIDANCE_FILE_BYTES = 48 * 1024;
 const PROJECT_ID_PATTERN = /^[A-Za-z0-9]{20}$/;
@@ -189,6 +191,15 @@ export const FRAMER_AGENT_TOOL_DEFINITIONS = [
                 type: 'array',
                 maxItems: 20,
                 items: { type: 'string', minLength: 1, maxLength: 500 },
+                description:
+                  'Optional exact literal text that must exist in the interaction target. Do not put behavioral descriptions or prose assertions here.',
+              },
+              expectedDestinations: {
+                type: 'array',
+                maxItems: 20,
+                items: { type: 'string', minLength: 1, maxLength: 500 },
+                description:
+                  'Required for navigation behavior. Use exact routes or URLs such as /contact.',
               },
               initialState: {
                 type: 'string',
@@ -237,6 +248,25 @@ export const FRAMER_AGENT_TOOL_DEFINITIONS = [
                 maxLength: 800,
               },
               representativeFirst: { type: 'boolean', default: true },
+              targetNodeIds: {
+                type: 'array',
+                maxItems: 50,
+                uniqueItems: true,
+                items: {
+                  type: 'string',
+                  minLength: 1,
+                  maxLength: 200,
+                },
+                description:
+                  'All intended target node IDs. Required when expectedTargets is greater than one.',
+              },
+              representativeTargetNodeId: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 200,
+                description:
+                  'The single target to implement and verify before fan-out.',
+              },
             },
             required: ['behaviorId', 'mechanism', 'rationale'],
             additionalProperties: false,
@@ -278,7 +308,7 @@ export const FRAMER_AGENT_TOOL_DEFINITIONS = [
   {
     name: 'framer_verify_interactions',
     description:
-      'Verify the observable behavior contract from the live Framer tree. The runtime derives the required action and invariants from the planned behavior and mechanism; supply canonical evidence node IDs. For native_effect, use hoverEffect, tapEffect, or appearEffect as the event value. This is the only tool that can satisfy interaction verification.',
+      'Verify the observable behavior contract from live Framer evidence. Results are verified, contradicted, or unknown. Unknown evidence never proves failure and must not trigger mutation. Native links and component-control navigation are verified from destinations, not onTap. You may add a grounded semanticAssessment; it cannot override a deterministic contradiction or authorize writes.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -310,6 +340,11 @@ export const FRAMER_AGENT_TOOL_DEFINITIONS = [
                 minLength: 1,
                 maxLength: 80,
               },
+              expectedDestination: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 500,
+              },
               targetNodeId: {
                 type: 'string',
                 minLength: 1,
@@ -350,12 +385,34 @@ export const FRAMER_AGENT_TOOL_DEFINITIONS = [
                 minLength: 1,
                 maxLength: 200,
               },
+              semanticAssessment: {
+                type: 'object',
+                properties: {
+                  verdict: {
+                    type: 'string',
+                    enum: ['verified', 'contradicted', 'unknown'],
+                  },
+                  rationale: {
+                    type: 'string',
+                    minLength: 10,
+                    maxLength: 1200,
+                  },
+                  evidenceNodeIds: {
+                    type: 'array',
+                    maxItems: 50,
+                    uniqueItems: true,
+                    items: {
+                      type: 'string',
+                      minLength: 1,
+                      maxLength: 200,
+                    },
+                  },
+                },
+                required: ['verdict', 'rationale', 'evidenceNodeIds'],
+                additionalProperties: false,
+              },
             },
-            required: [
-              'behaviorId',
-              'triggerNodeId',
-              'event',
-            ],
+            required: ['behaviorId'],
             additionalProperties: false,
           },
         },
@@ -1053,6 +1110,19 @@ export function createFramerAgentToolRuntime({
   const activePagePath = normalizePagePath(
     assignment?.context?.activePagePath,
   );
+  const semanticVerifierMode =
+    ['off', 'shadow', 'enforce'].includes(
+      String(
+        assignment?.context?.harnessAuthority?.semanticVerifierMode
+        || env.DEXTER_FRAMER_SEMANTIC_VERIFIER_MODE
+        || '',
+      ).trim(),
+    )
+      ? String(
+          assignment?.context?.harnessAuthority?.semanticVerifierMode
+          || env.DEXTER_FRAMER_SEMANTIC_VERIFIER_MODE,
+        ).trim()
+      : 'enforce';
   const authoritativeNodeIds =
     authoritativeNodeIdsFromAssignment(assignment);
   let sessionId = null;
@@ -1086,14 +1156,18 @@ export function createFramerAgentToolRuntime({
   let interactionVerificationCalls = 0;
   let interactionVerification = {
     completed: false,
-    verificationLevel: 'unverified',
+    verificationLevel: 'unknown',
     checks: [],
     behaviors: [],
+    budgetExhaustedBehaviorIds: [],
     verifiedAt: null,
   };
   const representativeVerifiedBehaviorIds = new Set();
+  const representativeMutatedBehaviorIds = new Set();
   const representativeRepairNodeIds = new Set();
-  const repeatedBehaviorVerificationFailures = new Map();
+  const representativeRepairBehaviorByNode = new Map();
+  const representativeEvidenceBehaviorByNode = new Map();
+  const behaviorVerificationAttempts = new Map();
   const mutationReceipts = [];
   let screenshotBeforeMutation = false;
   let lastScreenshotSequence = 0;
@@ -1588,9 +1662,11 @@ export function createFramerAgentToolRuntime({
             behaviors: taskPlan.behaviors.map((behavior) => ({
               ...behavior,
               expectedContent: [...behavior.expectedContent],
+              expectedDestinations: [...behavior.expectedDestinations],
             })),
             mechanisms: taskPlan.mechanisms.map((decision) => ({
               ...decision,
+              targetNodeIds: [...decision.targetNodeIds],
             })),
             rejectedMechanisms: taskPlan.rejectedMechanisms.map((entry) => ({
               ...entry,
@@ -1657,15 +1733,35 @@ export function createFramerAgentToolRuntime({
             verificationLevel:
               verificationCheckCompleted('interactions')
                 ? interactionVerification.verificationLevel
-                : 'unverified',
+                : 'unknown',
             checks: interactionVerification.checks.map((check) => ({
               ...check,
-              failures: [...check.failures],
+              contradictions: [...check.contradictions],
+              unknowns: [...check.unknowns],
+              observations: check.observations.map((observation) => ({
+                ...observation,
+              })),
+              nextSafeActions: [...check.nextSafeActions],
+              ...(check.semanticAssessment
+                ? {
+                    semanticAssessment: {
+                      ...check.semanticAssessment,
+                      evidenceNodeIds: [
+                        ...check.semanticAssessment.evidenceNodeIds,
+                      ],
+                    },
+                  }
+                : {}),
             })),
             behaviors: interactionVerification.behaviors.map((behavior) => ({
               ...behavior,
-              failures: [...behavior.failures],
+              contradictions: [...behavior.contradictions],
+              unknowns: [...behavior.unknowns],
             })),
+            semanticVerifierMode,
+            budgetExhaustedBehaviorIds: [
+              ...interactionVerification.budgetExhaustedBehaviorIds,
+            ],
             verifiedAt: interactionVerification.verifiedAt,
           },
         }
@@ -1720,12 +1816,27 @@ export function createFramerAgentToolRuntime({
       if (check === 'visual') return 'before-and-after screenshot verification';
       return `post-mutation ${check} verification`;
     });
-    const reason =
-      `The harness ended before completing ${missing.join(' and ')}.`;
+    const interactionDetails = interactionVerification.behaviors
+      .filter((behavior) => behavior.verdict !== 'verified')
+      .map((behavior) => {
+        const detail =
+          behavior.contradictions[0]
+          || behavior.unknowns[0]
+          || 'no conclusive live evidence';
+        return `${behavior.behaviorId}=${behavior.verdict} (${detail})`;
+      });
+    const reason = [
+      `The harness ended before completing ${missing.join(' and ')}.`,
+      ...(interactionDetails.length > 0
+        ? [`Interaction evidence: ${interactionDetails.join('; ')}.`]
+        : []),
+    ].join(' ');
     return {
       ...completion,
       status: 'failed',
-      summary: `${String(completion?.summary || '').trim()} ${reason}`.trim(),
+      summary:
+        String(completion?.summary || '').trim()
+        || 'The requested changes were applied.',
       checks: [
         ...(Array.isArray(completion?.checks) ? completion.checks : []),
         {
@@ -1756,9 +1867,17 @@ export function createFramerAgentToolRuntime({
             : 'report that the required baseline screenshot was missed; do not claim visual verification',
         );
       } else {
+        const interactionState = interactionVerification.behaviors
+          .map((behavior) =>
+            `${behavior.behaviorId}:${behavior.verdict}`)
+          .join(', ');
+        const exhausted =
+          interactionVerification.budgetExhaustedBehaviorIds.length > 0;
         missing.push(
           check === 'interactions'
-            ? 'call framer_verify_interactions with canonical evidence node IDs for every declared behavior and chosen mechanism'
+            ? exhausted
+              ? `report interaction verification as incomplete without further mutation or repeated verification (${interactionState || 'unknown'})`
+              : `call framer_verify_interactions with canonical evidence node IDs for every declared behavior and chosen mechanism; repair only contradicted evidence, while unknown evidence requires a different read or grounded semantic assessment (${interactionState || 'not yet checked'})`
             : `perform a focused read tagged with verifies:["${check}"] after the latest mutation`,
         );
       }
@@ -1767,7 +1886,7 @@ export function createFramerAgentToolRuntime({
       'Continue the same Framer task from its current project state.',
       'Do not redo successful work.',
       `Before returning, ${missing.join(' and ')}.`,
-      'Repair only concrete problems you observe, then return the required JSON outcome.',
+      'Never mutate merely because evidence is unknown. Repair one observed contradiction at most once, then return the required JSON outcome.',
     ].join(' ');
   };
 
@@ -1861,22 +1980,70 @@ export function createFramerAgentToolRuntime({
         `Choose a different mechanism for ${rejectedSelectedMechanisms.map((behavior) => behavior.id).join(', ')} before making another mutation.`,
       );
     }
-    if (mutationCalls > 0) {
-      const pendingRepresentative = taskPlan.behaviors
-        .filter((behavior) => behavior.expectedTargets > 1)
-        .filter((behavior) =>
-          taskPlan.mechanisms.find((decision) =>
-            decision.behaviorId === behavior.id
-            && decision.representativeFirst))
-        .filter((behavior) =>
-          !representativeVerifiedBehaviorIds.has(behavior.id));
-      if (pendingRepresentative.length > 0 && !isRepresentativeRepair) {
+    const changedNodeIds = new Set(
+      summarizeFramerChanges(changes).commands
+        .flatMap((command) => [
+          command.nodeId,
+          command.sourceNodeId,
+        ])
+        .filter(Boolean),
+    );
+    const rawChanges = String(changes || '');
+    const pendingRepresentative = taskPlan.behaviors
+      .filter((behavior) => behavior.expectedTargets > 1)
+      .map((behavior) => ({
+        behavior,
+        decision: taskPlan.mechanisms.find((decision) =>
+          decision.behaviorId === behavior.id),
+      }))
+      .filter(({ decision }) => decision?.representativeFirst)
+      .filter(({ behavior }) =>
+        !representativeVerifiedBehaviorIds.has(behavior.id));
+    for (const { behavior, decision } of pendingRepresentative) {
+      const touchedTargets = decision.targetNodeIds.filter((nodeId) =>
+        rawChanges.includes(nodeId));
+      const touchedEvidence = [...changedNodeIds].filter((nodeId) =>
+        representativeEvidenceBehaviorByNode.get(nodeId) === behavior.id);
+      if (
+        touchedTargets.length > 1
+        || (
+          touchedTargets.length === 1
+          && touchedTargets[0] !== decision.representativeTargetNodeId
+        )
+      ) {
+        throw toolError(
+          'FRAMER_BEHAVIOR_REPRESENTATIVE_MUTATION_REQUIRED',
+          `Implement only representative target ${decision.representativeTargetNodeId} for ${behavior.id} before changing the remaining targets.`,
+        );
+      }
+      if (touchedTargets.length === 0 && touchedEvidence.length === 0) {
+        continue;
+      }
+      if (!representativeMutatedBehaviorIds.has(behavior.id)) continue;
+      const attempt = behaviorVerificationAttempts.get(behavior.id);
+      const repairForBehavior =
+        isRepresentativeRepair
+        && repairTargets.every((nodeId) =>
+          representativeRepairBehaviorByNode.get(nodeId) === behavior.id);
+      if (
+        !repairForBehavior
+        || Number(attempt?.repairs || 0)
+          >= MAX_INTERACTION_REPAIRS_PER_BEHAVIOR
+      ) {
         throw toolError(
           'FRAMER_BEHAVIOR_REPRESENTATIVE_VERIFICATION_REQUIRED',
-          `Verify one representative implementation for ${pendingRepresentative.map((behavior) => behavior.id).join(', ')} before batching further mutations. A failed check may be repaired with SET changes limited to its evidence nodes.`,
+          `Verify representative target ${decision.representativeTargetNodeId} for ${behavior.id} before changing it again or batching the remaining targets.`,
         );
       }
+      behaviorVerificationAttempts.set(behavior.id, {
+        ...attempt,
+        repairs: Number(attempt?.repairs || 0) + 1,
+      });
     }
+    return pendingRepresentative
+      .filter(({ decision }) =>
+        rawChanges.includes(decision.representativeTargetNodeId))
+      .map(({ behavior }) => behavior.id);
   };
 
   async function invokeUnsafe(name, rawArguments = {}) {
@@ -2023,7 +2190,12 @@ export function createFramerAgentToolRuntime({
         const previousMechanisms = new Map(
           (taskPlan?.mechanisms || []).map((decision) => [
             decision.behaviorId,
-            decision.mechanism,
+            JSON.stringify({
+              mechanism: decision.mechanism,
+              targetNodeIds: decision.targetNodeIds,
+              representativeTargetNodeId:
+                decision.representativeTargetNodeId,
+            }),
           ]),
         );
         const behaviorPlan = mergeBehaviorPlans(taskPlan, nextPlan);
@@ -2041,8 +2213,16 @@ export function createFramerAgentToolRuntime({
         };
         for (const decision of taskPlan.mechanisms) {
           const prior = previousMechanisms.get(decision.behaviorId);
-          if (prior && prior !== decision.mechanism) {
+          const current = JSON.stringify({
+            mechanism: decision.mechanism,
+            targetNodeIds: decision.targetNodeIds,
+            representativeTargetNodeId:
+              decision.representativeTargetNodeId,
+          });
+          if (prior && prior !== current) {
             representativeVerifiedBehaviorIds.delete(decision.behaviorId);
+            representativeMutatedBehaviorIds.delete(decision.behaviorId);
+            behaviorVerificationAttempts.delete(decision.behaviorId);
           }
         }
         result = {
@@ -2088,21 +2268,43 @@ export function createFramerAgentToolRuntime({
           rawArguments.checks,
           taskPlan,
         );
+        const exhaustedBehaviorIds = uniqueStrings(
+          checks
+            .map((check) => check.behaviorId)
+            .filter((behaviorId) =>
+              behaviorVerificationAttempts.get(behaviorId)?.exhausted),
+        );
+        if (exhaustedBehaviorIds.length > 0) {
+          throw toolError(
+            'FRAMER_INTERACTION_VERIFICATION_BUDGET_EXHAUSTED',
+            `Interaction verification is exhausted for ${exhaustedBehaviorIds.join(', ')}. Stop retrying unchanged evidence and report the work as partially verified.`,
+          );
+        }
         const pagePath = normalizePagePath(rawArguments.pagePath);
         const requestedIds = evidenceNodeIds(checks);
+        const componentIds = uniqueStrings(
+          checks.map((check) => check.componentNodeId),
+        );
         const liveResult = await execCode(
           [
             `const requestedIds = ${JSON.stringify(requestedIds)};`,
-            'const nodes = await Promise.all(requestedIds.map(async (id) => ({',
-            '  id,',
-            '  node: await framer.agent.serialize({ id, depth: 8 },',
-            `    { pagePath: ${JSON.stringify(pagePath)} }).catch(() => null),`,
-            '  parentId: await framer.agent.getParentNode({ id },',
-            `    { pagePath: ${JSON.stringify(pagePath)} }).then((node) => node?.id ?? null).catch(() => null),`,
-            '  ancestorIds: await framer.agent.getAncestors({ id },',
-            `    { pagePath: ${JSON.stringify(pagePath)} }).then((nodes) => Array.isArray(nodes) ? nodes.map((node) => node?.id).filter(Boolean) : []).catch(() => []),`,
-            '})));',
-            'console.log(JSON.stringify({ nodes }, null, 2));',
+            `const componentIds = ${JSON.stringify(componentIds)};`,
+            'const [nodes, componentControls] = await Promise.all([',
+            '  Promise.all(requestedIds.map(async (id) => ({',
+            '    id,',
+            '    node: await framer.agent.serialize({ id, depth: 8 },',
+            `      { pagePath: ${JSON.stringify(pagePath)} }).catch(() => null),`,
+            '    parentId: await framer.agent.getParentNode({ id },',
+            `      { pagePath: ${JSON.stringify(pagePath)} }).then((node) => node?.id ?? null).catch(() => null),`,
+            '    ancestorIds: await framer.agent.getAncestors({ id },',
+            `      { pagePath: ${JSON.stringify(pagePath)} }).then((nodes) => Array.isArray(nodes) ? nodes.map((node) => node?.id).filter(Boolean) : []).catch(() => []),`,
+            '  }))),',
+            '  componentIds.length > 0',
+            '    ? framer.agent.readComponentControls({ componentIds },',
+            `        { pagePath: ${JSON.stringify(pagePath)} }).catch(() => null)`,
+            '    : null,',
+            ']);',
+            'console.log(JSON.stringify({ nodes, componentControls }, null, 2));',
           ].join('\n'),
         );
         const parsed = parseStructuredOutput(liveResult.stdout);
@@ -2127,52 +2329,115 @@ export function createFramerAgentToolRuntime({
           context: {
             lowLevelWriteCalls,
             authorizedInstanceContainerIds,
+            componentControls: parsed?.componentControls || null,
+            semanticVerifierMode,
           },
         });
         markInspection();
         interactionVerificationCalls += 1;
-        interactionVerification = {
-          ...verified,
-          verifiedAt: new Date().toISOString(),
-        };
         representativeRepairNodeIds.clear();
-        for (const check of verified.checks.filter((item) => !item.passed)) {
-          evidenceNodeIds([check]).forEach((nodeId) =>
-            representativeRepairNodeIds.add(nodeId));
-        }
+        representativeRepairBehaviorByNode.clear();
+        representativeEvidenceBehaviorByNode.clear();
+        const checkedBehaviorIds = new Set(
+          checks.map((check) => check.behaviorId),
+        );
         for (const behaviorResult of verified.behaviors) {
-          const failedChecks = verified.checks.filter((check) =>
-            check.behaviorId === behaviorResult.behaviorId && !check.passed);
-          if (failedChecks.length === 0) {
-            repeatedBehaviorVerificationFailures.delete(
-              behaviorResult.behaviorId,
-            );
+          if (!checkedBehaviorIds.has(behaviorResult.behaviorId)) continue;
+          const behaviorChecks = verified.checks.filter((check) =>
+            check.behaviorId === behaviorResult.behaviorId);
+          for (const check of behaviorChecks) {
+            evidenceNodeIds([check]).forEach((nodeId) =>
+              representativeEvidenceBehaviorByNode.set(
+                nodeId,
+                behaviorResult.behaviorId,
+              ));
+          }
+          const deterministicallyContradicted = behaviorChecks.some((check) =>
+            check.deterministicVerdict === 'contradicted');
+          const prior = behaviorVerificationAttempts.get(
+            behaviorResult.behaviorId,
+          ) || {
+            attempts: 0,
+            unchangedEvidenceCount: 0,
+            repairs: 0,
+            fingerprint: null,
+            exhausted: false,
+          };
+          if (behaviorResult.verdict === 'verified') {
+            behaviorVerificationAttempts.delete(behaviorResult.behaviorId);
+            Object.assign(behaviorResult, {
+              verificationAttempts: prior.attempts + 1,
+              verificationAttemptsRemaining: Math.max(
+                0,
+                MAX_INTERACTION_VERIFICATION_ATTEMPTS_PER_BEHAVIOR
+                  - prior.attempts
+                  - 1,
+              ),
+              repairAttempts: prior.repairs,
+              budgetExhausted: false,
+            });
             continue;
           }
-          const failureFingerprint = crypto
+          const evidenceFingerprint = crypto
             .createHash('sha256')
             .update(JSON.stringify({
               mechanism: behaviorResult.mechanism,
-              failures: failedChecks
-                .flatMap((check) => check.failures)
-                .sort(),
+              verdict: behaviorResult.verdict,
+              contradictions: [...behaviorResult.contradictions].sort(),
+              unknowns: [...behaviorResult.unknowns].sort(),
+              checks: behaviorChecks.map((check) => ({
+                verdict: check.verdict,
+                nodeIds: evidenceNodeIds([check]).sort(),
+                observations: check.observations,
+              })),
             }))
             .digest('hex');
-          const prior = repeatedBehaviorVerificationFailures.get(
-            behaviorResult.behaviorId,
-          );
-          const count =
-            prior?.fingerprint === failureFingerprint
-              ? prior.count + 1
+          const attempts = prior.attempts + 1;
+          const unchangedEvidenceCount =
+            prior.fingerprint === evidenceFingerprint
+              ? prior.unchangedEvidenceCount + 1
               : 1;
-          repeatedBehaviorVerificationFailures.set(
-            behaviorResult.behaviorId,
-            { fingerprint: failureFingerprint, count },
-          );
+          const exhausted =
+            attempts >= MAX_INTERACTION_VERIFICATION_ATTEMPTS_PER_BEHAVIOR
+            || unchangedEvidenceCount >= 2
+            || (
+              behaviorResult.verdict === 'contradicted'
+              && prior.repairs >= MAX_INTERACTION_REPAIRS_PER_BEHAVIOR
+            );
+          behaviorVerificationAttempts.set(behaviorResult.behaviorId, {
+            attempts,
+            unchangedEvidenceCount,
+            repairs: prior.repairs,
+            fingerprint: evidenceFingerprint,
+            exhausted,
+          });
+          Object.assign(behaviorResult, {
+            verificationAttempts: attempts,
+            verificationAttemptsRemaining: Math.max(
+              0,
+              MAX_INTERACTION_VERIFICATION_ATTEMPTS_PER_BEHAVIOR - attempts,
+            ),
+            repairAttempts: prior.repairs,
+            budgetExhausted: exhausted,
+          });
+          for (const check of behaviorChecks) {
+            check.repairAllowed =
+              check.deterministicVerdict === 'contradicted'
+              && prior.repairs < MAX_INTERACTION_REPAIRS_PER_BEHAVIOR
+              && !exhausted;
+            if (!check.repairAllowed) continue;
+            evidenceNodeIds([check]).forEach((nodeId) => {
+              representativeRepairNodeIds.add(nodeId);
+              representativeRepairBehaviorByNode.set(
+                nodeId,
+                behaviorResult.behaviorId,
+              );
+            });
+          }
           if (
-            count < 2
+            !deterministicallyContradicted
+            || !exhausted
             || !behaviorResult.mechanism
-            || behaviorResult.mechanism === 'native_effect'
           ) continue;
           const alreadyRejected = taskPlan.rejectedMechanisms.some((rejected) =>
             rejected.mechanism === behaviorResult.mechanism
@@ -2191,8 +2456,8 @@ export function createFramerAgentToolRuntime({
                 behaviorSignature: behaviorResult.behaviorSignature,
                 mechanism: behaviorResult.mechanism,
                 reason:
-                  `Repeated structural verification failed: ${failedChecks
-                    .flatMap((check) => check.failures)
+                  `Repeated live evidence contradicted this mechanism: ${behaviorChecks
+                    .flatMap((check) => check.contradictions)
                     .join('; ')
                     .slice(0, 700)}`,
                 source: 'verification_failure',
@@ -2200,6 +2465,15 @@ export function createFramerAgentToolRuntime({
             ],
           };
         }
+        const budgetExhaustedBehaviorIds = [...behaviorVerificationAttempts]
+          .filter(([, attempt]) => attempt.exhausted)
+          .map(([behaviorId]) => behaviorId);
+        interactionVerification = {
+          ...verified,
+          semanticVerifierMode,
+          budgetExhaustedBehaviorIds,
+          verifiedAt: new Date().toISOString(),
+        };
         verified.representativeBehaviorIds.forEach((behaviorId) =>
           representativeVerifiedBehaviorIds.add(behaviorId));
         if (interactionVerification.completed) {
@@ -2271,7 +2545,8 @@ export function createFramerAgentToolRuntime({
             'Framer Agent changes are required.',
           );
         }
-        requireTaskPlanForMutation({ canvas: true, changes });
+        const mutatedRepresentativeBehaviorIds =
+          requireTaskPlanForMutation({ canvas: true, changes });
         const pagePath = normalizePagePath(rawArguments.pagePath);
         result = await execCode(
           [
@@ -2282,6 +2557,8 @@ export function createFramerAgentToolRuntime({
         mutationCalls += 1;
         applyChangesCalls += 1;
         markMutation();
+        mutatedRepresentativeBehaviorIds.forEach((behaviorId) =>
+          representativeMutatedBehaviorIds.add(behaviorId));
         const parsedResult = parseStructuredOutput(result.stdout);
         mutationReceipts.push({
           sequence: operationSequence,
@@ -2541,6 +2818,10 @@ export function createFramerAgentToolRuntime({
         lowLevelWriteDisabled,
         lowLevelWriteBlockedCalls,
         instructionFallbacks,
+        interactionVerificationAttemptLimit:
+          MAX_INTERACTION_VERIFICATION_ATTEMPTS_PER_BEHAVIOR,
+        interactionRepairLimit:
+          MAX_INTERACTION_REPAIRS_PER_BEHAVIOR,
       },
       branch: branchChange,
       lastInspectionAt,