Add robust consent checks for Bluesky thread replies

tools/bluesky/create_bluesky_post.py

···
         raise
 
 
-def _verify_consent(client, agent_did: str, agent_handle: str, reply_to_uri: str):
+def _verify_consent(client, agent_did: str, agent_handle: str, reply_to_uri: str, target_did: str, root_did: str, parent_post_record=None):
     """
     Orchestrates the consent checks.
     Raises Exception with specific message if consent denied or verification fails.
     """
     try:
-        # 0. Get target DID from reply_to_uri
-        # We need to fetch the post we are replying to to get its author
-        # We can do this via get_post_thread or get_posts.
-        # Since we need thread later, maybe we just do that?
-        # But Follow Check is cheaper than Thread Check.
-        # So we should get the post details first (1 API call).
-        
-        # Parse DID from URI first to avoid API call if possible?
-        # URI format: at://did:plc:xyz/...
-        # The DID in the URI is the REPO owner, which is usually the author.
-        parts = reply_to_uri.replace('at://', '').split('/')
-        if len(parts) >= 1:
-            target_did = parts[0]
-        else:
-            # Should have been caught by validation, but just in case
-            raise Exception("Invalid URI format")
-
         # Check 1: Self-Post
         if _check_is_self(agent_did, target_did):
             return True
 
-        # Check 2: Follow Check
-        if _check_follows(client, agent_did, target_did):
+        # Check 2: Mention Check (Free/Cheap)
+        # If the post we are replying to mentions us, we can reply.
+        if parent_post_record:
+            # Check facets for mention
+            if hasattr(parent_post_record, 'facets') and parent_post_record.facets:
+                for facet in parent_post_record.facets:
+                    for feature in facet.features:
+                        if hasattr(feature, 'did') and feature.did == agent_did:
+                            return True
+            
+            # Fallback: Check text for handle
+            if hasattr(parent_post_record, 'text') and f"@{agent_handle}" in parent_post_record.text:
+                return True
+
+        # Check 3: Follow Check
+        # Rule: Target must follow agent.
+        # Rule 3B: If root author is different from target, Root must ALSO follow agent.
+        
+        target_follows = _check_follows(client, agent_did, target_did)
+        
+        if target_follows:
+            # If target follows, we must also check root if it's different
+            if root_did and root_did != target_did and root_did != agent_did:
+                root_follows = _check_follows(client, agent_did, root_did)
+                if not root_follows:
+                    # Target follows, but Root does not. Fail.
+                    raise Exception(
+                        "Message not sent: the author of the post follows you, but the thread starter (root author) "
+                        "does not. We respect the consent of the thread owner."
+                    )
             return True
 
-        # Check 3 & 4: Thread Participation / Mention
-        # This requires fetching the thread
+        # Check 4: Thread Participation
+        # This requires fetching the thread (Expensive)
         if _check_thread_participation(client, agent_did, agent_handle, reply_to_uri):
             return True
 
···
         client = Client()
         client.login(username, password)
         
-        # --- CONSENT GUARDRAILS ---
-        if reply_to_uri:
-            try:
-                agent_did = client.me.did
-                # agent_handle is username (without @ usually, but let's ensure)
-                agent_handle = username.replace('@', '')
-                
-                _verify_consent(client, agent_did, agent_handle, reply_to_uri)
-            except Exception as e:
-                return {
-                    "status": "error",
-                    "message": str(e)
-                }
-        # --------------------------
-
+        # --- FETCH PARENT/ROOT REFS ---
         initial_reply_ref = None
         initial_root_ref = None
+        target_did = None
+        root_did = None
+        parent_post_record = None
 
         if reply_to_uri:
             try:
···
                         "status": "error",
                         "message": f"Could not retrieve post data from URI: {reply_to_uri}. The post may not exist or the URI may be incorrect."
                     }
+                
+                # Extract target DID from parent post
+                target_did = repo_did
+                parent_post_record = parent_post.value
 
                 parent_ref = models.ComAtprotoRepoStrongRef.Main(
                     uri=parent_post.uri,
···
                     root=root_ref
                 )
                 initial_root_ref = root_ref
+                
+                # Extract root DID
+                root_uri_parts = root_ref.uri.replace('at://', '').split('/')
+                if len(root_uri_parts) >= 1:
+                    root_did = root_uri_parts[0]
 
             except Exception as e:
                 return {
                     "status": "error",
                     "message": f"Failed to fetch post to reply to: {str(e)}. Check the URI format and try again."
                 }
+
+        # --- CONSENT GUARDRAILS ---
+        if reply_to_uri:
+            try:
+                agent_did = client.me.did
+                # agent_handle is username (without @ usually, but let's ensure)
+                agent_handle = username.replace('@', '')
+                
+                _verify_consent(client, agent_did, agent_handle, reply_to_uri, target_did, root_did, parent_post_record)
+            except Exception as e:
+                return {
+                    "status": "error",
+                    "message": str(e)
+                }
+        # --------------------------
 
         post_urls = []
         previous_post_ref = None