@wowok/agent-mcp 2.3.16 → 2.4.1

package/dist/knowledge/reward-templates.js

@@ -1,95 +1,95 @@
 export const REWARD_TEMPLATES = [
     {
         type: "first_order",
-        name: "首单奖励",
-        description: "新客户首次下单后获得奖励，降低尝试门槛，促进转化。",
-        guardCondition: "Guard 验证: order_address 的 holder == 当前 claim 者, 且 order.service == 本 Service, 且 order 是该 holder 的第一笔订单 (通过 Repository 查询历史)",
+        name: "First-order reward",
+        description: "New customers receive a reward after their first order, lowering the trial barrier and boosting conversion.",
+        guardCondition: "Guard verifies: order_address.holder == current claimer, and order.service == this Service, and order is the first order for this holder (via Repository history query)",
         amountRange: { min: "0.1WOW", max: "5WOW" },
         allocationStrategy: "fixed",
         parameters: [
-            { name: "amount", type: "string", description: "奖励金额 (如 '1WOW')", required: true },
-            { name: "budget", type: "string", description: "总预算 (如 '100WOW')", required: true },
+            { name: "amount", type: "string", description: "Reward amount (e.g., '1WOW')", required: true },
+            { name: "budget", type: "string", description: "Total budget (e.g., '100WOW')", required: true },
         ],
-        example: "新客户下单购买摄影服务，首单获得 1 WOW 返还，降低首次尝试成本。",
+        example: "A new customer orders a photography service and receives 1 WOW cashback on the first order, lowering the first trial cost.",
         relevantGuardOps: ["query", "repository_read"],
     },
     {
         type: "referral",
-        name: "裂变推荐奖励",
-        description: "老客户推荐新客户下单后，双方各获得奖励，形成口碑传播飞轮。",
-        guardCondition: "Guard 验证: 推荐人地址在 Repository 评价表中标记为 'referred_by', 且被推荐人的订单已完成 (Progress 到达终态)",
+        name: "Referral viral reward",
+        description: "Existing customers refer new customers to place an order; both parties receive a reward, creating a word-of-mouth flywheel.",
+        guardCondition: "Guard verifies: referrer address is marked as 'referred_by' in the Repository review table, and the referee's order is completed (Progress reached terminal state)",
         amountRange: { min: "0.5WOW", max: "10WOW" },
         allocationStrategy: "proportional",
         parameters: [
-            { name: "referrer_reward", type: "string", description: "推荐人奖励 (如 '2WOW')", required: true },
-            { name: "referee_reward", type: "string", description: "被推荐人奖励 (如 '1WOW')", required: true },
-            { name: "max_referrals", type: "number", description: "每人最多推荐数 (如 10)", required: false },
+            { name: "referrer_reward", type: "string", description: "Referrer reward (e.g., '2WOW')", required: true },
+            { name: "referee_reward", type: "string", description: "Referee reward (e.g., '1WOW')", required: true },
+            { name: "max_referrals", type: "number", description: "Max referrals per person (e.g., 10)", required: false },
         ],
-        example: "Alice 推荐 Bob 购买服务，Bob 完成首单后 Alice 得 2 WOW、Bob 得 1 WOW。",
+        example: "Alice refers Bob to purchase a service; after Bob completes the first order, Alice gets 2 WOW and Bob gets 1 WOW.",
         relevantGuardOps: ["query", "repository_read", "repository_write"],
     },
     {
         type: "loyalty",
-        name: "忠诚度阶梯奖励",
-        description: "客户累计消费达到阶梯后解锁更高奖励，提升复购率和客单价。",
-        guardCondition: "Guard 验证: 通过 Repository 查询该地址历史订单数 >= N, N 为当前阶梯阈值",
+        name: "Loyalty tiered reward",
+        description: "Customers unlock higher rewards after reaching cumulative spending tiers, improving repeat rate and average order value.",
+        guardCondition: "Guard verifies: via Repository query, the address's historical order count >= N, where N is the current tier threshold",
         amountRange: { min: "1WOW", max: "50WOW" },
         allocationStrategy: "tiered",
         parameters: [
-            { name: "tier1_orders", type: "number", description: "第一阶梯订单数 (如 3)", required: true },
-            { name: "tier1_reward", type: "string", description: "第一阶梯奖励 (如 '1WOW')", required: true },
-            { name: "tier2_orders", type: "number", description: "第二阶梯订单数 (如 10)", required: true },
-            { name: "tier2_reward", type: "string", description: "第二阶梯奖励 (如 '5WOW')", required: true },
-            { name: "tier3_orders", type: "number", description: "第三阶梯订单数 (如 30)", required: false },
-            { name: "tier3_reward", type: "string", description: "第三阶梯奖励 (如 '20WOW')", required: false },
+            { name: "tier1_orders", type: "number", description: "Tier 1 order count (e.g., 3)", required: true },
+            { name: "tier1_reward", type: "string", description: "Tier 1 reward (e.g., '1WOW')", required: true },
+            { name: "tier2_orders", type: "number", description: "Tier 2 order count (e.g., 10)", required: true },
+            { name: "tier2_reward", type: "string", description: "Tier 2 reward (e.g., '5WOW')", required: true },
+            { name: "tier3_orders", type: "number", description: "Tier 3 order count (e.g., 30)", required: false },
+            { name: "tier3_reward", type: "string", description: "Tier 3 reward (e.g., '20WOW')", required: false },
         ],
-        example: "客户累计 3 单得 1 WOW，10 单得 5 WOW，30 单得 20 WOW，激励持续消费。",
+        example: "A customer with 3 cumulative orders gets 1 WOW, 10 orders gets 5 WOW, 30 orders gets 20 WOW, incentivizing continued spending.",
         relevantGuardOps: ["query", "repository_read"],
     },
     {
         type: "flash_sale",
-        name: "限时闪购",
-        description: "在限定时间窗口内提供折扣或额外奖励，制造紧迫感促进即时转化。",
-        guardCondition: "Guard 验证: 当前区块时间在 [start_time, end_time] 范围内 (Guard 时间条件)",
+        name: "Limited-time flash sale",
+        description: "Provides discounts or extra rewards within a limited time window, creating urgency to drive instant conversion.",
+        guardCondition: "Guard verifies: current block time is within [start_time, end_time] range (Guard time condition)",
         amountRange: { min: "0.1WOW", max: "20WOW" },
         allocationStrategy: "fixed",
         parameters: [
-            { name: "start_time", type: "string", description: "开始时间 (Unix timestamp)", required: true },
-            { name: "end_time", type: "string", description: "结束时间 (Unix timestamp)", required: true },
-            { name: "amount", type: "string", description: "闪购奖励金额", required: true },
-            { name: "max_claims", type: "number", description: "最大领取数 (如 100)", required: true },
+            { name: "start_time", type: "string", description: "Start time (Unix timestamp)", required: true },
+            { name: "end_time", type: "string", description: "End time (Unix timestamp)", required: true },
+            { name: "amount", type: "string", description: "Flash sale reward amount", required: true },
+            { name: "max_claims", type: "number", description: "Max claims (e.g., 100)", required: true },
         ],
-        example: "周末限时 48 小时闪购，下单客户额外获得 2 WOW 返还，前 100 名有效。",
+        example: "Weekend 48-hour flash sale: ordering customers get an extra 2 WOW cashback, valid for the first 100.",
         relevantGuardOps: ["query", "time_condition"],
     },
     {
         type: "cashback",
-        name: "消费返现",
-        description: "客户完成订单后按消费比例返现，提升复购意愿。",
-        guardCondition: "Guard 验证: order 已到达终态 (Progress completed), 且 order.service == 本 Service",
+        name: "Spending cashback",
+        description: "Customers receive cashback proportional to spending after completing an order, improving repeat purchase willingness.",
+        guardCondition: "Guard verifies: order has reached terminal state (Progress completed), and order.service == this Service",
         amountRange: { min: "0.1WOW", max: "100WOW" },
         allocationStrategy: "proportional",
         parameters: [
-            { name: "cashback_rate", type: "string", description: "返现比例 (如 '0.1' = 10%)", required: true },
-            { name: "max_cashback", type: "string", description: "单笔最大返现 (如 '10WOW')", required: true },
-            { name: "budget", type: "string", description: "总预算 (如 '500WOW')", required: true },
+            { name: "cashback_rate", type: "string", description: "Cashback rate (e.g., '0.1' = 10%)", required: true },
+            { name: "max_cashback", type: "string", description: "Max cashback per order (e.g., '10WOW')", required: true },
+            { name: "budget", type: "string", description: "Total budget (e.g., '500WOW')", required: true },
         ],
-        example: "客户消费 10 WOW，按 10% 比例返现 1 WOW，下次消费可抵扣。",
+        example: "A customer spends 10 WOW, gets 10% cashback = 1 WOW, which can be deducted on the next purchase.",
         relevantGuardOps: ["query"],
     },
     {
         type: "milestone",
-        name: "里程碑奖励",
-        description: "Service 达到特定里程碑（如 100 单、1000 客户）时给早期支持者发放额外奖励。",
-        guardCondition: "Guard 验证: Repository 查询 Service 累计订单数 >= milestone_threshold, 且 claim 者为早期客户 (order_index < milestone)",
+        name: "Milestone reward",
+        description: "When a Service reaches a specific milestone (e.g., 100 orders, 1000 customers), early supporters receive extra rewards.",
+        guardCondition: "Guard verifies: Repository query shows Service cumulative order count >= milestone_threshold, and claimer is an early customer (order_index < milestone)",
         amountRange: { min: "1WOW", max: "100WOW" },
         allocationStrategy: "fixed",
         parameters: [
-            { name: "milestone", type: "number", description: "里程碑值 (如 100)", required: true },
-            { name: "reward_per_user", type: "string", description: "每人奖励 (如 '5WOW')", required: true },
-            { name: "max_recipients", type: "number", description: "最大受益人数 (如 50)", required: true },
+            { name: "milestone", type: "number", description: "Milestone value (e.g., 100)", required: true },
+            { name: "reward_per_user", type: "string", description: "Reward per person (e.g., '5WOW')", required: true },
+            { name: "max_recipients", type: "number", description: "Max beneficiaries (e.g., 50)", required: true },
         ],
-        example: "Service 达到 100 单里程碑，前 50 名客户每人获得 5 WOW 额外奖励。",
+        example: "Service reaches the 100-order milestone; the first 50 customers each receive 5 WOW extra reward.",
         relevantGuardOps: ["query", "repository_read"],
     },
 ];
@@ -102,22 +102,22 @@ export function listRewardTemplates() {
 }
 export function suggestRewardTemplate(intent) {
     const lower = intent.toLowerCase();
-    if (lower.includes("首单") || lower.includes("new") || lower.includes("first")) {
+    if (lower.includes("first order") || lower.includes("new") || lower.includes("first")) {
         return getRewardTemplate("first_order");
     }
-    if (lower.includes("推荐") || lower.includes("裂变") || lower.includes("referral")) {
+    if (lower.includes("referral") || lower.includes("viral") || lower.includes("referral")) {
         return getRewardTemplate("referral");
     }
-    if (lower.includes("复购") || lower.includes("忠诚") || lower.includes("loyalty")) {
+    if (lower.includes("repeat") || lower.includes("loyalty") || lower.includes("loyalty")) {
         return getRewardTemplate("loyalty");
     }
-    if (lower.includes("限时") || lower.includes("闪购") || lower.includes("flash")) {
+    if (lower.includes("limited-time") || lower.includes("flash") || lower.includes("flash")) {
         return getRewardTemplate("flash_sale");
     }
-    if (lower.includes("返现") || lower.includes("cashback")) {
+    if (lower.includes("cashback") || lower.includes("cashback")) {
         return getRewardTemplate("cashback");
     }
-    if (lower.includes("里程碑") || lower.includes("milestone")) {
+    if (lower.includes("milestone") || lower.includes("milestone")) {
         return getRewardTemplate("milestone");
     }
     return undefined;

package/dist/knowledge/safety-rules.js

@@ -146,10 +146,71 @@ export const CONFIRMATION_RULES = [
         bypass_on_explicit_intent: [
             "use default account",
             "default account is fine",
-            "用默认账户",
-            "用默认账户即可",
+            "use the default account",
+            "default account works fine",
         ],
     },
+    {
+        id: "guard_create_immutable",
+        when: (ot, data, _env) => {
+            if (ot === "guard")
+                return true;
+            return false;
+        },
+        level: "irreversible",
+        preview: (ot, data, env) => {
+            const table = data?.table ?? [];
+            const root = data?.root;
+            const rely = data?.rely;
+            const rootType = typeof root === 'object' && root !== null && 'type' in root
+                ? root.type
+                : typeof root === 'object' && root !== null && 'type' in root && root.type === 'file'
+                    ? 'file'
+                    : 'unknown';
+            const immutable_fields = ['table', 'root'];
+            if (rely)
+                immutable_fields.push('rely');
+            return {
+                level: "irreversible",
+                operation: ot,
+                object: data?.namedNew?.name,
+                network: env?.network,
+                account: env?.account ?? "",
+                immutable_after: immutable_fields,
+                irreversible: true,
+                warnings: [
+                    ...collectDefaultWarnings(env, data),
+                    `Guard is CREATE-only and immutable — cannot be edited or deleted after creation`,
+                    `Table entries: ${table.length} (max 256)`,
+                    `Root node type: ${rootType} (must return Bool)`,
+                    ...(rely ? [`Rely dependencies: ${rely.guards?.length ?? 0} (max 4, AND/OR logic)`] : []),
+                    `To modify later: export via guard2file → edit → CREATE new → rebind`,
+                ],
+            };
+        },
+        bypass_on_explicit_intent: [],
+    },
+    {
+        id: "guard_gen_passport_test",
+        when: (ot, _data, _env) => {
+            if (ot === "gen_passport")
+                return true;
+            return false;
+        },
+        level: "standard",
+        preview: (ot, data, env) => ({
+            level: "standard",
+            operation: ot,
+            object: data?.guard,
+            network: env?.network,
+            account: env?.account ?? "",
+            warnings: [
+                ...collectDefaultWarnings(env, data),
+                "gen_passport will consume gas for static testing",
+            ],
+        }),
+        bypass_on_explicit_intent: ["test guard", "testing guard", "gen passport", "generate passport"],
+    },
 ];
 function extractAmount(data) {
     if (!data)

package/dist/knowledge/tool-constraints.js

@@ -26,10 +26,16 @@ export const TOOL_CONSTRAINTS = [
         constraints: [
             {
                 field: "node.nodes",
-                description: "Machine must have at least one node",
+                description: "Machine must have at least one node when published",
                 severity: "error",
-                check: (d) => Array.isArray(d?.node?.nodes) && d.node.nodes.length > 0,
-                message: () => "Machine has no nodes. A workflow template requires at least one node.",
+                check: (d) => {
+                    if (typeof d?.object === "string")
+                        return true;
+                    if (!d?.publish)
+                        return true;
+                    return Array.isArray(d?.node?.nodes) && d.node.nodes.length > 0;
+                },
+                message: () => "Publishing a Machine without nodes — a workflow template requires at least one node. Consider adding nodes before publish, or publish later after adding nodes.",
             },
         ],
     },
@@ -57,11 +63,11 @@ export const TOOL_CONSTRAINTS = [
         operation_type: "order",
         constraints: [
             {
-                field: "service",
-                description: "Order must reference a service",
+                field: "object",
+                description: "Order requires an existing Order object reference",
                 severity: "error",
-                check: (d) => !!d?.service,
-                message: () => "Order requires a 'service' field pointing to the service being ordered.",
+                check: (d) => !!d?.object,
+                message: () => "Order requires 'object' field (Order object ID or name).",
             },
         ],
     },
@@ -122,11 +128,11 @@ export const TOOL_CONSTRAINTS = [
         operation_type: "progress",
         constraints: [
             {
-                field: "parent",
-                description: "Progress must reference a parent machine",
+                field: "object",
+                description: "Progress requires an existing Progress object reference",
                 severity: "error",
-                check: (d) => !!d?.parent,
-                message: () => "Progress requires a 'parent' field pointing to the Machine.",
+                check: (d) => !!d?.object,
+                message: () => "Progress requires 'object' field (Progress object ID or name).",
             },
         ],
     },

package/dist/knowledge/trust-metrics.js

@@ -1,9 +1,9 @@
 export const TRUST_METRICS_VERSION = 1;
 const TRUST_LEVELS = [
-    { min: 75, level: "trusted", label: "高信任" },
-    { min: 50, level: "moderate", label: "中等信任" },
-    { min: 25, level: "caution", label: "需注意" },
-    { min: 0, level: "high_risk", label: "高风险" },
+    { min: 75, level: "trusted", label: "High trust" },
+    { min: 50, level: "moderate", label: "Moderate trust" },
+    { min: 25, level: "caution", label: "Needs attention" },
+    { min: 0, level: "high_risk", label: "High risk" },
 ];
 export function computeServiceTrustScore(metrics) {
     const breakdown = [];
@@ -11,49 +11,49 @@ export function computeServiceTrustScore(metrics) {
     const arbScore = computeArbitrationDimension(metrics);
     breakdown.push(arbScore);
     if (arbScore.score < arbScore.maxScore * 0.3) {
-        warnings.push("仲裁信任分较低，建议检查仲裁记录");
+        warnings.push("Arbitration trust score is low; recommend checking arbitration records");
     }
     const reviewScore = computeReviewDimension(metrics);
     breakdown.push(reviewScore);
     if (reviewScore.score < reviewScore.maxScore * 0.3 && metrics.reviewStats) {
-        warnings.push(`好评率较低 (${metrics.reviewStats.likes}/${metrics.reviewStats.totalReviews})`);
+        warnings.push(`Low like rate (${metrics.reviewStats.likes}/${metrics.reviewStats.totalReviews})`);
     }
     const fulfillmentScore = computeFulfillmentDimension(metrics);
     breakdown.push(fulfillmentScore);
     if (metrics.completedRate !== undefined && metrics.completedRate < 0.7) {
-        warnings.push(`完成率仅 ${Math.round(metrics.completedRate * 100)}%`);
+        warnings.push(`Completion rate only ${Math.round(metrics.completedRate * 100)}%`);
     }
     const fundScore = computeFundDimension(metrics);
     breakdown.push(fundScore);
     if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
-        warnings.push("无赔偿金，客户权益保障不足");
+        warnings.push("No compensation fund; insufficient protection of customer rights");
     }
     const transparencyScore = computeTransparencyDimension(metrics);
     breakdown.push(transparencyScore);
     const totalScore = breakdown.reduce((sum, d) => sum + d.score, 0);
     const level = TRUST_LEVELS.find((l) => totalScore >= l.min)?.level ?? "high_risk";
-    const label = TRUST_LEVELS.find((l) => totalScore >= l.min)?.label ?? "高风险";
+    const label = TRUST_LEVELS.find((l) => totalScore >= l.min)?.label ?? "High risk";
     const summary = buildSummary(totalScore, label, metrics, breakdown);
     return { score: totalScore, level, breakdown, summary, warnings };
 }
 function computeArbitrationDimension(metrics) {
     const maxScore = 30;
     if (metrics.arbitrationScore === undefined) {
-        return { name: "arbitration", score: maxScore * 0.5, maxScore, description: "仲裁信任分（无数据，默认中等）", humanReadable: "仲裁记录: 无数据" };
+        return { name: "arbitration", score: maxScore * 0.5, maxScore, description: "Arbitration trust score (no data, default moderate)", humanReadable: "Arbitration record: no data" };
     }
     const score = Math.round((metrics.arbitrationScore / 100) * maxScore);
     return {
         name: "arbitration",
         score,
         maxScore,
-        description: `仲裁信任分 ${metrics.arbitrationScore}/100`,
-        humanReadable: `仲裁信任: ${metrics.arbitrationScore}/100${metrics.arbitrationCases !== undefined ? ` (${metrics.arbitrationCases} 案件)` : ""}`,
+        description: `Arbitration trust score ${metrics.arbitrationScore}/100`,
+        humanReadable: `Arbitration trust: ${metrics.arbitrationScore}/100${metrics.arbitrationCases !== undefined ? ` (${metrics.arbitrationCases} cases)` : ""}`,
     };
 }
 function computeReviewDimension(metrics) {
     const maxScore = 25;
     if (!metrics.reviewStats || metrics.reviewStats.totalReviews === 0) {
-        return { name: "reviews", score: maxScore * 0.5, maxScore, description: "评价声誉（无评价数据）", humanReadable: "评价: 无数据" };
+        return { name: "reviews", score: maxScore * 0.5, maxScore, description: "Review reputation (no review data)", humanReadable: "Reviews: no data" };
     }
     const { likes, dislikes, verifiedReviews, totalReviews } = metrics.reviewStats;
     const likeRate = likes / Math.max(1, totalReviews);
@@ -63,14 +63,14 @@ function computeReviewDimension(metrics) {
         name: "reviews",
         score: Math.min(maxScore, score),
         maxScore,
-        description: `好评率 ${Math.round(likeRate * 100)}% (${totalReviews} 条评价, ${verifiedReviews} 条带凭证)`,
-        humanReadable: `好评率 ${Math.round(likeRate * 100)}% (${totalReviews} 评价)`,
+        description: `Like rate ${Math.round(likeRate * 100)}% (${totalReviews} reviews, ${verifiedReviews} verified)`,
+        humanReadable: `Like rate ${Math.round(likeRate * 100)}% (${totalReviews} reviews)`,
     };
 }
 function computeFulfillmentDimension(metrics) {
     const maxScore = 20;
     if (metrics.orderCount === undefined) {
-        return { name: "fulfillment", score: maxScore * 0.5, maxScore, description: "履约记录（无订单数据）", humanReadable: "履约: 无数据" };
+        return { name: "fulfillment", score: maxScore * 0.5, maxScore, description: "Fulfillment record (no order data)", humanReadable: "Fulfillment: no data" };
     }
     let score = 0;
     const orderScore = Math.min(10, Math.floor(metrics.orderCount / 5));
@@ -85,14 +85,14 @@ function computeFulfillmentDimension(metrics) {
         name: "fulfillment",
         score: Math.min(maxScore, score),
         maxScore,
-        description: `已完成 ${metrics.orderCount} 单, 完成率 ${metrics.completedRate !== undefined ? Math.round(metrics.completedRate * 100) + "%" : "未知"}`,
-        humanReadable: `履约: ${metrics.orderCount} 单${metrics.avgCompletionTime !== undefined ? `, 平均 ${metrics.avgCompletionTime}h` : ""}`,
+        description: `Completed ${metrics.orderCount} orders, completion rate ${metrics.completedRate !== undefined ? Math.round(metrics.completedRate * 100) + "%" : "unknown"}`,
+        humanReadable: `Fulfillment: ${metrics.orderCount} orders${metrics.avgCompletionTime !== undefined ? `, avg ${metrics.avgCompletionTime}h` : ""}`,
     };
 }
 function computeFundDimension(metrics) {
     const maxScore = 15;
     if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
-        return { name: "fund_safety", score: 0, maxScore, description: "无赔偿金", humanReadable: "赔偿金: 无" };
+        return { name: "fund_safety", score: 0, maxScore, description: "No compensation fund", humanReadable: "Compensation fund: none" };
     }
     const threshold = 1000000000000n;
     const ratio = Number(metrics.compensationFundBalance * 100n / threshold) / 100;
@@ -101,8 +101,8 @@ function computeFundDimension(metrics) {
         name: "fund_safety",
         score,
         maxScore,
-        description: `赔偿金 ${metrics.compensationFundBalance} 最小单位`,
-        humanReadable: `赔偿金: 充足`,
+        description: `Compensation fund ${metrics.compensationFundBalance} smallest unit`,
+        humanReadable: `Compensation fund: sufficient`,
     };
 }
 function computeTransparencyDimension(metrics) {
@@ -118,12 +118,12 @@ function computeTransparencyDimension(metrics) {
         name: "transparency",
         score: Math.min(maxScore, score),
         maxScore,
-        description: `链上事件 ${metrics.hasPublishedEvents ? "✓" : "✗"}, Machine ${metrics.hasMachineBound ? "✓" : "✗"}, Guard ${metrics.hasBuyGuard ? "✓" : "✗"}`,
-        humanReadable: `透明度: ${["事件", "Machine", "Guard"].filter((_, i) => [metrics.hasPublishedEvents, metrics.hasMachineBound, metrics.hasBuyGuard][i]).join("+") || "无"}`,
+        description: `On-chain events ${metrics.hasPublishedEvents ? "✓" : "✗"}, Machine ${metrics.hasMachineBound ? "✓" : "✗"}, Guard ${metrics.hasBuyGuard ? "✓" : "✗"}`,
+        humanReadable: `Transparency: ${["Events", "Machine", "Guard"].filter((_, i) => [metrics.hasPublishedEvents, metrics.hasMachineBound, metrics.hasBuyGuard][i]).join("+") || "none"}`,
     };
 }
 function buildSummary(score, label, metrics, breakdown) {
-    const parts = [`信任分 ${score}/100 (${label})`];
+    const parts = [`Trust score ${score}/100 (${label})`];
     for (const d of breakdown) {
         parts.push(`${d.humanReadable}`);
     }
@@ -132,7 +132,7 @@ function buildSummary(score, label, metrics, breakdown) {
 export function quickTrustCheck(metrics) {
     const result = computeServiceTrustScore(metrics);
     if (result.score < 25) {
-        return { pass: false, reason: `信任分 ${result.score}/100，高风险: ${result.warnings.join("; ")}` };
+        return { pass: false, reason: `Trust score ${result.score}/100, high risk: ${result.warnings.join("; ")}` };
     }
-    return { pass: true, reason: `信任分 ${result.score}/100 (${result.level})` };
+    return { pass: true, reason: `Trust score ${result.score}/100 (${result.level})` };
 }

package/dist/safety/confirm-gate.d.ts

@@ -1,14 +1,16 @@
 import type { CallEnv } from "../schema/call/base.js";
-import { type ConfirmationRule, type OperationPreview } from "../knowledge/safety-rules.js";
+import { type ConfirmLevel, type OperationPreview } from "../knowledge/safety-rules.js";
 export declare function isConfirmGateEnabled(): boolean;
+export type FailMode = "open" | "closed";
 export type ConfirmResult = {
     pass: true;
 } | {
     pass: false;
-    level: ConfirmationRule["level"];
+    level: ConfirmLevel;
     preview: OperationPreview;
     rule_id: string;
 };
+export declare function getFailMode(level: ConfirmLevel): FailMode;
 export declare function confirmGate(operation_type: string, data: any, env: any, userIntentPhrases?: string[]): ConfirmResult;
 export declare function isExplicitlyConfirmed(env: CallEnv & {
     confirmed?: boolean;

package/dist/safety/confirm-gate.js

@@ -3,24 +3,64 @@ import { isEnabled as isRuntimeEnabled } from "../config/index.js";
 export function isConfirmGateEnabled() {
     return isRuntimeEnabled("confirm_gate");
 }
+const internalErrorCounts = {};
+function logInternalError(context, error) {
+    const key = context;
+    internalErrorCounts[key] = (internalErrorCounts[key] ?? 0) + 1;
+    const count = internalErrorCounts[key];
+    console.warn(`[ConfirmGate] internal_error context="${context}" count=${count} error=${error instanceof Error ? error.message : String(error)}`);
+}
+export function getFailMode(level) {
+    switch (level) {
+        case "irreversible":
+        case "publish":
+        case "amount":
+            return "closed";
+        case "standard":
+        case "none":
+        default:
+            return "open";
+    }
+}
+function buildInternalErrorResult() {
+    return {
+        pass: false,
+        level: "irreversible",
+        preview: {
+            level: "irreversible",
+            operation: "unknown",
+            irreversible: true,
+        },
+        rule_id: "internal_error",
+    };
+}
 export function confirmGate(operation_type, data, env, userIntentPhrases) {
     if (!isConfirmGateEnabled())
         return { pass: true };
     if (env?.confirmed === true)
         return { pass: true };
     let matched;
+    let ruleSearchError = null;
     try {
         matched = CONFIRMATION_RULES.find((r) => {
             try {
                 return r.when(operation_type, data, env);
             }
-            catch {
+            catch (e) {
+                logInternalError(`rule_when:${r.id}`, e);
+                if (getFailMode(r.level) === "closed") {
+                    throw e;
+                }
                 return false;
             }
         });
     }
-    catch {
-        return { pass: true };
+    catch (e) {
+        ruleSearchError = e;
+    }
+    if (ruleSearchError) {
+        logInternalError("rule_search", ruleSearchError);
+        return buildInternalErrorResult();
     }
     if (!matched)
         return { pass: true };
@@ -34,7 +74,11 @@ export function confirmGate(operation_type, data, env, userIntentPhrases) {
     try {
         preview = matched.preview(operation_type, data, env);
     }
-    catch {
+    catch (e) {
+        logInternalError(`rule_preview:${matched.id}`, e);
+        if (getFailMode(matched.level) === "closed") {
+            return buildInternalErrorResult();
+        }
         return { pass: true };
     }
     return { pass: false, level: matched.level, preview, rule_id: matched.id };