@wowok/agent-mcp 2.6.1 → 2.6.3

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: {
@@ -233,7 +233,7 @@ export class CapabilityRegistry {
         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>" },
@@ -243,7 +243,7 @@ export class CapabilityRegistry {
         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: [] },
@@ -258,7 +258,7 @@ export class CapabilityRegistry {
         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"] },
@@ -272,7 +272,7 @@ export class CapabilityRegistry {
         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: {
@@ -311,7 +311,7 @@ export class CapabilityRegistry {
         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 },
@@ -321,7 +321,7 @@ export class CapabilityRegistry {
         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: {
@@ -339,7 +339,7 @@ export class CapabilityRegistry {
         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: {
@@ -355,7 +355,7 @@ export class CapabilityRegistry {
         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 +364,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: [
@@ -376,7 +376,7 @@ export class CapabilityRegistry {
         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>" },
@@ -386,7 +386,7 @@ export class CapabilityRegistry {
         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" },
@@ -396,7 +396,7 @@ export class CapabilityRegistry {
         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 },
@@ -406,7 +406,7 @@ export class CapabilityRegistry {
         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: {},
@@ -416,7 +416,7 @@ export class CapabilityRegistry {
         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: {},
@@ -426,7 +426,7 @@ export class CapabilityRegistry {
         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: {},
@@ -436,7 +436,7 @@ export class CapabilityRegistry {
         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: {},
@@ -446,7 +446,7 @@ export class CapabilityRegistry {
         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: {},
@@ -456,7 +456,7 @@ export class CapabilityRegistry {
         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: {},

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",
@@ -117,10 +117,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 +130,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 +146,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 +168,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:

package/dist/extensions/metric-registry.js

@@ -6,8 +6,8 @@ const LEVEL_WEIGHT = {
 const BUILTIN_RISK_METRICS = [
     {
         metric_id: "funds_risk",
-        display_name: "资金风险",
-        description: "直接操作资金 / 影响资金流向 / 无资金风险",
+        display_name: "Funds Risk",
+        description: "Directly operates funds / affects fund flow / no fund risk",
         type: "risk",
         scale: "level",
         weight: 1.0,
@@ -15,8 +15,8 @@ const BUILTIN_RISK_METRICS = [
     },
     {
         metric_id: "trust_risk",
-        display_name: "信任风险",
-        description: "影响信任机制的程度",
+        display_name: "Trust Risk",
+        description: "Degree of impact on trust mechanism",
         type: "risk",
         scale: "level",
         weight: 1.0,
@@ -24,8 +24,8 @@ const BUILTIN_RISK_METRICS = [
     },
     {
         metric_id: "delivery_risk",
-        display_name: "履约风险",
-        description: "影响订单履约的程度",
+        display_name: "Delivery Risk",
+        description: "Degree of impact on order fulfillment",
         type: "risk",
         scale: "level",
         weight: 1.0,
@@ -33,8 +33,8 @@ const BUILTIN_RISK_METRICS = [
     },
     {
         metric_id: "compliance_risk",
-        display_name: "合规风险",
-        description: "涉及监管的程度",
+        display_name: "Compliance Risk",
+        description: "Degree of regulatory involvement",
         type: "risk",
         scale: "level",
         weight: 1.0,
@@ -44,8 +44,8 @@ const BUILTIN_RISK_METRICS = [
 const BUILTIN_BENEFIT_METRICS = [
     {
         metric_id: "automation_level",
-        display_name: "自动化等级",
-        description: "全自动 / 半自动 / 手动",
+        display_name: "Automation Level",
+        description: "Fully automated / semi-automated / manual",
         type: "benefit",
         scale: "level",
         weight: 1.0,
@@ -53,8 +53,8 @@ const BUILTIN_BENEFIT_METRICS = [
     },
     {
         metric_id: "trust_boost",
-        display_name: "信任提升",
-        description: "对信任机制的增强程度",
+        display_name: "Trust Boost",
+        description: "Degree of enhancement to trust mechanism",
         type: "benefit",
         scale: "level",
         weight: 1.0,
@@ -62,8 +62,8 @@ const BUILTIN_BENEFIT_METRICS = [
     },
     {
         metric_id: "efficiency_gain",
-        display_name: "效率提升",
-        description: "对效率的提升程度",
+        display_name: "Efficiency Gain",
+        description: "Degree of efficiency improvement",
         type: "benefit",
         scale: "level",
         weight: 1.0,

package/dist/extensions/mode-evaluator.js

@@ -70,34 +70,34 @@ export class ModeEvaluator {
         feasibility_score = Math.max(0, Math.min(100, Math.round(feasibility_score)));
         const recommendations = [];
         if (benefit_delta > 0) {
-            recommendations.push(`收益提升 ${benefit_delta.toFixed(1)} 分，迁移有正向价值`);
+            recommendations.push(`Benefit increased by ${benefit_delta.toFixed(1)} points, migration has positive value`);
         }
         else if (benefit_delta < 0) {
-            recommendations.push(`收益下降 ${Math.abs(benefit_delta).toFixed(1)} 分，需评估迁移必要性`);
+            recommendations.push(`Benefit decreased by ${Math.abs(benefit_delta).toFixed(1)} points, need to evaluate migration necessity`);
         }
         if (risk_delta > 10) {
-            recommendations.push(`风险增加 ${risk_delta.toFixed(1)} 分，建议加强风险控制措施`);
+            recommendations.push(`Risk increased by ${risk_delta.toFixed(1)} points, recommend strengthening risk control measures`);
         }
         else if (risk_delta < -10) {
-            recommendations.push(`风险降低 ${Math.abs(risk_delta).toFixed(1)} 分，迁移有助于风险管控`);
+            recommendations.push(`Risk decreased by ${Math.abs(risk_delta).toFixed(1)} points, migration helps risk management`);
         }
         if (added_capabilities.length > 0) {
-            recommendations.push(`新增 ${added_capabilities.length} 个能力，需要额外配置：${added_capabilities.slice(0, 3).join(", ")}`);
+            recommendations.push(`Added ${added_capabilities.length} capabilities, need extra configuration: ${added_capabilities.slice(0, 3).join(", ")}`);
         }
         if (removed_capabilities.length > 0) {
-            recommendations.push(`移除 ${removed_capabilities.length} 个能力，相关功能将不可用`);
+            recommendations.push(`Removed ${removed_capabilities.length} capabilities, related features will be unavailable`);
         }
         if (conflicting_capabilities.length > 0) {
-            recommendations.push(`检测到 ${conflicting_capabilities.length} 个能力冲突，必须解决后才能迁移`);
+            recommendations.push(`Detected ${conflicting_capabilities.length} capability conflicts, must be resolved before migration`);
         }
         if (feasibility_score >= 70) {
-            recommendations.push("迁移可行性高，建议执行");
+            recommendations.push("Migration feasibility is high, recommend executing");
         }
         else if (feasibility_score >= 40) {
-            recommendations.push("迁移可行性中等，需谨慎评估");
+            recommendations.push("Migration feasibility is medium, need careful evaluation");
         }
         else {
-            recommendations.push("迁移可行性低，建议保持当前模式或寻找替代方案");
+            recommendations.push("Migration feasibility is low, recommend keeping the current mode or finding an alternative");
         }
         return {
             feasibility_score,
@@ -142,13 +142,13 @@ export class ModeEvaluator {
     generateRecommendations(mode, risk_score, benefit_score, capability_conflicts, violated_constraints, unmet_conditions) {
         const recs = [];
         if (capability_conflicts.length > 0) {
-            recs.push(`检测到 ${capability_conflicts.length} 个能力冲突，必须解决后才能应用模式`);
+            recs.push(`Detected ${capability_conflicts.length} capability conflicts, must be resolved before applying the mode`);
         }
         if (violated_constraints.length > 0) {
-            recs.push(`检测到 ${violated_constraints.length} 个硬约束违规，需要补充缺失的能力或调整模式配置`);
+            recs.push(`Detected ${violated_constraints.length} hard constraint violations, need to supplement missing capabilities or adjust mode configuration`);
         }
         if (unmet_conditions.length > 0) {
-            recs.push(`检测到 ${unmet_conditions.length} 个软约束未满足，建议调整以提升模式质量`);
+            recs.push(`Detected ${unmet_conditions.length} soft constraints not met, recommend adjusting to improve mode quality`);
         }
         const appetiteThresholds = {
             conservative: { max_risk: 30, min_benefit: 50 },
@@ -157,13 +157,13 @@ export class ModeEvaluator {
         };
         const threshold = appetiteThresholds[mode.risk_appetite];
         if (risk_score > threshold.max_risk) {
-            recs.push(`风险评分 ${risk_score} 超过 ${mode.risk_appetite} 模式阈值 ${threshold.max_risk}，建议降低风险或调整风险偏好`);
+            recs.push(`Risk score ${risk_score} exceeds ${mode.risk_appetite} mode threshold ${threshold.max_risk}, recommend reducing risk or adjusting risk appetite`);
         }
         if (benefit_score < threshold.min_benefit) {
-            recs.push(`收益评分 ${benefit_score} 低于 ${mode.risk_appetite} 模式阈值 ${threshold.min_benefit}，建议增加收益能力或调整风险偏好`);
+            recs.push(`Benefit score ${benefit_score} below ${mode.risk_appetite} mode threshold ${threshold.min_benefit}, recommend adding benefit capabilities or adjusting risk appetite`);
         }
         if (recs.length === 0) {
-            recs.push(`模式评估通过：风险 ${risk_score} / 收益 ${benefit_score} / 风险-收益比 ${(benefit_score / Math.max(risk_score, 1)).toFixed(2)}`);
+            recs.push(`Mode evaluation passed: risk ${risk_score} / benefit ${benefit_score} / risk-benefit ratio ${(benefit_score / Math.max(risk_score, 1)).toFixed(2)}`);
         }
         return recs;
     }