@wowok/agent-mcp 2.5.3 → 2.5.5

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") {

package/dist/customer/types.d.ts

@@ -28,6 +28,9 @@ export interface WorkflowAnalysis {
     guard_gated_forwards: number;
     has_refund_path: boolean;
     has_arbitration_path: boolean;
+    has_arbitration_binding: boolean;
+    has_wonder_node: boolean;
+    has_dispute_anti_pattern: boolean;
     has_milestone_nodes: boolean;
     dead_end_nodes: string[];
     terminal_nodes: string[];
@@ -77,6 +80,82 @@ export interface MarketContext {
     price_percentile: number;
     supply_demand_ratio: number;
 }
+export type UserMetricEvaluatorType = "threshold" | "ratio" | "boolean" | "presence" | "regex_match" | "custom_query";
+export interface UserMetric {
+    name: string;
+    label: string;
+    evaluator: UserMetricEvaluatorType;
+    params: {
+        path?: string;
+        threshold?: number | string;
+        invert?: boolean;
+        min?: number;
+        max?: number;
+        pattern?: string;
+        query_key?: string;
+    };
+    weight: number;
+    advice_on_fail?: string;
+    advice_on_pass?: string;
+}
+export interface UserMetricsConfig {
+    version: number;
+    source_file?: string;
+    metrics: UserMetric[];
+    adjustment_cap?: number;
+}
+export interface UserMetricResult {
+    name: string;
+    label: string;
+    passed: boolean;
+    score: number;
+    observed_value?: string | number | boolean;
+    weight: number;
+    advice?: string;
+}
+export interface UserMetricsResult {
+    metrics: UserMetricResult[];
+    score: number;
+    adjustment: number;
+    source_file?: string;
+    evaluated_at: number;
+}
+export interface ServiceNestingEvaluation {
+    depth_reached: number;
+    truncated: boolean;
+    bindings: {
+        machine?: {
+            object_id: string;
+            published: boolean;
+            risk_level: "low" | "medium" | "high" | "critical";
+            issues: string[];
+        };
+        arbitrations: Array<{
+            object_id: string;
+            voting_guard_count: number;
+            fee_balance: string;
+            paused: boolean;
+            risk_level: "low" | "medium" | "high" | "critical";
+            issues: string[];
+        }>;
+        rewards: Array<{
+            object_id: string;
+            balance: string;
+            guard_count: number;
+            risk_level: "low" | "medium" | "high" | "critical";
+            issues: string[];
+        }>;
+        repositories: Array<{
+            object_id: string;
+            risk_level: "low" | "medium" | "high" | "critical";
+            issues: string[];
+        }>;
+    };
+    overall_risk_level: "low" | "medium" | "high" | "critical";
+    overall_risk_score: number;
+    total_bindings_evaluated: number;
+    evaluated_at: number;
+}
 export interface InfoPuzzle {
     service_id: string;
     service_basics: ServiceBasics;
@@ -85,6 +164,8 @@ export interface InfoPuzzle {
     trust_signals?: TrustSignals;
     merchant_behavior?: MerchantBehavior;
     market_context?: MarketContext;
+    user_metrics?: UserMetricsResult;
+    service_nesting?: ServiceNestingEvaluation;
     completeness: number;
     gaps: string[];
     assembled_at: number;
@@ -107,8 +188,12 @@ export interface RiskDimensionScore {
 export type RiskLevel = "low" | "medium_low" | "medium_high" | "high";
 export interface RiskScore {
     total: number;
+    base_total: number;
     level: RiskLevel;
     dimensions: RiskDimensionScore[];
+    user_metrics_adjustment?: number;
+    service_nesting_risk?: number;
+    service_nesting_level?: "low" | "medium" | "high" | "critical";
     red_flags: string[];
     advice: string[];
 }

package/dist/knowledge/machine-ledger.js

@@ -29,25 +29,24 @@ export const MACHINE_SCENES = [
         id: "ecommerce_with_exceptions",
         name: "E-commerce Flow with Exception Branches",
         industry: ["ecommerce"],
-        scenario: "Paid (entry) → Ship → {Receive → Complete | Lost → Arbitration | Return → Refund}",
+        scenario: "Paid (entry) → Ship → {Receive → Complete | Lost (terminal) | Return → Refund}",
         participants: [
-            { role: "customer", permission_type: "OrderHolder", involved_in: ["Receive", "Return"] },
-            { role: "merchant", permission_type: "Permission", involved_in: ["Ship", "Refund"] },
-            { role: "arbitrator", permission_type: "NamedOperator", involved_in: ["Arbitration"] },
+            { role: "customer", permission_type: "OrderHolder", involved_in: ["Receive", "Return", "Lost"] },
+            { role: "merchant", permission_type: "Permission", involved_in: ["Ship", "Refund", "Lost"] },
         ],
         recommended_patterns: ["P-M-SEQ", "P-M-COMPETING"],
         recommended_topology: ["P-M-LINEAR", "P-M-COMPETING"],
         guard_requirements: [
             { forward: "Lost", scene: "machine_forward_guard", purpose: "Dual-sig to confirm lost" },
-            { forward: "Arbitration", scene: "arbitration_usage_guard", purpose: "Verify arbitration eligibility" },
         ],
-        allocation_integration: "Complete->merchant | Refund->customer | Arb->arbitrator",
+        allocation_integration: "Complete->merchant | Refund->customer | Lost->escrow or partial refund (Allocator only). Disputes are NOT modeled here — they flow through Order + Arbitration object off-Machine.",
         special_constraints: [
             "First node 'Paid' represents post-payment state — buy() completes payment atomically before Progress is created",
             "No separate 'Order' or 'Pay' nodes needed — payment is handled by Service.buy(), not Machine",
-            "Lost node threshold=2 (customer + merchant dual-sig)",
-            "Competing Pair: Receive vs Lost (first-wins)",
-            "Arbitration flow independent of main flow",
+            "Lost node threshold=2 (customer + merchant dual-sig) — Lost is a TERMINAL node, not a path to arbitration",
+            "Competing Pair: Receive vs Lost vs Return (first-wins)",
+            "DISPUTE INDEPENDENCE: arbitration is NOT a Machine node. If a Lost-terminal order later needs dispute resolution, the customer files arbitration::dispute(order, arbitration) against the Arbitration object bound to the Service — completely off-Machine. Arbitrators live in Arbitration.voting_guard, never in Permission or NamedOperator.",
+            "Refund Allocation must use sharing.who=OrderHolder (refund to customer, NOT merchant)",
         ],
         first_node_semantics: "Paid — order has been created and paid via Service.buy(); Machine starts at post-payment state",
         mutable_after_publish: false,
@@ -207,31 +206,32 @@ export const MACHINE_SCENES = [
         m_rounds_focus: ["M1", "M3", "M8"],
     },
     {
-        id: "arbitration_flow",
-        name: "Arbitration Flow",
-        industry: ["ecommerce", "service", "rental"],
-        scenario: "Dispute → Submit → Vote → Ruling → Execute",
+        id: "wonder_feedback",
+        name: "Wonder Feedback Flow (Post-Completion Rating)",
+        industry: ["ecommerce", "service", "rental", "subscription", "education"],
+        scenario: "Paid (entry) → ... → Completed → {Wonder | NoWonder} (rating terminals)",
         participants: [
-            { role: "disputant", permission_type: "OrderHolder", involved_in: ["Submit Dispute"] },
-            { role: "arbitrator", permission_type: "NamedOperator", involved_in: ["Vote"] },
-            { role: "system", permission_type: "Permission", involved_in: ["Execute Ruling"] },
+            { role: "customer", permission_type: "OrderHolder", involved_in: ["Wonder", "NoWonder"] },
+            { role: "merchant", permission_type: "Permission", involved_in: ["Completed"] },
         ],
-        recommended_patterns: ["P-M-VOTE", "P-M-SEQ"],
-        recommended_topology: ["P-M-LINEAR"],
+        recommended_patterns: ["P-M-SEQ", "P-M-COMPETING"],
+        recommended_topology: ["P-M-LINEAR", "P-M-COMPETING"],
         guard_requirements: [
-            { forward: "Submit Dispute", scene: "arbitration_usage_guard", purpose: "Verify dispute eligibility + prevent double-dispute" },
-            { forward: "Vote", scene: "arbitration_voting_guard", purpose: "Verify voting eligibility + extract weight" },
+            { forward: "Praise", scene: "machine_forward_guard", purpose: "Verify Progress.current == 'Completed' (rating only after completion)" },
+            { forward: "Complain", scene: "machine_forward_guard", purpose: "Verify Progress.current == 'Completed' (rating only after completion)" },
         ],
-        allocation_integration: "After ruling -> distribute funds according to ruling",
+        allocation_integration: "Completed -> merchant allocation (terminal); Wonder/NoWonder are reputation terminals — no fund allocation. Reward object (independent) claims fire when Progress.current == 'wonder'",
         special_constraints: [
-            "Arbitration object must be already created",
-            "Prevent double-dispute (R-X1-14 HIGH)",
-            "Prevent double-vote (R-X1-14 CRITICAL)",
-            "MAX_DISPUTE_COUNT=10 per order",
+            "Dispute MUST NOT be modeled as machine nodes — disputes flow through Order + Arbitration object, independent of this Machine",
+            "Wonder/NoWonder are POST-completion terminals: order is already settled when customer rates",
+            "Both Wonder and NoWonder forwards have named_operator='' (OrderHolder) — rating is a customer-only action",
+            "Reward object (if bound) MUST use a Guard verifying Progress.current == 'wonder' AND order.holder == signer — no Permission needed for reward claim",
+            "Competing Pair: Praise vs Complain (first-wins; one rating per order)",
+            "No dispute/refund/arbitration nodes in this Machine — those flows live off-Machine",
         ],
-        first_node_semantics: "DisputeOpened — order has been created and paid via Service.buy(); Machine starts at post-payment dispute state",
+        first_node_semantics: "Paid — order has been created and paid via Service.buy(); Machine starts at post-payment state, same as e-commerce baseline",
         mutable_after_publish: false,
-        m_rounds_focus: ["M1", "M3", "M4", "M5", "M8"],
+        m_rounds_focus: ["M1", "M2", "M3", "M5", "M8"],
     },
     {
         id: "subscription",
@@ -281,8 +281,11 @@ export function inferSceneFromFlow(description) {
     if (lower.includes("supply chain") || lower.includes("cross-machine")) {
         return findScene("cross_machine_supply_chain");
     }
-    if (lower.includes("arbitration") || lower.includes("dispute")) {
-        return findScene("arbitration_flow");
+    if (lower.includes("wonder") || lower.includes("praise") || lower.includes("complain")
+        || lower.includes("thumbs_up") || lower.includes("thumbs_down")
+        || lower.includes("rating") || lower.includes("feedback")
+        || lower.includes("好评") || lower.includes("差评")) {
+        return findScene("wonder_feedback");
     }
     if (lower.includes("reward") || lower.includes("incentive")) {
         return findScene("reward_incentive");

package/dist/knowledge/machine-risk.js

@@ -109,6 +109,29 @@ export const MACHINE_RISK_RULES = [
         auto_fixable: false,
         related_constraint: "MC-C-04",
     },
+    {
+        id: "R-M1-11",
+        name: "Dispute anti-pattern — machine illegally models dispute flow",
+        category: "structural",
+        severity: "critical",
+        description: "Machine contains nodes named 'disputed', 'refunded', 'arb', 'arbitration', " +
+            "'dispute', or 'refund'. This is a CRITICAL design anti-pattern because " +
+            "dispute is INDEPENDENT of the machine workflow. Dispute flows through: " +
+            "Order → Arbitration.dispute() → Arb object → arbitration() ruling → " +
+            "arb_withdraw by order holder. Arbitrators are configured in " +
+            "Arbitration.voting_guard, NOT in Permission. Merchants who model " +
+            "dispute in the machine (e.g., 'disputed → refunded' forward guarded " +
+            "by Permission index 1500) create dead-end paths because no one has " +
+            "Permission 1500 — arbitrators are NOT Permission holders.",
+        detection: "Match node names against regex /^(disputed|refunded|arb|arbitration|dispute|refund)$/i",
+        recommendation: "Remove all dispute/refund nodes from the machine. Instead: (1) bind an " +
+            "Arbitration object to the Service via Service.arbitrations, (2) configure " +
+            "arbitrators via Arbitration.voting_guard_add, (3) deposit compensation_fund " +
+            "to the Service. Disputes are then filed via arbitration::dispute(order, " +
+            "arbitration) — completely independent of the machine workflow.",
+        auto_fixable: false,
+        related_constraint: "dispute_independence_principle",
+    },
     {
         id: "R-M2-01",
         name: "Guard not created",

package/dist/knowledge/machine-templates.js

@@ -993,142 +993,174 @@ export const MACHINE_TEMPLATES = [
         ],
     },
     {
-        id: "tpl_machine_arbitration",
-        scene_id: "arbitration_flow",
-        name: "Arbitration Flow",
-        description: "Dispute -> Submit -> Vote -> Ruling -> Execute. Uses arbitration_usage_guard + arbitration_voting_guard. " +
-            "MAX_DISPUTE_COUNT=10 per order. Dual-vote prevention mandatory.",
-        recommended_patterns: ["P-M-VOTE", "P-M-SEQ"],
-        recommended_topology: ["P-M-LINEAR"],
+        id: "tpl_machine_wonder_feedback",
+        scene_id: "wonder_feedback",
+        name: "Wonder Feedback Flow (Post-Completion Rating)",
+        description: "Post-completion rating flow: Paid (entry) → Shipped → Received → Completed → {Wonder | NoWonder}. " +
+            "After the order reaches 'Completed' (terminal business state, funds already allocated to merchant), " +
+            "the OrderHolder (namedOperator='') can advance Progress to 'wonder' (positive review) or 'no_wonder' " +
+            "(negative review). A bound Reward object's claim_guard verifies Progress.current == 'wonder' before " +
+            "paying out — reward claim needs NO Permission. Dispute is NEVER modeled here: it flows through " +
+            "Order → Arbitration.dispute() → Arb → arbitration() ruling → arb_withdraw, fully off-Machine.",
+        recommended_patterns: ["P-M-SEQ", "P-M-COMPETING"],
+        recommended_topology: ["P-M-LINEAR", "P-M-COMPETING"],
         parameters: [
             {
-                name: "arbitration_ref",
-                type: "arbitration_ref",
+                name: "merchant_permission",
+                type: "permission_ref",
                 required: true,
-                description: "Arbitration object address",
+                description: "Merchant Permission object (index 2 = merchant, index 3 = admin)",
             },
             {
-                name: "max_disputes",
-                type: "number",
+                name: "wonder_node_name",
+                type: "string",
                 required: true,
-                default: "10",
-                description: "Hard limit: MAX_DISPUTE_COUNT=10 per order",
+                default: "wonder",
+                description: "Node name for positive feedback (好评) terminal",
+                constraint: "Must match /^(wonder|praise|thumbs_up)$/i OR be a custom name; must NOT match dispute anti-pattern regex",
             },
             {
-                name: "voting_threshold",
-                type: "number",
+                name: "no_wonder_node_name",
+                type: "string",
                 required: true,
-                default: "100",
-                description: "Weight threshold required for a voting decision to pass",
+                default: "no_wonder",
+                description: "Node name for negative feedback (差评) terminal",
+                constraint: "Must match /^(no_wonder|complain|thumbs_down)$/i OR be a custom name; must NOT match dispute anti-pattern regex",
+            },
+            {
+                name: "reward_ref",
+                type: "reward_ref",
+                required: false,
+                description: "Reward object address (optional). If bound, its claim_guard should verify Progress.current == wonder_node_name AND order.holder == signer. Use wonder_praise or wonder_feedback reward template.",
+            },
+            {
+                name: "rating_time_limit_days",
+                type: "number",
+                required: false,
+                default: "30",
+                description: "Days after completion during which the customer can rate (enforced by Guard on Praise/Complain forwards via context(Clock))",
+                constraint: "Must be > 0; reasonable range 7-90",
             },
         ],
         example_nodes: [
-            { name: "DisputeOpened" },
-            { name: "EvidenceSubmitted" },
-            { name: "Voting" },
-            { name: "Ruling" },
-            { name: "Executed" },
+            { name: "Paid", description: "Entry: order created and paid via Service.buy(); Machine starts here" },
+            { name: "Shipped", description: "Merchant dispatched goods/service" },
+            { name: "Received", description: "Customer confirmed receipt" },
+            { name: "Completed", description: "Terminal business state — triggers merchant Allocation. Funds settled." },
+            { name: "${wonder_node_name}", description: "Positive feedback terminal (好评). OrderHolder-only. Reward-eligible." },
+            { name: "${no_wonder_node_name}", description: "Negative feedback terminal (差评). OrderHolder-only. Optional Repository write for analytics." },
         ],
         example_pairs: [
             {
                 prev_node: "",
-                next_node: "DisputeOpened",
+                next_node: "Paid",
                 threshold: 1,
-                forwards: [
-                    {
-                        name: "OpenDispute",
-                        weight: 1,
-                        named_operator: "",
-                        guard: "arb_usage_guard",
-                        retained_submission: "dispute_record",
-                    },
-                ],
+                forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
             },
             {
-                prev_node: "DisputeOpened",
-                next_node: "EvidenceSubmitted",
+                prev_node: "Paid",
+                next_node: "Shipped",
                 threshold: 1,
-                forwards: [{ name: "SubmitEvidence", weight: 1, named_operator: "" }],
+                forwards: [{ name: "Ship", weight: 1, permission_index: 2, named_operator: "" }],
             },
             {
-                prev_node: "EvidenceSubmitted",
-                next_node: "Voting",
+                prev_node: "Shipped",
+                next_node: "Received",
+                threshold: 1,
+                forwards: [{ name: "ConfirmReceive", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Received",
+                next_node: "Completed",
                 threshold: 1,
-                forwards: [{ name: "StartVote", weight: 1, permission_index: 3 }],
+                forwards: [{ name: "Finish", weight: 1, permission_index: 2, named_operator: "" }],
             },
             {
-                prev_node: "Voting",
-                next_node: "Ruling",
-                threshold: "${voting_threshold}",
+                prev_node: "Completed",
+                next_node: "${wonder_node_name}",
+                threshold: 1,
                 forwards: [
                     {
-                        name: "ChiefVote",
-                        weight: 60,
-                        permission_index: 2,
-                        guard: "arb_voting_guard",
-                    },
-                    {
-                        name: "MemberVote",
-                        weight: 8,
-                        named_operator: "arbitrator",
-                        guard: "arb_voting_guard",
+                        name: "Praise",
+                        weight: 1,
+                        named_operator: "",
+                        guard: "rating_window_guard",
+                        retained_submission: "rating_record",
                     },
                 ],
             },
             {
-                prev_node: "Ruling",
-                next_node: "Executed",
+                prev_node: "Completed",
+                next_node: "${no_wonder_node_name}",
                 threshold: 1,
-                forwards: [{ name: "Execute", weight: 1, permission_index: 3 }],
+                forwards: [
+                    {
+                        name: "Complain",
+                        weight: 1,
+                        named_operator: "",
+                        guard: "rating_window_guard",
+                        retained_submission: "rating_record",
+                    },
+                ],
             },
         ],
         required_guards: [
             {
-                guard_template_id: "tpl_usage_guard_threshold",
-                bound_to_forward: "OpenDispute",
-                purpose: "Verify dispute count < MAX_DISPUTE_COUNT (10)",
-            },
-            {
-                guard_template_id: "tpl_voting_guard_numeric_weight",
-                bound_to_forward: "ChiefVote",
-                purpose: "Verify voting eligibility + weight extraction",
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "Praise",
+                purpose: "Verify Progress.current == 'Completed' (rating only allowed after completion) AND context(Clock) <= progress.entry_time + rating_time_limit_days",
             },
             {
-                guard_template_id: "tpl_voting_guard_numeric_weight",
-                bound_to_forward: "MemberVote",
-                purpose: "Verify voting eligibility + prevent double-vote (R-X1-14 CRITICAL)",
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "Complain",
+                purpose: "Verify Progress.current == 'Completed' (rating only allowed after completion) AND context(Clock) <= progress.entry_time + rating_time_limit_days",
             },
         ],
         required_permissions: [
-            { index: 2, name: "chief_arbitrator", description: "High-weight voter" },
-            { index: 3, name: "admin", description: "Vote starter / executor" },
+            { index: 2, name: "merchant", description: "Merchant role for Ship + Finish (NOT for rating — rating is OrderHolder-only via named_operator='')" },
+            { index: 3, name: "admin", description: "Admin override (optional)" },
         ],
         required_allocators: [
             {
-                name: "RulingAllocation",
-                trigger_node: "Executed",
-                description: "Allocation based on ruling outcome",
+                name: "MerchantAllocation",
+                trigger_node: "Completed",
+                description: "100% to merchant Treasury or personal address. Fires at Completion — NOT at Wonder/NoWonder (those are reputation-only terminals with no fund flow).",
             },
         ],
-        forkable_fields: ["voting_threshold", "voter_count", "evidence_steps"],
-        applicable_industries: ["arbitration", "ecommerce", "service", "rental"],
+        forkable_fields: ["wonder_node_name", "no_wonder_node_name", "rating_time_limit_days", "additional_rating_nodes"],
+        applicable_industries: ["ecommerce", "service", "rental", "subscription", "education"],
         relevant_risks: [
-            "R-M1-08", "R-M2-05", "R-M3-04", "R-M5-04",
-            "R-X1-14",
+            "R-M1-01", "R-M1-02", "R-M1-08", "R-M1-11",
+            "R-M2-01", "R-M2-05",
+            "R-M3-02", "R-M3-04",
+            "R-M4-01", "R-M5-03",
         ],
         creation_notes: [
-            "Arbitration object MUST be created before this Machine",
-            "Anti-double-dispute: query arb.dispute_count < 10 (R-X1-14 HIGH)",
-            "Anti-double-vote: query arb.voted has [Signer] (R-X1-14 CRITICAL)",
-            "MAX_DISPUTE_COUNT=10 hard limit per order (on-chain constant)",
-        ],
-        example_use_case: "E-commerce dispute: customer claims item not as described. Arbitration panel (1 chief + 3 members) " +
-            "votes to rule. Up to 10 disputes per order allowed.",
+            "DISPUTE INDEPENDENCE: This Machine MUST NOT contain 'disputed', 'refunded', 'arb', 'arbitration' nodes (R-M1-11 critical). Disputes are filed off-Machine via arbitration::dispute(order, arbitration).",
+            "Build order: Permission → Machine (unpublished) → Guards → Bind guards → Publish → Bind to Service → Bind Reward (optional)",
+            "First node 'Paid' represents post-payment state — Service.buy() completes payment atomically before Progress is created",
+            "No separate 'Order' or 'Pay' nodes needed — payment is handled by Service.buy(), not Machine",
+            "Wonder/NoWonder forwards have named_operator='' (empty) — this delegates to the OrderHolder (customer). No Permission index needed for rating.",
+            "Completed node triggers MerchantAllocation — funds are settled BEFORE the rating window opens. Rating does NOT affect fund flow.",
+            "Competing Pair: Praise vs Complain (first-wins) — one rating per order, enforced by Guard + retained_submission audit trail.",
+            "Reward object (if bound) is INDEPENDENT of Allocator: Reward.claim() requires Guard+passport, not Permission. Guard checks Progress.current == 'wonder' AND order.holder == signer.",
+            "rating_window_guard enforces time limit: context(Clock) <= progress.entry_time + rating_time_limit_days. After window closes, no rating possible (Completed becomes true terminal).",
+            "Optional: bind a Repository to record feedback node for analytics. Repository write happens via Guard's data extraction (NOT auto-passed — see 06 §14.4).",
+        ],
+        example_use_case: "Photography service: Paid → Shipped (booking confirmed) → Received (session delivered) → Completed " +
+            "(photos delivered, funds released to photographer) → customer advances to 'wonder' (loved the work) " +
+            "or 'no_wonder' (didn't love it). Bound Reward pays 1 WOW to customers who advance to 'wonder'. " +
+            "Merchant's wonder/no_wonder ratio becomes an on-chain reputation signal. Disputes (if any) are " +
+            "filed separately via Arbitration object — never enter this Machine.",
         publish_checklist: [
-            "Arbitration object created and tested",
-            "Both anti-double Guards tested (dispute + vote)",
-            "Voting threshold verified with different weight distributions",
-            "MAX_DISPUTE_COUNT boundary tested (10th dispute OK, 11th fails)",
+            "All 6 nodes verified: no 'disputed'/'refunded'/'arb'/'arbitration' names (R-M1-11 PASS)",
+            "Entry Pair exists (prev_node='' targets 'Paid')",
+            "Competing Pair tested: Praise vs Complain — first-wins semantics verified on testnet",
+            "rating_window_guard tested: rating blocked after time limit expires",
+            "MerchantAllocation fires ONLY at Completed (NOT at Wonder/NoWonder)",
+            "Reward object (if bound): claim_guard tested — Progress.current == 'wonder' required, claim fails at 'no_wonder' or 'Completed'",
+            "named_operator='' on Praise/Complain forwards verified (OrderHolder-only operation)",
+            "machineNode2file export as backup",
         ],
     },
     {