@11agents/cli 0.1.41 → 0.1.43

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

@@ -59,6 +59,21 @@ class XAdbPublishResult:
     screenshot_path: str
     remote_media_path: str = ""
     link_url: str = ""
+    platform_permalink: str = ""
+    link_status: str = ""
+    link_error: str = ""
+    link_screenshot_path: str = ""
+    clipboard_method: str = ""
+    error: str = ""
+
+
+@dataclass
+class XAdbLinkResult:
+    device_id: str
+    status: str
+    platform_permalink: str
+    screenshot_path: str
+    clipboard_method: str = ""
     error: str = ""
 
 
@@ -118,6 +133,7 @@ class XAdbPublisher:
         remote = ""
         if local is not None:
             remote = f"/sdcard/DCIM/Camera/groupctl-{device.device_id}-x-{stamp}{local.suffix}"
+        link_result: XAdbLinkResult | None = None
 
         try:
             self._prepare_device(device)
@@ -136,6 +152,10 @@ class XAdbPublisher:
             else:
                 self._tap_post(device, run_dir)
                 final_shot = self._wait_for_publish_complete(device, run_dir, publish_text, verify_profile=verify_profile)
+                link_result = self._copy_published_post_link(device, run_dir / "link", publish_text)
+                if link_result.status != "retrieved" or not link_result.platform_permalink:
+                    raise AutomationBlockedError(f"X post-publish link recovery failed: {link_result.error or link_result.status}")
+                final_shot = Path(link_result.screenshot_path)
                 status = "published"
                 append_publish_record(
                     self.records_path,
@@ -148,12 +168,13 @@ class XAdbPublisher:
                         local_media_path=str(local) if local else "",
                         remote_media_path=remote,
                         caption=publish_text,
-                        platform_permalink="",
+                        platform_permalink=link_result.platform_permalink,
                         published_at=utc_now_iso(),
                         result_screenshot_path=str(final_shot),
                         status="published",
                     ),
                 )
+                self._close_x_best_effort(device, run_dir)
 
             return XAdbPublishResult(
                 device_id=device.device_id,
@@ -167,9 +188,14 @@ class XAdbPublisher:
                 remote_media_path=remote,
                 link_url=link_url,
                 screenshot_path=str(final_shot),
+                platform_permalink=link_result.platform_permalink if link_result else "",
+                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 "",
+                clipboard_method=link_result.clipboard_method if link_result else "",
             )
         except AutomationBlockedError as exc:
-            return self._failure_result(
+            result = self._failure_result(
                 device,
                 run_dir,
                 record_id,
@@ -181,9 +207,12 @@ class XAdbPublisher:
                 link_url=link_url,
                 status="failed",
                 error=str(exc),
+                link_result=link_result,
             )
+            self._close_x_best_effort(device, run_dir)
+            return result
         except Exception as exc:
-            return self._failure_result(
+            result = self._failure_result(
                 device,
                 run_dir,
                 record_id,
@@ -195,7 +224,10 @@ class XAdbPublisher:
                 link_url=link_url,
                 status="failed",
                 error=str(exc),
+                link_result=link_result,
             )
+            self._close_x_best_effort(device, run_dir)
+            return result
 
     def _failure_result(
         self,
@@ -211,9 +243,11 @@ class XAdbPublisher:
         link_url: str = "",
         status: str,
         error: str,
+        link_result: XAdbLinkResult | None = None,
     ) -> XAdbPublishResult:
-        failure_shot = run_dir / f"{status}.png"
-        self.adb.screenshot(device.adb_serial, failure_shot)
+        failure_shot = Path(link_result.screenshot_path) if link_result and link_result.screenshot_path else run_dir / f"{status}.png"
+        if not failure_shot.exists():
+            self.adb.screenshot(device.adb_serial, failure_shot)
         return XAdbPublishResult(
             device_id=device.device_id,
             status=status,
@@ -226,6 +260,11 @@ class XAdbPublisher:
             remote_media_path=remote_media_path,
             link_url=link_url,
             screenshot_path=str(failure_shot),
+            platform_permalink=link_result.platform_permalink if link_result else "",
+            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 "",
+            clipboard_method=link_result.clipboard_method if link_result else "",
             error=error,
         )
 
@@ -247,6 +286,18 @@ class XAdbPublisher:
             raise AutomationBlockedError("X is not foreground after launch; check install/login/verification state")
         self._raise_if_blocked(device, run_dir / "home.xml")
 
+    def _close_x(self, device: Device) -> None:
+        self._ok(self.adb.force_stop(device.adb_serial, X_PACKAGE), "close X")
+
+    def _close_x_best_effort(self, device: Device, run_dir: Path | None = None) -> None:
+        try:
+            self._close_x(device)
+            if run_dir is not None:
+                time.sleep(1)
+                self.adb.screenshot(device.adb_serial, run_dir / "after-app-close.png")
+        except Exception:
+            pass
+
     def _open_compose(self, device: Device, run_dir: Path) -> None:
         if self._is_compose_open(device, run_dir / "compose-check-initial.xml"):
             return
@@ -461,6 +512,209 @@ class XAdbPublisher:
         self.adb.screenshot(device.adb_serial, run_dir / "profile-post-missing.png")
         raise AutomationBlockedError("X publish completed, but the expected post text was not found on the profile page")
 
+    def _copy_published_post_link(self, device: Device, run_dir: Path, publish_text: str) -> XAdbLinkResult:
+        run_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            self._open_published_post_detail(device, run_dir, publish_text)
+            self._tap_share_from_detail(device, run_dir)
+            self._tap_copy_link(device, run_dir)
+            time.sleep(1.5)
+            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:
+                return XAdbLinkResult(
+                    device_id=device.device_id,
+                    status="retrieved",
+                    platform_permalink=permalink,
+                    screenshot_path=str(final_shot),
+                    clipboard_method=method,
+                )
+            return XAdbLinkResult(
+                device_id=device.device_id,
+                status="failed",
+                platform_permalink="",
+                screenshot_path=str(final_shot),
+                error=error or "copied link to device clipboard, but automatic clipboard read returned no URL",
+            )
+        except Exception as exc:
+            failure_shot = run_dir / "failed-copy-link.png"
+            self.adb.screenshot(device.adb_serial, failure_shot)
+            return XAdbLinkResult(
+                device_id=device.device_id,
+                status="failed",
+                platform_permalink="",
+                screenshot_path=str(failure_shot),
+                error=str(exc),
+            )
+
+    def _open_published_post_detail(self, device: Device, run_dir: Path, publish_text: str) -> Path:
+        if not self._is_profile_open(device):
+            self._open_profile(device, run_dir)
+        for attempt in range(6):
+            root = ui.dump_ui(self.adb, device, run_dir / f"profile-before-detail-{attempt + 1}.xml")
+            row = _find_post_row(root, publish_text)
+            if row is not None:
+                target = _find_post_text_node(row, publish_text) or row
+                self._tap_post_detail_target(device, target)
+                time.sleep(3)
+                detail_root = ui.dump_ui(self.adb, device, run_dir / f"detail-after-tap-{attempt + 1}.xml")
+                if self._is_post_detail_open(device, detail_root, publish_text):
+                    detail_shot = run_dir / "post-detail.png"
+                    self.adb.screenshot(device.adb_serial, detail_shot)
+                    return detail_shot
+                if not self._is_profile_open(device):
+                    self.adb.keyevent(device.adb_serial, "KEYCODE_BACK")
+                    time.sleep(1)
+            self.adb.swipe(device.adb_serial, 540, 1800, 540, 760, 350)
+            time.sleep(2)
+
+        self.adb.screenshot(device.adb_serial, run_dir / "post-detail-open-failed.png")
+        raise AutomationBlockedError("X published post could not be opened from the profile page")
+
+    def _tap_post_detail_target(self, device: Device, node) -> None:
+        bounds = ui.bounds(node)
+        if not bounds:
+            raise AutomationBlockedError("X published post row has no tappable bounds")
+        left, top, right, bottom = bounds
+        x = min(max((left + right) // 2, 220), 940)
+        y = min(max((top + bottom) // 2, 320), 1840)
+        self._ok(self.adb.tap(device.adb_serial, x, y), "tap X published post")
+
+    def _is_post_detail_open(self, device: Device, root, publish_text: str) -> bool:
+        focus = self.adb.current_focus(device.adb_serial)
+        if X_PACKAGE not in focus or X_COMPOSER_ACTIVITY in focus:
+            return False
+        if not _profile_has_post(root, publish_text):
+            return False
+        if X_PROFILE_ACTIVITY not in focus:
+            return True
+        return ui.find_node(
+            root,
+            ids={f"{X_PACKAGE}:id/tweet_detail_view"},
+            id_suffixes={"tweet_detail_view", "tweet_detail_container", "tweet_detail"},
+            visible_only=False,
+        ) is not None
+
+    def _tap_share_from_detail(self, device: Device, run_dir: Path) -> None:
+        for attempt in range(5):
+            root = ui.dump_ui(self.adb, device, run_dir / f"detail-before-share-{attempt + 1}.xml")
+            node = ui.find_node(
+                root,
+                ids={f"{X_PACKAGE}:id/inline_twitter_share"},
+                id_suffixes={"inline_twitter_share", "tweet_share_button", "share_button"},
+                descs={"分享", "Share"},
+                partial_texts={"分享", "share"},
+                clickable_only=False,
+            )
+            if node is not None:
+                ui.tap_node(self.adb, device, node, sleep_s=2)
+                self.adb.screenshot(device.adb_serial, run_dir / "share-sheet.png")
+                return
+            self.adb.swipe(device.adb_serial, 540, 1700, 540, 950, 300)
+            time.sleep(1)
+        self.adb.screenshot(device.adb_serial, run_dir / "share-icon-missing.png")
+        raise AutomationBlockedError("X share icon was not found on the post detail page")
+
+    def _tap_copy_link(self, device: Device, run_dir: Path) -> None:
+        for attempt in range(5):
+            root = ui.dump_ui(self.adb, device, run_dir / f"share-sheet-{attempt + 1}.xml")
+            if attempt == 0:
+                self.adb.screenshot(device.adb_serial, run_dir / "share-sheet.png")
+            node = ui.find_node(
+                root,
+                texts={"复制链接", "复制帖子链接", "复制推文链接", "Copy link", "Copy link to post", "Copy link to Tweet"},
+                descs={"复制链接", "复制帖子链接", "复制推文链接", "Copy link", "Copy link to post", "Copy link to Tweet"},
+                partial_texts={"复制链接", "复制帖子链接", "复制推文链接", "copy link"},
+                clickable_only=False,
+            )
+            if node is not None:
+                ui.tap_node(self.adb, device, node, sleep_s=1)
+                return
+            time.sleep(1)
+        self.adb.screenshot(device.adb_serial, run_dir / "copy-link-missing.png")
+        raise AutomationBlockedError("X copy link action was not found in the share sheet")
+
+    def _read_copied_link(self, device: Device, run_dir: Path) -> tuple[str, str, str]:
+        errors: list[str] = []
+
+        result = self.adb.shell(device.adb_serial, "cmd", "clipboard", "get")
+        if result.ok:
+            link = _extract_x_url(result.stdout)
+            if link:
+                return link, "adb_cmd_clipboard", ""
+            errors.append("adb_cmd_clipboard returned no URL")
+        else:
+            errors.append(f"adb_cmd_clipboard failed: {_short(result.stderr or result.stdout)}")
+
+        result = self.adb.shell(device.adb_serial, "dumpsys", "clipboard")
+        if result.ok:
+            link = _extract_x_url(result.stdout)
+            if link:
+                return link, "adb_dumpsys_clipboard", ""
+            errors.append("adb_dumpsys_clipboard returned no URL")
+        else:
+            errors.append(f"adb_dumpsys_clipboard failed: {_short(result.stderr or result.stdout)}")
+
+        link = self._read_link_by_paste_probe(device, run_dir)
+        if link:
+            return link, "paste_probe_ui_dump", ""
+        errors.append("paste_probe_ui_dump returned no URL")
+
+        appium = AppiumClient(self.appium_server)
+        try:
+            appium.start_session(_capabilities(device.adb_serial))
+            text = appium.get_clipboard()
+            link = _extract_x_url(text)
+            if link:
+                return link, "appium_get_clipboard", ""
+            errors.append("appium_get_clipboard returned no URL")
+        except Exception as exc:
+            errors.append(f"appium_get_clipboard failed: {_short(str(exc))}")
+        finally:
+            try:
+                appium.delete_session()
+            except Exception:
+                pass
+
+        return "", "", "; ".join(errors)
+
+    def _read_link_by_paste_probe(self, device: Device, run_dir: Path) -> str:
+        opened_input = False
+        try:
+            root = ui.dump_ui(self.adb, device, run_dir / "before-paste-probe.xml")
+            node = ui.find_node(
+                root,
+                ids={f"{X_PACKAGE}:id/tweet_text"},
+                id_suffixes={"tweet_text"},
+                partial_texts={"发布你的回复", "Post your reply", "Tweet your reply"},
+                clickable_only=False,
+            )
+            if node is None:
+                node = ui.find_node(
+                    root,
+                    ids={f"{X_PACKAGE}:id/persistent_reply"},
+                    id_suffixes={"persistent_reply"},
+                    partial_texts={"发布你的回复", "Post your reply", "reply"},
+                    clickable_only=True,
+                )
+            if node is None:
+                self.adb.screenshot(device.adb_serial, run_dir / "paste-probe-input-missing.png")
+                return ""
+            ui.tap_node(self.adb, device, node, sleep_s=1)
+            opened_input = True
+            self.adb.keyevent(device.adb_serial, "KEYCODE_PASTE")
+            time.sleep(1)
+            root = ui.dump_ui(self.adb, device, run_dir / "paste-probe.xml")
+            self.adb.screenshot(device.adb_serial, run_dir / "paste-probe.png")
+            return _extract_x_url(ui.all_text(root))
+        except Exception:
+            return ""
+        finally:
+            if opened_input:
+                self.adb.keyevent(device.adb_serial, "KEYCODE_BACK")
+                time.sleep(0.3)
+
     def _open_profile(self, device: Device, run_dir: Path) -> None:
         if self._is_profile_open(device):
             return
@@ -576,10 +830,70 @@ def _profile_has_post(root, expected_text: str) -> bool:
     return False
 
 
+def _find_post_row(root, expected_text: str) -> object | None:
+    expected = _normalize_for_match(expected_text)
+    if not expected:
+        return None
+    candidates = []
+    for node in root.iter("node"):
+        resource_id = node.attrib.get("resource-id", "")
+        if not (resource_id == f"{X_PACKAGE}:id/row" or resource_id.endswith(":id/row")):
+            continue
+        if not ui.is_visible(node):
+            continue
+        text = _normalize_for_match(_node_text(node))
+        if expected in text or (len(expected) >= 80 and expected[:60] in text):
+            candidates.append(node)
+    return ui.sorted_visible_nodes(candidates)[0] if candidates else None
+
+
+def _find_post_text_node(row, expected_text: str) -> object | None:
+    expected = _normalize_for_match(expected_text)
+    candidates = []
+    for node in row.iter("node"):
+        resource_id = node.attrib.get("resource-id", "")
+        if not (resource_id.endswith(":id/tweet_content_text") or node.attrib.get("text", "")):
+            continue
+        if not ui.is_visible(node):
+            continue
+        text = _normalize_for_match(_node_text(node))
+        if expected in text or (len(expected) >= 80 and expected[:60] in text):
+            candidates.append(node)
+    return ui.sorted_visible_nodes(candidates)[0] if candidates else None
+
+
+def _node_text(node) -> str:
+    parts: list[str] = []
+    for item in node.iter("node"):
+        for key in ("text", "content-desc"):
+            value = item.attrib.get(key, "")
+            if value:
+                parts.append(value)
+    return "\n".join(parts)
+
+
 def _normalize_for_match(value: str) -> str:
     return re.sub(r"\s+", " ", value).strip()
 
 
+def _extract_x_url(text: str) -> str:
+    urls = []
+    for raw in re.findall(r"https?://[^\s\"'<>]+", text or ""):
+        url = raw.rstrip(").,;，。]")
+        if url:
+            urls.append(url)
+    for url in urls:
+        lowered = url.lower()
+        if any(marker in lowered for marker in ("x.com/", "twitter.com/", "mobile.twitter.com/", "t.co/")):
+            return url
+    return urls[0] if urls else ""
+
+
+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] + "..."
+
+
 def _find_top_left_clickable(root) -> object | None:
     candidates = []
     for node in root.iter("node"):

package/mobile-runtime/skills/android-collect-tiktok-metrics/SKILL.md

@@ -55,6 +55,82 @@ If device, logged-in account, target video, or measurement window is missing, as
 11agents mobile add-metrics --record-id pub_123 --platform tiktok --metric views=0 --json --task-id TASK_123
 ```
 
+6. When a project swarm token is available, map collected TikTok data into `swarm.telemetry.v1` instead of returning only a markdown summary:
+   - Use `platform: "tiktok_public"`.
+   - Account overview rows are `artifact_type: "account_period"`; create one artifact per account/period/date range and put `period`, `period_days`, `date_range`, account id, device id, and evidence paths in payload fields.
+   - Single-video rows are `artifact_type: "video"`; create one artifact per video/profile order/post id and put `profile_order`, `posted_time`, caption/title, account id, device id, and evidence paths in artifact or observation payload fields.
+   - Put numeric analytics in `observations[].metrics`.
+   - Include `dashboard_spec.metric_schema` and set recovered account/video metrics to `aggregation: "snapshot"` so Agent Performance does not sum values that already include a time window.
+   - Include `observation_table` widgets with explicit columns for account period rows and video rows so both account-level and single-video fields are visible.
+
+## Swarm Dashboard Contract
+
+Use explicit snapshot tables for TikTok metrics:
+
+```json
+{
+  "schema_version": "swarm.dashboard.v1",
+  "title": "TikTok Data Collection",
+  "metric_schema": {
+    "post_views": { "label": "Post views", "aggregation": "snapshot" },
+    "profile_views": { "label": "Profile views", "aggregation": "snapshot" },
+    "views": { "label": "Views", "aggregation": "snapshot" },
+    "likes": { "label": "Likes", "aggregation": "snapshot" },
+    "comments": { "label": "Comments", "aggregation": "snapshot" },
+    "shares": { "label": "Shares", "aggregation": "snapshot" },
+    "saves": { "label": "Saves", "aggregation": "snapshot" },
+    "avg_watch_seconds": { "label": "Avg watch", "aggregation": "snapshot", "unit": "seconds" },
+    "watched_full_rate": { "label": "Watched full", "aggregation": "snapshot", "format": "percent" },
+    "new_followers": { "label": "New followers", "aggregation": "snapshot" }
+  },
+  "widgets": [
+    {
+      "id": "account_periods",
+      "title": "Account Period Snapshots",
+      "type": "table",
+      "query": {
+        "kind": "observation_table",
+        "platform": "tiktok_public",
+        "artifact_type": "account_period",
+        "latest_per_artifact": true,
+        "columns": [
+          { "key": "period", "label": "Period", "source": "payload" },
+          { "key": "date_range", "label": "Date range", "source": "payload" },
+          { "key": "post_views", "label": "Post views", "source": "metric" },
+          { "key": "profile_views", "label": "Profile views", "source": "metric" },
+          { "key": "likes", "label": "Likes", "source": "metric" },
+          { "key": "comments", "label": "Comments", "source": "metric" },
+          { "key": "shares", "label": "Shares", "source": "metric" }
+        ]
+      }
+    },
+    {
+      "id": "video_snapshots",
+      "title": "Video Snapshots",
+      "type": "table",
+      "query": {
+        "kind": "observation_table",
+        "platform": "tiktok_public",
+        "artifact_type": "video",
+        "latest_per_artifact": true,
+        "columns": [
+          { "key": "profile_order", "label": "Profile order", "source": "payload" },
+          { "key": "posted_time", "label": "Posted time", "source": "payload" },
+          { "key": "views", "label": "Views", "source": "metric" },
+          { "key": "likes", "label": "Likes", "source": "metric" },
+          { "key": "comments", "label": "Comments", "source": "metric" },
+          { "key": "shares", "label": "Shares", "source": "metric" },
+          { "key": "saves", "label": "Saves", "source": "metric" },
+          { "key": "avg_watch_seconds", "label": "Avg watch", "source": "metric" },
+          { "key": "watched_full_rate", "label": "Watched full", "source": "metric" },
+          { "key": "new_followers", "label": "New followers", "source": "metric" }
+        ]
+      }
+    }
+  ]
+}
+```
+
 ## Output
 
 Return metric status, snapshot ids, account/video target, data freshness, screenshot paths when created, run log path, missing access, and `agent_memory_delta` with reusable creative or account learning.

package/mobile-runtime/skills/android-publish-tiktok/SKILL.md

@@ -34,13 +34,13 @@ ADB fallback when explicitly requested:
 
 Use `--range`, `--parallel`, and `--max-concurrency N` only when the approved plan targets multiple devices. Keep concurrency at or below 5.
 
-Successful live publish is only confirmed after the CLI taps the publish button and verifies TikTok publish completion. After writing the publish record, the CLI force-stops TikTok and captures `after-app-close.png` in the run artifacts.
+Successful live publish is only confirmed after the CLI taps the publish button and verifies the post-publish surface. If the just-published video detail page already shows `复制链接`/`Copy link`, the CLI copies that link directly; otherwise it reopens TikTok on the profile post grid, opens the latest owned video, and copies its share link. Link readback uses the Android launcher/system search input as the default paste probe after direct clipboard reads; TikTok search is only a fallback. The CLI stores `platform_permalink`/`platform_post_id` in the publish record when available and force-stops TikTok after recovery. Treat missing `platform_permalink` or `link_status!="retrieved"` as a failed publish workflow even if the video tap itself succeeded. The run artifacts include `after-app-close.png`.
 
-When the agent environment contains `ELEVENAGENTS_PUBLISH_DINGTALK_WEBHOOK`, the CLI sends a DingTalk notification after status `published`; `ELEVENAGENTS_PUBLISH_DINGTALK_SECRET` is optional. TikTok notification content does not show a link.
+When the agent environment contains `ELEVENAGENTS_PUBLISH_DINGTALK_WEBHOOK`, the CLI sends a DingTalk notification after status `published`; `ELEVENAGENTS_PUBLISH_DINGTALK_SECRET` is optional. The message starts with the project, includes the task/device/link, and uses `链接：未收集到` when link recovery returned empty.
 
 ## Output
 
-Return publish status, record id, account/device, screenshot path, permalink or platform post id when available, duration, error action, and the data-collection handoff:
+Return publish status, record id, account/device, screenshot path, `platform_permalink`, `platform_post_id`, `link_status`, duration, error action, and the data-collection handoff:
 
 ```bash
 11agents mobile data collect --platform tiktok --scope video --record-id <record_id> --json --task-id TASK_123

package/mobile-runtime/skills/android-publish-x/SKILL.md

@@ -21,6 +21,8 @@ If approval, account access, content fields, or device readiness is missing, ask
 11agents mobile list-devices --health --json
 ```
 
+Live publishing verifies the post on the account profile, opens the published post detail page, taps the share icon, copies the post link, reads the copied permalink back into the publish record, and closes X after link recovery. Treat missing `platform_permalink` or `link_status!="retrieved"` as a failed publish workflow even if the post tap itself succeeded.
+
 Examples:
 
 ```bash
@@ -31,9 +33,11 @@ Examples:
 
 Do not automate replies, follows, likes, reposts, random browsing, or DM actions from this skill.
 
+When the agent environment contains `ELEVENAGENTS_PUBLISH_DINGTALK_WEBHOOK`, the CLI sends a DingTalk notification after status `published`; `ELEVENAGENTS_PUBLISH_DINGTALK_SECRET` is optional. The message starts with the project, includes the task/device/link, and uses `链接：未收集到` when link recovery returned empty.
+
 ## Output
 
-Return publish status, record id, account/device, screenshot path, permalink or platform post id when available, duration, error, and the data-collection handoff:
+Return publish status, record id, account/device, screenshot path, `platform_permalink`, `link_status`, duration, error, and the data-collection handoff:
 
 ```bash
 11agents mobile data collect --platform x --record-id <record_id> --json --task-id TASK_123

package/mobile-runtime/skills/android-publish-xiaohongshu/SKILL.md

@@ -35,7 +35,7 @@ Structured package:
 
 Successful live publish is only confirmed after the CLI taps the final publish button, waits without tapping while Xiaohongshu shows upload/progress state, closes and relaunches Xiaohongshu, then opens the "我" page, opens the note whose title matches the expected title or the first visible profile note as a verified fallback, and verifies the detail page against the expected title/body. The CLI recovers the note link by default for live publish; use `--no-copy-link-after-publish` only when link recovery is explicitly not wanted. After writing the publish record, the CLI force-stops Xiaohongshu and captures `after-app-close.png` in the run artifacts. If that evidence does not match, treat the result as `failed`; do not claim publish success from the publish button tap alone.
 
-When the agent environment contains `ELEVENAGENTS_PUBLISH_DINGTALK_WEBHOOK`, the CLI sends a DingTalk notification after status `published`; `ELEVENAGENTS_PUBLISH_DINGTALK_SECRET` is optional. The Xiaohongshu notification includes the recovered link when available and still sends if the link was not recovered.
+When the agent environment contains `ELEVENAGENTS_PUBLISH_DINGTALK_WEBHOOK`, the CLI sends a DingTalk notification after status `published`; `ELEVENAGENTS_PUBLISH_DINGTALK_SECRET` is optional. The message starts with the project, includes the task/device/link, and uses `链接：未收集到` when link recovery returned empty.
 
 Link copy after publish or during the recovery skill:
 

package/mobile-runtime/skills/mobile-publish-data-collection/SKILL.md

@@ -41,9 +41,85 @@ If records, platform post id/permalink, or analytics access is missing, ask the
 ```
 
 5. Treat X, Facebook, and unsupported platform collectors that return `missing_access` as a valid recovery status. Ask for the relevant API token, analytics export, or manual values, then append with `11agents mobile add-metrics`.
-6. If platform metrics are unavailable, record the missing access and ask for the relevant token/export instead of inventing numbers.
-7. Summarize metrics by platform, account, device, content type, creative pattern, and issue/task id.
-8. Write reusable learning as `agent_memory_delta` for channel agents.
+6. For TikTok account/video recovery, map the data into `swarm.telemetry.v1` when the project swarm token is available:
+   - Use `platform: "tiktok_public"`.
+   - Use `artifact_type: "account_period"` for account overview period/date-range rows.
+   - Use `artifact_type: "video"` for single-video/profile-order rows.
+   - Put period/date range, posted time, profile order, account id, device id, and evidence paths in payload/artifact fields.
+   - Put numeric analytics in `observations[].metrics`.
+   - In `dashboard_spec.metric_schema`, mark windowed/snapshot metrics as `aggregation: "snapshot"` so Agent Performance does not sum them again.
+   - Include `observation_table` widgets for account period snapshots and video snapshots, with explicit columns for every recovered field.
+7. If platform metrics are unavailable, record the missing access and ask for the relevant token/export instead of inventing numbers.
+8. Summarize metrics by platform, account, device, content type, creative pattern, and issue/task id.
+9. Write reusable learning as `agent_memory_delta` for channel agents.
+
+## TikTok Dashboard Contract
+
+TikTok recovery should include account-level and video-level tables in `dashboard_spec`:
+
+```json
+{
+  "schema_version": "swarm.dashboard.v1",
+  "title": "TikTok Data Collection",
+  "metric_schema": {
+    "post_views": { "label": "Post views", "aggregation": "snapshot" },
+    "profile_views": { "label": "Profile views", "aggregation": "snapshot" },
+    "views": { "label": "Views", "aggregation": "snapshot" },
+    "likes": { "label": "Likes", "aggregation": "snapshot" },
+    "comments": { "label": "Comments", "aggregation": "snapshot" },
+    "shares": { "label": "Shares", "aggregation": "snapshot" },
+    "saves": { "label": "Saves", "aggregation": "snapshot" },
+    "avg_watch_seconds": { "label": "Avg watch", "aggregation": "snapshot", "unit": "seconds" },
+    "watched_full_rate": { "label": "Watched full", "aggregation": "snapshot", "format": "percent" },
+    "new_followers": { "label": "New followers", "aggregation": "snapshot" }
+  },
+  "widgets": [
+    {
+      "id": "account_periods",
+      "title": "Account Period Snapshots",
+      "type": "table",
+      "query": {
+        "kind": "observation_table",
+        "platform": "tiktok_public",
+        "artifact_type": "account_period",
+        "latest_per_artifact": true,
+        "columns": [
+          { "key": "period", "label": "Period", "source": "payload" },
+          { "key": "date_range", "label": "Date range", "source": "payload" },
+          { "key": "post_views", "label": "Post views", "source": "metric" },
+          { "key": "profile_views", "label": "Profile views", "source": "metric" },
+          { "key": "likes", "label": "Likes", "source": "metric" },
+          { "key": "comments", "label": "Comments", "source": "metric" },
+          { "key": "shares", "label": "Shares", "source": "metric" }
+        ]
+      }
+    },
+    {
+      "id": "video_snapshots",
+      "title": "Video Snapshots",
+      "type": "table",
+      "query": {
+        "kind": "observation_table",
+        "platform": "tiktok_public",
+        "artifact_type": "video",
+        "latest_per_artifact": true,
+        "columns": [
+          { "key": "profile_order", "label": "Profile order", "source": "payload" },
+          { "key": "posted_time", "label": "Posted time", "source": "payload" },
+          { "key": "views", "label": "Views", "source": "metric" },
+          { "key": "likes", "label": "Likes", "source": "metric" },
+          { "key": "comments", "label": "Comments", "source": "metric" },
+          { "key": "shares", "label": "Shares", "source": "metric" },
+          { "key": "saves", "label": "Saves", "source": "metric" },
+          { "key": "avg_watch_seconds", "label": "Avg watch", "source": "metric" },
+          { "key": "watched_full_rate", "label": "Watched full", "source": "metric" },
+          { "key": "new_followers", "label": "New followers", "source": "metric" }
+        ]
+      }
+    }
+  ]
+}
+```
 
 ## Output
 Return recovered links/metrics, missing analytics access, record ids covered, data freshness, run log path, notable performance patterns, and follow-up tasks for planning.

package/mobile-runtime/skills/mobile-publish-execution/SKILL.md

@@ -51,7 +51,7 @@ If mobile setup, device online status, media path, app login readiness, or appro
 11. Use `11agents mobile publish-tiktok`, `publish-instagram`, `publish-facebook`, `publish-reddit`, `publish-x`, and `publish-xiaohongshu`.
 12. Prefer `--json` and parse status, duration, record id, screenshot path, permalink, platform post id, and error.
 13. Pass `--task-id <task_id>` so logs land at `~/.11agents/mobile/runs/<task_id>/log`.
-14. Do not run custom DingTalk webhook scripts after Xiaohongshu or TikTok publish. When the agent environment contains `ELEVENAGENTS_PUBLISH_DINGTALK_WEBHOOK`, the CLI sends the publish-success notification automatically; `ELEVENAGENTS_PUBLISH_DINGTALK_SECRET` is optional for signed robots.
+14. Do not run custom DingTalk webhook scripts after X, Xiaohongshu, or TikTok publish. When the agent environment contains `ELEVENAGENTS_PUBLISH_DINGTALK_WEBHOOK`, the CLI sends the publish-success notification automatically; `ELEVENAGENTS_PUBLISH_DINGTALK_SECRET` is optional for signed robots. The message starts with the project, includes the task/device/link, and uses `链接：未收集到` when link recovery returned empty.
 15. Stop on `failed`; surface screenshot and error instead of repeated retries.
 
 ## Output