@xiaohhhh1/canvas-agent 0.4.78 → 0.4.80

package/dist/integrations/fastmoss-visible-evidence.d.ts

@@ -0,0 +1,52 @@
+import { type DailySale, type Period, type ProductEvidence, type Ranking, type SelectionConfig, type VideoSale } from "./fastmoss-opportunity.js";
+export type VisibleSection = {
+    url: string;
+    selector: string;
+    observedAt: string;
+    text: string;
+    blocked: string | null;
+    loading: boolean;
+    inputs: Array<{
+        value: string;
+        placeholder: string;
+        checked: boolean;
+        label: string;
+    }>;
+    links: Array<{
+        href: string;
+        text: string;
+    }>;
+    tables: Array<{
+        headers: string[];
+        rows: Array<{
+            cells: string[];
+            links: Array<{
+                href: string;
+                text: string;
+            }>;
+            images: string[];
+        }>;
+    }>;
+};
+/** Serializable DOM-only reader. Never reads app state, network responses or concealed text. */
+export declare function readVisibleSection(selector: string): VisibleSection;
+export declare function sectionPeriod(snapshot: VisibleSection, days?: number): Period | null;
+export declare function rankingProducts(snapshot: VisibleSection, ranking: Ranking, config: SelectionConfig, offset?: number): ProductEvidence[];
+export declare function dailyFromSection(snapshot: VisibleSection, days: number): DailySale[];
+export declare function overviewFromSection(snapshot: VisibleSection): ProductEvidence["overview"];
+export declare function videosFromSection(snapshot: VisibleSection, expected: Period | null): VideoSale[];
+export interface EvidenceBrowser {
+    goto(url: string): Promise<void>;
+    snapshot(selector: string): Promise<VisibleSection>;
+    clickText(selector: string, text: string, occurrence?: number): Promise<void>;
+    next(selector: string): Promise<boolean>;
+    pause(): Promise<void>;
+}
+export declare class VisibleFastMossCollector {
+    private browser;
+    constructor(browser: EvidenceBrowser);
+    private stable;
+    verifyOverview(product: ProductEvidence): Promise<ProductEvidence>;
+    discover(ranking: Ranking, config: SelectionConfig, save: (products: ProductEvidence[]) => Promise<void>): Promise<void>;
+    detail(product: ProductEvidence, config: SelectionConfig, save: (product: ProductEvidence) => Promise<void>): Promise<ProductEvidence>;
+}

package/dist/integrations/fastmoss-visible-evidence.js

@@ -0,0 +1,303 @@
+import { MARKETS, OPPORTUNITY_VERSION, RANKINGS, isoDate, matchesCategory, visibleNumber } from "./fastmoss-opportunity.js";
+/** Serializable DOM-only reader. Never reads app state, network responses or concealed text. */
+export function readVisibleSection(selector) {
+    const root = document.querySelector(selector);
+    const readability = [];
+    const readable = (element) => {
+        const cached = readability.find(([node]) => node === element);
+        if (cached)
+            return cached[1];
+        for (let node = element; node; node = node.parentElement) {
+            const style = getComputedStyle(node);
+            if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity) === 0 || /blur\((?!0px)/.test(style.filter) || node.getAttribute("aria-hidden") === "true") {
+                if (element)
+                    readability.push([element, false]);
+                return false;
+            }
+        }
+        const value = Boolean(element?.getClientRects().length);
+        if (element)
+            readability.push([element, value]);
+        return value;
+    };
+    const gateCache = [];
+    const gated = (element) => {
+        const cached = gateCache.find(([node]) => node === element);
+        if (cached)
+            return cached[1];
+        // Upgrade masks belong to their own section; the global upgrade button is not a gate.
+        const value = [...element.querySelectorAll("div,span,p")].some(n => readable(n) && /升级会员解锁|升级.*查看.*数据|仅.*会员.*查看|unlock.*(?:data|access)|sample data|演示数据/i.test([...n.childNodes].filter(c => c.nodeType === 3).map(c => c.textContent || "").join("")));
+        gateCache.push([element, value]);
+        return value;
+    };
+    const blocked = !root ? "页面区域尚未出现" : !readable(root) ? "页面区域不可见" : gated(root) && !selector.includes("dashboard-container") ? "该区域需要升级或仅展示样例，未采集" : null;
+    const empty = { url: location.href, selector, observedAt: new Date().toISOString(), text: "", blocked, loading: false, inputs: [], links: [], tables: [] };
+    if (!root || blocked)
+        return empty;
+    const inGate = (element) => {
+        for (let node = element; node && node !== root; node = node.parentElement)
+            if (node.id && gated(node))
+                return true;
+        return false;
+    };
+    const allowed = (element) => readable(element) && !inGate(element);
+    const text = (element) => {
+        if (!allowed(element))
+            return "";
+        if ([...element.querySelectorAll("*")].some(n => !allowed(n)))
+            return [...element.childNodes].map(n => n.nodeType === 3 ? n.textContent || "" : n.nodeType === 1 && "innerText" in n ? text(n) : "").join("\n");
+        return element.innerText;
+    };
+    const links = (element) => [...element.querySelectorAll("a[href]")].filter(allowed).map(a => ({ href: a.href, text: text(a) }));
+    return { ...empty, text: text(root).slice(0, 45000), loading: [...root.querySelectorAll(".ant-spin-spinning,[aria-busy=true]")].some(readable),
+        inputs: [...root.querySelectorAll("input")].filter(i => readable(i) || (i.type === "radio" && i.closest("label") && allowed(i.closest("label")))).filter(i => !inGate(i)).map(i => ({ value: i.value, placeholder: i.placeholder, checked: i.checked, label: i.closest("label") ? text(i.closest("label")) : "" })),
+        links: links(root),
+        tables: [...root.querySelectorAll("table")].filter(allowed).map(table => ({ headers: [...table.querySelectorAll("thead th")].map(h => allowed(h) ? text(h).trim() : ""), rows: [...table.querySelectorAll("tbody tr")].filter(row => allowed(row) && !row.className.includes("measure-row")).map(row => {
+                const productLink = [...row.querySelectorAll("a[href]")].find(a => /\/e-commerce\/detail\/\d+/.test(a.href));
+                return { cells: [...row.querySelectorAll("td")].map(cell => text(cell).trim()), links: links(row), images: [...(productLink?.closest("td") || row).querySelectorAll("img")].filter(allowed).map(i => i.currentSrc || i.src).filter(u => /^https:\/\//.test(u)).slice(0, 5) };
+            }) })) };
+}
+export function sectionPeriod(snapshot, days) {
+    const start = snapshot.inputs.find(i => i.placeholder === "开始日期")?.value || "";
+    const end = snapshot.inputs.find(i => i.placeholder === "结束日期")?.value || "";
+    if (!isoDate(start) || !isoDate(end) || start > end || (days && (Date.parse(end) - Date.parse(start)) / 86400000 + 1 !== days))
+        return null;
+    return { start, end, timeZone: "UTC+08:00" };
+}
+const ref = (snapshot, period) => ({ url: snapshot.url, section: snapshot.selector, observedAt: snapshot.observedAt, period });
+const cell = (headers, cells, pattern) => cells[headers.findIndex(h => pattern.test(h.replace(/\s+/g, "")))] || "";
+export function rankingProducts(snapshot, ranking, config, offset = 0) {
+    if (snapshot.blocked || snapshot.loading || new URL(snapshot.url).searchParams.get("region") !== config.market)
+        return [];
+    const result = [];
+    for (const table of snapshot.tables)
+        for (const row of table.rows) {
+            const link = row.links.find(a => /\/e-commerce\/detail\/\d+/.test(a.href));
+            const productId = link?.href.match(/\/e-commerce\/detail\/(\d+)/)?.[1];
+            if (!link || !productId)
+                continue;
+            const country = cell(table.headers, row.cells, /国家|地区|country|market/i);
+            if (country && !country.includes(config.market) && !country.includes(MARKETS[config.market]))
+                continue;
+            const title = (link.text.trim() || cell(table.headers, row.cells, /商品|product/i)).split(/\n\s*(?:售价|价格|佣金)/)[0].trim();
+            const category = cell(table.headers, row.cells, /类目|分类|category/i);
+            result.push({ version: OPPORTUNITY_VERSION, productId, market: config.market, title, url: link.href, category, storeName: cell(table.headers, row.cells, /所属店铺|店铺名称|shop/i), imageUrls: row.images,
+                discoveredAt: snapshot.observedAt, rankings: [{ source: ranking, position: visibleNumber(row.cells[0]) || offset + result.length + 1, ref: ref(snapshot, null) }], identityVerified: false, currency: null, listingDate: null, price: null, stock: null, rating: null, daily: [], videos: [], overview: null, missing: [], detailState: "pending" });
+        }
+    return [...new Map(result.map(p => [p.productId, p])).values()];
+}
+export function dailyFromSection(snapshot, days) {
+    const period = sectionPeriod(snapshot, days);
+    if (snapshot.blocked || snapshot.loading || !period)
+        return [];
+    const table = snapshot.tables.find(t => t.headers.some(h => /^(时间|日期)$/.test(h.trim())) && t.headers.some(h => h.trim() === "销量"));
+    if (!table)
+        return [];
+    return table.rows.flatMap(row => {
+        const date = cell(table.headers, row.cells, /^(时间|日期)$/).slice(0, 10);
+        if (!isoDate(date) || date < period.start || date > period.end)
+            return [];
+        return [{ date, units: visibleNumber(cell(table.headers, row.cells, /^销量$/)), ref: ref(snapshot, period) }];
+    });
+}
+export function overviewFromSection(snapshot) {
+    const period = sectionPeriod(snapshot, 7);
+    if (snapshot.blocked || snapshot.loading || !period)
+        return null;
+    const share = (pattern) => { const value = visibleNumber(snapshot.text.match(pattern)?.[1]); return value !== null && value <= 100 ? value : null; };
+    const unitsText = snapshot.inputs.find(i => i.value === "sold_count_show")?.label.trim().split("\n").filter(Boolean)[0] || "";
+    const compact = unitsText.match(/\d+(?:\.(\d+))?(万|亿|[kKmMbB])$/);
+    const factors = { 万: 1e4, 亿: 1e8, k: 1e3, m: 1e6, b: 1e9 };
+    // FastMoss abbreviates by truncation too (26491 appears as 2.64万).
+    // Allow one displayed unit of precision, never a blanket percentage.
+    const unitsTolerance = compact ? factors[compact[2].toLowerCase()] / 10 ** (compact[1]?.length || 0) : 0;
+    return { ref: ref(snapshot, period), units: visibleNumber(unitsText), unitsTolerance, videoShare: share(/(?:^|\n)视频\s*\n\s*([\d.]+%)/), liveShare: share(/(?:^|\n)直播\s*\n\s*([\d.]+%)/), adShare: share(/广告投放[（(]视频[）)]\s*\n\s*([\d.]+%)/), otherShare: share(/其他流量\s*\n\s*([\d.]+%)/) };
+}
+export function videosFromSection(snapshot, expected) {
+    if (snapshot.blocked || snapshot.loading || !expected)
+        return [];
+    const publishedPeriod = sectionPeriod(snapshot, 7);
+    if (!publishedPeriod || publishedPeriod.start !== expected.start || publishedPeriod.end !== expected.end)
+        return [];
+    // Dates in this section belong to publication filtering. Transaction dates are
+    // aligned independently through the selected first period group + column label.
+    const firstSelected = snapshot.inputs.find(i => i.checked && /^近\d+天$/.test(i.label.trim()));
+    if (firstSelected?.label.trim() !== "近7天")
+        return [];
+    const table = snapshot.tables.find(t => t.headers.some(h => /^销量\(近7天\)$/.test(h.replace(/\s/g, ""))));
+    if (!table)
+        return [];
+    return table.rows.flatMap(row => {
+        const link = row.links.find(a => /\/media-source\/video\/\d+/.test(a.href));
+        const id = link?.href.match(/\/media-source\/video\/(\d+)/)?.[1];
+        if (!id || !link)
+            return [];
+        const creator = row.links.find(a => /\/(?:influencer|author)\/detail\/\d+/.test(a.href));
+        return [{ id, url: link.href, creatorId: creator?.href.match(/\/detail\/(\d+)/)?.[1] || null, creatorName: row.cells[0]?.split("\n").filter(Boolean).at(-1) || "", published: cell(table.headers, row.cells, /视频发布时间/).slice(0, 10), units: visibleNumber(cell(table.headers, row.cells, /^销量\(近7天\)$/)), ad: /\bAds\b/.test(row.cells[0] || "") ? true : null, ref: ref(snapshot, expected) }];
+    });
+}
+export class VisibleFastMossCollector {
+    browser;
+    constructor(browser) {
+        this.browser = browser;
+    }
+    async stable(selector, accept) {
+        let previous = "", stableReads = 0;
+        const deadline = Date.now() + 25_000;
+        for (let attempt = 0; attempt < 200 && Date.now() < deadline; attempt++) {
+            const snapshot = await this.browser.snapshot(selector);
+            if (snapshot.blocked && snapshot.blocked !== "页面区域尚未出现")
+                throw new Error(snapshot.blocked);
+            const signature = JSON.stringify([snapshot.text, snapshot.inputs, snapshot.tables]);
+            stableReads = !snapshot.loading && accept(snapshot) && signature === previous ? stableReads + 1 : 0;
+            if (stableReads >= 2)
+                return snapshot;
+            previous = signature;
+            await this.browser.pause();
+        }
+        throw new Error("页面未稳定或时间范围未核实，已保留此前数据");
+    }
+    async verifyOverview(product) {
+        let latest = null;
+        let snapshot;
+        try {
+            snapshot = await this.stable("#overview", s => {
+                const overview = overviewFromSection(s);
+                if (!overview || overview.units === null || overview.units === undefined)
+                    return false;
+                latest = s;
+                const dates = [...new Map(product.daily.filter(d => d.date >= overview.ref.period.start && d.date <= overview.ref.period.end).map(d => [d.date, d])).values()];
+                return dates.length === 7 && dates.every(d => d.units !== null) && Math.abs(dates.reduce((sum, d) => sum + d.units, 0) - overview.units) <= (overview.unitsTolerance || 0);
+            });
+        }
+        catch (error) {
+            if (!latest)
+                throw error;
+            // A stable source discrepancy is an observation, not a reason to keep
+            // failing the whole product forever. The evaluator blocks recommendation.
+            snapshot = latest;
+            product.missing.push("7天汇总未与逐日合计对齐，保留可见数值待复核");
+        }
+        product.overview = overviewFromSection(snapshot);
+        product.price = visibleNumber(snapshot.inputs.find(i => i.value === "price")?.label.trim().split("\n").filter(Boolean)[0]);
+        product.priceBasis = "7天成交均价";
+        return product;
+    }
+    async discover(ranking, config, save) {
+        await this.browser.goto(`https://www.fastmoss.com/zh/e-commerce/${RANKINGS[ranking]}?region=${config.market}&page=1`);
+        const seen = new Set();
+        const sourceIndex = ["sales", "new", "hot", "video"].indexOf(ranking);
+        const target = Math.floor(config.candidateLimit / 4) + (sourceIndex < config.candidateLimit % 4 ? 1 : 0);
+        let previous = "";
+        // Categories are filtered on observed row text; never claim a hidden site filter was applied.
+        for (let page = 0; page < 5 && seen.size < target; page++) {
+            const snapshot = await this.stable("#dashboard-container-zh", s => rankingProducts(s, ranking, config).length > 0 && JSON.stringify(s.tables) !== previous);
+            const products = rankingProducts(snapshot, ranking, config, page * 10).filter(p => matchesCategory(p.category, config));
+            const fresh = products.filter(p => !seen.has(p.productId)).slice(0, target - seen.size);
+            for (const product of fresh)
+                seen.add(product.productId);
+            if (fresh.length)
+                await save(fresh);
+            previous = JSON.stringify(snapshot.tables);
+            if (seen.size >= target || !(await this.browser.next("#dashboard-container-zh")))
+                break;
+        }
+    }
+    async detail(product, config, save) {
+        await this.browser.goto(product.url);
+        const head = await this.stable("#dashboard-container-zh", s => s.text.includes("预估上架日期") && s.text.includes("数据总览"));
+        const text = head.text.split("数据总览")[0];
+        product.identityVerified = head.url.includes(`/detail/${product.productId}`) && text.includes(`${MARKETS[config.market]}销量榜`);
+        if (!product.identityVerified)
+            throw new Error("详情页未核实国家与商品身份");
+        product.listingDate = text.match(/预估上架日期[：:]?\s*(\d{4}-\d{2}-\d{2})/)?.[1] || null;
+        const priceText = text.match(/价格[：:]\s*([^\n]+)/)?.[1] || "";
+        product.price = visibleNumber(priceText);
+        product.currency = priceText.match(/MX\$|R\$|RM|Rp|US\$|[$€£฿¥₱₫]/)?.[0] || null;
+        product.stockText = text.match(/(?:^|\n)库存[：:]\s*([^\n]+)/)?.[1] || "";
+        product.stock = visibleNumber(product.stockText);
+        product.rating = visibleNumber(text.match(/(?:^|\n)([\d.]+)\s*\/\s*5\s*评论数/)?.[1]);
+        product.reviewCount = visibleNumber(text.match(/评论数[：:]?\s*([^\n]+)/)?.[1]);
+        if (product.reviewCount === 0)
+            product.rating = null;
+        product.error = undefined;
+        product.missing = [];
+        await save(product);
+        for (const days of [7, config.opportunity === "emerging" ? 28 : 90]) {
+            try {
+                await this.browser.clickText("#overview label", `近${days}天`);
+                let snapshot = await this.stable("#overview", s => Boolean(sectionPeriod(s, days)) && s.inputs.some(i => i.checked && i.label.trim() === `近${days}天`));
+                if (days === 7) {
+                    product.overview = overviewFromSection(snapshot);
+                    const averagePrice = snapshot.inputs.find(i => i.value === "price")?.label.trim().split("\n").filter(Boolean)[0];
+                    product.price = visibleNumber(averagePrice);
+                    product.priceBasis = "7天成交均价";
+                    await save(product);
+                }
+                const period = sectionPeriod(snapshot, days);
+                const savedDates = new Set(product.daily.filter(d => d.units !== null && d.ref.period?.start === period.start && d.ref.period?.end === period.end).map(d => d.date));
+                if (savedDates.size === days) {
+                    if (days === 7) {
+                        await this.verifyOverview(product);
+                        await save(product);
+                    }
+                    continue;
+                }
+                if (!snapshot.tables.some(t => t.headers.includes("时间")))
+                    await this.browser.clickText("#overview", "查看表格");
+                let previous = "";
+                for (let page = 0; page < 24; page++) {
+                    snapshot = await this.stable("#overview", s => dailyFromSection(s, days).length > 0 && JSON.stringify(s.tables) !== previous);
+                    const points = dailyFromSection(snapshot, days);
+                    // Retain 7-day and historical observations separately so conflicting
+                    // same-day snapshots remain detectable instead of being overwritten.
+                    product.daily.push(...points);
+                    await save(product);
+                    previous = JSON.stringify(snapshot.tables);
+                    if (!(await this.browser.next("#overview")))
+                        break;
+                }
+                if (days === 7) {
+                    await this.verifyOverview(product);
+                    await save(product);
+                }
+            }
+            catch (error) {
+                product.missing.push(`${days}天总览：${error instanceof Error ? error.message : String(error)}`);
+                await save(product);
+            }
+        }
+        try {
+            // FastMoss mounts lower detail sections only after they enter view.
+            await this.browser.clickText("#dashboard-container-zh", "商品关联视频");
+            await this.stable("#related_videos", s => s.inputs.some(i => /^近7天$/.test(i.label.trim())));
+            await this.browser.clickText("#related_videos label", "近7天", 0);
+            await this.browser.clickText("#related_videos label", "近7天", 1);
+            const expected = product.overview?.ref.period || null;
+            const snapshot = await this.stable("#related_videos", s => (videosFromSection(s, expected).length > 0 || /暂无数据|No data/i.test(s.text)) && s.inputs.filter(i => i.checked && i.label.trim() === "近7天").length === 2);
+            product.videos = videosFromSection(snapshot, expected);
+            if (!product.videos.length)
+                product.missing.push("所选窗口关联视频显示暂无数据，缺少近期新视频成交证据");
+            await save(product);
+            for (const video of product.videos.slice(0, 5)) {
+                try {
+                    await this.browser.goto(video.url);
+                    const detail = await this.stable("#dashboard-container-zh", s => s.links.some(l => /\/(?:influencer|author)\/detail\/\d+/.test(l.href)));
+                    const link = detail.links.find(l => /\/(?:influencer|author)\/detail\/\d+/.test(l.href));
+                    video.creatorId = link?.href.match(/\/detail\/(\d+)/)?.[1] || null;
+                    await save(product);
+                }
+                catch {
+                    product.missing.push(`视频 ${video.id} 的达人ID未核实`);
+                }
+            }
+        }
+        catch (error) {
+            product.missing.push(`近期视频：${error instanceof Error ? error.message : String(error)}`);
+        }
+        await save(product);
+        if (product.missing.some(m => /未稳定|deadline|超时|Timeout|selector/i.test(m)))
+            throw new Error("部分详情未完成，已保存可用证据，可继续复核");
+        return product;
+    }
+}

package/dist/integrations/fastmoss.d.ts

@@ -1,4 +1,6 @@
 import { type Response } from "playwright-core";
+import { FastMossSelectionSessions } from "./fastmoss-selection-session.js";
+import type { SelectionConfig } from "./fastmoss-opportunity.js";
 export type FastMossRankingSource = "new" | "hot" | "video" | "sales";
 export type FastMossPhase = "idle" | "saved" | "launching" | "login_required" | "ready" | "verification_required" | "membership_expired" | "error";
 export type FastMossStatus = {
@@ -55,11 +57,54 @@ export declare class FastMossIntegration {
     private readonly profileDir;
     private readonly authenticatedMarker;
     private readonly dataDir;
+    private selectionPage;
+    readonly selection: FastMossSelectionSessions;
     private savedAuthenticated;
     private observedVideoRecords;
     private videoResponseTasks;
     private observedVideoPages;
     constructor();
+    startSelection(id: string, config: Partial<SelectionConfig>, resume?: boolean): Promise<{
+        candidates: {
+            source: string;
+            sourceProductId: string;
+            platformProductId: string;
+            title: string;
+            market: string;
+            category: string;
+            storeName: string;
+            productUrl: string;
+            imageUrls: string[];
+            metrics: {
+                strategy: "fastmoss-evidence-v2";
+                selectionSessionId: string;
+                selectionDecision: "test" | "watch" | "skip";
+                selectionEligible: boolean;
+                portfolioSelected: boolean;
+                selectionReasons: string[];
+                selectionRisks: string[];
+                sales: number | null;
+                growthPercent: number | null;
+                price: number | null;
+                currency: string | null;
+                captureDate: string;
+                sourceVerified: boolean;
+                opportunityAssessment: import("./fastmoss-opportunity.js").Assessment;
+                opportunityEvidence: import("./fastmoss-opportunity.js").ProductEvidence;
+            };
+        }[];
+        id: string;
+        config: SelectionConfig;
+        createdAt: string;
+        updatedAt: string;
+        phase: "collecting" | "reviewing" | "complete" | "interrupted";
+        active: boolean;
+        completedRankings: import("./fastmoss-opportunity.js").Ranking[];
+        rankingErrors: Partial<Record<import("./fastmoss-opportunity.js").Ranking, string>>;
+        products: import("./fastmoss-opportunity.js").ProductEvidence[];
+        error?: string;
+    } | null>;
+    private selectionBrowser;
     status(): FastMossStatus;
     start(): Promise<FastMossStatus>;
     inspect(): Promise<FastMossStatus>;

package/dist/integrations/fastmoss.js

@@ -4,6 +4,8 @@ import os from "node:os";
 import path from "node:path";
 import { chromium } from "playwright-core";
 import { CONFIG_DIR } from "../config.js";
+import { FastMossSelectionSessions } from "./fastmoss-selection-session.js";
+import { VisibleFastMossCollector, readVisibleSection } from "./fastmoss-visible-evidence.js";
 const FASTMOSS_HOME = "https://www.fastmoss.com/";
 const MEMBERSHIP_RECHECK_MS = 5 * 60_000;
 const MANUAL_VERIFICATION_TIMEOUT_MS = 10 * 60_000;
@@ -37,6 +39,11 @@ export class FastMossIntegration {
     profileDir = path.join(CONFIG_DIR, "fastmoss-session");
     authenticatedMarker = path.join(this.profileDir, "authenticated.json");
     dataDir = path.join(CONFIG_DIR, "fastmoss-selection");
+    selectionPage = null;
+    selection = new FastMossSelectionSessions(path.join(this.dataDir, "sessions-v2"), {
+        discover: async (ranking, config, save) => new VisibleFastMossCollector(await this.selectionBrowser()).discover(ranking, config, save),
+        detail: async (product, config, save) => new VisibleFastMossCollector(await this.selectionBrowser()).detail(product, config, save),
+    });
     savedAuthenticated = existsSync(this.authenticatedMarker);
     observedVideoRecords = [];
     videoResponseTasks = new Set();
@@ -48,6 +55,40 @@ export class FastMossIntegration {
         this.authenticated = true;
         this.message = "FastMoss 登录已保存在本机；窗口可以关闭，抓取时会自动恢复";
     }
+    async startSelection(id, config, resume = false) {
+        return this.selection.start(id, config, resume);
+    }
+    async selectionBrowser() {
+        if (!this.context)
+            await this.start();
+        if (!this.context)
+            throw new Error("FastMoss 本机浏览器未启动");
+        if (!this.selectionPage || this.selectionPage.isClosed())
+            this.selectionPage = await this.context.newPage();
+        const page = this.selectionPage;
+        return {
+            goto: async (url) => {
+                const parsed = new URL(url);
+                if (parsed.protocol !== "https:" || parsed.hostname !== "www.fastmoss.com")
+                    throw new Error("商品证据地址不是 FastMoss 页面");
+                await page.goto(url, { waitUntil: "domcontentloaded", timeout: 45_000 });
+            },
+            snapshot: selector => page.evaluate(readVisibleSection, selector),
+            clickText: async (selector, text, occurrence = 0) => {
+                const scope = page.locator(selector);
+                const matches = selector.endsWith(" label") ? scope.filter({ hasText: new RegExp(`^${text}$`) }) : scope.getByText(text, { exact: true });
+                await matches.nth(occurrence).click({ timeout: 15_000 });
+            },
+            next: async (selector) => {
+                const next = page.locator(`${selector} .ant-pagination-next`).first();
+                if (!(await next.count()) || await next.getAttribute("aria-disabled") === "true" || (await next.getAttribute("class"))?.includes("ant-pagination-disabled"))
+                    return false;
+                await next.click({ timeout: 10_000 });
+                return true;
+            },
+            pause: () => page.waitForTimeout(600),
+        };
+    }
     status() {
         return {
             phase: this.phase,
@@ -172,6 +213,8 @@ export class FastMossIntegration {
         return this.status();
     }
     async capture(input = {}) {
+        if (this.selection.isRunning())
+            throw new Error("新版选品正在采集，请等待完成");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         await this.inspect();
@@ -280,6 +323,8 @@ export class FastMossIntegration {
      * private FastMoss API requests and pauses for the operator when a CAPTCHA appears.
      */
     async captureLearningVideos(input = {}) {
+        if (this.selection.isRunning())
+            throw new Error("选品正在使用 FastMoss，请等待完成后再采集素材");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         await this.inspect();
@@ -385,6 +430,8 @@ export class FastMossIntegration {
         return { ...this.status(), sources, rejected, requestedTarget, complete: sources.length >= requestedTarget };
     }
     async close() {
+        if (this.selection.isRunning())
+            throw new Error("选品正在保存数据，请等待完成后关闭浏览器");
         const context = this.context;
         this.context = null;
         this.page = null;
@@ -500,6 +547,8 @@ export class FastMossIntegration {
         }
     }
     async switchAccount() {
+        if (this.selection.isRunning())
+            throw new Error("选品尚未完成，请等待完成后更换账号");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         this.useLatestPage();

package/dist/server/http.js

@@ -133,7 +133,10 @@ export function startHttpServer() {
         await openExternalUrl(url.toString());
         res.json({ ok: true });
     }));
-    app.get("/agent/integrations/fastmoss/status", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.inspect() })));
+    app.get("/agent/integrations/fastmoss/status", route(async (_req, res) => res.json({ ok: true, ...(fastmoss.selection.isRunning() ? fastmoss.status() : await fastmoss.inspect()) })));
+    app.get("/agent/integrations/fastmoss/selection", route(async (_req, res) => res.json({ ok: true, session: await fastmoss.selection.get() })));
+    app.get("/agent/integrations/fastmoss/selection/:sessionId", route(async (req, res) => res.json({ ok: true, session: await fastmoss.selection.get(routeParam(req.params.sessionId)) })));
+    app.post("/agent/integrations/fastmoss/selection", route(async (req, res) => res.json({ ok: true, session: await fastmoss.startSelection(String(req.body?.sessionId || ""), req.body?.config || {}, req.body?.resume === true) })));
     app.get("/agent/integrations/fastmoss/observations", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.observations() })));
     app.post("/agent/integrations/fastmoss/start", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.start() })));
     app.post("/agent/integrations/fastmoss/refresh", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.inspect() })));

package/dist/workflow/content-method.d.ts

@@ -1,4 +1,7 @@
 export declare const FLOW_C_CONTENT_STRATEGY_VERSION = "flow-c-content-strategy-v1";
+export declare const FLOW_C_GENERATED_MONTAGE_VERSION = "flow-c-generated-montage-v1";
+export declare const FLOW_C_GENERATED_MONTAGE_STYLE = "generated-montage";
+export declare const FLOW_C_GENERATED_MONTAGE_VERSION_UNSUPPORTED = "FLOW_C_GENERATED_MONTAGE_VERSION_UNSUPPORTED";
 export type FlowCContentStrategy = {
     contractVersion: typeof FLOW_C_CONTENT_STRATEGY_VERSION;
     mode: "smart-diverse" | "best-match";
@@ -27,7 +30,7 @@ export type FlowCContentSummary = {
 };
 export type FlowCContentAdvisory = {
     ordinal: number;
-    code: "voice_pacing" | "ending_frame_unanchored" | "repeated_opening";
+    code: "voice_pacing" | "voice_without_visible_evidence" | "ending_frame_unanchored" | "repeated_opening";
     segment?: number;
     shot?: number;
     wordCount?: number;
@@ -35,6 +38,14 @@ export type FlowCContentAdvisory = {
     durationSeconds?: number;
     matchedOrdinal?: number;
 };
+/** Explicit styles are capability-versioned; an unknown pair must never silently fall back. */
+export declare function flowCGeneratedMontage(value: unknown): boolean;
+/** A short same-turn writing/review sequence. It never creates another model stage or output field. */
+export declare function flowCContentWritingReviewPrompt(strategy: FlowCContentStrategy | null, options: {
+    frameworkOrdinals: readonly number[];
+}): string;
+/** Rules for the separately selected generated-montage content style. */
+export declare function flowCGeneratedMontagePrompt(ordinals: readonly number[]): string;
 /** Missing/unknown versions keep historical tasks on their exact original prompt. */
 export declare function flowCContentStrategy(value: unknown): FlowCContentStrategy | null;
 export declare function flowCContentDirection(value: unknown, strategy: FlowCContentStrategy | null): FlowCContentDirection | null;
@@ -52,4 +63,5 @@ export declare function flowCContentMethodPrompt(strategy: FlowCContentStrategy
     productIndexes: number[];
     ordinals: number[];
     frameworkOrdinals: number[];
+    montageOrdinals?: number[];
 }): string;