@wowok/agent-mcp 2.5.2 → 2.5.4

package/dist/customer/index.d.ts

@@ -1,5 +1,5 @@
-export { CUSTOMER_INTELLIGENCE_VERSION, RISK_LEVELS, RISK_DIMENSION_MAX, type PuzzleDepth, type ServiceBasics, type WorkflowAnalysis, type FundSafety, type TrustSignals, type MerchantBehavior, type MarketContext, type InfoPuzzle, type RiskDimensionName, type RiskCheck, type RiskDimensionScore, type RiskLevel, type RiskScore, type UserPreferences, type ReminderPriority, type Reminder, type GameScenario, type GameStrategy, type CustomerAdvice, } from "./types.js";
-export { assembleServiceBasics, assembleWorkflowAnalysis, assembleFundSafety, assembleTrustSignals, assembleMerchantBehavior, assembleMarketContext, assembleInfoPuzzle, type ServiceRawData, type MachineNodeRaw, type ReviewRaw, type EventRaw, type PuzzleRawData, } from "./info-puzzle.js";
+export { CUSTOMER_INTELLIGENCE_VERSION, RISK_LEVELS, RISK_DIMENSION_MAX, type PuzzleDepth, type ServiceBasics, type WorkflowAnalysis, type FundSafety, type TrustSignals, type MerchantBehavior, type MarketContext, type InfoPuzzle, type RiskDimensionName, type RiskCheck, type RiskDimensionScore, type RiskLevel, type RiskScore, type UserPreferences, type ReminderPriority, type Reminder, type GameScenario, type GameStrategy, type CustomerAdvice, type UserMetricEvaluatorType, type UserMetric, type UserMetricsConfig, type UserMetricResult, type UserMetricsResult, type ServiceNestingEvaluation, } from "./types.js";
+export { assembleServiceBasics, assembleWorkflowAnalysis, assembleFundSafety, assembleTrustSignals, assembleMerchantBehavior, assembleMarketContext, assembleInfoPuzzle, assembleUserMetrics, evaluateServiceNesting, type ServiceRawData, type MachineNodeRaw, type ReviewRaw, type EventRaw, type PuzzleRawData, type ServiceNestingRawData, } from "./info-puzzle.js";
 export { riskLevelFromScore, riskLevelLabel, riskLevelEmoji, assessRisk, passesRiskThreshold, } from "./risk-assessment.js";
 export { getIndustryRiskChecks, getIndustryNeeds, checkIndustryNeeds, assessIndustryRisks, inferIndustry, type IndustryNeedTier, type IndustryNeed, type IndustryRiskCheck, type IndustryRiskResult, } from "./industry-risks.js";
 export { getDefaultPreferences, getIndustryTemplate, inferPreferences, matchServiceToPreferences, mergePreferences, validatePreferences, SUPPORTED_INDUSTRIES, type Industry, type IndustryTemplate, type OrderHistoryEntry, type PreferenceInference, type ServiceForMatching, type PreferenceMatchResult, } from "./user-preferences.js";

package/dist/customer/index.js

@@ -1,5 +1,5 @@
 export { CUSTOMER_INTELLIGENCE_VERSION, RISK_LEVELS, RISK_DIMENSION_MAX, } from "./types.js";
-export { assembleServiceBasics, assembleWorkflowAnalysis, assembleFundSafety, assembleTrustSignals, assembleMerchantBehavior, assembleMarketContext, assembleInfoPuzzle, } from "./info-puzzle.js";
+export { assembleServiceBasics, assembleWorkflowAnalysis, assembleFundSafety, assembleTrustSignals, assembleMerchantBehavior, assembleMarketContext, assembleInfoPuzzle, assembleUserMetrics, evaluateServiceNesting, } from "./info-puzzle.js";
 export { riskLevelFromScore, riskLevelLabel, riskLevelEmoji, assessRisk, passesRiskThreshold, } from "./risk-assessment.js";
 export { getIndustryRiskChecks, getIndustryNeeds, checkIndustryNeeds, assessIndustryRisks, inferIndustry, } from "./industry-risks.js";
 export { getDefaultPreferences, getIndustryTemplate, inferPreferences, matchServiceToPreferences, mergePreferences, validatePreferences, SUPPORTED_INDUSTRIES, } from "./user-preferences.js";

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

@@ -1,4 +1,4 @@
-import type { InfoPuzzle, ServiceBasics, WorkflowAnalysis, FundSafety, TrustSignals, MerchantBehavior, MarketContext, PuzzleDepth } from "./types.js";
+import type { InfoPuzzle, ServiceBasics, WorkflowAnalysis, FundSafety, TrustSignals, MerchantBehavior, MarketContext, PuzzleDepth, UserMetricsConfig, UserMetricsResult, ServiceNestingEvaluation } from "./types.js";
 import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
 export interface ServiceRawData {
     name?: string;
@@ -60,7 +60,7 @@ export interface EventRaw {
     data?: Record<string, unknown>;
 }
 export declare function assembleServiceBasics(serviceId: string, raw: ServiceRawData, wipVerified?: boolean): ServiceBasics;
-export declare function assembleWorkflowAnalysis(nodes: MachineNodeRaw[], isPublished: boolean, isPaused: boolean): WorkflowAnalysis;
+export declare function assembleWorkflowAnalysis(nodes: MachineNodeRaw[], isPublished: boolean, isPaused: boolean, serviceRaw?: ServiceRawData): WorkflowAnalysis;
 export declare function assembleFundSafety(raw: ServiceRawData, orderAmount: bigint): FundSafety;
 export declare function assembleTrustSignals(service: ServiceRawData, reviews: ReviewRaw[], trustScore: {
     score: number;
@@ -97,6 +97,43 @@ export interface PuzzleRawData {
         has_dispute: boolean;
         is_repeat: boolean;
     }>;
+    user_metrics_config?: UserMetricsConfig;
+    user_metrics_context?: Record<string, unknown>;
+    service_nesting_raw?: ServiceNestingRawData;
+    service_nesting?: ServiceNestingEvaluation;
 }
 export declare function assembleInfoPuzzle(serviceId: string, raw: PuzzleRawData, depth?: PuzzleDepth): InfoPuzzle;
+export declare function assembleUserMetrics(config: UserMetricsConfig, context: Record<string, unknown>): UserMetricsResult;
+export interface ServiceNestingRawData {
+    service_id: string;
+    depth?: number;
+    maxDepth?: number;
+    machine?: {
+        object_id: string;
+        published: boolean;
+        paused: boolean;
+        has_dispute_anti_pattern?: boolean;
+        has_no_entry?: boolean;
+        has_no_terminal?: boolean;
+        structural_issue_count?: number;
+    };
+    arbitrations?: Array<{
+        object_id: string;
+        voting_guard_count: number;
+        fee_balance: bigint;
+        paused: boolean;
+    }>;
+    rewards?: Array<{
+        object_id: string;
+        balance: bigint;
+        guard_count: number;
+        expiration_time?: number;
+    }>;
+    repositories?: Array<{
+        object_id: string;
+        has_write_guard: boolean;
+        is_empty: boolean;
+    }>;
+}
+export declare function evaluateServiceNesting(raw: ServiceNestingRawData): ServiceNestingEvaluation | undefined;
 export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/customer/info-puzzle.js

@@ -22,17 +22,24 @@ export function assembleServiceBasics(serviceId, raw, wipVerified = false) {
         wip_verified: wipVerified,
     };
 }
-export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
+export function assembleWorkflowAnalysis(nodes, isPublished, isPaused, serviceRaw) {
     const riskSignals = [];
     const terminalNodes = [];
     const deadEndNodes = [];
     let userOperable = 0;
     let providerOnly = 0;
     let guardGated = 0;
-    let hasRefundPath = false;
-    let hasArbitrationPath = false;
     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 totalForwards = nodes.reduce((sum, n) => sum + (n.forwards?.length ?? 0), 0);
+    for (const node of nodes) {
+        if (antiPatternNodeRegex.test(node.name.trim())) {
+            hasDisputeAntiPattern = true;
+        }
+    }
     for (const node of nodes) {
         const outForwards = node.forwards ?? [];
         if (outForwards.length === 0) {
@@ -55,15 +62,11 @@ export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
             else {
                 providerOnly++;
             }
-            const fwdName = (fwd.name ?? "").toLowerCase();
-            const target = (fwd.to ?? "").toLowerCase();
-            if (fwdName.includes("refund") || target.includes("refund")) {
-                hasRefundPath = true;
-            }
-            if (fwdName.includes("arb") || target.includes("arb")) {
-                hasArbitrationPath = true;
+            const target = (fwd.to ?? "").trim().toLowerCase();
+            if (wonderNodeRegex.test(target)) {
+                hasWonderNode = true;
             }
-            if (fwdName.includes("milestone") || target.includes("milestone")) {
+            if (target.includes("milestone")) {
                 hasMilestone = true;
             }
         }
@@ -77,10 +80,18 @@ export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
             }
         }
     }
+    const hasArbitrationBinding = (serviceRaw?.arbitrations?.length ?? 0) > 0;
+    const compBalance = serviceRaw?.compensation_fund?.balance ?? 0n;
+    const hasArbRefundPath = hasArbitrationBinding && compBalance > 0n;
+    const allocators = serviceRaw?.order_allocators?.[0]?.allocators ?? [];
+    const hasRefundAllocator = allocators.some((a) => a.surplus_to === "order" || a.surplus_to === "Order");
+    const hasRefundPath = hasArbRefundPath || hasRefundAllocator;
     if (!hasRefundPath)
         riskSignals.push("no_refund_path");
-    if (!hasArbitrationPath)
-        riskSignals.push("no_arbitration_path");
+    if (!hasArbitrationBinding)
+        riskSignals.push("no_arbitration_binding");
+    if (hasDisputeAntiPattern)
+        riskSignals.push("dispute_anti_pattern");
     if (userOperable === 0)
         riskSignals.push("no_user_operable_path");
     if (deadEndNodes.length > 0)
@@ -94,7 +105,10 @@ export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
         provider_only_forwards: providerOnly,
         guard_gated_forwards: guardGated,
         has_refund_path: hasRefundPath,
-        has_arbitration_path: hasArbitrationPath,
+        has_arbitration_path: hasArbitrationBinding,
+        has_arbitration_binding: hasArbitrationBinding,
+        has_wonder_node: hasWonderNode,
+        has_dispute_anti_pattern: hasDisputeAntiPattern,
         has_milestone_nodes: hasMilestone,
         dead_end_nodes: deadEndNodes,
         terminal_nodes: terminalNodes,
@@ -251,7 +265,7 @@ export function assembleInfoPuzzle(serviceId, raw, depth = "evaluate") {
     let trustSignals;
     if (depth === "evaluate" || depth === "preorder" || depth === "monitor") {
         if (raw.machine_nodes) {
-            workflowAnalysis = assembleWorkflowAnalysis(raw.machine_nodes, raw.machine_published ?? false, raw.machine_paused ?? false);
+            workflowAnalysis = assembleWorkflowAnalysis(raw.machine_nodes, raw.machine_published ?? false, raw.machine_paused ?? false, raw.service);
         }
         else {
             gaps.push("machine_workflow");
@@ -283,19 +297,14 @@ export function assembleInfoPuzzle(serviceId, raw, depth = "evaluate") {
             gaps.push("market_context");
         }
     }
-    const expectedDimensions = depth === "browse" ? 1
-        : depth === "evaluate" ? 4
-            : depth === "preorder" ? 6
-                : 4;
-    const actualDimensions = [
-        serviceBasics,
-        workflowAnalysis,
-        fundSafety,
-        trustSignals,
-        merchantBehavior,
-        marketContext,
-    ].filter((d) => d !== undefined && d !== null).length;
-    const completeness = Math.min(1, actualDimensions / expectedDimensions);
+    let userMetrics;
+    if (raw.user_metrics_config && raw.user_metrics_config.metrics.length > 0) {
+        userMetrics = assembleUserMetrics(raw.user_metrics_config, raw.user_metrics_context ?? {});
+    }
+    let serviceNesting = raw.service_nesting;
+    if (!serviceNesting && raw.service_nesting_raw) {
+        serviceNesting = evaluateServiceNesting(raw.service_nesting_raw);
+    }
     return {
         service_id: serviceId,
         service_basics: serviceBasics,
@@ -304,9 +313,341 @@ export function assembleInfoPuzzle(serviceId, raw, depth = "evaluate") {
         trust_signals: trustSignals,
         merchant_behavior: merchantBehavior,
         market_context: marketContext,
-        completeness,
+        user_metrics: userMetrics,
+        service_nesting: serviceNesting,
+        completeness: computeCompleteness(depth, [
+            serviceBasics,
+            workflowAnalysis,
+            fundSafety,
+            trustSignals,
+            merchantBehavior,
+            marketContext,
+            userMetrics,
+            serviceNesting,
+        ]),
         gaps,
         assembled_at: Date.now(),
     };
 }
+export function assembleUserMetrics(config, context) {
+    const cap = config.adjustment_cap ?? 10;
+    const results = [];
+    const totalWeight = config.metrics.reduce((sum, m) => sum + Math.max(0, m.weight), 0);
+    for (const metric of config.metrics) {
+        const normalizedWeight = totalWeight > 0 ? Math.max(0, metric.weight) / totalWeight : 0;
+        const observed = resolvePath(context, metric.params.path ?? metric.name);
+        const { passed, score, observed_value } = evaluateMetric(metric, observed);
+        results.push({
+            name: metric.name,
+            label: metric.label,
+            passed,
+            score,
+            observed_value: formatObservedValue(observed),
+            weight: normalizedWeight,
+            advice: passed
+                ? metric.advice_on_pass
+                : metric.advice_on_fail,
+        });
+    }
+    const aggregated = results.reduce((sum, r) => sum + r.score * r.weight, 0);
+    const score = Math.round(aggregated * 100);
+    const adjustment = Math.round(((score - 50) / 50) * cap);
+    return {
+        metrics: results,
+        score,
+        adjustment,
+        source_file: config.source_file,
+        evaluated_at: Date.now(),
+    };
+}
+function resolvePath(obj, path) {
+    if (!path)
+        return undefined;
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function evaluateMetric(metric, observed) {
+    const p = metric.params;
+    switch (metric.evaluator) {
+        case "threshold": {
+            const v = typeof observed === "number" ? observed
+                : typeof observed === "string" ? Number(observed)
+                    : typeof observed === "bigint" ? Number(observed)
+                        : NaN;
+            const threshold = typeof p.threshold === "number" ? p.threshold
+                : typeof p.threshold === "string" ? Number(p.threshold)
+                    : NaN;
+            if (isNaN(v) || isNaN(threshold)) {
+                return { passed: false, score: 0, observed_value: observed };
+            }
+            const passed = p.invert ? v <= threshold : v >= threshold;
+            const margin = Math.abs(threshold) * 0.5 || 1;
+            const rawScore = p.invert
+                ? (threshold - v) / margin + 1
+                : (v - threshold) / margin + 1;
+            const score = Math.max(0, Math.min(1, rawScore));
+            return { passed, score, observed_value: observed };
+        }
+        case "ratio": {
+            const v = typeof observed === "number" ? observed
+                : typeof observed === "string" ? Number(observed)
+                    : NaN;
+            const min = p.min ?? 0;
+            const max = p.max ?? 1;
+            if (isNaN(v)) {
+                return { passed: false, score: 0, observed_value: observed };
+            }
+            const passed = v >= min && v <= max;
+            const range = max - min;
+            const mid = (min + max) / 2;
+            const score = range > 0 ? Math.max(0, 1 - Math.abs(v - mid) / (range / 2)) : 1;
+            return { passed, score, observed_value: observed };
+        }
+        case "boolean": {
+            const passed = !!observed;
+            return { passed, score: passed ? 1 : 0, observed_value: observed };
+        }
+        case "presence": {
+            const present = observed !== undefined && observed !== null && observed !== "";
+            return { passed: present, score: present ? 1 : 0, observed_value: observed };
+        }
+        case "regex_match": {
+            if (typeof observed !== "string" || !p.pattern) {
+                return { passed: false, score: 0, observed_value: observed };
+            }
+            try {
+                const regex = new RegExp(p.pattern);
+                const passed = regex.test(observed);
+                return { passed, score: passed ? 1 : 0, observed_value: observed };
+            }
+            catch {
+                return { passed: false, score: 0, observed_value: observed };
+            }
+        }
+        case "custom_query": {
+            return { passed: false, score: 0.5, observed_value: observed };
+        }
+        default:
+            return { passed: false, score: 0, observed_value: observed };
+    }
+}
+function formatObservedValue(v) {
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+        return v;
+    if (typeof v === "bigint")
+        return v.toString();
+    if (v === undefined || v === null)
+        return undefined;
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+function computeCompleteness(depth, dimensions) {
+    const requiredCount = depth === "browse" ? 1
+        : depth === "evaluate" ? 4
+            : depth === "preorder" ? 6
+                : 5;
+    const requiredDimensions = dimensions.slice(0, requiredCount);
+    const presentCount = requiredDimensions.filter((d) => d !== undefined && d !== null).length;
+    return Math.min(1, presentCount / requiredCount);
+}
+export function evaluateServiceNesting(raw) {
+    const depth = raw.depth ?? 0;
+    const maxDepth = raw.maxDepth ?? 3;
+    const truncated = depth >= maxDepth;
+    const bindings = {
+        arbitrations: [],
+        rewards: [],
+        repositories: [],
+    };
+    let totalEvaluated = 0;
+    if (raw.machine) {
+        const m = raw.machine;
+        const issues = [];
+        let score = 0;
+        if (m.published)
+            score += 10;
+        else
+            issues.push("Machine not published");
+        if (m.paused) {
+            score += 40;
+            issues.push("Machine paused");
+        }
+        if (m.has_no_entry) {
+            score += 50;
+            issues.push("No entry point (R-M1-01)");
+        }
+        if (m.has_no_terminal) {
+            score += 50;
+            issues.push("No terminal node (R-M1-02)");
+        }
+        if (m.has_dispute_anti_pattern) {
+            score += 60;
+            issues.push("Dispute anti-pattern (R-M1-11): machine illegally models dispute flow");
+        }
+        const structIssues = m.structural_issue_count ?? 0;
+        if (structIssues > 0) {
+            score += structIssues * 15;
+            issues.push(`${structIssues} structural issue(s) detected (cycles/dead-ends/orphans)`);
+        }
+        score = Math.min(100, score);
+        bindings.machine = {
+            object_id: m.object_id,
+            published: m.published,
+            risk_level: scoreToNestingLevel(score),
+            issues,
+        };
+        totalEvaluated++;
+    }
+    for (const arb of raw.arbitrations ?? []) {
+        const issues = [];
+        let score = 0;
+        if (arb.voting_guard_count === 0) {
+            score += 50;
+            issues.push("No voting_guard configured — no arbitrators can vote");
+        }
+        else if (arb.voting_guard_count <= 2) {
+            score += 30;
+            issues.push("Few arbitrators (<=2) — limited dispute resolution capacity");
+        }
+        else {
+            score += 10;
+        }
+        if (arb.paused) {
+            score += 40;
+            issues.push("Arbitration paused — disputes cannot be filed");
+        }
+        if (arb.fee_balance === 0n) {
+            score += 30;
+            issues.push("No compensation fund balance — rulings cannot pay out");
+        }
+        score = Math.min(100, score);
+        bindings.arbitrations.push({
+            object_id: arb.object_id,
+            voting_guard_count: arb.voting_guard_count,
+            fee_balance: arb.fee_balance.toString(),
+            paused: arb.paused,
+            risk_level: scoreToNestingLevel(score),
+            issues,
+        });
+        totalEvaluated++;
+    }
+    for (const r of raw.rewards ?? []) {
+        const issues = [];
+        let score = 0;
+        if (r.balance === 0n) {
+            score += 60;
+            issues.push("Reward fund empty — claims will fail");
+        }
+        if (r.guard_count === 0) {
+            score += 50;
+            issues.push("No claim_guard — anyone could claim (or no one can, depending on default)");
+        }
+        if (r.expiration_time && r.expiration_time > 0 && r.expiration_time < Date.now()) {
+            score += 40;
+            issues.push("Reward expired — claims no longer possible");
+        }
+        score = Math.min(100, score);
+        bindings.rewards.push({
+            object_id: r.object_id,
+            balance: r.balance.toString(),
+            guard_count: r.guard_count,
+            risk_level: scoreToNestingLevel(score),
+            issues,
+        });
+        totalEvaluated++;
+    }
+    for (const repo of raw.repositories ?? []) {
+        const issues = [];
+        let score = 0;
+        if (!repo.has_write_guard) {
+            score += 40;
+            issues.push("No write_guard — Repository is open to arbitrary writes");
+        }
+        if (repo.is_empty) {
+            score += 20;
+            issues.push("Repository empty — no historical data for evaluation");
+        }
+        score = Math.min(100, score);
+        bindings.repositories.push({
+            object_id: repo.object_id,
+            risk_level: scoreToNestingLevel(score),
+            issues,
+        });
+        totalEvaluated++;
+    }
+    if (totalEvaluated === 0) {
+        return undefined;
+    }
+    const machineScore = bindings.machine ? nestingLevelToScore(bindings.machine.risk_level) : 0;
+    const machineWeight = bindings.machine ? 35 : 0;
+    const arbScore = bindings.arbitrations.length > 0
+        ? Math.max(...bindings.arbitrations.map((a) => nestingLevelToScore(a.risk_level)))
+        : 0;
+    const arbWeight = bindings.arbitrations.length > 0 ? 30 : 0;
+    const rewardScore = bindings.rewards.length > 0
+        ? Math.max(...bindings.rewards.map((r) => nestingLevelToScore(r.risk_level)))
+        : 0;
+    const rewardWeight = bindings.rewards.length > 0 ? 20 : 0;
+    const repoScore = bindings.repositories.length > 0
+        ? Math.max(...bindings.repositories.map((r) => nestingLevelToScore(r.risk_level)))
+        : 0;
+    const repoWeight = bindings.repositories.length > 0 ? 15 : 0;
+    const totalWeight = machineWeight + arbWeight + rewardWeight + repoWeight;
+    const overallScore = totalWeight > 0
+        ? Math.round((machineScore * machineWeight + arbScore * arbWeight
+            + rewardScore * rewardWeight + repoScore * repoWeight) / totalWeight)
+        : 0;
+    const allLevels = [];
+    if (bindings.machine)
+        allLevels.push(bindings.machine.risk_level);
+    for (const a of bindings.arbitrations)
+        allLevels.push(a.risk_level);
+    for (const r of bindings.rewards)
+        allLevels.push(r.risk_level);
+    for (const r of bindings.repositories)
+        allLevels.push(r.risk_level);
+    const overallLevel = allLevels.reduce(highestLevel, "low");
+    return {
+        depth_reached: depth,
+        truncated,
+        bindings,
+        overall_risk_level: overallLevel,
+        overall_risk_score: overallScore,
+        total_bindings_evaluated: totalEvaluated,
+        evaluated_at: Date.now(),
+    };
+}
+function scoreToNestingLevel(score) {
+    if (score >= 75)
+        return "critical";
+    if (score >= 50)
+        return "high";
+    if (score >= 25)
+        return "medium";
+    return "low";
+}
+function nestingLevelToScore(level) {
+    switch (level) {
+        case "critical": return 90;
+        case "high": return 65;
+        case "medium": return 40;
+        case "low": return 10;
+    }
+}
+function highestLevel(a, b) {
+    const order = { low: 0, medium: 1, high: 2, critical: 3 };
+    return order[a] >= order[b] ? a : b;
+}
 export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/customer/risk-assessment.js

@@ -14,23 +14,23 @@ export function riskLevelEmoji(level) {
 function assessWorkflowRisk(puzzle) {
     const wf = puzzle.workflow_analysis;
     const checks = [];
-    const hasRefund = wf?.has_refund_path ?? false;
+    const hasArb = wf?.has_arbitration_binding ?? wf?.has_arbitration_path ?? false;
     checks.push({
-        id: "wf_refund_path",
+        id: "wf_arbitration_binding",
         dimension: "workflow",
-        description: "Refund path exists (100%→Order Allocator)",
+        description: "Service has Arbitration object bound (dispute independence)",
         weight: 10,
-        passed: hasRefund,
-        advice: hasRefund ? undefined : "⚠️ No refund path: if delivery fails, funds may not be recoverable. Recommend negotiating refund terms with the merchant via Messenger and writing them into the WTS before ordering.",
+        passed: hasArb,
+        advice: hasArb ? undefined : "⚠️ No Arbitration binding: disputes cannot be escalated to third-party arbitration. Recommend requiring the merchant to bind an Arbitration service (with voting_guard config) before ordering. Dispute is filed via arbitration::dispute(order, arbitration), independent of the machine workflow.",
     });
-    const hasArb = wf?.has_arbitration_path ?? false;
+    const hasRefund = wf?.has_refund_path ?? false;
     checks.push({
-        id: "wf_arbitration_path",
+        id: "wf_refund_path",
         dimension: "workflow",
-        description: "Arbitration path exists",
+        description: "Refund path exists (Arbitration+compensation_fund OR refund Allocator)",
         weight: 10,
-        passed: hasArb,
-        advice: hasArb ? undefined : "⚠️ No arbitration path: disputes cannot be escalated to third-party arbitration. Recommend requiring the merchant to bind an Arbitration service before ordering.",
+        passed: hasRefund,
+        advice: hasRefund ? undefined : "⚠️ No refund path: if delivery fails, funds may not be recoverable. Either (a) bind Arbitration AND deposit compensation_fund, or (b) configure a refund-to-order Allocator. Refund via arbitration flows: dispute → arbitration() ruling with indemnity → arb_withdraw by order holder.",
     });
     const userOps = wf?.user_operable_forwards ?? 0;
     checks.push({
@@ -51,14 +51,19 @@ function assessWorkflowRisk(puzzle) {
         passed: noDeadEnds,
         advice: noDeadEnds ? undefined : `⚠️ Detected ${deadEnds.length} potential dead-end node(s): ${deadEnds.join(", ")}. All exits of these nodes depend on merchant action.`,
     });
-    const machineUsable = wf ? (wf.machine_published && !wf.machine_paused) : false;
+    const machineUsable = wf
+        ? (wf.machine_published && !wf.machine_paused && !wf.has_dispute_anti_pattern)
+        : false;
     checks.push({
         id: "wf_machine_usable",
         dimension: "workflow",
-        description: "Machine is published and not paused",
+        description: "Machine published, not paused, no dispute anti-pattern",
         weight: 3,
         passed: machineUsable,
-        advice: machineUsable ? undefined : "⚠️ Machine is not published or is paused: the workflow may not be in effect or has been actively paused by the merchant.",
+        advice: machineUsable ? undefined
+            : wf?.has_dispute_anti_pattern
+                ? "🔴 Machine contains dispute anti-pattern nodes (disputed/refunded/arb/arbitration). Dispute is INDEPENDENT of machine — these nodes create dead-end paths because arbitrators are in Arbitration.voting_guard, not Permission. Recommend removing these nodes and binding an Arbitration object to the Service instead."
+                : "⚠️ Machine is not published or is paused: the workflow may not be in effect or has been actively paused by the merchant.",
     });
     const score = checks.reduce((sum, c) => sum + (c.passed ? c.weight : 0), 0);
     return { name: "workflow", score, max_score: RISK_DIMENSION_MAX.workflow, checks };
@@ -264,7 +269,12 @@ export function assessRisk(puzzle) {
         assessTrustRisk(puzzle),
         assessBehaviorRisk(puzzle),
     ];
-    const total = dimensions.reduce((sum, d) => sum + d.score, 0);
+    const baseTotal = dimensions.reduce((sum, d) => sum + d.score, 0);
+    const userMetricsAdjustment = puzzle.user_metrics?.adjustment ?? 0;
+    const serviceNestingRisk = puzzle.service_nesting?.overall_risk_score;
+    const serviceNestingLevel = puzzle.service_nesting?.overall_risk_level;
+    const wonderBonus = puzzle.workflow_analysis?.has_wonder_node ? 2 : 0;
+    const total = Math.max(0, Math.min(100, baseTotal + userMetricsAdjustment + wonderBonus));
     const level = riskLevelFromScore(total);
     const redFlags = [];
     for (const dim of dimensions) {
@@ -284,11 +294,18 @@ export function assessRisk(puzzle) {
             redFlags.push(`[behavior_flag] ${f}`);
         }
     }
+    if (serviceNestingLevel === "high" || serviceNestingLevel === "critical") {
+        redFlags.push(`[service_nesting] overall nesting risk: ${serviceNestingLevel} (score ${serviceNestingRisk})`);
+    }
     const advice = generateAdvice(puzzle, total, level, dimensions);
     return {
         total,
+        base_total: baseTotal,
         level,
         dimensions,
+        user_metrics_adjustment: userMetricsAdjustment,
+        service_nesting_risk: serviceNestingRisk,
+        service_nesting_level: serviceNestingLevel,
         red_flags: redFlags,
         advice,
     };
@@ -326,6 +343,26 @@ function generateAdvice(puzzle, total, level, dimensions) {
     if (puzzle.completeness < 0.8) {
         advice.push(`ℹ️ Information completeness is only ${Math.round(puzzle.completeness * 100)}%; missing: ${puzzle.gaps.join(", ") || "none"}. Recommend supplementing data before making a decision.`);
     }
+    if (puzzle.workflow_analysis?.has_wonder_node) {
+        advice.push("🌟 Machine implements wonder/no-wonder praise design: customers can advance Progress to 'wonder' (positive review) or 'no_wonder' (negative review) after completion. Reward objects can claim against Progress.current == 'wonder' to incentivize positive outcomes.");
+    }
+    if (puzzle.workflow_analysis?.has_dispute_anti_pattern) {
+        advice.push("🔴 Machine contains dispute anti-pattern nodes (disputed/refunded/arb/arbitration). Dispute is INDEPENDENT of machine — it flows through Order → Arbitration.dispute() → Arb → arbitration() → arb_withdraw. Arbitrators are configured in Arbitration.voting_guard, NOT in Permission. Recommend the merchant remove these nodes and bind an Arbitration object instead.");
+    }
+    if (puzzle.user_metrics) {
+        const um = puzzle.user_metrics;
+        const passedCount = um.metrics.filter((m) => m.passed).length;
+        advice.push(`📊 User-customized metrics: ${passedCount}/${um.metrics.length} passed (score ${um.score}/100, adjustment ${um.adjustment >= 0 ? "+" : ""}${um.adjustment}).${um.source_file ? ` Source: ${um.source_file}` : ""}`);
+        for (const m of um.metrics) {
+            if (!m.passed && m.advice) {
+                advice.push(`   • ${m.label}: ${m.advice}`);
+            }
+        }
+    }
+    if (puzzle.service_nesting) {
+        const sn = puzzle.service_nesting;
+        advice.push(`🔗 Service nesting evaluation: ${sn.total_bindings_evaluated} bound objects, overall risk ${sn.overall_risk_level} (score ${sn.overall_risk_score}/100).${sn.truncated ? " Recursion truncated at depth limit." : ""}`);
+    }
     return advice;
 }
 export function passesRiskThreshold(score, minLevel = "medium_high") {