@wowok/agent-mcp 2.6.1 → 2.6.3

package/dist/extensions/modes.js

@@ -64,19 +64,47 @@ const RETAIL_BUILD_NOTES = [
     "Refund path must support return-and-exchange flow",
     "Compensation fund covers return/exchange disputes",
 ];
+const RETAIL_D2C_MACHINE_SHAPE = [
+    { name: "ordered", role: "Entry: order created (funds escrowed in Allocation)" },
+    { name: "shipped", role: "Merchant ships goods" },
+    { name: "delivered", role: "Goods delivered to buyer" },
+    { name: "completed", role: "Buyer confirms receipt — withdraw_guard releases funds" },
+    { name: "cancelled", role: "Pre-ship cancellation — refund_guard refunds buyer" },
+];
+const RETAIL_D2C_GUARDS = [
+    { template_id: "withdraw_guard_delivery", host: "service", purpose: "Release funds to merchant + processor on order completion (delivery confirmation)" },
+    { template_id: "refund_guard_cancellation", host: "service", purpose: "Refund 100% to buyer on order cancellation" },
+];
+const RETAIL_D2C_ALLOCATOR = {
+    recipient: "entity",
+    count: 2,
+    mode: "rate",
+    description: "Merchant 97% + Processor 3% (rate-based split, no platform commission)",
+};
+const RETAIL_D2C_KEY_RISK = "No platform arbitration — disputes rely on optional Arbitration or off-chain chargeback";
+const RETAIL_D2C_BUILD_NOTES = [
+    "Allocation escrow replaces platform custody — funds locked in contract until Guard releases",
+    "withdraw_guard enforces delivery gate — merchant must reach 'completed' state to receive payment",
+    "refund_guard ensures 100% refund on cancellation — no merchant approval needed",
+    "No buy_guard needed — D2C doesn't gate purchases (open storefront)",
+    "Arbitration is optional — add when dispute volume justifies the cost",
+    "Service ↔ Guard circular dependency: create Service (unpublished) → create Guards → update Service (publish)",
+];
 const SUPPORTED_INDUSTRY_SET = new Set([
-    "freelance", "rental", "education", "travel", "subscription", "retail",
+    "freelance", "rental", "education", "travel", "subscription", "retail", "retail_d2c",
 ]);
 function fetchTemplate(name) {
-    const traits = getIndustryTraits(name) ?? GENERAL_TRAITS;
+    const traitsLookupName = name === "retail_d2c" ? "retail" : name;
+    const traits = getIndustryTraits(traitsLookupName) ?? GENERAL_TRAITS;
     const isSupported = SUPPORTED_INDUSTRY_SET.has(name);
+    const industryLookupName = name === "retail_d2c" ? "retail" : name;
     const risk_checks = isSupported
-        ? getIndustryRiskChecks(name)
+        ? getIndustryRiskChecks(industryLookupName)
         : [];
     const needs = isSupported
-        ? getIndustryNeeds(name)
+        ? getIndustryNeeds(industryLookupName)
         : [];
-    const flywheel = getFlywheelForIndustry(name) ?? GENERAL_FLYWHEEL;
+    const flywheel = getFlywheelForIndustry(traitsLookupName) ?? GENERAL_FLYWHEEL;
     let machine_shape;
     let guards;
     let allocator;
@@ -89,6 +117,13 @@ function fetchTemplate(name) {
         key_risk = RETAIL_KEY_RISK;
         build_notes = RETAIL_BUILD_NOTES;
     }
+    else if (name === "retail_d2c") {
+        machine_shape = RETAIL_D2C_MACHINE_SHAPE;
+        guards = RETAIL_D2C_GUARDS;
+        allocator = RETAIL_D2C_ALLOCATOR;
+        key_risk = RETAIL_D2C_KEY_RISK;
+        build_notes = RETAIL_D2C_BUILD_NOTES;
+    }
     else if (name === "general") {
         const sm = getScenarioMode("general");
         machine_shape = GENERAL_MACHINE_SHAPE;
@@ -113,7 +148,7 @@ function fetchTemplate(name) {
 export const BUILTIN_MODES = [
     {
         name: "freelance",
-        display_name: "Freelance 自由职业",
+        display_name: "Freelance",
         version: "v1",
         source: "builtin",
         ...fetchTemplate("freelance"),
@@ -131,28 +166,31 @@ export const BUILTIN_MODES = [
             machine: { wip_required: true, wip_hash_algorithm: "sha256", acceptance_gate: true },
         },
         expected_benefits: [
-            { metric: "纠纷率降低", expected_value: "40%", evidence: "WIP 哈希 + 里程碑分账强制交付证据" },
-            { metric: "交付确认效率", expected_value: "提升 50%", evidence: "acceptance gate 自动化验收" },
-            { metric: "提供方回款保障", expected_value: "100%", evidence: "accepted 节点后资金自动释放给提供方" },
+            { metric: "Dispute rate reduction", expected_value: "40%", evidence: "WIP hash + milestone allocation enforces delivery evidence" },
+            { metric: "Delivery confirmation efficiency", expected_value: "+50%", evidence: "acceptance gate automates acceptance workflow" },
+            { metric: "Provider payment assurance", expected_value: "100%", evidence: "Funds auto-release to provider after accepted node" },
         ],
         risk_appetite: "balanced",
         risk_constraints: {
             require_arbitration: true,
             require_compensation_fund: false,
             require_wip_evidence: true,
-            other_constraints: ["setting_locked_time ≥ 7d 以锁定合作期规则"],
+            other_constraints: [
+                "setting_locked_time >= 7d to lock engagement-period rules",
+                "ISSUE-P1-4: 48h auto-accept requires off-chain keeper (WoWok Guard does not support time-based triggers). Deploy a keeper service that polls Progress objects in 'delivered' state and calls adminUnhold (permission 224) after 48h timeout. See keeper template in docs.",
+            ],
         },
         applicable_conditions: {
             business_scale: "small",
             min_daily_orders: 1,
-            other_conditions: ["适合中长期项目交付", "需里程碑分阶段验收"],
+            other_conditions: ["Suitable for mid-to-long-term project delivery", "Requires milestone-based phased acceptance"],
         },
         similar_industries: ["rental", "education"],
         novel_capabilities: ["allocation.distribute_milestone"],
     },
     {
         name: "rental",
-        display_name: "Rental 租赁",
+        display_name: "Rental",
         version: "v1",
         source: "builtin",
         ...fetchTemplate("rental"),
@@ -170,9 +208,9 @@ export const BUILTIN_MODES = [
             machine: { wip_required: true, wip_stages: ["handover_out", "returned"], inspection_gate: true },
         },
         expected_benefits: [
-            { metric: "押金纠纷率", expected_value: "降低 60%", evidence: "pre-rental WIP 强制记录物品原始状态" },
-            { metric: "损坏定责准确率", expected_value: "提升 70%", evidence: "前后 WIP 哈希对比，杜绝无据扣款" },
-            { metric: "信任评分", expected_value: "提升 25%", evidence: "compensation_fund 覆盖损坏风险" },
+            { metric: "Deposit dispute rate", expected_value: "-60%", evidence: "pre-rental WIP mandatorily records item's original state" },
+            { metric: "Damage liability accuracy", expected_value: "+70%", evidence: "pre/post WIP hash comparison eliminates unfounded deductions" },
+            { metric: "Trust score", expected_value: "+25%", evidence: "compensation_fund covers damage risk" },
         ],
         risk_appetite: "conservative",
         risk_constraints: {
@@ -180,19 +218,20 @@ export const BUILTIN_MODES = [
             require_compensation_fund: true,
             require_wip_evidence: true,
             max_single_transaction: 10000,
-            other_constraints: ["押金必须 escrow 托管（不可直转）", "lock_duration ≥ 7d 防止商家随意提取"],
+            compensation_fund_coverage_ratio: 10,
+            other_constraints: ["Deposit must be escrowed (no direct transfer)", "lock_duration >= 7d to prevent arbitrary merchant withdrawal"],
         },
         applicable_conditions: {
             business_scale: "small",
             min_daily_orders: 1,
-            other_conditions: ["需物理物品交接", "有物流或线下交付环节"],
+            other_conditions: ["Requires physical item handover", "Has logistics or offline delivery leg"],
         },
         similar_industries: ["retail", "travel"],
         novel_capabilities: [],
     },
     {
         name: "education",
-        display_name: "Education 教育",
+        display_name: "Education",
         version: "v1",
         source: "builtin",
         ...fetchTemplate("education"),
@@ -218,28 +257,28 @@ export const BUILTIN_MODES = [
             service: { setting_locked_time: "120d", anti_runaway: true },
         },
         expected_benefits: [
-            { metric: "退费纠纷率", expected_value: "降低 50%", evidence: "per-session release 按课时释放学费" },
-            { metric: "机构跑路风险", expected_value: "消除", evidence: "资金按课时释放，未交付部分可退" },
-            { metric: "出勤可追溯", expected_value: "100%", evidence: "attendance_guard 每课时签名" },
+            { metric: "Refund dispute rate", expected_value: "-50%", evidence: "per-session release distributes tuition by class" },
+            { metric: "Institution runaway risk", expected_value: "eliminated", evidence: "Funds release per session; undelivered portion is refundable" },
+            { metric: "Attendance traceability", expected_value: "100%", evidence: "attendance_guard signs each session" },
         ],
         risk_appetite: "conservative",
         risk_constraints: {
             require_arbitration: true,
             require_compensation_fund: true,
             require_wip_evidence: false,
-            other_constraints: ["setting_locked_time 覆盖整个学期（≥90d）", "长周期需关注 >90d 进度"],
+            other_constraints: ["setting_locked_time covers the entire term (>=90d)", "Long-cycle projects must monitor >90d progress"],
         },
         applicable_conditions: {
             business_scale: "medium",
             min_daily_orders: 1,
-            other_conditions: ["长周期交付", "需分课时验收", "监管强度 medium"],
+            other_conditions: ["Long-cycle delivery", "Requires per-session acceptance", "Regulatory intensity: medium"],
         },
         similar_industries: ["freelance", "subscription"],
         novel_capabilities: ["allocation.distribute_milestone"],
     },
     {
         name: "travel",
-        display_name: "Travel 旅游",
+        display_name: "Travel",
         version: "v1",
         source: "builtin",
         ...fetchTemplate("travel"),
@@ -266,28 +305,28 @@ export const BUILTIN_MODES = [
             service: { supply_chain_suborders: true, segment_guard_required: true },
         },
         expected_benefits: [
-            { metric: "资金透明度", expected_value: "100%", evidence: "multi-tier allocation 按段分账至酒店/导游/司机" },
-            { metric: "行程变更纠纷", expected_value: "降低 45%", evidence: "segment WIP 每段验收" },
-            { metric: "违约赔付保障", expected_value: "提升 60%", evidence: "compensation_fund 覆盖行程违约" },
+            { metric: "Fund transparency", expected_value: "100%", evidence: "multi-tier allocation splits per segment to hotel/guide/driver" },
+            { metric: "Itinerary change disputes", expected_value: "-45%", evidence: "segment WIP accepts each leg" },
+            { metric: "Breach compensation assurance", expected_value: "+60%", evidence: "compensation_fund covers itinerary breach" },
         ],
         risk_appetite: "balanced",
         risk_constraints: {
             require_arbitration: true,
             require_compensation_fund: true,
             require_wip_evidence: true,
-            other_constraints: ["多级分账需 guard chaining 校验", "deposit 20% + final 80% 两段付款"],
+            other_constraints: ["Multi-tier allocation requires guard chaining validation", "deposit 20% + final 80% two-stage payment"],
         },
         applicable_conditions: {
             business_scale: "medium",
             min_daily_orders: 1,
-            other_conditions: ["多段行程组合", "需酒店/导游/司机多方分账"],
+            other_conditions: ["Multi-segment itinerary combination", "Requires hotel/guide/driver multi-party allocation"],
         },
         similar_industries: ["rental", "education"],
         novel_capabilities: [],
     },
     {
         name: "subscription",
-        display_name: "Subscription 订阅",
+        display_name: "Subscription",
         version: "v1",
         source: "builtin",
         ...fetchTemplate("subscription"),
@@ -310,28 +349,29 @@ export const BUILTIN_MODES = [
             service: { creator_data_subscription: true, periodic_billing: true },
         },
         expected_benefits: [
-            { metric: "续费率", expected_value: "提升 25%", evidence: "loyalty reward + 透明订阅机制" },
-            { metric: "退订纠纷", expected_value: "消除", evidence: "cancel anytime + no auto-renew trap" },
-            { metric: "创作者留存", expected_value: "提升 30%", evidence: "deliver_guard_wip 防止内容断更" },
+            { metric: "Renewal rate", expected_value: "+25%", evidence: "loyalty reward + transparent subscription mechanism" },
+            { metric: "Cancellation disputes", expected_value: "eliminated", evidence: "cancel anytime + no auto-renew trap" },
+            { metric: "Creator retention", expected_value: "+30%", evidence: "deliver_guard_wip prevents content dropout" },
         ],
         risk_appetite: "aggressive",
         risk_constraints: {
             require_arbitration: false,
             require_compensation_fund: false,
             require_wip_evidence: false,
-            other_constraints: ["禁止 dead-end 节点（防止锁定）", "charge_guard 每期需用户确认"],
+            compensation_fund_coverage_ratio: 3,
+            other_constraints: ["Forbid dead-end nodes (prevent lock-in)", "charge_guard requires user confirmation each period"],
         },
         applicable_conditions: {
             business_scale: "small",
             min_daily_orders: 5,
-            other_conditions: ["纯数字交付", "周期性内容或 SaaS 服务"],
+            other_conditions: ["Pure-digital delivery", "Periodic content or SaaS service"],
         },
         similar_industries: ["freelance", "education"],
         novel_capabilities: [],
     },
     {
         name: "retail",
-        display_name: "Retail 零售",
+        display_name: "Retail",
         version: "v1",
         source: "builtin",
         ...fetchTemplate("retail"),
@@ -354,28 +394,74 @@ export const BUILTIN_MODES = [
             service: { logistics_mode: "standard", first_order_discount: true },
         },
         expected_benefits: [
-            { metric: "退货纠纷率", expected_value: "降低 35%", evidence: "logistics WIP + refund path 保障" },
-            { metric: "复购率", expected_value: "提升 20%", evidence: "spend cashback reward" },
-            { metric: "商品真实性可追溯", expected_value: "100%", evidence: "WIP 验证商品/物流信息" },
+            { metric: "Return dispute rate", expected_value: "-35%", evidence: "logistics WIP + refund path assurance" },
+            { metric: "Repurchase rate", expected_value: "+20%", evidence: "spend cashback reward" },
+            { metric: "Product authenticity traceability", expected_value: "100%", evidence: "WIP verifies product/logistics info" },
         ],
         risk_appetite: "conservative",
         risk_constraints: {
             require_arbitration: true,
             require_compensation_fund: true,
             require_wip_evidence: false,
-            other_constraints: ["refund_window ≥ 7d", "confirm_gate 仅买家可确认收货"],
+            compensation_fund_coverage_ratio: 5,
+            other_constraints: ["refund_window >= 7d", "confirm_gate: only buyer can confirm receipt"],
         },
         applicable_conditions: {
             business_scale: "medium",
             min_daily_orders: 10,
-            other_conditions: ["有物流发货环节", "高频小额交易"],
+            other_conditions: ["Has logistics shipping leg", "High-frequency small-ticket transactions"],
         },
         similar_industries: ["rental", "subscription"],
         novel_capabilities: [],
     },
+    {
+        name: "retail_d2c",
+        display_name: "Retail D2C (Direct-to-Consumer)",
+        version: "v1",
+        source: "builtin",
+        ...fetchTemplate("retail_d2c"),
+        capabilities_used: [
+            "permission.index_create", "permission.role_assign",
+            "guard.validate_withdraw", "guard.validate_refund",
+            "machine.node_topology",
+            "allocation.distribute",
+            "service.publish", "progress.advance",
+            "contact.im_create",
+        ],
+        config_overrides: {
+            machine: {
+                wip_required: false,
+                confirm_gate: true,
+                refund_requires_approval: false,
+            },
+            service: { logistics_mode: "merchant_managed", multi_recipient_allocation: true },
+        },
+        expected_benefits: [
+            { metric: "Merchant revenue share", expected_value: "97%", evidence: "No platform commission — only 3% processing fee" },
+            { metric: "Fund safety", expected_value: "contract-grade", evidence: "Allocation escrow + Guard verification replaces platform custody" },
+            { metric: "Delivery reliability", expected_value: "high", evidence: "withdraw_guard enforces delivery confirmation before payment" },
+        ],
+        risk_appetite: "balanced",
+        risk_constraints: {
+            require_arbitration: false,
+            require_compensation_fund: false,
+            require_wip_evidence: false,
+            other_constraints: [
+                "Allocation escrow required (withdraw_guard + refund_guard)",
+                "Service ↔ Guard circular dependency requires 3-step creation pattern",
+            ],
+        },
+        applicable_conditions: {
+            business_scale: "small",
+            min_daily_orders: 1,
+            other_conditions: ["Independent storefront (no marketplace)", "Merchant-managed logistics", "Allocation escrow model"],
+        },
+        similar_industries: ["retail", "subscription"],
+        novel_capabilities: ["Allocation escrow as platform-custody alternative", "Multi-recipient allocation (merchant + processor)"],
+    },
     {
         name: "general",
-        display_name: "General 通用",
+        display_name: "General",
         version: "v1",
         source: "builtin",
         ...fetchTemplate("general"),
@@ -388,8 +474,8 @@ export const BUILTIN_MODES = [
             "progress.advance",
         ],
         expected_benefits: [
-            { metric: "灵活性", expected_value: "100%", evidence: "用户自定义所有信任机制参数" },
-            { metric: "降级安全", expected_value: "可用", evidence: "任意时刻可切换至 general 兜底" },
+            { metric: "Flexibility", expected_value: "100%", evidence: "User customizes all trust mechanism parameters" },
+            { metric: "Degraded safety", expected_value: "usable", evidence: "Can fall back to general at any time" },
         ],
         risk_appetite: "balanced",
         risk_constraints: {
@@ -399,7 +485,7 @@ export const BUILTIN_MODES = [
         },
         applicable_conditions: {
             business_scale: "small",
-            other_conditions: ["降级兜底模式", "未被其他行业覆盖的混合场景"],
+            other_conditions: ["Fallback degraded mode", "Hybrid scenarios not covered by other industries"],
         },
         similar_industries: [],
         novel_capabilities: [],

package/dist/extensions/registry.d.ts

@@ -41,6 +41,8 @@ export declare class IndustryModeRegistry {
     private buildSteps;
     private defaultScenarios;
     private recordCapabilitiesUsed;
+    private deriveGuardShortName;
+    private getFirstServiceGuardName;
     private makeObject;
     private registerBuiltinModes;
 }

package/dist/extensions/registry.js

@@ -116,7 +116,7 @@ export class IndustryModeRegistry {
             mode.evolution_history = [{
                     version: mode.version || "v1",
                     changed_at: Date.now(),
-                    changes: ["初始注册（registerUserMode）"],
+                    changes: ["Initial registration (registerUserMode)"],
                 }];
         }
         this.userModes.set(userKey, mode);
@@ -161,7 +161,7 @@ export class IndustryModeRegistry {
             evolution_history: [{
                     version: "v1",
                     changed_at: Date.now(),
-                    changes: [`从 builtin '${sourceMode}' 派生`],
+                    changes: [`Derived from builtin '${sourceMode}'`],
                 }],
         };
         this.userModes.set(userKey, derived);
@@ -333,22 +333,33 @@ export class IndustryModeRegistry {
         const objects = [];
         objects.push(this.makeObject("permission", `${prefix}_permission`, {
             name: `${prefix}_permission`,
-            description: `Permission: 角色权限索引（${mode.display_name}）`,
+            description: `Permission: role permission index (${mode.display_name})`,
             permission_indexes: this.buildPermissionIndexes(mode),
             tags: [`industry:${mode.name}`],
         }));
-        objects.push(this.makeObject("guard", `${prefix}_guard_buy`, {
-            name: `${prefix}_guard_buy`,
-            description: `Guard: 下单验证（${mode.display_name}）`,
-            host: "service",
-            templates: mode.guards.filter(g => g.host === "service").map(g => g.template_id),
-            tags: [`industry:${mode.name}`],
-        }));
+        const serviceGuardName = this.getFirstServiceGuardName(mode, prefix);
+        for (const guard of mode.guards) {
+            const shortName = this.deriveGuardShortName(guard.template_id);
+            const guardName = `${prefix}_guard_${shortName}`;
+            objects.push(this.makeObject("guard", guardName, {
+                name: guardName,
+                description: `Guard: ${guard.purpose} (${mode.display_name})`,
+                host: guard.host,
+                template_id: guard.template_id,
+                tags: [`industry:${mode.name}`, `host:${guard.host}`],
+            }));
+        }
         objects.push(this.makeObject("machine", `${prefix}_machine`, {
             name: `${prefix}_machine`,
-            description: `Machine: 工作流拓扑（${mode.display_name}）— ${mode.machine_shape.length} 节点`,
+            description: `Machine: workflow topology (${mode.display_name}) — ${mode.machine_shape.length} nodes`,
             nodes: mode.machine_shape.map(n => ({ name: n.name, role: n.role })),
-            guard_templates: mode.guards.filter(g => g.host === "machine").map(g => g.template_id),
+            guard_objects: mode.guards
+                .filter(g => g.host === "machine")
+                .map(g => ({
+                template_id: g.template_id,
+                object_name: `${prefix}_guard_${this.deriveGuardShortName(g.template_id)}`,
+                purpose: g.purpose,
+            })),
             permission: `${prefix}_permission`,
             entry_node_forward_hint: {
                 entry_node_name: mode.machine_shape[0]?.name ?? "paid",
@@ -366,31 +377,32 @@ export class IndustryModeRegistry {
         }, true));
         objects.push(this.makeObject("treasury", `${prefix}_treasury`, {
             name: `${prefix}_treasury`,
-            description: `Treasury: 资金托管（${mode.display_name}）`,
+            description: `Treasury: fund escrow (${mode.display_name})`,
             owner_receive: true,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("allocation", `${prefix}_allocation`, {
             name: `${prefix}_allocation`,
-            description: `Allocation: 分账策略（${mode.display_name}）— ${mode.allocator.description}`,
+            description: `Allocation: allocation strategy (${mode.display_name}) — ${mode.allocator.description}`,
             strategy: mode.allocator,
             treasury: `${prefix}_treasury`,
-            guard: `${prefix}_guard_buy`,
+            guard: serviceGuardName,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("service", `${prefix}_service`, {
             name: `${prefix}_service`,
-            description: `Service: 业务服务（${mode.display_name}）— ${intent.slice(0, 100)}`,
+            description: `Service: business service (${mode.display_name}) — ${intent.slice(0, 100)}`,
             machine: `${prefix}_machine`,
-            buy_guard: `${prefix}_guard_buy`,
+            buy_guard: serviceGuardName,
             permission: `${prefix}_permission`,
             order_allocators: [`${prefix}_allocation`],
             compensation_fund_balance: 0,
             compensation_fund_required: mode.risk_constraints?.require_compensation_fund ?? false,
+            compensation_fund_coverage_ratio: mode.risk_constraints?.compensation_fund_coverage_ratio ?? 5,
             compensation_fund_add_hint: "Call service.compensation_fund_add with a Coin<T> to deposit. " +
                 "The compensation_fund is a Balance<T> (numeric), not a Treasury object reference. " +
                 "Without deposit, arbitration rulings that award refunds to buyers cannot be paid out. " +
-                "Recommend 5× the max single-order amount (P1-1 evaluation rule).",
+                `Recommend ${mode.risk_constraints?.compensation_fund_coverage_ratio ?? 5}× the max single-order amount (P1-1 evaluation rule, industry: ${mode.name}).`,
             arbitrations: [`${prefix}_arb`],
             rewards: [`${prefix}_reward`],
             business_intent: intent,
@@ -399,25 +411,25 @@ export class IndustryModeRegistry {
         }, true));
         objects.push(this.makeObject("progress", `${prefix}_progress`, {
             name: `${prefix}_progress`,
-            description: `Progress: 订单履约进度（${mode.display_name}）`,
+            description: `Progress: order fulfillment progress (${mode.display_name})`,
             parent: `${prefix}_machine`,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("arb", `${prefix}_arb`, {
             name: `${prefix}_arb`,
-            description: `Arbitration: 仲裁规则（${mode.display_name}）— ${mode.key_risk}`,
+            description: `Arbitration: arbitration rules (${mode.display_name}) — ${mode.key_risk}`,
             guard: `${prefix}_guard_buy`,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("reward", `${prefix}_reward`, {
             name: `${prefix}_reward`,
-            description: `Reward: 激励规则（${mode.display_name}）`,
+            description: `Reward: incentive rules (${mode.display_name})`,
             claim_guard: `${prefix}_guard_buy`,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("contact", `${prefix}_contact`, {
             name: `${prefix}_contact`,
-            description: `Contact: 客服联系（${mode.display_name}）`,
+            description: `Contact: customer service contact (${mode.display_name})`,
             tags: [`industry:${mode.name}`],
         }));
         return objects;
@@ -501,21 +513,21 @@ export class IndustryModeRegistry {
             ?? "";
         const service = find(`${prefix}_service`);
         const machine = find(`${prefix}_machine`);
-        const guard = find(`${prefix}_guard_buy`);
         const permission = find(`${prefix}_permission`);
         const allocation = find(`${prefix}_allocation`);
         const treasury = find(`${prefix}_treasury`);
         const arb = find(`${prefix}_arb`);
         const reward = find(`${prefix}_reward`);
         const progress = find(`${prefix}_progress`);
-        if (!service || !machine || !guard || !permission) {
+        const allGuards = objects.filter(o => o.object_type === "guard");
+        const serviceGuard = allGuards.find(g => g.config?.host === "service");
+        const machineGuards = allGuards.filter(g => g.config?.host === "machine");
+        if (!service || !machine || !permission) {
             const missing = [];
             if (!service)
                 missing.push("service");
             if (!machine)
                 missing.push("machine");
-            if (!guard)
-                missing.push("guard");
             if (!permission)
                 missing.push("permission");
             console.warn(`[buildEdges] Missing core objects: ${missing.join(", ")}. ` +
@@ -524,7 +536,9 @@ export class IndustryModeRegistry {
             return edges;
         }
         edges.push(this.makeEdge(service, machine, "machine", "service.machine", true));
-        edges.push(this.makeEdge(service, guard, "buy_guard", "service.buy_guard", true));
+        if (serviceGuard) {
+            edges.push(this.makeEdge(service, serviceGuard, "buy_guard", "service.buy_guard", true));
+        }
         edges.push(this.makeEdge(service, permission, "permission", "service.permission", true));
         if (allocation)
             edges.push(this.makeEdge(service, allocation, "order_allocators", "service.order_allocators", true));
@@ -533,12 +547,15 @@ export class IndustryModeRegistry {
         if (reward)
             edges.push(this.makeEdge(service, reward, "rewards", "service.rewards", false));
         edges.push(this.makeEdge(machine, permission, "permission", "machine.permission", false));
+        for (const mg of machineGuards) {
+            edges.push(this.makeEdge(machine, mg, "guard", "machine.forwards.guard", false));
+        }
         if (progress)
             edges.push(this.makeEdge(progress, machine, "parent", "progress.parent", false));
         if (allocation && treasury)
             edges.push(this.makeEdge(allocation, treasury, "treasury", "allocation.treasury", false));
-        if (allocation && guard)
-            edges.push(this.makeEdge(allocation, guard, "buy_guard", "allocation.guard", false));
+        if (allocation && serviceGuard)
+            edges.push(this.makeEdge(allocation, serviceGuard, "buy_guard", "allocation.guard", false));
         return edges;
     }
     makeEdge(from, to, edge_kind, field_path, required_at_publish) {
@@ -590,7 +607,7 @@ export class IndustryModeRegistry {
         const service = objects.find(o => o.object_type === "service");
         return [{
                 scenario_id: `${mode.name}_primary`,
-                description: `${mode.display_name} 主流程：${intent.slice(0, 80)}`,
+                description: `${mode.display_name} main flow: ${intent.slice(0, 80)}`,
                 primary_object: service?.entry_id ?? "",
                 supporting_objects: objects.filter(o => o.object_type !== "service").map(o => o.entry_id),
             }];
@@ -607,6 +624,22 @@ export class IndustryModeRegistry {
         catch {
         }
     }
+    deriveGuardShortName(templateId) {
+        if (templateId.startsWith("tpl_")) {
+            const parts = templateId.split("_");
+            return parts[parts.length - 1] || templateId;
+        }
+        const match = templateId.match(/^([a-z]+)_guard_/);
+        if (match)
+            return match[1];
+        return templateId.split("_")[0] || templateId;
+    }
+    getFirstServiceGuardName(mode, prefix) {
+        const serviceGuard = mode.guards.find(g => g.host === "service");
+        if (!serviceGuard)
+            return "";
+        return `${prefix}_guard_${this.deriveGuardShortName(serviceGuard.template_id)}`;
+    }
     makeObject(type, name, config, publish_required = false) {
         return {
             entry_id: `${type}:${name}`,

package/dist/extensions/types.d.ts

@@ -68,6 +68,7 @@ export interface ModeRiskConstraints {
     require_compensation_fund: boolean;
     require_wip_evidence: boolean;
     max_single_transaction?: number;
+    compensation_fund_coverage_ratio?: number;
     other_constraints?: string[];
 }
 export interface ModeApplicableConditions {