@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/knowledge/glossary.js

@@ -3,7 +3,7 @@ export const CONCEPT_GLOSSARY = [
         term: "Permission",
         definition: "Organization-wide permission object. indices 0-999 builtin, 1000-65535 custom. " +
             "Shared across all Progress instances of a Service. Use for internal staff roles.",
-        aliases: ["permission object", "权限对象"],
+        aliases: ["permission object"],
         category: "permission",
     },
     {
@@ -17,7 +17,7 @@ export const CONCEPT_GLOSSARY = [
         term: "OrderHolder",
         definition: "The order holder and their agents. Represented by namedOperator=\"\" (empty string) " +
             "on a Forward. Lets the customer operate their own order.",
-        aliases: ["order owner", "orderholder", "订单持有人"],
+        aliases: ["order owner", "orderholder", "order holder"],
         category: "permission",
     },
     {
@@ -25,139 +25,139 @@ export const CONCEPT_GLOSSARY = [
         definition: "A state-transition edge in a Machine. Carries weight, a permission " +
             "(Permission index / NamedOperator / OrderHolder), and an optional Guard. " +
             "Every Forward MUST define at least one permission.",
-        aliases: ["迁移", "transition"],
+        aliases: ["transition"],
         category: "operation",
     },
     {
         term: "Pair",
         definition: "A prev_node → next_node transition group in a Machine with a threshold. " +
             "When the cumulative weight of executed Forwards meets the threshold, the Pair fires.",
-        aliases: ["迁移对", "transition pair"],
+        aliases: ["transition pair"],
         category: "operation",
     },
     {
         term: "Machine",
         definition: "Workflow blueprint (directed graph). Becomes immutable after publish. " +
             "A Progress instance is created per order from the Machine.",
-        aliases: ["工作流模板", "machine template"],
+        aliases: ["machine template"],
         category: "object",
     },
     {
         term: "Progress",
         definition: "A workflow instance bound to one order. Advances via Forwards; " +
             "carries retained_submission values for Guard verification.",
-        aliases: ["流程实例", "progress instance"],
+        aliases: ["progress instance"],
         category: "object",
     },
     {
         term: "Guard",
         definition: "Immutable static validation rule. Verifies submissions and on-chain object data. " +
             "Returns boolean. Cannot be mutated after creation.",
-        aliases: ["守卫", "guard object"],
+        aliases: ["guard object"],
         category: "acceptance",
     },
     {
         term: "Repository",
         definition: "Mutable dynamic acceptance store. Keyed by (name, entity). " +
             "Used for data that can change over time (e.g. SLA config, review records).",
-        aliases: ["仓库", "repository object"],
+        aliases: ["repository object"],
         category: "acceptance",
     },
     {
         term: "Acceptance",
         definition: "The verification standard for a process step. Composed of static Guard + " +
             "dynamic Repository. Drives whether a Forward can execute.",
-        aliases: ["验收标准", "acceptance standard"],
+        aliases: ["acceptance standard"],
         category: "acceptance",
     },
     {
         term: "Service",
         definition: "A merchant's service listing. References Machine, order_allocators, arbitrations, " +
             "compensation_fund, rewards, buy_guard. machine & order_allocators lock after publish.",
-        aliases: ["服务", "service object"],
+        aliases: ["service object"],
         category: "object",
     },
     {
         term: "Order",
         definition: "An order against a Service. Funds are escrowed; released via Progress + Allocation. " +
             "Arb cases attach to orders for dispute resolution.",
-        aliases: ["订单"],
+        aliases: ["order instance"],
         category: "object",
     },
     {
         term: "Allocator",
         definition: "Fund distribution rules. Priority: Amount → Rate → Surplus. first-Guard-wins. " +
             "Locked on Service publish (order_allocators).",
-        aliases: ["分账器", "allocation"],
+        aliases: ["allocation"],
         category: "fund",
     },
     {
         term: "Allocation",
         definition: "The act of distributing escrowed funds to recipients per an Allocator. " +
             "Executed by the order holder or Permission holder.",
-        aliases: ["分账"],
+        aliases: ["allocation act"],
         category: "fund",
     },
     {
         term: "Arbitration",
         definition: "Independent arbitration service object. Configured with voting_guard, usage_guard, " +
             "fee. Generates Arb cases per dispute. Third-party preferred over self-built.",
-        aliases: ["仲裁服务", "arb service"],
+        aliases: ["arb service"],
         category: "object",
     },
     {
         term: "Arb",
         definition: "A single dispute case instance of an Arbitration. Has a state machine " +
             "(dispute → confirm → vote → verdict → settle).",
-        aliases: ["仲裁案", "arb case"],
+        aliases: ["arb case"],
         category: "object",
     },
     {
         term: "compensation_fund",
         definition: "A fund attached to a Service. Arbitration indemnity is drawn from it. " +
             "Adequacy is a key trust signal for customers.",
-        aliases: ["赔偿基金", "赔偿金"],
+        aliases: ["compensation fund"],
         category: "fund",
     },
     {
         term: "buy_guard",
         definition: "A Guard attached to a Service that gates purchasing. Validates customer eligibility.",
-        aliases: ["购买守卫"],
+        aliases: ["buy guard"],
         category: "acceptance",
     },
     {
         term: "Sub-Order",
         definition: "A child order in a cross-Machine supply chain. Introduced at a node with transparent " +
             "suppliers; verified by Guard to originate from one of the declared suppliers.",
-        aliases: ["采购子订单", "suborder", "sub order"],
+        aliases: ["suborder", "sub order"],
         category: "object",
     },
     {
         term: "Reward",
         definition: "Incentive pool. claim is Guard-gated. guard_add supports Fixed or GuardU64Identifier " +
             "(dynamic). Used for marketing (first-order, cumulative, referral).",
-        aliases: ["奖励", "reward pool"],
+        aliases: ["reward pool"],
         category: "fund",
     },
     {
         term: "Demand",
         definition: "A user's posted service request with optional reward. presenters submit proposals; " +
             "Guard filters them. Matches Services for personalized acquisition.",
-        aliases: ["需求"],
+        aliases: ["demand request"],
         category: "object",
     },
     {
         term: "Personal",
         definition: "Permanently public on-chain identity profile. Social links, reputation (likes/dislikes), " +
             "personal info records. CRITICAL: everything here is PUBLIC forever.",
-        aliases: ["公开身份", "personal profile"],
+        aliases: ["personal profile"],
         category: "object",
     },
     {
         term: "Contact",
         definition: "Bridges a Service's um (contact) and the Messenger ims (messaging). Enables " +
             "off-chain encrypted communication for pre-order negotiation & evidence.",
-        aliases: ["联系"],
+        aliases: ["contact bridge"],
         category: "object",
     },
 ];

package/dist/knowledge/guard-ledger.d.ts

@@ -14,6 +14,6 @@ export interface GuardScene {
 }
 export declare const GUARD_SCENES: GuardScene[];
 export declare function findScene(host_object: string, binding_field: string): GuardScene | undefined;
-export declare function inferSceneFromAction(action: "buy" | "forward" | "allocate" | "claim_reward" | "vote" | "dispute" | "write_repository" | "submit_progress"): GuardScene | undefined;
+export declare function inferSceneFromAction(action: "buy" | "forward" | "allocate" | "claim_reward" | "vote" | "dispute" | "write_repository" | "submit_progress" | "gen_passport"): GuardScene | undefined;
 export declare function getImmutableScenes(): GuardScene[];
 export declare function getNumericIdentifierScenes(): GuardScene[];

package/dist/knowledge/guard-ledger.js

@@ -1,197 +1,237 @@
 export const GUARD_SCENES = [
     {
         id: "service_buy_guard",
-        name: "服务购买验证（buy_guard）",
+        name: "Service purchase validation (buy_guard)",
         host_object: "Service",
         binding_field: "buy_guard",
-        validation_scene: "客户下单购买服务时，Guard 验证客户是否有资格购买（身份/许可/条件）",
-        pass_result: "创建 Order 对象，客户进入支付流程",
-        fail_result: "交易拒绝，Order 不创建，客户无法购买",
-        submission_source: "Customer（signer 地址、credentials、Passport 等）",
+        validation_scene: "When a customer places an order to purchase a service, the Guard validates whether the customer is eligible to purchase (identity/permission/condition)",
+        pass_result: "Create the Order object; the customer enters the payment flow",
+        fail_result: "Transaction rejected; Order is not created; the customer cannot purchase",
+        submission_source: "Customer (signer address, credentials, Passport, etc.)",
         special_constraints: [
-            "Guard table 必须声明所有客户需要提交的数据",
-            "b_submission=true 条目的 name 必须是自然语言描述（客户看到的契约）",
-            "如果 Guard 引用 Service 本身，使用循环引用模式（CREATE Service → CREATE Guard → MODIFY Service）",
-            "Service 发布后 buy_guard 仍可修改（通过 MODIFY Service）",
+            "The Guard table must declare all data the customer needs to submit",
+            "The name of b_submission=true entries must be a natural-language description (the contract the customer sees)",
+            "If the Guard references the Service itself, use the circular reference pattern (CREATE Service → CREATE Guard → MODIFY Service)",
+            "buy_guard can still be modified after Service is published (via MODIFY Service)",
+            "Reentrancy: LOW — Each purchase creates a fresh Order; no existing Order state is modified. Default: no reentrancy risk. IF business intent is 'limit one purchase per user' (limited-edition goods, whitelist single-buy), an anti-reentrancy check is REQUIRED but no direct GUARDQUERY primitive exists for per-user purchase history — use a Repository to record prior purchases and add `repository.data has` (query 1166) + `logic_not` to root, or revoke EntityRegistrar membership after first buy",
         ],
         common_patterns: [
-            "身份检查：context(Signer) + logic_equal（单地址）/ vec_contains_address（白名单）",
-            "会员验证：query EntityRegistrar(0xaab) + logic_and 组合",
-            "时间限制：context(Clock) + logic_as_u256_greater_or_equal",
-            "多条件：logic_and 组合多个检查",
+            "Identity check: context(Signer) + logic_equal (single address) / vec_contains_address (whitelist)",
+            "Membership validation: query EntityRegistrar(0xaab) + logic_and combination",
+            "Time limit: context(Clock) + logic_as_u256_greater_or_equal",
+            "Multi-condition: logic_and combining multiple checks",
         ],
         mutable_after_publish: true,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R7", "R9"],
     },
     {
         id: "service_order_allocators_guard",
-        name: "分账策略选择验证（order_allocators[].guard）",
+        name: "Allocation strategy selection validation (order_allocators[].guard)",
         host_object: "Service",
         binding_field: "order_allocators",
-        validation_scene: "订单完成或满足分账条件时，系统按 order_allocators 顺序评估每个 Allocator 的 Guard，" +
-            "第一个通过的 Guard 对应的 Allocator 执行分账",
-        pass_result: "执行该 Allocator 的分账策略（按比例/按条件分配资金）",
-        fail_result: "跳过此 Allocator，尝试下一个（first-match-wins）。如果所有 Allocator 都失败，资金不分配",
-        submission_source: "System 从 Progress 状态自动派生（无需客户显式提交）",
+        validation_scene: "When an order is completed or allocation conditions are met, the system evaluates each Allocator's Guard in order_allocators order. " +
+            "The first Allocator whose Guard passes executes the allocation",
+        pass_result: "Execute that Allocator's allocation strategy (distribute funds by ratio/condition)",
+        fail_result: "Skip this Allocator and try the next (first-match-wins). If all Allocators fail, funds are not distributed",
+        submission_source: "System auto-derives from Progress state (no explicit customer submission needed)",
         special_constraints: [
-            "order_allocators 顺序敏感：第一个 Guard 通过的 Allocator 执行分账",
-            "Service 发布后 order_allocators 不可修改（immutable）",
-            "Guard 通常查询 Order/Progress 状态判断分账条件",
-            "常用 query: order.amount, progress.current_node, order.completed 等",
-            "GuardIdentifier 可用于动态金额（从 table 提取 u64 值作为分账比例）",
+            "order_allocators is order-sensitive: the first Allocator whose Guard passes executes allocation",
+            "order_allocators cannot be modified after Service is published (immutable)",
+            "Guard usually queries Order/Progress state to determine allocation conditions",
+            "Common queries: order.amount, progress.current_node, order.completed, etc.",
+            "GuardIdentifier can be used for dynamic amounts (extract u64 value from table as allocation ratio)",
+            "Guard+sharing coupling: Guard determines IF allocation happens; sharing.who determines WHERE funds go. If sharing.who=Signer, the caller receives funds — the Guard MUST bind Signer (context(Signer)==authorized) to prevent theft. PREFERRED: use sharing.who=Entity (Treasury or fixed address) so funds always go to the legitimate recipient regardless of caller.",
+            "allocators require unique guard addresses: no two allocators may reference the same Guard object (create separate Guard objects with identical root/table but different descriptions if needed).",
+            "First-match-wins: only the first allocator whose Guard passes executes; subsequent allocators are skipped. Multiple allocators represent alternative strategies, not a simultaneous split.",
+            "If sharing.who=Entity references a Treasury object, verify the Treasury's permission is consistent with the Service's permission (different permissions = different permission organizations = minor risk).",
+            "Reentrancy: LOW — Protocol-level protection: order::on_allocation (order.move L116-119) asserts `allocation` field is None (E_ALLOCATION_ALREADY_SPECIFIED), enforcing ONE Allocation object per Order, ever. After alloc() executes, typical Rate-mode allocators (sum=10000, validated at allocation.move L162-163) and any Surplus-mode allocator drain balance to 0 via balance::withdraw_all (L254), making a second alloc() fail at `assert!(balance >= threshold)` (L193). EDGE CASE: Amount-mode-only allocators (no Surplus, total < full balance) leave remainder; a second alloc() could extract more — mitigated by preferring Rate/Surplus modes. External deposit via receive() (L291) is possible but irrational (attacker funds the Allocation they attack). Optional anti-reentrancy primitive: `order.allocation some` (query 1568) + logic_not",
         ],
         common_patterns: [
-            "节点状态检查：query(Progress.current_node) + logic_equal('Completed')",
-            "金额阈值：query(Order.amount) + logic_as_u256_greater_or_equal(threshold)",
-            "多条件组合：logic_and（节点状态 + 金额 + 时间）",
-            "GuardIdentifier 动态比例：table[u64] 提取分账比例",
+            "Node state check: query(Progress.current_node) + logic_equal('Completed')",
+            "Amount threshold: query(Order.amount) + logic_as_u256_greater_or_equal(threshold)",
+            "Multi-condition combination: logic_and (node state + amount + time)",
+            "GuardIdentifier dynamic ratio: table[u64] extracts allocation ratio",
+            "Treasury+personal 2-allocator pattern: 2 Guard objects (identical root/table, different descriptions) + 2 allocators (sharing.who=Entity Treasury / Entity personal) — 2 alternative merchant collection approaches; first-match-wins means only the first executes.",
         ],
         mutable_after_publish: false,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7"],
     },
     {
         id: "machine_forward_guard",
-        name: "工作流节点推进验证（Forward.guard）",
+        name: "Workflow node advancement validation (Forward.guard)",
         host_object: "Machine",
         binding_field: "Forward.guard",
-        validation_scene: "客户或商家执行 Forward 操作推进工作流时，Guard 验证是否允许推进到下一节点",
-        pass_result: "Progress 推进到 next_node，session 累计权重",
-        fail_result: "Forward 阻塞，Progress 停留在当前节点。可选 retained_submission 留存审计数据",
-        submission_source: "执行 Forward 的一方（Customer 或 Provider，取决于 Forward 配置）",
+        validation_scene: "When a customer or provider executes a Forward operation to advance the workflow, the Guard validates whether advancement to the next node is allowed",
+        pass_result: "Progress advances to next_node; session accumulates weight",
+        fail_result: "Forward is blocked; Progress stays at the current node. Optional retained_submission retains audit data",
+        submission_source: "The party executing Forward (Customer or Provider, depending on Forward configuration)",
         special_constraints: [
-            "Machine 发布后 Forward.guard 不可修改（需新建 Machine）",
-            "可选 retained_submission：将提交数据存入 Progress 供后续审计",
-            "retained_submission 索引必须与 Guard table 对应",
-            "常用 query: progress.current_node, progress.session_forward, order.service 等",
-            "时间锁：context(Clock) + calc_number_add(progress.entry_time, duration) 测试用 1000ms",
+            "Forward.guard cannot be modified after Machine is published (a new Machine must be created)",
+            "Optional retained_submission: stores submission data in Progress for later audit",
+            "retained_submission indices must correspond to the Guard table",
+            "Common queries: progress.current_node, progress.session_forward, order.service, etc.",
+            "Time lock: context(Clock) + calc_number_add(progress.entry_time, duration) tested with 1000ms",
+            "Reentrancy: ALLOWED — By design, Forward moves progress.current_node to next_node (progress.move L443), naturally invalidating the Guard at the old node. Re-submission at the SAME node (before forward completes) is intentional: users may fix prior submission data or accumulate session weight toward threshold. No anti-reentrancy primitive needed. Optional observability queries: `progress.session_forward` (1262), `progress.history` (1273), `query_progress_history_find` (1274)",
         ],
         common_patterns: [
-            "身份检查：context(Signer) + logic_equal（只有特定方可推进）",
-            "时间锁：context(Clock) + calc_number_add + logic_as_u256_greater_or_equal",
-            "前置 Forward 完成：query_progress_history_find + logic_equal(accomplished=true)",
-            "提交数据验证：identifier(submission) + logic_equal(expected_value)",
-            "跨对象查询：convert_witness=TypeOrderProgress(100) 从 Order 查 Progress",
+            "Identity check: context(Signer) + logic_equal (only specific parties can advance)",
+            "Time lock: context(Clock) + calc_number_add + logic_as_u256_greater_or_equal",
+            "Prior Forward completion: query_progress_history_find + logic_equal(accomplished=true)",
+            "Submission data validation: identifier(submission) + logic_equal(expected_value)",
+            "Cross-object query: convert_witness=TypeOrderProgress(100) queries Progress from Order",
         ],
         mutable_after_publish: false,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7", "R8", "R9"],
     },
     {
         id: "progress_submission_guard",
-        name: "Progress 提交数据验证（submission guard）",
+        name: "Progress submission data validation (submission guard)",
         host_object: "Progress",
         binding_field: "submission",
-        validation_scene: "Forward 执行时提交的数据（如签名、凭证、确认）是否满足 Guard 条件",
-        pass_result: "Forward 完成，session 累计权重达到阈值后推进节点",
-        fail_result: "Forward 不完成，等待重新提交或满足条件",
-        submission_source: "提交数据的一方（Customer 或 Provider）",
+        validation_scene: "Whether the data (e.g. signature, credential, confirmation) submitted during Forward execution satisfies the Guard condition",
+        pass_result: "Forward completes; node advances after session accumulates weight to threshold",
+        fail_result: "Forward does not complete; waits for resubmission or condition satisfaction",
+        submission_source: "The party submitting data (Customer or Provider)",
         special_constraints: [
-            "与 Forward.guard 协同：Forward.guard 验证资格，submission guard 验证数据",
-            "retained_submission 将提交数据存入 Progress session 供审计",
-            "常用 query: progress.session_forward, progress.session_weight 等",
+            "Works in concert with Forward.guard: Forward.guard validates eligibility, submission guard validates data",
+            "retained_submission stores submission data in Progress session for audit",
+            "Common queries: progress.session_forward, progress.session_weight, etc.",
+            "Reentrancy: ALLOWED — Multiple submissions accumulate session weight toward threshold by design (progress.move session_accomplish_imp). Re-submission is the intended mechanism for reaching threshold; no anti-reentrancy primitive needed",
         ],
         common_patterns: [
-            "签名验证：identifier(signature_submission) + logic_equal(expected)",
-            "凭证验证：query(Repository.data) + logic_equal(submission_proof)",
-            "确认验证：identifier(confirm_submission) + logic_equal(true)",
+            "Signature validation: identifier(signature_submission) + logic_equal(expected)",
+            "Credential validation: query(Repository.data) + logic_equal(submission_proof)",
+            "Confirmation validation: identifier(confirm_submission) + logic_equal(true)",
         ],
         mutable_after_publish: false,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R8"],
     },
     {
         id: "reward_guard",
-        name: "奖励领取验证（Reward.guard）",
+        name: "Reward claim validation (Reward.guard)",
         host_object: "Reward",
         binding_field: "guard",
-        validation_scene: "用户领取奖励池时，Guard 验证是否有资格领取",
-        pass_result: "奖励发放给 Claimant，记录到 reward_record",
-        fail_result: "领取拒绝，奖励不发",
-        submission_source: "Claimant（address、credentials、Passport）",
+        validation_scene: "When a user claims from a reward pool, the Guard validates eligibility to claim",
+        pass_result: "Reward is distributed to the Claimant and recorded in reward_record",
+        fail_result: "Claim rejected; reward is not distributed",
+        submission_source: "Claimant (address, credentials, Passport)",
         special_constraints: [
-            "常用 query_reward_record_count 防重复领取（one-time claim）",
-            "Guard 通常查询历史记录 + 时间条件 + 身份验证",
-            "如果 Reward 引用 Service，使用循环引用模式",
+            "Common query_reward_record_count prevents duplicate claims (one-time claim)",
+            "Guard usually queries history records + time conditions + identity validation",
+            "If the Reward references a Service, use the circular reference pattern",
+            "Reentrancy: CRITICAL — Guard pass distributes reward funds to the Claimant AND creates a reward_record, but the Guard conditions (identity, time, node state) do NOT naturally invalidate after a claim. Without an explicit anti-reentrancy primitive, the same Claimant can repeatedly pass the Guard and DRAIN THE ENTIRE POOL. This is the most severe reentrancy scene. REQUIRED anti-reentrancy primitive (any one): `reward.record has` (query 1613, Bool) + `logic_not`; OR `reward.record count` (query 1612, U64) + `logic_equal(0)`; OR `reward.record.find_first` (query 1626, U64) + `logic_not`/`logic_equal(0)`. Reference template: MyShop_Advanced Guard 7 condition 4 — `logic_not(query_reward_record_exists(where.storeFromId=order_id))`",
         ],
         common_patterns: [
-            "一次性领取：query_reward_record_count(recipient) + logic_equal(0)",
-            "时间窗口：context(Clock) + logic_as_u256_greater_or_equal(start_time)",
-            "身份验证：context(Signer) + vec_contains_address(allowlist)",
-            "多条件：logic_and（身份 + 时间 + 未领取过）",
+            "One-time claim: query_reward_record_count(recipient) + logic_equal(0)",
+            "Time window: context(Clock) + logic_as_u256_greater_or_equal(start_time)",
+            "Identity validation: context(Signer) + vec_contains_address(allowlist)",
+            "Multi-condition: logic_and (identity + time + not claimed before)",
         ],
         mutable_after_publish: true,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R7", "R8", "R9"],
     },
     {
         id: "repository_write_guard",
-        name: "存储写入验证（write_guard）",
+        name: "Repository write validation (write_guard)",
         host_object: "Repository",
         binding_field: "write_guard",
-        validation_scene: "写入链上存储时，Guard 验证写入资格并可选提取数据",
-        pass_result: "写入成功；可选 id_from_submission 提取 entity ID，data_from_submission 提取数据值",
-        fail_result: "写入拒绝",
+        validation_scene: "When writing to on-chain storage, the Guard validates write eligibility and optionally extracts data",
+        pass_result: "Write succeeds; optional id_from_submission extracts the entity ID, data_from_submission extracts the data value",
+        fail_result: "Write rejected",
         submission_source: "Writer/Reader",
         special_constraints: [
-            "id_from_submission 引用的 table 条目必须是 Address 类型",
-            "data_from_submission 引用的 table 条目必须匹配 Repository 的 value_type",
-            "类型不匹配导致写入失败或数据损坏",
-            "常用于 oracle 数据写入、第三方凭证存证等场景",
+            "The table entry referenced by id_from_submission must be of Address type",
+            "The table entry referenced by data_from_submission must match the Repository's value_type",
+            "Type mismatch leads to write failure or data corruption",
+            "Commonly used for oracle data writes, third-party credential attestation, etc.",
+            "Reentrancy: LOW — Default writes are idempotent (same ID overwrites, different ID appends); no fund flow. IF business intent is 'one write per ID' (e.g. voting, immutable credential, single-attestation), an anti-reentrancy check is needed. Optional primitive: `repository.data has` (query 1166, Bool) + `logic_not`",
         ],
         common_patterns: [
-            "授权写入者：context(Signer) + vec_contains_address(authorized_writers)",
-            "数据格式验证：identifier(data_submission) + logic_string_contains(expected_prefix)",
-            "ID 提取：id_from_submission + data_from_submission 组合",
+            "Authorized writer: context(Signer) + vec_contains_address(authorized_writers)",
+            "Data format validation: identifier(data_submission) + logic_string_contains(expected_prefix)",
+            "ID extraction: id_from_submission + data_from_submission combination",
         ],
         mutable_after_publish: true,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7"],
     },
     {
         id: "arbitration_usage_guard",
-        name: "争议发起验证（usage_guard）",
+        name: "Dispute initiation validation (usage_guard)",
         host_object: "Arbitration",
         binding_field: "usage_guard",
-        validation_scene: "客户对订单发起争议时，Guard 验证客户是否有资格发起争议",
-        pass_result: "创建 Arb 案件，进入仲裁流程",
-        fail_result: "争议拒绝，Arb 不创建",
-        submission_source: "Customer（Passport credential）",
+        validation_scene: "When a customer initiates a dispute against an order, the Guard validates whether the customer is eligible to initiate the dispute",
+        pass_result: "Create an Arb case and enter the arbitration flow",
+        fail_result: "Dispute rejected; Arb is not created",
+        submission_source: "Customer (Passport credential)",
         special_constraints: [
-            "Arbitration bPaused=true 时优先阻塞（先于 Guard 检查）",
-            "客户需先生成 Passport（gen_passport 通过 usage_guard）",
-            "常用 query: order.completed, order.service, entity.has 等",
-            "Guard 验证客户身份 + 订单状态 + 争议资格",
+            "When Arbitration bPaused=true, it blocks first (before the Guard check)",
+            "The customer must first generate a Passport (gen_passport passes usage_guard)",
+            "Common queries: order.completed, order.service, entity.has, etc.",
+            "Guard validates customer identity + order status + dispute eligibility",
+            "Reentrancy: HIGH — Guard pass creates a new Arb case. Without anti-reentrancy, a customer can create multiple Arb cases for the SAME Order (up to MAX_DISPUTE_COUNT=10 per order.move L96), harassing the counterparty and inflating arbitration system load. Not direct fund loss, but severe system abuse. Note: order::dispute (order.move L93-99) deduplicates by Arb address but does NOT prevent multiple distinct Arbs for the same Order. REQUIRED anti-reentrancy primitive (any one): `order.dispute has` (query 1565, Bool, per-Arb check) + `logic_not`; OR `order.dispute count` (query 1564, U64) + `logic_equal(0)` (strict: block any prior dispute) or `logic_as_u256_less_or_equal(N)` (lenient: allow up to N disputes)",
         ],
         common_patterns: [
-            "订单状态验证：query(Order.status) + logic_equal('completed')",
-            "会员验证：query(EntityRegistrar) + logic_and",
-            "时间窗口：query(Order.time) + calc_number_add + context(Clock)",
-            " Passport 凭证：identifier(passport_submission) + context(Signer)",
+            "Order status validation: query(Order.status) + logic_equal('completed')",
+            "Membership validation: query(EntityRegistrar) + logic_and",
+            "Time window: query(Order.time) + calc_number_add + context(Clock)",
+            "Passport credential: identifier(passport_submission) + context(Signer)",
         ],
         mutable_after_publish: true,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R7", "R8", "R9"],
     },
     {
         id: "arbitration_voting_guard",
-        name: "仲裁投票权重验证（voting_guard[]）",
+        name: "Arbitration voting weight validation (voting_guard[])",
         host_object: "Arbitration",
         binding_field: "voting_guard",
-        validation_scene: "仲裁员投票时，Guard 验证投票资格并从 GuardIdentifier 提取投票权重（u32）",
-        pass_result: "投票计入，权重为 GuardIdentifier 提取的数值",
-        fail_result: "投票拒绝",
-        submission_source: "Voter（Passport credential with weight data）",
+        validation_scene: "When an arbitrator votes, the Guard validates voting eligibility and extracts the voting weight (u32) from GuardIdentifier",
+        pass_result: "Vote is counted; weight is the value extracted by GuardIdentifier",
+        fail_result: "Vote rejected",
+        submission_source: "Voter (Passport credential with weight data)",
         special_constraints: [
-            "GuardIdentifier 引用的 table 条目必须是 numeric 类型（U8-U256），cast 为 u32",
-            "非 numeric 类型导致 E_GUARD_IDENTIFIER_NOT_NUMBER 错误",
-            "b_submission 必须 true（权重由 voter 运行时提交）",
-            "可配置多个 voting_guard，每个对应不同投票者群体",
-            "Arbitration bPaused=true 时阻塞投票",
+            "The table entry referenced by GuardIdentifier must be of a numeric type (U8-U256), cast to u32",
+            "Non-numeric types cause E_GUARD_IDENTIFIER_NOT_NUMBER error",
+            "b_submission must be true (weight is submitted at runtime by the voter)",
+            "Multiple voting_guards can be configured, each corresponding to a different voter group",
+            "When Arbitration bPaused=true, voting is blocked",
+            "Reentrancy: CRITICAL — Guard pass counts the vote with the extracted weight. Without anti-reentrancy, the same voter can vote MULTIPLE times, multiplying their weight and skewing the arbitration result (which directly determines fund ownership via compensation). The voter's eligibility (identity, reputation) does NOT naturally invalidate after voting. REQUIRED anti-reentrancy primitive (any one): `arb.voted has` (query 1404, Bool, per-voter) + `logic_not`; OR `arb.voted.agree has` (query 1406, Bool, per-voter-per-proposition) + `logic_not`; OR `arb.voted.agree count` (query 1405, U64, per-voter) + `logic_equal(0)`. Note: `arb.voted_count` (1403) is total voter count (NOT per-voter) and does NOT serve as an anti-reentrancy primitive for individual voters",
         ],
         common_patterns: [
-            "声誉分权重：query(EntityRegistrar.records[reputation]) + GuardIdentifier(u64)",
-            "固定权重：identifier(constant_weight) + GuardIdentifier",
-            "多级投票：不同 voting_guard 对应不同权重等级",
-            "资格 + 权重：logic_and（资格检查 + GuardIdentifier 提取权重）",
+            "Reputation score weight: query(EntityRegistrar.records[reputation]) + GuardIdentifier(u64)",
+            "Fixed weight: identifier(constant_weight) + GuardIdentifier",
+            "Multi-tier voting: different voting_guards correspond to different weight tiers",
+            "Eligibility + weight: logic_and (eligibility check + GuardIdentifier extracts weight)",
         ],
         mutable_after_publish: true,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7", "R8", "R9"],
     },
+    {
+        id: "gen_passport_guard",
+        name: "Passport credential generation validation (gen_passport)",
+        host_object: "Standalone",
+        binding_field: "none",
+        validation_scene: "When a user calls gen_passport, the Guard validates user eligibility and generates a Passport with credentials",
+        pass_result: "Passport is generated, containing credentials validated by the Guard",
+        fail_result: "Passport generation fails; the user did not pass validation",
+        submission_source: "Passport applicant (signer + credentials)",
+        special_constraints: [
+            "impack_list is always empty during the verify phase (only filled after result_for_permission)",
+            "Therefore quote_guard (query 1167) always fails in the gen_passport flow (IMPACK_GUARD_NOT_FOUND)",
+            "Only Repository queries with quote_guard==None can pass in gen_passport",
+            "Guard can be created standalone (not bound to a specific Host Object)",
+            "Guard can be depended on by other Guards via rely (requires rep=true)",
+            "The Passport generated by gen_passport can be used as submission data for subsequent operations",
+            "Reentrancy: LOW — Each gen_passport call generates an independent Passport (one Passport per operation). Multiple Passports for the same user are usually valid (each serves a different subsequent operation). IF business intent is 'one active Passport per user', an anti-reentrancy check is needed but no direct GUARDQUERY primitive exists — use off-chain tracking or a Repository to record issued Passport IDs",
+        ],
+        common_patterns: [
+            "Identity validation: context(Signer) + logic_equal (single address/whitelist)",
+            "Membership eligibility: query(EntityRegistrar) + logic_equal",
+            "Reputation threshold: query(EntityRegistrar.records[reputation]) + logic_as_u256_greater_or_equal",
+            "Multi-condition combination: logic_and (identity + eligibility + reputation)",
+        ],
+        mutable_after_publish: false,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7"],
+    },
 ];
 export function findScene(host_object, binding_field) {
     return GUARD_SCENES.find((s) => s.host_object === host_object &&
@@ -207,6 +247,7 @@ export function inferSceneFromAction(action) {
         dispute: "arbitration_usage_guard",
         write_repository: "repository_write_guard",
         submit_progress: "progress_submission_guard",
+        gen_passport: "gen_passport_guard",
     };
     const id = map[action];
     return GUARD_SCENES.find((s) => s.id === id);