@wowok/agent-mcp 2.3.18 → 2.4.1

package/dist/knowledge/guard-translation.js

@@ -1,20 +1,59 @@
 export const SEMANTIC_TO_SCHEMA_RULES = [
     {
-        id: "A01_identity_single",
-        pattern_name: "身份检查（单地址）",
-        semantic_intent: "只有地址 X 能执行此操作",
-        match_keywords: ["只有", "允许", "授权", "身份", "指定地址", "签名者"],
+        id: "P02",
+        pattern_name: "Query published object + system context",
+        data_source_combination: "Type1 + Type4",
+        semantic_intent: "Query published on-chain object fields and compare with system context",
+        match_keywords: ["paused", "published", "service status", "machine status", "paused", "published"],
+        schema_elements: {
+            root_type: "logic_equal / logic_and",
+            table_entries: [
+                { value_type: "Address", b_submission: false, purpose: "Published object address constant (Type1)" },
+            ],
+            context_nodes: [
+                { context_type: "Signer", purpose: "Optional: identity validation" },
+            ],
+            tree_structure: "logic_equal(query(<instruction>, object: { identifier: 0 }), identifier[1] or context(Signer))",
+        },
+        constraints: [
+            "The object_type of table[0] must match the target object type of the query instruction",
+            "The query return type must be compatible with the comparison object",
+            "The object must be published (published=true) to ensure fields are immutable",
+        ],
+        example: {
+            root: {
+                type: "logic_equal",
+                nodes: [
+                    { type: "query", query: "service.paused", object: { identifier: 0 }, parameters: [] },
+                    { type: "identifier", identifier: 1 },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: false, value_type: "Address", value: "0xSERVICE", name: "Service object address" },
+                { identifier: 1, b_submission: false, value_type: "Bool", value: false, name: "Expected paused state (false=not paused)" },
+            ],
+        },
+    },
+    {
+        id: "P03",
+        pattern_name: "Identity check (single address)",
+        data_source_combination: "Type4 + Type1 constant",
+        semantic_intent: "Only a specific address can perform the operation",
+        match_keywords: ["only", "allow", "authorize", "identity", "specified address", "signer"],
         schema_elements: {
             root_type: "logic_equal",
             table_entries: [
-                { value_type: "Address", b_submission: false, purpose: "授权地址常量" },
+                { value_type: "Address", b_submission: false, purpose: "Authorized address constant (Type1 constant)" },
+            ],
+            context_nodes: [
+                { context_type: "Signer", purpose: "Current transaction signer (Type4)" },
             ],
             tree_structure: "logic_equal(context(Signer), identifier[0])",
         },
         constraints: [
-            "root 必须 logic_equal（返回 Bool）",
-            "table[0] 必须 Address 类型，b_submission=false",
-            "context(Signer) 返回当前交易签名者地址",
+            "root must be logic_equal (returns Bool)",
+            "table[0] must be Address type, b_submission=false",
+            "context(Signer) returns the current transaction signer address",
         ],
         example: {
             root: {
@@ -25,26 +64,30 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
                 ],
             },
             table: [
-                { identifier: 0, b_submission: false, value_type: "Address", value: "0xabc...", name: "授权操作者地址" },
+                { identifier: 0, b_submission: false, value_type: "Address", value: "0xabc...", name: "Authorized operator address" },
             ],
         },
     },
     {
-        id: "A02_identity_allowlist",
-        pattern_name: "身份检查（白名单）",
-        semantic_intent: "白名单中的地址可以执行此操作",
-        match_keywords: ["白名单", "多个地址", "列表", "允许列表", "名单"],
+        id: "P04",
+        pattern_name: "Identity check (whitelist)",
+        data_source_combination: "Type4 + Type1 constant (VecAddress)",
+        semantic_intent: "Addresses in the whitelist can perform this operation",
+        match_keywords: ["whitelist", "multiple addresses", "list", "allowlist", "roster"],
         schema_elements: {
             root_type: "vec_contains_address",
             table_entries: [
-                { value_type: "VecAddress", b_submission: false, purpose: "授权地址列表" },
+                { value_type: "VecAddress", b_submission: false, purpose: "Authorized address list (Type1 constant)" },
+            ],
+            context_nodes: [
+                { context_type: "Signer", purpose: "Signer being looked up (Type4)" },
             ],
             tree_structure: "vec_contains_address(identifier[0], context(Signer))",
         },
         constraints: [
-            "root vec_contains_address 返回 Bool",
-            "table[0] 必须 VecAddress 类型",
-            "context(Signer) 作为被查找的元素",
+            "root vec_contains_address returns Bool",
+            "table[0] must be VecAddress type",
+            "context(Signer) is the element being looked up",
         ],
         example: {
             root: {
@@ -55,31 +98,36 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
                 ],
             },
             table: [
-                { identifier: 0, b_submission: false, value_type: "VecAddress", value: ["0xabc...", "0xdef..."], name: "授权地址白名单" },
+                { identifier: 0, b_submission: false, value_type: "VecAddress", value: ["0xabc...", "0xdef..."], name: "Authorized address whitelist" },
             ],
         },
     },
     {
-        id: "A03_time_lock",
-        pattern_name: "时间锁",
-        semantic_intent: "等待 N 毫秒后才能执行此操作",
-        match_keywords: ["等待", "时间", "锁定", "延迟", "小时", "天", "毫秒"],
+        id: "P05",
+        pattern_name: "Time lock",
+        data_source_combination: "Type2 + Type4 + Type1 constant",
+        semantic_intent: "This operation can only be executed after waiting N milliseconds",
+        match_keywords: ["wait", "time", "lock", "delay", "hours", "days", "milliseconds"],
         schema_elements: {
             root_type: "logic_as_u256_greater_or_equal",
             table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "目标对象地址（如 Order）" },
-                { value_type: "U64", b_submission: false, purpose: "锁定时长（毫秒，测试用 1000）" },
+                { value_type: "Address", b_submission: true, purpose: "Source object address (e.g. Order, Type3) or constant (Type1)" },
+                { value_type: "U64", b_submission: false, purpose: "Lock duration (in milliseconds, 1000 for tests, Type1 constant)" },
             ],
             query_nodes: [
-                { query_name: "progress.session.time", object_type: "Progress", convert_witness: 100 },
+                { query_name: "progress.current_time", object_type: "Progress", convert_witness: 100 },
+            ],
+            context_nodes: [
+                { context_type: "Clock", purpose: "Current on-chain timestamp (Type4)" },
             ],
-            tree_structure: "logic_as_u256_greater_or_equal(context(Clock), calc_number_add(query(progress.time, witness=100), identifier[1]))",
+            tree_structure: "logic_as_u256_greater_or_equal(context(Clock), calc_number_add(query(1272: progress.current_time, witness=100, identifier[0]), identifier[1]))",
         },
         constraints: [
-            "时间单位为毫秒，测试时用 1000ms，生产环境再调整",
-            "convert_witness=100 (TypeOrderProgress) 从 Order 转换到 Progress",
-            "table[0] 的 object_type 必须匹配 witness source type (Order)",
-            "calc_number_add 返回 U256，context(Clock) 返回 U64，自动宽展",
+            "Time unit is milliseconds; use 1000ms for tests and adjust in production",
+            "convert_witness=100 (TypeOrderProgress) converts from Order to Progress",
+            "The object_type of table[0] must match the witness source type (Order)",
+            "calc_number_add returns U256, context(Clock) returns U64, auto-widened",
+            "Key: use progress.current_time(1272) rather than progress.session.forward.time(1271); the latter querying an unforwarded session returns 0 and disables the time lock",
         ],
         example: {
             root: {
@@ -91,7 +139,7 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
                         nodes: [
                             {
                                 type: "query",
-                                query: "progress.session.time",
+                                query: "progress.current_time",
                                 object: { identifier: 0, convert_witness: 100 },
                                 parameters: [],
                             },
@@ -101,32 +149,34 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
                 ],
             },
             table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "目标 Order 地址", object_type: "Order" },
-                { identifier: 1, b_submission: false, value_type: "U64", value: 1000, name: "锁定时长（毫秒）" },
+                { identifier: 0, b_submission: true, value_type: "Address", name: "Target Order address", object_type: "Order" },
+                { identifier: 1, b_submission: false, value_type: "U64", value: 1000, name: "Lock duration (milliseconds)" },
             ],
         },
     },
     {
-        id: "A04_progress_state",
-        pattern_name: "进度状态检查",
-        semantic_intent: "订单进度达到指定节点才能执行此操作",
-        match_keywords: ["进度", "节点", "状态", "完成", "到达", "当前节点"],
+        id: "P06",
+        pattern_name: "Progress state check",
+        data_source_combination: "Type2 + Type1 constant",
+        semantic_intent: "The order progress must reach the specified node before this operation can be executed",
+        match_keywords: ["progress", "node", "state", "completed", "reach", "current node"],
         schema_elements: {
             root_type: "logic_equal",
             table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "目标 Order 地址" },
-                { value_type: "String", b_submission: false, purpose: "期望的节点名称" },
+                { value_type: "Address", b_submission: true, purpose: "Source Order address (Type3, witness source)" },
+                { value_type: "String", b_submission: false, purpose: "Expected node name (Type1 constant)" },
             ],
             query_nodes: [
-                { query_name: "progress.current_node_name", object_type: "Progress", convert_witness: 100 },
+                { query_name: "progress.current", object_type: "Progress", convert_witness: 100 },
             ],
-            tree_structure: "logic_equal(query(progress.node, witness=100, identifier[0]), identifier[1])",
+            tree_structure: "logic_equal(query(1253: progress.current, witness=100, identifier[0]), identifier[1])",
         },
         constraints: [
-            "query 返回 String，identifier[1] 必须 String 类型",
-            "logic_equal 比较 String 时大小写敏感",
-            "如需大小写不敏感，使用 logic_string_nocase_equal",
-            "convert_witness=100 (TypeOrderProgress) 从 Order 转换",
+            "query returns String; identifier[1] must be String type",
+            "logic_equal comparison on String is case-sensitive",
+            "For case-insensitive comparison, use logic_string_nocase_equal",
+            "convert_witness=100 (TypeOrderProgress) converts from Order",
+            "Type2 stacks on Type3: the source object Order is submitted (b_submission=true)",
         ],
         example: {
             root: {
@@ -134,7 +184,7 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
                 nodes: [
                     {
                         type: "query",
-                        query: "progress.current_node_name",
+                        query: "progress.current",
                         object: { identifier: 0, convert_witness: 100 },
                         parameters: [],
                     },
@@ -142,31 +192,33 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
                 ],
             },
             table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "目标 Order 地址", object_type: "Order" },
-                { identifier: 1, b_submission: false, value_type: "String", value: "Completed", name: "期望的进度节点名" },
+                { identifier: 0, b_submission: true, value_type: "Address", name: "Target Order address", object_type: "Order" },
+                { identifier: 1, b_submission: false, value_type: "String", value: "Completed", name: "Expected progress node name" },
             ],
         },
     },
     {
-        id: "A05_one_time_claim",
-        pattern_name: "一次性领取检查",
-        semantic_intent: "用户只能领取一次奖励",
-        match_keywords: ["一次", "领取", "重复", "已领", "领取过"],
+        id: "P07",
+        pattern_name: "One-time claim check",
+        data_source_combination: "Type3 + Type1 constant",
+        semantic_intent: "Users can only claim the reward once",
+        match_keywords: ["once", "claim", "duplicate", "already claimed", "claimed before"],
         schema_elements: {
             root_type: "logic_equal",
             table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "Reward 对象地址" },
-                { value_type: "Address", b_submission: false, purpose: "领取者地址（从 context 派生）" },
+                { value_type: "Address", b_submission: true, purpose: "Reward object address (Type3, submitted)" },
+                { value_type: "U64", b_submission: false, purpose: "Expected historical claim count 0 (Type1 constant)" },
             ],
             query_nodes: [
                 { query_name: "reward.record.count", object_type: "Reward" },
             ],
-            tree_structure: "logic_equal(query_reward_record_count(identifier[0], identifier[1]), constant(0))",
+            tree_structure: "logic_equal(query_reward_record_count(object: { identifier: 0 }, recipient: context(Signer)), identifier[1])",
         },
         constraints: [
-            "query_reward_record_count 返回 U64",
-            "比较 count == 0 表示无历史记录（可领取）",
-            "identifier[1] 可用 context(Signer) 替代",
+            "query_reward_record_count returns U64",
+            "Comparing count == 0 means no history record (can claim)",
+            "recipient defaults to context(Signer) to ensure the claimer's identity is bound",
+            "Type3 submitted objects must have constraint rules (here the constraint is count==0 and recipient=Signer)",
         ],
         example: {
             root: {
@@ -175,31 +227,116 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
                     {
                         type: "query_reward_record_count",
                         object: { identifier: 0 },
-                        recipient: { type: "context", context: "Signer" },
                     },
                     { type: "identifier", identifier: 1 },
                 ],
             },
             table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "Reward 对象地址", object_type: "Reward" },
-                { identifier: 1, b_submission: false, value_type: "U64", value: 0, name: "期望的历史领取数（0）" },
+                { identifier: 0, b_submission: true, value_type: "Address", name: "Reward object address", object_type: "Reward" },
+                { identifier: 1, b_submission: false, value_type: "U64", value: 0, name: "Expected historical claim count (0)" },
             ],
         },
     },
     {
-        id: "A06_multi_condition_and",
-        pattern_name: "多条件组合（AND）",
-        semantic_intent: "多个条件必须同时满足",
-        match_keywords: ["并且", "同时", "都满足", "AND", "且", "还需要"],
+        id: "P08",
+        pattern_name: "Submitted object identity validation",
+        data_source_combination: "Type3 + Type4",
+        semantic_intent: "Verify that the owner of the submitted object matches the signer",
+        match_keywords: ["ownership", "belonging", "customer", "submitted object", "order.customer"],
         schema_elements: {
-            root_type: "logic_and",
+            root_type: "logic_equal",
+            table_entries: [
+                { value_type: "Address", b_submission: true, purpose: "Submitted Order address (Type3)" },
+            ],
+            context_nodes: [
+                { context_type: "Signer", purpose: "Current signer (Type4), compared with order.customer" },
+            ],
+            query_nodes: [
+                { query_name: "order.customer", object_type: "Order" },
+            ],
+            tree_structure: "logic_equal(query(1550: order.customer, object: { identifier: 0 }), context(Signer))",
+        },
+        constraints: [
+            "query returns Address, context(Signer) returns Address, types compatible",
+            "Type3 submitted object constraint: indirectly binds submitter identity via order.customer == Signer",
+            "Ensures callers cannot submit other users' Order addresses",
+        ],
+        example: {
+            root: {
+                type: "logic_equal",
+                nodes: [
+                    {
+                        type: "query",
+                        query: "order.customer",
+                        object: { identifier: 0 },
+                        parameters: [],
+                    },
+                    { type: "context", context: "Signer" },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: true, value_type: "Address", name: "User-submitted Order address", object_type: "Order" },
+            ],
+        },
+    },
+    {
+        id: "P09",
+        pattern_name: "Submitted object + witness derivation query",
+        data_source_combination: "Type3 + Type2 (source is Type3)",
+        semantic_intent: "User submits an Order and queries the Progress state via witness",
+        match_keywords: ["submit", "derive", "witness", "order to progress", "convert"],
+        schema_elements: {
+            root_type: "logic_equal / logic_and",
+            table_entries: [
+                { value_type: "Address", b_submission: true, purpose: "Submitted Order address (Type3, witness source)" },
+                { value_type: "String", b_submission: false, purpose: "Expected node name (Type1 constant)" },
+            ],
+            query_nodes: [
+                { query_name: "progress.current", object_type: "Progress", convert_witness: 100 },
+            ],
+            tree_structure: "logic_equal(query(1253: progress.current, object: { identifier: 0, convert_witness: 100 }), identifier[1])",
+        },
+        constraints: [
+            "Type2 stacks on Type3: the source object Order has b_submission=true",
+            "witness=100 (TypeOrderProgress) derives Progress from the submitted Order",
+            "query returns String; identifier[1] must be String type",
+            "Key: Type2 can stack on Type1 or Type3, depending on the source object's b_submission",
+        ],
+        example: {
+            root: {
+                type: "logic_equal",
+                nodes: [
+                    {
+                        type: "query",
+                        query: "progress.current",
+                        object: { identifier: 0, convert_witness: 100 },
+                        parameters: [],
+                    },
+                    { type: "identifier", identifier: 1 },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: true, value_type: "Address", name: "User-submitted Order address", object_type: "Order" },
+                { identifier: 1, b_submission: false, value_type: "String", value: "Inspecting", name: "Expected progress node name" },
+            ],
+        },
+    },
+    {
+        id: "P10",
+        pattern_name: "Multi-condition combination (AND/OR)",
+        data_source_combination: "Type1 + Type2 + Type3 + Type4 (combination)",
+        semantic_intent: "Multiple conditions must all be satisfied (AND) or any one is satisfied (OR)",
+        match_keywords: ["and", "simultaneously", "all satisfied", "AND", "and also", "also need", "or", "any", "OR", "or", "one of"],
+        schema_elements: {
+            root_type: "logic_and / logic_or",
             table_entries: [],
-            tree_structure: "logic_and([condition1, condition2, ...])",
+            tree_structure: "logic_and/logic_or([condition1, condition2, ...]) — each condition can be any combination of P03-P09",
         },
         constraints: [
-            "logic_and 所有子节点必须返回 Bool",
-            "子节点数量 2-8（MAX_MULTI_OPERANDS）",
-            "每个子条件可以是任何返回 Bool 的节点",
+            "All subnodes of logic_and/logic_or must return Bool",
+            "Subnode count 2-8 (MAX_MULTI_OPERANDS)",
+            "Each subcondition can be any node that returns Bool",
+            "Multi-condition combination is a container for other Patterns and does not stand alone",
         ],
         example: {
             root: {
@@ -212,252 +349,734 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
         },
     },
     {
-        id: "A07_multi_condition_or",
-        pattern_name: "多条件组合（OR）",
-        semantic_intent: "任一条件满足即可",
-        match_keywords: ["或者", "任一", "OR", "或", "之一"],
+        id: "P11",
+        pattern_name: "Entity registration check",
+        data_source_combination: "Type1 system address + Type3",
+        semantic_intent: "Verify that the user is registered in the entity registrar",
+        match_keywords: ["register", "entity", "EntityRegistrar", "member", "certify"],
         schema_elements: {
-            root_type: "logic_or",
-            table_entries: [],
-            tree_structure: "logic_or([condition1, condition2, ...])",
+            root_type: "logic_and",
+            table_entries: [
+                { value_type: "Address", b_submission: false, purpose: "EntityRegistrar system address 0xaab (Type1 system address)" },
+                { value_type: "Address", b_submission: true, purpose: "User address (Type3, submitted)" },
+            ],
+            query_nodes: [
+                { query_name: "entity.registrar.records", object_type: "EntityRegistrar" },
+            ],
+            tree_structure: "logic_and(query(1760: entity.registrar.records, object: { identifier: 0 }, parameters: [identifier[1]]), ...)",
         },
         constraints: [
-            "logic_or 所有子节点必须返回 Bool",
-            "子节点数量 2-8",
-            "等价于 rely.logic_or=true（如果使用 rely 组合）",
+            "EntityRegistrar address is fixed at 0xaab (system address)",
+            "EntityLinker address is fixed at 0xaaa",
+            "table[0] has is_system_address=true",
+            "query parameters must match the instruction definition",
         ],
         example: {
             root: {
-                type: "logic_or",
+                type: "logic_and",
+                nodes: [
+                    {
+                        type: "query",
+                        query: "entity.registrar.records",
+                        object: { identifier: 0 },
+                        parameters: [{ type: "identifier", identifier: 1 }],
+                    },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: false, value_type: "Address", value: "0xaab", name: "EntityRegistrar system address" },
+                { identifier: 1, b_submission: true, value_type: "Address", name: "User address (submitted)" },
+            ],
+        },
+    },
+    {
+        id: "P12",
+        pattern_name: "Dynamic voting weight",
+        data_source_combination: "Type3 + Type4 + Type1 constant",
+        semantic_intent: "Voting weight equals the reputation score (extracted from submitted data)",
+        match_keywords: ["weight", "vote", "reputation", "score", "voting", "weight"],
+        schema_elements: {
+            root_type: "logic_and",
+            table_entries: [
+                { value_type: "Address", b_submission: true, purpose: "Voter address (Type3)" },
+                { value_type: "U64", b_submission: true, purpose: "Voter weight (Type3, extracted by GuardIdentifier)" },
+            ],
+            context_nodes: [
+                { context_type: "Signer", purpose: "Validate voter identity (Type4)" },
+            ],
+            query_nodes: [
+                { query_name: "entity.registrar.records", object_type: "EntityRegistrar" },
+            ],
+            tree_structure: "logic_and(identity check: logic_equal(context(Signer), identifier[0]), weight comparison: GuardIdentifier extracts identifier[1])",
+        },
+        constraints: [
+            "The table entry referenced by GuardIdentifier must be numeric (U8-U256)",
+            "b_submission must be true (weight is submitted at runtime by the voter)",
+            "Non-numeric types cause E_GUARD_IDENTIFIER_NOT_NUMBER error",
+            "Weight value is cast to u32",
+            "voting_guard scene special constraint: GuardIdentifier numeric",
+        ],
+        example: {
+            root: {
+                type: "logic_and",
                 nodes: [
                     {},
                     {},
                 ],
             },
+            table: [
+                { identifier: 0, b_submission: true, value_type: "Address", name: "Voter address" },
+                { identifier: 1, b_submission: true, value_type: "U64", name: "Voter weight (extracted from reputation score)" },
+            ],
         },
     },
     {
-        id: "A08_dynamic_weight",
-        pattern_name: "动态投票权重",
-        semantic_intent: "投票权重等于用户声誉分（从提交数据提取）",
-        match_keywords: ["权重", "投票", "声誉", "分数", "voting", "weight"],
+        id: "P13",
+        pattern_name: "Repository data query",
+        data_source_combination: "Type1 + Type2",
+        semantic_intent: "Query Repository data and validate",
+        match_keywords: ["Repository", "storage", "data source", "weather", "external data", "oracle"],
         schema_elements: {
             root_type: "logic_and",
             table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "投票者地址" },
-                { value_type: "U64", b_submission: true, purpose: "投票者权重（GuardIdentifier 提取）" },
+                { value_type: "Address", b_submission: false, purpose: "Repository address (Type1 constant)" },
             ],
             query_nodes: [
-                { query_name: "entity.records.value", object_type: "EntityRegistrar" },
+                { query_name: "repository.data", object_type: "Repository" },
             ],
-            tree_structure: "logic_and(资格检查, GuardIdentifier 提取权重[1])",
+            tree_structure: "logic_and(query(1167: repository.data, object: { identifier: 0 }, parameters: [...]), [data validation condition])",
         },
         constraints: [
-            "GuardIdentifier 引用的 table 条目必须 numeric (U8-U256)",
-            "b_submission 必须 true（权重由 voter 运行时提交）",
-            "非 numeric 类型导致 E_GUARD_IDENTIFIER_NOT_NUMBER 错误",
-            "权重值 cast 为 u32",
+            "The quote_guard authentication of query 1167 always has empty impack_list during the verify phase",
+            "Repository queries with quote_guard fail with IMPACK_GUARD_NOT_FOUND in the gen_passport flow",
+            "Only passes when quote_guard==None",
+            "rep semantics: repository.data query does not depend on runtime submission, so rep=true",
         ],
         example: {
             root: {
                 type: "logic_and",
                 nodes: [
-                    {},
+                    {
+                        type: "query",
+                        query: "repository.data",
+                        object: { identifier: 0 },
+                        parameters: [{ type: "identifier", identifier: 1 }],
+                    },
                     {},
                 ],
             },
             table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "投票者地址" },
-                { identifier: 1, b_submission: true, value_type: "U64", name: "投票者权重（从声誉分提取）" },
+                { identifier: 0, b_submission: false, value_type: "Address", value: "0xREPO", name: "Repository address" },
+            ],
+        },
+    },
+    {
+        id: "P14",
+        pattern_name: "Pure dependency combination",
+        data_source_combination: "None (rely only)",
+        semantic_intent: "Does not compute itself; fully depends on the results of other Guards",
+        match_keywords: ["depend", "combine", "reuse", "rely", "delegate"],
+        schema_elements: {
+            root_type: "logic_and / logic_or (minimized tautology)",
+            table_entries: [],
+            tree_structure: "root: minimized (e.g. context(Clock) >= 0, tautology) + rely: { guards: [...], logic_or: false }",
+        },
+        constraints: [
+            "Depended-on Guards must have rep=true (repository.data query does not depend on runtime submission)",
+            "rely.guards supports at most 4 (MAX_DEPENDED_COUNT)",
+            "Self-reference is forbidden",
+            "AND logic: all dependencies must pass; OR logic: any one passing is sufficient",
+        ],
+        example: {
+            root: {
+                type: "logic_as_u256_greater_or_equal",
+                nodes: [
+                    { type: "context", context: "Clock" },
+                    { type: "identifier", identifier: 0 },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: false, value_type: "U64", value: 0, name: "Tautology baseline value (0)" },
+            ],
+            rely: { guards: ["guard_a", "guard_b"], logic_or: false },
+        },
+    },
+    {
+        id: "P15",
+        pattern_name: "Submission data retention pattern (retained_submission)",
+        data_source_combination: "Type3 + Type4 (submission + system context binding)",
+        semantic_intent: "Guard accepts runtime-submitted data but ensures it is trustworthy via Signer binding and type checking",
+        match_keywords: ["submit", "retain", "retained", "submission", "bind signer", "submission check"],
+        schema_elements: {
+            root_type: "logic_and",
+            table_entries: [
+                { value_type: "Address", b_submission: true, purpose: "Submitted object address (Type3, requires Signer binding)" },
+                { value_type: "U256", b_submission: true, purpose: "Submitted numeric value (e.g. amount, weight, requires range check)" },
+            ],
+            context_nodes: [
+                { context_type: "Signer", purpose: "Validate submitter identity to ensure submission data ownership" },
+            ],
+            tree_structure: "logic_and(logic_equal(context(Signer), query(..., signer_field)), logic_as_u256_greater_or_equal(identifier[1], identifier[2]))",
+        },
+        constraints: [
+            "The name of each b_submission=true entry must be a complete natural-language description (not a technical identifier)",
+            "The submitted object address should be bound to Signer (query the signer/owner field of the submitted object to validate ownership)",
+            "Submitted numeric values should have range checks (>= min, <= max)",
+            "Total table size must not exceed 40000 bytes",
+            "Total submission bytes must not exceed 256",
+        ],
+        example: {
+            root: {
+                type: "logic_and",
+                nodes: [
+                    {
+                        type: "logic_equal",
+                        nodes: [
+                            { type: "context", context: "Signer" },
+                            {
+                                type: "query",
+                                query: 1237,
+                                object: { identifier: 0 },
+                                parameters: [],
+                            },
+                        ],
+                    },
+                    {
+                        type: "logic_as_u256_greater_or_equal",
+                        nodes: [
+                            { type: "identifier", identifier: 1 },
+                            { type: "identifier", identifier: 2 },
+                        ],
+                    },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: true, value_type: "Address", name: "Submitted Order object address; must belong to the current signer" },
+                { identifier: 1, b_submission: true, value_type: "U256", name: "Submitted amount (unit: MIST); must be >= minimum amount" },
+                { identifier: 2, b_submission: false, value_type: "U256", value: 1000000, name: "Minimum amount constant (1 MIST)" },
+            ],
+        },
+    },
+    {
+        id: "P16",
+        pattern_name: "Circular reference pattern (Guard references the host object itself)",
+        data_source_combination: "Type1 (host object as constant, using name instead of address)",
+        semantic_intent: "Guard binds to a Host Object while querying the Host Object's own fields; uses name reference to achieve circular binding",
+        match_keywords: ["circular reference", "self", "host", "host", "circular", "self-reference"],
+        schema_elements: {
+            root_type: "logic_equal / logic_and",
+            table_entries: [
+                { value_type: "Address", b_submission: false, purpose: "Host object name (SDK resolves to address at binding time)" },
+            ],
+            query_nodes: [
+                { query_name: "query_service_* / query_machine_*", object_type: "Service / Machine" },
+            ],
+            tree_structure: "logic_equal(query(<host_field_query>, object: { identifier: 0 }), identifier[1] or context(Signer))",
+        },
+        constraints: [
+            "The Host Object must not be published (bPublished=false) when creating and binding the Guard",
+            "Use the Host Object name (not address) in the table; the SDK resolves it at binding time",
+            "The Host Object can only be published after the Guard is bound",
+            "Guard verification only runs normally after the Host Object is published",
+            "Use guard2file to export Guard backups for easy rebuilding",
+        ],
+        example: {
+            root: {
+                type: "logic_equal",
+                nodes: [
+                    {
+                        type: "query",
+                        query: 1231,
+                        object: { identifier: 0 },
+                        parameters: [],
+                    },
+                    { type: "identifier", identifier: 1 },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: false, value_type: "Address", value: "my_service", name: "Host Service name (circular reference, resolved by SDK at binding time)" },
+                { identifier: 1, b_submission: false, value_type: "Bool", value: false, name: "Expected Service paused state (false=not paused)" },
+            ],
+        },
+    },
+    {
+        id: "P17",
+        pattern_name: "Query parameter translation pattern (type conversion node combination)",
+        data_source_combination: "Type1/2 + type conversion (query parameter type translation)",
+        semantic_intent: "Guard queries parameters that require type conversion (e.g. Address → U64 timestamp key); uses convert_* nodes to translate",
+        match_keywords: ["type conversion", "translate", "convert", "timestamp key", "parameter translation", "address to u64"],
+        schema_elements: {
+            root_type: "logic_equal / logic_as_u256_greater_or_equal",
+            table_entries: [
+                { value_type: "Address", b_submission: false, purpose: "Query target object address (Type1/2)" },
+                { value_type: "U64", b_submission: false, purpose: "Comparison baseline value (e.g. timestamp threshold)" },
+            ],
+            query_nodes: [
+                { query_name: "query_repository_data / query_progress_history_*", object_type: "Repository / Progress" },
+            ],
+            tree_structure: "logic_as_u256_greater_or_equal(query(<query_with_converted_param>, object: { identifier: 0 }, parameters: [convert_number_address(identifier[1])]), identifier[2])",
+        },
+        constraints: [
+            "The query parameter type must match the parameters type defined in GUARDQUERY",
+            "If the table declares Address but the query requires U64, convert_number_address must be used to translate",
+            "The input type of convert_* nodes must be compatible with the child node's return type",
+            "The translated type must match the parameters definition of the query instruction",
+            "Use wowok_buildin_info info='guard instructions' to verify parameter types",
+        ],
+        example: {
+            root: {
+                type: "logic_as_u256_greater_or_equal",
+                nodes: [
+                    {
+                        type: "query",
+                        query: 1167,
+                        object: { identifier: 0 },
+                        parameters: [
+                            {
+                                type: "convert_number_address",
+                                nodes: [
+                                    { type: "identifier", identifier: 1 },
+                                ],
+                            },
+                        ],
+                    },
+                    { type: "identifier", identifier: 2 },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: false, value_type: "Address", value: "0xrepo", name: "Repository address constant" },
+                { identifier: 1, b_submission: false, value_type: "U64", value: 1700000000000, name: "Timestamp key (U64, needs to be converted to Address for Repository query)" },
+                { identifier: 2, b_submission: false, value_type: "U256", value: 100, name: "Expected Repository data value" },
             ],
         },
     },
 ];
 export const SCHEMA_TO_SEMANTIC_RULES = [
-    { element_type: "node", type_name: "logic_equal", semantic: "相等比较（==），返回 Bool", return_type: "Bool", child_constraints: "2 个子节点，类型必须兼容" },
-    { element_type: "node", type_name: "logic_not", semantic: "逻辑非（!），返回 Bool", return_type: "Bool", child_constraints: "1 个子节点，必须 Bool" },
-    { element_type: "node", type_name: "logic_and", semantic: "逻辑与（AND），所有子节点为 true 则 true", return_type: "Bool", child_constraints: "2-8 个 Bool 子节点" },
-    { element_type: "node", type_name: "logic_or", semantic: "逻辑或（OR），任一子节点为 true 则 true", return_type: "Bool", child_constraints: "2-8 个 Bool 子节点" },
-    { element_type: "node", type_name: "logic_as_u256_greater", semantic: "数值大于（>），自动宽展到 U256", return_type: "Bool", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "logic_as_u256_lesser", semantic: "数值小于（<）", return_type: "Bool", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "logic_as_u256_equal", semantic: "数值相等（==）", return_type: "Bool", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "logic_as_u256_greater_or_equal", semantic: "数值大于等于（>=）", return_type: "Bool", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "logic_as_u256_lesser_or_equal", semantic: "数值小于等于（<=）", return_type: "Bool", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "logic_string_contains", semantic: "字符串包含（大小写敏感）", return_type: "Bool", child_constraints: "2 个 String 子节点" },
-    { element_type: "node", type_name: "logic_string_nocase_contains", semantic: "字符串包含（大小写不敏感）", return_type: "Bool", child_constraints: "2 个 String 子节点" },
-    { element_type: "node", type_name: "logic_string_nocase_equal", semantic: "字符串相等（大小写不敏感）", return_type: "Bool", child_constraints: "2 个 String 子节点" },
-    { element_type: "node", type_name: "identifier", semantic: "引用 table 条目的值", return_type: "由 table 条目 value_type 决定", child_constraints: "无子节点，需要 identifier 字段引用 table" },
-    { element_type: "node", type_name: "context", semantic: "交易上下文数据（Signer 地址、Clock 时间戳、Guard 自身 ID）", return_type: "Address (Signer) / U64 (Clock) / Address (Self)", child_constraints: "无子节点" },
-    { element_type: "node", type_name: "query", semantic: "查询链上对象数据", return_type: "由查询指令决定", child_constraints: "需要 query + object + parameters 字段", discovery_tool: "wowok_buildin_info(info='guard instructions')" },
-    { element_type: "node", type_name: "calc_number_add", semantic: "数值加法", return_type: "U256", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "calc_number_sub", semantic: "数值减法", return_type: "U256", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "calc_number_mul", semantic: "数值乘法", return_type: "U256", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "calc_number_div", semantic: "数值除法", return_type: "U256", child_constraints: "2 个数值子节点" },
-    { element_type: "node", type_name: "convert_string_number", semantic: "String → Number 转换", return_type: "U256", child_constraints: "1 个 String 子节点" },
-    { element_type: "node", type_name: "convert_number_string", semantic: "Number → String 转换", return_type: "String", child_constraints: "1 个数值子节点" },
-    { element_type: "node", type_name: "convert_number_address", semantic: "Number → Address 转换（时间戳转地址等）", return_type: "Address", child_constraints: "1 个数值子节点" },
-    { element_type: "node", type_name: "vec_contains_bool", semantic: "向量是否包含 Bool 值", return_type: "Bool", child_constraints: "2 个子节点：VecBool + Bool" },
-    { element_type: "node", type_name: "vec_contains_address", semantic: "向量是否包含 Address（白名单检查）", return_type: "Bool", child_constraints: "2 个子节点：VecAddress + Address" },
-    { element_type: "node", type_name: "vec_contains_string", semantic: "向量是否包含 String", return_type: "Bool", child_constraints: "2 个子节点：VecString + String" },
-    { element_type: "node", type_name: "vec_contains_string_nocase", semantic: "向量是否包含 String（大小写不敏感）", return_type: "Bool", child_constraints: "2 个子节点：VecString + String" },
-    { element_type: "node", type_name: "vec_contains_number", semantic: "向量是否包含数值", return_type: "Bool", child_constraints: "2 个子节点：Vec* + Number" },
-    { element_type: "node", type_name: "query_reward_record_exists", semantic: "查询奖励领取记录是否存在（Bool）", return_type: "Bool", child_constraints: "需要 object + recipient 字段" },
-    { element_type: "node", type_name: "query_reward_record_count", semantic: "查询奖励领取记录数（U64）", return_type: "U64", child_constraints: "需要 object + recipient 字段" },
-    { element_type: "node", type_name: "query_progress_history_find", semantic: "查询 Progress 历史中是否存在指定 session", return_type: "Bool", child_constraints: "需要 object + historyIdx + sessionIdx" },
-    { element_type: "node", type_name: "query_progress_history_session_forward_find", semantic: "查询 Progress session 中是否存在指定 forward", return_type: "Bool", child_constraints: "需要 object + historyIdx + sessionIdx + forwardIdx" },
-    { element_type: "node", type_name: "query_progress_history_session_forward_retained_submission_count", semantic: "查询 Progress session forward 的保留提交数", return_type: "U64", child_constraints: "需要 object + historyIdx + sessionIdx + forwardIdx" },
-    { element_type: "witness", type_name: "TypeOrderProgress", semantic: "从 Order 地址转换到 Progress（100）", discovery_tool: "wowok_buildin_info(info='guard instructions')" },
-    { element_type: "witness", type_name: "TypeOrderMachine", semantic: "从 Order 地址转换到 Machine（101）" },
-    { element_type: "witness", type_name: "TypeOrderService", semantic: "从 Order 地址转换到 Service（102）" },
-    { element_type: "witness", type_name: "TypeProgressMachine", semantic: "从 Progress 地址转换到 Machine（103）" },
-    { element_type: "witness", type_name: "TypeArbOrder", semantic: "从 Arb 地址转换到 Order（104）" },
-    { element_type: "witness", type_name: "TypeArbArbitration", semantic: "从 Arb 地址转换到 Arbitration（105，父服务）" },
-    { element_type: "witness", type_name: "TypeArbProgress", semantic: "从 Arb 地址转换到 Progress（106）" },
-    { element_type: "witness", type_name: "TypeArbMachine", semantic: "从 Arb 地址转换到 Machine（107）" },
-    { element_type: "witness", type_name: "TypeArbService", semantic: "从 Arb 地址转换到 Service（108）" },
-    { element_type: "table_entry", type_name: "Bool", semantic: "布尔值常量或提交" },
-    { element_type: "table_entry", type_name: "Address", semantic: "地址常量或提交" },
-    { element_type: "table_entry", type_name: "String", semantic: "字符串常量或提交" },
-    { element_type: "table_entry", type_name: "U8", semantic: "8 位无符号整数" },
-    { element_type: "table_entry", type_name: "U16", semantic: "16 位无符号整数" },
-    { element_type: "table_entry", type_name: "U32", semantic: "32 位无符号整数" },
-    { element_type: "table_entry", type_name: "U64", semantic: "64 位无符号整数" },
-    { element_type: "table_entry", type_name: "U128", semantic: "128 位无符号整数" },
-    { element_type: "table_entry", type_name: "U256", semantic: "256 位无符号整数" },
-    { element_type: "table_entry", type_name: "VecAddress", semantic: "地址向量（用于白名单）" },
-    { element_type: "table_entry", type_name: "VecString", semantic: "字符串向量" },
-    { element_type: "table_entry", type_name: "VecU64", semantic: "U64 向量" },
-    { element_type: "rely", type_name: "rely_and", semantic: "依赖其他 Guard，AND 逻辑（所有必须通过）", child_constraints: "最多 4 个依赖，每个 rep=true" },
-    { element_type: "rely", type_name: "rely_or", semantic: "依赖其他 Guard，OR 逻辑（任一通过即可）", child_constraints: "最多 4 个依赖，每个 rep=true" },
+    { element_type: "node", type_name: "logic_equal", semantic: "Equality comparison (==), returns Bool. Accepts any type but both operands must be type-compatible", return_type: "Bool", child_constraints: "2 child nodes, types must be compatible" },
+    { element_type: "node", type_name: "logic_not", semantic: "Logical NOT (!), returns Bool", return_type: "Bool", child_constraints: "1 child node, must be Bool" },
+    { element_type: "node", type_name: "logic_and", semantic: "Logical AND; true if all child nodes are true", return_type: "Bool", child_constraints: "2-8 Bool child nodes (MAX_MULTI_OPERANDS)" },
+    { element_type: "node", type_name: "logic_or", semantic: "Logical OR; true if any child node is true", return_type: "Bool", child_constraints: "2-8 Bool child nodes" },
+    { element_type: "node", type_name: "logic_as_u256_greater", semantic: "Numeric greater than (>), auto-widened to U256", return_type: "Bool", child_constraints: "2 numeric child nodes (U8-U256 compatible)" },
+    { element_type: "node", type_name: "logic_as_u256_lesser", semantic: "Numeric less than (<)", return_type: "Bool", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "logic_as_u256_equal", semantic: "Numeric equality (==)", return_type: "Bool", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "logic_as_u256_greater_or_equal", semantic: "Numeric greater than or equal (>=)", return_type: "Bool", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "logic_as_u256_lesser_or_equal", semantic: "Numeric less than or equal (<=)", return_type: "Bool", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "logic_string_contains", semantic: "String contains (case-sensitive)", return_type: "Bool", child_constraints: "2 String child nodes" },
+    { element_type: "node", type_name: "logic_string_nocase_contains", semantic: "String contains (case-insensitive)", return_type: "Bool", child_constraints: "2 String child nodes" },
+    { element_type: "node", type_name: "logic_string_nocase_equal", semantic: "String equality (case-insensitive)", return_type: "Bool", child_constraints: "2 String child nodes" },
+    { element_type: "node", type_name: "identifier", semantic: "References the value of a table entry. The data source type depends on b_submission: false=Type1 constant, true=Type3 submitted", return_type: "Determined by table entry value_type", child_constraints: "No child nodes; requires identifier field to reference table", data_source_class: "Type1_OnChainConstant" },
+    { element_type: "node", type_name: "context", semantic: "Transaction context data (Type4 SystemContext). Signer=signer address, Clock=on-chain timestamp (U64), Guard=ObjectID of the Guard currently being verified", return_type: "Address (Signer/Guard) / U64 (Clock)", child_constraints: "No child nodes", data_source_class: "Type4_SystemContext" },
+    { element_type: "node", type_name: "query", semantic: "Queries on-chain object data. The data source type depends on object.convert_witness: present=Type2 (witness-derived), absent+constant=Type1, absent+submitted=Type3", return_type: "Determined by the query instruction", child_constraints: "Requires query + object + parameters fields", data_source_class: "Type1_OnChainConstant", discovery_tool: "wowok_buildin_info(info='guard instructions')" },
+    { element_type: "node", type_name: "calc_number_add", semantic: "Numeric addition", return_type: "U256", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "calc_number_subtract", semantic: "Numeric subtraction", return_type: "U256", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "calc_number_multiply", semantic: "Numeric multiplication", return_type: "U256", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "calc_number_divide", semantic: "Numeric division", return_type: "U256", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "calc_number_mod", semantic: "Numeric modulo", return_type: "U256", child_constraints: "2 numeric child nodes" },
+    { element_type: "node", type_name: "calc_string_length", semantic: "String length", return_type: "U64", child_constraints: "1 String child node" },
+    { element_type: "node", type_name: "calc_string_contains", semantic: "String contains (returns Bool)", return_type: "Bool", child_constraints: "2 String child nodes" },
+    { element_type: "node", type_name: "calc_string_nocase_contains", semantic: "String contains (case-insensitive, returns Bool)", return_type: "Bool", child_constraints: "2 String child nodes" },
+    { element_type: "node", type_name: "calc_string_nocase_equal", semantic: "String equality (case-insensitive, returns Bool)", return_type: "Bool", child_constraints: "2 String child nodes" },
+    { element_type: "node", type_name: "calc_string_indexof", semantic: "String find index", return_type: "U64", child_constraints: "2 String child nodes + order" },
+    { element_type: "node", type_name: "calc_string_nocase_indexof", semantic: "String find index (case-insensitive)", return_type: "U64", child_constraints: "2 String child nodes + order" },
+    { element_type: "node", type_name: "convert_number_address", semantic: "Number → Address conversion (e.g. timestamp to address)", return_type: "Address", child_constraints: "1 numeric child node" },
+    { element_type: "node", type_name: "convert_address_number", semantic: "Address → Number conversion", return_type: "U256", child_constraints: "1 Address child node" },
+    { element_type: "node", type_name: "convert_number_string", semantic: "Number → String conversion", return_type: "String", child_constraints: "1 numeric child node" },
+    { element_type: "node", type_name: "convert_string_number", semantic: "String → Number conversion", return_type: "U256", child_constraints: "1 String child node" },
+    { element_type: "node", type_name: "convert_safe_u8", semantic: "Safe conversion to U8 (errors on overflow)", return_type: "U8", child_constraints: "1 numeric child node" },
+    { element_type: "node", type_name: "convert_safe_u16", semantic: "Safe conversion to U16", return_type: "U16", child_constraints: "1 numeric child node" },
+    { element_type: "node", type_name: "convert_safe_u32", semantic: "Safe conversion to U32", return_type: "U32", child_constraints: "1 numeric child node" },
+    { element_type: "node", type_name: "convert_safe_u64", semantic: "Safe conversion to U64", return_type: "U64", child_constraints: "1 numeric child node" },
+    { element_type: "node", type_name: "convert_safe_u128", semantic: "Safe conversion to U128", return_type: "U128", child_constraints: "1 numeric child node" },
+    { element_type: "node", type_name: "convert_safe_u256", semantic: "Safe conversion to U256", return_type: "U256", child_constraints: "1 numeric child node" },
+    { element_type: "node", type_name: "value_type", semantic: "Returns the value's type identifier (U8) — used for dynamic type checking", return_type: "U8", child_constraints: "1 variable child node" },
+    { element_type: "node", type_name: "vec_length", semantic: "Vector length", return_type: "U64", child_constraints: "1 vec child node" },
+    { element_type: "node", type_name: "vec_contains_bool", semantic: "Whether the vector contains a Bool value", return_type: "Bool", child_constraints: "1 VecBool + 1 Bool" },
+    { element_type: "node", type_name: "vec_contains_address", semantic: "Whether the vector contains an Address (whitelist check)", return_type: "Bool", child_constraints: "1 VecAddress + 1 Address" },
+    { element_type: "node", type_name: "vec_contains_string", semantic: "Whether the vector contains a String", return_type: "Bool", child_constraints: "1 VecString + 1 String" },
+    { element_type: "node", type_name: "vec_contains_string_nocase", semantic: "Whether the vector contains a String (case-insensitive)", return_type: "Bool", child_constraints: "1 VecString + 1 String" },
+    { element_type: "node", type_name: "vec_contains_number", semantic: "Whether the vector contains a number", return_type: "Bool", child_constraints: "1 Vec* + 1 Number" },
+    { element_type: "node", type_name: "vec_indexof_bool", semantic: "Bool vector find index", return_type: "U64", child_constraints: "VecBool + Bool + order" },
+    { element_type: "node", type_name: "vec_indexof_address", semantic: "Address vector find index", return_type: "U64", child_constraints: "VecAddress + Address + order" },
+    { element_type: "node", type_name: "vec_indexof_string", semantic: "String vector find index", return_type: "U64", child_constraints: "VecString + String + order" },
+    { element_type: "node", type_name: "vec_indexof_string_nocase", semantic: "String vector find index (case-insensitive)", return_type: "U64", child_constraints: "VecString + String + order" },
+    { element_type: "node", type_name: "vec_indexof_number", semantic: "Numeric vector find index", return_type: "U64", child_constraints: "Vec* + Number + order" },
+    { element_type: "node", type_name: "query_reward_record_find", semantic: "Query reward claim records (returns the found record)", return_type: "Bool", child_constraints: "Requires object + recipient + where + find" },
+    { element_type: "node", type_name: "query_reward_record_count", semantic: "Query reward claim record count (U64)", return_type: "U64", child_constraints: "Requires object + recipient (optional)" },
+    { element_type: "node", type_name: "query_reward_record_exists", semantic: "Query whether a reward claim record exists (Bool)", return_type: "Bool", child_constraints: "Requires object + recipient (optional)" },
+    { element_type: "node", type_name: "query_progress_history_find", semantic: "Query whether a specified session exists in Progress history", return_type: "Bool", child_constraints: "Requires object + where + find" },
+    { element_type: "node", type_name: "query_progress_history_session_find", semantic: "Query a Progress session", return_type: "Bool", child_constraints: "Requires object + historyIdx + where + find" },
+    { element_type: "node", type_name: "query_progress_history_session_forward_find", semantic: "Query whether a specified forward exists in a Progress session", return_type: "Bool", child_constraints: "Requires object + historyIdx + sessionIdx + where + find" },
+    { element_type: "node", type_name: "query_progress_history_session_count", semantic: "Query the number of Progress sessions", return_type: "U64", child_constraints: "Requires object + historyIdx" },
+    { element_type: "node", type_name: "query_progress_history_session_forward_count", semantic: "Query the number of forwards in a Progress session", return_type: "U64", child_constraints: "Requires object + historyIdx + sessionIdx" },
+    { element_type: "node", type_name: "query_progress_history_session_forward_retained_submission_count", semantic: "Query the retained submission count of a forward in a Progress session", return_type: "U64", child_constraints: "Requires object + historyIdx + sessionIdx + forwardIdx" },
+    { element_type: "witness", type_name: "TypeOrderProgress", semantic: "Reads the order.progress field from an Order address to derive Progress (100, single hop)", data_source_class: "Type2_WitnessDerived", discovery_tool: "wowok_buildin_info(info='guard instructions')" },
+    { element_type: "witness", type_name: "TypeOrderMachine", semantic: "Reads the order.machine field from an Order address to derive Machine (101, single hop)", data_source_class: "Type2_WitnessDerived" },
+    { element_type: "witness", type_name: "TypeOrderService", semantic: "Reads the order.service field from an Order address to derive Service (102, single hop)", data_source_class: "Type2_WitnessDerived" },
+    { element_type: "witness", type_name: "TypeProgressMachine", semantic: "Reads the progress.machine field from a Progress address to derive Machine (103, single hop)", data_source_class: "Type2_WitnessDerived" },
+    { element_type: "witness", type_name: "TypeArbOrder", semantic: "Reads the arb.order field from an Arb address to derive Order (104, single hop)", data_source_class: "Type2_WitnessDerived" },
+    { element_type: "witness", type_name: "TypeArbArbitration", semantic: "Reads the arb.arbitration field from an Arb address to derive the parent Arbitration service (105, single hop)", data_source_class: "Type2_WitnessDerived" },
+    { element_type: "witness", type_name: "TypeArbProgress", semantic: "Derives from Arb in two hops: arb.order → order.progress (106, multi-hop)", data_source_class: "Type2_WitnessDerived" },
+    { element_type: "witness", type_name: "TypeArbMachine", semantic: "Derives from Arb in two hops: arb.order → order.machine (107, multi-hop)", data_source_class: "Type2_WitnessDerived" },
+    { element_type: "witness", type_name: "TypeArbService", semantic: "Derives from Arb in two hops: arb.order → order.service (108, multi-hop)", data_source_class: "Type2_WitnessDerived" },
+    { element_type: "context", type_name: "Signer", semantic: "Current transaction signer address (TransactionContext.sender())", return_type: "Address", data_source_class: "Type4_SystemContext" },
+    { element_type: "context", type_name: "Clock", semantic: "Current on-chain timestamp (reads timestamp_ms of WOW_CLOCK_OBJECT_ID 0x6)", return_type: "U64", data_source_class: "Type4_SystemContext" },
+    { element_type: "context", type_name: "Guard", semantic: "ObjectID of the Guard object currently being verified (self-reference, rare)", return_type: "Address", data_source_class: "Type4_SystemContext" },
+    { element_type: "table_entry", type_name: "Bool", semantic: "Boolean constant or submission" },
+    { element_type: "table_entry", type_name: "Address", semantic: "Address constant (Type1) or submission (Type3). Object address type" },
+    { element_type: "table_entry", type_name: "String", semantic: "String constant or submission" },
+    { element_type: "table_entry", type_name: "U8", semantic: "8-bit unsigned integer" },
+    { element_type: "table_entry", type_name: "U16", semantic: "16-bit unsigned integer" },
+    { element_type: "table_entry", type_name: "U32", semantic: "32-bit unsigned integer" },
+    { element_type: "table_entry", type_name: "U64", semantic: "64-bit unsigned integer (commonly used for timestamps)" },
+    { element_type: "table_entry", type_name: "U128", semantic: "128-bit unsigned integer" },
+    { element_type: "table_entry", type_name: "U256", semantic: "256-bit unsigned integer (auto-widening target for numeric operations)" },
+    { element_type: "table_entry", type_name: "VecAddress", semantic: "Address vector (used for whitelists, Type1 constant)" },
+    { element_type: "table_entry", type_name: "VecString", semantic: "String vector" },
+    { element_type: "table_entry", type_name: "VecU64", semantic: "U64 vector" },
+    { element_type: "table_entry", type_name: "VecU8", semantic: "U8 vector (raw bytes)" },
+    { element_type: "table_entry", type_name: "Value", semantic: "Dynamic type (19, first byte is the type identifier) — used for Repository data, EntityRegistrar records, Passport submission value" },
+    { element_type: "rely", type_name: "rely_and", semantic: "Depends on other Guards, AND logic (all must pass). Depended-on Guards must have rep=true", child_constraints: "At most 4 dependencies, each with rep=true (repository.data query does not depend on submission)" },
+    { element_type: "rely", type_name: "rely_or", semantic: "Depends on other Guards, OR logic (any one passing is sufficient). Depended-on Guards must have rep=true", child_constraints: "At most 4 dependencies, each with rep=true" },
 ];
 export const GUARD_CONSTRAINT_RULES = [
     {
         id: "ROOT_01",
-        name: "root 返回 Bool",
-        description: "Guard root 节点必须返回 Bool 类型",
+        name: "root returns Bool",
+        description: "The Guard root node must return a Bool type",
         category: "root",
-        validation_logic: "root.node_type 必须在 allowedTypes 列表中（logic_*, calc_string_contains, vec_contains_*, query_reward_record_exists, query[Bool返回], identifier[Bool类型]）",
+        phase: "creation",
+        validation_logic: "root.node_type must be in the allowedTypes list (logic_*, calc_string_contains, vec_contains_*, query_reward_record_exists, query[Bool return], identifier[Bool type])",
         failure_message: "Guard root node must be an operation that returns Bool",
+        verification_location: "SDK buildNode(root, ValueType.Bool, ...)",
         pitfall_number: 7,
     },
     {
         id: "TABLE_01",
-        name: "identifier 唯一性",
-        description: "table 中每个 identifier 必须唯一（0-255）",
+        name: "identifier uniqueness",
+        description: "Each identifier in the table must be unique (0-255)",
         category: "table",
-        validation_logic: "table 中无重复 identifier",
+        phase: "creation",
+        validation_logic: "No duplicate identifiers in the table",
         failure_message: "Duplicate table identifier",
+        verification_location: "SDK lodash groupBy",
     },
     {
         id: "TABLE_02",
-        name: "identifier 引用完整性",
-        description: "计算树中每个 identifier 节点必须在 table 中存在",
+        name: "identifier referential integrity",
+        description: "Every identifier node in the computation tree must exist in the table",
         category: "table",
-        validation_logic: "遍历计算树，每个 identifier 节点的 index 在 table 中存在",
+        phase: "creation",
+        validation_logic: "Traverse the computation tree; each identifier node's index exists in the table",
         failure_message: "Identifier not found in table",
+        verification_location: "SDK buildNode",
         pitfall_number: 1,
     },
     {
         id: "TABLE_03",
-        name: "常量条目必须有值",
-        description: "b_submission=false 的条目必须有 value 字段",
+        name: "Constant entries must have a value",
+        description: "Entries with b_submission=false must have a value field",
         category: "table",
-        validation_logic: "所有 b_submission=false 的条目 value 字段非空",
+        phase: "creation",
+        validation_logic: "All entries with b_submission=false have a non-empty value field",
         failure_message: "Constant table entry must have a value",
+        verification_location: "SDK operate",
     },
     {
         id: "TABLE_04",
-        name: "table 大小限制",
-        description: "最多 256 条目，序列化后不超过 40000 字节",
+        name: "table size limit",
+        description: "At most 256 entries; serialized size must not exceed 40000 bytes",
         category: "table",
+        phase: "creation",
         validation_logic: "table.length <= 256 && serialize(table).length <= 40000",
         failure_message: "Table exceeds size limit (256 entries or 40000 bytes)",
+        verification_location: "Move guard::new",
+    },
+    {
+        id: "TABLE_05",
+        name: "submission entry value is 1 byte (type code only)",
+        description: "Entries with b_submission=true have a serialized value of just 1 byte (the type code)",
+        category: "table",
+        phase: "creation",
+        validation_logic: "When b_submission=true, bcsValue.length === 1 and bcsValue[0] === valueType",
+        failure_message: "Submission table entry value must be 1 byte (type code only)",
+        verification_location: "native deserialize_constants",
     },
     {
         id: "QUERY_01",
-        name: "query 指令有效",
-        description: "query 节点的 query 字段必须是有效的 GUARDQUERY ID 或 name",
+        name: "query instruction valid",
+        description: "The query field of a query node must be a valid GUARDQUERY ID or name",
         category: "query",
-        validation_logic: "query 字段在 GUARDQUERY 中存在（通过 isValidGuardQueryIdOrName）",
+        phase: "creation",
+        validation_logic: "The query field exists in GUARDQUERY (via isValidGuardQueryIdOrName)",
         failure_message: "Invalid Guard query instruction",
+        verification_location: "SDK getGuardQueryInfo",
         pitfall_number: 3,
     },
     {
         id: "QUERY_02",
-        name: "query 参数匹配",
-        description: "query 节点的 parameters 数量和类型必须匹配指令定义",
+        name: "query parameter count match",
+        description: "The number and types of parameters in a query node must match the instruction definition",
         category: "query",
-        validation_logic: "parameters.length === instruction.parameters.length && 类型兼容",
+        phase: "creation",
+        validation_logic: "parameters.length === instruction.parameters.length && type-compatible",
         failure_message: "Query parameter count or type mismatch",
+        verification_location: "SDK buildNode",
         pitfall_number: 3,
     },
     {
         id: "QUERY_03",
-        name: "query object 类型匹配",
-        description: "query object 的 object_type 必须匹配指令的 objectType",
+        name: "query return type compatible",
+        description: "The return type of a query node must be compatible with the parent node's expected type",
         category: "query",
-        validation_logic: "table[object.identifier].object_type === instruction.objectType（考虑 witness 转换）",
-        failure_message: "Query object type mismatch",
+        phase: "creation",
+        validation_logic: "checkType(query.return_type, parent.expected_type)",
+        failure_message: "Query return type incompatible with parent node",
+        verification_location: "SDK checkType",
+    },
+    {
+        id: "QUERY_04",
+        name: "query object identifier's value_type is Address",
+        description: "The table entry referenced by query node's object.identifier must have value_type of Address",
+        category: "query",
+        phase: "creation",
+        validation_logic: "table[object.identifier].value_type === Address",
+        failure_message: "Query object identifier must reference an Address-type table entry",
+        verification_location: "SDK buildNode L603-609",
     },
     {
         id: "WITNESS_01",
-        name: "witness 类型有效",
-        description: "convert_witness 必须是有效的 WitnessType (100-108)",
+        name: "witness type valid",
+        description: "convert_witness must be a valid WitnessType (100-108)",
         category: "witness",
-        validation_logic: "witness 值在 WitnessTypeSchema 允许范围内",
+        phase: "creation",
+        validation_logic: "The witness value is within the range allowed by WitnessTypeSchema (100-108)",
         failure_message: "Invalid witness type",
+        verification_location: "SDK isWitnessType",
         pitfall_number: 4,
     },
     {
         id: "WITNESS_02",
-        name: "witness source-target 匹配",
-        description: "witness 的 source type 必须匹配 table 条目 object_type，target type 必须匹配 query objectType",
+        name: "witness target matches query objectType",
+        description: "The witness's target type must match the query instruction's objectType",
+        category: "witness",
+        phase: "creation",
+        validation_logic: "witness.target_type === instruction.objectType",
+        failure_message: "Witness target type does not match query object type",
+        verification_location: "SDK buildNode L613-619",
+        pitfall_number: 4,
+    },
+    {
+        id: "WITNESS_03",
+        name: "witness source matches tableItem object_type",
+        description: "The witness's source type must match the object_type declared in the table entry (if declared)",
         category: "witness",
-        validation_logic: "table[identifier].object_type === witness.source_type && instruction.objectType === witness.target_type",
-        failure_message: "Witness source/target type mismatch",
+        phase: "creation",
+        validation_logic: "table[identifier].object_type === witness.source_type (if tableItem.object_type is declared)",
+        failure_message: "Witness source type does not match table entry object_type",
+        verification_location: "SDK buildNode L622-631",
         pitfall_number: 4,
     },
     {
         id: "RELY_01",
-        name: "rely 依赖数量",
-        description: "rely.guards 最多 4 个依赖",
+        name: "rely dependency count ≤ 4",
+        description: "rely.guards supports at most 4 dependencies (MAX_DEPENDED_COUNT)",
         category: "rely",
+        phase: "creation",
         validation_logic: "rely.guards.length <= 4",
         failure_message: "Rely dependencies exceed limit (4)",
+        verification_location: "SDK reliesAdd",
     },
     {
         id: "RELY_02",
-        name: "rely 依赖 rep=true",
-        description: "所有 rely 依赖的 Guard 必须 rep=true（无 Repository 依赖）",
+        name: "rely dependency rep=true",
+        description: "All rely-depended Guards must have rep=true (repository.data query does not depend on runtime submission)",
         category: "rely",
-        validation_logic: "查询每个依赖 Guard 的 rep 字段，必须为 true",
+        phase: "creation",
+        validation_logic: "Query each depended Guard's rep field; must be true",
         failure_message: "Rely dependency has rep=false (not standalone)",
+        verification_location: "Move guard::relies_add",
         pitfall_number: 8,
     },
+    {
+        id: "RELY_03",
+        name: "rely forbids self-reference",
+        description: "A Guard cannot depend on itself",
+        category: "rely",
+        phase: "creation",
+        validation_logic: "rely.guards does not contain the current Guard's address",
+        failure_message: "Guard cannot rely on itself",
+        verification_location: "SDK reliesAdd",
+    },
     {
         id: "BINDING_01",
         name: "voting_guard GuardIdentifier numeric",
-        description: "Arbitration voting_guard 的 GuardIdentifier 引用的 table 条目必须 numeric 类型",
+        description: "The table entry referenced by Arbitration voting_guard's GuardIdentifier must be of a numeric type",
         category: "binding",
-        validation_logic: "如果 binding=voting_guard，GuardIdentifier 指向的 table 条目 value_type 在 [U8,U16,U32,U64,U128,U256] 中",
+        phase: "creation",
+        validation_logic: "If binding=voting_guard, the table entry pointed to by GuardIdentifier has value_type in [U8,U16,U32,U64,U128,U256]",
         failure_message: "E_GUARD_IDENTIFIER_NOT_NUMBER: voting_guard weight must be numeric",
+        verification_location: "Move Arbitration",
         pitfall_number: 9,
     },
     {
         id: "BINDING_02",
         name: "Repository id_from_submission Address",
-        description: "Repository write_guard 的 id_from_submission 引用的 table 条目必须 Address 类型",
+        description: "The table entry referenced by Repository write_guard's id_from_submission must be of Address type",
         category: "binding",
-        validation_logic: "如果 binding=write_guard 且 id_from_submission 设置，table[id_from_submission].value_type === Address",
+        phase: "creation",
+        validation_logic: "If binding=write_guard and id_from_submission is set, table[id_from_submission].value_type === Address",
         failure_message: "Repository id_from_submission must be Address type",
+        verification_location: "Move Repository",
     },
     {
         id: "BINDING_03",
-        name: "Repository data_from_submission 类型匹配",
-        description: "Repository write_guard 的 data_from_submission 引用的 table 条目必须匹配 Repository value_type",
+        name: "Repository data_from_submission type match",
+        description: "The table entry referenced by Repository write_guard's data_from_submission must match the Repository value_type",
         category: "binding",
-        validation_logic: "如果 binding=write_guard 且 data_from_submission 设置，table[data_from_submission].value_type === Repository.value_type",
+        phase: "creation",
+        validation_logic: "If binding=write_guard and data_from_submission is set, table[data_from_submission].value_type === Repository.value_type",
         failure_message: "Repository data_from_submission type mismatch",
+        verification_location: "Move Repository",
+    },
+    {
+        id: "INPUT_01",
+        name: "root byte stream non-empty",
+        description: "The serialized byte stream of root cannot be empty",
+        category: "input",
+        phase: "creation",
+        validation_logic: "input.length > 0",
+        failure_message: "Input cannot be empty",
+        verification_location: "SDK newGuard",
+    },
+    {
+        id: "INPUT_02",
+        name: "root byte stream ≤ MAX_INPUT_SIZE",
+        description: "The serialized byte stream of root must not exceed MAX_INPUT_SIZE",
+        category: "input",
+        phase: "creation",
+        validation_logic: "input.length <= MAX_INPUT_SIZE",
+        failure_message: "Input size exceeds maximum limit",
+        verification_location: "SDK newGuard",
+    },
+    {
+        id: "IMMUTABLE_01",
+        name: "Guard immutable=true after creation",
+        description: "After creation, a Guard cannot be modified or deleted (CREATE-only)",
+        category: "immutable",
+        phase: "creation",
+        validation_logic: "After guard::create, the immutable field is set to true",
+        failure_message: "Guard is immutable after creation",
+        verification_location: "Move guard::create",
+    },
+    {
+        id: "RUN_IMMUTABLE_01",
+        name: "Guard must be immutable=true to verify",
+        description: "At runtime verification, the Guard must be frozen (immutable=true)",
+        category: "immutable",
+        phase: "runtime",
+        validation_logic: "guard.immutable === true",
+        failure_message: "Guard must be immutable to verify",
+        verification_location: "native verify_guard L497-506",
+    },
+    {
+        id: "RUN_SUB_01",
+        name: "submission type byte matches table declaration",
+        description: "The value[0] (type byte) of submission must match the value_type declared in the table",
+        category: "table",
+        phase: "runtime",
+        validation_logic: "submission_value[0] === table[identifier].value_type",
+        failure_message: "Submission type byte does not match table declaration",
+        verification_location: "native parse_table_items L306",
+    },
+    {
+        id: "RUN_SUB_02",
+        name: "table entries with b_submission=true must be found in submission",
+        description: "All table entries declared as submitted must have corresponding submission data",
+        category: "table",
+        phase: "runtime",
+        validation_logic: "forall identifier in table where b_submission=true: identifier in submission_map",
+        failure_message: "Missing submission for declared b_submission=true table entry",
+        verification_location: "native parse_table_items L301-321",
+    },
+    {
+        id: "RUN_SUB_03",
+        name: "submission total bytes ≤ MAX_SUBMISSION_SIZE (256)",
+        description: "The total bytes of all data submitted at runtime must not exceed 256",
+        category: "table",
+        phase: "runtime",
+        validation_logic: "total_submission_bytes <= 256",
+        failure_message: "Submission exceeds MAX_SUBMISSION_SIZE (256 bytes)",
+        verification_location: "Move verify L252",
+    },
+    {
+        id: "RUN_WITNESS_01",
+        name: "witness derivation source object must have the required relation field",
+        description: "When witness conversion occurs, the source object must contain the relation field needed for derivation",
+        category: "witness",
+        phase: "runtime",
+        validation_logic: "The source object exists and contains the field required for witness derivation (e.g. order.progress field is non-empty)",
+        failure_message: "Witness source object missing required field for derivation",
+        verification_location: "native convert_witness",
+    },
+    {
+        id: "RUN_WITNESS_02",
+        name: "witness-derived target object must exist",
+        description: "The target object derived by witness must exist on-chain",
+        category: "witness",
+        phase: "runtime",
+        validation_logic: "The derived target object ID exists on-chain",
+        failure_message: "Witness derived target object does not exist",
+        verification_location: "native convert_witness",
+    },
+    {
+        id: "RUN_QUERY_01",
+        name: "query target object must exist and type match",
+        description: "The target object of a query must exist on-chain and its type must match",
+        category: "query",
+        phase: "runtime",
+        validation_logic: "Target object exists && object type matches query.objectType",
+        failure_message: "Query target object does not exist or type mismatch",
+        verification_location: "native process_object_query",
+    },
+    {
+        id: "RUN_IMPACK_01",
+        name: "at least one impack guard",
+        description: "Passport verification requires at least one impack guard",
+        category: "runtime",
+        phase: "runtime",
+        validation_logic: "impack_list.length >= 1 (note: impack_list is always empty during verify phase; this constraint is checked in result_for_permission phase)",
+        failure_message: "No impack guard found",
+        verification_location: "Move verify L281",
+    },
+    {
+        id: "RUN_IMPACK_02",
+        name: "impack guard failure fails the entire passport",
+        description: "If any impack guard verification fails, the entire passport verification fails",
+        category: "runtime",
+        phase: "runtime",
+        validation_logic: "forall guard in impack_list: guard.result === true",
+        failure_message: "Impack guard verification failed",
+        verification_location: "Move verify L270-275",
+    },
+    {
+        id: "RUN_TX_01",
+        name: "Passport tx_hash must match the current transaction",
+        description: "The tx_hash recorded in the Passport must match the hash of the currently executing transaction",
+        category: "runtime",
+        phase: "runtime",
+        validation_logic: "passport.tx_hash === current_tx_hash",
+        failure_message: "Passport tx_hash does not match current transaction",
+        verification_location: "Move verify L231",
+    },
+    {
+        id: "RUN_RELY_01",
+        name: "rely guard must have been added to passport",
+        description: "Guards relied on must have been registered in the passport",
+        category: "rely",
+        phase: "runtime",
+        validation_logic: "forall guard in rely.guards: guard in passport.relies",
+        failure_message: "Rely guard not added to passport",
+        verification_location: "Move calculate_relies_result",
     },
 ];
 export function matchSemanticPattern(userIntent) {
@@ -482,6 +1101,18 @@ export function explainWitness(witnessType) {
     const name = witnessMap[witnessType];
     return SCHEMA_TO_SEMANTIC_RULES.find((r) => r.element_type === "witness" && r.type_name === name);
 }
+export function explainContext(contextType) {
+    return SCHEMA_TO_SEMANTIC_RULES.find((r) => r.element_type === "context" && r.type_name === contextType);
+}
 export function getConstraintsByCategory(category) {
     return GUARD_CONSTRAINT_RULES.filter((r) => r.category === category);
 }
+export function getConstraintsByPhase(phase) {
+    return GUARD_CONSTRAINT_RULES.filter((r) => r.phase === phase);
+}
+export function getPatternById(id) {
+    return SEMANTIC_TO_SCHEMA_RULES.find((r) => r.id === id);
+}
+export function getDataSourceCombinations() {
+    return [...new Set(SEMANTIC_TO_SCHEMA_RULES.map((r) => r.data_source_combination))];
+}