@11agents/cli 0.1.26 → 0.1.27

package/mobile-runtime/python/src/device_control/publishers/xiaohongshu_adb.py

@@ -74,7 +74,7 @@ DEFAULT_FLOW_CONFIG = {
         "after_paste_probe": 1,
         "detail_load_timeout": 12,
         "publish_poll_interval": 2,
-        "publish_timeout": 45,
+        "publish_timeout": 180,
     },
     "success_focus_keywords": ["IndexActivityV2"],
     "detail_focus_keywords": ["NoteDetailActivity"],
@@ -116,6 +116,10 @@ class XiaohongshuAdbPublishResult:
     link_status: str = ""
     link_error: str = ""
     link_screenshot_path: str = ""
+    verification_status: str = ""
+    verification_error: str = ""
+    profile_screenshot_path: str = ""
+    detail_screenshot_path: str = ""
 
 
 @dataclass
@@ -131,6 +135,12 @@ class XiaohongshuLinkResult:
     error: str = ""
 
 
+class XiaohongshuAutomationError(RuntimeError):
+    def __init__(self, message: str, screenshot_path: str | Path = "") -> None:
+        super().__init__(message)
+        self.screenshot_path = str(screenshot_path)
+
+
 class XiaohongshuAdbPublisher:
     """Xiaohongshu image/video publisher for a configured device flow."""
 
@@ -281,23 +291,32 @@ class XiaohongshuAdbPublisher:
                 status = "dry_run"
             else:
                 self._tap_first_publish(device)
-                self.adb.screenshot(device.adb_serial, run_dir / "disclosure-prompt.png")
-                if not confirm_no_disclosure_needed:
+                prompt_state, prompt_shot = self._handle_after_first_publish_tap(
+                    device,
+                    run_dir,
+                    confirm_no_disclosure_needed=confirm_no_disclosure_needed,
+                )
+                if prompt_state == "blocked":
+                    self._close_xiaohongshu_best_effort(device)
                     return XiaohongshuAdbPublishResult(
                         device_id=device.device_id,
-                        status="needs_human",
+                        status="failed",
                         record_id=record_id,
                         started_at=started_at,
                         ended_at=_now_shanghai(),
                         duration_seconds=int(time.time()) - started_epoch,
                         post_type=post_type,
                         remote_media_path=remote,
-                        screenshot_path=str(run_dir / "disclosure-prompt.png"),
-                        error="content disclosure prompt needs explicit confirmation",
+                        screenshot_path=str(prompt_shot),
+                        error="content disclosure prompt was not auto-approved by policy",
                     )
-                self._tap_confirm_publish(device)
-                time.sleep(self._wait("after_confirm_publish"))
-                final_shot = self._wait_for_publish_complete(device, run_dir)
+                composed_caption = _compose_caption_for_record(caption, tag_values, topic_values)
+                final_shot = self._verify_published_note_and_open_detail(
+                    device,
+                    run_dir,
+                    expected_title=title,
+                    expected_caption=composed_caption,
+                )
                 status = "published"
                 if copy_link_after_publish:
                     link_result = self.copy_current_note_link(device, prepare=False, run_dir=run_dir / "link")
@@ -336,10 +355,35 @@ class XiaohongshuAdbPublisher:
                 link_status=link_result.status if link_result else "",
                 link_error=link_result.error if link_result else "",
                 link_screenshot_path=link_result.screenshot_path if link_result else "",
+                verification_status="verified" if status == "published" else "",
+                profile_screenshot_path=str(run_dir / "profile.png") if (run_dir / "profile.png").exists() else "",
+                detail_screenshot_path=str(final_shot) if status == "published" else "",
+            )
+        except XiaohongshuAutomationError as exc:
+            human_shot = Path(exc.screenshot_path) if exc.screenshot_path else run_dir / "verification-failed.png"
+            if not human_shot.exists():
+                self.adb.screenshot(device.adb_serial, human_shot)
+            self._close_xiaohongshu_best_effort(device)
+            return XiaohongshuAdbPublishResult(
+                device_id=device.device_id,
+                status="failed",
+                record_id=record_id,
+                started_at=started_at,
+                ended_at=_now_shanghai(),
+                duration_seconds=int(time.time()) - started_epoch,
+                post_type=post_type,
+                remote_media_path=remote,
+                screenshot_path=str(human_shot),
+                error=str(exc),
+                verification_status="failed",
+                verification_error=str(exc),
+                profile_screenshot_path=str(run_dir / "profile.png") if (run_dir / "profile.png").exists() else "",
+                detail_screenshot_path=str(run_dir / "published-note-detail.png") if (run_dir / "published-note-detail.png").exists() else "",
             )
         except Exception as exc:
             failure_shot = run_dir / "failed.png"
             self.adb.screenshot(device.adb_serial, failure_shot)
+            self._close_xiaohongshu_best_effort(device)
             return XiaohongshuAdbPublishResult(
                 device_id=device.device_id,
                 status="failed",
@@ -359,6 +403,9 @@ class XiaohongshuAdbPublisher:
         *,
         prepare: bool = True,
         run_dir: Path | None = None,
+        expected_title: str = "",
+        expected_caption: str = "",
+        close_after_recovery: bool = True,
     ) -> XiaohongshuLinkResult:
         started_epoch = int(time.time())
         started_at = _now_shanghai()
@@ -368,51 +415,82 @@ class XiaohongshuAdbPublisher:
         run_dir.mkdir(parents=True, exist_ok=True)
 
         try:
-            if prepare:
-                self._prepare_device(device)
-            else:
-                self._ok(self.adb.wake(device.adb_serial), "wake device")
-            focus = self.adb.current_focus(device.adb_serial)
-            if not any(keyword in focus for keyword in self._keywords("detail_focus_keywords")):
-                self._open_latest_own_note_for_link(device, run_dir)
-            self.adb.screenshot(device.adb_serial, run_dir / "before-copy-link.png")
-            self._tap_coord(device, "note_share", self._wait("after_share_tap"))
-            self.adb.screenshot(device.adb_serial, run_dir / "share-sheet.png")
-            self._tap_copy_link(device, run_dir)
-            time.sleep(self._wait("after_copy_link"))
-            final_shot = run_dir / "after-copy-link.png"
-            self.adb.screenshot(device.adb_serial, final_shot)
-
-            permalink, method, error = self._read_copied_link(device, run_dir)
-            if permalink:
-                status = "retrieved"
-            else:
-                status = "needs_human"
-                error = error or "copied link to device clipboard, but automatic clipboard read returned no URL"
-            return XiaohongshuLinkResult(
-                device_id=device.device_id,
-                status=status,
-                started_at=started_at,
-                ended_at=_now_shanghai(),
-                duration_seconds=int(time.time()) - started_epoch,
-                platform_permalink=permalink,
-                screenshot_path=str(final_shot),
-                clipboard_method=method,
-                error=error,
-            )
-        except Exception as exc:
-            failure_shot = run_dir / "failed-copy-link.png"
-            self.adb.screenshot(device.adb_serial, failure_shot)
-            return XiaohongshuLinkResult(
-                device_id=device.device_id,
-                status="failed",
-                started_at=started_at,
-                ended_at=_now_shanghai(),
-                duration_seconds=int(time.time()) - started_epoch,
-                platform_permalink="",
-                screenshot_path=str(failure_shot),
-                error=str(exc),
-            )
+            try:
+                if prepare:
+                    self._prepare_device(device)
+                else:
+                    self._ok(self.adb.wake(device.adb_serial), "wake device")
+                focus = self.adb.current_focus(device.adb_serial)
+                if any(keyword in focus for keyword in self._keywords("detail_focus_keywords")):
+                    if expected_title or expected_caption:
+                        try:
+                            self._verify_current_note_detail(
+                                device,
+                                run_dir,
+                                expected_title=expected_title,
+                                expected_caption=expected_caption,
+                                prefix="current-note-detail",
+                            )
+                        except XiaohongshuAutomationError:
+                            self._leave_detail_if_needed(device)
+                            self._open_latest_own_note_for_link(
+                                device,
+                                run_dir,
+                                expected_title=expected_title,
+                                expected_caption=expected_caption,
+                            )
+                else:
+                    self._open_latest_own_note_for_link(
+                        device,
+                        run_dir,
+                        expected_title=expected_title,
+                        expected_caption=expected_caption,
+                    )
+                self.adb.screenshot(device.adb_serial, run_dir / "before-copy-link.png")
+                self._tap_coord(device, "note_share", self._wait("after_share_tap"))
+                self.adb.screenshot(device.adb_serial, run_dir / "share-sheet.png")
+                self._tap_copy_link(device, run_dir)
+                time.sleep(self._wait("after_copy_link"))
+                final_shot = run_dir / "after-copy-link.png"
+                self.adb.screenshot(device.adb_serial, final_shot)
+
+                permalink, method, error = self._read_copied_link(device, run_dir)
+                if permalink:
+                    status = "retrieved"
+                else:
+                    status = "failed"
+                    error = error or "copied link to device clipboard, but automatic clipboard read returned no URL"
+                return XiaohongshuLinkResult(
+                    device_id=device.device_id,
+                    status=status,
+                    started_at=started_at,
+                    ended_at=_now_shanghai(),
+                    duration_seconds=int(time.time()) - started_epoch,
+                    platform_permalink=permalink,
+                    screenshot_path=str(final_shot),
+                    clipboard_method=method,
+                    error=error,
+                )
+            except Exception as exc:
+                failure_shot = run_dir / "failed-copy-link.png"
+                self.adb.screenshot(device.adb_serial, failure_shot)
+                return XiaohongshuLinkResult(
+                    device_id=device.device_id,
+                    status="failed",
+                    started_at=started_at,
+                    ended_at=_now_shanghai(),
+                    duration_seconds=int(time.time()) - started_epoch,
+                    platform_permalink="",
+                    screenshot_path=str(failure_shot),
+                    error=str(exc),
+                )
+        finally:
+            if close_after_recovery:
+                try:
+                    self._close_xiaohongshu(device)
+                    self.adb.screenshot(device.adb_serial, run_dir / "after-app-close.png")
+                except Exception:
+                    pass
 
     def _prepare_device(self, device: Device) -> None:
         self._ok(self.adb.wake(device.adb_serial), "wake device")
@@ -426,6 +504,15 @@ class XiaohongshuAdbPublisher:
         self._ok(self.adb.launch_package(device.adb_serial, self.package), "launch Xiaohongshu")
         time.sleep(self._wait("after_launch"))
 
+    def _close_xiaohongshu(self, device: Device) -> None:
+        self._ok(self.adb.force_stop(device.adb_serial, self.package), "close Xiaohongshu")
+
+    def _close_xiaohongshu_best_effort(self, device: Device) -> None:
+        try:
+            self._close_xiaohongshu(device)
+        except Exception:
+            pass
+
     def _open_album_flow(self, device: Device, run_dir: Path) -> None:
         self._tap_coord(device, "home_plus", self._wait("after_plus"))
         ui.tap_permission_prompt_if_present(self.adb, device, run_dir / "after-plus-permission.xml")
@@ -661,20 +748,64 @@ class XiaohongshuAdbPublisher:
         if not any(keyword in focus for keyword in self._keywords("post_form_focus_keywords")):
             raise RuntimeError(f"resume_post_form requires Xiaohongshu post form; current_focus={focus}")
 
-    def _open_latest_own_note_for_link(self, device: Device, run_dir: Path) -> None:
+    def _verify_published_note_and_open_detail(
+        self,
+        device: Device,
+        run_dir: Path,
+        *,
+        expected_title: str,
+        expected_caption: str,
+    ) -> Path:
+        self._wait_for_publish_exit_after_confirm(device, run_dir)
+        return self._open_latest_own_note_for_link(
+            device,
+            run_dir,
+            expected_title=expected_title,
+            expected_caption=expected_caption,
+            force_profile=True,
+        )
+
+    def _open_latest_own_note_for_link(
+        self,
+        device: Device,
+        run_dir: Path,
+        *,
+        expected_title: str = "",
+        expected_caption: str = "",
+        force_profile: bool = False,
+    ) -> Path:
         focus = self.adb.current_focus(device.adb_serial)
         if self.package not in focus:
             self._launch_xiaohongshu(device)
+        elif any(keyword in focus for keyword in self._keywords("in_progress_focus_keywords")):
+            self._close_xiaohongshu(device)
+            self._launch_xiaohongshu(device)
 
         self._dismiss_link_recovery_prompts(device, run_dir)
         focus = self.adb.current_focus(device.adb_serial)
         if any(keyword in focus for keyword in self._keywords("detail_focus_keywords")):
-            return
+            if force_profile:
+                self._leave_detail_if_needed(device)
+            else:
+                return self._verify_current_note_detail(
+                    device,
+                    run_dir,
+                    expected_title=expected_title,
+                    expected_caption=expected_caption,
+                    prefix="current-note-detail",
+                )
 
         self._open_me_tab(device, run_dir)
         self._dismiss_link_recovery_prompts(device, run_dir)
-        self._tap_latest_profile_note(device, run_dir)
+        self._tap_latest_profile_note(device, run_dir, expected_title=expected_title)
         self._wait_for_detail_screen(device, run_dir)
+        return self._verify_current_note_detail(
+            device,
+            run_dir,
+            expected_title=expected_title,
+            expected_caption=expected_caption,
+            prefix="published-note-detail",
+        )
 
     def _dismiss_link_recovery_prompts(self, device: Device, run_dir: Path) -> None:
         for idx in range(2):
@@ -691,7 +822,7 @@ class XiaohongshuAdbPublisher:
             if node is not None:
                 ui.tap_node(self.adb, device, node, sleep_s=self._wait("after_prompt_dismiss"))
                 continue
-            if any(marker in all_text for marker in ("发布成功", "完善个人资料", "上传头像", "填写名字")):
+            if any(marker in all_text for marker in ("完善个人资料", "上传头像", "填写名字")):
                 self._tap_coord_or_default(
                     device,
                     "post_publish_prompt_close",
@@ -713,15 +844,26 @@ class XiaohongshuAdbPublisher:
             self._tap_coord_or_default(device, "bottom_me", self._relative_coord(0.9, 0.93), self._wait("after_me_tab"))
         self.adb.screenshot(device.adb_serial, run_dir / "profile.png")
 
-    def _tap_latest_profile_note(self, device: Device, run_dir: Path) -> None:
-        for attempt in range(3):
+    def _tap_latest_profile_note(self, device: Device, run_dir: Path, *, expected_title: str = "") -> None:
+        attempts = 8 if expected_title else 3
+        for attempt in range(attempts):
             root = ui.dump_ui(self.adb, device, run_dir / f"profile-before-latest-note-{attempt + 1}.xml")
-            node = self._find_latest_profile_note_node(root)
+            node = self._find_latest_profile_note_node(root, expected_title=expected_title)
             if node is not None:
                 ui.tap_node(self.adb, device, node, sleep_s=self._wait("after_latest_note_tap"))
                 self.adb.screenshot(device.adb_serial, run_dir / "latest-note-opened.png")
                 return
-            time.sleep(1)
+            if expected_title and attempt < attempts - 1:
+                self._scroll_profile_notes_down_half_screen(device)
+                self.adb.screenshot(device.adb_serial, run_dir / f"profile-after-scroll-{attempt + 1}.png")
+            time.sleep(2 if expected_title else 1)
+        if expected_title:
+            not_found_shot = run_dir / "expected-profile-note-not-found.png"
+            self.adb.screenshot(device.adb_serial, not_found_shot)
+            raise XiaohongshuAutomationError(
+                f"expected Xiaohongshu profile note was not visible after publish: {expected_title!r}",
+                not_found_shot,
+            )
         self._tap_coord_or_default(
             device,
             "profile_latest_note",
@@ -744,6 +886,46 @@ class XiaohongshuAdbPublisher:
         self.adb.screenshot(device.adb_serial, run_dir / "latest-note-detail-timeout.png")
         raise RuntimeError(f"latest own Xiaohongshu note did not open; current_focus={last_focus}")
 
+    def _leave_detail_if_needed(self, device: Device) -> None:
+        focus = self.adb.current_focus(device.adb_serial)
+        if any(keyword in focus for keyword in self._keywords("detail_focus_keywords")):
+            self._ok(self.adb.keyevent(device.adb_serial, "KEYCODE_BACK"), "leave note detail")
+            time.sleep(self._wait("after_prompt_dismiss"))
+
+    def _verify_current_note_detail(
+        self,
+        device: Device,
+        run_dir: Path,
+        *,
+        expected_title: str,
+        expected_caption: str,
+        prefix: str,
+    ) -> Path:
+        detail_shot = run_dir / f"{prefix}.png"
+        detail_xml = run_dir / f"{prefix}.xml"
+        self.adb.screenshot(device.adb_serial, detail_shot)
+        if not expected_title and not expected_caption:
+            return detail_shot
+
+        try:
+            root = ui.dump_ui(self.adb, device, detail_xml)
+            visible_text = ui.all_text(root)
+        except Exception as exc:
+            mismatch_shot = run_dir / f"{prefix}-verification-failed.png"
+            self.adb.screenshot(device.adb_serial, mismatch_shot)
+            raise XiaohongshuAutomationError(
+                f"could not verify Xiaohongshu note detail text: {_short(str(exc))}",
+                mismatch_shot,
+            ) from exc
+
+        matched, reason = _note_text_matches_expected(visible_text, expected_title, expected_caption)
+        if matched:
+            return detail_shot
+
+        mismatch_shot = run_dir / f"{prefix}-mismatch.png"
+        self.adb.screenshot(device.adb_serial, mismatch_shot)
+        raise XiaohongshuAutomationError(f"latest Xiaohongshu note did not match expected content: {reason}", mismatch_shot)
+
     def _find_bottom_tab(self, root, labels: set[str]):
         _width, height = self._screen_size()
         min_top = int(height * 0.72)
@@ -758,10 +940,11 @@ class XiaohongshuAdbPublisher:
                 return node
         return None
 
-    def _find_latest_profile_note_node(self, root):
-        width, height = self._screen_size()
+    def _find_latest_profile_note_node(self, root, *, expected_title: str = ""):
+        width, height = self._ui_root_size(root)
         min_top = self._profile_note_min_top(root, height)
-        bottom_guard = int(height * 0.08)
+        bottom_guard = 0 if expected_title else int(height * 0.08)
+        expected = _normalize_match_text(expected_title)
         candidates = []
         image_candidates = []
         blocked_text = {"首页", "购物", "发布", "消息", "我", "关注", "编辑资料", "设置"}
@@ -781,10 +964,15 @@ class XiaohongshuAdbPublisher:
             desc = node.attrib.get("content-desc", "")
             if text in blocked_text or desc in blocked_text:
                 continue
+            note_text = f"{text}\n{desc}"
+            if expected:
+                if not _looks_like_profile_note_card(node) or expected not in _normalize_match_text(note_text):
+                    continue
+                return node
             item = (top, left, node)
-            if node.attrib.get("clickable") == "true":
+            if _looks_like_profile_note_card(node):
                 candidates.append(item)
-            elif node.attrib.get("class") == "android.widget.ImageView":
+            elif not expected and node.attrib.get("class") == "android.widget.ImageView":
                 image_candidates.append(item)
 
         chosen = candidates or image_candidates
@@ -792,6 +980,30 @@ class XiaohongshuAdbPublisher:
             return None
         return sorted(chosen, key=lambda item: (item[0], item[1]))[0][2]
 
+    def _scroll_profile_notes_down_half_screen(self, device: Device) -> None:
+        width, height = self._screen_size()
+        x = width // 2
+        start_y = int(height * 0.82)
+        end_y = int(height * 0.50)
+        self._ok(self.adb.swipe(device.adb_serial, x, start_y, x, end_y, 350), "scroll profile notes down")
+
+    def _ui_root_size(self, root) -> tuple[int, int]:
+        width, height = self._screen_size()
+        max_right = 0
+        max_bottom = 0
+        for node in root.iter("node"):
+            bounds = ui.bounds(node)
+            if not bounds:
+                continue
+            _left, _top, right, bottom = bounds
+            max_right = max(max_right, right)
+            max_bottom = max(max_bottom, bottom)
+        if max_right > 0:
+            width = max_right
+        if max_bottom > 0:
+            height = max_bottom
+        return width, height
+
     def _profile_note_min_top(self, root, height: int) -> int:
         min_top = int(height * 0.35)
         for node in root.iter("node"):
@@ -810,6 +1022,42 @@ class XiaohongshuAdbPublisher:
     def _tap_confirm_publish(self, device: Device) -> None:
         self._tap_coord(device, "confirm_publish", 0)
 
+    def _handle_after_first_publish_tap(
+        self,
+        device: Device,
+        run_dir: Path,
+        *,
+        confirm_no_disclosure_needed: bool,
+    ) -> tuple[str, Path]:
+        xml_path = run_dir / "after-first-publish.xml"
+        shot_path = run_dir / "after-first-publish.png"
+        root = None
+        visible_text = ""
+        try:
+            root = ui.dump_ui(self.adb, device, xml_path)
+            visible_text = ui.all_text(root)
+        finally:
+            self.adb.screenshot(device.adb_serial, shot_path)
+
+        status, reason = _publish_progress_status(visible_text)
+        if status == "failed":
+            raise XiaohongshuAutomationError(f"Xiaohongshu publish failed after first publish tap: {reason}", shot_path)
+        if status in {"uploading", "success"}:
+            return status, shot_path
+        if root is None or not _publish_disclosure_prompt_visible(root, visible_text):
+            return "waiting", shot_path
+        if not confirm_no_disclosure_needed:
+            return "blocked", shot_path
+
+        confirm_node = _find_publish_disclosure_confirm_node(root)
+        if confirm_node is not None:
+            ui.tap_node(self.adb, device, confirm_node, sleep_s=0)
+        else:
+            self._tap_confirm_publish(device)
+        time.sleep(self._wait("after_confirm_publish"))
+        self.adb.screenshot(device.adb_serial, run_dir / "after-disclosure-confirm.png")
+        return "confirmed", shot_path
+
     def _tap_copy_link(self, device: Device, run_dir: Path) -> None:
         xml_path = run_dir / "share-sheet.xml"
         try:
@@ -927,6 +1175,81 @@ class XiaohongshuAdbPublisher:
                 return candidate
         return None
 
+    def _wait_for_publish_exit_after_confirm(self, device: Device, run_dir: Path) -> None:
+        interval = max(0.5, self._wait("publish_poll_interval"))
+        deadline = time.time() + max(self._wait("publish_timeout"), 180.0)
+        last_focus = ""
+        last_text = ""
+        saw_upload_progress = False
+        clear_progress_polls = 0
+        stable_home_polls = 0
+        attempt = 0
+
+        while time.time() < deadline:
+            attempt += 1
+            focus = self.adb.current_focus(device.adb_serial)
+            if focus:
+                last_focus = focus
+
+            status = "unknown"
+            reason = ""
+            try:
+                root = ui.dump_ui(self.adb, device, run_dir / f"publish-progress-{attempt}.xml")
+                visible_text = ui.all_text(root)
+                last_text = _short(visible_text, 500)
+                status, reason = _publish_progress_status(visible_text)
+            except Exception as exc:
+                last_text = f"ui dump failed: {_short(str(exc))}"
+
+            if status == "failed":
+                failed_shot = run_dir / "publish-failed.png"
+                self.adb.screenshot(device.adb_serial, failed_shot)
+                raise XiaohongshuAutomationError(f"Xiaohongshu publish failed after publish tap: {reason}", failed_shot)
+            if status == "success":
+                success_shot = run_dir / "publish-success.png"
+                self.adb.screenshot(device.adb_serial, success_shot)
+                return
+            if status == "uploading":
+                saw_upload_progress = True
+                clear_progress_polls = 0
+                stable_home_polls = 0
+                if attempt == 1 or attempt % 5 == 0:
+                    self.adb.screenshot(device.adb_serial, run_dir / f"publish-uploading-{attempt}.png")
+                time.sleep(interval)
+                continue
+            if saw_upload_progress:
+                clear_progress_polls += 1
+                if clear_progress_polls >= 3:
+                    complete_shot = run_dir / "publish-progress-complete.png"
+                    self.adb.screenshot(device.adb_serial, complete_shot)
+                    return
+            elif self._is_publish_home_focus(focus):
+                stable_home_polls += 1
+                if stable_home_polls >= 3:
+                    complete_shot = run_dir / "publish-home-stable.png"
+                    self.adb.screenshot(device.adb_serial, complete_shot)
+                    return
+            else:
+                stable_home_polls = 0
+            time.sleep(interval)
+
+        timeout_shot = run_dir / "after-publish-still-in-progress.png"
+        self.adb.screenshot(device.adb_serial, timeout_shot)
+        raise XiaohongshuAutomationError(
+            "Xiaohongshu publish result was not confirmed before verification; "
+            f"current_focus={last_focus}; last_text={last_text}",
+            timeout_shot,
+        )
+
+    def _is_publish_home_focus(self, focus: str) -> bool:
+        if self.package not in focus:
+            return False
+        if any(keyword in focus for keyword in self._keywords("detail_focus_keywords")):
+            return False
+        if any(keyword in focus for keyword in self._keywords("in_progress_focus_keywords")):
+            return False
+        return any(keyword in focus for keyword in self._keywords("success_focus_keywords"))
+
     def _wait_for_publish_complete(self, device: Device, run_dir: Path) -> Path:
         timeout = self._wait("publish_timeout")
         interval = max(0.5, self._wait("publish_poll_interval"))
@@ -1134,6 +1457,127 @@ def _extract_url(text: str) -> str:
     return urls[0].rstrip(").,;，。]") if urls else ""
 
 
+def _note_text_matches_expected(visible_text: str, expected_title: str, expected_caption: str) -> tuple[bool, str]:
+    haystack = _normalize_match_text(visible_text)
+    title = _normalize_match_text(expected_title)
+    caption_fragment = _verification_fragment(expected_caption)
+
+    if title and title not in haystack:
+        return False, f"title not visible: {expected_title!r}"
+    if caption_fragment and caption_fragment not in haystack:
+        return False, f"caption fragment not visible: {caption_fragment!r}"
+    if not title and not caption_fragment:
+        return True, ""
+    return True, ""
+
+
+def _looks_like_profile_note_card(node) -> bool:
+    text = node.attrib.get("text", "")
+    desc = node.attrib.get("content-desc", "")
+    resource_id = node.attrib.get("resource-id", "")
+    haystack = f"{text}\n{desc}"
+    if "笔记," in desc and "来自" in desc:
+        return True
+    if "笔记" in haystack and "来自" in haystack and ("赞" in haystack or "阅读" in haystack):
+        return True
+    return resource_id.endswith(":id/card_view") and bool(desc.strip()) and "笔记" in desc
+
+
+def _publish_disclosure_prompt_visible(root, visible_text: str) -> bool:
+    text = visible_text or ui.all_text(root)
+    if _publish_progress_status(text)[0] in {"uploading", "success", "failed"}:
+        return False
+    prompt_markers = (
+        "发布声明",
+        "内容声明",
+        "声明",
+        "商业推广",
+        "品牌合作",
+        "利益相关",
+        "推广合作",
+        "是否涉及",
+        "不涉及",
+        "无需声明",
+    )
+    if not any(marker in text for marker in prompt_markers):
+        return False
+    return _find_publish_disclosure_confirm_node(root) is not None
+
+
+def _find_publish_disclosure_confirm_node(root):
+    confirm_texts = {
+        "确认发布",
+        "确认",
+        "确定",
+        "继续发布",
+        "仍要发布",
+        "发布",
+    }
+    deny_markers = ("取消", "返回", "暂不", "稍后", "不同意", "放弃")
+    candidates = []
+    for node in root.iter("node"):
+        if not ui.is_visible(node):
+            continue
+        text = node.attrib.get("text", "")
+        desc = node.attrib.get("content-desc", "")
+        label = f"{text}\n{desc}".strip()
+        if not label or any(marker in label for marker in deny_markers):
+            continue
+        if text not in confirm_texts and desc not in confirm_texts:
+            continue
+        value = ui.bounds(node)
+        if not value:
+            continue
+        _left, top, _right, bottom = value
+        score = 100 if node.attrib.get("clickable") == "true" else 0
+        if bottom > 1600:
+            score += 50
+        candidates.append((score, top, node))
+    if not candidates:
+        return None
+    return sorted(candidates, key=lambda item: (item[0], item[1]), reverse=True)[0][2]
+
+
+def _publish_progress_status(visible_text: str) -> tuple[str, str]:
+    text = visible_text or ""
+    normalized = _normalize_match_text(text)
+    if any(marker in text for marker in ("发布失败", "上传失败", "发送失败")):
+        return "failed", _short(text)
+    if "重试" in text and any(marker in text for marker in ("上传", "发布", "笔记")):
+        return "failed", _short(text)
+    if "发布成功" in text or "发布成功" in normalized:
+        return "success", "publish success marker visible"
+    upload_markers = (
+        "上传中",
+        "请勿离开小红书",
+        "capa_progress_text",
+        "capa_desc_text",
+        "capa_progress_bar",
+    )
+    if any(marker in text for marker in upload_markers):
+        return "uploading", "upload progress marker visible"
+    if re.search(r"\b\d{1,3}%\b", text) and any(marker in text for marker in ("上传", "capa_", "progress")):
+        return "uploading", "upload percent visible"
+    return "unknown", ""
+
+
+def _verification_fragment(text: str) -> str:
+    normalized = _normalize_match_text(_strip_hashtags(text))
+    if not normalized:
+        normalized = _normalize_match_text(text)
+    if len(normalized) <= 18:
+        return normalized
+    return normalized[:18]
+
+
+def _strip_hashtags(text: str) -> str:
+    return re.sub(r"#[^\s#]+", "", text or "").strip()
+
+
+def _normalize_match_text(text: str) -> str:
+    return re.sub(r"\s+", "", text or "").strip().lower()
+
+
 def _short(text: str, limit: int = 220) -> str:
     one_line = " ".join((text or "").split())
     return one_line if len(one_line) <= limit else one_line[: limit - 3] + "..."