@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/knowledge/guard-translation.js

@@ -0,0 +1,487 @@
+export const SEMANTIC_TO_SCHEMA_RULES = [
+    {
+        id: "A01_identity_single",
+        pattern_name: "身份检查（单地址）",
+        semantic_intent: "只有地址 X 能执行此操作",
+        match_keywords: ["只有", "允许", "授权", "身份", "指定地址", "签名者"],
+        schema_elements: {
+            root_type: "logic_equal",
+            table_entries: [
+                { value_type: "Address", b_submission: false, purpose: "授权地址常量" },
+            ],
+            tree_structure: "logic_equal(context(Signer), identifier[0])",
+        },
+        constraints: [
+            "root 必须 logic_equal（返回 Bool）",
+            "table[0] 必须 Address 类型，b_submission=false",
+            "context(Signer) 返回当前交易签名者地址",
+        ],
+        example: {
+            root: {
+                type: "logic_equal",
+                nodes: [
+                    { type: "context", context: "Signer" },
+                    { type: "identifier", identifier: 0 },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: false, value_type: "Address", value: "0xabc...", name: "授权操作者地址" },
+            ],
+        },
+    },
+    {
+        id: "A02_identity_allowlist",
+        pattern_name: "身份检查（白名单）",
+        semantic_intent: "白名单中的地址可以执行此操作",
+        match_keywords: ["白名单", "多个地址", "列表", "允许列表", "名单"],
+        schema_elements: {
+            root_type: "vec_contains_address",
+            table_entries: [
+                { value_type: "VecAddress", b_submission: false, purpose: "授权地址列表" },
+            ],
+            tree_structure: "vec_contains_address(identifier[0], context(Signer))",
+        },
+        constraints: [
+            "root vec_contains_address 返回 Bool",
+            "table[0] 必须 VecAddress 类型",
+            "context(Signer) 作为被查找的元素",
+        ],
+        example: {
+            root: {
+                type: "vec_contains_address",
+                nodes: [
+                    { type: "identifier", identifier: 0 },
+                    { type: "context", context: "Signer" },
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: false, value_type: "VecAddress", value: ["0xabc...", "0xdef..."], name: "授权地址白名单" },
+            ],
+        },
+    },
+    {
+        id: "A03_time_lock",
+        pattern_name: "时间锁",
+        semantic_intent: "等待 N 毫秒后才能执行此操作",
+        match_keywords: ["等待", "时间", "锁定", "延迟", "小时", "天", "毫秒"],
+        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）" },
+            ],
+            query_nodes: [
+                { query_name: "progress.session.time", object_type: "Progress", convert_witness: 100 },
+            ],
+            tree_structure: "logic_as_u256_greater_or_equal(context(Clock), calc_number_add(query(progress.time, witness=100), 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，自动宽展",
+        ],
+        example: {
+            root: {
+                type: "logic_as_u256_greater_or_equal",
+                nodes: [
+                    { type: "context", context: "Clock" },
+                    {
+                        type: "calc_number_add",
+                        nodes: [
+                            {
+                                type: "query",
+                                query: "progress.session.time",
+                                object: { identifier: 0, convert_witness: 100 },
+                                parameters: [],
+                            },
+                            { type: "identifier", identifier: 1 },
+                        ],
+                    },
+                ],
+            },
+            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: "锁定时长（毫秒）" },
+            ],
+        },
+    },
+    {
+        id: "A04_progress_state",
+        pattern_name: "进度状态检查",
+        semantic_intent: "订单进度达到指定节点才能执行此操作",
+        match_keywords: ["进度", "节点", "状态", "完成", "到达", "当前节点"],
+        schema_elements: {
+            root_type: "logic_equal",
+            table_entries: [
+                { value_type: "Address", b_submission: true, purpose: "目标 Order 地址" },
+                { value_type: "String", b_submission: false, purpose: "期望的节点名称" },
+            ],
+            query_nodes: [
+                { query_name: "progress.current_node_name", object_type: "Progress", convert_witness: 100 },
+            ],
+            tree_structure: "logic_equal(query(progress.node, witness=100, identifier[0]), identifier[1])",
+        },
+        constraints: [
+            "query 返回 String，identifier[1] 必须 String 类型",
+            "logic_equal 比较 String 时大小写敏感",
+            "如需大小写不敏感，使用 logic_string_nocase_equal",
+            "convert_witness=100 (TypeOrderProgress) 从 Order 转换",
+        ],
+        example: {
+            root: {
+                type: "logic_equal",
+                nodes: [
+                    {
+                        type: "query",
+                        query: "progress.current_node_name",
+                        object: { identifier: 0, convert_witness: 100 },
+                        parameters: [],
+                    },
+                    { type: "identifier", identifier: 1 },
+                ],
+            },
+            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: "期望的进度节点名" },
+            ],
+        },
+    },
+    {
+        id: "A05_one_time_claim",
+        pattern_name: "一次性领取检查",
+        semantic_intent: "用户只能领取一次奖励",
+        match_keywords: ["一次", "领取", "重复", "已领", "领取过"],
+        schema_elements: {
+            root_type: "logic_equal",
+            table_entries: [
+                { value_type: "Address", b_submission: true, purpose: "Reward 对象地址" },
+                { value_type: "Address", b_submission: false, purpose: "领取者地址（从 context 派生）" },
+            ],
+            query_nodes: [
+                { query_name: "reward.record.count", object_type: "Reward" },
+            ],
+            tree_structure: "logic_equal(query_reward_record_count(identifier[0], identifier[1]), constant(0))",
+        },
+        constraints: [
+            "query_reward_record_count 返回 U64",
+            "比较 count == 0 表示无历史记录（可领取）",
+            "identifier[1] 可用 context(Signer) 替代",
+        ],
+        example: {
+            root: {
+                type: "logic_equal",
+                nodes: [
+                    {
+                        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）" },
+            ],
+        },
+    },
+    {
+        id: "A06_multi_condition_and",
+        pattern_name: "多条件组合（AND）",
+        semantic_intent: "多个条件必须同时满足",
+        match_keywords: ["并且", "同时", "都满足", "AND", "且", "还需要"],
+        schema_elements: {
+            root_type: "logic_and",
+            table_entries: [],
+            tree_structure: "logic_and([condition1, condition2, ...])",
+        },
+        constraints: [
+            "logic_and 所有子节点必须返回 Bool",
+            "子节点数量 2-8（MAX_MULTI_OPERANDS）",
+            "每个子条件可以是任何返回 Bool 的节点",
+        ],
+        example: {
+            root: {
+                type: "logic_and",
+                nodes: [
+                    {},
+                    {},
+                ],
+            },
+        },
+    },
+    {
+        id: "A07_multi_condition_or",
+        pattern_name: "多条件组合（OR）",
+        semantic_intent: "任一条件满足即可",
+        match_keywords: ["或者", "任一", "OR", "或", "之一"],
+        schema_elements: {
+            root_type: "logic_or",
+            table_entries: [],
+            tree_structure: "logic_or([condition1, condition2, ...])",
+        },
+        constraints: [
+            "logic_or 所有子节点必须返回 Bool",
+            "子节点数量 2-8",
+            "等价于 rely.logic_or=true（如果使用 rely 组合）",
+        ],
+        example: {
+            root: {
+                type: "logic_or",
+                nodes: [
+                    {},
+                    {},
+                ],
+            },
+        },
+    },
+    {
+        id: "A08_dynamic_weight",
+        pattern_name: "动态投票权重",
+        semantic_intent: "投票权重等于用户声誉分（从提交数据提取）",
+        match_keywords: ["权重", "投票", "声誉", "分数", "voting", "weight"],
+        schema_elements: {
+            root_type: "logic_and",
+            table_entries: [
+                { value_type: "Address", b_submission: true, purpose: "投票者地址" },
+                { value_type: "U64", b_submission: true, purpose: "投票者权重（GuardIdentifier 提取）" },
+            ],
+            query_nodes: [
+                { query_name: "entity.records.value", object_type: "EntityRegistrar" },
+            ],
+            tree_structure: "logic_and(资格检查, GuardIdentifier 提取权重[1])",
+        },
+        constraints: [
+            "GuardIdentifier 引用的 table 条目必须 numeric (U8-U256)",
+            "b_submission 必须 true（权重由 voter 运行时提交）",
+            "非 numeric 类型导致 E_GUARD_IDENTIFIER_NOT_NUMBER 错误",
+            "权重值 cast 为 u32",
+        ],
+        example: {
+            root: {
+                type: "logic_and",
+                nodes: [
+                    {},
+                    {},
+                ],
+            },
+            table: [
+                { identifier: 0, b_submission: true, value_type: "Address", name: "投票者地址" },
+                { identifier: 1, b_submission: true, value_type: "U64", name: "投票者权重（从声誉分提取）" },
+            ],
+        },
+    },
+];
+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" },
+];
+export const GUARD_CONSTRAINT_RULES = [
+    {
+        id: "ROOT_01",
+        name: "root 返回 Bool",
+        description: "Guard root 节点必须返回 Bool 类型",
+        category: "root",
+        validation_logic: "root.node_type 必须在 allowedTypes 列表中（logic_*, calc_string_contains, vec_contains_*, query_reward_record_exists, query[Bool返回], identifier[Bool类型]）",
+        failure_message: "Guard root node must be an operation that returns Bool",
+        pitfall_number: 7,
+    },
+    {
+        id: "TABLE_01",
+        name: "identifier 唯一性",
+        description: "table 中每个 identifier 必须唯一（0-255）",
+        category: "table",
+        validation_logic: "table 中无重复 identifier",
+        failure_message: "Duplicate table identifier",
+    },
+    {
+        id: "TABLE_02",
+        name: "identifier 引用完整性",
+        description: "计算树中每个 identifier 节点必须在 table 中存在",
+        category: "table",
+        validation_logic: "遍历计算树，每个 identifier 节点的 index 在 table 中存在",
+        failure_message: "Identifier not found in table",
+        pitfall_number: 1,
+    },
+    {
+        id: "TABLE_03",
+        name: "常量条目必须有值",
+        description: "b_submission=false 的条目必须有 value 字段",
+        category: "table",
+        validation_logic: "所有 b_submission=false 的条目 value 字段非空",
+        failure_message: "Constant table entry must have a value",
+    },
+    {
+        id: "TABLE_04",
+        name: "table 大小限制",
+        description: "最多 256 条目，序列化后不超过 40000 字节",
+        category: "table",
+        validation_logic: "table.length <= 256 && serialize(table).length <= 40000",
+        failure_message: "Table exceeds size limit (256 entries or 40000 bytes)",
+    },
+    {
+        id: "QUERY_01",
+        name: "query 指令有效",
+        description: "query 节点的 query 字段必须是有效的 GUARDQUERY ID 或 name",
+        category: "query",
+        validation_logic: "query 字段在 GUARDQUERY 中存在（通过 isValidGuardQueryIdOrName）",
+        failure_message: "Invalid Guard query instruction",
+        pitfall_number: 3,
+    },
+    {
+        id: "QUERY_02",
+        name: "query 参数匹配",
+        description: "query 节点的 parameters 数量和类型必须匹配指令定义",
+        category: "query",
+        validation_logic: "parameters.length === instruction.parameters.length && 类型兼容",
+        failure_message: "Query parameter count or type mismatch",
+        pitfall_number: 3,
+    },
+    {
+        id: "QUERY_03",
+        name: "query object 类型匹配",
+        description: "query object 的 object_type 必须匹配指令的 objectType",
+        category: "query",
+        validation_logic: "table[object.identifier].object_type === instruction.objectType（考虑 witness 转换）",
+        failure_message: "Query object type mismatch",
+    },
+    {
+        id: "WITNESS_01",
+        name: "witness 类型有效",
+        description: "convert_witness 必须是有效的 WitnessType (100-108)",
+        category: "witness",
+        validation_logic: "witness 值在 WitnessTypeSchema 允许范围内",
+        failure_message: "Invalid witness type",
+        pitfall_number: 4,
+    },
+    {
+        id: "WITNESS_02",
+        name: "witness source-target 匹配",
+        description: "witness 的 source type 必须匹配 table 条目 object_type，target type 必须匹配 query objectType",
+        category: "witness",
+        validation_logic: "table[identifier].object_type === witness.source_type && instruction.objectType === witness.target_type",
+        failure_message: "Witness source/target type mismatch",
+        pitfall_number: 4,
+    },
+    {
+        id: "RELY_01",
+        name: "rely 依赖数量",
+        description: "rely.guards 最多 4 个依赖",
+        category: "rely",
+        validation_logic: "rely.guards.length <= 4",
+        failure_message: "Rely dependencies exceed limit (4)",
+    },
+    {
+        id: "RELY_02",
+        name: "rely 依赖 rep=true",
+        description: "所有 rely 依赖的 Guard 必须 rep=true（无 Repository 依赖）",
+        category: "rely",
+        validation_logic: "查询每个依赖 Guard 的 rep 字段，必须为 true",
+        failure_message: "Rely dependency has rep=false (not standalone)",
+        pitfall_number: 8,
+    },
+    {
+        id: "BINDING_01",
+        name: "voting_guard GuardIdentifier numeric",
+        description: "Arbitration voting_guard 的 GuardIdentifier 引用的 table 条目必须 numeric 类型",
+        category: "binding",
+        validation_logic: "如果 binding=voting_guard，GuardIdentifier 指向的 table 条目 value_type 在 [U8,U16,U32,U64,U128,U256] 中",
+        failure_message: "E_GUARD_IDENTIFIER_NOT_NUMBER: voting_guard weight must be numeric",
+        pitfall_number: 9,
+    },
+    {
+        id: "BINDING_02",
+        name: "Repository id_from_submission Address",
+        description: "Repository write_guard 的 id_from_submission 引用的 table 条目必须 Address 类型",
+        category: "binding",
+        validation_logic: "如果 binding=write_guard 且 id_from_submission 设置，table[id_from_submission].value_type === Address",
+        failure_message: "Repository id_from_submission must be Address type",
+    },
+    {
+        id: "BINDING_03",
+        name: "Repository data_from_submission 类型匹配",
+        description: "Repository write_guard 的 data_from_submission 引用的 table 条目必须匹配 Repository value_type",
+        category: "binding",
+        validation_logic: "如果 binding=write_guard 且 data_from_submission 设置，table[data_from_submission].value_type === Repository.value_type",
+        failure_message: "Repository data_from_submission type mismatch",
+    },
+];
+export function matchSemanticPattern(userIntent) {
+    const lower = userIntent.toLowerCase();
+    return SEMANTIC_TO_SCHEMA_RULES.filter((rule) => rule.match_keywords.some((kw) => lower.includes(kw.toLowerCase())));
+}
+export function explainNode(nodeType) {
+    return SCHEMA_TO_SEMANTIC_RULES.find((r) => r.element_type === "node" && r.type_name === nodeType);
+}
+export function explainWitness(witnessType) {
+    const witnessMap = {
+        100: "TypeOrderProgress",
+        101: "TypeOrderMachine",
+        102: "TypeOrderService",
+        103: "TypeProgressMachine",
+        104: "TypeArbOrder",
+        105: "TypeArbArbitration",
+        106: "TypeArbProgress",
+        107: "TypeArbMachine",
+        108: "TypeArbService",
+    };
+    const name = witnessMap[witnessType];
+    return SCHEMA_TO_SEMANTIC_RULES.find((r) => r.element_type === "witness" && r.type_name === name);
+}
+export function getConstraintsByCategory(category) {
+    return GUARD_CONSTRAINT_RULES.filter((r) => r.category === category);
+}

package/dist/knowledge/index.d.ts

@@ -0,0 +1,77 @@
+import { CONCEPT_GLOSSARY, CONCEPT_GLOSSARY_VERSION, resolveTerm, lookupEntry, validateText, auditSchemaFields, type GlossaryEntry, type GlossaryCategory, type GlossaryDrift } from "./glossary.js";
+import { CONFIRMATION_RULES, SAFETY_RULES_VERSION, type ConfirmationRule, type OperationPreview, type ConfirmLevel } from "./safety-rules.js";
+import { TOOL_CONSTRAINTS, TOOL_CONSTRAINTS_VERSION, validateOperation, hasBlockingViolations, getWarningViolations, type ConstraintSeverity, type FieldConstraint, type OperationConstraint, type ConstraintViolation } from "./tool-constraints.js";
+import { PERMISSION_TYPES, GAME_ELEMENTS, getPermissionType, getGameElement, getGameElementsByType, PROCESS_MODEL_VERSION, type PermissionScope, type PermissionTypeDef, type GameElementType, type GameElementDef } from "./process-model.js";
+import { computeTrustScore, quickRiskAssessment, ARBITRATION_TRUST_VERSION, type ArbMetrics, type TrustScore, type TrustComponent } from "./arbitration-trust.js";
+import { REWARD_TEMPLATES, REWARD_TEMPLATES_VERSION, getRewardTemplate, listRewardTemplates, suggestRewardTemplate, type RewardTemplateType, type RewardTemplate } from "./reward-templates.js";
+import { AUDIT_RULES, AUDIT_RULES_VERSION, auditService, hasBlockingErrors, getErrors, getWarnings, summarizeFindings, type AuditSeverity, type AuditFinding, type AuditRule, type AuditContext } from "./audit-rules.js";
+import { matchDemand, extractDemandInfo, DEMAND_MATCHING_VERSION, type ServiceInfo, type DemandInfo, type DemandMatch } from "./demand-matching.js";
+import { suggestPricing, getMutableFields, getMutableField, MUTABLE_FIELDS, DYNAMIC_PRICING_VERSION, type MarketSignals, type PricingSuggestion, type MutableFieldInfo } from "./dynamic-pricing.js";
+import { computeServiceTrustScore, quickTrustCheck, TRUST_METRICS_VERSION, type ServiceTrustMetrics, type ServiceTrustScore, type TrustDimension } from "./trust-metrics.js";
+import { buildReviewRepositorySetup, computeReviewStats, isVerifiedReview, filterVerifiedReviews, detectReviewManipulation, REPUTATION_RULES_VERSION, type Review, type ReviewStats, type ReviewRepositorySetup } from "./reputation-rules.js";
+import { INDUSTRY_FLYWHEELS, getFlywheelForIndustry, listIndustries, suggestAcquisitionActions, generateTrustDescription, buildAcquisitionDashboard, ACQUISITION_FLYWHEEL_VERSION, type FlywheelAction, type AcquisitionFlywheel, type TrustDescriptionParams, type AcquisitionDashboard } from "./acquisition-flywheel.js";
+import { INDUSTRY_REGISTRY_VERSION, type IndustryTraits, type IndustryProfile, type IndustrySource, type IndustryEvolutionMeta, type ExtendedIndustry, getIndustryProfile, registerIndustry, getIndustryTraits, resolveIndustryName, getRegistrySize, listBuiltinIndustryNames } from "./industry-registry.js";
+import { DEFAULT_TRAITS, inferTraitsFromDescription, synthesizeProfile, findSimilarIndustries, composeIndustries, type TraitInferenceResult, type SimilarIndustryMatch } from "./industry-generalizer.js";
+import { INDUSTRY_EVOLUTION_THRESHOLDS, aggregateIndustryMetrics, evaluateIndustryHealth, suggestIndustryUpdate, applyIndustryUpdate, runIndustryHealthPipeline, type IndustryMetrics, type OrderRawDataPoint, type IndustryHealthReport, type TraitDrift, type IndustryUpdateSuggestion } from "./industry-evolution.js";
+import { FLYWHEEL_LOOP_VERSION, FLYWHEEL_LOOP_MIN_SIGNALS, EVOLUTION_STATE_VERSION, recordIndustrySignal, updateIndustryCognition, injectEvolutionContext, getIndustryEvolutionStatus, getIndustrySignalCount, getIndustrySignals, listIndustriesWithSignals, getPendingSuggestions, recordDecisionContext, queryDecisionsByIndustry, queryDecisionsByNode, backfillDecisionOutcome, setEvolutionSchedule, getEvolutionSchedule, setIndustryIntent, getIndustryIntent, saveEvolutionState, loadEvolutionState, hasPersistedEvolutionState, type IndustrySignal, type DecisionContext, type CognitionUpdateResult, type EvolutionContext, type IndustryEvolutionStatus, type EvolutionScheduleConfig, type EvolutionScheduleMode } from "./flywheel-loop.js";
+import { BUILTIN_INTENT_SPECS, registerIntentProfile, getIntentProfile, listIntents, evaluateIndustryHealthByIntent, suggestIndustryUpdateByIntent, evaluateIndustryHealthMultiIntent, getRoleAdvice, filterSuggestionsByRole, type BusinessIntent, type MetricDimension, type IntentMetricSpec, type IntentSuggestionTrigger, type AdviceRole } from "./intent-metrics.js";
+import { GUARD_SCENES, findScene, inferSceneFromAction, getImmutableScenes, getNumericIdentifierScenes, type GuardScene } from "./guard-ledger.js";
+import { SEMANTIC_TO_SCHEMA_RULES, SCHEMA_TO_SEMANTIC_RULES, GUARD_CONSTRAINT_RULES, matchSemanticPattern, explainNode, explainWitness, getConstraintsByCategory, type SemanticToSchemaRule, type SchemaToSemanticRule, type GuardConstraintRule } from "./guard-translation.js";
+import { checkPuzzleCompleteness, generateConfirmationText, initPuzzleFromIntent, inferBindingFromAction, type GuardPuzzle, type IntentPuzzle, type BindingPuzzle, type DataEntryPuzzle, type QueryPuzzle, type LogicNodePuzzle, type ConstraintChecklist, type PuzzleCompleteness, type PuzzleDimension } from "./guard-puzzle.js";
+import { assessGuardRisks, assessGuardRisksForOperation, getRiskSummary, type GuardRisk, type GuardRiskAssessment, type GuardStakeholder, type RiskLevel, type RiskCategory } from "./guard-risk.js";
+export { CONCEPT_GLOSSARY, CONCEPT_GLOSSARY_VERSION, resolveTerm, lookupEntry, validateText, auditSchemaFields, type GlossaryEntry, type GlossaryCategory, type GlossaryDrift, };
+export { CONFIRMATION_RULES, SAFETY_RULES_VERSION, type ConfirmationRule, type OperationPreview, type ConfirmLevel, };
+export { TOOL_CONSTRAINTS, TOOL_CONSTRAINTS_VERSION, validateOperation, hasBlockingViolations, getWarningViolations, type ConstraintSeverity, type FieldConstraint, type OperationConstraint, type ConstraintViolation, };
+export { PERMISSION_TYPES, GAME_ELEMENTS, getPermissionType, getGameElement, getGameElementsByType, PROCESS_MODEL_VERSION, type PermissionScope, type PermissionTypeDef, type GameElementType, type GameElementDef, };
+export { computeTrustScore, quickRiskAssessment, ARBITRATION_TRUST_VERSION, type ArbMetrics, type TrustScore, type TrustComponent, };
+export { REWARD_TEMPLATES, REWARD_TEMPLATES_VERSION, getRewardTemplate, listRewardTemplates, suggestRewardTemplate, type RewardTemplateType, type RewardTemplate, };
+export { AUDIT_RULES, AUDIT_RULES_VERSION, auditService, hasBlockingErrors, getErrors, getWarnings, summarizeFindings, type AuditSeverity, type AuditFinding, type AuditRule, type AuditContext, };
+export { matchDemand, extractDemandInfo, DEMAND_MATCHING_VERSION, type ServiceInfo, type DemandInfo, type DemandMatch, };
+export { suggestPricing, getMutableFields, getMutableField, MUTABLE_FIELDS, DYNAMIC_PRICING_VERSION, type MarketSignals, type PricingSuggestion, type MutableFieldInfo, };
+export { computeServiceTrustScore, quickTrustCheck, TRUST_METRICS_VERSION, type ServiceTrustMetrics, type ServiceTrustScore, type TrustDimension, };
+export { buildReviewRepositorySetup, computeReviewStats, isVerifiedReview, filterVerifiedReviews, detectReviewManipulation, REPUTATION_RULES_VERSION, type Review, type ReviewStats, type ReviewRepositorySetup, };
+export { INDUSTRY_FLYWHEELS, getFlywheelForIndustry, listIndustries, suggestAcquisitionActions, generateTrustDescription, buildAcquisitionDashboard, ACQUISITION_FLYWHEEL_VERSION, type FlywheelAction, type AcquisitionFlywheel, type TrustDescriptionParams, type AcquisitionDashboard, };
+export { INDUSTRY_REGISTRY_VERSION, getIndustryProfile, listIndustries as listRegistryIndustries, registerIndustry, getIndustryTraits, resolveIndustryName, getRegistrySize, listBuiltinIndustryNames, type IndustryTraits, type IndustryProfile, type IndustrySource, type IndustryEvolutionMeta, type ExtendedIndustry, };
+export { DEFAULT_TRAITS, inferTraitsFromDescription, synthesizeProfile, findSimilarIndustries, composeIndustries, type TraitInferenceResult, type SimilarIndustryMatch, };
+export { INDUSTRY_EVOLUTION_THRESHOLDS, aggregateIndustryMetrics, evaluateIndustryHealth, suggestIndustryUpdate, applyIndustryUpdate, runIndustryHealthPipeline, type IndustryMetrics, type OrderRawDataPoint, type IndustryHealthReport, type TraitDrift, type IndustryUpdateSuggestion, };
+export { FLYWHEEL_LOOP_VERSION, FLYWHEEL_LOOP_MIN_SIGNALS, EVOLUTION_STATE_VERSION, recordIndustrySignal, updateIndustryCognition, injectEvolutionContext, getIndustryEvolutionStatus, getIndustrySignalCount, getIndustrySignals, listIndustriesWithSignals, getPendingSuggestions, recordDecisionContext, queryDecisionsByIndustry, queryDecisionsByNode, backfillDecisionOutcome, setEvolutionSchedule, getEvolutionSchedule, setIndustryIntent, getIndustryIntent, saveEvolutionState, loadEvolutionState, hasPersistedEvolutionState, type IndustrySignal, type DecisionContext, type CognitionUpdateResult, type EvolutionContext, type IndustryEvolutionStatus, type EvolutionScheduleConfig, type EvolutionScheduleMode, };
+export { BUILTIN_INTENT_SPECS, registerIntentProfile, getIntentProfile, listIntents, evaluateIndustryHealthByIntent, suggestIndustryUpdateByIntent, evaluateIndustryHealthMultiIntent, getRoleAdvice, filterSuggestionsByRole, type BusinessIntent, type MetricDimension, type IntentMetricSpec, type IntentSuggestionTrigger, type AdviceRole, };
+export { GUARD_SCENES, findScene, inferSceneFromAction, getImmutableScenes, getNumericIdentifierScenes, type GuardScene, };
+export { SEMANTIC_TO_SCHEMA_RULES, SCHEMA_TO_SEMANTIC_RULES, GUARD_CONSTRAINT_RULES, matchSemanticPattern, explainNode, explainWitness, getConstraintsByCategory, type SemanticToSchemaRule, type SchemaToSemanticRule, type GuardConstraintRule, };
+export { checkPuzzleCompleteness, generateConfirmationText, initPuzzleFromIntent, inferBindingFromAction, type GuardPuzzle, type IntentPuzzle, type BindingPuzzle, type DataEntryPuzzle, type QueryPuzzle, type LogicNodePuzzle, type ConstraintChecklist, type PuzzleCompleteness, type PuzzleDimension, };
+export { assessGuardRisks, assessGuardRisksForOperation, getRiskSummary, type GuardRisk, type GuardRiskAssessment, type GuardStakeholder, type RiskLevel, type RiskCategory, };
+export declare function getKnowledgeBase(): {
+    version: {
+        glossary: number;
+        safety: number;
+        tool_constraints: number;
+        process_model: number;
+        arbitration_trust: number;
+        reward_templates: number;
+        audit_rules: number;
+        demand_matching: number;
+        dynamic_pricing: number;
+        trust_metrics: number;
+        reputation_rules: number;
+        acquisition_flywheel: number;
+        industry_registry: number;
+        flywheel_loop: number;
+    };
+    glossary_entries: number;
+    confirmation_rules: number;
+    confirmation_rule_ids: string[];
+    tool_constraints_count: number;
+    permission_types_count: number;
+    game_elements_count: number;
+    reward_templates_count: number;
+    audit_rules_count: number;
+    mutable_fields_count: number;
+    industry_flywheels_count: number;
+    industry_registry_count: number;
+    intent_count: number;
+    guard_scenes_count: number;
+    guard_semantic_rules_count: number;
+    guard_schema_rules_count: number;
+    guard_constraint_rules_count: number;
+    guard_risk_rules_count: number;
+};