@xiaohhhh1/canvas-agent 0.4.79 → 0.4.81

package/dist/agent/codex.d.ts

@@ -48,6 +48,7 @@ export declare function flowCCodexWorkerStatus(): {
     active: number;
     limit: number;
 };
+export declare function boundedWorkflowProcessAttempts(value?: number): number;
 /**
  * 记录尚未确认 OS exit 的 worker 进程。worker 可以释放给队列，但在对应
  * barrier 完成前只能等待/失败，绝不能启动替代 app-server。
@@ -70,6 +71,7 @@ export declare function interruptCodexTurn(threadId?: string): Promise<boolean>;
 export declare function runCodexWorkflowTurn(prompt: string, emit: AgentEmit, options: CodexRunOptions & {
     timeoutMs: number;
     attachments?: AgentAttachment[];
+    maxProcessAttempts?: number;
     onWorkerStart?: () => void;
     onWorkerFinish?: () => void;
 }): Promise<CodexWorkflowRunResult>;

package/dist/agent/codex.js

@@ -12,6 +12,11 @@ export const FLOW_C_CODEX_WORKER_CONCURRENCY = boundedWorkerConcurrency(process.
 export const FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS = 3;
 const FLOW_C_CODEX_MIN_START_BUDGET_MS = 5_000;
 export function flowCCodexWorkerStatus() { return { active: workflowCodexPool.activeCount, limit: FLOW_C_CODEX_WORKER_CONCURRENCY }; }
+export function boundedWorkflowProcessAttempts(value) {
+    if (value === undefined)
+        return FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS;
+    return Math.max(1, Math.min(FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS, Math.floor(Number(value) || 1)));
+}
 let codexQueue = Promise.resolve();
 let codexApp = null;
 let codexAppStart = null;
@@ -88,6 +93,7 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
         let modelMs = 0;
         let app;
         let processAttempts = 0;
+        const processMaxAttempts = boundedWorkflowProcessAttempts(options.maxProcessAttempts);
         let processRecoveryObserved = false;
         let cleanupConfirmed = true;
         let files = [];
@@ -136,17 +142,17 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
                         threadStartMs += Date.now() - attemptStartedAt;
                 }
             }, {
-                maxAttempts: FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS,
+                maxAttempts: processMaxAttempts,
                 backoffMs: (failedAttempt) => Math.max(0, Math.min(failedAttempt === 1 ? 250 : 750, deadlineAt - Date.now())),
                 onRetry: async (error, failedAttempt) => {
                     processRecoveryObserved = true;
-                    cleanupConfirmed = await discardWorkflowCodexApp(workerIndex, app, `Flow C 本机脚本引擎第 ${failedAttempt}/${FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS} 次进程异常，正在换新进程重试`);
+                    cleanupConfirmed = await discardWorkflowCodexApp(workerIndex, app, `Flow C 本机脚本引擎第 ${failedAttempt}/${processMaxAttempts} 次进程异常，正在换新进程重试`);
                     app = undefined;
                     if (!cleanupConfirmed)
                         throw error;
                     if (deadlineAt - Date.now() < FLOW_C_CODEX_MIN_START_BUDGET_MS)
                         throw new CodexWorkflowTimeoutError();
-                    emit("agent_log", { text: `Flow C 本机脚本引擎异常，已回收当前 worker，将进行第 ${failedAttempt + 1}/${FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS} 次尝试（${error.message}）` });
+                    emit("agent_log", { text: `Flow C 本机脚本引擎异常，已回收当前 worker，将进行第 ${failedAttempt + 1}/${processMaxAttempts} 次尝试（${error.message}）` });
                 },
             });
             return { ok: true, text, timings: { queueWaitMs, threadStartMs, modelMs } };
@@ -167,7 +173,7 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
             let message = deadlineAfterProcessFailure
                 ? `本机 Codex 脚本引擎进程异常后未能在原 8 分钟截止时间内完成恢复，已停止当前任务：${rawMessage}`
                 : transportFailure
-                    ? `本机 Codex 脚本引擎已自动尝试 ${Math.max(1, processAttempts)}/${FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS} 次仍失败：${rawMessage}`
+                    ? `本机 Codex 脚本引擎已自动尝试 ${Math.max(1, processAttempts)}/${processMaxAttempts} 次仍失败：${rawMessage}`
                     : timeoutFailure ? "Flow C 脚本执行链路超过 8 分钟，已自动终止当前 worker" : rawMessage;
             if ((processFailure || timeoutFailure) && app) {
                 cleanupConfirmed = await discardWorkflowCodexApp(workerIndex, app, "Flow C 脚本执行结束，正在确认当前 worker 已退出", timeoutFailure);

package/dist/integrations/fastmoss-opportunity.d.ts

@@ -0,0 +1,160 @@
+/** V2 uses visible, dated product evidence. The historical 6.9 selector is separate. */
+export declare const OPPORTUNITY_VERSION: "fastmoss-evidence-v2";
+export declare const MARKETS: {
+    MX: string;
+    US: string;
+    GB: string;
+    BR: string;
+    DE: string;
+    ES: string;
+    FR: string;
+    IT: string;
+    ID: string;
+    TH: string;
+    VN: string;
+    PH: string;
+    MY: string;
+    JP: string;
+    SG: string;
+    AT: string;
+    BE: string;
+    NL: string;
+    PL: string;
+    PT: string;
+};
+export type Ranking = "sales" | "new" | "hot" | "video";
+export declare const RANKINGS: Record<Ranking, string>;
+export type SelectionConfig = {
+    market: string;
+    categories: string[]; /** Legacy single-category sessions. */
+    category?: string;
+    opportunity: "all" | "emerging" | "rebound";
+    candidateLimit: number;
+    detailLimit: number;
+};
+type CategoryScope = Pick<Partial<SelectionConfig>, "categories" | "category">;
+export declare function selectionCategories(input: CategoryScope): string[];
+/** Match any selected visible category keyword; an empty scope means all categories. */
+export declare function matchesCategory(category: string, config: CategoryScope): boolean;
+export type Period = {
+    start: string;
+    end: string;
+    timeZone: string;
+};
+export type EvidenceRef = {
+    url: string;
+    section: string;
+    observedAt: string;
+    period: Period | null;
+};
+export type DailySale = {
+    date: string;
+    units: number | null;
+    ref: EvidenceRef;
+};
+export type VideoSale = {
+    id: string;
+    url: string;
+    creatorId: string | null;
+    creatorName: string;
+    published: string;
+    units: number | null;
+    ad: boolean | null;
+    ref: EvidenceRef;
+};
+export type ProductEvidence = {
+    version: typeof OPPORTUNITY_VERSION;
+    productId: string;
+    market: string;
+    title: string;
+    url: string;
+    category: string;
+    storeName: string;
+    imageUrls: string[];
+    discoveredAt: string;
+    rankings: Array<{
+        source: Ranking;
+        position: number;
+        ref: EvidenceRef;
+    }>;
+    identityVerified: boolean;
+    currency: string | null;
+    listingDate: string | null;
+    price: number | null;
+    stock: number | null;
+    rating: number | null;
+    priceBasis?: "7天成交均价";
+    stockText?: string;
+    reviewCount?: number | null;
+    daily: DailySale[];
+    videos: VideoSale[];
+    overview: {
+        ref: EvidenceRef;
+        units?: number | null;
+        unitsTolerance?: number;
+        videoShare: number | null;
+        liveShare: number | null;
+        adShare: number | null;
+        otherShare: number | null;
+    } | null;
+    missing: string[];
+    detailState: "pending" | "running" | "complete" | "failed";
+    error?: string;
+};
+export type Assessment = {
+    decision: "test" | "watch" | "skip";
+    opportunity: "emerging" | "rebound" | "unconfirmed";
+    reasons: string[];
+    risks: string[];
+    missing: string[];
+    cutoff: string | null;
+    recentUnits: number | null;
+    previousUnits: number | null;
+    growthPercent: number | null;
+    increment: number | null;
+    newVideoUnits: number | null;
+    newVideoCount: number;
+    convertingCreators: number;
+    topCreatorShare: number | null;
+    reboundWindows: Array<{
+        start: string;
+        end: string;
+        units: number;
+    }>;
+};
+export declare function selectionConfig(input: Partial<SelectionConfig>): SelectionConfig;
+/** Missing, rounded lower bounds and ranges must never silently become exact zero. */
+export declare function visibleNumber(value: unknown): number | null;
+export declare const isoDate: (value: string) => boolean;
+export declare const dayOffset: (date: string, days: number) => string;
+export declare const samePeriod: (a: Period | null, b: Period | null) => boolean;
+export declare function assessOpportunity(product: ProductEvidence, config: SelectionConfig, now?: Date): Assessment;
+export declare function opportunityCandidate(product: ProductEvidence, config: SelectionConfig, sessionId: string): {
+    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: Assessment;
+        opportunityEvidence: ProductEvidence;
+    };
+};
+export {};

package/dist/integrations/fastmoss-opportunity.js

@@ -0,0 +1,183 @@
+/** V2 uses visible, dated product evidence. The historical 6.9 selector is separate. */
+export const OPPORTUNITY_VERSION = "fastmoss-evidence-v2";
+export const MARKETS = { MX: "墨西哥", US: "美国", GB: "英国", BR: "巴西", DE: "德国", ES: "西班牙", FR: "法国", IT: "意大利", ID: "印度尼西亚", TH: "泰国", VN: "越南", PH: "菲律宾", MY: "马来西亚", JP: "日本", SG: "新加坡", AT: "奥地利", BE: "比利时", NL: "荷兰", PL: "波兰", PT: "葡萄牙" };
+export const RANKINGS = { sales: "saleslist", new: "newProducts", hot: "hotlist", video: "hotvideo" };
+export function selectionCategories(input) {
+    const values = input.categories === undefined ? [input.category || ""] : input.categories;
+    if (!Array.isArray(values) || values.some(value => typeof value !== "string"))
+        throw new Error("类目须为文字列表");
+    const categories = [...new Set(values.map(value => value.trim().replace(/\s+/g, " ").toLowerCase()).filter(Boolean))].sort();
+    if (categories.some(value => value.length > 100))
+        throw new Error("每个类目关键词最多100字");
+    return categories;
+}
+/** Match any selected visible category keyword; an empty scope means all categories. */
+export function matchesCategory(category, config) {
+    const categories = selectionCategories(config), visible = category.trim().replace(/\s+/g, " ").toLowerCase();
+    return !categories.length || categories.some(keyword => visible.includes(keyword));
+}
+export function selectionConfig(input) {
+    const market = String(input.market || "MX").toUpperCase();
+    if (!(market in MARKETS))
+        throw new Error("请选择支持的具体国家");
+    const opportunity = input.opportunity || "all";
+    if (!["all", "emerging", "rebound"].includes(opportunity))
+        throw new Error("选品方向无效");
+    const bounded = (value, fallback, max) => {
+        if (value === undefined)
+            return fallback;
+        if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > max)
+            throw new Error("采集数量超出范围");
+        return value;
+    };
+    const candidateLimit = bounded(input.candidateLimit, 30, 100);
+    if (candidateLimit < 4)
+        throw new Error("四榜采集的候选数量上限至少为4");
+    return { market, categories: selectionCategories(input), opportunity, candidateLimit, detailLimit: Math.min(candidateLimit, bounded(input.detailLimit, 10, 30)) };
+}
+/** Missing, rounded lower bounds and ranges must never silently become exact zero. */
+export function visibleNumber(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) && value >= 0 ? value : null;
+    if (typeof value !== "string")
+        return null;
+    const raw = value.trim().replace(/,/g, "");
+    if (!raw || /[+<>~～]|\d\s*[-–—]\s*\d|解锁|升级|示例|演示/.test(raw))
+        return null;
+    const match = raw.match(/^(?:(?:MX\$|R\$|RM|Rp|US\$|USD|MXN|GBP|EUR|BRL|SGD|PHP|IDR|THB|MYR|VND|JPY)|[$€£฿¥₱₫])?\s*(\d+(?:\.\d+)?)\s*(亿|万|[kKmMbB])?%?$/);
+    if (!match)
+        return null;
+    const factors = { 亿: 1e8, 万: 1e4, k: 1e3, m: 1e6, b: 1e9 };
+    return Number(match[1]) * (factors[String(match[2] || "").toLowerCase()] || 1);
+}
+export const isoDate = (value) => /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
+export const dayOffset = (date, days) => new Date(Date.parse(date) + days * 86400000).toISOString().slice(0, 10);
+export const samePeriod = (a, b) => Boolean(a && b && a.start === b.start && a.end === b.end && a.timeZone === b.timeZone);
+export function assessOpportunity(product, config, now = new Date()) {
+    const reasons = [], risks = [], missing = [...product.missing];
+    const belongs = (reference) => { try {
+        const url = new URL(reference.url);
+        return url.hostname === "www.fastmoss.com" && url.pathname.endsWith(`/e-commerce/detail/${product.productId}`);
+    }
+    catch {
+        return false;
+    } };
+    const valid = product.daily.filter(p => belongs(p.ref) && isoDate(p.date) && p.units !== null && p.units >= 0 && p.ref.period && p.date >= p.ref.period.start && p.date <= p.ref.period.end);
+    const byDate = new Map();
+    for (const point of valid) {
+        const previous = byDate.get(point.date);
+        if (previous && previous.units !== point.units)
+            missing.push("同一天销量快照不一致，需复核");
+        if (!previous || point.ref.observedAt > previous.ref.observedAt)
+            byDate.set(point.date, point);
+    }
+    const cutoff = [...byDate.keys()].sort().at(-1) || null;
+    const window = (end, length) => Array.from({ length }, (_, i) => byDate.get(dayOffset(end, i - length + 1)));
+    const sum = (points) => points.every((p) => Boolean(p && p.units !== null)) && new Set(points.map(p => p.ref.period.timeZone)).size === 1 ? points.reduce((total, p) => total + p.units, 0) : null;
+    const current = cutoff ? window(cutoff, 7) : [];
+    const recentUnits = current.length ? sum(current) : null;
+    const previousUnits = cutoff && sum(window(cutoff, 14)) !== null ? sum(window(dayOffset(cutoff, -7), 7)) : null;
+    const increment = recentUnits !== null && previousUnits !== null ? recentUnits - previousUnits : null;
+    const growthPercent = increment !== null && previousUnits > 0 ? increment / previousUnits * 100 : null;
+    if (recentUnits === null)
+        missing.push("缺少连续7天可见日销量");
+    if (previousUnits === null)
+        missing.push("缺少前一可比7天，不能确认周增长");
+    if (recentUnits !== null)
+        reasons.push(`最近7天 ${recentUnits} 单`);
+    if (increment !== null)
+        reasons.push(`比前7天${increment >= 0 ? "增加" : "减少"} ${Math.abs(increment)} 单${growthPercent !== null ? `（${growthPercent.toFixed(1)}%）` : "（前期为0，不计算百分比）"}`);
+    const fresh = Boolean(cutoff && Date.parse(cutoff) <= now.getTime() && now.getTime() - Date.parse(cutoff) < 4 * 86400000);
+    if (!fresh)
+        missing.push("数据截止日期缺失或已超过3天，需刷新");
+    const previousAverage = previousUnits === null ? null : previousUnits / 7;
+    const sustained = recentUnits !== null && previousAverage !== null && current.slice(-3).every(p => p.units > previousAverage);
+    const rising = increment !== null && increment > 0 && sustained;
+    if (!sustained && increment !== null && increment > 0)
+        risks.push("尚未连续3天高于前周日均，可能受单日尖峰影响");
+    if (current.length && recentUnits && Math.max(...current.map(p => p?.units || 0)) / recentUnits > 0.5)
+        risks.push("超过一半周销量集中在一天");
+    const recentPeriod = cutoff && current[0]?.ref.period ? { start: dayOffset(cutoff, -6), end: cutoff, timeZone: current[0].ref.period.timeZone } : null;
+    const videos = [...new Map(product.videos.filter(v => belongs(v.ref) && samePeriod(v.ref.period, recentPeriod) && isoDate(v.published) && v.published >= recentPeriod.start && v.published <= recentPeriod.end && v.units !== null && v.units > 0).map(v => [v.id, v])).values()];
+    const creatorSales = new Map();
+    for (const v of videos)
+        if (v.creatorId)
+            creatorSales.set(v.creatorId, (creatorSales.get(v.creatorId) || 0) + v.units);
+    const newVideoUnits = videos.length ? videos.reduce((s, v) => s + v.units, 0) : null;
+    const topCreatorShare = newVideoUnits && creatorSales.size ? Math.max(...creatorSales.values()) / newVideoUnits : null;
+    if (!videos.length)
+        missing.push("缺少同期间新发布且出单的视频");
+    if (videos.some(v => !v.creatorId))
+        missing.push("部分出单视频的达人ID尚未核实");
+    const distributed = creatorSales.size >= 2 && videos.every(v => v.creatorId) && topCreatorShare !== null && topCreatorShare <= 0.8;
+    if (!distributed)
+        missing.push("尚未验证多个不同达人均有近期有效成交");
+    if (topCreatorShare !== null && topCreatorShare > 0.8)
+        risks.push("已读取的新视频成交超过80%集中在一个达人，扩散证据不足");
+    if (videos.length)
+        reasons.push(`已读取 ${videos.length} 条近期出单新视频，核实 ${creatorSales.size} 个达人（样本，非全量）`);
+    const overview = product.overview && belongs(product.overview.ref) && samePeriod(product.overview.ref.period, recentPeriod) ? product.overview : null;
+    if (!overview)
+        missing.push("成交渠道统计与7天销量窗口未对齐");
+    const totalsMatch = Boolean(overview && overview.units !== null && overview.units !== undefined && recentUnits !== null && Math.abs(overview.units - recentUnits) <= (overview.unitsTolerance || 0));
+    if (!totalsMatch)
+        missing.push(overview?.units !== null && overview?.units !== undefined && recentUnits !== null ? `7天总览 ${overview.units} 单与逐日合计 ${recentUnits} 单不一致，需复核数据快照` : "缺少7天总览销量，尚不能与逐日合计核对");
+    if (overview?.adShare === null || !overview)
+        missing.push("广告成交占比未知");
+    if (overview?.liveShare === null || !overview)
+        missing.push("直播成交占比未知");
+    if (overview && overview.adShare !== null && overview.adShare >= 70)
+        risks.push(`广告成交占比 ${overview.adShare}%，需验证投流条件，不能推断自然流量可复制`);
+    if (overview && overview.liveShare !== null && overview.liveShare >= 50)
+        risks.push(`直播成交占比 ${overview.liveShare}%，短视频机会仍待验证`);
+    const weeks = [];
+    if (cutoff)
+        for (let end = dayOffset(cutoff, -7); end >= dayOffset(cutoff, -83); end = dayOffset(end, -7)) {
+            const total = sum(window(end, 7));
+            if (total !== null)
+                weeks.unshift({ start: dayOffset(end, -6), end, units: total });
+        }
+    let reboundWindows = [];
+    // Require a complete observed path from a past peak through a subsequent trough.
+    for (let peak = 0; peak < weeks.length - 1; peak++)
+        for (let trough = peak + 1; trough < weeks.length; trough++) {
+            const path = weeks.slice(peak, trough + 1);
+            const continuous = path.every((w, i) => !i || dayOffset(path[i - 1].end, 1) === w.start);
+            if (continuous && cutoff && sum(window(cutoff, Math.round((Date.parse(cutoff) - Date.parse(weeks[peak].start)) / 86400000) + 1)) !== null && weeks[peak].units > 0 && weeks[trough].units <= weeks[peak].units * 0.5 && recentUnits !== null && recentUnits >= Math.max(1, weeks[trough].units * 1.5) && rising)
+                reboundWindows = [weeks[peak], weeks[trough], { start: dayOffset(cutoff, -6), end: cutoff, units: recentUnits }];
+        }
+    const opportunity = reboundWindows.length ? "rebound" : rising ? "emerging" : "unconfirmed";
+    if (reboundWindows.length)
+        reasons.push("逐日历史支持高峰→回落→再次起量，仍需结合新内容判断驱动");
+    if (config.opportunity === "rebound" && !reboundWindows.length)
+        missing.push("历史高峰、回落及持续回升尚未全部证实");
+    if (!product.identityVerified || product.market !== config.market)
+        missing.push("国家与商品身份尚未在详情页核实");
+    if (product.stock === null)
+        missing.push("具体SKU库存待核对");
+    if (product.rating === null)
+        missing.push("商品评分未知");
+    missing.push("同国同类目相近价格带竞争、具体SKU及实际视频呈现仍需人工复核");
+    const wrongDirection = config.opportunity === "emerging" && opportunity === "rebound";
+    const poorRating = product.rating !== null && product.rating < 3.5 && product.reviewCount !== 0;
+    const hardSkip = product.stock === 0 || poorRating || (increment !== null && increment <= 0) || wrongDirection;
+    if (product.stock === 0)
+        risks.push("详情显示无库存");
+    if (poorRating)
+        risks.push("详情评分低于3.5，先核对质量问题");
+    if (product.reviewCount === 0)
+        missing.push("暂无评论，不能按0分判断质量");
+    if (increment !== null && increment <= 0)
+        risks.push("近7天销量未高于前7天");
+    if (wrongDirection)
+        risks.push("已识别为二次起量，与本轮仅找潜力起量的范围不符");
+    const aligned = overview && overview.adShare !== null && overview.adShare < 70 && overview.liveShare !== null && overview.liveShare < 50 && overview.videoShare !== null && overview.videoShare >= 50;
+    const hasConflict = missing.some(x => /快照不一致/.test(x));
+    const decision = hardSkip ? "skip" : product.detailState === "complete" && product.identityVerified && product.market === config.market && fresh && rising && distributed && aligned && totalsMatch && !hasConflict && (config.opportunity !== "rebound" || reboundWindows.length > 0) ? "test" : "watch";
+    return { decision, opportunity, reasons, risks, missing: [...new Set(missing)], cutoff, recentUnits, previousUnits, growthPercent, increment, newVideoUnits, newVideoCount: videos.length, convertingCreators: creatorSales.size, topCreatorShare, reboundWindows };
+}
+export function opportunityCandidate(product, config, sessionId) {
+    const assessment = assessOpportunity(product, config);
+    return { source: "fastmoss-agent", sourceProductId: product.productId, platformProductId: product.productId, title: product.title, market: product.market, category: product.category, storeName: product.storeName, productUrl: product.url, imageUrls: product.imageUrls,
+        metrics: { strategy: OPPORTUNITY_VERSION, selectionSessionId: sessionId, selectionDecision: assessment.decision, selectionEligible: assessment.decision !== "skip", portfolioSelected: assessment.decision === "test", selectionReasons: assessment.reasons, selectionRisks: [...assessment.risks, ...assessment.missing], sales: assessment.recentUnits, growthPercent: assessment.growthPercent, price: product.price, currency: product.currency, captureDate: product.discoveredAt, sourceVerified: false, opportunityAssessment: assessment, opportunityEvidence: product } };
+}

package/dist/integrations/fastmoss-selection-session.d.ts

@@ -0,0 +1,112 @@
+import { type ProductEvidence, type Ranking, type SelectionConfig } from "./fastmoss-opportunity.js";
+export type SelectionSession = {
+    id: string;
+    config: SelectionConfig;
+    createdAt: string;
+    updatedAt: string;
+    phase: "collecting" | "reviewing" | "complete" | "interrupted";
+    active: boolean;
+    completedRankings: Ranking[];
+    rankingErrors: Partial<Record<Ranking, string>>;
+    products: ProductEvidence[];
+    error?: string;
+};
+export type SelectionAdapter = {
+    discover: (ranking: Ranking, config: SelectionConfig, save: (products: ProductEvidence[]) => Promise<void>) => Promise<void>;
+    detail: (product: ProductEvidence, config: SelectionConfig, save: (product: ProductEvidence) => Promise<void>) => Promise<ProductEvidence>;
+};
+export declare class FastMossSelectionSessions {
+    private directory;
+    private adapter;
+    private activeId;
+    private task;
+    private serial;
+    constructor(directory: string, adapter: SelectionAdapter);
+    isRunning(): boolean;
+    private atomic;
+    private persist;
+    private load;
+    get(id?: string): 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: ProductEvidence;
+            };
+        }[];
+        id: string;
+        config: SelectionConfig;
+        createdAt: string;
+        updatedAt: string;
+        phase: "collecting" | "reviewing" | "complete" | "interrupted";
+        active: boolean;
+        completedRankings: Ranking[];
+        rankingErrors: Partial<Record<Ranking, string>>;
+        products: ProductEvidence[];
+        error?: string;
+    } | null>;
+    /** Serialize ACK creation; repeat POST with the same id never starts duplicate work. */
+    start(id: string, input: 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: ProductEvidence;
+            };
+        }[];
+        id: string;
+        config: SelectionConfig;
+        createdAt: string;
+        updatedAt: string;
+        phase: "collecting" | "reviewing" | "complete" | "interrupted";
+        active: boolean;
+        completedRankings: Ranking[];
+        rankingErrors: Partial<Record<Ranking, string>>;
+        products: ProductEvidence[];
+        error?: string;
+    } | null>;
+    waitUntilIdle(): Promise<void>;
+    private run;
+}