@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/customer/customer-advice.d.ts

@@ -0,0 +1,31 @@
+import { type InfoPuzzle, type RiskScore, type UserPreferences, type Industry, type StrategyRecommendation, type PreferenceMatchResult, type ServiceForMatching, type IndustryRiskResult, type Reminder, type ReminderContext } from "./index.js";
+export interface PreorderAdviceInput {
+    puzzle: InfoPuzzle;
+    risk?: RiskScore;
+    preferences?: UserPreferences;
+    industry?: Industry;
+    matching_overrides?: Partial<ServiceForMatching>;
+    reminder_overrides?: Partial<ReminderContext>;
+    max_strategies?: number;
+    max_reminders?: number;
+}
+export interface ConfidenceScore {
+    score: number;
+    base: number;
+    user_adjustment: number;
+    preference_nudge: number;
+    explanation: string;
+}
+export interface PreorderAdvice {
+    service_id: string;
+    risk: RiskScore;
+    industry?: Industry;
+    strategies: StrategyRecommendation[];
+    preference_match?: PreferenceMatchResult;
+    industry_risks?: IndustryRiskResult;
+    reminders: Reminder[];
+    blocking_reminders: Reminder[];
+    confidence: ConfidenceScore;
+    summary: string;
+}
+export declare function assemblePreorderAdvice(input: PreorderAdviceInput): PreorderAdvice;

package/dist/customer/customer-advice.js

@@ -0,0 +1,129 @@
+import { assessRisk, detectScenarios, recommendStrategy, matchServiceToPreferences, assessIndustryRisks, inferIndustry, generateReminders, getBlockingReminders, sortAndCapReminders, } from "./index.js";
+import { registryDisplayHint } from "../knowledge/fund-layer.js";
+export function assemblePreorderAdvice(input) {
+    const { puzzle } = input;
+    const risk = input.risk ?? assessRisk(puzzle);
+    const industry = input.industry ?? inferIndustry(puzzle);
+    const scenarios = detectScenarios(puzzle);
+    const strategies = scenarios
+        .slice(0, input.max_strategies ?? 3)
+        .map(s => recommendStrategy(s, { puzzle, prefs: input.preferences }));
+    let preferenceMatch;
+    if (input.preferences) {
+        const service = toMatchingService(puzzle, risk, input.matching_overrides);
+        preferenceMatch = matchServiceToPreferences(service, input.preferences);
+    }
+    let industryRisks;
+    if (industry) {
+        industryRisks = assessIndustryRisks(puzzle, industry);
+    }
+    const reminderCtx = buildReminderContext(puzzle, risk, input.reminder_overrides);
+    const reminders = sortAndCapReminders(generateReminders(reminderCtx))
+        .slice(0, input.max_reminders ?? 8);
+    const blocking = getBlockingReminders(reminders);
+    const confidence = computeConfidence(puzzle, risk, preferenceMatch);
+    return {
+        service_id: puzzle.service_id,
+        risk,
+        industry,
+        strategies,
+        preference_match: preferenceMatch,
+        industry_risks: industryRisks,
+        reminders,
+        blocking_reminders: blocking,
+        confidence,
+        summary: buildSummary(puzzle, risk, industry, strategies, preferenceMatch, blocking, confidence),
+    };
+}
+function toMatchingService(puzzle, risk, overrides) {
+    const basics = puzzle.service_basics;
+    const fund = puzzle.fund_safety;
+    const trust = puzzle.trust_signals;
+    const behavior = puzzle.merchant_behavior;
+    return {
+        service_id: puzzle.service_id,
+        price: basics.price_raw,
+        token_type: basics.token_type ?? "",
+        avg_market_price: puzzle.market_context?.avg_price,
+        merchant_order_history_count: behavior?.total_orders ?? 0,
+        merchant_age: behavior
+            ? behavior.total_orders >= 50 ? "established" : "emerging"
+            : "unknown",
+        has_arbitration: (trust?.arbitration_count ?? 0) > 0,
+        has_compensation_fund: fund ? fund.compensation_ratio > 0 : false,
+        has_reward_activity: false,
+        has_discount: false,
+        risk_score: risk.total,
+        trust_score: trust?.trust_score ?? 50,
+        requires_messenger: false,
+        after_sales_support_level: trust?.has_messenger ? "full" : "minimal",
+        ...overrides,
+    };
+}
+function buildReminderContext(puzzle, risk, overrides) {
+    const trust = puzzle.trust_signals;
+    const fund = puzzle.fund_safety;
+    const wf = puzzle.workflow_analysis;
+    return {
+        stage: "preorder",
+        service_id: puzzle.service_id,
+        review_count: trust?.review_total,
+        like_rate: trust?.like_rate,
+        avg_market_price: puzzle.market_context?.avg_price,
+        service_price: puzzle.service_basics.price_raw,
+        token: registryDisplayHint(puzzle.service_basics.token_type),
+        has_arbitration: (trust?.arbitration_count ?? 0) > 0,
+        has_compensation: fund ? fund.compensation_ratio > 0 : undefined,
+        compensation_ratio: fund?.compensation_ratio,
+        risk_score: risk.total,
+        risk_level: risk.level,
+        has_refund_path: wf?.has_refund_path,
+        has_messenger: trust?.has_messenger,
+        ...overrides,
+    };
+}
+function computeConfidence(puzzle, risk, match) {
+    const base = Math.max(0, Math.min(100, 100 - risk.total));
+    const userAdj = puzzle.user_metrics?.adjustment ?? 0;
+    const prefNudge = match ? Math.round((match.score - 50) / 10) : 0;
+    const score = Math.max(0, Math.min(100, base + userAdj + prefNudge));
+    const parts = [`base ${base} (= 100 - risk ${risk.total})`];
+    if (userAdj !== 0)
+        parts.push(`your custom metrics ${userAdj > 0 ? "+" : ""}${userAdj}`);
+    if (prefNudge !== 0)
+        parts.push(`preference fit ${prefNudge > 0 ? "+" : ""}${prefNudge}`);
+    return {
+        score,
+        base,
+        user_adjustment: userAdj,
+        preference_nudge: prefNudge,
+        explanation: `Confidence ${score}/100 = ${parts.join(" ")}. ` +
+            `This is evidence aggregation, not advice — the decision is yours.`,
+    };
+}
+function buildSummary(puzzle, risk, industry, strategies, match, blocking, confidence) {
+    const parts = [
+        `Order confidence ${confidence.score}/100 (risk ${risk.total}/100, level ${risk.level})` +
+            (industry ? ` for ${industry} service` : "") +
+            `. Information completeness ${Math.round(puzzle.completeness * 100)}%.`,
+    ];
+    if (blocking.length > 0) {
+        parts.push(`⚠️ ${blocking.length} blocking concern(s): ${blocking.map(r => r.message).join("; ")}`);
+    }
+    if (risk.red_flags.length > 0) {
+        parts.push(`Red flags: ${risk.red_flags.slice(0, 3).join("; ")}.`);
+    }
+    if (strategies.length > 0) {
+        const top = strategies[0];
+        parts.push(`Key protection (${top.scenario}): ${top.strategy.user_strategy}`);
+    }
+    if (match) {
+        parts.push(match.mismatches.length > 0
+            ? `Preference mismatches: ${match.mismatches.slice(0, 2).join("; ")}.`
+            : `Service matches your preferences (score ${match.score}/100).`);
+    }
+    if (puzzle.gaps.length > 0) {
+        parts.push(`Missing information: ${puzzle.gaps.join(", ")} — consider asking the merchant via Messenger before ordering.`);
+    }
+    return parts.join(" ");
+}

package/dist/customer/index.d.ts

@@ -7,3 +7,5 @@ export { monitorOrder, sortAlerts, getCriticalAlerts, getActionableAlerts, summa
 export { recommendStrategy, detectScenarios, flowMigrationStrategy, repeatGameStrategy, rightsProtectionStrategy, type StrategyContext, type StrategyRecommendation, } from "./order-strategy.js";
 export { generatePostPurchaseAdvice, trackRefund, handleQualityIssue, handleMerchantUnreachable, arbitrationSupport, generateArbitrationTemplate, type PostPurchasePhase, type PostPurchaseContext, type PostPurchaseAction, } from "./post-purchase.js";
 export { generateReminders, sortAndCapReminders, generateMultiStageReminders, isBlocking, getBlockingReminders, summarizeReminders, topReminders, type ReminderStage, type ReminderContext, } from "./reminder-system.js";
+export { assemblePreorderAdvice, type PreorderAdviceInput, type PreorderAdvice, type ConfidenceScore, } from "./customer-advice.js";
+export { buildPreorderComparison, type PreorderCompareRow, type PreorderComparison, } from "./preorder-compare.js";

package/dist/customer/index.js

@@ -7,3 +7,5 @@ export { monitorOrder, sortAlerts, getCriticalAlerts, getActionableAlerts, summa
 export { recommendStrategy, detectScenarios, flowMigrationStrategy, repeatGameStrategy, rightsProtectionStrategy, } from "./order-strategy.js";
 export { generatePostPurchaseAdvice, trackRefund, handleQualityIssue, handleMerchantUnreachable, arbitrationSupport, generateArbitrationTemplate, } from "./post-purchase.js";
 export { generateReminders, sortAndCapReminders, generateMultiStageReminders, isBlocking, getBlockingReminders, summarizeReminders, topReminders, } from "./reminder-system.js";
+export { assemblePreorderAdvice, } from "./customer-advice.js";
+export { buildPreorderComparison, } from "./preorder-compare.js";

package/dist/customer/info-puzzle.d.ts

@@ -65,12 +65,15 @@ export declare function assembleFundSafety(raw: ServiceRawData, orderAmount: big
 export declare function assembleTrustSignals(service: ServiceRawData, reviews: ReviewRaw[], trustScore: {
     score: number;
     level: string;
-}, arbitrationOwner?: string, serviceOwner?: string): TrustSignals;
+}, arbitrationOwner?: string, serviceOwner?: string, permissionShared?: boolean, permissionOverlap?: boolean): TrustSignals;
 export declare function assembleMerchantBehavior(events: EventRaw[], orderHistory?: Array<{
     status: string;
     has_dispute: boolean;
     is_repeat: boolean;
-}>): MerchantBehavior;
+}>, reputation?: {
+    likes: number;
+    dislikes: number;
+}): MerchantBehavior;
 export declare function assembleMarketContext(similarServices: Array<{
     price: bigint;
 }>, currentPrice: bigint): MarketContext;
@@ -97,6 +100,10 @@ export interface PuzzleRawData {
         has_dispute: boolean;
         is_repeat: boolean;
     }>;
+    merchant_reputation?: {
+        likes: number;
+        dislikes: number;
+    };
     user_metrics_config?: UserMetricsConfig;
     user_metrics_context?: Record<string, unknown>;
     service_nesting_raw?: ServiceNestingRawData;

package/dist/customer/info-puzzle.js

@@ -32,8 +32,8 @@ export function assembleWorkflowAnalysis(nodes, isPublished, isPaused, serviceRa
     let hasMilestone = false;
     let hasWonderNode = false;
     let hasDisputeAntiPattern = false;
-    const antiPatternNodeRegex = /^(disputed|refunded|arb|arbitration|dispute|refund)$/i;
-    const wonderNodeRegex = /^(wonder|no_wonder|praise|complain|thumbs_up|thumbs_down|好评|差评)$/i;
+    const antiPatternNodeRegex = /(^|_)(disputed?|refund(?:ed)?|arbitration|arb)(_|$)/i;
+    const wonderNodeRegex = /^(wonder|no_wonder|praise|complain|thumbs_up|thumbs_down|positive_review|negative_review)$/i;
     const totalForwards = nodes.reduce((sum, n) => sum + (n.forwards?.length ?? 0), 0);
     for (const node of nodes) {
         if (antiPatternNodeRegex.test(node.name.trim())) {
@@ -146,7 +146,7 @@ export function assembleFundSafety(raw, orderAmount) {
         price_anomaly: priceAnomaly,
     };
 }
-export function assembleTrustSignals(service, reviews, trustScore, arbitrationOwner, serviceOwner) {
+export function assembleTrustSignals(service, reviews, trustScore, arbitrationOwner, serviceOwner, permissionShared, permissionOverlap) {
     const likes = reviews.filter((r) => r.rating === "like").length;
     const dislikes = reviews.filter((r) => r.rating === "dislike").length;
     const verified = reviews.filter((r) => r.verified || r.has_evidence).length;
@@ -168,9 +168,31 @@ export function assembleTrustSignals(service, reviews, trustScore, arbitrationOw
         trust_level: trustScore.level,
         has_contact: !!service.um,
         has_messenger: !!service.um,
+        arbitration_permission_shared: permissionShared,
+        arbitration_permission_overlap: permissionOverlap,
     };
 }
-export function assembleMerchantBehavior(events, orderHistory) {
+const REPUTATION_MIN_VOTES = 3;
+function toReputation(rep) {
+    const total = rep.likes + rep.dislikes;
+    return {
+        likes: rep.likes,
+        dislikes: rep.dislikes,
+        like_ratio: total > 0 ? rep.likes / total : 1,
+    };
+}
+function reputationRedFlags(rep) {
+    if (!rep)
+        return [];
+    const total = rep.likes + rep.dislikes;
+    if (total >= REPUTATION_MIN_VOTES && rep.like_ratio < 0.5) {
+        return ["reputation_negative"];
+    }
+    return [];
+}
+export function assembleMerchantBehavior(events, orderHistory, reputation) {
+    const rep = reputation ? toReputation(reputation) : undefined;
+    const repFlags = reputationRedFlags(rep);
     if (orderHistory && orderHistory.length > 0) {
         const total = orderHistory.length;
         const completed = orderHistory.filter((o) => o.status === "completed").length;
@@ -191,7 +213,7 @@ export function assembleMerchantBehavior(events, orderHistory) {
             else if (secondRate > firstRate * 1.15)
                 trend = "declining";
         }
-        const redFlags = [];
+        const redFlags = [...repFlags];
         if (disputeRate > 0.1)
             redFlags.push("dispute_rate_high");
         if (trend === "declining")
@@ -205,6 +227,7 @@ export function assembleMerchantBehavior(events, orderHistory) {
             repeat_buyer_rate: repeatRate,
             recent_trend: trend,
             red_flags: redFlags,
+            reputation: rep,
         };
     }
     const orderEvents = events.filter((e) => e.type.includes("Order") || e.type.includes("order"));
@@ -212,7 +235,7 @@ export function assembleMerchantBehavior(events, orderHistory) {
     const total = orderEvents.length;
     const disputes = disputeEvents.length;
     const disputeRate = total > 0 ? disputes / total : 0;
-    const redFlags = [];
+    const redFlags = [...repFlags];
     if (disputeRate > 0.1)
         redFlags.push("dispute_rate_high");
     return {
@@ -224,6 +247,7 @@ export function assembleMerchantBehavior(events, orderHistory) {
         repeat_buyer_rate: 0,
         recent_trend: "stable",
         red_flags: redFlags,
+        reputation: rep,
     };
 }
 export function assembleMarketContext(similarServices, currentPrice) {
@@ -282,7 +306,10 @@ export function assembleInfoPuzzle(serviceId, raw, depth = "evaluate") {
     let merchantBehavior;
     if (depth === "preorder" || depth === "monitor") {
         if (raw.events || raw.order_history) {
-            merchantBehavior = assembleMerchantBehavior(raw.events ?? [], raw.order_history);
+            merchantBehavior = assembleMerchantBehavior(raw.events ?? [], raw.order_history, raw.merchant_reputation);
+        }
+        else if (raw.merchant_reputation) {
+            merchantBehavior = assembleMerchantBehavior([], undefined, raw.merchant_reputation);
         }
         else {
             gaps.push("merchant_behavior");

package/dist/customer/order-monitor.d.ts

@@ -1,5 +1,6 @@
 import type { RiskLevel } from "./types.js";
 import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+import { type TokenDisplayHint } from "../knowledge/fund-layer.js";
 export type AlertSeverity = "info" | "warning" | "critical";
 export type AlertCategory = "progress_stall" | "compensation_drop" | "compensation_insufficient" | "messenger_timeout" | "user_action_required" | "review_window" | "arb_window" | "refund_received" | "anomaly";
 export interface MonitorAlert {
@@ -30,6 +31,7 @@ export interface OrderSnapshot {
     expected_progress_hours?: number;
     order_amount?: bigint;
     compensation_balance?: bigint;
+    token?: TokenDisplayHint;
     has_arbitration?: boolean;
     has_messenger?: boolean;
     last_merchant_reply_at?: number;

package/dist/customer/order-monitor.js

@@ -1,4 +1,5 @@
 import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+import { formatAmountText } from "../knowledge/fund-layer.js";
 const DEFAULT_THRESHOLDS = {
     progress_stall_hours: 0,
     compensation_drop_ratio: 0.3,
@@ -118,7 +119,7 @@ function detectCompensationChange(cur, prev, t) {
                 category: "compensation_insufficient",
                 severity,
                 title: "Compensation fund coverage insufficient",
-                message: `Merchant compensation fund covers only ${Math.round(ratio * 100)}% of the order amount (required ${Math.round(t.compensation_coverage_min * 100)}%)`,
+                message: `Merchant compensation fund covers only ${Math.round(ratio * 100)}% of the order amount (required ${Math.round(t.compensation_coverage_min * 100)}%): fund ${formatAmountText(cur.compensation_balance, cur.token?.decimals, cur.token?.symbol)} vs order ${formatAmountText(cur.order_amount, cur.token?.decimals, cur.token?.symbol)}`,
                 action: "Require the merchant to top up the compensation fund before ordering, or negotiate higher coverage via Messenger",
                 timestamp: cur.now,
                 order_id: cur.order_id,
@@ -143,7 +144,7 @@ function detectCompensationChange(cur, prev, t) {
                     category: "compensation_drop",
                     severity,
                     title: "Compensation fund balance dropped significantly",
-                    message: `Merchant compensation fund dropped from ${prevBal} to ${cur.compensation_balance} (down ${Math.round(dropRatio * 100)}%)`,
+                    message: `Merchant compensation fund dropped from ${formatAmountText(prevBal, cur.token?.decimals, cur.token?.symbol)} to ${formatAmountText(cur.compensation_balance, cur.token?.decimals, cur.token?.symbol)} (down ${Math.round(dropRatio * 100)}%)`,
                     action: "Immediately ask the merchant for the reason; if it keeps dropping, the merchant may be processing payouts for other orders, which is a risk",
                     timestamp: cur.now,
                     order_id: cur.order_id,

package/dist/customer/post-purchase.d.ts

@@ -1,5 +1,6 @@
 import type { InfoPuzzle } from "./types.js";
 import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+import { type TokenDisplayHint } from "../knowledge/fund-layer.js";
 export type PostPurchasePhase = "refund_tracking" | "quality_issue" | "merchant_unreachable" | "arbitration_support";
 export interface PostPurchaseContext {
     phase: PostPurchasePhase;
@@ -8,6 +9,7 @@ export interface PostPurchaseContext {
     puzzle?: InfoPuzzle;
     order_amount?: bigint;
     refunded_amount?: bigint;
+    token?: TokenDisplayHint;
     wip_hash?: string;
     original_wip_hash?: string;
     last_merchant_reply_at?: number;

package/dist/customer/post-purchase.js

@@ -1,4 +1,5 @@
 import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+import { formatAmountText } from "../knowledge/fund-layer.js";
 export function generatePostPurchaseAdvice(ctx) {
     switch (ctx.phase) {
         case "refund_tracking":
@@ -21,7 +22,7 @@ export function trackRefund(ctx) {
             phase: "refund_tracking",
             priority: "info",
             title: "Refund complete",
-            message: `✅ Order ${ctx.order_id} refund fully received (${refunded} smallest units)`,
+            message: `✅ Order ${ctx.order_id} refund fully received (${formatAmountText(refunded, ctx.token?.decimals, ctx.token?.symbol)})`,
             next_step: "You can close post-purchase tracking; recommend submitting an order review",
         });
         return actions;
@@ -33,7 +34,7 @@ export function trackRefund(ctx) {
             phase: "refund_tracking",
             priority: "required",
             title: "Refund incomplete",
-            message: `⚠️ Order ${ctx.order_id} only refunded ${refunded}/${orderAmount}; the difference of ${diff} smallest units has not been received`,
+            message: `⚠️ Order ${ctx.order_id} only refunded ${formatAmountText(refunded, ctx.token?.decimals, ctx.token?.symbol)} of ${formatAmountText(orderAmount, ctx.token?.decimals, ctx.token?.symbol)}; the difference of ${formatAmountText(diff, ctx.token?.decimals, ctx.token?.symbol)} has not been received`,
             next_step: "Urge the merchant via Messenger to make up the difference, or initiate arbitration to recover it",
             tool: "messenger_send",
         });
@@ -284,7 +285,7 @@ export function generateArbitrationTemplate(ctx) {
     descriptionParts.push(`Dispute type: ${phaseLabel}`);
     switch (ctx.phase) {
         case "refund_tracking":
-            descriptionParts.push(`Dispute summary: The merchant did not refund as required. Order amount ${ctx.order_amount ?? "unknown"} smallest units, refunded ${ctx.refunded_amount ?? 0n} smallest units.`);
+            descriptionParts.push(`Dispute summary: The merchant did not refund as required. Order amount ${ctx.order_amount !== undefined ? formatAmountText(ctx.order_amount, ctx.token?.decimals, ctx.token?.symbol) : "unknown"}, refunded ${formatAmountText(ctx.refunded_amount ?? 0n, ctx.token?.decimals, ctx.token?.symbol)}.`);
             break;
         case "quality_issue":
             descriptionParts.push(`Dispute summary: The deliverable has quality issues. Original WIP hash: ${ctx.original_wip_hash ?? "unknown"}, current: ${ctx.wip_hash ?? "unknown"}.`);
@@ -335,9 +336,9 @@ function buildClaim(ctx) {
             const refunded = ctx.refunded_amount ?? 0n;
             const diff = orderAmount - refunded;
             if (refunded === 0n) {
-                return `Request the arbitrator to order a full refund (${orderAmount} smallest units).`;
+                return `Request the arbitrator to order a full refund (${formatAmountText(orderAmount, ctx.token?.decimals, ctx.token?.symbol)}).`;
             }
-            return `Request the arbitrator to order the merchant to make up the refund difference (${diff} smallest units).`;
+            return `Request the arbitrator to order the merchant to make up the refund difference (${formatAmountText(diff, ctx.token?.decimals, ctx.token?.symbol)}).`;
         }
         case "quality_issue":
             return "Request the arbitrator to order the merchant to redeliver a deliverable that meets the agreement, or to fully refund.";

package/dist/customer/preorder-compare.d.ts

@@ -0,0 +1,24 @@
+export interface PreorderCompareRow {
+    service_id: string;
+    service_name: string;
+    error?: string;
+    industry?: string;
+    confidence?: number;
+    risk_total?: number;
+    risk_level?: string;
+    trust_score?: number;
+    trust_level?: string;
+    preference_match?: number;
+    reputation_like_ratio?: number;
+    reputation_votes?: number;
+    red_flags_count?: number;
+    blocking_reminders_count?: number;
+    info_gaps_count?: number;
+}
+export interface PreorderComparison {
+    rows: PreorderCompareRow[];
+    best_per_metric: Record<string, string[]>;
+    evaluated_metrics: string[];
+    note: string;
+}
+export declare function buildPreorderComparison(rows: PreorderCompareRow[]): PreorderComparison;

package/dist/customer/preorder-compare.js

@@ -0,0 +1,34 @@
+const METRICS = [
+    { key: "confidence", name: "confidence", direction: "high" },
+    { key: "risk_total", name: "risk_total", direction: "low" },
+    { key: "trust_score", name: "trust_score", direction: "high" },
+    { key: "preference_match", name: "preference_match", direction: "high" },
+    { key: "reputation_like_ratio", name: "reputation_like_ratio", direction: "high" },
+    { key: "red_flags_count", name: "red_flags_count", direction: "low" },
+    { key: "blocking_reminders_count", name: "blocking_reminders_count", direction: "low" },
+    { key: "info_gaps_count", name: "info_gaps_count", direction: "low" },
+];
+const NEUTRALITY_NOTE = "Per-metric bests only — NO overall ranking is computed. " +
+    "Metric weights are the buyer's own: re-run with user_metrics to change what matters. " +
+    "A service 'best' on one metric may be worst on another; the decision is yours.";
+export function buildPreorderComparison(rows) {
+    const best_per_metric = {};
+    const evaluated_metrics = [];
+    for (const m of METRICS) {
+        const candidates = rows.filter((r) => !r.error && typeof r[m.key] === "number");
+        if (candidates.length < 2)
+            continue;
+        const values = candidates.map((r) => r[m.key]);
+        const best = m.direction === "high" ? Math.max(...values) : Math.min(...values);
+        best_per_metric[m.name] = candidates
+            .filter((r) => r[m.key] === best)
+            .map((r) => r.service_id);
+        evaluated_metrics.push(m.name);
+    }
+    return {
+        rows,
+        best_per_metric,
+        evaluated_metrics,
+        note: NEUTRALITY_NOTE,
+    };
+}

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

@@ -1,5 +1,6 @@
 import type { Reminder, RiskLevel } from "./types.js";
 import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+import { type TokenDisplayHint } from "../knowledge/fund-layer.js";
 export type ReminderStage = "browse" | "evaluate" | "preorder" | "in_progress" | "complete" | "after_sale";
 export interface ReminderContext {
     stage: ReminderStage;
@@ -13,6 +14,7 @@ export interface ReminderContext {
     has_compensation?: boolean;
     compensation_balance?: bigint;
     compensation_ratio?: number;
+    token?: TokenDisplayHint;
     risk_score?: number;
     risk_level?: RiskLevel;
     has_refund_path?: boolean;

package/dist/customer/reminder-system.js

@@ -1,4 +1,5 @@
 import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+import { formatAmountText } from "../knowledge/fund-layer.js";
 const REMINDER_RULES = [
     {
         id: "browse_reviews_summary",
@@ -108,7 +109,7 @@ const REMINDER_RULES = [
         id: "preorder_payment_confirm",
         stage: "preorder",
         priority: "required",
-        message: (ctx) => `🔔 About to pay ${ctx.service_price} smallest units to the escrow account, please confirm`,
+        message: (ctx) => `🔔 About to pay ${formatAmountText(ctx.service_price ?? 0n, ctx.token?.decimals, ctx.token?.symbol)} to the escrow account, please confirm`,
         applies: (ctx) => ctx.service_price !== undefined,
         dedup_key: "payment_confirm",
     },

package/dist/customer/risk-assessment.js

@@ -134,13 +134,35 @@ function assessTrustRisk(puzzle) {
     const trust = puzzle.trust_signals;
     const checks = [];
     const arbIndependent = trust?.arbitration_independent ?? true;
+    const permShared = trust?.arbitration_permission_shared === true;
+    const permOverlap = trust?.arbitration_permission_overlap === true;
+    let arbPassed = arbIndependent;
+    let arbAdvice;
+    let arbWeight = 6;
+    if (permShared) {
+        arbPassed = false;
+        arbAdvice = "🔴 CRITICAL: Arbitration and Service share the SAME Permission object. " +
+            "The merchant fully controls arbitration operations (vote, confirm, execute rulings). " +
+            "Dispute fairness cannot be guaranteed. Require the merchant to use a separate, " +
+            "independent Permission object for Arbitration before ordering.";
+    }
+    else if (permOverlap) {
+        arbPassed = false;
+        arbAdvice = "🔴 WARNING: Arbitration and Service have overlapping Permission control " +
+            "(shared owner or admin). Even with separate Permission objects, the merchant can " +
+            "influence dispute outcomes. For mainnet, require completely independent third-party " +
+            "Permission (different owner and admin list) for Arbitration.";
+    }
+    else if (!arbIndependent) {
+        arbAdvice = "🔴 Arbitrator and merchant are the same address: arbitration fairness cannot be guaranteed.";
+    }
     checks.push({
         id: "trust_arb_independent",
         dimension: "trust",
-        description: "Arbitrator has no conflict of interest with the merchant",
-        weight: 6,
-        passed: arbIndependent,
-        advice: arbIndependent ? undefined : "🔴 Arbitrator and merchant are the same address: arbitration fairness cannot be guaranteed.",
+        description: "Arbitrator has no conflict of interest with the merchant (Permission isolation)",
+        weight: arbWeight,
+        passed: arbPassed,
+        advice: arbAdvice,
     });
     let reviewPassed = false;
     let reviewAdvice;
@@ -223,7 +245,8 @@ function assessBehaviorRisk(puzzle) {
         passed: trendPassed,
         advice: trendAdvice,
     });
-    const completionPassed = beh ? beh.completed_rate >= 0.85 : true;
+    const hasOrders = beh != null && beh.total_orders > 0;
+    const completionPassed = hasOrders ? beh.completed_rate >= 0.85 : true;
     checks.push({
         id: "behavior_completion_rate",
         dimension: "behavior",
@@ -232,7 +255,7 @@ function assessBehaviorRisk(puzzle) {
         passed: completionPassed,
         advice: completionPassed ? undefined : `🔴 Completion rate is only ${Math.round((beh?.completed_rate ?? 0) * 100)}%: a higher-than-average share of orders end in failure.`,
     });
-    const disputeOk = beh ? beh.dispute_rate <= 0.1 : true;
+    const disputeOk = hasOrders ? beh.dispute_rate <= 0.1 : true;
     checks.push({
         id: "behavior_low_dispute",
         dimension: "behavior",
@@ -241,7 +264,7 @@ function assessBehaviorRisk(puzzle) {
         passed: disputeOk,
         advice: disputeOk ? undefined : `⚠️ Dispute rate is ${Math.round((beh?.dispute_rate ?? 0) * 100)}%: above the industry average.`,
     });
-    const arbLossOk = beh ? beh.arb_loss_rate <= 0.3 : true;
+    const arbLossOk = hasOrders ? beh.arb_loss_rate <= 0.3 : true;
     checks.push({
         id: "behavior_arb_loss",
         dimension: "behavior",

package/dist/customer/types.d.ts

@@ -61,6 +61,8 @@ export interface TrustSignals {
     trust_level: "high_risk" | "caution" | "moderate" | "trusted";
     has_contact: boolean;
     has_messenger: boolean;
+    arbitration_permission_shared?: boolean;
+    arbitration_permission_overlap?: boolean;
 }
 export interface MerchantBehavior {
     total_orders: number;
@@ -71,6 +73,11 @@ export interface MerchantBehavior {
     repeat_buyer_rate: number;
     recent_trend: "improving" | "stable" | "declining";
     red_flags: string[];
+    reputation?: {
+        likes: number;
+        dislikes: number;
+        like_ratio: number;
+    };
 }
 export interface MarketContext {
     similar_services_count: number;

package/dist/examples/arbitration-dispute-create.json

@@ -0,0 +1,41 @@
+{
+  "title": "Open Dispute on an Order (Arbitration Case Creation)",
+  "description": "Customer opens a dispute on order myshop_order_v1 via the MyShop Arbitration object, paying the dispute fee and naming the new Arb case object for later vote/verdict operations.",
+  "tags": ["arbitration", "dispute", "order", "retail"],
+  "industry": "retail",
+  "operation_type": "arbitration",
+  "source": "constructed under T-09 authorization; grounded in DisputeSchema + SDK arbitration.ts dispute flow + arb.move dispute_imp — schema-validated, not chain-verified",
+  "verified": false,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "arbitration",
+    "data": {
+      "object": "myshop_arbitration_v2",
+      "dispute": {
+        "order": "myshop_order_v1",
+        "description": "Toy arrived damaged; requesting refund per service promise.",
+        "proposition": [
+          "Full refund to customer",
+          "Partial refund 50%",
+          "No refund — service delivered as promised"
+        ],
+        "fee": { "balance": 5000000 },
+        "namedArb": { "name": "myshop_dispute_v1" }
+      }
+    },
+    "env": {
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "PREREQUISITES (SDK-validated client-side): the Arbitration must NOT be paused (bPaused=false — new Arbitrations are created paused; unpause first via {object:'myshop_arbitration_v2', pause:false}); the Order must not be already claimed (claimed_by empty) and must have fewer than MAX_DISPUTE_COUNT disputes.",
+    "fee uses CoinParam {balance: <smallest unit>} — 5000000 = 0.005 WOW (9 decimals). Contract asserts fee >= arbitration.fee (E_FEE_NOT_ENOUGH); excess is split and returned to the sender.",
+    "proposition is the list of options voters choose between; votes reference propositions by 0-BASED INDEX (0='Full refund', 1='Partial 50%', 2='No refund'). Order matters and is immutable once the Arb is created.",
+    "namedArb names the NEW Arb (arbitration case) object — strongly recommended: subsequent confirm/vote/arbitration calls reference the case by this name ('myshop_dispute_v1') instead of a raw address.",
+    "If the Arbitration has a usage_guard configured, the dispute caller must pass that Guard (SDK auto-adds it to the passport verification list). This example assumes no usage_guard.",
+    "The Arb case is created in a pre-voting state; the arbitrator next calls confirm with a voting_deadline to open the voting window."
+  ]
+}