@wowok/agent-mcp 2.6.3 → 2.6.6

package/README.md

@@ -46,28 +46,32 @@ wowok-skills init --target all       # All 10 supported clients
 
 #### Available Skills
 
-**Always loaded** (3 skills — foundational layer):
+**Always loaded** (1 skill — foundational layer):
 
 | Skill | Purpose |
 |-------|---------|
-| `wowok-tools` | MCP tool reference — 17 sub-tools, schema-gated execution, constraints |
-| `wowok-safety` | Safety protocol — dry-run → confirm → execute, immutability rules |
 | `wowok-output` | Output processing — address resolution, name mapping, data visualization |
 
-**On-demand** (11 skills — loaded by context):
+**On-demand** (8 skills — loaded by context):
 
 | Skill | Role | Purpose |
 |-------|------|---------|
+| `wowok-order` | 👤 Customer | Order lifecycle — due diligence, consensus, order creation, progress, arbitration |
 | `wowok-provider` | 🏪 Provider | Service provider guide — create Service, Machine, Allocators, order fulfillment |
 | `wowok-machine` | 🏪 Provider | Workflow design — state machines, node/pair/forward graph, publish lifecycle |
-| `wowok-order` | 👤 Customer | Order lifecycle — due diligence, consensus, order creation, progress, arbitration |
 | `wowok-arbitrator` | ⚖️ Arbitrator | Arbitration service — dispute resolution, weighted voting, fee management |
-| `wowok-guard` | 🛠️ Shared | Guard design — programmable trust rules, 4 data sources, 33 constraints |
 | `wowok-messenger` | 🛠️ Shared | Encrypted messaging — E2E communication, WTS evidence, anti-spam |
 | `wowok-onboard` | 🆕 New User | First-touch onboarding — 10-round dialogue from zero to first published Service |
-| `wowok-scenario` | 🛠️ Shared | Industry mode templates — freelance, rental, education, travel presets |
 | `wowok-planner` | 🛠️ Shared | Planning — converts natural language intent into Object Dependency Graph (ODG) |
 | `wowok-auditor` | 🛠️ Shared | Pre-publish audit — Guard completeness, Machine soundness, 32 audit checks |
-| `wowok-distill` | 🏪 Provider | Distillation review — review AI-generated improvement proposals |
 
-> **Tip:** `wowok-tools` + `wowok-safety` + `wowok-output` are always loaded and serve all roles. Add role-specific skills (`wowok-provider`, `wowok-order`, `wowok-arbitrator`) as needed.
+**Deprecated** (sunk to MCP knowledge layer — no longer installed as skills; their content is served by `schema_query` / `project_operation`):
+
+| Skill | Replaced By |
+|-------|-------------|
+| `wowok-tools` | `schema_query action='get_tool_reference'` |
+| `wowok-safety` | `schema_query action='get_safety_rules'` + runtime confirm-gate |
+| `wowok-guard` | `schema_query action='get_guard_design_patterns'` |
+| `wowok-scenario` | `project_operation` (recommend_industry / create_project) |
+
+> **Tip:** `wowok-output` is always loaded. Add role-specific skills (`wowok-order`, `wowok-provider`, `wowok-arbitrator`) as needed. Guard design, safety rules, tool reference, and industry mode content are now served directly by the MCP server — no skill installation required.

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

@@ -70,7 +70,10 @@ export declare function assembleMerchantBehavior(events: EventRaw[], orderHistor
     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,7 +32,7 @@ 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 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) {
@@ -172,7 +172,27 @@ export function assembleTrustSignals(service, reviews, trustScore, arbitrationOw
         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;
@@ -193,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")
@@ -207,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"));
@@ -214,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 {
@@ -226,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) {
@@ -284,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

@@ -245,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",
@@ -254,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",
@@ -263,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

@@ -73,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."
+  ]
+}

package/dist/examples/arbitration-vote-weighted.json

@@ -0,0 +1,35 @@
+{
+  "title": "Vote on Dispute Propositions via Voting Guard",
+  "description": "Eligible arbitrator casts a weighted vote for proposition 0 (full refund) on dispute case myshop_dispute_v1, verifying through the configured voting_guard.",
+  "tags": ["arbitration", "vote", "dispute", "guard"],
+  "industry": "retail",
+  "operation_type": "arbitration",
+  "source": "constructed under T-09 authorization; grounded in VoteSchema + SDK arbitration.ts vote flow + arb.move vote (re-vote replaces) — schema-validated, not chain-verified",
+  "verified": false,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "arbitration",
+    "data": {
+      "object": "myshop_arbitration_v2",
+      "vote": {
+        "arb": "myshop_dispute_v1",
+        "votes": [0],
+        "voting_guard": "arbitrator_eligibility_guard"
+      }
+    },
+    "env": {
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "votes elements are PROPOSITION INDICES (u8, 0-based) into the dispute's proposition list — [0] means 'agree with proposition 0 (Full refund)'. Voting for multiple propositions at once is allowed (e.g. [0,1]); each listed index receives the voter's full weight. An out-of-range index aborts with E_PROPOSITION_NOT_FOUND.",
+    "RE-VOTING REPLACES: a second vote by the same voter removes the old weight from previously voted indices and applies it to the new set (arb.move vote). There is no separate 'unvote' operation.",
+    "SDK REQUIREMENT (call/arbitration.ts L264-273): when voting on an EXISTING Arbitration through the SDK/MCP path, vote.voting_guard is effectively REQUIRED — the SDK adds it to the passport verification list and errors 'vote.voting_guard invalid' if omitted, even though the MCP schema marks it optional. Always provide it.",
+    "PREREQUISITES: (1) the Arb case must be in Status_Voting — the arbitrator has called confirm with a voting_deadline; (2) voting must be within the deadline (E_VOTING_DEADLINE_PASSED); (3) the guard must be in the Arbitration's voting_guard list (see arbitration-voting-guard-add example) and the voter must pass its verification.",
+    "Weight resolution (arbitration.move vote_with_voting_guard): {FixedValue: n} → weight n; {GuardIdentifier: i} → weight read from the voter's passport submission at that Guard table index.",
+    "Voting concludes when the arbitrator calls arbitration (verdict) with an indemnity amount; the verdict only RECORDS the indemnity on the Arb — the customer then claims compensation from the Service's compensation_fund via order compensation_claim."
+  ]
+}