@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/extensions/capability-manifest.js

@@ -117,19 +117,19 @@ export class CapabilityRegistry {
             : Math.round(((covered.length - conflicting.length) / (covered.length + missing.length)) * 100);
         const recommendations = [];
         if (missing.length > 0) {
-            recommendations.push(`缺失 ${missing.length} 个能力，需要新增：${missing.slice(0, 5).join(", ")}${missing.length > 5 ? "..." : ""}`);
+            recommendations.push(`Missing ${missing.length} capabilities, need to add: ${missing.slice(0, 5).join(", ")}${missing.length > 5 ? "..." : ""}`);
         }
         if (conflicting.length > 0) {
-            recommendations.push(`检测到 ${conflicting.length} 个能力参数差异过大，需要重写配置`);
+            recommendations.push(`Detected ${conflicting.length} capabilities with large parameter differences, need to rewrite configuration`);
         }
         if (feasibility_score >= 80) {
-            recommendations.push("迁移可行性高，可直接复用大部分能力");
+            recommendations.push("Migration feasibility is high, most capabilities can be reused directly");
         }
         else if (feasibility_score >= 50) {
-            recommendations.push("迁移可行性中等，需要补充或重写部分能力");
+            recommendations.push("Migration feasibility is medium, need to supplement or rewrite some capabilities");
         }
         else {
-            recommendations.push("迁移可行性低，建议基于 target 行业模板重新生成方案");
+            recommendations.push("Migration feasibility is low, recommend regenerating the plan based on the target industry template");
         }
         return {
             feasibility_score,
@@ -207,7 +207,7 @@ export class CapabilityRegistry {
         this.registerCard({
             capability_id: "permission.index_create",
             display_name: "Permission Index Create",
-            description: "创建角色权限索引，支持 merchant/customer/arbiter 等多角色权限分配",
+            description: "Create role permission index, supports multi-role permission assignment such as merchant/customer/arbiter",
             object_type: "permission", module: "handler", category: "trust",
             industry_agnostic: "high",
             config_template: {
@@ -229,21 +229,37 @@ export class CapabilityRegistry {
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "low", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Index proliferation without naming convention makes permission audits harder"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Role-based governance foundation for all other objects"],
+            },
         });
         this.registerCard({
             capability_id: "permission.role_assign",
             display_name: "Permission Role Assign",
-            description: "为对象（Machine/Service/Allocation）分配角色权限索引",
+            description: "Assign role permission index to objects (Machine/Service/Allocation)",
             object_type: "permission", module: "handler", category: "trust",
             industry_agnostic: "high",
             config_template: { target_object: "<obj>", role: "<role_name>" },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["permission.index_create"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Mis-assigned role grants unintended operational authority"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Binds governance roles to concrete objects"],
+            },
         });
         this.registerCard({
             capability_id: "guard.validate_buy",
             display_name: "Guard Validate Buy",
-            description: "下单验证：检查买家资格、订单参数、库存等条件",
+            description: "Order validation: check buyer eligibility, order parameters, inventory and other conditions",
             object_type: "guard", module: "handler", category: "validation",
             industry_agnostic: "medium",
             config_template: { host: "service", templates: [] },
@@ -254,11 +270,19 @@ export class CapabilityRegistry {
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["permission.index_create"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Over-strict buy validation blocks legitimate orders; over-loose validation admits fraud"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "high",
+                benefits: ["Automated purchase gating without manual review"],
+            },
         });
         this.registerCard({
             capability_id: "guard.validate_wip_hash",
             display_name: "Guard Validate WIP Hash",
-            description: "验证 WIP（Work-In-Progress）哈希，用于数字交付物的里程碑验证",
+            description: "Validate WIP (Work-In-Progress) hash, used for milestone validation of digital deliverables",
             object_type: "guard", module: "handler", category: "evidence",
             industry_agnostic: "low",
             config_template: { host: "machine", templates: ["tpl_validate_wip_hash"] },
@@ -268,20 +292,28 @@ export class CapabilityRegistry {
             observed_in_industries: {}, success_count: 0, failure_count: 0,
             known_failure_modes: ["milestone mode requires WIP hash evidence — without WIP, allocation cannot advance"],
             depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "high", compliance_risk: "low",
+                known_risks: ["Wrong hash algorithm or field mapping stalls milestone release"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["Tamper-proof delivery evidence for digital deliverables"],
+            },
         });
         this.registerCard({
             capability_id: "machine.node_topology",
             display_name: "Machine Node Topology",
-            description: "工作流节点拓扑：定义订单从创建到完成的状态机",
+            description: "Workflow node topology: define the state machine from order creation to completion",
             object_type: "machine", module: "templates", category: "workflow",
             industry_agnostic: "low",
             config_template: {
                 nodes: [
                     { name: "paid", role: "Entry: order created and paid" },
                     { name: "delivering", role: "Service delivery in progress" },
+                    { name: "delivered", role: "Deliverable available for review" },
                     { name: "completed", role: "Service completed, funds released" },
-                    { name: "refunded", role: "Customer refund path" },
-                    { name: "cancelled", role: "Pre-delivery cancellation" },
+                    { name: "cancelled", role: "Pre-delivery cancellation — triggers refund Allocator" },
                 ],
             },
             industry_overrides: {
@@ -291,7 +323,7 @@ export class CapabilityRegistry {
                         { name: "delivered", role: "Goods delivered" },
                         { name: "confirmed", role: "Buyer confirms receipt" },
                         { name: "completed", role: "Funds released" },
-                        { name: "refunded", role: "Return & refund" },
+                        { name: "returned", role: "Buyer ships goods back — triggers refund Allocator (R-M1-11)" },
                         { name: "cancelled", role: "Pre-ship cancellation" },
                     ] },
                 freelance: { nodes: [
@@ -301,27 +333,42 @@ export class CapabilityRegistry {
                         { name: "accepted", role: "Buyer accepts deliverable" },
                         { name: "completed", role: "Funds released" },
                         { name: "revision", role: "Revision requested" },
-                        { name: "refunded", role: "Refund path" },
-                        { name: "cancelled", role: "Pre-start cancellation" },
+                        { name: "cancelled", role: "Pre-start cancellation — triggers refund Allocator (R-M1-11)" },
                     ] },
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["permission.index_create"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "high", compliance_risk: "low",
+                known_risks: ["Dead-end nodes or missing refund paths trap order funds"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "medium", efficiency_gain: "high",
+                benefits: ["Declarative workflow from order creation to completion"],
+            },
         });
         this.registerCard({
             capability_id: "treasury.owner_receive",
             display_name: "Treasury Owner Receive",
-            description: "资金托管：支持 owner_receive 模式，资金直接进入对象 owner 钱包",
+            description: "Fund escrow: supports owner_receive mode, funds go directly into the object owner wallet",
             object_type: "treasury", module: "handler", category: "fund_flow",
             industry_agnostic: "high",
             config_template: { owner_receive: true },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "medium", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Direct fund custody — misconfigured owner diverts all proceeds"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["Automated escrow and owner settlement"],
+            },
         });
         this.registerCard({
             capability_id: "allocation.distribute",
             display_name: "Multi-tier Allocation Distribution",
-            description: "多级分账：支持按比例 / 按顺序 / 按条件分配资金给多个接收者",
+            description: "Multi-tier allocation: supports distributing funds to multiple recipients by ratio / by order / by condition",
             object_type: "allocation", module: "handler", category: "fund_flow",
             industry_agnostic: "medium",
             config_template: {
@@ -335,11 +382,19 @@ export class CapabilityRegistry {
             observed_in_industries: {}, success_count: 0, failure_count: 0,
             known_failure_modes: ["milestone mode requires WIP hash evidence — without WIP, allocation cannot advance"],
             depends_on_capabilities: ["treasury.owner_receive", "guard.validate_buy"], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "low", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Wrong split ratios or recipient addresses misdirect settlement funds"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "high",
+                benefits: ["Multi-recipient settlement without manual transfers"],
+            },
         });
         this.registerCard({
             capability_id: "allocation.distribute_milestone",
             display_name: "Milestone-based Allocation",
-            description: "里程碑分账：按交付里程碑释放资金，每里程碑需 WIP 哈希验证",
+            description: "Milestone allocation: release funds by delivery milestones, each milestone requires WIP hash validation",
             object_type: "allocation", module: "handler", category: "fund_flow",
             industry_agnostic: "low",
             config_template: {
@@ -351,11 +406,19 @@ export class CapabilityRegistry {
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["allocation.distribute", "guard.validate_wip_hash"], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Stuck milestone gates lock buyer funds until evidence is supplied"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Evidence-gated release protects both buyer and provider"],
+            },
         });
         this.registerCard({
             capability_id: "service.publish",
             display_name: "Service Publish",
-            description: "发布 Service 对象到链上，绑定 Machine/Guard/Permission/Allocation 等依赖",
+            description: "Publish Service object on-chain, bind Machine/Guard/Permission/Allocation and other dependencies",
             object_type: "service", module: "handler", category: "lifecycle",
             industry_agnostic: "high",
             config_template: {
@@ -364,7 +427,7 @@ export class CapabilityRegistry {
                 permission: "<permission_name>",
                 order_allocators: ["<allocation_name>"],
                 compensation_fund_balance: 0,
-                compensation_fund_add_hint: "Post-publish: call service.compensation_fund_add with Coin<T>. Recommend 5× max single-order amount.",
+                compensation_fund_add_hint: "Post-publish: call service.compensation_fund_add with Coin<T>. Recommend 3-10× max single-order amount (industry-specific: subscription 3×, retail 5×, rental 10×).",
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [
@@ -372,96 +435,220 @@ export class CapabilityRegistry {
                 "allocation.distribute", "treasury.owner_receive",
             ],
             version: "v1",
+            risk_profile: {
+                funds_risk: "medium", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "medium",
+                known_risks: ["Publish freezes machine binding and order_allocators permanently (E_ALREADY_PUBLISHED)"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["On-chain discoverability and order intake"],
+            },
         });
         this.registerCard({
             capability_id: "progress.advance",
             display_name: "Progress Advance",
-            description: "订单履约进度推进：基于 Machine 节点拓扑前进到下一状态",
+            description: "Order fulfillment progress advance: advance to next state based on Machine node topology",
             object_type: "progress", module: "handler", category: "workflow",
             industry_agnostic: "medium",
             config_template: { parent: "<machine_name>" },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["machine.node_topology"], version: "v1",
+            risk_profile: {
+                funds_risk: "medium", trust_risk: "low", delivery_risk: "high", compliance_risk: "low",
+                known_risks: ["Forward without authorized executor permanently stalls the order"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "high",
+                benefits: ["Deterministic order state progression"],
+            },
         });
         this.registerCard({
             capability_id: "arb.vote_weighted",
             display_name: "Arbitration Vote Weighted",
-            description: "guard-based 加权投票仲裁：按 Guard 权重投票决定仲裁结果",
+            description: "guard-based weighted voting arbitration: vote by Guard weight to determine arbitration result",
             object_type: "arb", module: "handler", category: "trust",
             industry_agnostic: "medium",
             config_template: { guard: "<guard_name>", voting_rule: "guard_weighted" },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "high", delivery_risk: "medium", compliance_risk: "medium",
+                known_risks: ["Shared permission with Service destroys dispute independence (E_ARBITRATION_PERMISSION_CONFLICT)"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "high", efficiency_gain: "low",
+                benefits: ["Neutral third-party dispute resolution"],
+            },
         });
         this.registerCard({
             capability_id: "reward.claim_guard",
             display_name: "Reward Claim Guard",
-            description: "奖励申领：通过 Guard 验证申领条件（如好评、复购）后释放奖励",
+            description: "Reward claim: release reward after validating claim conditions (such as positive review, repurchase) via Guard",
             object_type: "reward", module: "handler", category: "fund_flow",
             industry_agnostic: "medium",
             config_template: { claim_guard: "<guard_name>", max_guard_count: 1 },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+            risk_profile: {
+                funds_risk: "medium", trust_risk: "low", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Loose claim conditions drain the reward pool"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["Incentivizes reviews and repurchase"],
+            },
         });
         this.registerCard({
             capability_id: "contact.im_create",
             display_name: "Contact IM Create",
-            description: "创建 IM 联系对象：买卖双方通过 Messenger 通信",
+            description: "Create IM contact object: buyer and seller communicate via Messenger",
             object_type: "contact", module: "handler", category: "communication",
             industry_agnostic: "high",
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "low", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Unattended IM channel degrades dispute response time"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["Direct buyer-seller encrypted communication"],
+            },
         });
         this.registerCard({
             capability_id: "demand.matching",
             display_name: "Demand Matching",
-            description: "需求匹配：根据用户需求匹配对应 Service",
+            description: "Demand matching: match corresponding Service based on user demand",
             object_type: "demand", module: "handler", category: "query",
             industry_agnostic: "high",
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["service.publish"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "low", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Poor matching signals bury quality services"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "low", efficiency_gain: "medium",
+                benefits: ["Demand-side discovery channel"],
+            },
         });
         this.registerCard({
             capability_id: "repository.write_validate",
             display_name: "Repository Write Validate",
-            description: "知识库写入验证：通过 Guard 验证写入权限和数据格式",
+            description: "Knowledge base write validation: validate write permissions and data format via Guard",
             object_type: "repository", module: "handler", category: "validation",
             industry_agnostic: "high",
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "low", compliance_risk: "medium",
+                known_risks: ["Unvalidated writes pollute the knowledge base with unverifiable claims"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Guard-gated attestation for off-chain data"],
+            },
         });
         this.registerCard({
             capability_id: "proof.evidence_anchor",
             display_name: "Proof Evidence Anchor",
-            description: "凭证上链：将交付凭证（哈希）锚定到链上 Progress 节点",
+            description: "Evidence on-chain: anchor delivery evidence (hash) to on-chain Progress node",
             object_type: "proof", module: "handler", category: "evidence",
             industry_agnostic: "medium",
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["progress.advance"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Anchored evidence is immutable — wrong hash cannot be corrected"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Immutable WTS evidence for Messenger confirmations"],
+            },
         });
         this.registerCard({
             capability_id: "personal.profile_manage",
             display_name: "Personal Profile Manage",
-            description: "个人档案管理：用户身份/偏好/历史记录管理",
+            description: "Personal profile management: user identity/preference/history management",
             object_type: "personal", module: "handler", category: "data_model",
             industry_agnostic: "high",
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "low", delivery_risk: "low", compliance_risk: "medium",
+                known_risks: ["Profile data may fall under privacy regulation (PII)"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "low", efficiency_gain: "low",
+                benefits: ["Portable user identity across services"],
+            },
         });
         this.registerCard({
             capability_id: "payment.settle",
             display_name: "Payment Settle",
-            description: "支付结算：与 Allocation 协作完成资金结算",
+            description: "Payment settlement: complete fund settlement in collaboration with Allocation",
             object_type: "payment", module: "handler", category: "fund_flow",
             industry_agnostic: "high",
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["allocation.distribute", "treasury.owner_receive"], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "low", delivery_risk: "low", compliance_risk: "medium",
+                known_risks: ["Settlement errors are irreversible once funds transfer"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "low", efficiency_gain: "high",
+                benefits: ["Atomic settlement in collaboration with Allocation"],
+            },
+        });
+        this.registerCard({
+            capability_id: "guard.validate_withdraw",
+            display_name: "Guard Validate Withdraw",
+            description: "Withdrawal validation: gate fund release from Allocation escrow on delivery confirmation",
+            object_type: "guard", module: "handler", category: "validation",
+            industry_agnostic: "medium",
+            config_template: { host: "service", templates: ["tpl_withdraw_on_completed"] },
+            industry_overrides: {
+                retail_d2c: { templates: ["tpl_withdraw_on_completed"] },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0,
+            known_failure_modes: ["Withdraw gate on wrong node lets merchant pull funds before delivery"],
+            depends_on_capabilities: ["allocation.distribute"], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Mis-gated withdrawal releases escrowed funds prematurely"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "high",
+                benefits: ["Contract-enforced delivery gate replaces platform custody"],
+            },
+        });
+        this.registerCard({
+            capability_id: "guard.validate_refund",
+            display_name: "Guard Validate Refund",
+            description: "Refund validation: gate buyer refund on cancellation or return conditions",
+            object_type: "guard", module: "handler", category: "validation",
+            industry_agnostic: "medium",
+            config_template: { host: "service", templates: ["tpl_refund_on_cancelled"] },
+            industry_overrides: {
+                retail_d2c: { templates: ["tpl_refund_on_cancelled"] },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0,
+            known_failure_modes: ["Missing refund path on pre-delivery cancellation traps buyer funds"],
+            depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+            risk_profile: {
+                funds_risk: "medium", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Over-broad refund conditions enable buyer abuse"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "high",
+                benefits: ["Trustless buyer refund without merchant approval"],
+            },
         });
     }
     registerBuiltinEdges() {

package/dist/extensions/constraint-registry.js

@@ -1,8 +1,8 @@
 const BUILTIN_CONSTRAINTS = [
     {
         constraint_id: "require_arbitration",
-        display_name: "必须仲裁",
-        description: "模式必须包含仲裁能力（arb.*），用于争议解决",
+        display_name: "Require Arbitration",
+        description: "Mode must include arbitration capability (arb.*) for dispute resolution",
         rule: { type: "capability_required", capability_id: "arb.vote_weighted" },
         severity: "hard",
         on_violation: "block",
@@ -10,8 +10,8 @@ const BUILTIN_CONSTRAINTS = [
     },
     {
         constraint_id: "require_compensation_fund",
-        display_name: "必须补偿基金",
-        description: "模式必须包含资金托管能力（treasury.*），用于补偿基金",
+        display_name: "Require Compensation Fund",
+        description: "Mode must include fund escrow capability (treasury.*) for compensation fund",
         rule: { type: "capability_required", capability_id: "treasury.owner_receive" },
         severity: "hard",
         on_violation: "block",
@@ -19,8 +19,8 @@ const BUILTIN_CONSTRAINTS = [
     },
     {
         constraint_id: "require_wip_evidence",
-        display_name: "必须 WIP 证据",
-        description: "模式必须包含 WIP 证据能力（guard.validate_wip_hash），用于数字交付验证",
+        display_name: "Require WIP Evidence",
+        description: "Mode must include WIP evidence capability (guard.validate_wip_hash) for digital delivery validation",
         rule: { type: "capability_required", capability_id: "guard.validate_wip_hash" },
         severity: "soft",
         on_violation: "warn",
@@ -28,8 +28,8 @@ const BUILTIN_CONSTRAINTS = [
     },
     {
         constraint_id: "max_single_transaction_limit",
-        display_name: "单笔交易限额",
-        description: "单笔交易金额不超过 10000 WOW（默认值，可被模式覆盖）",
+        display_name: "Single Transaction Limit",
+        description: "Single transaction amount must not exceed 10000 WOW (default value, can be overridden by mode)",
         rule: { type: "numeric_limit", field: "max_single_transaction", max: 10000 },
         severity: "soft",
         on_violation: "warn",
@@ -92,7 +92,9 @@ export class ConstraintRegistry {
         return this.constraints.delete(constraint_id);
     }
     checkConstraints(mode, _capabilityRegistry, extraConstraints) {
-        const allConstraints = [...this.constraints.values()];
+        const disabled = new Set(mode.disabled_builtin_constraints ?? []);
+        const allConstraints = [...this.constraints.values()]
+            .filter(c => !(c.scope === "builtin" && disabled.has(c.constraint_id)));
         if (extraConstraints) {
             for (const c of extraConstraints) {
                 if (!allConstraints.some(existing => existing.constraint_id === c.constraint_id)) {
@@ -117,10 +119,10 @@ export class ConstraintRegistry {
                     return {
                         constraint_id: constraint.constraint_id,
                         display_name: constraint.display_name,
-                        violation: `缺少必需能力: ${rule.capability_id}`,
+                        violation: `Missing required capability: ${rule.capability_id}`,
                         severity: constraint.severity,
                         action: constraint.on_violation,
-                        recommendation: `在 capabilities_used 中添加 "${rule.capability_id}"`,
+                        recommendation: `Add "${rule.capability_id}" to capabilities_used`,
                     };
                 }
                 return null;
@@ -130,10 +132,10 @@ export class ConstraintRegistry {
                     return {
                         constraint_id: constraint.constraint_id,
                         display_name: constraint.display_name,
-                        violation: `包含禁止能力: ${rule.capability_id}`,
+                        violation: `Contains forbidden capability: ${rule.capability_id}`,
                         severity: constraint.severity,
                         action: constraint.on_violation,
-                        recommendation: `从 capabilities_used 中移除 "${rule.capability_id}"`,
+                        recommendation: `Remove "${rule.capability_id}" from capabilities_used`,
                     };
                 }
                 return null;
@@ -146,20 +148,20 @@ export class ConstraintRegistry {
                     return {
                         constraint_id: constraint.constraint_id,
                         display_name: constraint.display_name,
-                        violation: `${rule.field}=${fieldValue} 超过上限 ${rule.max}`,
+                        violation: `${rule.field}=${fieldValue} exceeds upper limit ${rule.max}`,
                         severity: constraint.severity,
                         action: constraint.on_violation,
-                        recommendation: `将 ${rule.field} 降低到 ${rule.max} 以下`,
+                        recommendation: `Reduce ${rule.field} below ${rule.max}`,
                     };
                 }
                 if (rule.min !== undefined && fieldValue < rule.min) {
                     return {
                         constraint_id: constraint.constraint_id,
                         display_name: constraint.display_name,
-                        violation: `${rule.field}=${fieldValue} 低于下限 ${rule.min}`,
+                        violation: `${rule.field}=${fieldValue} below lower limit ${rule.min}`,
                         severity: constraint.severity,
                         action: constraint.on_violation,
-                        recommendation: `将 ${rule.field} 提高到 ${rule.min} 以上`,
+                        recommendation: `Increase ${rule.field} above ${rule.min}`,
                     };
                 }
                 return null;
@@ -168,10 +170,10 @@ export class ConstraintRegistry {
                 return {
                     constraint_id: constraint.constraint_id,
                     display_name: constraint.display_name,
-                    violation: `自然语言条件待 AI 评估: "${rule.condition}"`,
+                    violation: `Natural language condition pending AI evaluation: "${rule.condition}"`,
                     severity: constraint.severity,
                     action: constraint.on_violation,
-                    recommendation: `请 AI 评估该条件是否满足，并更新模式配置`,
+                    recommendation: `Please have AI evaluate whether this condition is satisfied, and update the mode configuration`,
                 };
             }
             default: