@wowok/agent-mcp 2.5.2 → 2.5.4

package/dist/knowledge/payment-risk.js

@@ -155,6 +155,71 @@ const R_P_07 = {
         return { ...R_P_07.rule, evidence: "uses_signer_for_provenance=true (informational only)" };
     },
 };
+const R_P_08 = {
+    rule: {
+        id: "R-PAYMENT-08",
+        level: "MEDIUM",
+        category: "semantic",
+        title: "Payment scene binding (for_object + for_guard + index) — anti-reuse for exception branches",
+        description: "PaymentInfo supports for_object (binds to specific Order), for_guard (binds to specific Guard), " +
+            "and index (binds to specific Progress step) — payment.move#L66-71. When all three are set via " +
+            "payment_info_with_guard (payment.move#L82-86), the Payment is scene-bound: it can ONLY be used " +
+            "in the specific order + guard + progress context. This is the anti-reuse design for exception " +
+            "branch compensation (e.g., delivery delay >30min triggers auto-compensation). " +
+            "Payment is immutable (freeze_object, payment.move#L160) — binding cannot be altered. " +
+            "VERIFIER-EVIDENCE DESIGN: customer submits Payment, Guard verifies binding fields match current context.",
+        affected_stakeholders: ["signer", "recipient", "consumer"],
+        scenario: "Treasury creates compensation Payment with PaymentInfo(for_object=order, for_guard=exception_guard, index=current_progress) for delivery delay",
+        mitigation: "Use payment_info_with_guard for all exception branch Payments. Ensure for_object, for_guard, and index " +
+            "all match the intended context. Use tpl_payment_exception_compensation (guard-templates.ts) as design template.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.uses_scene_binding)
+            return null;
+        const missing = [];
+        if (!ctx.has_for_object)
+            missing.push("for_object not set (Order binding missing)");
+        if (!ctx.has_for_guard)
+            missing.push("for_guard not set (Guard binding missing)");
+        if (!ctx.has_index)
+            missing.push("index not set (Progress step binding missing)");
+        if (missing.length === 0)
+            return null;
+        return { ...R_P_08.rule, evidence: `incomplete scene binding: ${missing.join(", ")}` };
+    },
+};
+const R_P_09 = {
+    rule: {
+        id: "R-PAYMENT-09",
+        level: "LOW",
+        category: "semantic",
+        title: "PaymentInfo variant selection — use payment_info_with_guard for exception branches",
+        description: "PaymentInfo has 4 constructor variants (payment.move#L66-86): " +
+            "payment_info (for_object+remark+index, no for_guard), " +
+            "payment_info2 (remark+index, no for_object/for_guard), " +
+            "payment_info_with_guard (for_object+for_guard+remark+index — FULL binding), " +
+            "payment_info2_with_guard (for_guard+remark+index, no for_object). " +
+            "For exception branch compensation, ALWAYS use payment_info_with_guard to get full scene binding. " +
+            "Using payment_info (without for_guard) or payment_info2 (without for_object) weakens anti-reuse protection.",
+        affected_stakeholders: ["signer", "consumer"],
+        scenario: "Caller uses payment_info instead of payment_info_with_guard for exception compensation; for_guard is lost",
+        mitigation: "For exception branch Payments: always use payment_info_with_guard(for_object, for_guard, remark, index). " +
+            "For simple Payments without scene binding: payment_info or payment_info2 is fine. " +
+            "SDK should auto-select the variant based on which fields are provided.",
+        auto_fixable: true,
+    },
+    check: (ctx) => {
+        if (!ctx.uses_scene_binding)
+            return null;
+        if (ctx.payment_info_variant === "payment_info_with_guard")
+            return null;
+        return {
+            ...R_P_09.rule,
+            evidence: `uses_scene_binding=true but variant=${ctx.payment_info_variant ?? "unknown"} (should be payment_info_with_guard)`,
+        };
+    },
+};
 export const PAYMENT_RISK_RULES = [
     R_P_01,
     R_P_02,
@@ -163,6 +228,8 @@ export const PAYMENT_RISK_RULES = [
     R_P_05,
     R_P_06,
     R_P_07,
+    R_P_08,
+    R_P_09,
 ];
 export const PAYMENT_RISK_VERSION = "1.0.0";
 export function checkPaymentRisks(ctx) {

package/dist/knowledge/repository-confirm.d.ts

@@ -25,6 +25,10 @@ export interface RepositoryOpCheckInput {
     reward_count?: number;
     is_data_remove_with_passport?: boolean;
     description?: string;
+    has_quote_guard?: boolean;
+    quote_guard_is_depended?: boolean;
+    quote_guard_verifies_payment?: boolean;
+    has_owner_receive?: boolean;
 }
 export declare function preCheckRepositoryOp(input: RepositoryOpCheckInput): RepositoryConfirmItem[];
 export declare function canProceedRepositoryOp(input: RepositoryOpCheckInput): {

package/dist/knowledge/repository-confirm.js

@@ -196,6 +196,48 @@ function checkIdFromString(input) {
         fix_hint: "Use 0/1/2, or 'None'/'Clock'/'Signer' (case-insensitive).",
     };
 }
+function checkQuoteGuardIsDepended(input) {
+    if (!input.has_quote_guard) {
+        return { id: "C-REP-11", severity: "info", title: "quote_guard is_depended check", description: "Skipped: no quote_guard set.", passed: true };
+    }
+    const passed = input.quote_guard_is_depended === true;
+    return {
+        id: "C-REP-11",
+        severity: passed ? "info" : "block",
+        title: "quote_guard satisfies is_depended (immutable + rep=true + no relies)",
+        description: "When quote_guard is set, it MUST satisfy guard::is_depended (guard.move#L133-135): " +
+            "immutable=true, relies empty, rep=true. Move aborts with E_NEED_DEPENDENT_GUARD (repository.move#L422). " +
+            "VERIFIED: passport.rs#L545-612 — check_repository_quote_guard enforces this at query time. " +
+            "quote_guard is a RIGID verification requirement: any guard querying this Repository's data must satisfy it.",
+        passed,
+        evidence: passed ? "quote_guard is is_depended" : "quote_guard NOT is_depended (will abort)",
+        fix_hint: "Ensure the quote_guard Guard object has: immutable=true, relies=empty, rep=true.",
+    };
+}
+function checkQuoteGuardSubscriptionDesign(input) {
+    if (!input.has_quote_guard) {
+        return { id: "C-REP-12", severity: "info", title: "quote_guard subscription design check", description: "Skipped: no quote_guard set.", passed: true };
+    }
+    const issues = [];
+    if (!input.quote_guard_verifies_payment)
+        issues.push("quote_guard does not verify Payment for subscription");
+    if (!input.has_owner_receive)
+        issues.push("Repository missing owner_receive for Payment revenue");
+    const passed = issues.length === 0;
+    return {
+        id: "C-REP-12",
+        severity: passed ? "info" : "warn",
+        title: "quote_guard data subscription design — Payment verification + owner_receive revenue",
+        description: "For data subscription pattern (Repository+quote_guard+Payment): " +
+            "(1) quote_guard should verify Payment (for_object matches Repository, amount meets subscription price); " +
+            "(2) Repository should have owner_receive<T> configured to accept Payment as subscription revenue " +
+            "(repository.move#L714-717). VERIFIED: passport.rs#L545-612. " +
+            "DESIGN: user submits Payment via Passport → quote_guard verifies → repository data query passes.",
+        passed,
+        evidence: passed ? "quote_guard subscription design complete" : issues.join("; "),
+        fix_hint: "Use tpl_repository_quote_guard_subscription (guard-templates.ts) as the design template.",
+    };
+}
 export function preCheckRepositoryOp(input) {
     return [
         checkPolicyCount(input),
@@ -208,6 +250,8 @@ export function preCheckRepositoryOp(input) {
         checkRewardCount(input),
         checkDataRemoveWithPassportSubmission(input),
         checkIdFromString(input),
+        checkQuoteGuardIsDepended(input),
+        checkQuoteGuardSubscriptionDesign(input),
     ];
 }
 export function canProceedRepositoryOp(input) {

package/dist/knowledge/repository-risk.d.ts

@@ -31,10 +31,16 @@ export interface RepositoryRiskCheckContext {
     constants_synced?: boolean;
 }
 declare function normalizeIdFrom(v: number | string): number;
+export interface RepositoryQuoteGuardContext {
+    has_quote_guard?: boolean;
+    quote_guard_is_depended?: boolean;
+    quote_guard_verifies_payment?: boolean;
+    has_owner_receive?: boolean;
+}
 export declare const REPOSITORY_RISK_RULES: {
     rule: RepositoryRisk;
-    check: (ctx: RepositoryRiskCheckContext) => RepositoryRisk | null;
+    check: (ctx: RepositoryRiskCheckContext & RepositoryQuoteGuardContext) => RepositoryRisk | null;
 }[];
-export declare function checkRepositoryRisks(ctx: RepositoryRiskCheckContext): RepositoryRisk[];
+export declare function checkRepositoryRisks(ctx: RepositoryRiskCheckContext & RepositoryQuoteGuardContext): RepositoryRisk[];
 export declare function getRepositoryRiskById(id: string): RepositoryRisk | undefined;
 export { normalizeIdFrom as parseIdFromForRiskCheck };

package/dist/knowledge/repository-risk.js

@@ -285,6 +285,65 @@ const R_REP_5_01 = {
         return { ...R_REP_5_01.rule, evidence: "constants_synced=false" };
     },
 };
+const R_REP_6_01 = {
+    rule: {
+        id: "R-REP-11",
+        level: "HIGH",
+        category: "policy",
+        title: "quote_guard must be is_depended (immutable + rep=true + no relies) — Move assert",
+        description: "Repository policy's quote_guard must satisfy guard::is_depended (guard.move#L133-135): " +
+            "immutable=true, relies empty, rep=true. This ensures the quote_guard is a stable, " +
+            "repository-querying guard that can be depended upon. Move aborts with " +
+            "E_NEED_DEPENDENT_GUARD (repository.move#L422) if the guard is not is_depended. " +
+            "VERIFIED: passport.rs#L545-612 (check_repository_quote_guard enforces this at query time).",
+        affected_stakeholders: ["creator", "reader"],
+        scenario: "Creator sets quote_guard to a Guard that is not is_depended (e.g., has relies or is mutable)",
+        mitigation: "Ensure the quote_guard Guard object has: immutable=true, relies=empty, rep=true. " +
+            "Use pattern.repository_quote_guard_subscription as the design template.",
+        related_move_error: "E_NEED_DEPENDENT_GUARD",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.has_quote_guard)
+            return null;
+        if (ctx.quote_guard_is_depended)
+            return null;
+        return { ...R_REP_6_01.rule, evidence: "quote_guard set but not is_depended (immutable + rep=true + no relies)" };
+    },
+};
+const R_REP_6_02 = {
+    rule: {
+        id: "R-REP-12",
+        level: "MEDIUM",
+        category: "knowledge",
+        title: "quote_guard data subscription design — verify Payment verification + owner_receive revenue",
+        description: "When using quote_guard for data subscription (Repository+quote_guard+Payment pattern), " +
+            "ensure: (1) quote_guard verifies Payment fields (for_object matches Repository, amount meets price), " +
+            "(2) Repository has owner_receive<T> configured to accept Payment as subscription revenue " +
+            "(repository.move#L714-717). VERIFIED: passport.rs#L545-612, repository.move#L714-717. " +
+            "DESIGN: quote_guard is a RIGID verification requirement — any guard querying this Repository's " +
+            "data MUST satisfy the quote_guard (see R-X1-10 in guard-risk.ts).",
+        affected_stakeholders: ["creator", "reader", "verifier"],
+        scenario: "Creator sets quote_guard but does not configure Payment verification or owner_receive",
+        mitigation: "1) Ensure quote_guard verifies Payment (for_object, amount); " +
+            "2) Configure Repository owner_receive<T> to accept subscription Payment revenue; " +
+            "3) Use pattern.repository_quote_guard_subscription (guard-design-patterns.ts) and " +
+            "tpl_repository_quote_guard_subscription (guard-templates.ts) as design templates.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.has_quote_guard)
+            return null;
+        if (ctx.quote_guard_verifies_payment && ctx.has_owner_receive)
+            return null;
+        const missing = [];
+        if (!ctx.quote_guard_verifies_payment)
+            missing.push("quote_guard does not verify Payment");
+        if (!ctx.has_owner_receive)
+            missing.push("Repository missing owner_receive for revenue");
+        return { ...R_REP_6_02.rule, evidence: missing.join("; ") };
+    },
+};
 export const REPOSITORY_RISK_RULES = [
     R_REP_1_01,
     R_REP_2_01,
@@ -296,6 +355,8 @@ export const REPOSITORY_RISK_RULES = [
     R_REP_1_04,
     R_REP_1_05,
     R_REP_5_01,
+    R_REP_6_01,
+    R_REP_6_02,
 ];
 export function checkRepositoryRisks(ctx) {
     const risks = [];

package/dist/knowledge/repository-translation.js

@@ -329,6 +329,29 @@ export const REPOSITORY_CONSTRAINT_RULES = [
         failure_message: "Mode 5 routing missed if only id_from_submission is checked (P1-1 fix)",
         related_field: "policies[].write_guard",
     },
+    {
+        id: "REP_C_09",
+        name: "quote_guard must be is_depended (immutable + rep=true + no relies)",
+        description: "When quote_guard is set on a policy, it MUST satisfy guard::is_depended (guard.move#L133-135): " +
+            "immutable=true, relies empty, rep=true. Move aborts with E_NEED_DEPENDENT_GUARD (repository.move#L422). " +
+            "VERIFIED: passport.rs#L545-612 — check_repository_quote_guard enforces this when any guard queries " +
+            "this Repository's data (query 1167). quote_guard is a RIGID verification requirement.",
+        validation_logic: "quote_guard != null => guard.is_depended (immutable && relies.empty && rep)",
+        failure_message: "quote_guard must be is_depended — E_NEED_DEPENDENT_GUARD (repository.move#L422)",
+        related_field: "policies[].quote_guard",
+    },
+    {
+        id: "REP_C_10",
+        name: "quote_guard data subscription design (Payment verification + owner_receive)",
+        description: "For data subscription pattern: (1) quote_guard should verify Payment (for_object matches Repository, " +
+            "amount meets subscription price); (2) Repository should have owner_receive<T> configured to accept " +
+            "Payment as subscription revenue (repository.move#L714-717). " +
+            "DESIGN: user submits Payment via Passport → quote_guard verifies → impack_list updated → repository " +
+            "data query passes. 'On-chain data is consumed by guard verifiers.'",
+        validation_logic: "quote_guard != null => quote_guard_verifies_payment && repository_has_owner_receive",
+        failure_message: "quote_guard subscription incomplete: missing Payment verification or owner_receive revenue",
+        related_field: "policies[].quote_guard",
+    },
 ];
 function normalizeIdFrom(v) {
     if (typeof v === "number")

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;

package/dist/knowledge/scenario-modes.js

@@ -13,7 +13,7 @@ export const SCENARIO_MODES = [
             multi_tier_allocation: false,
         },
         machine_shape: [
-            { name: "ordered", role: "Customer places order, payment escrowed" },
+            { name: "paid", role: "Entry: order created and paid via Service.buy(); Machine starts here" },
             { name: "delivering", role: "Provider submits deliverable (WIP hash)" },
             { name: "delivered", role: "Deliverable available for review" },
             { name: "accepted", role: "Customer signs acceptance" },
@@ -27,6 +27,7 @@ export const SCENARIO_MODES = [
             { template_id: "accept_guard_signer", host: "machine", purpose: "Only customer can sign acceptance" },
             { template_id: "withdraw_guard_permission", host: "machine", purpose: "Only provider can withdraw after acceptance" },
             { template_id: "refund_guard_signer", host: "machine", purpose: "Only customer can initiate refund" },
+            { template_id: "tpl_payment_exception_compensation", host: "machine", purpose: "Delivery delay exception compensation via scene-bound Payment (§2.13)" },
         ],
         allocator: {
             recipient: "signer",
@@ -39,6 +40,7 @@ export const SCENARIO_MODES = [
             "Use Service `setting_locked_time` to lock rules for the engagement duration",
             "WIP hash on deliverable is mandatory — protects provider in disputes",
             "Acceptance gate is the trust pivot — both parties must agree on criteria",
+            "NEW: Payment exception compensation for delivery delays — provider Treasury auto-compensates customer (§2.13)",
         ],
     },
     {
@@ -55,7 +57,7 @@ export const SCENARIO_MODES = [
             multi_tier_allocation: false,
         },
         machine_shape: [
-            { name: "reserved", role: "Customer reserves item, pays deposit + rent" },
+            { name: "deposit_paid", role: "Entry: deposit + rent paid via Service.buy(); Machine starts here" },
             { name: "handover_out", role: "Owner hands over item, records pre-rental WIP" },
             { name: "in_use", role: "Rental period active" },
             { name: "returned", role: "Customer returns item" },
@@ -69,6 +71,8 @@ export const SCENARIO_MODES = [
             { template_id: "inspect_guard_signer", host: "machine", purpose: "Only owner can submit inspection result" },
             { template_id: "refund_guard_permission", host: "machine", purpose: "Refund requires owner permission" },
             { template_id: "damage_guard_wip", host: "machine", purpose: "Damage claim requires pre+post WIP comparison" },
+            { template_id: "tpl_payment_exception_compensation", host: "machine", purpose: "Return delay/damage exception compensation via scene-bound Payment (§2.13)" },
+            { template_id: "tpl_repository_quote_guard_subscription", host: "repository", purpose: "Weather/usage data oracle subscription (§2.11)" },
         ],
         allocator: {
             recipient: "entity",
@@ -81,6 +85,8 @@ export const SCENARIO_MODES = [
             "Pre-rental WIP is non-negotiable — without it, damage claims fail",
             "Deposit must be escrowed, not direct-transferred — enables fair deduction",
             "Inspection gate prevents customer from denying damage",
+            "NEW: Payment exception compensation for return delays — Treasury withdraws scene-bound Payment (§2.13)",
+            "NEW: Repository quote_guard for weather/usage data subscription revenue (§2.11)",
         ],
     },
     {
@@ -97,7 +103,7 @@ export const SCENARIO_MODES = [
             multi_tier_allocation: false,
         },
         machine_shape: [
-            { name: "enrolled", role: "Student enrolls, pays tuition" },
+            { name: "paid", role: "Entry: enrollment and tuition paid via Service.buy(); Machine starts here" },
             { name: "session_N", role: "Per-session attendance (1..N)" },
             { name: "completed", role: "All sessions delivered" },
             { name: "refunded", role: "Institution-approved refund" },
@@ -105,6 +111,7 @@ export const SCENARIO_MODES = [
         guards: [
             { template_id: "attendance_guard_signer", host: "machine", purpose: "Per-session student attendance signature" },
             { template_id: "refund_guard_permission", host: "machine", purpose: "Institution approval OR arbiter for refund" },
+            { template_id: "tpl_buy_guard_order_holder", host: "service", purpose: "Course module progressive unlock via supply chain sub-orders (§2.12)" },
         ],
         allocator: {
             recipient: "entity",
@@ -117,6 +124,8 @@ export const SCENARIO_MODES = [
             "Use Service `setting_locked_time` to lock rules mid-semester (regulatory compliance)",
             "Attendance Guard needs WIP hash for session content commitment",
             "Per-session release requires threshold-based trigger",
+            "NEW: Supply chain sub-orders for course module progressive unlock — each module = sub-service with buy_guard verifying previous module completion (§2.12)",
+            "NEW: Repository for learning progress collaboration data — progress as key, session data as value (§2.10)",
         ],
     },
     {
@@ -133,7 +142,7 @@ export const SCENARIO_MODES = [
             multi_tier_allocation: true,
         },
         machine_shape: [
-            { name: "ordered", role: "Customer books tour, pays deposit + final" },
+            { name: "paid", role: "Entry: tour booked and paid (deposit + final) via Service.buy(); Machine starts here" },
             { name: "segment_D1", role: "Segment 1 (e.g., hotel check-in)" },
             { name: "segment_D2", role: "Segment 2 (e.g., guided tour)" },
             { name: "returned", role: "Trip completed, customer returns" },
@@ -143,6 +152,9 @@ export const SCENARIO_MODES = [
         guards: [
             { template_id: "segment_guard_wip", host: "machine", purpose: "Per-segment arrival WIP (hotel check-in, etc.)" },
             { template_id: "refund_guard_permission", host: "machine", purpose: "Agency approval OR arbiter for trip interruption" },
+            { template_id: "tpl_buy_guard_order_holder", host: "service", purpose: "Supply chain sub-orders for tour package segments (§2.12)" },
+            { template_id: "tpl_payment_exception_compensation", host: "machine", purpose: "Trip delay/segment change exception compensation (§2.13)" },
+            { template_id: "tpl_repository_quote_guard_subscription", host: "repository", purpose: "Weather/travel data oracle subscription (§2.11)" },
         ],
         allocator: {
             recipient: "entity",
@@ -155,6 +167,9 @@ export const SCENARIO_MODES = [
             "Multi-tier Allocation is WoWok's unique advantage over traditional travel platforms",
             "segment_guard needs standardized WIP templates per segment type (hotel, transport, activity)",
             "Multi-tier waterfall needs guard chaining validation",
+            "NEW: Supply chain sub-orders — each tour segment = sub-service with buy_guard verifying main tour order (§2.12)",
+            "NEW: Payment exception compensation for flight/segment delays (§2.13)",
+            "NEW: Repository quote_guard for weather/travel data subscription revenue (§2.11)",
         ],
     },
     {
@@ -171,7 +186,7 @@ export const SCENARIO_MODES = [
             multi_tier_allocation: false,
         },
         machine_shape: [
-            { name: "subscribed", role: "Subscriber signs up" },
+            { name: "paid", role: "Entry: subscription paid and active via Service.buy(); Machine starts here" },
             { name: "charge_period_N", role: "Periodic charge (1..N)" },
             { name: "deliver_period_N", role: "Per-period delivery" },
             { name: "cancelled", role: "Subscriber cancels — takes effect next period" },
@@ -181,6 +196,7 @@ export const SCENARIO_MODES = [
             { template_id: "charge_guard_signer", host: "machine", purpose: "User confirms each charge — no auto-renew trap" },
             { template_id: "cancel_guard_signer", host: "machine", purpose: "User cancels anytime, next-period effective" },
             { template_id: "deliver_guard_wip", host: "machine", purpose: "Creator WIP hash per period — prevents content abandonment" },
+            { template_id: "tpl_repository_quote_guard_subscription", host: "repository", purpose: "Creator publishes paid data (analytics, market data) with quote_guard subscription (§2.11)" },
         ],
         allocator: {
             recipient: "entity",
@@ -193,6 +209,7 @@ export const SCENARIO_MODES = [
             "Pure digital — native WoWok soil",
             "charge_guard needs periodic trigger (off-chain scheduler + on-chain Guard)",
             "Targets indie creators, niche SaaS, paid newsletters",
+            "NEW: Repository quote_guard for creator data subscription revenue — creators publish paid data, users pay to access (§2.11)",
         ],
     },
     {

package/dist/knowledge/service-templates.js

@@ -369,6 +369,44 @@ export const SERVICE_TEMPLATES = [
             "Sales can still be updated post-publish (only allocator is locked)",
         ],
     },
+    {
+        id: "T-S-09",
+        name: "Supply Chain Sub-order Service (milestone unlock via buy_guard)",
+        description: "Sub-service whose buy_guard verifies the user purchased the main service order. Each milestone = one sub-order. Enables supply chain composition: main service → multiple sub-services with conditional access.",
+        applicable_scenes: ["service_buy_guard"],
+        industry_tags: ["travel", "rental", "education", "freelance", "ecommerce", "supply_chain"],
+        params: [
+            { name: "owner_address", type: "address", description: "Sub-service owner address", required: true },
+            { name: "permission_address", type: "address", description: "Permission object address", required: true },
+            { name: "description", type: "string", description: "Sub-service description (e.g., 'Hotel booking for tour package X')", required: true },
+            { name: "main_service_address", type: "address", description: "Main Service object address (the parent service)", required: true },
+            { name: "buy_guard_address", type: "address", description: "Guard address verifying main order ownership (order.owner==Signer AND order.service==main_service)", required: true },
+            { name: "price", type: "number", description: "Sub-service price", required: true },
+            { name: "machine_address", type: "address", description: "Machine object for sub-order workflow", required: true },
+        ],
+        body: (p) => ({
+            object: null,
+            description: p.description,
+            service_type: "supply_chain_sub",
+            buy_guard: p.buy_guard_address,
+            price: p.price,
+            machine: p.machine_address,
+            permission: p.permission_address,
+        }),
+        notes: [
+            "VERIFIED: service.move#L173 (buy_guard: Option<address>), L263-268 (buy_with_passport evaluates buy_guard)",
+            "VERIFIER-EVIDENCE DESIGN: user submits main Order as evidence (b_submission=true), buy_guard verifies order.owner==Signer AND order.service==main_service_address",
+            "No parent_order field needed — relationship verified via buy_guard querying submitted Order fields",
+            "Each milestone = one sub-order with its own Service + buy_guard + Machine",
+            "Main flow Machine can branch to different sub-services based on node progression",
+            "Use tpl_buy_guard_order_holder (guard-templates.ts) for the buy_guard design",
+        ],
+        post_publish_considerations: [
+            "buy_guard is mutable post-publish (can update the guard address)",
+            "If main service is unpublished, sub-service buy_guard will fail (order.service won't match)",
+            "Consider publishing main service before sub-services",
+        ],
+    },
 ];
 export const SERVICE_TEMPLATES_VERSION = "1.0.0";
 export function getAllServiceTemplates() {

package/dist/knowledge/treasury-templates.js

@@ -272,6 +272,48 @@ export const TREASURY_TEMPLATES = [
             "Suitable for fee sinks, donation pools, or auto-forwarding revenue",
         ],
     },
+    {
+        id: "T-T-07",
+        name: "Exception Compensation Treasury (scene-bound Payment withdraw)",
+        description: "Treasury for exception branch compensation: withdraws create scene-bound Payments with for_object + for_guard + index binding. Enables auto-compensation for delays, defects, or service exceptions.",
+        applicable_scenes: ["treasury_fund_collection", "treasury_um_delegation"],
+        industry_tags: ["retail", "travel", "rental", "freelance", "ecommerce"],
+        params: [
+            { name: "treasury_name", type: "string", description: "Name for the new Treasury object", required: true },
+            { name: "owner_address", type: "address", description: "Owner address (service provider, becomes admin)", required: true },
+            { name: "coin_type", type: "coin_type", description: "Coin type T (e.g. 0x2::wow::WOW)", required: true },
+            { name: "description", type: "string", description: "Treasury description (e.g., 'Compensation fund for delivery delays')", required: true },
+            { name: "permission_name", type: "string", description: "Name for the new Permission object", required: true },
+            { name: "withdrawer_address", type: "address", description: "Address authorized to withdraw compensations (can be same as owner)", required: true },
+            { name: "external_withdraw_guard", type: "address", description: "Guard address for external_withdraw (verifies exception conditions + Payment binding)", required: true },
+        ],
+        body: (p) => ({
+            object: {
+                name: p.treasury_name,
+                type_parameter: p.coin_type,
+                permission: {
+                    name: p.permission_name,
+                    description: `Permission for ${p.treasury_name}`,
+                    indexes: [
+                        { index: 253, name: "TREASURY_DEPOSIT", mark: p.owner_address, description: "Owner deposits funds" },
+                        { index: 254, name: "TREASURY_WITHDRAW", mark: p.withdrawer_address, description: "Withdraw for exception compensation (creates scene-bound Payment)" },
+                        { index: 256, name: "TREASURY_EXTERNAL_WITHDRAW", mark: p.withdrawer_address, description: "External withdraw with guard (verifies exception + Payment binding)" },
+                        { index: 257, name: "TREASURY_OWNER_RECEIVE", mark: p.owner_address, description: "Owner receives remaining funds" },
+                    ],
+                },
+            },
+            description: p.description,
+        }),
+        notes: [
+            "VERIFIED: treasury.move#L249-264 (withdraw creates Payment via payment::new_singleton + from_object_set)",
+            "VERIFIED: treasury.move#L415-418 (withdraw<T> sends to recipient with PaymentInfo)",
+            "Payment created has PaymentInfo(for_object=order, for_guard=exception_guard, index=current_progress)",
+            "ANTI-REUSE: for_object + for_guard + index binds Payment to specific context (payment.move#L66-71)",
+            "VERIFIER-EVIDENCE: customer submits Payment via Passport, Guard verifies binding fields match",
+            "Use with tpl_payment_exception_compensation (guard-templates.ts) for the exception branch guard",
+            "Suitable for: delivery delay compensation, defect refund, service-level agreement penalties",
+        ],
+    },
 ];
 export const TREASURY_TEMPLATES_VERSION = "1.0.0";
 export function getAllTreasuryTemplates() {

package/dist/knowledge/trust-metrics.d.ts

@@ -1,6 +1,9 @@
 export interface ServiceTrustMetrics {
     arbitrationScore?: number;
     arbitrationCases?: number;
+    arbitrationVotingGuardCount?: number;
+    arbitrationFeeBalance?: bigint;
+    arbitrationPaused?: boolean;
     reviewStats?: {
         likes: number;
         dislikes: number;
@@ -11,6 +14,7 @@ export interface ServiceTrustMetrics {
     completedRate?: number;
     avgCompletionTime?: number;
     compensationFundBalance?: bigint;
+    typicalOrderAmount?: bigint;
     hasPublishedEvents?: boolean;
     hasMachineBound?: boolean;
     hasBuyGuard?: boolean;