shuadouyin 0.4.1 → 0.5.0

package/.dy-build-commit

@@ -1 +1 @@
-d9528376f4f68e7e7414bc7968f619267fd656b4
+e648c8d2d2d011a9aec54030287f9a8cf4947bf1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.5.0 — 2026-10-31
+
+### 新增
+
+- `video ai` — 读平台自己的 AI 对这条作品的描述。它能覆盖截图覆盖不到的：整条视频发生了什么、歌词唱什么、评论区在聊什么。**它是抖音在描述自己的内容，不是这个工具观察到的画面**，每条返回都带着这句话。
+- `video digest --ai` — 一次调用同时拿到采样画面和平台描述。两者放在不同字段里，不混在一起。
+- `video favorites` — 读自己收藏的作品，`--tab` 可换 喜欢 / 观看历史 / 稍后再看 / 我的预约。之前只能写收藏，看不到收藏了什么。
+
+### 改进
+
+- `context show` 对人格文件改用按段投影，和 `persona show` 一致。低预算时身份与声音不会被静静切掉。自由格式（没有 `##` 段）回退到原文而不是返回空。
+- 成功事件也记录耗时。之前只有失败记，所以「哪个命令慢」只能回答坏掉的那些。
+- 轮次摘要分开报 `browser_ms`（页面调用时间）和 `elapsed_ms`（轮次开了多久），并单独报 `duplicate_observations`——一个作品读两次，预算算一次，成本付两次。
+
+### 修复
+
+- `context show` 遇到只有标题没有小节的人格文件会返回空内容，等于说人格是空的。现在回退到原文。
+
 ## 0.4.1 — 2026-10-31
 
 ### 文档

package/README.en.md

@@ -29,9 +29,26 @@ ShuaDouyin's executable is `dy`. Give it to an AI Agent that can run shell comma
 
 ## Quick start
 
+### Copy an installation prompt (recommended)
+
+Copy the entire block to an Agent that can run shell commands. Install the skill first, then let its instructions guide CLI installation and setup:
+
+```text
+Please install the dy skill:
+npx skills add https://github.com/9Ashwin/ShuaDouyin --skill dy
+
+Read the installed dy skill and follow it to check and install the CLI,
+guide me through persona setup and Douyin login, and verify that it works.
+Preserve existing settings and memories. Only install, configure, and run read-only checks.
+```
+
+The skill includes CLI installation instructions. The Agent checks `dy --version` first and follows `references/setup.md` if the CLI is missing. The skill installer fetches its content from GitHub, so you do not need to open the repository and read the docs yourself. `dy` uses your existing Agent and needs no separate model API key. You log into Douyin yourself in local Chrome.
+
+### Manual installation
+
 You need **Node.js 22.19+, Chrome, and an Agent that can execute shell commands**.
 
-### 1. Install the CLI and skill
+#### 1. Install the CLI and skill
 
 ```bash
 npm install -g shuadouyin
@@ -41,7 +58,7 @@ dy skill install
 
 The npm package is `shuadouyin`; the command is `dy`. The published package includes the build output and uses your local Chrome, without downloading another browser. The skill installer detects supported Agent directories and preserves existing copies it does not manage.
 
-### 2. Create the workspace and log in
+#### 2. Create the workspace and log in
 
 ```bash
 dy init
@@ -50,9 +67,11 @@ dy auth login
 
 Scan the login QR code in the dedicated Chrome window. The default workspace is `~/.dy`; the browser login persists in `~/.dy/chrome`.
 
-### 3. Start a conversation with your Agent
+### Start using it
+
+After setup, send this to your Agent:
 
-> Use dy to help me set up a name, voice and boundaries. Then browse five works, pick one to inspect its frames and comments, and tell me what you observed. Only read this round; do not interact.
+> Use dy to browse five works, pick one to inspect its frames and comments, and tell me what you observed. Only read this round; do not interact. If no persona has been configured yet, guide me through setup first.
 
 You can also start with a specific task:
 
@@ -96,11 +115,9 @@ Updating or reinstalling the CLI continues to use the existing workspace. Use th
 
 ## Agent integration
 
-The [dy skill](skills/dy/SKILL.md) teaches Agents to use the tool, with topic-specific workflows in [references](skills/dy/references/). As an alternative to `dy skill install`, use the skills installer:
+For a first installation, use the [installation prompt above](#copy-an-installation-prompt-recommended). The following covers skill entry points and the usual calling sequence.
 
-```bash
-npx skills add https://github.com/9Ashwin/ShuaDouyin --skill dy
-```
+The [dy skill](skills/dy/SKILL.md) teaches Agents to install and use the tool, with topic-specific workflows in [references](skills/dy/references/). If the CLI is already installed, you can also run `dy skill install` to connect the skill.
 
 Start each task by reading persona and relevant context:
 

package/README.md

@@ -29,9 +29,26 @@ ShuaDouyin 的命令叫 `dy`。把它交给能执行 shell 的 AI Agent，就能
 
 ## 快速开始
 
+### 复制给 Agent 安装（推荐）
+
+把下面整段复制给能执行 shell 的 Agent，先装 skill，再由技能引导完成 CLI 安装与设置：
+
+```text
+请帮我安装 dy 技能：
+npx skills add https://github.com/9Ashwin/ShuaDouyin --skill dy
+
+安装后读取 dy skill，按技能指引检查并安装 CLI，
+带我完成人格设置和抖音登录，并验证是否可用。
+已有配置和记忆请保留，这次只做安装、配置和只读验证。
+```
+
+skill 已包含 CLI 的安装指引，Agent 会先检查 `dy --version`，缺少 CLI 时按 `references/setup.md` 继续安装。技能安装器会从 GitHub 获取内容，你无需手动打开仓库查文档。`dy` 使用你现有的 Agent，不需要单独配置模型 API Key；抖音登录由你在本机 Chrome 中完成。
+
+### 自己安装
+
 准备好 **Node.js 22.19+、Chrome，以及一个能执行 shell 的 Agent**。
 
-### 1. 安装工具与 skill
+#### 1. 安装工具与 skill
 
 ```bash
 npm install -g shuadouyin
@@ -41,7 +58,7 @@ dy skill install
 
 npm 包叫 `shuadouyin`，可执行命令叫 `dy`。发布包已包含构建产物；使用本机 Chrome，不额外下载浏览器。`dy skill install` 会为已检测到的 Agent 安装技能，已有的非托管副本会保留。
 
-### 2. 建立工作区并登录
+#### 2. 建立工作区并登录
 
 ```bash
 dy init
@@ -50,9 +67,11 @@ dy auth login
 
 在打开的专用 Chrome 窗口里扫码登录。工作区默认位于 `~/.dy`，浏览器登录保存在 `~/.dy/chrome`，后续继续使用。
 
-### 3. 在你的 Agent 里开始聊
+### 开始使用
+
+设置好后，把这句话发给你的 Agent：
 
-> 用 dy 带我完成设置，先问我名字、语气和边界。然后刷 5 条，挑 1 条读画面和评论，告诉我看到了什么。这轮只看，不互动。
+> 用 dy 刷 5 条，挑 1 条读画面和评论，告诉我看到了什么。这轮只看，不互动。如果还没设置人格，先带我完成设置。
 
 也可以从具体任务开始：
 
@@ -96,11 +115,9 @@ dy auth login
 
 ## 给 Agent 接入
 
-[dy skill](skills/dy/SKILL.md) 负责教 Agent 如何使用工具，主题流程放在 [references](skills/dy/references/) 中。除了 `dy skill install`，也可以使用技能安装器：
+首次安装可以直接使用上面的[安装提示词](#复制给-agent-安装推荐)。下面是技能入口和日常调用顺序。
 
-```bash
-npx skills add https://github.com/9Ashwin/ShuaDouyin --skill dy
-```
+[dy skill](skills/dy/SKILL.md) 负责教 Agent 安装和使用工具，主题流程放在 [references](skills/dy/references/) 中。如果已经安装 CLI，也可以运行 `dy skill install` 接入技能。
 
 每次任务先读人格和相关上下文，再读页面：
 

package/dist/app.js

@@ -5,6 +5,7 @@ import { CliError, normalizeError } from "./errors.js";
 import { Knowledge, knowledgeOperation, validateKnowledge } from "./knowledge.js";
 import { migrateLegacyLayout } from "./migrate.js";
 import { askDouyin } from "./operations/ai-search.js";
+import { readAiSummary } from "./operations/ai-summary.js";
 import { rounds } from "./operations/browsing.js";
 import { audio, capture, noteImage, noteSlide, observe } from "./operations/capture.js";
 import { captureChatImage, listChats, readChat } from "./operations/chat.js";
@@ -18,6 +19,7 @@ import { closeComments, commentVoice, knownVoices, listComments, listReplies, ph
 import { inspectCreator } from "./operations/creator.js";
 import { digest } from "./operations/digest.js";
 import { pageFactsRead } from "./operations/facts.js";
+import { readFavorites } from "./operations/favorites.js";
 import { readImage } from "./operations/image-file.js";
 import { readInbox } from "./operations/inbox.js";
 import { resolveLink } from "./operations/links.js";
@@ -252,9 +254,16 @@ export class App {
                         // starting. Reading "the open round" after the fact would attach a
                         // long sweep to whichever round happened to be open when it ended.
                         const open = rounds(await this.store.events()).find((round) => round.status === "open");
-                        const data = open && result && typeof result === "object"
-                            ? { ...result, _browse: { round_id: open.id, started_at: open.started_at } }
-                            : result;
+                        // How long the page call took is measured here, where the clock is
+                        // already running. Only failures carried a duration before, so
+                        // "which command is slow" could be answered for the ones that broke
+                        // and never for the ones that worked — which is the question a
+                        // caller actually has.
+                        const elapsed = Math.max(0, Math.round(performance.now() - started));
+                        const browse = open ? { round_id: open.id, started_at: open.started_at, elapsed_ms: elapsed } : null;
+                        const data = !open && !(result && typeof result === "object")
+                            ? result
+                            : { ...result, _elapsed_ms: elapsed, ...(browse ? { _browse: browse } : {}) };
                         await this.store.append(operation, data);
                     }
                     const notices = {
@@ -656,6 +665,10 @@ export class App {
                 return userRelations(session, { ...input, relation: operation === "user.following" ? "following" : "followers" }, signal);
             case "ai.ask":
                 return askDouyin(session, input, signal);
+            case "video.ai":
+                return readAiSummary(session, input, signal);
+            case "video.favorites":
+                return readFavorites(session, input, signal);
             case "person.read":
                 input.user_id = resourceID(input.resource ?? "", "user");
                 return readPerson(session, input, signal);

package/dist/catalog.js

@@ -900,6 +900,20 @@ export const COMMANDS = [
         effect: "account_write",
         guidance: "Read video info first. --value false removes the like; an already matching state does not click the button. Image posts use their own controls and never fall back to the video button.",
     },
+    {
+        id: "video.favorites",
+        description: "List the works this account has saved, from its own profile tab",
+        flags: [
+            {
+                key: "target",
+                name: "--tab <name>",
+                description: "收藏 (default), 喜欢, 观看历史, 稍后再看, 我的预约",
+                type: "string",
+            },
+        ],
+        effect: "read",
+        guidance: "Opens this account's own profile and reads the work grid on the named tab. Writing a favorite already existed; this is the read side, without which a caller adds to a collection it cannot see. Only works loaded in the window are listed and the page states no total, so complete is always false. A tab that comes back empty is empty, not still loading: the reader waits for the grid to change and then reports what is there.",
+    },
     {
         id: "video.favorite",
         description: "Set the desired favorite state of the current video or image post",
@@ -912,6 +926,13 @@ export const COMMANDS = [
         flags: [{ key: "output", name: "--output <path>", description: "PNG output path", type: "string" }],
         effect: "local",
     },
+    {
+        id: "video.ai",
+        description: "Read the platform's own summary of the current work",
+        flags: [video],
+        effect: "read",
+        guidance: "Opens the work's AI panel and returns what Douyin's model wrote about it. This covers what frames cannot — the whole video, the lyrics, what the comments are about — and it is the platform describing its own content rather than an observation: an answer here can be wrong in ways a screenshot cannot. Every response carries that distinction in its limits, and complete:false means the panel had not finished writing, so the text is partial. Use video digest for what the page shows and this for what the platform says about it; a claim worth repeating should be checked against the work.",
+    },
     {
         id: "video.digest",
         description: "Gather what a work is about: identity, sampled positions and loaded comments",
@@ -929,6 +950,13 @@ export const COMMANDS = [
             },
             { key: "limit", name: "--limit <count>", description: "Comments to read (default 8)", type: "number" },
             { key: "output", name: "--output <directory>", description: "Frame output directory", type: "string" },
+            {
+                key: "ai",
+                name: "--ai",
+                description: "Also read the platform's own summary of the work",
+                type: "boolean",
+                default: false,
+            },
         ],
         effect: "local",
         guidance: "A title states the form, not the point. Three positions inside a work carry the argument, and the comment section says who is watching and what they took from it. Sampling avoids the opening and the end, which are the least informative parts. Frames are viewport screenshots and are labelled as samples, never as a claim about the whole work. A work under 15 seconds is not sampled: it is its own summary. Use --frames 0 to skip seeking entirely.",

package/dist/knowledge.js

@@ -481,7 +481,46 @@ export class Knowledge {
                         remaining -= kept.length;
                         return { content: kept.join(""), truncated: kept.length < chars.length };
                     };
-                    const documentViews = documents.map((document) => ({ ...document, ...excerpt(document.content, 8000) }));
+                    // The persona is projected by section, not sliced from the front.
+                    //
+                    // Slicing is right for memories and wrong for a persona: identity and
+                    // voice sit after the role introduction, so a budget that runs out
+                    // silently removes the part the agent is supposed to sound like, and
+                    // nothing in the output says it was cut. The projection returns whole
+                    // sections and marks each one, and persona show uses the same function
+                    // so two callers cannot disagree about what the persona is.
+                    const documentViews = documents.map((document) => {
+                        if (document.file !== "AGENTS.md")
+                            return { ...document, ...excerpt(document.content, 8000) };
+                        const sectionBudget = Math.min(4000, remaining);
+                        const surface = personaSurface(BOT_ID, document.file, document.revision, document.content, sectionBudget);
+                        // A file with no sections is not a persona with nothing in it. The
+                        // projection cannot read it, so the document is passed through as
+                        // written and the flags say the shape was not understood — an empty
+                        // content field would say the persona itself is empty.
+                        if (surface.needs_interpretation)
+                            return { ...document, ...excerpt(document.content, 8000) };
+                        const parts = surface.parts.filter((part) => part.complete);
+                        // The remaining sections are reported, not dropped: a caller that sees
+                        // complete:false knows to raise the budget or read the document.
+                        remaining -= surface.characters;
+                        return {
+                            ...document,
+                            content: parts
+                                .map((part) => `${part.name === "identity" ? "## 身份与声音" : part.name}\n\n${part.text}`)
+                                .join("\n\n"),
+                            truncated: !surface.complete,
+                            persona: {
+                                name: surface.name,
+                                sections: surface.parts.map((part) => ({
+                                    name: part.name,
+                                    complete: part.complete,
+                                })),
+                                missing: surface.missing,
+                                needs_interpretation: true,
+                            },
+                        };
+                    });
                     const memoryViews = packed.items.map(({ hit, body, truncated }) => {
                         const row = hit.entry.row;
                         const short = (value, max) => Array.from(value).slice(0, max).join("");

package/dist/operations/ai-summary.js

@@ -0,0 +1,52 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { CliError } from "../errors.js";
+import { control } from "./navigation.js";
+export const AI_SUMMARY_LIMITS = [
+    "Written by Douyin's model about its own content, not observed by this tool. Quote it as the platform's description, never as something seen here.",
+    "It can describe what the frames cannot: the whole video, lyrics, and what the comments are about.",
+    "Read the ending marker as the signal it finished. Without it the answer was still streaming, and this returns complete:false rather than the partial text.",
+];
+export async function readAiSummary(session, input, signal) {
+    const open = await session.call("video.info", input);
+    const workID = open.video?.id ?? null;
+    const point = await session.call("ai.entry.point", {});
+    await session.tab.mouse.click(point.x, point.y);
+    // The panel streams. Two reads in a row with the same text means it stopped;
+    // waiting for a non-empty read alone would return the first sentence of an
+    // answer that is still being written.
+    const deadline = Date.now() + 30_000;
+    let previous = "";
+    let stable = 0;
+    let last = { complete: false, summary: "", why: "" };
+    while (Date.now() < deadline) {
+        signal.throwIfAborted();
+        await delay(600, undefined, { signal });
+        last = await session.call("ai.summary", {});
+        // The disclaimer is the page stating the answer is done, which is stronger
+        // evidence than a stable read.
+        if (last.complete) {
+            if (last.summary && last.summary === previous)
+                stable++;
+            else
+                stable = 0;
+            previous = last.summary;
+            if (stable >= 1)
+                break;
+        }
+    }
+    if (!last.summary)
+        throw new CliError("timeout", "The AI panel did not produce a summary", {
+            hint: last.why || "The entry may have opened a different panel, or the page changed.",
+        });
+    // A panel stays open across feed moves and would be read as this work's
+    // summary. Closing is best-effort: a panel that is already gone has nothing
+    // to close, and failing here would throw away a summary already read.
+    await control(session, "chat.close").catch(() => undefined);
+    return {
+        work_id: workID,
+        summary: last.summary,
+        complete: last.complete && stable >= 1,
+        limits: AI_SUMMARY_LIMITS,
+    };
+}
+//# sourceMappingURL=ai-summary.js.map

package/dist/operations/browsing.js

@@ -203,6 +203,25 @@ export function roundSummary(events, id) {
         inspected,
         interacted: [...interacted].length,
         elapsed_ms: elapsed,
+        // Time spent inside page calls, apart from how long the round was open. A
+        // round can be open for an hour with four minutes of browser work in it,
+        // and the difference is the caller thinking, not the tool being slow.
+        browser_ms: (() => {
+            let total = 0;
+            for (const event of inside) {
+                const data = record(event);
+                if (typeof data._elapsed_ms === "number" && data._elapsed_ms >= 0)
+                    total += data._elapsed_ms;
+            }
+            return total;
+        })(),
+        // The same work returned by more than one command. Counting it once is
+        // right for the budget and misleading for cost: reading a work twice is
+        // paid for twice.
+        duplicate_observations: (() => {
+            const all = observations(inside);
+            return all.length - uniqueObservations(all).length;
+        })(),
         budget: round.budget,
         // What the round is delivering against, and how far along it is. The
         // qualified count comes from the checkpoints, so it says what the caller

package/dist/operations/digest.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { classifyComment } from "../comment-stance.js";
 import { CliError } from "../errors.js";
+import { AI_SUMMARY_LIMITS, readAiSummary } from "./ai-summary.js";
 import { captureSnapshot, noteImage, noteSlide } from "./capture.js";
 import { listComments } from "./comments.js";
 // Long works earn more samples; a nine-second clip is its own summary. The
@@ -53,6 +54,11 @@ export async function digest(session, store, input, signal) {
     const duration = initial.video?.duration ?? null;
     const frames = [];
     const limitations = [];
+    // Requested before the frames so a failure here is the caller's error rather
+    // than a digest that quietly comes back with pictures and no summary.
+    const ai = input.ai
+        ? await readAiSummary(session, { ...input, video_id: initial.video?.id ?? initial.note?.id ?? undefined }, signal)
+        : null;
     const directory = store.path(join("captures", `digest-${work.id}`));
     // An image post is a set of pictures, and the set is the work. Sampling a video
     // means picking moments inside one; sampling an image post means looking at every
@@ -164,9 +170,15 @@ export async function digest(session, store, input, signal) {
         },
         frames,
         comments,
+        // The platform's own description, when asked for. It goes in a field of its
+        // own and never into `frames`: one is what was seen, the other is what the
+        // platform says, and merging them would make the difference invisible at the
+        // point a caller reads it.
+        ...(ai ? { platform_summary: ai } : {}),
         scope: frames.length ? "sampled_positions_and_loaded_comments" : "loaded_comments",
         limitations: [
             "Frames are screenshots of the viewport: they show what was on screen, not a claim about the whole work.",
+            ...(ai ? [AI_SUMMARY_LIMITS[0]] : []),
             ...limitations,
         ],
     };

package/dist/operations/favorites.js

@@ -0,0 +1,67 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { CliError } from "../errors.js";
+import { navigate } from "./navigation.js";
+// The tab labels the profile offers. Reading a different tab is the same code
+// path with a different label, so this is not only about favorites.
+const TABS = ["收藏", "喜欢", "观看历史", "稍后再看", "我的预约"];
+export async function readFavorites(session, input, signal) {
+    const requested = (input.target ?? "收藏").trim();
+    if (!TABS.includes(requested))
+        throw new CliError("invalid_argument", `Unknown profile tab "${requested}"`, {
+            hint: `Accepted: ${TABS.join(", ")}`,
+        });
+    const limits = [
+        "Screenshots and the private area are not read; this is the work grid as the page renders it.",
+        "Only works loaded in the current window are listed. Scroll the page for more.",
+        "A work being listed here says it is on this tab, not why the account saved it.",
+    ];
+    await navigate(session, "https://www.douyin.com/user/self", "profile", signal);
+    // The tab strip renders with the header, a moment after the route settles. A
+    // read taken on the navigation's word found no tabs at all and reported the
+    // page as changed.
+    const tabDeadline = Date.now() + 6000;
+    while (Date.now() < tabDeadline) {
+        signal.throwIfAborted();
+        try {
+            await session.call("profile.tab.point", { target: requested });
+            break;
+        }
+        catch (error) {
+            if (error instanceof CliError && error.code === "selector_changed") {
+                await delay(300, undefined, { signal });
+                continue;
+            }
+            throw error;
+        }
+    }
+    const before = await session.call("profile.tab.works", {});
+    const point = await session.call("profile.tab.point", { target: requested });
+    await session.tab.mouse.click(point.x, point.y);
+    await delay(400, undefined, { signal });
+    // The grid replaces the previous tab's list rather than appending to it, so
+    // waiting for the first work to differ is what tells the two apart. Reading
+    // before that returns the previous tab and calls it this one.
+    const deadline = Date.now() + 6000;
+    let works = before.works;
+    while (Date.now() < deadline) {
+        signal.throwIfAborted();
+        await delay(300, undefined, { signal });
+        const read = await session.call("profile.tab.works", {});
+        if (read.works.length && JSON.stringify(read.works) !== JSON.stringify(before.works)) {
+            works = read.works;
+            break;
+        }
+        // An empty tab is a real answer: the list is empty rather than still
+        // loading. It is taken once the wait has run out, never on the first read.
+        works = read.works;
+    }
+    return {
+        tab: requested,
+        works,
+        // The page does not state a total, so "complete" would be a claim about a
+        // number nothing here knows.
+        complete: false,
+        limits,
+    };
+}
+//# sourceMappingURL=favorites.js.map

package/dist/operations/validate.js

@@ -90,6 +90,13 @@ export function validate(operation, raw) {
             throw new CliError("invalid_argument", `--${key} must be an integer from ${minimum} to ${maximum}`);
     }
     switch (operation) {
+        case "video.favorites":
+            // The tab name is checked before Chrome starts. A page command that
+            // validated after connecting reported browser_not_running to a caller
+            // whose actual mistake was a typo in the tab name.
+            if (input.target && !["收藏", "喜欢", "观看历史", "稍后再看", "我的预约"].includes(input.target))
+                throw new CliError("invalid_argument", "--tab must be 收藏, 喜欢, 观看历史, 稍后再看 or 我的预约");
+            break;
         case "search":
         case "user.search":
             if (!input.query?.trim() || input.query.length > 300)

package/dist/page-adapter.js

@@ -765,6 +765,29 @@ var DouyinPage = (() => {
     const label = clean(container.getAttribute("aria-label") || container.getAttribute("title")) || images.map((image) => image.label).filter(Boolean).join(" ");
     return { name: label || null, images, requires_visual: !label };
   }
+  function aiEntryPoint() {
+    const entries2 = findRendered(document, '[class*="ai-douyin-entry"]').filter((element) => {
+      const box2 = element.getBoundingClientRect();
+      return box2.width > 0 && box2.height > 0 && box2.bottom > 0 && box2.top < innerHeight;
+    });
+    const entry = one(entries2, "AI summary entry on screen");
+    const box = entry.getBoundingClientRect();
+    return { x: Math.round(box.left + box.width / 2), y: Math.round(box.top + box.height / 2) };
+  }
+  function aiSummary() {
+    const text = document.body.innerText;
+    const marker = "\u4EE5\u4E0A\u5185\u5BB9\u7531AI\u751F\u6210";
+    const end = text.indexOf(marker);
+    if (end < 0) return { complete: false, summary: "", why: "The AI panel is not showing a finished answer" };
+    const head = text.slice(0, end);
+    const tabs = /(?:TA的作品|相关推荐)\s*\n?\s*评论?\s*\n?\s*相关推荐\s*\n*/;
+    const after = tabs.test(head) ? head.slice(head.search(tabs) + (head.match(tabs)?.[0].length ?? 0)).trim() : head.trim();
+    return {
+      complete: true,
+      summary: clean(after),
+      why: ""
+    };
+  }
   function readShare(container) {
     let videoID2 = null;
     let kind = null;
@@ -2650,10 +2673,22 @@ var DouyinPage = (() => {
     for (const anchor of anchors) {
       const id = /\/video\/(\d+)/.exec(anchor.getAttribute("href") ?? "")?.[1];
       if (!id || works.has(id)) continue;
-      works.set(id, { url: anchor.href, title: clean(anchor.textContent) });
+      const text = clean(anchor.textContent);
+      const half = text.slice(0, Math.floor(text.length / 2));
+      works.set(id, { url: anchor.href, title: half && text === half + half ? half : text });
     }
     return [...works.values()];
   }
+  function profileTabPoint(label) {
+    const entries2 = [...document.querySelectorAll('[data-e2e="user-tab-icon"]')].map((icon) => ({ icon, label: clean(icon.parentElement?.textContent) })).filter((entry2) => entry2.label === label);
+    const entry = one(entries2, `profile tab "${label}"`);
+    const box = entry.icon.getBoundingClientRect();
+    if (box.width === 0 || box.height === 0) fail("selector_changed", `The "${label}" tab is not laid out`);
+    return { x: Math.round(box.left + box.width / 2), y: Math.round(box.top + box.height / 2) };
+  }
+  function tabWorks() {
+    return readProfileWorks();
+  }
   var hoverPoint = null;
   async function execute(operation, args) {
     switch (operation) {
@@ -2934,6 +2969,10 @@ var DouyinPage = (() => {
           index
         };
       }
+      case "ai.entry.point":
+        return aiEntryPoint();
+      case "ai.summary":
+        return aiSummary();
       case "chat.detail.open":
         return findRendered(document, '[class*="messageMessageListlist"],[data-e2e="message-list"]').length > 0;
       case "chat.recall.target":
@@ -3208,6 +3247,10 @@ var DouyinPage = (() => {
       }
       case "profile.works":
         return { works: readProfileWorks().length };
+      case "profile.tab.point":
+        return profileTabPoint(args.target ?? "\u6536\u85CF");
+      case "profile.tab.works":
+        return { works: tabWorks() };
       case "user.get": {
         const id = userIdentity(args.user_id);
         const matches = find(document, '[data-e2e="user-info"],[data-e2e="user-detail"]');

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shuadouyin",
-	"version": "0.4.1",
+	"version": "0.5.0",
 	"packageManager": "pnpm@10.34.7",
 	"description": "Browse Douyin with a persistent bot persona and a memory of its own",
 	"type": "module",

package/skills/dy/references/commands.md

@@ -104,6 +104,8 @@ dy note capture --index 0 --output x.png
 
 ```bash
 dy video digest [--frames N --limit 8]    # 标题 + 采样画面 + 评论；不写 --frames 就按时长自动选
+dy video ai                              # 平台自己的 AI 对这条作品的描述
+dy video digest --ai                     # 一次拿到截图和平台描述
 dy video seek --at 120                    # 跳到第 120 秒
 dy video observe --at 200 --seconds 4 --frames 2   # 在指定位置采样
 dy video play [--video-id <id>]           # 播放
@@ -116,6 +118,10 @@ dy video audio --seconds 10 --output a.webm
 
 `--frames 0` 只读身份和评论，不采样——筛候选时用这个，比每条都截图快得多。
 
+**`video ai` 看的是平台模型写的描述，不是画面。** 它能覆盖截图覆盖不到的：整条视频发生了什么、歌词唱什么、评论区在聊什么。但它是抖音在描述自己的内容，可能错、可能空泛、可能顺着你说——所以它返回的每条都带 `limits` 说明这一点。
+
+用截图能确认的事实用 `digest`；想知道「这条到底讲了什么」用 `ai`，但引述时要说「平台的说法」，不能说成「我看到的」。`complete: false` 表示它还没写完，不要把那半段当全文。
+
 `--frames 0` 跳过所有采样只读评论（最快）；短片自动不采样并说明原因。
 
 `video.seek` 越界会**拒绝**而不是截断——传了超出时长的位置说明你猜错了时长，需要知道。
@@ -126,7 +132,8 @@ dy video audio --seconds 10 --output a.webm
 
 ```bash
 dy video like --value true|false
-dy video favorite --value true|false
+dy video favorite --video-id <id> --value true|false   # 收藏/取消
+ dy video favorites                              # 读自己的收藏列表（--tab 可换 喜欢/观看历史/稍后再看）
 dy user follow --value true|false
 ```