@wowok/agent-mcp 2.3.18 → 2.4.1

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,223 @@
 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)",
         ],
         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)",
         ],
         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",
         ],
         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",
         ],
         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.",
         ],
         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",
         ],
         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.",
         ],
         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",
         ],
         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",
         ],
         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",
+        ],
+        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 +233,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);

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

@@ -0,0 +1,76 @@
+import { type GuardRiskAssessment } from "./guard-risk.js";
+export type DiagnosticSource = "sdk" | "lint" | "risk";
+export type DiagnosticSeverity = "error" | "warning" | "info" | "hint";
+export interface GuardDiagnostic {
+    code: string;
+    message: string;
+    severity: DiagnosticSeverity;
+    source: DiagnosticSource;
+    location: {
+        path: string;
+    };
+    fix?: {
+        description: string;
+        auto_fixable: boolean;
+    };
+}
+export interface GuardJsonInput {
+    description?: string;
+    table: Array<{
+        identifier: number;
+        b_submission?: boolean;
+        value_type?: string;
+        value?: unknown;
+        name?: string;
+        object_type?: string;
+        is_system_address?: boolean;
+    }>;
+    root: any;
+    rely?: {
+        guards: string[];
+        logic_or?: boolean;
+    };
+    binding_hint?: {
+        host_object?: string;
+        binding_field?: string;
+        action?: string;
+    };
+}
+export interface AutoFixAction {
+    diagnostic_code: string;
+    description: string;
+    before?: string;
+    after?: string;
+    path: string;
+}
+export interface GuardLintResult {
+    json_summary: {
+        table_count: number;
+        root_type: string;
+        has_rely: boolean;
+        rely_count: number;
+        has_description: boolean;
+    };
+    diagnostics: GuardDiagnostic[];
+    fixed_json?: GuardJsonInput;
+    fix_actions: AutoFixAction[];
+    risk_assessment?: GuardRiskAssessment;
+    summary: {
+        errors: number;
+        warnings: number;
+        infos: number;
+        auto_fixes_applied: number;
+        ready: boolean;
+        next_step: string;
+    };
+}
+export declare function autoFixGuard(json: GuardJsonInput): {
+    fixed: GuardJsonInput;
+    actions: AutoFixAction[];
+};
+export declare function lintGuard(json: GuardJsonInput, options?: {
+    auto_fix?: boolean;
+}): Promise<GuardLintResult>;
+export declare function isGuardReady(json: GuardJsonInput): Promise<boolean>;
+export declare function getGuardErrors(json: GuardJsonInput): Promise<GuardDiagnostic[]>;
+export declare function formatLintResult(result: GuardLintResult): string;