@11agents/cli 0.1.42 → 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-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-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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@11agents/cli",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "11agents local runtime and telemetry CLI",
   "type": "module",
   "bin": {

package/src/commands/knowledge.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, readdir, rm, rmdir, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 import { flag } from '../args.js'
@@ -116,6 +116,27 @@ export function buildKnowledgeBaseDir(project, { homeDir = os.homedir() } = {})
   return path.join(homeDir, '.11agents', slugify(project), 'knowledge_base')
 }
 
+// Mirror the skill-sync strategy: after a sync the cloud snapshot is the source
+// of truth, so local knowledge text files missing from it are removed. Scope is
+// strictly the project's knowledge_base directory.
+async function pruneLocalKnowledgeFiles(baseDir, keepPaths) {
+  for (const localPath of await listKnowledgeTextFiles(baseDir)) {
+    if (keepPaths.has(localPath)) continue
+    await rm(path.join(baseDir, localPath), { force: true })
+  }
+  const removeEmptyDirs = async dir => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+    for (const entry of entries) {
+      if (entry.isDirectory()) await removeEmptyDirs(path.join(dir, entry.name))
+    }
+    if (dir !== baseDir) {
+      const remaining = await readdir(dir).catch(() => ['keep'])
+      if (remaining.length === 0) await rmdir(dir).catch(() => {})
+    }
+  }
+  await removeEmptyDirs(baseDir)
+}
+
 export async function writeKnowledgeSnapshot(project, snapshot, { homeDir = os.homedir() } = {}) {
   const normalized = normalizeSnapshot(snapshot)
   const baseDir = buildKnowledgeBaseDir(project, { homeDir })
@@ -138,6 +159,7 @@ export async function writeKnowledgeSnapshot(project, snapshot, { homeDir = os.h
     await mkdir(path.dirname(target), { recursive: true })
     await writeFile(target, markdownForNode(node))
   }
+  await pruneLocalKnowledgeFiles(baseDir, new Set(normalized.nodes.map(node => node.local_path)))
   return index
 }
 

package/src/commands/mobile.js

@@ -65,8 +65,10 @@ const COMMAND_ALIASES = new Map([
 
 const WRAPPER_FLAG_NAMES = new Set([
   'mobile-home',
+  'project',
   'task-id',
   'task-title',
+  'workspace',
 ])
 
 const EMPTY_DATA_FILES = [
@@ -99,7 +101,7 @@ Runtime:
   Python/device-control code is bundled with @11agents/cli.
   Mutable runtime state lives in ~/.11agents/mobile by default.
   Every command writes logs under ~/.11agents/mobile/runs/<task_id>/log.
-  Xiaohongshu/TikTok publish-success DingTalk notification is enabled by
+  X/Xiaohongshu/TikTok publish-success DingTalk notification is enabled by
   ELEVENAGENTS_PUBLISH_DINGTALK_WEBHOOK and optional
   ELEVENAGENTS_PUBLISH_DINGTALK_SECRET.`)
 }
@@ -602,10 +604,12 @@ function buildRunContext(rawArgs, deps = {}) {
       || env.ELEVENAGENTS_ISSUE_TITLE
       || taskId
   ).trim()
+  const project = projectFromMobileContext(flags, env)
   const runDir = path.join(home, 'runs', taskId)
   return {
     flags,
     home,
+    project,
     taskId,
     taskTitle,
     runDir,
@@ -613,6 +617,20 @@ function buildRunContext(rawArgs, deps = {}) {
   }
 }
 
+function projectFromMobileContext(flags = {}, env = process.env) {
+  return String(
+    flag(flags, 'project')
+      || flag(flags, 'workspace')
+      || env.ELEVENAGENTS_PROJECT_SLUG
+      || env.ELEVENAGENTS_PROJECT
+      || env.ELEVENAGENTS_PROJECT_NAME
+      || env.ELEVENAGENTS_WORKSPACE_SLUG
+      || env.GTM_SWARM_WORKSPACE
+      || env.WORKSPACE_SLUG
+      || ''
+  ).trim()
+}
+
 async function dispatchPython(rawArgs, deps = {}) {
   const command = normalizePythonCommand(rawArgs[0] || '')
   if (!PYTHON_COMMANDS.has(command)) throw new Error(`unsupported mobile command: ${rawArgs[0] || ''}`)
@@ -622,6 +640,7 @@ async function dispatchPython(rawArgs, deps = {}) {
   const env = pythonEnv(context.home, deps.env || process.env)
   env.ELEVENAGENTS_MOBILE_RUN_DIR = context.runDir
   env.ELEVENAGENTS_TASK_ID = context.taskId
+  if (context.project) env.ELEVENAGENTS_PROJECT_SLUG = context.project
   const result = await runAndLog({
     command: python,
     args: childArgs,
@@ -661,6 +680,7 @@ async function dispatchScript(rawArgs, deps = {}) {
   const env = pythonEnv(context.home, deps.env || process.env)
   env.ELEVENAGENTS_MOBILE_RUN_DIR = context.runDir
   env.ELEVENAGENTS_TASK_ID = context.taskId
+  if (context.project) env.ELEVENAGENTS_PROJECT_SLUG = context.project
   const result = await runAndLog({
     command: python,
     args: [scriptPath, ...stripWrapperFlags(rawArgs.slice(1))],
@@ -702,6 +722,7 @@ async function notifyMobilePublishSuccess({ command, context, parsed, env = proc
     const link = publishResultLink(row)
     const content = buildPublishNotificationContent({
       platform,
+      project: context.project,
       task: context.taskTitle || context.taskId,
       deviceId: row.device_id || row.device || '',
       link,
@@ -755,7 +776,7 @@ function isPublishedResult(row) {
 }
 
 function shouldNotifyPublishPlatform(platform) {
-  return platform === 'xiaohongshu' || platform === 'tiktok'
+  return platform === 'xiaohongshu' || platform === 'tiktok' || platform === 'x'
 }
 
 function publishResultLink(row) {
@@ -768,13 +789,14 @@ function publishResultLink(row) {
   ).trim()
 }
 
-function buildPublishNotificationContent({ platform, task, deviceId = '', link }) {
+function buildPublishNotificationContent({ platform, project = '', task, deviceId = '', link }) {
   const label = platformLabel(platform)
+  const projectText = String(project || '').trim()
   const taskText = String(task || 'task').trim()
   const deviceText = deviceId ? `（设备 ${deviceId}）` : ''
-  if (platform === 'tiktok') return `${label} ${taskText}${deviceText}已发布`
-  const linkText = String(link || '').trim() || '未回收'
-  return `${label} ${taskText}${deviceText}已发布，链接：${linkText}`
+  const linkText = String(link || '').trim() || '未收集到'
+  const prefix = projectText ? `[${projectText}] ` : ''
+  return `${prefix}${label} ${taskText}${deviceText}已发布，链接：${linkText}`
 }
 
 function platformLabel(platform) {
@@ -946,6 +968,7 @@ export const mobileInternals = {
   mobileHome,
   parseRawArgs,
   platformFromMobileCommand,
+  projectFromMobileContext,
   publishResultLink,
   shouldNotifyPublishPlatform,
   signedDingTalkUrl,

package/src/commands/runtime.js

@@ -1124,10 +1124,13 @@ async function prepareRuntimeTask(task, flags, deps, config) {
   // Resolve project token before skill sync so MCP auth is available.
   const projectToken = await projectSyncToken(projectTokenCandidatesForTask(task, flags), flags, deps, task.workspace?.swarm_token)
   const skills = await syncSkillsViaMcp({ task, workdir, flags, deps, projectToken, config })
+  const projectSlug = projectSlugForTask(task, flags)
   const env = {
     ...process.env,
     ...agentEnvironment(task),
     ELEVENAGENTS_PROJECT_DIR: workdir,
+    ELEVENAGENTS_PROJECT_SLUG: projectSlug,
+    ELEVENAGENTS_PROJECT_NAME: String(task.workspace?.name || task.workspace?.slug || task.workspace_slug || ''),
     ELEVENAGENTS_AGENT_DIR: agentDir,
     ELEVENAGENTS_AGENT_SKILLS_DIR: agentSkillsDir,
     ELEVENAGENTS_AGENT_MEMORY_DIR: agentMemoryDir,
@@ -1146,7 +1149,7 @@ async function prepareRuntimeTask(task, flags, deps, config) {
     agent_results_dir: agentResultsDir,
     tmp_dir: tmpDir,
     run_dir: runDir,
-    project_slug: projectSlugForTask(task, flags),
+    project_slug: projectSlug,
     readonly: true,
     env,
     database,