@wowok/agent-mcp 2.3.14 → 2.3.16

package/dist/customer/post-purchase.js

@@ -0,0 +1,350 @@
+import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+export function generatePostPurchaseAdvice(ctx) {
+    switch (ctx.phase) {
+        case "refund_tracking":
+            return trackRefund(ctx);
+        case "quality_issue":
+            return handleQualityIssue(ctx);
+        case "merchant_unreachable":
+            return handleMerchantUnreachable(ctx);
+        case "arbitration_support":
+            return arbitrationSupport(ctx);
+    }
+}
+export function trackRefund(ctx) {
+    const actions = [];
+    const orderAmount = ctx.order_amount ?? 0n;
+    const refunded = ctx.refunded_amount ?? 0n;
+    if (orderAmount > 0n && refunded >= orderAmount) {
+        actions.push({
+            id: "refund_complete",
+            phase: "refund_tracking",
+            priority: "info",
+            title: "退款已完成",
+            message: `✅ 订单 ${ctx.order_id} 退款已全额到账（${refunded} 最小单位）`,
+            next_step: "可关闭售后跟踪，建议提交订单评价",
+        });
+        return actions;
+    }
+    if (refunded > 0n && refunded < orderAmount) {
+        const diff = orderAmount - refunded;
+        actions.push({
+            id: "refund_partial",
+            phase: "refund_tracking",
+            priority: "required",
+            title: "退款不完整",
+            message: `⚠️ 订单 ${ctx.order_id} 仅退款 ${refunded}/${orderAmount}，差额 ${diff} 最小单位未到账`,
+            next_step: "通过 Messenger 催促商家补足差额，或发起仲裁追回",
+            tool: "messenger_send",
+        });
+        return actions;
+    }
+    if (refunded === 0n && ctx.refund_requested === true) {
+        actions.push({
+            id: "refund_waiting",
+            phase: "refund_tracking",
+            priority: "recommended",
+            title: "等待商家退款",
+            message: `⏳ 订单 ${ctx.order_id} 已申请退款，等待商家触发退款 Allocator`,
+            next_step: "若 48 小时内未到账，建议通过 Messenger 催促或发起仲裁",
+            tool: "query_toolkit",
+        });
+        return actions;
+    }
+    const hasRefundPath = ctx.puzzle?.workflow_analysis?.has_refund_path ?? false;
+    if (refunded === 0n && ctx.refund_requested !== true && hasRefundPath) {
+        actions.push({
+            id: "refund_trigger_available",
+            phase: "refund_tracking",
+            priority: "recommended",
+            title: "可通过 Allocator 触发退款",
+            message: `ℹ️ 订单 ${ctx.order_id} 存在退款路径，可触发 refund Allocator 退款`,
+            next_step: "通过 query_toolkit 查询 refund Allocator 触发条件并申请退款",
+            tool: "query_toolkit",
+        });
+        return actions;
+    }
+    actions.push({
+        id: "refund_no_path",
+        phase: "refund_tracking",
+        priority: "required",
+        title: "无退款路径，需通过仲裁",
+        message: `🔴 订单 ${ctx.order_id} 无退款 Allocator 路径，需通过仲裁追回资金`,
+        next_step: "切换到 arbitration_support 阶段，发起仲裁申请",
+        tool: "mark_arbitration",
+    });
+    return actions;
+}
+export function handleQualityIssue(ctx) {
+    const actions = [];
+    if (ctx.original_wip_hash &&
+        ctx.wip_hash &&
+        ctx.original_wip_hash !== ctx.wip_hash) {
+        actions.push({
+            id: "quality_wip_mismatch",
+            phase: "quality_issue",
+            priority: "required",
+            title: "检测到 WIP hash 不一致",
+            message: `🔴 订单 ${ctx.order_id} 的 WIP hash 与下单时不一致，可能存在交付物变更。\n` +
+                `  原始：${ctx.original_wip_hash}\n` +
+                `  当前：${ctx.wip_hash}`,
+            next_step: "通过 query_toolkit 复核 WIP，并立即发起仲裁",
+            tool: "query_toolkit",
+        });
+    }
+    if (!ctx.wip_hash) {
+        actions.push({
+            id: "quality_wip_missing",
+            phase: "quality_issue",
+            priority: "recommended",
+            title: "要求商家提供 WIP hash 验证",
+            message: `⚠️ 订单 ${ctx.order_id} 缺少当前 WIP hash，无法验证交付物完整性`,
+            next_step: "通过 Messenger 索取最新 WIP hash 并与原始 hash 对比",
+            tool: "messenger_send",
+        });
+    }
+    const evidenceCount = ctx.evidence?.length ?? 0;
+    if (evidenceCount === 0) {
+        actions.push({
+            id: "quality_collect_evidence",
+            phase: "quality_issue",
+            priority: "recommended",
+            title: "收集证据：截图、聊天记录、交付物样品",
+            message: `📋 订单 ${ctx.order_id} 暂无证据收集记录。建议立即收集：\n` +
+                `  • 交付物截图 / 录屏\n` +
+                `  • Messenger 聊天记录（导出 WTS 凭证）\n` +
+                `  • 交付物样品或测试结果`,
+            next_step: "通过 messenger_mark_evidence 生成 WTS 证据文件",
+            tool: "messenger_mark_evidence",
+        });
+    }
+    else if (evidenceCount < 3) {
+        actions.push({
+            id: "quality_supplement_evidence",
+            phase: "quality_issue",
+            priority: "recommended",
+            title: `补充更多证据（当前 ${evidenceCount} 项，建议 ≥3 项）`,
+            message: `⚠️ 订单 ${ctx.order_id} 已收集 ${evidenceCount} 项证据，建议补充至 3 项以上以增强仲裁胜算。\n` +
+                `  当前证据：${ctx.evidence?.join(" / ") ?? "无"}`,
+            next_step: "补充截图、聊天记录或第三方鉴定报告",
+            tool: "messenger_mark_evidence",
+        });
+    }
+    if (actions.length === 0) {
+        actions.push({
+            id: "quality_ok",
+            phase: "quality_issue",
+            priority: "info",
+            title: "质量验证通过",
+            message: `✅ 订单 ${ctx.order_id} 的 WIP hash 与原始一致，证据齐全（${evidenceCount} 项）`,
+            next_step: "可正常推进验收流程",
+        });
+    }
+    return actions;
+}
+export function handleMerchantUnreachable(ctx) {
+    const actions = [];
+    const lastReply = ctx.last_merchant_reply_at;
+    const days = lastReply !== undefined
+        ? Math.floor((ctx.now - lastReply) / (24 * 60 * 60 * 1000))
+        : Infinity;
+    const hasArbitration = ctx.has_arbitration ?? ctx.puzzle?.workflow_analysis?.has_arbitration_path ?? false;
+    if (days > 7) {
+        if (hasArbitration) {
+            actions.push({
+                id: "unreachable_arb_recommend",
+                phase: "merchant_unreachable",
+                priority: "required",
+                title: "建议发起仲裁",
+                message: `🔴 订单 ${ctx.order_id} 商家已失联 ${days} 天，资金可能冻结。建议立即发起仲裁。`,
+                next_step: "切换到 arbitration_support 阶段，提交仲裁申请",
+                tool: "mark_arbitration",
+            });
+        }
+        else {
+            actions.push({
+                id: "unreachable_no_arb",
+                phase: "merchant_unreachable",
+                priority: "required",
+                title: "无仲裁通道，资金可能冻结，建议联系 WoWok 官方",
+                message: `🔴 订单 ${ctx.order_id} 商家已失联 ${days} 天，且未配置仲裁通道，资金可能长期冻结。建议联系 WoWok 官方协助处理。`,
+                next_step: "联系 WoWok 官方支持并提供订单与沟通记录",
+            });
+        }
+        return actions;
+    }
+    if (days > 3) {
+        actions.push({
+            id: "unreachable_urge",
+            phase: "merchant_unreachable",
+            priority: "recommended",
+            title: "持续无响应，发送催促消息",
+            message: `⚠️ 订单 ${ctx.order_id} 商家已 ${days} 天未回复，建议通过 Messenger 发送催促消息并保留记录`,
+            next_step: "若 3 天内仍无回复，发起仲裁",
+            tool: "messenger_send",
+        });
+        return actions;
+    }
+    actions.push({
+        id: "unreachable_wait",
+        phase: "merchant_unreachable",
+        priority: "info",
+        title: "商家可能忙碌，等待回复",
+        message: `ℹ️ 订单 ${ctx.order_id} 商家 ${days === Infinity ? "尚未回复" : `已 ${days} 天未回复`}，可能正在忙碌。建议再等待 1-2 天`,
+        next_step: "若 3 天后仍无回复，发送催促消息",
+    });
+    return actions;
+}
+export function arbitrationSupport(ctx) {
+    const actions = [];
+    const initiated = ctx.arbitration_initiated === true;
+    const evidenceCount = ctx.evidence?.length ?? 0;
+    const arbWindowDays = ctx.arb_window_days ?? 0;
+    if (!initiated) {
+        actions.push({
+            id: "arb_not_initiated",
+            phase: "arbitration_support",
+            priority: "required",
+            title: "建议发起仲裁申请",
+            message: `🔔 订单 ${ctx.order_id} 尚未发起仲裁。建议立即生成仲裁申请模板并提交。`,
+            next_step: "调用 generateArbitrationTemplate 生成申请模板",
+            tool: "mark_arbitration",
+        });
+        if (arbWindowDays > 0 && arbWindowDays <= 7) {
+            actions.push({
+                id: "arb_window_closing_soon",
+                phase: "arbitration_support",
+                priority: "required",
+                title: `仲裁窗口将在 ${arbWindowDays} 天后关闭`,
+                message: `⏰ 订单 ${ctx.order_id} 的仲裁申请窗口仅剩 ${arbWindowDays} 天，请尽快提交仲裁申请`,
+                next_step: "立即提交仲裁申请",
+                deadline: ctx.now + arbWindowDays * 24 * 60 * 60 * 1000,
+            });
+        }
+        return actions;
+    }
+    if (arbWindowDays > 0 && arbWindowDays <= 3) {
+        actions.push({
+            id: "arb_window_urgent",
+            phase: "arbitration_support",
+            priority: "required",
+            title: "仲裁窗口即将关闭",
+            message: `⏰ 订单 ${ctx.order_id} 的仲裁窗口仅剩 ${arbWindowDays} 天，请尽快补充证据并跟进投票进度`,
+            next_step: "立即补充证据并查询仲裁进度",
+            tool: "query_toolkit",
+            deadline: ctx.now + arbWindowDays * 24 * 60 * 60 * 1000,
+        });
+    }
+    if (evidenceCount === 0) {
+        actions.push({
+            id: "arb_no_evidence",
+            phase: "arbitration_support",
+            priority: "required",
+            title: "补充证据",
+            message: `📋 订单 ${ctx.order_id} 已发起仲裁但无证据记录。建议立即收集：\n` +
+                `  • Messenger 聊天记录\n` +
+                `  • WIP hash 对比记录\n` +
+                `  • Progress 停滞截图`,
+            next_step: "通过 messenger_mark_evidence 生成证据文件并提交",
+            tool: "messenger_mark_evidence",
+        });
+    }
+    else if (evidenceCount < 3) {
+        actions.push({
+            id: "arb_supplement_evidence",
+            phase: "arbitration_support",
+            priority: "recommended",
+            title: `补充更多证据以增强仲裁胜算（当前 ${evidenceCount} 项）`,
+            message: `⚠️ 订单 ${ctx.order_id} 已提交 ${evidenceCount} 项证据，建议补充至 3 项以上。\n` +
+                `  当前证据：${ctx.evidence?.join(" / ") ?? "无"}`,
+            next_step: "补充第三方鉴定、聊天记录或交付物截图",
+            tool: "messenger_mark_evidence",
+        });
+    }
+    if (evidenceCount >= 3 && (arbWindowDays === 0 || arbWindowDays > 3)) {
+        actions.push({
+            id: "arb_monitor_progress",
+            phase: "arbitration_support",
+            priority: "info",
+            title: "仲裁进行中，持续监控投票进度",
+            message: `📊 订单 ${ctx.order_id} 仲裁已发起，证据 ${evidenceCount} 项齐全。建议定期查询投票进度并准备补充证据。`,
+            next_step: "通过 query_toolkit 查询仲裁投票状态",
+            tool: "query_toolkit",
+        });
+    }
+    return actions;
+}
+export function generateArbitrationTemplate(ctx) {
+    const phaseLabel = phaseToLabel(ctx.phase);
+    const evidenceCount = ctx.evidence?.length ?? 0;
+    const title = `订单 ${ctx.order_id} 仲裁申请 — ${phaseLabel}`;
+    const descriptionParts = [];
+    descriptionParts.push(`订单 ID：${ctx.order_id}`);
+    descriptionParts.push(`Service ID：${ctx.service_id}`);
+    descriptionParts.push(`纠纷类型：${phaseLabel}`);
+    switch (ctx.phase) {
+        case "refund_tracking":
+            descriptionParts.push(`纠纷概述：商家未按要求退款。订单金额 ${ctx.order_amount ?? "未知"} 最小单位，已退款 ${ctx.refunded_amount ?? 0n} 最小单位。`);
+            break;
+        case "quality_issue":
+            descriptionParts.push(`纠纷概述：交付物质量存在问题。WIP hash 原始：${ctx.original_wip_hash ?? "未知"}，当前：${ctx.wip_hash ?? "未知"}。`);
+            break;
+        case "merchant_unreachable":
+            descriptionParts.push(`纠纷概述：商家长期失联。最后回复时间：${ctx.last_merchant_reply_at ? new Date(ctx.last_merchant_reply_at).toISOString() : "未知"}。`);
+            break;
+        case "arbitration_support":
+            descriptionParts.push("纠纷概述：详见上述阶段记录。");
+            break;
+    }
+    descriptionParts.push(`已收集证据：${evidenceCount} 项`);
+    const description = descriptionParts.join("\n");
+    const evidence_required = [
+        "Messenger 沟通记录（导出 WTS 证据文件）",
+        "订单创建与支付凭证",
+        "Progress 节点推进记录",
+    ];
+    switch (ctx.phase) {
+        case "quality_issue":
+            evidence_required.push("WIP hash 对比记录（原始 vs 当前）");
+            evidence_required.push("交付物截图或样品");
+            break;
+        case "merchant_unreachable":
+            evidence_required.push("失联时长记录（基于 last_merchant_reply_at）");
+            evidence_required.push("催促消息发送记录");
+            break;
+        case "refund_tracking":
+            evidence_required.push("退款申请记录");
+            evidence_required.push("退款差额计算凭证");
+            break;
+    }
+    const claim = buildClaim(ctx);
+    return { title, description, evidence_required, claim };
+}
+function phaseToLabel(phase) {
+    switch (phase) {
+        case "refund_tracking": return "退款纠纷";
+        case "quality_issue": return "质量问题";
+        case "merchant_unreachable": return "商家失联";
+        case "arbitration_support": return "仲裁支持";
+    }
+}
+function buildClaim(ctx) {
+    switch (ctx.phase) {
+        case "refund_tracking": {
+            const orderAmount = ctx.order_amount ?? 0n;
+            const refunded = ctx.refunded_amount ?? 0n;
+            const diff = orderAmount - refunded;
+            if (refunded === 0n) {
+                return `请求仲裁商家全额退款（${orderAmount} 最小单位）。`;
+            }
+            return `请求仲裁商家补足退款差额（${diff} 最小单位）。`;
+        }
+        case "quality_issue":
+            return "请求仲裁商家重新交付符合约定的交付物，或全额退款。";
+        case "merchant_unreachable":
+            return "请求仲裁商家履行订单义务或退还全部款项，并赔偿因失联造成的损失。";
+        case "arbitration_support":
+            return "请求仲裁支持本方诉求，依据所附证据判定商家违约并赔偿。";
+    }
+}
+export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/customer/reminder-system.d.ts

@@ -0,0 +1,42 @@
+import type { Reminder, RiskLevel } from "./types.js";
+import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+export type ReminderStage = "browse" | "evaluate" | "preorder" | "in_progress" | "complete" | "after_sale";
+export interface ReminderContext {
+    stage: ReminderStage;
+    service_id?: string;
+    order_id?: string;
+    review_count?: number;
+    like_rate?: number;
+    avg_market_price?: bigint;
+    service_price?: bigint;
+    has_arbitration?: boolean;
+    has_compensation?: boolean;
+    compensation_balance?: bigint;
+    compensation_ratio?: number;
+    risk_score?: number;
+    risk_level?: RiskLevel;
+    has_refund_path?: boolean;
+    has_user_operable?: boolean;
+    has_messenger?: boolean;
+    ambiguous_guards?: string[];
+    current_node?: string;
+    expected_progress_hours?: number;
+    hours_since_last_progress?: number;
+    hours_since_messenger_reply?: number;
+    completed_at?: number;
+    review_window_days?: number;
+    arb_window_days?: number;
+    user_min_trust_score?: number;
+    user_require_arbitration?: boolean;
+    user_require_compensation?: boolean;
+}
+export declare function generateReminders(ctx: ReminderContext): Reminder[];
+export declare function sortAndCapReminders(reminders: Reminder[]): Reminder[];
+export declare function generateMultiStageReminders(ctx: Partial<ReminderContext> & {
+    stage: ReminderStage;
+}, additionalStages?: ReminderStage[]): Reminder[];
+export declare function isBlocking(reminder: Reminder): boolean;
+export declare function getBlockingReminders(reminders: Reminder[]): Reminder[];
+export declare function summarizeReminders(reminders: Reminder[]): string;
+export declare function topReminders(reminders: Reminder[], n?: number): Reminder[];
+export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/customer/reminder-system.js

@@ -0,0 +1,295 @@
+import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+const REMINDER_RULES = [
+    {
+        id: "browse_reviews_summary",
+        stage: "browse",
+        priority: "info",
+        message: (ctx) => `This Service has ${ctx.review_count} reviews, like rate ${Math.round((ctx.like_rate ?? 0) * 100)}%`,
+        applies: (ctx) => (ctx.review_count ?? 0) > 0,
+        dedup_key: "reviews_summary",
+    },
+    {
+        id: "browse_price_anomaly_low",
+        stage: "browse",
+        priority: "recommended",
+        message: (ctx) => {
+            if (!ctx.avg_market_price || !ctx.service_price || ctx.avg_market_price === 0n) {
+                return "⚠️ 价格异常低，请警惕质量风险";
+            }
+            const ratio = Number(ctx.service_price * 100n / ctx.avg_market_price) / 100;
+            const below = Math.round((1 - ratio) * 100);
+            return `⚠️ 价格低于同类均价 ${below}%，请警惕质量风险`;
+        },
+        applies: (ctx) => {
+            if (!ctx.avg_market_price || !ctx.service_price)
+                return false;
+            if (ctx.avg_market_price === 0n)
+                return false;
+            const ratio = Number(ctx.service_price * 100n / ctx.avg_market_price) / 100;
+            return ratio < 0.6;
+        },
+        dedup_key: "price_anomaly",
+    },
+    {
+        id: "browse_no_arbitration",
+        stage: "browse",
+        priority: "recommended",
+        message: "⚠️ 该 Service 未配置仲裁，纠纷无解决通道",
+        applies: (ctx) => ctx.has_arbitration === false,
+        dedup_key: "no_arbitration",
+    },
+    {
+        id: "browse_no_compensation",
+        stage: "browse",
+        priority: "recommended",
+        message: "⚠️ 该 Service 无赔偿金，订单失败时无自动赔付来源",
+        applies: (ctx) => ctx.has_compensation === false,
+        dedup_key: "no_compensation",
+    },
+    {
+        id: "evaluate_checklist",
+        stage: "evaluate",
+        priority: "info",
+        message: "📋 Running 4-dimension risk check (workflow/fund/trust/behavior)...",
+        applies: () => true,
+        dedup_key: "checklist_start",
+    },
+    {
+        id: "evaluate_high_risk",
+        stage: "evaluate",
+        priority: "required",
+        message: (ctx) => `🔴 Composite risk score ${ctx.risk_score}/100, strongly recommend not purchasing`,
+        applies: (ctx) => (ctx.risk_level ?? "low") === "high",
+        dedup_key: "high_risk_score",
+    },
+    {
+        id: "evaluate_medium_high_risk",
+        stage: "evaluate",
+        priority: "recommended",
+        message: (ctx) => `🟠 综合风险分 ${ctx.risk_score}/100，谨慎购买，需重点关注 2-3 项风险`,
+        applies: (ctx) => (ctx.risk_level ?? "low") === "medium_high",
+        dedup_key: "medium_high_risk",
+    },
+    {
+        id: "evaluate_ambiguous_guard",
+        stage: "evaluate",
+        priority: "required",
+        message: (ctx) => `🔴 检测到 ${ctx.ambiguous_guards?.length ?? 0} 个模糊 Guard，必须人工审查后才能继续：${ctx.ambiguous_guards?.join(", ") ?? ""}`,
+        applies: (ctx) => (ctx.ambiguous_guards?.length ?? 0) > 0,
+        dedup_key: "ambiguous_guard",
+    },
+    {
+        id: "evaluate_no_refund_path",
+        stage: "evaluate",
+        priority: "recommended",
+        message: "⚠️ 无退款路径：若交付失败，资金可能无法回收。建议 Messenger 协商退款条款",
+        applies: (ctx) => ctx.has_refund_path === false,
+        dedup_key: "no_refund_path",
+    },
+    {
+        id: "evaluate_no_user_operable",
+        stage: "evaluate",
+        priority: "required",
+        message: "🔴 流程中无任何用户可操作步骤：订单进度完全依赖商家",
+        applies: (ctx) => ctx.has_user_operable === false,
+        dedup_key: "no_user_operable",
+    },
+    {
+        id: "evaluate_below_min_trust",
+        stage: "evaluate",
+        priority: "required",
+        message: (ctx) => `🔴 Risk score ${ctx.risk_score} is below your minimum requirement of ${ctx.user_min_trust_score}`,
+        applies: (ctx) => ctx.user_min_trust_score !== undefined &&
+            ctx.risk_score !== undefined &&
+            ctx.risk_score < ctx.user_min_trust_score,
+        dedup_key: "below_min_trust",
+    },
+    {
+        id: "preorder_payment_confirm",
+        stage: "preorder",
+        priority: "required",
+        message: (ctx) => `🔔 即将支付 ${ctx.service_price} 最小单位到托管账户，请确认`,
+        applies: (ctx) => ctx.service_price !== undefined,
+        dedup_key: "payment_confirm",
+    },
+    {
+        id: "preorder_compensation_insufficient",
+        stage: "preorder",
+        priority: "recommended",
+        message: (ctx) => `⚠️ Compensation balance only covers ${Math.round((ctx.compensation_ratio ?? 0) * 100)}% of the order amount`,
+        applies: (ctx) => (ctx.compensation_ratio ?? 1) < 1,
+        dedup_key: "compensation_insufficient",
+    },
+    {
+        id: "preorder_user_require_arb_missing",
+        stage: "preorder",
+        priority: "required",
+        message: "🔴 您的偏好要求必备仲裁，但该 Service 未配置",
+        applies: (ctx) => ctx.user_require_arbitration === true && ctx.has_arbitration === false,
+        dedup_key: "user_require_arb_missing",
+    },
+    {
+        id: "preorder_user_require_comp_missing",
+        stage: "preorder",
+        priority: "required",
+        message: "🔴 您的偏好要求必备赔偿金，但该 Service 无",
+        applies: (ctx) => ctx.user_require_compensation === true && ctx.has_compensation === false,
+        dedup_key: "user_require_comp_missing",
+    },
+    {
+        id: "preorder_no_messenger",
+        stage: "preorder",
+        priority: "recommended",
+        message: "⚠️ 商家无 Messenger 通道，下单后无法协商或售后",
+        applies: (ctx) => ctx.has_messenger === false,
+        dedup_key: "no_messenger",
+    },
+    {
+        id: "in_progress_progress_stalled",
+        stage: "in_progress",
+        priority: "recommended",
+        message: (ctx) => `⚠️ 订单已停留在节点 ${ctx.current_node} 超过 ${ctx.hours_since_last_progress} 小时，建议联系商家`,
+        applies: (ctx) => {
+            const stallHours = ctx.hours_since_last_progress ?? 0;
+            const expected = ctx.expected_progress_hours ?? 24;
+            return stallHours > expected * 2;
+        },
+        dedup_key: "progress_stalled",
+    },
+    {
+        id: "in_progress_compensation_drop",
+        stage: "in_progress",
+        priority: "recommended",
+        message: "⚠️ 商家赔偿金余额下降 30%，请注意",
+        applies: () => false,
+        dedup_key: "compensation_drop",
+    },
+    {
+        id: "in_progress_user_action_required",
+        stage: "in_progress",
+        priority: "reminder",
+        message: (ctx) => `🔔 订单推进到节点 ${ctx.current_node}，需要您操作`,
+        applies: (ctx) => ctx.current_node !== undefined && ctx.current_node !== "",
+        dedup_key: "user_action_required",
+    },
+    {
+        id: "in_progress_messenger_unanswered",
+        stage: "in_progress",
+        priority: "recommended",
+        message: (ctx) => `⚠️ 商家已 ${ctx.hours_since_messenger_reply} 小时未回复 Messenger，可考虑发起仲裁`,
+        applies: (ctx) => (ctx.hours_since_messenger_reply ?? 0) > 24,
+        dedup_key: "messenger_unanswered",
+    },
+    {
+        id: "complete_review_reminder",
+        stage: "complete",
+        priority: "info",
+        message: "💡 订单已完成，是否要提交评价？",
+        applies: () => true,
+        dedup_key: "review_reminder",
+    },
+    {
+        id: "complete_review_window",
+        stage: "complete",
+        priority: "reminder",
+        message: (ctx) => `⏰ 评价窗口将在 ${ctx.review_window_days} 天后关闭`,
+        applies: (ctx) => (ctx.review_window_days ?? 0) > 0,
+        dedup_key: "review_window",
+    },
+    {
+        id: "after_sale_arb_window",
+        stage: "after_sale",
+        priority: "reminder",
+        message: (ctx) => `⏰ 仲裁申请窗口将在 ${ctx.arb_window_days} 天后关闭`,
+        applies: (ctx) => (ctx.arb_window_days ?? 0) > 0,
+        dedup_key: "arb_window",
+    },
+    {
+        id: "after_sale_refund_received",
+        stage: "after_sale",
+        priority: "info",
+        message: "✅ 退款已到账",
+        applies: () => false,
+        dedup_key: "refund_received",
+    },
+];
+export function generateReminders(ctx) {
+    const stageRules = REMINDER_RULES.filter((r) => r.stage === ctx.stage);
+    const byKey = new Map();
+    for (const rule of stageRules) {
+        if (!rule.applies(ctx))
+            continue;
+        const existing = byKey.get(rule.dedup_key);
+        if (!existing || priorityRank(rule.priority) > priorityRank(existing.priority)) {
+            byKey.set(rule.dedup_key, rule);
+        }
+    }
+    const reminders = Array.from(byKey.values()).map((rule) => ({
+        id: rule.id,
+        stage: rule.stage,
+        priority: rule.priority,
+        message: typeof rule.message === "function" ? rule.message(ctx) : rule.message,
+        action: rule.action,
+    }));
+    return sortAndCapReminders(reminders);
+}
+export function sortAndCapReminders(reminders) {
+    const sorted = [...reminders].sort((a, b) => priorityRank(b.priority) - priorityRank(a.priority));
+    const highRisk = sorted.filter((r) => r.priority === "required" || r.priority === "recommended");
+    const others = sorted.filter((r) => r.priority === "info" || r.priority === "reminder");
+    const cappedHighRisk = highRisk.slice(0, 3);
+    return [...cappedHighRisk, ...others];
+}
+function priorityRank(p) {
+    switch (p) {
+        case "required": return 4;
+        case "recommended": return 3;
+        case "info": return 2;
+        case "reminder": return 1;
+    }
+}
+export function generateMultiStageReminders(ctx, additionalStages = []) {
+    const stages = [ctx.stage, ...additionalStages];
+    const all = [];
+    const seenKeys = new Set();
+    for (const stage of stages) {
+        const stageCtx = { ...ctx, stage };
+        const stageReminders = generateReminders(stageCtx);
+        for (const r of stageReminders) {
+            const key = `${stage}:${r.id}`;
+            if (!seenKeys.has(key)) {
+                seenKeys.add(key);
+                all.push(r);
+            }
+        }
+    }
+    return all;
+}
+export function isBlocking(reminder) {
+    return reminder.priority === "required";
+}
+export function getBlockingReminders(reminders) {
+    return reminders.filter(isBlocking);
+}
+export function summarizeReminders(reminders) {
+    if (reminders.length === 0)
+        return "无提醒";
+    const required = reminders.filter((r) => r.priority === "required");
+    const recommended = reminders.filter((r) => r.priority === "recommended");
+    const info = reminders.filter((r) => r.priority === "info");
+    const reminderOnly = reminders.filter((r) => r.priority === "reminder");
+    const parts = [];
+    if (required.length)
+        parts.push(`🔴 必读 ${required.length} 条`);
+    if (recommended.length)
+        parts.push(`⚠️ 建议 ${recommended.length} 条`);
+    if (info.length)
+        parts.push(`💡 提示 ${info.length} 条`);
+    if (reminderOnly.length)
+        parts.push(`🔔 提醒 ${reminderOnly.length} 条`);
+    return parts.join("，");
+}
+export function topReminders(reminders, n = 5) {
+    return sortAndCapReminders(reminders).slice(0, n);
+}
+export { CUSTOMER_INTELLIGENCE_VERSION };