@wowok/agent-mcp 2.5.3 → 2.5.4

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",
         ],
     },
     {

package/dist/knowledge/reward-templates.d.ts

@@ -1,4 +1,4 @@
-export type RewardTemplateType = "first_order" | "referral" | "loyalty" | "flash_sale" | "bulk_discount" | "milestone" | "cashback";
+export type RewardTemplateType = "first_order" | "referral" | "loyalty" | "flash_sale" | "bulk_discount" | "milestone" | "cashback" | "wonder_praise" | "wonder_feedback";
 export interface RewardTemplate {
     type: RewardTemplateType;
     name: string;

package/dist/knowledge/reward-templates.js

@@ -92,6 +92,68 @@ export const REWARD_TEMPLATES = [
         example: "Service reaches the 100-order milestone; the first 50 customers each receive 5 WOW extra reward.",
         relevantGuardOps: ["query", "repository_read"],
     },
+    {
+        type: "wonder_praise",
+        name: "Wonder-node praise reward (post-completion positive feedback)",
+        description: "Rewards customers who advance their order Progress to the 'wonder' node after normal completion — " +
+            "a user-driven positive-feedback mechanism. The machine design pattern is: " +
+            "place_order → booked → in_progress → completed → (wonder | no_wonder). " +
+            "After the order reaches 'completed' (terminal business state), the OrderHolder " +
+            "(namedOperator='') can advance Progress to 'wonder' (positive review) or 'no_wonder' " +
+            "(negative review). The Reward's claim_guard verifies Progress.current == 'wonder' " +
+            "AND order.service == this Service, so only satisfied customers can claim. " +
+            "This creates an on-chain reputation signal that benefits both the merchant " +
+            "(public proof of quality) and the customer (monetary reward for honest feedback).",
+        guardCondition: "Guard verifies: (1) Progress.current == 'wonder' (customer advanced to praise node), " +
+            "(2) Progress.task == order_address AND order.service == this Service, " +
+            "(3) Progress.machine == service.machine (snapshot match), " +
+            "(4) claimer is the order holder (order.holder == signer). " +
+            "Recommended Guard ops: query Progress object, query Order object, " +
+            "verify Progress.current field equals 'wonder'.",
+        amountRange: { min: "0.1WOW", max: "20WOW" },
+        allocationStrategy: "fixed",
+        parameters: [
+            { name: "amount", type: "string", description: "Reward amount per praise (e.g., '1WOW')", required: true },
+            { name: "budget", type: "string", description: "Total budget (e.g., '500WOW')", required: true },
+            { name: "expiration_time", type: "number", description: "Claim expiration timestamp (ms); 0 = no expiration", required: false },
+            { name: "max_claims_per_user", type: "number", description: "Max claims per user (default 1, prevents duplicate praise rewards)", required: false },
+        ],
+        example: "A photography service machine: place_order → booked → in_progress → completed → wonder. " +
+            "After delivery, the customer advances Progress to 'wonder' if satisfied. " +
+            "The Reward's Guard verifies Progress.current == 'wonder', and the customer claims 1 WOW. " +
+            "Merchant benefits from on-chain proof of customer satisfaction.",
+        relevantGuardOps: ["query", "progress_node_check"],
+    },
+    {
+        type: "wonder_feedback",
+        name: "Wonder-node feedback collection (covers wonder & no_wonder)",
+        description: "A feedback-collection Reward that pays a small amount for EITHER positive (wonder) OR " +
+            "negative (no_wonder) feedback, encouraging customers to leave honest reviews. " +
+            "The machine design pattern is the same as wonder_praise: " +
+            "place_order → booked → in_progress → completed → (wonder | no_wonder). " +
+            "The Reward's claim_guard verifies Progress.current ∈ {'wonder', 'no_wonder'} — both nodes " +
+            "trigger the reward. This is useful for merchants who want to gather feedback signal " +
+            "regardless of sentiment, e.g., for product improvement or public reputation metrics. " +
+            "Pair with a Repository that records the feedback node for historical analysis.",
+        guardCondition: "Guard verifies: (1) Progress.current ∈ {'wonder', 'no_wonder'}, " +
+            "(2) Progress.task == order_address AND order.service == this Service, " +
+            "(3) claimer is the order holder. " +
+            "The Guard should query the Progress object and check that current node is one of the " +
+            "two feedback nodes. Optional: write the feedback node to a Repository for analytics.",
+        amountRange: { min: "0.05WOW", max: "5WOW" },
+        allocationStrategy: "fixed",
+        parameters: [
+            { name: "amount", type: "string", description: "Reward amount per feedback (e.g., '0.5WOW')", required: true },
+            { name: "budget", type: "string", description: "Total budget (e.g., '200WOW')", required: true },
+            { name: "feedback_nodes", type: "string", description: "Comma-separated list of feedback node names (default: 'wonder,no_wonder')", required: false },
+            { name: "expiration_time", type: "number", description: "Claim expiration timestamp (ms); 0 = no expiration", required: false },
+        ],
+        example: "A freelance design service: place_order → ... → completed → (wonder | no_wonder). " +
+            "Customer advances to 'wonder' (liked the work) or 'no_wonder' (didn't like it). " +
+            "Both trigger a 0.5 WOW feedback reward. Merchant tracks the wonder/no_wonder ratio " +
+            "in a Repository to identify quality issues and improve service.",
+        relevantGuardOps: ["query", "progress_node_check", "repository_write"],
+    },
 ];
 const TEMPLATE_INDEX = new Map(REWARD_TEMPLATES.map((t) => [t.type, t]));
 export function getRewardTemplate(type) {
@@ -102,22 +164,32 @@ export function listRewardTemplates() {
 }
 export function suggestRewardTemplate(intent) {
     const lower = intent.toLowerCase();
+    if (lower.includes("wonder") || lower.includes("praise") || lower.includes("thumbs_up")
+        || lower.includes("好评") || lower.includes("positive review")
+        || lower.includes("satisfaction reward")) {
+        return getRewardTemplate("wonder_praise");
+    }
+    if (lower.includes("feedback") || lower.includes("review collection")
+        || lower.includes("no_wonder") || lower.includes("thumbs_down")
+        || lower.includes("差评") || lower.includes("both sentiment")) {
+        return getRewardTemplate("wonder_feedback");
+    }
     if (lower.includes("first order") || lower.includes("new") || lower.includes("first")) {
         return getRewardTemplate("first_order");
     }
-    if (lower.includes("referral") || lower.includes("viral") || lower.includes("referral")) {
+    if (lower.includes("referral") || lower.includes("viral")) {
         return getRewardTemplate("referral");
     }
-    if (lower.includes("repeat") || lower.includes("loyalty") || lower.includes("loyalty")) {
+    if (lower.includes("repeat") || lower.includes("loyalty")) {
         return getRewardTemplate("loyalty");
     }
-    if (lower.includes("limited-time") || lower.includes("flash") || lower.includes("flash")) {
+    if (lower.includes("limited-time") || lower.includes("flash")) {
         return getRewardTemplate("flash_sale");
     }
-    if (lower.includes("cashback") || lower.includes("cashback")) {
+    if (lower.includes("cashback")) {
         return getRewardTemplate("cashback");
     }
-    if (lower.includes("milestone") || lower.includes("milestone")) {
+    if (lower.includes("milestone")) {
         return getRewardTemplate("milestone");
     }
     return undefined;