@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/knowledge/guard-risk.js

@@ -1,367 +1,1693 @@
+import { GUARDQUERY } from "@wowok/wowok";
+function rootStr(ctx) {
+    return JSON.stringify(ctx.root).toLowerCase();
+}
+function hasSignerCheck(ctx) {
+    return JSON.stringify(ctx.root).includes('"Signer"');
+}
+function hasClockCheck(ctx) {
+    return JSON.stringify(ctx.root).includes('"Clock"');
+}
+function hasGuardSelfRef(ctx) {
+    return JSON.stringify(ctx.root).includes('"Guard"');
+}
+function hasWitness(root) {
+    const str = JSON.stringify(root);
+    return str.includes('"convert_witness"');
+}
+function queriesRepository(ctx) {
+    return rootStr(ctx).includes('repository');
+}
+function queriesProgress(ctx) {
+    return rootStr(ctx).includes('progress');
+}
+function extractWitnessCodes(root) {
+    const codes = [];
+    const str = JSON.stringify(root);
+    const matches = str.matchAll(/"convert_witness"\s*:\s*(\d+)/g);
+    for (const m of matches) {
+        const code = parseInt(m[1], 10);
+        if (code >= 100 && code <= 108)
+            codes.push(code);
+    }
+    return codes;
+}
+const WITNESS_CHAIN = {
+    100: ["Order", "Progress"],
+    101: ["Order", "Machine"],
+    102: ["Order", "Service"],
+    103: ["Progress", "Machine"],
+    104: ["Arb", "Order"],
+    105: ["Arb", "Arbitration"],
+    106: ["Arb", "Order", "Progress"],
+    107: ["Arb", "Order", "Service"],
+    108: ["Arb", "Order", "Machine"],
+};
+function extractWitnessIdentifierPairs(root) {
+    const pairs = [];
+    const visited = new WeakSet();
+    function walk(node) {
+        if (node === null || typeof node !== "object")
+            return;
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        if (typeof node.convert_witness === "number" &&
+            typeof node.identifier === "number") {
+            pairs.push({ code: node.convert_witness, identifier: node.identifier });
+        }
+        for (const key of Object.keys(node)) {
+            const child = node[key];
+            if (Array.isArray(child)) {
+                for (const item of child)
+                    walk(item);
+            }
+            else if (child !== null && typeof child === "object") {
+                walk(child);
+            }
+        }
+    }
+    walk(root);
+    return pairs;
+}
+function getChildNodes(node) {
+    if (!node || typeof node !== "object")
+        return [];
+    const children = [];
+    if (Array.isArray(node.nodes))
+        children.push(...node.nodes);
+    if (node.left)
+        children.push(node.left);
+    if (node.right)
+        children.push(node.right);
+    if (node.vec)
+        children.push(node.vec);
+    if (node.target)
+        children.push(node.target);
+    if (node.object && typeof node.object === "object")
+        children.push(node.object);
+    if (Array.isArray(node.parameters))
+        children.push(...node.parameters);
+    return children.filter((c) => c && typeof c === "object");
+}
+function findSignerLogicEqualNodes(root) {
+    const results = [];
+    function walk(node, parentType) {
+        if (!node || typeof node !== "object")
+            return;
+        if (node.type === "logic_equal") {
+            const operands = Array.isArray(node.nodes)
+                ? node.nodes
+                : node.left && node.right
+                    ? [node.left, node.right]
+                    : [];
+            if (operands.length === 2) {
+                const signerIdx = operands.findIndex((op) => op?.type === "context" && op?.context === "Signer");
+                if (signerIdx >= 0) {
+                    results.push({
+                        node,
+                        parentType,
+                        otherOperand: operands[1 - signerIdx],
+                    });
+                }
+            }
+        }
+        for (const child of getChildNodes(node)) {
+            walk(child, node.type);
+        }
+    }
+    walk(root, null);
+    return results;
+}
+function detectLevel1StrictBinding(root, table) {
+    const signerChecks = findSignerLogicEqualNodes(root);
+    for (const check of signerChecks) {
+        const other = check.otherOperand;
+        if (other?.type === "identifier") {
+            const entry = table.find((e) => e.identifier === other.identifier);
+            if (entry &&
+                !entry.b_submission &&
+                entry.value_type === "Address" &&
+                typeof entry.value === "string" &&
+                entry.value.length > 0) {
+                return {
+                    detected: true,
+                    entry: {
+                        identifier: entry.identifier,
+                        value: entry.value,
+                        name: entry.name,
+                    },
+                };
+            }
+        }
+    }
+    return { detected: false };
+}
+function isSignerCheckInLogicOr(root) {
+    const signerChecks = findSignerLogicEqualNodes(root);
+    return signerChecks.some((check) => check.parentType === "logic_or");
+}
+const QUERY_INVARIANT_MAP = (() => {
+    const map = new Map();
+    for (const q of GUARDQUERY) {
+        if (q.invariant !== undefined) {
+            map.set(q.id, q.invariant);
+        }
+    }
+    return map;
+})();
+function extractQueryIds(root) {
+    const ids = [];
+    const str = JSON.stringify(root);
+    const numMatches = str.matchAll(/"query"\s*:\s*(\d+)/g);
+    for (const m of numMatches) {
+        const id = parseInt(m[1], 10);
+        if (!ids.includes(id))
+            ids.push(id);
+    }
+    const nameMatches = str.matchAll(/"query"\s*:\s*"([^"]+)"/g);
+    for (const m of nameMatches) {
+        const name = m[1];
+        const entry = GUARDQUERY.find((q) => q.name === name);
+        if (entry && !ids.includes(entry.id))
+            ids.push(entry.id);
+    }
+    return ids;
+}
+function getQueryInvariant(queryId) {
+    return QUERY_INVARIANT_MAP.get(queryId);
+}
+function rootHasNonZeroQuery(root) {
+    const ids = extractQueryIds(root);
+    return ids.some((id) => QUERY_INVARIANT_MAP.has(id));
+}
+function rootAllQueriesNonZero(root) {
+    const ids = extractQueryIds(root);
+    if (ids.length === 0)
+        return false;
+    return ids.every((id) => QUERY_INVARIANT_MAP.has(id));
+}
+const REENTRANCY_SPECS = [
+    {
+        sceneId: "reward_guard",
+        level: "critical",
+        existsPrimitives: [1613],
+        countPrimitives: [1612],
+        addressPrimitives: [1626],
+        rationale: "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 — direct fund loss.",
+        mitigation: "Add ONE of the following to the root (wrapped in logic_and with existing conditions):\n" +
+            "  - logic_not(query('reward.record has', object=reward, parameters=[claimant_address])) — RECOMMENDED (per-user Bool check)\n" +
+            "  - logic_equal([query('reward.record count', object=reward), identifier(N)]) where table[N].value=0 — total-claim count is 0\n" +
+            "  - logic_not(query('reward.record.find_first', object=reward, where={...})) — no matching record found\n" +
+            "Reference template: MyShop_Advanced Guard 7 condition 4 (logic_not(query_reward_record_exists(where.storeFromId=order_id)))",
+    },
+    {
+        sceneId: "arbitration_voting_guard",
+        level: "critical",
+        existsPrimitives: [1404, 1406],
+        countPrimitives: [1405],
+        addressPrimitives: [],
+        rationale: "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. " +
+            "Note: arb.voted_count (1403) is total voter count (NOT per-voter) and does NOT serve as an anti-reentrancy primitive for an individual voter.",
+        mitigation: "Add ONE of the following to the root (wrapped in logic_and):\n" +
+            "  - logic_not(query('arb.voted has', object=arb, parameters=[voter_address])) — RECOMMENDED (per-voter Bool)\n" +
+            "  - logic_not(query('arb.voted.agree has', object=arb, parameters=[voter_address, proposition_index])) — per-voter-per-proposition\n" +
+            "  - logic_equal([query('arb.voted.agree count', object=arb, parameters=[voter_address]), identifier(N)]) where table[N].value=0",
+    },
+    {
+        sceneId: "arbitration_usage_guard",
+        level: "high",
+        existsPrimitives: [1565],
+        countPrimitives: [1564],
+        addressPrimitives: [],
+        rationale: "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. order::dispute (order.move L93-99) deduplicates by Arb address but does NOT prevent multiple distinct Arbs.",
+        mitigation: "Add ONE of the following to the root (wrapped in logic_and):\n" +
+            "  - logic_not(query('order.dispute has', object=order, parameters=[existing_arb_address])) — per-Arb check\n" +
+            "  - logic_equal([query('order.dispute count', object=order), identifier(N)]) where table[N].value=0 — STRICT: block any prior dispute\n" +
+            "  - logic_as_u256_less_or_equal([query('order.dispute count', object=order), identifier(N)]) where table[N].value=K — LENIENT: allow up to K disputes",
+    },
+    {
+        sceneId: "service_order_allocators_guard",
+        level: "info",
+        existsPrimitives: [1568],
+        countPrimitives: [],
+        addressPrimitives: [1569],
+        rationale: "Protocol-level protection: order::on_allocation (order.move L116-119) asserts ONE Allocation per Order (E_ALLOCATION_ALREADY_SPECIFIED). " +
+            "After alloc() executes, typical Rate-mode allocators (sum=10000) and Surplus-mode allocators drain balance to 0, making reentrancy unprofitable. " +
+            "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() is possible but irrational (attacker funds the Allocation they attack).",
+        mitigation: "Default: no action needed (protocol-level guard). IF using Amount-mode-only allocators without Surplus: " +
+            "consider adding logic_not(query('order.allocation some', object=order)) OR switch to Rate/Surplus mode to drain balance completely.",
+    },
+    {
+        sceneId: "service_buy_guard",
+        level: "info",
+        existsPrimitives: [],
+        countPrimitives: [],
+        addressPrimitives: [],
+        rationale: "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.",
+        mitigation: "IF limit-purchase intent: record purchases in a Repository and add logic_not(query('repository.data has', ...)) to root; " +
+            "OR revoke EntityRegistrar membership after first buy; OR use an off-chain allowlist with on-chain Merkle proof.",
+    },
+    {
+        sceneId: "repository_write_guard",
+        level: "info",
+        existsPrimitives: [1166],
+        countPrimitives: [],
+        addressPrimitives: [],
+        rationale: "Default writes are idempotent (same ID overwrites, different ID appends); no fund flow. " +
+            "IF business intent is 'one write per ID' (voting, immutable credential, single-attestation), an anti-reentrancy check is needed.",
+        mitigation: "IF one-write-per-ID intent: add logic_not(query('repository.data has', object=repository, parameters=[policy_name, user_or_object_id])) to root.",
+    },
+    {
+        sceneId: "gen_passport_guard",
+        level: "info",
+        existsPrimitives: [],
+        countPrimitives: [],
+        addressPrimitives: [],
+        rationale: "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.",
+        mitigation: "IF one-passport-per-user intent: use off-chain tracking or a Repository to record issued Passport IDs.",
+    },
+];
+const QUERY_TYPE_ALIASES = new Map([
+    ["query_reward_record_exists", 1613],
+    ["query_reward_record_count", 1612],
+    ["query_reward_record_find", 1626],
+    ["query_progress_history_find", 1274],
+    ["query_progress_history_session_find", 1275],
+    ["query_progress_history_session_forward_find", 1276],
+    ["query_progress_history_session_count", 1273],
+    ["query_progress_history_session_forward_count", 1262],
+]);
+function detectReentrancyProtection(root, table, spec) {
+    const allPrimitives = new Set([
+        ...spec.existsPrimitives,
+        ...spec.countPrimitives,
+        ...spec.addressPrimitives,
+    ]);
+    if (allPrimitives.size === 0) {
+        return {
+            state: "absent",
+            evidence: "No anti-reentrancy primitive available in GUARDQUERY for this scene",
+        };
+    }
+    const idToName = new Map();
+    const nameToId = new Map();
+    for (const id of allPrimitives) {
+        const entry = GUARDQUERY.find((q) => q.id === id);
+        if (entry) {
+            idToName.set(id, entry.name);
+            nameToId.set(entry.name, id);
+        }
+    }
+    const primitiveNames = Array.from(nameToId.keys());
+    function resolvePrimitiveId(node) {
+        if (!node || typeof node !== "object")
+            return -1;
+        if (typeof node.query === "number" && allPrimitives.has(node.query)) {
+            return node.query;
+        }
+        if (typeof node.query === "string" && nameToId.has(node.query)) {
+            return nameToId.get(node.query);
+        }
+        if (typeof node.type === "string" && QUERY_TYPE_ALIASES.has(node.type)) {
+            const aliasId = QUERY_TYPE_ALIASES.get(node.type);
+            if (allPrimitives.has(aliasId)) {
+                return aliasId;
+            }
+        }
+        if (typeof node.type === "string" && nameToId.has(node.type)) {
+            return nameToId.get(node.type);
+        }
+        return -1;
+    }
+    function isZeroValue(node) {
+        if (!node || typeof node !== "object")
+            return false;
+        if (typeof node.type === "string" &&
+            ["number", "u8", "u16", "u32", "u64", "u128", "u256"].includes(node.type)) {
+            return node.value === 0 || node.value === "0" || node.value === 0n;
+        }
+        if (node.type === "identifier" && typeof node.identifier === "number") {
+            const entry = table.find((e) => e.identifier === node.identifier);
+            if (entry && !entry.b_submission) {
+                return entry.value === 0 || entry.value === "0" || entry.value === 0n;
+            }
+        }
+        return false;
+    }
+    function getSiblings(parent, child) {
+        if (!parent || typeof parent !== "object")
+            return [];
+        const siblings = [];
+        if (Array.isArray(parent.nodes)) {
+            for (const n of parent.nodes) {
+                if (n !== child)
+                    siblings.push(n);
+            }
+        }
+        if (parent.left && parent.left !== child)
+            siblings.push(parent.left);
+        if (parent.right && parent.right !== child)
+            siblings.push(parent.right);
+        return siblings.filter((s) => s && typeof s === "object");
+    }
+    let foundPrimitive = false;
+    let foundProtected = false;
+    let pseudoEvidence = "";
+    let foundPrimitiveName = "";
+    function walk(node, parent) {
+        if (!node || typeof node !== "object")
+            return;
+        const primId = resolvePrimitiveId(node);
+        if (primId >= 0) {
+            foundPrimitive = true;
+            const primName = idToName.get(primId) ?? `query_${primId}`;
+            foundPrimitiveName = primName;
+            const parentType = parent?.type ?? null;
+            let properlyWrapped = false;
+            const isExistsStyle = spec.existsPrimitives.includes(primId);
+            const isAddressStyle = spec.addressPrimitives.includes(primId);
+            const isCountStyle = spec.countPrimitives.includes(primId);
+            if ((isExistsStyle || isAddressStyle) && parentType === "logic_not") {
+                properlyWrapped = true;
+            }
+            if (isCountStyle && parentType === "logic_equal") {
+                const siblings = getSiblings(parent, node);
+                if (siblings.some((sib) => isZeroValue(sib))) {
+                    properlyWrapped = true;
+                }
+            }
+            if (properlyWrapped) {
+                foundProtected = true;
+            }
+            else if (!pseudoEvidence) {
+                const expected = isCountStyle
+                    ? "logic_equal with a zero operand"
+                    : "logic_not";
+                pseudoEvidence = `Primitive "${primName}" found but its immediate parent is ${parentType ?? "root"} (expected ${expected}). The primitive is present but does NOT actually prevent reentrancy — this is a false sense of security.`;
+            }
+        }
+        const children = [];
+        if (Array.isArray(node.nodes))
+            children.push(...node.nodes);
+        if (node.left)
+            children.push(node.left);
+        if (node.right)
+            children.push(node.right);
+        if (node.node)
+            children.push(node.node);
+        if (node.vec)
+            children.push(node.vec);
+        if (node.target)
+            children.push(node.target);
+        if (node.object && typeof node.object === "object")
+            children.push(node.object);
+        if (Array.isArray(node.parameters))
+            children.push(...node.parameters);
+        for (const child of children) {
+            if (child && typeof child === "object") {
+                walk(child, node);
+            }
+        }
+    }
+    walk(root, null);
+    if (foundProtected) {
+        return {
+            state: "protected",
+            evidence: `Anti-reentrancy primitive "${foundPrimitiveName}" is properly wrapped`,
+            foundPrimitiveName,
+        };
+    }
+    if (foundPrimitive) {
+        return {
+            state: "pseudo",
+            evidence: pseudoEvidence,
+            foundPrimitiveName,
+        };
+    }
+    return {
+        state: "absent",
+        evidence: `No anti-reentrancy primitive found in root. Expected one of: ${primitiveNames.join(", ")}`,
+    };
+}
 const RISK_RULES = [
     {
-        id: "R-DST-01",
-        trigger: "Guard 查询 Repository 数据但未验证写入者权限",
+        id: "R-C1-01",
+        data_source_class: "type1_onchain_constant",
+        trigger: "Guard table contains Address constants with b_submission=false; values may change after Guard rebuild",
         check: (ctx) => {
-            const rootStr = JSON.stringify(ctx.root).toLowerCase();
-            if (rootStr.includes('"query"') && rootStr.includes('repository')) {
-                const hasSignerCheck = rootStr.includes('"signer"') || rootStr.includes('"context"');
-                if (!hasSignerCheck) {
-                    return {
-                        id: "R-DST-01",
-                        level: "high",
-                        category: "data_source_trust",
-                        title: "Repository 数据源未验证写入者权限",
-                        description: "Guard 查询 Repository 数据，但未验证谁有权写入该 Repository。" +
-                            "恶意写入者可以操纵 Repository 数据来欺骗 Guard。",
-                        affected_stakeholders: ["customer", "provider"],
-                        scenario: "数据源操纵：攻击者写入虚假数据使 Guard 通过",
-                        mitigation: "1) 在 Repository write_guard 中限制写入者权限；" +
-                            "2) 在当前 Guard 中添加 context(Signer) 验证写入者身份；" +
-                            "3) 使用多点数据源交叉验证",
-                    };
+            const constAddrEntries = ctx.table.filter((e) => !e.b_submission && e.value_type === "Address" && e.value);
+            if (constAddrEntries.length === 0)
+                return null;
+            return {
+                id: "R-C1-01",
+                data_source_class: "type1_onchain_constant",
+                level: "low",
+                category: "data_source_trust",
+                title: "Constant object addresses may be inconsistent after Guard rebuild",
+                description: `Guard table contains ${constAddrEntries.length} Address constants (b_submission=false).` +
+                    "Guard is immutable, but if a future Guard rebuild is needed (e.g. to fix logic), the new Guard's table constant addresses may differ from the old version." +
+                    "Objects referencing the old Guard (Machine/Service, etc.) will not auto-update, leading to constant address inconsistency.",
+                affected_stakeholders: ["provider"],
+                scenario: "Guard iteration: after rebuild, constant addresses change but references still point to the old Guard",
+                mitigation: "1) After Guard rebuild, update all references (Machine forward guard, Service buy_guard, etc.);" +
+                    "2) Use guard2file to export a backup and record constant-address-to-semantics mappings;" +
+                    "3) Document constant-address changes in the migration notes",
+                evidence: `Constant Address entries: ${constAddrEntries.map((e) => `#${e.identifier}=${e.value}`).join(", ")}`,
+            };
+        },
+    },
+    {
+        id: "R-C1-02",
+        data_source_class: "type1_onchain_constant",
+        trigger: "Guard table contains EntityRegistrar(0xaab) or EntityLinker(0xaaa) system address constants",
+        check: (ctx) => {
+            const sysAddrEntries = ctx.table.filter((e) => !e.b_submission &&
+                e.value_type === "Address" &&
+                typeof e.value === "string" &&
+                (e.value.toLowerCase() === "0xaab" || e.value.toLowerCase() === "0xaaa"));
+            if (sysAddrEntries.length === 0)
+                return null;
+            const wrong = sysAddrEntries.find((e) => (e.value === "0xaab" && e.name && !e.name.toLowerCase().includes("registrar")) ||
+                (e.value === "0xaaa" && e.name && !e.name.toLowerCase().includes("linker")));
+            return {
+                id: "R-C1-02",
+                data_source_class: "type1_onchain_constant",
+                level: wrong ? "medium" : "info",
+                category: "data_source_trust",
+                title: wrong
+                    ? "EntityRegistrar/EntityLinker system address name annotation suspected to be wrong"
+                    : "Guard uses EntityRegistrar/EntityLinker system address constants",
+                description: "EntityRegistrar (0xaab) and EntityLinker (0xaaa) are fixed WoWok protocol system addresses." +
+                    (wrong
+                        ? "Detected name annotation does not match the address (e.g. 0xaab not annotated as registrar), which may cause semantic misunderstanding."
+                        : "Address is correct, but ensure the name annotation is clear to avoid later maintenance confusion."),
+                affected_stakeholders: ["provider"],
+                scenario: "System address misuse: incorrect 0xaab/0xaaa name annotation causes query target confusion",
+                mitigation: "1) Confirm 0xaab corresponds to EntityRegistrar (entity registrar);" +
+                    "2) Confirm 0xaaa corresponds to EntityLinker (entity linker);" +
+                    "3) The table entry name should clearly indicate the system address purpose",
+                evidence: `System address entries: ${sysAddrEntries.map((e) => `#${e.identifier}=${e.value}(${e.name})`).join(", ")}`,
+            };
+        },
+    },
+    {
+        id: "R-C1-03",
+        data_source_class: "type1_onchain_constant",
+        trigger: "Guard queries Repository data without verifying writer permissions",
+        check: (ctx) => {
+            if (!queriesRepository(ctx))
+                return null;
+            if (hasSignerCheck(ctx))
+                return null;
+            return {
+                id: "R-C1-03",
+                data_source_class: "type1_onchain_constant",
+                level: "high",
+                category: "data_source_trust",
+                title: "Repository data source does not verify writer permissions",
+                description: "Guard queries Repository data but does not verify who has permission to write to that Repository." +
+                    "A malicious writer can manipulate Repository data to deceive the Guard. As a Type1 constant object, " +
+                    "the Repository's address is immutable, but its internal data can be modified by authorized writers.",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Data source manipulation: attacker writes false data so Guard passes",
+                mitigation: "1) Restrict writer permissions in the Repository write_guard;" +
+                    "2) Add context(Signer) in the current Guard to verify writer identity;" +
+                    "3) Use multi-point data source cross-validation",
+            };
+        },
+    },
+    {
+        id: "R-C2-01",
+        data_source_class: "type2_witness_derived",
+        trigger: "Guard uses multi-hop witness (106/107/108: Arb→Progress/Machine/Service) to derive target object",
+        check: (ctx) => {
+            const codes = extractWitnessCodes(ctx.root);
+            const multiHop = codes.filter((c) => [106, 107, 108].includes(c));
+            if (multiHop.length === 0)
+                return null;
+            const witnessNames = {
+                106: "Arb→Progress (two hops: arb.order → order.progress)",
+                107: "Arb→Machine (two hops: arb.order → order.machine)",
+                108: "Arb→Service (two hops: arb.order → order.service)",
+            };
+            return {
+                id: "R-C2-01",
+                data_source_class: "type2_witness_derived",
+                level: "medium",
+                category: "data_source_trust",
+                title: "Multi-hop witness chain derivation may break",
+                description: `Guard uses multi-hop witness [${multiHop.join(", ")}] to derive target object.` +
+                    "Multi-hop witness (e.g. Arb→Progress requires reading arb.order then order.progress) requires intermediate objects to exist and fields to be set." +
+                    "If an intermediate object does not exist (e.g. Arb's order field is empty) or the relationship chain breaks, witness derivation fails." +
+                    "In the WoWok protocol this usually returns empty or 0, potentially causing unexpected Guard behavior.\n" +
+                    multiHop.map((c) => `  - ${c}: ${witnessNames[c]}`).join("\n"),
+                affected_stakeholders: ["customer", "provider", "arbitrator"],
+                scenario: "Witness break: intermediate object missing causes derivation failure and unexpected Guard behavior",
+                mitigation: "1) Confirm the Arb object's order field is properly set (Arb is bound to Order at creation);" +
+                    "2) Add null checks for derived results in Guard logic;" +
+                    "3) Prefer single-hop witness (100-105) to reduce derivation chain length;" +
+                    "4) Test the edge case where Arb is not associated with an Order",
+                evidence: `Multi-hop witness codes: ${multiHop.join(", ")}`,
+            };
+        },
+    },
+    {
+        id: "R-C2-02",
+        data_source_class: "type2_witness_derived",
+        trigger: "Guard uses witness but source object's object_type may not match the witness source type, or multi-hop chain has missing intermediate objects",
+        check: (ctx) => {
+            const pairs = extractWitnessIdentifierPairs(ctx.root);
+            const validPairs = pairs.filter((p) => p.code >= 100 && p.code <= 108);
+            if (validPairs.length === 0)
+                return null;
+            const hardMismatches = [];
+            const missingAnnotations = [];
+            for (const { code, identifier } of validPairs) {
+                const chain = WITNESS_CHAIN[code];
+                if (!chain)
+                    continue;
+                const expectedSource = chain[0];
+                const entry = ctx.table.find((e) => e.identifier === identifier);
+                if (!entry)
+                    continue;
+                const chainStr = `${code} (${chain.join("→")})`;
+                if (entry.object_type) {
+                    if (entry.object_type !== expectedSource) {
+                        hardMismatches.push(`witness ${chainStr} references #${identifier} ` +
+                            `but object_type=${entry.object_type} (expected ${expectedSource})`);
+                    }
+                }
+                else {
+                    missingAnnotations.push(`witness ${chainStr} references #${identifier} ` +
+                        `but object_type is not set (expected ${expectedSource})`);
+                }
+                if (chain.length === 3) {
+                    const intermediateType = chain[1];
+                    const hasIntermediate = ctx.table.some((e) => e.object_type === intermediateType);
+                    if (!hasIntermediate) {
+                        missingAnnotations.push(`witness ${chainStr} multi-hop chain expects intermediate ` +
+                            `${intermediateType} in table, but no entry with object_type=${intermediateType} found`);
+                    }
                 }
             }
-            return null;
+            const totalIssues = hardMismatches.length + missingAnnotations.length;
+            if (totalIssues === 0)
+                return null;
+            const level = hardMismatches.length > 0 ? "medium" : "low";
+            const evidenceParts = [
+                ...hardMismatches,
+                ...missingAnnotations,
+            ];
+            return {
+                id: "R-C2-02",
+                data_source_class: "type2_witness_derived",
+                level,
+                category: "data_source_trust",
+                title: hardMismatches.length > 0
+                    ? "witness source object_type explicitly contradicts the witness derivation chain"
+                    : "witness source object_type annotation missing or multi-hop chain incomplete",
+                description: "Guard uses witness derivation, but the source object's object_type in table is either " +
+                    "inconsistent with the witness expected source type, or the annotation is missing " +
+                    "(preventing validation), or the multi-hop chain lacks an intermediate object.\n" +
+                    evidenceParts.map((e) => `  - ${e}`).join("\n") +
+                    "\nNote: object_type is an auxiliary annotation field on table entries; it is not strictly " +
+                    "validated at on-chain creation. However, wrong or missing annotations cause semantic " +
+                    "misunderstanding and maintenance difficulty, and may indicate a deeper structural mismatch.",
+                affected_stakeholders: ["provider"],
+                scenario: hardMismatches.length > 0
+                    ? "Type annotation mismatch: witness source type annotation is wrong, causing semantic confusion"
+                    : "Type annotation missing: witness source type cannot be validated, raising maintenance risk",
+                mitigation: "1) Set or fix the table entry's object_type field to match the witness source type;\n" +
+                    "2) witness 100-102 source type is Order; 103 is Progress; 104-108 is Arb;\n" +
+                    "3) For multi-hop witnesses (106-108), ensure the intermediate Order object is also in the table;\n" +
+                    "4) Use wowok_buildin_info(info='guard instructions') to query the full witness definition",
+                evidence: evidenceParts.join("; "),
+            };
         },
     },
     {
-        id: "R-DST-02",
-        trigger: "Guard 查询 Progress 状态但未验证 Machine 发布状态",
+        id: "R-C2-03",
+        data_source_class: "type2_witness_derived",
+        trigger: "Guard queries Progress status without verifying Machine publish state",
         check: (ctx) => {
-            const rootStr = JSON.stringify(ctx.root).toLowerCase();
-            if (rootStr.includes('progress') && ctx.scene?.host_object === "Machine") {
-                return {
-                    id: "R-DST-02",
-                    level: "medium",
-                    category: "data_source_trust",
-                    title: "Progress 数据依赖 Machine 不可变性",
-                    description: "Guard 查询 Progress 状态。如果 Machine 未发布，Provider 可以修改 Machine 节点结构，" +
-                        "导致 Guard 验证的节点名失效或被重命名。",
-                    affected_stakeholders: ["customer"],
-                    scenario: "Provider 修改 Machine 节点名使 Guard 验证失效",
-                    mitigation: "1) 确保 Machine 已发布（bPublished=true）再绑定 Guard；" +
-                        "2) 在 Guard 中查询 Machine.bPublished 字段验证；" +
-                        "3) 使用节点 ID 而非节点名进行比较",
-                };
-            }
-            return null;
+            if (!queriesProgress(ctx))
+                return null;
+            if (!hasWitness(ctx.root))
+                return null;
+            if (ctx.scene?.host_object !== "Machine")
+                return null;
+            return {
+                id: "R-C2-03",
+                data_source_class: "type2_witness_derived",
+                level: "medium",
+                category: "data_source_trust",
+                title: "Progress data depends on Machine immutability",
+                description: "Guard queries Progress status via witness, and the Guard is bound to a Machine." +
+                    "If the Machine is not published (bPublished=false), the Provider can modify the Machine node structure, " +
+                    "causing node names validated by the Guard to become invalid or be renamed. Progress's current node name, node time, etc. " +
+                    "all depend on the Machine's node definitions.",
+                affected_stakeholders: ["customer"],
+                scenario: "Provider modifies Machine node names to invalidate Guard verification",
+                mitigation: "1) Ensure the Machine is published (bPublished=true) before binding the Guard;" +
+                    "2) Query the Machine.bPublished field in the Guard to verify;" +
+                    "3) Use node IDs instead of node names for comparison",
+            };
         },
     },
     {
-        id: "R-SF-01",
-        trigger: "Guard 依赖提交数据但未验证签名者身份（无 Signer 检查=high；有 Signer 检查=info 降级）",
+        id: "R-C2-04",
+        data_source_class: "type2_witness_derived",
+        trigger: "Guard uses witness query and the query parameter requires type conversion (e.g. Address → U64 timestamp key)",
+        check: (ctx) => {
+            if (!hasWitness(ctx.root))
+                return null;
+            const str = rootStr(ctx);
+            const hasTypeConversion = str.includes("convert_number_address") ||
+                str.includes("convert_address_number") ||
+                str.includes("convert_u256") ||
+                str.includes("convert_string");
+            const queriesRepo = str.includes("repository") && str.includes('"query"');
+            const queriesProgressHistory = str.includes("progress_history") && str.includes('"query"');
+            if (!queriesRepo && !queriesProgressHistory)
+                return null;
+            return {
+                id: "R-C2-04",
+                data_source_class: "type2_witness_derived",
+                level: "medium",
+                category: "data_source_trust",
+                title: "witness query parameter requires type translation (missing will cause type mismatch or wrong comparison)",
+                description: "Guard queries object fields via witness, but the query parameter type may not match the type declared in table.\n" +
+                    "Typical scenarios:\n" +
+                    "  - Repository.data query: the key may be of Address type (vector<u8> address representation in Move), " +
+                    "but the actual semantics is a U64 timestamp, requiring convert_number_address translation\n" +
+                    "  - Progress.history query: Forward ID may need to be converted from String to Address\n" +
+                    "  - Order field query: some ID fields may be stored as Address but need U256 for comparison\n" +
+                    (hasTypeConversion
+                        ? "\nThe current Guard already uses type conversion nodes, but ensure the conversion direction is correct."
+                        : "\nWarning: no type conversion node detected in the current Guard; parameter type mismatch risk may exist."),
+                affected_stakeholders: ["provider", "customer"],
+                scenario: "Query parameter type does not match the parameters type defined by GUARDQUERY, causing creation failure or runtime comparison error",
+                mitigation: "1) Query GUARDQUERY to confirm the parameters type and return type of each query instruction;\n" +
+                    "2) If table declares Address but the query needs U64, use convert_number_address to translate;\n" +
+                    "3) Use wowok_buildin_info info='guard instructions' to verify parameter types;\n" +
+                    "4) Verify type compatibility via schema_query before creation",
+                evidence: hasTypeConversion ? "Type conversion node in use" : "No type conversion node detected",
+            };
+        },
+    },
+    {
+        id: "R-C3-01",
+        data_source_class: "type3_submitted_object",
+        trigger: "Guard depends on submitted data but does not verify signer identity (no Signer check=high; with Signer check=info downgrade)",
         check: (ctx) => {
             const hasSubmission = ctx.table.some((e) => e.b_submission);
             if (!hasSubmission)
                 return null;
             if (ctx.scene?.binding_field === "voting_guard")
                 return null;
-            const rootStr = JSON.stringify(ctx.root);
-            const hasSignerCheck = rootStr.includes('"Signer"');
-            if (!hasSignerCheck) {
+            if (ctx.scene?.id === "service_order_allocators_guard" &&
+                ctx.sharing_recipients &&
+                ctx.sharing_recipients.length > 0 &&
+                !ctx.sharing_recipients.includes("Signer")) {
+                return null;
+            }
+            if (!hasSignerCheck(ctx)) {
+                if (ctx.scene?.id === "machine_forward_guard") {
+                    return {
+                        id: "R-C3-01",
+                        data_source_class: "type3_submitted_object",
+                        level: "medium",
+                        category: "submission_forgery",
+                        title: "Submitted data not bound to signer identity (Forward scenario implicitly verified by permissionIndex)",
+                        description: "Guard accepts runtime-submitted data (b_submission=true), and root does not explicitly verify Signer." +
+                            "This Guard is used for Machine Forward; Forward's permissionIndex/namedOperator already implicitly verifies operator identity, " +
+                            "so the Signer binding risk is reduced. But permissionIndex only verifies 'operator has permission', " +
+                            "not 'submitted data belongs to operator' — for example, a merchant holding permissionIndex can still submit someone else's credentials.",
+                        affected_stakeholders: ["customer", "provider"],
+                        scenario: "In-permission forgery: an authorized operator submits someone else's data (e.g. someone else's Merkle Root)",
+                        mitigation: "1) If the submitted data should belong to the operator (e.g. the operator's address), it is still recommended to add context(Signer) binding;" +
+                            "2) If the submitted data is a public credential (e.g. Merkle Root string), the current risk is acceptable;" +
+                            "3) Use retained_submission to retain submitted data for later audit",
+                    };
+                }
                 return {
-                    id: "R-SF-01",
+                    id: "R-C3-01",
+                    data_source_class: "type3_submitted_object",
                     level: "high",
                     category: "submission_forgery",
-                    title: "提交数据未与签名者身份绑定",
-                    description: "Guard 接受运行时提交数据，但未验证提交者是否为当前交易签名者。" +
-                        "攻击者可以提交他人的数据（如他人的地址、他人的凭证）来通过 Guard。",
+                    title: "Submitted data not bound to signer identity",
+                    description: "Guard accepts runtime-submitted data (b_submission=true), but does not verify whether the submitter is the current transaction signer." +
+                        "An attacker can submit someone else's data (e.g. someone else's address, someone else's credentials) to pass the Guard." +
+                        "Type3 submitted objects are isomorphic with Type1 at the native layer (TYPE_QUERY+TYPE_CONSTANT), " +
+                        "the only difference being that the value is injected by submission, so identity must be bound via logical constraints.",
                     affected_stakeholders: ["customer", "provider"],
-                    scenario: "身份伪造：攻击者提交他人的地址冒充授权用户",
-                    mitigation: "1) 添加 context(Signer) 与提交数据绑定验证；" +
-                        "2) 使用 vec_contains_address 验证签名者在白名单中；" +
-                        "3) 使用 Passport 凭证替代裸地址提交",
+                    scenario: "Identity forgery: attacker submits someone else's address to impersonate an authorized user",
+                    mitigation: "1) Add context(Signer) binding with the submitted data for verification;" +
+                        "2) Use vec_contains_address to verify the signer is in the whitelist;" +
+                        "3) Use Passport credentials instead of bare address submission",
                 };
             }
             return {
-                id: "R-SF-01",
+                id: "R-C3-01",
+                data_source_class: "type3_submitted_object",
                 level: "info",
                 category: "submission_forgery",
-                title: "提交数据已通过 context(Signer) 间接绑定（请确认绑定方向正确）",
-                description: "Guard 接受运行时提交数据，且 root 子树中包含 context(Signer) 检查，" +
-                    "提交数据与签名者形成间接绑定，伪造风险已降低。" +
-                    "但需人工确认：context(Signer) 比较的常量是正确角色（如 Provider 地址而非 Customer 地址），" +
-                    "且提交数据确实应由该签名者提供。",
+                title: "Submitted data is indirectly bound via context(Signer) (confirm the binding direction is correct)",
+                description: "Guard accepts runtime-submitted data, and the root subtree contains a context(Signer) check, " +
+                    "forming an indirect binding between submitted data and signer, reducing forgery risk." +
+                    "But manual confirmation is needed: the constant compared with context(Signer) is the correct role (e.g. Provider address rather than Customer address), " +
+                    "and the submitted data should indeed be provided by that signer. See R-C4-01 Signer direction risk.",
                 affected_stakeholders: ["customer", "provider"],
-                scenario: "间接绑定待确认：Signer 检查方向与提交数据归属是否匹配",
-                mitigation: "1) 确认 context(Signer) 与正确的 table 常量比较（Provider 地址而非 Customer 地址）；" +
-                    "2) 确认提交数据的来源角色与 Signer 检查一致；" +
-                    "3) 如需更严格绑定，使用 query 验证提交者链上身份",
+                scenario: "Indirect binding to confirm: whether the Signer check direction matches the submitted data ownership",
+                mitigation: "1) Confirm context(Signer) is compared with the correct table constant (Provider address rather than Customer address);" +
+                    "2) Confirm the source role of the submitted data matches the Signer check;" +
+                    "3) For stricter binding, use query to verify the submitter's on-chain identity",
             };
         },
     },
     {
-        id: "R-SF-02",
-        trigger: "voting_guard 权重来自提交数据但未验证来源",
+        id: "R-C3-02",
+        data_source_class: "type3_submitted_object",
+        trigger: "voting_guard weight comes from submitted data without verifying source",
         check: (ctx) => {
-            if (ctx.scene?.binding_field === "voting_guard") {
-                const numericEntries = ctx.table.filter((e) => e.b_submission && ["U8", "U16", "U32", "U64", "U128", "U256"].includes(e.value_type));
-                if (numericEntries.length > 0) {
-                    return {
-                        id: "R-SF-02",
-                        level: "critical",
-                        category: "submission_forgery",
-                        title: "投票权重来自用户提交，可能被伪造",
-                        description: "voting_guard 的权重数据来自 b_submission=true 的 table 条目。" +
-                            "如果未通过 EntityRegistrar 或其他可信来源验证权重，" +
-                            "投票者可以提交任意高权重操纵投票结果。",
-                        affected_stakeholders: ["arbitrator"],
-                        scenario: "权重伪造：投票者提交虚假高分操纵仲裁结果",
-                        mitigation: "1) 权重应从 EntityRegistrar 查询而非用户提交；" +
-                            "2) 使用 query(entity.records) 获取链上注册的声誉分；" +
-                            "3) 在 Guard 中验证提交权重与链上记录一致",
-                    };
-                }
-            }
-            return null;
+            if (ctx.scene?.binding_field !== "voting_guard")
+                return null;
+            const numericEntries = ctx.table.filter((e) => e.b_submission &&
+                ["U8", "U16", "U32", "U64", "U128", "U256"].includes(e.value_type));
+            if (numericEntries.length === 0)
+                return null;
+            return {
+                id: "R-C3-02",
+                data_source_class: "type3_submitted_object",
+                level: "critical",
+                category: "submission_forgery",
+                title: "Voting weight comes from user submission and may be forged",
+                description: "voting_guard weight data comes from table entries with b_submission=true (Type3 submitted values)." +
+                    "If the weight is not verified through EntityRegistrar or other trusted sources, " +
+                    "a voter can submit arbitrarily high weights to manipulate the voting result." +
+                    "Type3 submitted values are only validated by type byte (value[0]) at the native layer; value range and source are not checked.",
+                affected_stakeholders: ["arbitrator"],
+                scenario: "Weight forgery: voters submit fake high scores to manipulate the arbitration result",
+                mitigation: "1) Weights should be queried from EntityRegistrar rather than submitted by users;" +
+                    "2) Use query(entity.records) to obtain on-chain registered reputation scores;" +
+                    "3) Verify in the Guard that the submitted weight matches the on-chain record",
+                evidence: `Submitted numeric entries: ${numericEntries.map((e) => `#${e.identifier}(${e.value_type})`).join(", ")}`,
+            };
         },
     },
     {
-        id: "R-GT-01",
-        trigger: "分账 Guard 可能导致某些参与者被跳过",
+        id: "R-C3-03",
+        data_source_class: "type3_submitted_object",
+        trigger: "Guard contains Address entries with b_submission=true; the runtime submitted object type may not match expectations",
         check: (ctx) => {
-            if (ctx.scene?.binding_field === "order_allocators") {
-                return {
-                    id: "R-GT-01",
-                    level: "medium",
-                    category: "game_theory",
-                    title: "order_allocators first-match-wins 可能导致分账不公",
-                    description: "order_allocators 采用 first-match-wins 策略：第一个 Guard 通过的 Allocator 执行分账。" +
-                        "如果顺序设计不当，某些参与者可能永远无法获得分账。" +
-                        "例如：如果第一个 Allocator 的 Guard 条件过宽，后续更精确的 Allocator 永远不会执行。",
-                    affected_stakeholders: ["provider"],
-                    scenario: "分账跳过：Provider 的分账 Allocator 被前面的宽泛条件跳过",
-                    mitigation: "1) 确保 order_allocators 顺序从严格到宽松；" +
-                        "2) 每个 Allocator 的 Guard 条件应互斥；" +
-                        "3) 考虑使用逻辑_or 依赖而非顺序排列",
-                };
-            }
-            return null;
+            const submittedAddr = ctx.table.filter((e) => e.b_submission && e.value_type === "Address");
+            if (submittedAddr.length === 0)
+                return null;
+            const noType = submittedAddr.filter((e) => !e.object_type);
+            const hasQuery = rootStr(ctx).includes('"query"');
+            if (!hasQuery)
+                return null;
+            return {
+                id: "R-C3-03",
+                data_source_class: "type3_submitted_object",
+                level: noType.length > 0 ? "medium" : "low",
+                category: "submission_forgery",
+                title: noType.length > 0
+                    ? "Submitted object missing object_type annotation; runtime type validation relies on native inference"
+                    : "Submitted object type validation relies on runtime native inference",
+                description: "Guard contains " + submittedAddr.length + " Address entries with b_submission=true (Type3 submitted objects)." +
+                    "The native layer (passport.rs#parse_table_items) only checks the value[0] type byte for submission; " +
+                    "object_type is derived at runtime by wobject_type and does not strictly validate the actual submitted object type.\n" +
+                    (noType.length > 0
+                        ? `Warning: ${noType.length} entries are missing object_type annotation, semantics are unclear.`
+                        : "object_type is annotated, but still confirm the annotation matches what the query expects."),
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Type mismatch: submitting a wrong-typed object causes query to return unexpected values",
+                mitigation: "1) Annotate object_type for all Address entries with b_submission=true;" +
+                    "2) object_type should match the object type expected by the query instruction;" +
+                    "3) Indirectly verify the object type via query results in Guard logic (e.g. query order.amount to verify it is an Order)",
+                evidence: noType.length > 0
+                    ? `Missing object_type: ${noType.map((e) => `#${e.identifier}`).join(", ")}`
+                    : `Annotated: ${submittedAddr.map((e) => `#${e.identifier}=${e.object_type}`).join(", ")}`,
+            };
         },
     },
     {
-        id: "R-GT-02",
-        trigger: "流程 Guard 时间锁可能锁定弱势方",
+        id: "R-C3-04",
+        data_source_class: "type3_submitted_object",
+        trigger: "Repository write_guard does not verify id_from_submission type",
         check: (ctx) => {
-            const rootStr = JSON.stringify(ctx.root);
-            if (rootStr.includes("Clock") && rootStr.includes("calc_number_add")) {
-                return {
-                    id: "R-GT-02",
-                    level: "medium",
-                    category: "game_theory",
-                    title: "时间锁可能锁定处于弱势的一方",
-                    description: "Guard 使用时间锁（context(Clock) + calc_number_add）。时间锁本身是中性的，" +
-                        "但需检查锁定方向：如果锁定 Customer 先付款但不能及时验收，Provider 获得优势；" +
-                        "如果锁定 Provider 先交付但不能及时收款，Customer 获得优势。",
-                    affected_stakeholders: ["customer", "provider"],
-                    scenario: "时间不对等：一方被时间锁定，另一方有行动自由",
-                    mitigation: "1) 确保时间锁对称（双方都有时间约束）；" +
-                        "2) 时间锁到期后提供退出机制（如自动退款/自动完成）；" +
-                        "3) 在 Machine 中设计对应的超时 Forward 节点",
-                };
-            }
-            return null;
+            if (ctx.scene?.binding_field !== "write_guard")
+                return null;
+            return {
+                id: "R-C3-04",
+                data_source_class: "type3_submitted_object",
+                level: "high",
+                category: "binding_risk",
+                title: "Repository write_guard must verify id_from_submission type",
+                description: "The table entry referenced by Repository write_guard's id_from_submission must be of Address type (Type3 submitted object)." +
+                    "The entry referenced by data_from_submission must match the Repository value_type." +
+                    "Type mismatch will cause write failure or data corruption. The write_guard submission contains both id and data parts; " +
+                    "the native layer distinguishes them by op_code, but value types must match the table declaration.",
+                affected_stakeholders: ["provider"],
+                scenario: "Type mismatch: write failure or data corruption",
+                mitigation: "1) Confirm the entry referenced by id_from_submission has value_type=Address;" +
+                    "2) Confirm the entry referenced by data_from_submission has value_type matching the Repository;" +
+                    "3) Cover write scenarios in gen_passport tests",
+            };
         },
     },
     {
-        id: "R-GT-03",
-        trigger: "Arbitration usage_guard 可能阻止合法争议",
+        id: "R-C3-05",
+        data_source_class: "type3_submitted_object",
+        trigger: "Guard accepts a runtime-submitted Order/Progress/Arb object (Type3) but does NOT verify the submitted object belongs to the current project (Machine or Service). " +
+            "The WoWok runtime does NOT enforce any binding between the submitted order_id and the actual Progress being forwarded — verify_guard receives only the caller-provided submission bytes, never the Progress object under advancement (passport.move:27,251-253; progress.move:458-483). " +
+            "A caller can therefore submit an unrelated order_id from a DIFFERENT project while forwarding a different Progress, causing witness=100 (Order->Progress) to evaluate against foreign data.",
         check: (ctx) => {
-            if (ctx.scene?.binding_field === "usage_guard") {
-                const rootStr = JSON.stringify(ctx.root);
-                const andCount = (rootStr.match(/"logic_and"/g) || []).length;
-                if (andCount >= 3) {
-                    return {
-                        id: "R-GT-03",
-                        level: "high",
-                        category: "game_theory",
-                        title: "usage_guard 条件过多可能阻止合法争议",
-                        description: `检测到 ${andCount} 个 logic_and 组合。过多 AND 条件使争议门槛过高，` +
-                            "Customer 可能无法发起合法争议，Provider 获得不正当优势。",
-                        affected_stakeholders: ["customer"],
-                        scenario: "争议门槛过高：Customer 无法发起合法争议",
-                        mitigation: "1) 重新评估每个 AND 条件的必要性；" +
-                            "2) 考虑使用 logic_or 降低门槛；" +
-                            "3) 将非必要条件移到 voting_guard 而非 usage_guard",
-                    };
-                }
+            const submittedAddrs = ctx.table.filter((e) => e.b_submission && e.value_type === "Address");
+            if (submittedAddrs.length === 0)
+                return null;
+            const witnessCodes = extractWitnessCodes(ctx.root);
+            const hasOrderWitness = witnessCodes.some((c) => [100, 101, 102].includes(c));
+            const hasProgressWitness = witnessCodes.some((c) => [103].includes(c));
+            const hasArbWitness = witnessCodes.some((c) => [104, 105, 106, 107, 108].includes(c));
+            const submittedOrders = submittedAddrs.filter((e) => e.object_type === "Order" || (hasOrderWitness && !e.object_type));
+            const submittedProgress = submittedAddrs.filter((e) => e.object_type === "Progress" || (hasProgressWitness && !e.object_type));
+            const submittedArbs = submittedAddrs.filter((e) => e.object_type === "Arb" || (hasArbWitness && !e.object_type));
+            const hasProjectRelevantSubmission = submittedOrders.length > 0 ||
+                submittedProgress.length > 0 ||
+                submittedArbs.length > 0;
+            if (!hasProjectRelevantSubmission)
+                return null;
+            const affectedSceneIds = [
+                "machine_forward_guard",
+                "service_order_allocators_guard",
+                "arbitration_usage_guard",
+                "arbitration_voting_guard",
+                "reward_guard",
+                "progress_submission_guard",
+            ];
+            const sceneId = ctx.scene?.id;
+            const isAffectedScene = !sceneId || affectedSceneIds.includes(sceneId);
+            if (!isAffectedScene)
+                return null;
+            const PROJECT_BINDING_QUERY_IDS = new Set([1563, 1560, 1250, 1402, 1401]);
+            const rootQueryIds = extractQueryIds(ctx.root);
+            const hasProjectBinding = rootQueryIds.some((id) => PROJECT_BINDING_QUERY_IDS.has(id));
+            if (hasProjectBinding)
+                return null;
+            const criticalScenes = new Set([
+                "machine_forward_guard",
+                "service_order_allocators_guard",
+            ]);
+            const level = sceneId && criticalScenes.has(sceneId)
+                ? "critical"
+                : "high";
+            const unboundEntries = [];
+            for (const e of submittedOrders) {
+                unboundEntries.push(`#${e.identifier}${e.object_type ? "(Order)" : "(inferred Order via witness 100-102)"}`);
             }
-            return null;
+            for (const e of submittedProgress) {
+                unboundEntries.push(`#${e.identifier}${e.object_type ? "(Progress)" : "(inferred Progress via witness 103)"}`);
+            }
+            for (const e of submittedArbs) {
+                unboundEntries.push(`#${e.identifier}${e.object_type ? "(Arb)" : "(inferred Arb via witness 104-108)"}`);
+            }
+            const sceneLabel = sceneId ?? "unknown scene (conservative flag)";
+            return {
+                id: "R-C3-05",
+                data_source_class: "type3_submitted_object",
+                level,
+                category: "submission_forgery",
+                title: "Submitted Order/Progress/Arb is NOT verified to belong to the current project (cross-project bypass — CRITICAL trust-boundary gap)",
+                description: `Guard accepts runtime-submitted Order/Progress/Arb object(s) [${unboundEntries.join(", ")}] but the root does NOT verify the submitted object belongs to the current project (no query of order.service/order.machine/progress.machine/arb.service compared to a project constant).\n\n` +
+                    "TRUST-BOUNDARY GAP (verified via Move source):\n" +
+                    "  - The Passport submission is built by the CALLER, not auto-injected by the runtime (passport.move:120,149,157)\n" +
+                    "  - verify_guard receives ONLY the caller-provided submission bytes — it never sees the Progress/Order actually being forwarded (passport.move:27,251-253)\n" +
+                    "  - next_with_passport performs NO linkage check between the passport submission and the Progress under advancement (progress.move:458-483)\n" +
+                    "  - Even order_next_with_passport's E_ORDER_NOT_MATCH only checks the separate `order:&Order` parameter, NOT the order_id embedded in the passport submission (progress.move:452)\n\n" +
+                    `EXPLOIT (scene=${sceneLabel}):\n` +
+                    "  1. Attacker holds Order Y from project B (where progress.current_time is old enough to pass the time-lock)\n" +
+                    "  2. Attacker calls forward on Order X's Progress (project A, freshly entered the node)\n" +
+                    "  3. Attacker submits Order Y's ID in the passport (lying about which order is being forwarded)\n" +
+                    "  4. Guard's witness=100 reads Order Y's Progress -> time-lock passes (Order Y is old)\n" +
+                    "  5. forward actually executes on Order X's Progress -> TIME-LOCK BYPASSED\n\n" +
+                    "This is distinct from R-C3-01 (Signer binding — WHO can submit) and R-C3-03 (type matching — WHAT type is submitted). " +
+                    "R-C3-05 addresses WHETHER the submitted object belongs to the current project — a third orthogonal axis of submission trust. " +
+                    "Even with R-C3-01 satisfied (authorized Signer) and R-C3-03 satisfied (correct type), the Signer can still submit an unrelated project's object.",
+                affected_stakeholders: ["customer", "provider", "arbitrator"],
+                scenario: "Cross-project bypass: authorized signer submits an unrelated project's order/progress/arb to bypass time-lock, status, or allocation conditions",
+                mitigation: "Add a project-binding check to the root (wrap existing root in logic_and):\n" +
+                    "  - For submitted Order: add logic_equal[query(1563: order.service), identifier[N](project_service_address)] — RECOMMENDED (service is the canonical project anchor)\n" +
+                    "  - For submitted Order: add logic_equal[query(1560: order.machine), identifier[N](project_machine_address)] — alternative (machine anchor)\n" +
+                    "  - For submitted Progress: add logic_equal[query(1250: progress.machine), identifier[N](project_machine_address)]\n" +
+                    "  - For submitted Arb: add logic_equal[query(1402: arb.service), identifier[N](project_service_address)]\n" +
+                    "  - Use witness=102 (TypeOrderService) on the submitted Order to derive the Service, then compare to the project service constant\n\n" +
+                    "Intentional cross-project exception: if the Guard is DESIGNED to accept cross-project submissions (rare), document this explicitly in the description and add a binding_hint annotation 'cross_project_intentional:true' to suppress this rule.",
+                evidence: `Unbound submitted project-relevant entries: ${unboundEntries.join(", ")}. ` +
+                    `Scene: ${sceneLabel}. ` +
+                    `Missing project-binding queries: none of [1563(order.service), 1560(order.machine), 1250(progress.machine), 1402(arb.service)] present in root.`,
+            };
         },
     },
     {
-        id: "R-LG-01",
-        trigger: "Guard root 为 identifier 直接返回 Bool",
+        id: "R-C3-06",
+        data_source_class: "type3_submitted_object",
+        trigger: "Guard is bound to Service order_allocators (service_order_allocators_guard scene). " +
+            "In this scene the Guard decides IF allocation happens, while sharing.who decides WHERE funds go. " +
+            "If sharing.who=Signer, the transaction caller receives the funds — so a Guard that does NOT bind " +
+            "context(Signer) lets ANYONE who passes the Guard steal 100% of the order funds. " +
+            "This is a Guard+sharing coupling risk: neither piece alone reveals the theft — only their combination.",
         check: (ctx) => {
-            if (ctx.root?.type === "identifier") {
-                return {
-                    id: "R-LG-01",
-                    level: "medium",
-                    category: "logic_gap",
-                    title: "Root 直接返回提交的 Bool 值，可被操纵",
-                    description: "Guard root 是 identifier 节点，直接返回 table 中的 Bool 值。" +
-                        "如果该条目 b_submission=true，调用者可以直接提交 true 绕过所有验证。",
-                    affected_stakeholders: ["customer", "provider"],
-                    scenario: "绕过验证：调用者提交 true 直接通过 Guard",
-                    mitigation: "1) 确保 identifier 引用的条目 b_submission=false（常量）；" +
-                        "2) 或添加额外的 logic_and 条件进行交叉验证",
-                };
-            }
-            return null;
+            if (ctx.scene?.id !== "service_order_allocators_guard")
+                return null;
+            if (hasSignerCheck(ctx))
+                return null;
+            const recipients = ctx.sharing_recipients;
+            const sharingProvided = recipients !== undefined && recipients.length > 0;
+            const hasSignerSharing = sharingProvided && recipients.includes("Signer");
+            if (sharingProvided && !hasSignerSharing)
+                return null;
+            const level = hasSignerSharing ? "critical" : "medium";
+            const recipientsLabel = sharingProvided
+                ? `[${recipients.join(", ")}]`
+                : "(not provided — conservative flag)";
+            const titleSuffix = hasSignerSharing
+                ? "sharing.who=Signer confirmed — anyone can steal 100% of funds"
+                : "if sharing.who=Signer, anyone can steal 100% of funds";
+            return {
+                id: "R-C3-06",
+                data_source_class: "type3_submitted_object",
+                level,
+                category: "binding_risk",
+                title: `allocators Guard without Signer binding — ${titleSuffix}`,
+                description: `Guard is bound to Service order_allocators but does NOT verify context(Signer). ` +
+                    `In the allocators scene, sharing.who determines the fund recipient:\n` +
+                    `  - sharing.who=Signer → funds flow to the CALLER (transaction signer)\n` +
+                    `  - sharing.who=Entity → funds flow to a FIXED address (Treasury/personal)\n` +
+                    `  - sharing.who=GuardIdentifier → funds flow to a Guard-table-derived address\n\n` +
+                    `When sharing.who=Signer and the Guard does not bind Signer, ANY caller who passes the Guard ` +
+                    `receives the order funds — a direct theft. Even an authorized caller is unnecessary: the attacker ` +
+                    `only needs to pass the Guard's condition (e.g. submit any completed order_id), then the funds go to ` +
+                    `their own address.\n\n` +
+                    `This is distinct from R-C3-01 (generic Signer binding) and R-C3-05 (cross-project bypass). ` +
+                    `R-C3-06 addresses the allocators-specific Guard+sharing coupling: the SAFE design uses ` +
+                    `sharing.who=Entity so the recipient is fixed, making Guard Signer binding unnecessary.\n\n` +
+                    `sharing_recipients hint: ${recipientsLabel}`,
+                affected_stakeholders: ["provider", "customer"],
+                scenario: "Fund theft: attacker passes the allocators Guard (e.g. submits a completed order_id) and " +
+                    "sharing.who=Signer routes 100% of the order funds to the attacker's address",
+                mitigation: "TWO mitigation options:\n" +
+                    "  (A) Traditional: add context(Signer) binding to the Guard root " +
+                    "(logic_equal[context(Signer), identifier[N](authorized_address)]) so only the authorized " +
+                    "recipient can trigger allocation.\n" +
+                    "  (B) PREFERRED: use sharing.who=Entity (Treasury object or fixed personal address) in the " +
+                    "Allocator's sharing config. Funds then always flow to the designated recipient regardless of " +
+                    "who triggers allocation — the Guard does NOT need to bind Signer. This is more robust because " +
+                    "it does not depend on Guard correctness.\n\n" +
+                    "Design checklist when using sharing.who=Entity:\n" +
+                    "  - If Entity points to a Treasury object, verify the Treasury's permission is consistent with " +
+                    "the Service's permission (different permissions = different permission organizations = minor risk).\n" +
+                    "  - allocators require unique guard addresses: create separate Guard objects (identical root/table, " +
+                    "different descriptions) for each allocator.\n" +
+                    "  - First-match-wins: only the first Allocator whose Guard passes executes; multiple allocators " +
+                    "represent alternative strategies, not a simultaneous split.\n" +
+                    "  - Still add order.service project binding (query 1563) to prevent cross-project bypass (R-C3-05) " +
+                    "triggering premature allocation.",
+                evidence: `Scene: service_order_allocators_guard. ` +
+                    `Guard binds Signer: no. ` +
+                    `sharing_recipients: ${recipientsLabel}. ` +
+                    `Level rationale: ${hasSignerSharing ? "Signer sharing confirmed → critical" : "sharing hint absent → conservative medium"}.`,
+            };
         },
     },
     {
-        id: "R-LG-02",
-        trigger: "Guard 使用 logic_as_u256_greater 但未处理空值",
+        id: "R-C4-01",
+        data_source_class: "type4_system_context",
+        trigger: "Guard contains context(Signer) check; need to confirm comparison direction (== vs !=) and compared object role",
         check: (ctx) => {
-            const rootStr = JSON.stringify(ctx.root);
-            if (rootStr.includes("logic_as_u256_greater") && rootStr.includes("query")) {
-                return {
-                    id: "R-LG-02",
-                    level: "medium",
-                    category: "logic_gap",
-                    title: "数值比较未处理查询返回空值的情况",
-                    description: "Guard 使用 logic_as_u256_greater 进行数值比较，且操作数来自 query。" +
-                        "如果 query 返回空值（如对象不存在、字段未设置），比较结果可能不确定。" +
-                        "WoWok 协议中空值通常被视为 0，可能导致非预期通过。",
-                    affected_stakeholders: ["customer", "provider"],
-                    scenario: "空值误判：query 返回 0 导致 > 0 条件意外通过或失败",
-                    mitigation: "1) 在比较前添加 query 结果存在性检查；" +
-                        "2) 使用 query_reward_record_exists 或 query_progress_history_find 先验证；" +
-                        "3) 考虑添加 logic_and(对象存在, 数值比较) 组合",
-                };
-            }
-            return null;
+            if (!hasSignerCheck(ctx))
+                return null;
+            const rootStrRaw = JSON.stringify(ctx.root);
+            const hasEqual = rootStrRaw.includes('"logic_equal"');
+            const hasNotEqual = rootStrRaw.includes('"logic_not_equal"');
+            return {
+                id: "R-C4-01",
+                data_source_class: "type4_system_context",
+                level: "medium",
+                category: "system_context_risk",
+                title: "Signer check direction needs manual confirmation (comparison operator and role match)",
+                description: "Guard contains a context(Signer) check. Signer is a Type4 system context, " +
+                    "from TransactionContext.sender() (transaction initiator address).\n" +
+                    `Detected comparison: ${hasEqual ? "logic_equal(==)" : ""} ${hasNotEqual ? "logic_not_equal(!=)" : ""}\n` +
+                    "Manual confirmation required:\n" +
+                    "  1) Whether the comparison direction is correct: use == for identity verification (Signer == authorized address), use != for exclusion (Signer != blacklist address)\n" +
+                    "  2) Whether the compared object role is correct: buy_guard should compare the Customer address, Forward.guard may compare the Provider address\n" +
+                    "  3) Wrong direction causes reverse effect: == blacklist address would only allow blacklisted users",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Wrong direction: Signer == blacklist address would only allow blacklisted users",
+                mitigation: "1) Confirm logic_equal is used for identity verification (Signer == authorized address);" +
+                    "2) Confirm logic_not_equal is used for exclusion (Signer != blacklist address);" +
+                    "3) Confirm the compared table constant is the address of the correct role;" +
+                    "4) Cover both expected-pass and expected-fail scenarios in gen_passport tests",
+                evidence: `Comparison: ${hasEqual ? "==" : ""} ${hasNotEqual ? "!=" : ""}`,
+            };
         },
     },
     {
-        id: "R-LG-03",
-        trigger: "Guard 使用 logic_string_contains 可能被子串匹配绕过",
+        id: "R-C4-02",
+        data_source_class: "type4_system_context",
+        trigger: "Guard uses context(Clock) for precise boundary time-lock comparison",
         check: (ctx) => {
-            const rootStr = JSON.stringify(ctx.root);
-            if (rootStr.includes("logic_string_contains") && !rootStr.includes("logic_string_nocase")) {
-                return {
-                    id: "R-LG-03",
-                    level: "low",
-                    category: "logic_gap",
-                    title: "logic_string_contains 子串匹配可能被绕过",
-                    description: "Guard 使用 logic_string_contains 进行字符串匹配。" +
-                        "子串匹配可能被绕过：例如检查 'Completed' 时，'NotCompleted' 也包含 'Completed'。" +
-                        "此外，大小写敏感可能导致非预期失败。",
-                    affected_stakeholders: ["customer", "provider"],
-                    scenario: "子串误匹配：'NotCompleted' 包含 'Completed' 导致误通过",
-                    mitigation: "1) 优先使用 logic_equal 进行精确匹配；" +
-                        "2) 如需子串匹配，添加边界条件（如前缀+后缀）；" +
-                        "3) 确认是否需要大小写不敏感（使用 nocase 变体）",
-                };
-            }
-            return null;
+            if (!hasClockCheck(ctx))
+                return null;
+            const str = rootStr(ctx);
+            const hasGreaterOrEqual = str.includes("logic_as_u256_greater_or_equal");
+            const hasGreater = str.includes("logic_as_u256_greater");
+            if (!hasGreaterOrEqual && !hasGreater)
+                return null;
+            return {
+                id: "R-C4-02",
+                data_source_class: "type4_system_context",
+                level: "low",
+                category: "system_context_risk",
+                title: "Clock time-lock should have tolerance to avoid boundary invalidation from validator block-time variance",
+                description: "Guard uses context(Clock) for time-lock comparison. Clock comes from the timestamp_ms field (U64 millisecond timestamp) of system shared object 0x6.\n" +
+                    "The Wow on-chain timestamp is produced by validator consensus and has a slight deviation from real time (usually < 1 second), " +
+                    "and block-time variance may cause timestamp jumps. Using precise boundaries (>= or ==) may cause:\n" +
+                    "  - The time-lock expiration transaction is packaged exactly at the moment but fails due to slight timestamp deviation\n" +
+                    "  - Or conversely, slight deviation causes the time-lock to pass early\n" +
+                    "It is recommended to use > instead of >=, or add a small tolerance constant.",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Timestamp variance: validator block-time deviation causes boundary transactions to fail or pass early",
+                mitigation: "1) Use logic_as_u256_greater (>) instead of greater_or_equal (>=) for expiration judgment;" +
+                    "2) Or add a small tolerance constant (e.g. 1000ms) in calc_number_add;" +
+                    "3) Time-locks should not rely on second-level precision; reserve minute-level tolerance;" +
+                    "4) Design timeout Forward nodes in the Machine as a fallback",
+                evidence: `Comparison: ${hasGreaterOrEqual ? ">=" : ""} ${hasGreater ? ">" : ""}`,
+            };
         },
     },
     {
-        id: "R-LG-04",
-        trigger: "时间锁 query 返回 0 导致 logic_as_u256_greater_or_equal 比较永远为 true",
+        id: "R-C4-03",
+        data_source_class: "type4_system_context",
+        trigger: "Guard uses context(Guard) self-reference",
         check: (ctx) => {
-            const rootStr = JSON.stringify(ctx.root);
-            const hasGreaterOrEqual = rootStr.includes("logic_as_u256_greater_or_equal");
-            const hasClock = rootStr.includes('"Clock"');
-            const hasCalcAdd = rootStr.includes("calc_number_add");
-            const hasQuery = rootStr.includes('"query"');
-            if (hasGreaterOrEqual && hasClock && hasCalcAdd && hasQuery) {
-                return {
-                    id: "R-LG-04",
-                    level: "medium",
-                    category: "logic_gap",
-                    title: "时间锁查询可能返回 0 导致 >= 比较永远为 true",
-                    description: "Guard 使用 logic_as_u256_greater_or_equal 进行时间锁比较，且被比较的基准值来自 query。" +
-                        "如果 query 返回 0（如查询尚未发生的操作时间戳、未设置的节点进入时间），" +
-                        "则 Clock >= 0 + timeout 永远为 true，时间锁形同虚设，弱势方可以立即绕过时间约束。",
-                    affected_stakeholders: ["customer", "provider"],
-                    scenario: "时间锁失效：query 返回 0 使 >= 条件永远通过",
-                    mitigation: "1) 使用返回当前节点进入时间的 query（如 progress.current_time, id=1272）" +
-                        "而非操作时间戳（如 progress.session.forward.time, id=1271）；" +
-                        "2) 在时间锁前添加 query > 0 的前置检查；" +
-                        "3) 确认 query 在 Guard 执行时必然有值（查询当前节点属性而非历史操作）",
-                };
-            }
-            return null;
+            if (!hasGuardSelfRef(ctx))
+                return null;
+            return {
+                id: "R-C4-03",
+                data_source_class: "type4_system_context",
+                level: "info",
+                category: "system_context_risk",
+                title: "Guard uses context(Guard) self-reference (rare scenario, needs special explanation)",
+                description: "Guard contains a context(Guard) node. Guard is a Type4 system context, " +
+                    "returning the ObjectID of the currently verified Guard object itself.\n" +
+                    "This is a rare scenario, typically used for:\n" +
+                    "  1) Guard referencing its own address as a replacement for a table constant (avoiding hardcoding)\n" +
+                    "  2) Identifying the current Guard in a rely combination (rare)\n" +
+                    "Need to confirm whether the use of context(Guard) is necessary and whether the comparison object is correct.",
+                affected_stakeholders: ["provider"],
+                scenario: "Self-reference misuse: context(Guard) comparing wrong object causes logic invalidation",
+                mitigation: "1) Confirm the context(Guard) comparison object is the Guard ObjectID rather than an address constant;" +
+                    "2) Evaluate whether self-reference is truly needed; usually a table constant can replace it;" +
+                    "3) Verify in gen_passport tests that self-reference behavior meets expectations",
+            };
         },
     },
     {
-        id: "R-BR-01",
-        trigger: "Guard 绑定到已发布的 Machine/Service（不可变）",
+        id: "R-C4-04",
+        data_source_class: "type4_system_context",
+        trigger: "Guard uses logic_equal[context(Signer), identifier[N](fixed_address)] — Level 1 strict single-identity binding. " +
+            "Only ONE address can pass the Guard, and because Guards are immutable, changing the authorized address requires " +
+            "rebuilding the Guard and migrating all references. This creates a convenience trade-off: maximum security but " +
+            "maximum inflexibility (key loss or personnel change permanently blocks the operation).",
         check: (ctx) => {
-            if (ctx.scene && !ctx.scene.mutable_after_publish) {
-                return {
-                    id: "R-BR-01",
-                    level: "info",
-                    category: "binding_risk",
-                    title: `Guard 绑定到不可变的 ${ctx.scene.host_object}（发布后不可修改）`,
-                    description: `${ctx.scene.host_object} 发布后 ${ctx.scene.binding_field} 不可修改。` +
-                        "如果 Guard 设计有误，需要新建 Machine/Service 并迁移所有引用。" +
-                        "这是设计约束而非风险，但需要确保 Guard 设计正确后再发布。",
-                    affected_stakeholders: ["provider"],
-                    scenario: "不可逆绑定：发布后发现 Guard 设计有误无法修改",
-                    mitigation: "1) 发布前使用 gen_passport 进行充分测试；" +
-                        "2) 测试 expected-pass 和 expected-fail 两种场景；" +
-                        "3) 发布前导出 Guard 备份（guard2file）",
-                };
-            }
-            return null;
+            if (!hasSignerCheck(ctx))
+                return null;
+            if (isSignerCheckInLogicOr(ctx.root))
+                return null;
+            const detection = detectLevel1StrictBinding(ctx.root, ctx.table);
+            if (!detection.detected || !detection.entry)
+                return null;
+            const entry = detection.entry;
+            return {
+                id: "R-C4-04",
+                data_source_class: "type4_system_context",
+                level: "info",
+                category: "system_context_risk",
+                title: "Level 1 strict single-identity Signer binding — convenience trade-off (consider Level 2/3 alternatives)",
+                description: `Guard uses logic_equal[context(Signer), identifier[${entry.identifier}](fixed address)] — only the address "${entry.value}" can pass.\n` +
+                    "This is Level 1 strict single-identity binding: maximally secure but maximally inconvenient.\n" +
+                    "Guards are immutable on-chain. If the authorized address becomes unavailable (key loss, personnel change, " +
+                    "role rotation), the Guard permanently blocks the operation — the only recovery is to build a new Guard " +
+                    "and migrate ALL references (Machine forward guards, Service buy_guard, allocators, etc.).\n\n" +
+                    "Three verifier constraint levels trade off security vs convenience:\n" +
+                    "  - Level 1 (current): strict single-identity — one address, no flexibility (AVOID unless justified)\n" +
+                    "  - Level 2: identity-set — logic_or of multiple valid identities (e.g. order.owner OR order.agent; " +
+                    "permission.owner OR permission.admin). Recommended for role-based access.\n" +
+                    "  - Level 3: scene-combined — verify whether Signer binding is even needed. Many scenes (allocators with " +
+                    "sharing.who=Entity, machine forward with permissionIndex) already ensure safety without Signer binding.\n\n" +
+                    "Use Level 1 only when: (a) the role is permanently tied to one address, AND (b) the designer explicitly " +
+                    "accepts the immutability lock-in risk. Otherwise prefer Level 2 or Level 3.",
+                affected_stakeholders: ["provider"],
+                scenario: "Immutability lock-in: authorized address becomes unavailable, Guard permanently blocks the operation, " +
+                    "requiring full Guard rebuild and reference migration",
+                mitigation: "Consider these alternatives before settling on Level 1 strict binding:\n" +
+                    "  (A) Level 2 identity-set (RECOMMENDED for role-based access): use logic_or to allow multiple valid identities.\n" +
+                    "      - Order holder: logic_or[logic_equal[query(1562: order.owner), context(Signer)], query(1567: order.agent has, parameters: [context(Signer)])]\n" +
+                    "      - Service provider: logic_or[logic_equal[query(1002: permission.owner), context(Signer)], query(1004: permission.admin has, parameters: [context(Signer)])]\n" +
+                    "      - Dynamic permission (survives rotation): submit permission address, verify query(1488: service.permission) == submitted, then check 1002/1004\n" +
+                    "  (B) Level 3 scene-combined: evaluate whether Signer binding is needed at all.\n" +
+                    "      - If using allocators with sharing.who=Entity (Treasury): funds flow to a fixed recipient regardless of caller — no Signer binding needed (R-C3-06 safe)\n" +
+                    "      - If using machine forward: permissionIndex already verifies operator identity — Signer binding may be redundant\n" +
+                    "  (C) If Level 1 is truly required: document the justification in the Guard description and ensure a key-recovery / address-rotation plan exists.",
+                evidence: `Level 1 strict binding detected: logic_equal[context(Signer), identifier[${entry.identifier}]] ` +
+                    `where identifier[${entry.identifier}] is a fixed Address constant (b_submission=false, value="${entry.value}"${entry.name ? `, name="${entry.name}"` : ""}). ` +
+                    `Not wrapped in logic_or (not Level 2 identity-set).`,
+            };
         },
     },
     {
-        id: "R-BR-02",
-        trigger: "Repository write_guard 未验证 id_from_submission 类型",
+        id: "R-X1-01",
+        data_source_class: "cross_type",
+        trigger: "Time-lock uses logic_as_u256_greater_or_equal with a baseline query that has NO non-zero invariant (i.e. the query MAY legitimately return 0 when it succeeds), causing Clock >= 0 + timeout to always be true",
         check: (ctx) => {
-            if (ctx.scene?.binding_field === "write_guard") {
-                return {
-                    id: "R-BR-02",
-                    level: "high",
-                    category: "binding_risk",
-                    title: "Repository write_guard 需验证 id_from_submission 类型",
-                    description: "Repository write_guard 的 id_from_submission 引用的 table 条目必须 Address 类型。" +
-                        "data_from_submission 引用的条目必须匹配 Repository value_type。" +
-                        "类型不匹配会导致写入失败或数据损坏。",
-                    affected_stakeholders: ["provider"],
-                    scenario: "类型不匹配：写入失败或数据损坏",
-                    mitigation: "1) 确认 id_from_submission 引用的条目 value_type=Address；" +
-                        "2) 确认 data_from_submission 引用的条目 value_type 匹配 Repository；" +
-                        "3) 在 gen_passport 测试中覆盖写入场景",
-                };
-            }
-            return null;
+            const str = rootStr(ctx);
+            const hasGreaterOrEqual = str.includes("logic_as_u256_greater_or_equal");
+            const hasClock = str.includes('"clock"');
+            const hasCalcAdd = str.includes("calc_number_add");
+            const hasQuery = str.includes('"query"');
+            if (!(hasGreaterOrEqual && hasClock && hasCalcAdd && hasQuery))
+                return null;
+            if (rootAllQueriesNonZero(ctx.root))
+                return null;
+            const queryIds = extractQueryIds(ctx.root);
+            const riskyQueries = queryIds.filter((id) => !QUERY_INVARIANT_MAP.has(id));
+            const evidence = riskyQueries.length > 0
+                ? `Queries without non-zero invariant: ${riskyQueries
+                    .map((id) => {
+                    const q = GUARDQUERY.find((x) => x.id === id);
+                    return q ? `${q.id} (${q.name})` : `${id}`;
+                })
+                    .join(", ")}`
+                : "Baseline query may return 0";
+            return {
+                id: "R-X1-01",
+                data_source_class: "cross_type",
+                level: "medium",
+                category: "logic_gap",
+                title: "Time-lock baseline query may return 0 causing >= comparison to always be true",
+                description: "Guard uses logic_as_u256_greater_or_equal for time-lock comparison, and the compared baseline value comes from a query (Type1/2/3 data sources). " +
+                    "If the query SUCCEEDS but its stored value is 0 (e.g. a count that is 0 in the empty initial state, a user-submitted value of 0, or a Some(0) from an Option field), " +
+                    "then Clock >= 0 + timeout is always true, the time-lock is effectively void, and the disadvantaged party can bypass the time constraint immediately.\n\n" +
+                    "IMPORTANT — 'VM error = Guard failure' baseline: " +
+                    "if a query targets an absent object, unset Option, or missing collection entry, the WoWok native runtime aborts with a VM error (e.g. W_FIELD_NOT_FOUND) " +
+                    "and the Guard fails as a whole (does NOT silently return 0). Therefore the null-bypass risk ONLY applies to queries whose stored value can legitimately be 0 " +
+                    "while the query itself succeeds. Such queries are exactly those WITHOUT an `invariant` annotation in the SDK GUARDQUERY catalog.",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Time-lock invalidation: baseline query returns 0 (not VM error), making the >= condition always pass",
+                mitigation: "1) Use a query whose return is guaranteed non-zero (look for `invariant` in guard-ins.ts — e.g. progress.current_time id=1272 with invariant='clock_derived'); " +
+                    "2) Add a precondition check query > 0 before the time-lock (for queries without an invariant, e.g. user-submitted baselines); " +
+                    "3) Avoid using count/index/find/user-submitted values as time-lock baselines — these can all legitimately return 0; " +
+                    "4) Distinguish 'VM error' (safe — Guard fails) from 'query returns 0' (unsafe — Guard bypassed). Only the latter is a null-bypass risk.",
+                evidence,
+            };
+        },
+    },
+    {
+        id: "R-X1-02",
+        data_source_class: "cross_type",
+        trigger: "Guard uses logic_as_u256_greater with a query operand that has NO non-zero invariant (i.e. the query MAY legitimately return 0 when it succeeds), and the comparison does not distinguish 'query succeeded with 0' from 'query failed'",
+        check: (ctx) => {
+            const str = rootStr(ctx);
+            if (!(str.includes("logic_as_u256_greater") && str.includes('"query"')))
+                return null;
+            if (rootAllQueriesNonZero(ctx.root))
+                return null;
+            const queryIds = extractQueryIds(ctx.root);
+            const riskyQueries = queryIds.filter((id) => !QUERY_INVARIANT_MAP.has(id));
+            const evidence = riskyQueries.length > 0
+                ? `Queries without non-zero invariant: ${riskyQueries
+                    .map((id) => {
+                    const q = GUARDQUERY.find((x) => x.id === id);
+                    return q ? `${q.id} (${q.name})` : `${id}`;
+                })
+                    .join(", ")}`
+                : "Query may return 0";
+            return {
+                id: "R-X1-02",
+                data_source_class: "cross_type",
+                level: "medium",
+                category: "logic_gap",
+                title: "Numeric comparison with a query that may legitimately return 0",
+                description: "Guard uses logic_as_u256_greater for numeric comparison, and one of the operands comes from a query (Type1/2/3 data sources) that has NO non-zero invariant annotation. " +
+                    "If the query SUCCEEDS but its stored value is 0 (e.g. a count that is 0 in the empty initial state, a user-submitted value of 0, or a Some(0) from an Option field), " +
+                    "the comparison may produce an unexpected result (e.g. `query > 0` fails, or `query > some_threshold` is silently bypassed).\n\n" +
+                    "IMPORTANT — 'VM error = Guard failure' baseline: " +
+                    "if a query targets absent data (e.g. object does not exist, Option is None, collection entry is missing), the WoWok native runtime aborts with a VM error " +
+                    "(not 0). The Guard fails as a whole (does NOT silently return 0). Therefore this rule only flags queries whose stored value can be 0 while the query succeeds.",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Null misjudgment: query succeeds with value 0, causing > 0 condition to unexpectedly fail (or > threshold to be bypassed)",
+                mitigation: "1) Prefer queries with an `invariant` annotation (e.g. clock_derived / positive_lower_bound); " +
+                    "2) Add a precondition check (query > 0) before the main comparison when using count/index/find/user-submitted baselines; " +
+                    "3) Distinguish 'VM error' (safe — Guard fails) from 'query returns 0' (potentially unsafe). Only the latter is a null-bypass risk.",
+                evidence,
+            };
+        },
+    },
+    {
+        id: "R-X1-03",
+        data_source_class: "cross_type",
+        trigger: "Guard uses logic_string_contains and may be bypassed by substring matching",
+        check: (ctx) => {
+            const str = rootStr(ctx);
+            if (!(str.includes("logic_string_contains") && !str.includes("logic_string_nocase")))
+                return null;
+            return {
+                id: "R-X1-03",
+                data_source_class: "cross_type",
+                level: "low",
+                category: "logic_gap",
+                title: "logic_string_contains substring match may be bypassed",
+                description: "Guard uses logic_string_contains for string matching." +
+                    "Substring matching may be bypassed: e.g. when checking 'Completed', 'NotCompleted' also contains 'Completed'." +
+                    "In addition, case sensitivity may cause unexpected failures. String data may come from Type1 (query object fields), " +
+                    "Type3 (submitted values), or the context of a rely-dependent Guard.",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Substring mismatch: 'NotCompleted' contains 'Completed', causing false pass",
+                mitigation: "1) Prefer logic_equal for exact matching;" +
+                    "2) If substring matching is needed, add boundary conditions (e.g. prefix + suffix);" +
+                    "3) Confirm whether case-insensitivity is needed (use the nocase variant)",
+            };
+        },
+    },
+    {
+        id: "R-X1-04",
+        data_source_class: "cross_type",
+        trigger: "Guard root is an identifier directly returning Bool",
+        check: (ctx) => {
+            if (ctx.root?.type !== "identifier")
+                return null;
+            const entry = ctx.table.find((e) => e.identifier === ctx.root.identifier);
+            const isSubmission = entry?.b_submission ?? false;
+            return {
+                id: "R-X1-04",
+                data_source_class: "cross_type",
+                level: isSubmission ? "medium" : "low",
+                category: "logic_gap",
+                title: "Root directly returns identifier value, no operation logic",
+                description: "Guard root is an identifier node, directly returning the value (Bool) from table." +
+                    (isSubmission
+                        ? "This entry has b_submission=true (Type3 submitted value); the caller can directly submit true to bypass all verification."
+                        : "This entry has b_submission=false (Type1 constant); the value is fixed but the Guard has no actual verification logic."),
+                affected_stakeholders: ["customer", "provider"],
+                scenario: isSubmission
+                    ? "Bypass verification: caller submits true to pass the Guard directly"
+                    : "No verification logic: Guard always returns a fixed value, providing no actual protection",
+                mitigation: isSubmission
+                    ? "1) Ensure the entry referenced by identifier has b_submission=false (constant);" +
+                        "2) Or add an additional logic_and condition for cross-validation"
+                    : "1) Add actual verification logic (query + logic comparison);" +
+                        "2) Evaluate whether this Guard needs to exist",
+            };
+        },
+    },
+    {
+        id: "R-X1-05",
+        data_source_class: "cross_type",
+        trigger: "Allocation Guard may cause some participants to be skipped",
+        check: (ctx) => {
+            if (ctx.scene?.binding_field !== "order_allocators")
+                return null;
+            return {
+                id: "R-X1-05",
+                data_source_class: "cross_type",
+                level: "medium",
+                category: "game_theory",
+                title: "order_allocators first-match-wins may cause unfair allocation",
+                description: "order_allocators uses a first-match-wins strategy: the first Allocator whose Guard passes executes the allocation." +
+                    "If the order is poorly designed, some participants may never get allocated." +
+                    "For example: if the first Allocator's Guard condition is too broad, subsequent more precise Allocators will never execute." +
+                    "Allocation Guards typically combine Type1 (query order fields), Type3 (submit Order address), and Type4 (Signer) data.",
+                affected_stakeholders: ["provider"],
+                scenario: "Allocation skip: the Provider's allocation Allocator is skipped by preceding broad conditions",
+                mitigation: "1) Ensure the order_allocators order goes from strict to loose;" +
+                    "2) Each Allocator's Guard conditions should be mutually exclusive;" +
+                    "3) Consider using logic_or dependencies rather than sequential ordering",
+            };
         },
     },
     {
-        id: "R-DR-01",
-        trigger: "Guard 使用 rely 但依赖的 Guard 可能失效",
+        id: "R-X1-06",
+        data_source_class: "cross_type",
+        trigger: "Workflow Guard time-lock may lock the disadvantaged party",
         check: (ctx) => {
-            if (ctx.rely && ctx.rely.guards.length > 0) {
-                const logic = ctx.rely.logic_or ? "OR" : "AND";
+            const str = rootStr(ctx);
+            if (!(str.includes("clock") && str.includes("calc_number_add")))
+                return null;
+            return {
+                id: "R-X1-06",
+                data_source_class: "cross_type",
+                level: "medium",
+                category: "game_theory",
+                title: "Time-lock may lock the disadvantaged party",
+                description: "Guard uses a time-lock (context(Clock) + calc_number_add). The time-lock itself is neutral, " +
+                    "but the locking direction needs to be checked: if the Customer is locked to pay first but cannot accept in time, the Provider gains advantage; " +
+                    "if the Provider is locked to deliver first but cannot receive payment in time, the Customer gains advantage." +
+                    "The time-lock combines Type4 (Clock) and Type1/2 (query time fields) data sources.",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Time asymmetry: one party is locked by time while the other has freedom of action",
+                mitigation: "1) Ensure the time-lock is symmetric (both parties have time constraints);" +
+                    "2) Provide an exit mechanism after the time-lock expires (e.g. auto-refund/auto-complete);" +
+                    "3) Design corresponding timeout Forward nodes in the Machine",
+            };
+        },
+    },
+    {
+        id: "R-X1-07",
+        data_source_class: "cross_type",
+        trigger: "Arbitration usage_guard may block legitimate disputes",
+        check: (ctx) => {
+            if (ctx.scene?.binding_field !== "usage_guard")
+                return null;
+            const str = rootStr(ctx);
+            const andCount = (str.match(/"logic_and"/g) || []).length;
+            if (andCount < 3)
+                return null;
+            return {
+                id: "R-X1-07",
+                data_source_class: "cross_type",
+                level: "high",
+                category: "game_theory",
+                title: "usage_guard has too many conditions and may block legitimate disputes",
+                description: `Detected ${andCount} logic_and combinations. Too many AND conditions make the dispute threshold too high, ` +
+                    "the Customer may not be able to initiate a legitimate dispute, and the Provider gains an unfair advantage." +
+                    "usage_guard typically combines Type4 (Signer identity), Type3 (submit Passport credentials), " +
+                    "and Type1 (query EntityRegistrar verification) data sources.",
+                affected_stakeholders: ["customer"],
+                scenario: "Dispute threshold too high: Customer cannot initiate a legitimate dispute",
+                mitigation: "1) Re-evaluate the necessity of each AND condition;" +
+                    "2) Consider using logic_or to lower the threshold;" +
+                    "3) Move non-essential conditions to voting_guard rather than usage_guard",
+            };
+        },
+    },
+    {
+        id: "R-X1-08",
+        data_source_class: "cross_type",
+        trigger: "Guard is bound to a published Machine/Service (immutable)",
+        check: (ctx) => {
+            if (!ctx.scene || ctx.scene.mutable_after_publish)
+                return null;
+            return {
+                id: "R-X1-08",
+                data_source_class: "cross_type",
+                level: "info",
+                category: "binding_risk",
+                title: `Guard is bound to immutable ${ctx.scene.host_object} (cannot be modified after publish)`,
+                description: `After ${ctx.scene.host_object} is published, ${ctx.scene.binding_field} cannot be modified.` +
+                    "If the Guard design is flawed, a new Machine/Service must be created and all references migrated." +
+                    "This is a design constraint rather than a risk, but the Guard design must be correct before publishing.",
+                affected_stakeholders: ["provider"],
+                scenario: "Irreversible binding: after publish, a flawed Guard design cannot be modified",
+                mitigation: "1) Use gen_passport for thorough testing before publishing;" +
+                    "2) Test both expected-pass and expected-fail scenarios;" +
+                    "3) Export a Guard backup (guard2file) before publishing",
+            };
+        },
+    },
+    {
+        id: "R-X1-09",
+        data_source_class: "cross_type",
+        trigger: "Guard uses rely but the dependent Guard may fail",
+        check: (ctx) => {
+            if (!ctx.rely || ctx.rely.guards.length === 0)
+                return null;
+            const logic = ctx.rely.logic_or ? "OR" : "AND";
+            return {
+                id: "R-X1-09",
+                data_source_class: "cross_type",
+                level: ctx.rely.logic_or ? "low" : "medium",
+                category: "dependency_risk",
+                title: `rely ${logic} depends on ${ctx.rely.guards.length} external Guards`,
+                description: `Guard uses rely ${logic} to depend on ${ctx.rely.guards.length} external Guards.` +
+                    (ctx.rely.logic_or
+                        ? "OR logic: any one passing is enough. If a dependent Guard is loosely designed, it may become a bypass entry point."
+                        : "AND logic: all dependencies must pass. If a dependent Guard fails or is deleted, the current Guard will always fail.") +
+                    " rely-dependent Guards must have rep=true (repository.data queries do not depend on runtime submission).",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: ctx.rely.logic_or
+                    ? "Dependency bypass: a loose dependent Guard becomes an attack entry point"
+                    : "Dependency failure: a dependent Guard is deleted, causing the current Guard to always fail",
+                mitigation: ctx.rely.logic_or
+                    ? "1) Review the strictness of each dependent Guard; 2) Ensure all dependent Guards are at least as strict as the current Guard"
+                    : "1) Confirm all dependent Guards have rep=true and cannot be deleted; 2) Consider whether AND dependency is truly needed",
+            };
+        },
+    },
+    {
+        id: "R-X1-10",
+        data_source_class: "cross_type",
+        trigger: "Guard uses repository.data query (query 1167) and the Repository has quote_guard set",
+        check: (ctx) => {
+            const str = rootStr(ctx);
+            if (!(str.includes("repository") && str.includes('"query"')))
+                return null;
+            return {
+                id: "R-X1-10",
+                data_source_class: "cross_type",
+                level: "medium",
+                category: "impack_risk",
+                title: "repository.data query's quote_guard is invalid in the verify phase (impack_list is empty)",
+                description: "Guard queries repository.data (query 1167). According to passport.move#L289 and passport.rs implementation, " +
+                    "the impack_list is always empty in the verify phase (only filled after result_for_permission).\n" +
+                    "Therefore in check_repository_quote_guard (inside query 1167), " +
+                    "if the Repository policy's quote_guard is Some(addr), " +
+                    "since addr is not in the empty list, it will always report IMPACK_GUARD_NOT_FOUND.\n" +
+                    "Only when quote_guard==None can query 1167 pass.\n" +
+                    "This means: querying Repository data with a quote_guard in the Guard will always fail.",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "quote_guard invalidation: impack_list is empty in the verify phase, causing the 1167 query to always fail",
+                mitigation: "1) Confirm the queried Repository's quote_guard is None;" +
+                    "2) If quote authentication is needed, modify the verify loop in the Move layer to maintain impack_list;" +
+                    "3) Document this limitation clearly: Repositories with quote_guard cannot be queried in the Guard;" +
+                    "4) Consider using other data sources instead of Repository.data query",
+            };
+        },
+    },
+    {
+        id: "R-X1-11",
+        data_source_class: "cross_type",
+        trigger: "Guard uses rely to depend on other Guards; need to confirm the rep flag of dependent Guards is correct",
+        check: (ctx) => {
+            if (!ctx.rely || ctx.rely.guards.length === 0)
+                return null;
+            const str = rootStr(ctx);
+            const queriesRepoData = str.includes("repository") && str.includes('"query"');
+            const hasRepoSubmission = ctx.table.some((e) => e.b_submission && e.value_type === "Address" && e.object_type === "Repository");
+            return {
+                id: "R-X1-11",
+                data_source_class: "cross_type",
+                level: queriesRepoData && hasRepoSubmission ? "medium" : "low",
+                category: "rep_risk",
+                title: "rep semantics needs confirmation (when repository.data query depends on submission, rep=false and cannot be depended on)",
+                description: "Guard uses rely to depend on external Guards. In the WoWok protocol, rely-dependent Guards must have rep=true.\n" +
+                    "Precise rep semantics (guard.rs#L483-L492): repository.data query (query 1167) does not depend on runtime submission.\n" +
+                    "  - rep=true: repository.data query is fully constant-driven (object address b_submission=false and query parameters are not submission)\n" +
+                    "  - rep=false: repository address comes from runtime submission, or query parameters come from submission\n" +
+                    "Guards with rep=false cannot appear in other Guards' rely lists.\n" +
+                    (queriesRepoData && hasRepoSubmission
+                        ? "\nWarning: the current Guard itself queries repository.data and the Repository address comes from submission, " +
+                            "so its own rep=false and cannot be depended on by other Guards."
+                        : ""),
+                affected_stakeholders: ["provider"],
+                scenario: "rep misjudgment: depending on a rep=false Guard causes creation failure, or its own rep=false is wrongly depended on",
+                mitigation: "1) Confirm all rely-dependent Guards have rep=true (do not depend on submission to query repository.data);" +
+                    "2) If the current Guard queries repository.data and the address comes from submission, its own rep=false; annotate that it cannot be depended on;" +
+                    "3) rep is not 'no Repository dependency', but 'repository.data query does not depend on submission';" +
+                    "4) Use wowok_buildin_info to query the full definition of the rep flag",
+                evidence: queriesRepoData && hasRepoSubmission
+                    ? "Self rep=false (repository.data query depends on submission)"
+                    : "Self rep status to be confirmed",
+            };
+        },
+    },
+    {
+        id: "R-X1-12",
+        data_source_class: "cross_type",
+        trigger: "Guard table contains b_submission=true entries with vague name descriptions or missing binding_constraint",
+        check: (ctx) => {
+            const submissionEntries = ctx.table.filter((e) => e.b_submission);
+            if (submissionEntries.length === 0)
+                return null;
+            const vagueEntries = submissionEntries.filter((e) => {
+                const name = e.name ?? "";
+                return name.length < 10 || /^[a-z_]+$/i.test(name) || name === "";
+            });
+            if (vagueEntries.length === 0)
+                return null;
+            return {
+                id: "R-X1-12",
+                data_source_class: "cross_type",
+                level: "medium",
+                category: "submission_forgery",
+                title: "Submitted data entry description is vague (retained_submission risk: caller may submit wrong data)",
+                description: `Guard table has ${vagueEntries.length} b_submission=true entries with vague name descriptions.\n` +
+                    "The name of a submission entry is the only data contract between the Guard and the caller.\n" +
+                    "If the name description is unclear (e.g. only 'addr' / 'order_id'), the caller may:\n" +
+                    "  - Submit a wrong-typed object address (e.g. submit a Service address instead of an Order address)\n" +
+                    "  - Submit a wrong value (e.g. inconsistent amount units)\n" +
+                    "  - Confuse submission slots of different Guards in multi-Guard scenarios\n" +
+                    "Vague submission entries are 'retained' in the table but provide no effective data constraints, " +
+                    "equivalent to the Guard accepting arbitrary data without validating its semantic correctness.",
+                affected_stakeholders: ["customer", "provider"],
+                scenario: "Caller submits wrong data due to vague name description; the Guard passes verification but the business logic is wrong",
+                mitigation: "1) Each submission entry's name should be a complete natural-language description (e.g. 'The order ID that identifies the target Order for verification');\n" +
+                    "2) Avoid Technical identifiers as name (e.g. 'order_id' should become 'Order ID, used to query progress status');\n" +
+                    "3) Add failure_conditions in binding_hint to clarify failure scenarios;\n" +
+                    "4) Consider adding type validation logic in root (e.g. query the submitted object's objectType and match with expectation)",
+                evidence: `Vague entries: ${vagueEntries.map((e) => `identifier=${e.identifier}, name="${e.name}"`).join("; ")}`,
+            };
+        },
+    },
+    {
+        id: "R-X1-13",
+        data_source_class: "cross_type",
+        trigger: "Guard references its host object (Host Object) itself — circular reference pattern",
+        check: (ctx) => {
+            if (!ctx.scene)
+                return null;
+            const hostType = ctx.scene.host_object;
+            const circularEntry = ctx.table.find((e) => !e.b_submission && e.value_type === "Address" &&
+                e.object_type === hostType);
+            if (!circularEntry)
+                return null;
+            return {
+                id: "R-X1-13",
+                data_source_class: "cross_type",
+                level: "medium",
+                category: "binding_risk",
+                title: "Circular reference pattern (Guard references the host object itself; note creation order)",
+                description: `In the Guard's table, identifier=${circularEntry.identifier} has object_type equal to the host object type "${hostType}".\n` +
+                    "Circular reference pattern: the Guard is bound to a Host Object (e.g. Service.buy_guard) and also queries the Host Object's own fields.\n" +
+                    "Creation order constraints:\n" +
+                    "  1. The Host Object must be created first (unpublished state)\n" +
+                    "  2. When the Guard is created, the table uses the Host Object's name (not address); the SDK resolves it at binding time\n" +
+                    "  3. After the Guard is bound to the Host Object, the Host Object is published\n" +
+                    "Risks:\n" +
+                    "  - If the Host Object is already published (immutable), the Guard can no longer be bound\n" +
+                    "  - If the Host Object's name is modified after the Guard is created, the Guard's table reference is invalidated\n" +
+                    "  - Circular reference makes the Guard not independently testable (the Host Object must exist to verify)",
+                affected_stakeholders: ["provider"],
+                scenario: "Guard queries fields of the Service/Machine/Reward it is bound to; wrong creation order causes binding failure",
+                mitigation: "1) Ensure the Host Object is unpublished (bPublished=false) when creating and binding the Guard;\n" +
+                    "2) Use the Host Object's name rather than address in table (the SDK auto-resolves);\n" +
+                    "3) Perform Guard verification tests after the Host Object is published;\n" +
+                    "4) Use guard2file to export a Guard backup for restoring references during rebuild",
+                evidence: `Circular reference: identifier=${circularEntry.identifier}, object_type="${hostType}" → ${ctx.scene.host_object}`,
+            };
+        },
+    },
+    {
+        id: "R-X1-14",
+        data_source_class: "cross_type",
+        trigger: "Scene-specific reentrancy: Guard pass triggers a state-changing side effect (fund distribution, vote count, Arb creation) that does NOT naturally invalidate the Guard condition. " +
+            "Without an anti-reentrancy primitive, the same Signer can repeatedly pass the Guard. " +
+            "Additionally detects pseudo-protection: primitive present but not properly wrapped in logic_not (for Bool queries) or logic_equal(0) (for count queries).",
+        check: (ctx) => {
+            const spec = REENTRANCY_SPECS.find((s) => s.sceneId === ctx.scene?.id);
+            if (!spec)
+                return null;
+            const protection = detectReentrancyProtection(ctx.root, ctx.table, spec);
+            if (protection.state === "protected")
+                return null;
+            if (protection.state === "pseudo") {
                 return {
-                    id: "R-DR-01",
-                    level: ctx.rely.logic_or ? "low" : "medium",
-                    category: "dependency_risk",
-                    title: `rely ${logic} 依赖 ${ctx.rely.guards.length} 个外部 Guard`,
-                    description: `Guard 使用 rely ${logic} 依赖 ${ctx.rely.guards.length} 个外部 Guard。` +
-                        (ctx.rely.logic_or
-                            ? "OR 逻辑：任一依赖通过即可。如果某个依赖 Guard 设计宽松，可能成为绕过入口。"
-                            : "AND 逻辑：所有依赖必须通过。如果某个依赖 Guard 失效或被删除，当前 Guard 将永远失败。"),
-                    affected_stakeholders: ["customer", "provider"],
-                    scenario: ctx.rely.logic_or
-                        ? "依赖绕过：宽松的依赖 Guard 成为攻击入口"
-                        : "依赖失效：依赖 Guard 被删除导致当前 Guard 永远失败",
-                    mitigation: ctx.rely.logic_or
-                        ? "1) 审查每个依赖 Guard 的严格程度；2) 确保所有依赖 Guard 至少与当前 Guard 同等严格"
-                        : "1) 确认所有依赖 Guard 的 rep=true 且不可删除；2) 考虑是否真的需要 AND 依赖",
+                    id: "R-X1-14",
+                    data_source_class: "cross_type",
+                    level: "medium",
+                    category: "logic_gap",
+                    title: `Reentrancy pseudo-protection: anti-reentrancy primitive present but not properly wrapped (${spec.sceneId})`,
+                    description: `Scene: ${spec.sceneId}\n` +
+                        `The Guard root contains an anti-reentrancy primitive (${protection.foundPrimitiveName}), but it is NOT properly wrapped.\n` +
+                        "Proper wrapping rules:\n" +
+                        "  - Bool-returning primitives (exists-style): must be wrapped in logic_not\n" +
+                        "  - U64-returning primitives (count-style): must be compared to 0 via logic_equal\n" +
+                        "  - Address-returning primitives: must be wrapped in logic_not (None check)\n\n" +
+                        "WHY THIS IS DANGEROUS:\n" +
+                        "  The developer likely intended to prevent reentrancy but the wrapping is incorrect, " +
+                        "so the primitive does NOT actually block repeated Guard passes. This is arguably MORE " +
+                        "dangerous than absence — code reviewers see the primitive and assume protection is in place.\n\n" +
+                        `Scene rationale: ${spec.rationale}`,
+                    affected_stakeholders: deriveStakeholders(spec.sceneId),
+                    scenario: `Developer added anti-reentrancy primitive but used wrong wrapping; reentrancy exploit still possible in ${spec.sceneId}`,
+                    mitigation: "Fix the wrapping:\n" +
+                        "  - For exists-style (Bool) primitives: wrap in logic_not — { type: 'logic_not', node: { type: 'query', query: <primitive>, ... } }\n" +
+                        "  - For count-style (U64) primitives: compare to 0 — { type: 'logic_equal', nodes: [ { type: 'query', query: <primitive>, ... }, identifier(N) ] } where table[N].value = 0\n" +
+                        "  - For address-style primitives: wrap in logic_not (None check)\n" +
+                        `Then wrap the protection in logic_and with the existing root conditions.\n\n` +
+                        `Full mitigation for ${spec.sceneId}:\n${spec.mitigation}`,
+                    evidence: protection.evidence,
                 };
             }
-            return null;
+            const level = spec.level;
+            const stakeholders = deriveStakeholders(spec.sceneId);
+            return {
+                id: "R-X1-14",
+                data_source_class: "cross_type",
+                level,
+                category: "logic_gap",
+                title: level === "info"
+                    ? `Reentrancy reminder: ${spec.sceneId} has no anti-reentrancy primitive (LOW risk)`
+                    : `Reentrancy risk: ${spec.sceneId} has NO anti-reentrancy protection (${level.toUpperCase()})`,
+                description: `Scene: ${spec.sceneId}\n` +
+                    `Reentrancy risk level: ${level.toUpperCase()}\n\n` +
+                    `RATIONALE:\n${spec.rationale}\n\n` +
+                    (protection.evidence
+                        ? `DETECTION:\n${protection.evidence}\n\n`
+                        : "") +
+                    (level === "critical"
+                        ? "IMPACT: Without protection, the same Signer can repeatedly trigger the side effect (fund distribution / vote counting), causing direct fund loss or result manipulation. THIS IS A CRITICAL VULNERABILITY — the Guard MUST be rebuilt with an anti-reentrancy primitive before deployment.\n\n"
+                        : level === "high"
+                            ? "IMPACT: Without protection, the system can be abused (multiple dispute cases, arbitration harassment). Strongly recommended to add protection.\n\n"
+                            : "IMPACT: Low by default; only relevant if business intent requires single-action enforcement. Review the rationale above.\n\n"),
+                affected_stakeholders: stakeholders,
+                scenario: level === "info"
+                    ? `${spec.sceneId} lacks anti-reentrancy primitive; may or may not be needed depending on business intent`
+                    : `${spec.sceneId} lacks anti-reentrancy primitive; same Signer can repeatedly trigger the side effect`,
+                mitigation: spec.mitigation,
+                evidence: protection.evidence,
+            };
         },
     },
 ];
+function deriveStakeholders(sceneId) {
+    switch (sceneId) {
+        case "reward_guard":
+            return ["claimant", "provider"];
+        case "arbitration_voting_guard":
+            return ["customer", "provider", "arbitrator"];
+        case "arbitration_usage_guard":
+            return ["customer", "provider"];
+        case "service_order_allocators_guard":
+            return ["customer", "provider"];
+        default:
+            return ["provider"];
+    }
+}
 export function assessGuardRisks(params) {
     const ctx = {
         table: params.table,
@@ -369,6 +1695,7 @@ export function assessGuardRisks(params) {
         rely: params.rely,
         scene: params.scene,
         operation_type: params.operation_type,
+        sharing_recipients: params.sharing_recipients,
     };
     const risks = [];
     for (const rule of RISK_RULES) {
@@ -381,6 +1708,11 @@ export function assessGuardRisks(params) {
         }
     }
     const overall_risk = getOverallRiskLevel(risks);
+    const risks_by_data_source = {};
+    for (const risk of risks) {
+        risks_by_data_source[risk.data_source_class] =
+            (risks_by_data_source[risk.data_source_class] ?? 0) + 1;
+    }
     const stakeholder_advice = generateStakeholderAdvice(risks, params.scene);
     const needs_human_review = risks.some((r) => r.level === "critical") ||
         risks.filter((r) => r.level === "high").length >= 2;
@@ -390,6 +1722,7 @@ export function assessGuardRisks(params) {
         scene: params.scene,
         risks,
         overall_risk,
+        risks_by_data_source,
         stakeholder_advice,
         needs_human_review,
     };
@@ -419,22 +1752,22 @@ function generateStakeholderAdvice(risks, scene) {
             case "buy_guard":
                 if (!advice.customer)
                     advice.customer = [];
-                advice.customer.push("购买前确认 buy_guard 的验证逻辑，确保你的身份/凭证能通过验证");
+                advice.customer.push("Before purchase, verify the buy_guard logic to ensure your identity/credentials can pass validation");
                 break;
             case "order_allocators":
                 if (!advice.provider)
                     advice.provider = [];
-                advice.provider.push("确认 order_allocators 顺序，确保你的分账 Allocator 不会被前面的条件跳过");
+                advice.provider.push("Verify the order_allocators ordering to ensure your Allocator will not be skipped by preceding conditions");
                 break;
             case "voting_guard":
                 if (!advice.arbitrator)
                     advice.arbitrator = [];
-                advice.arbitrator.push("确认投票权重来源可信，建议从 EntityRegistrar 查询而非用户提交");
+                advice.arbitrator.push("Confirm the voting weight source is trustworthy; prefer querying EntityRegistrar rather than user-submitted data");
                 break;
             case "Forward.guard":
                 if (!advice.customer)
                     advice.customer = [];
-                advice.customer.push("确认 Forward.guard 的条件，确保你能满足推进条件，避免资金被锁定");
+                advice.customer.push("Verify the Forward.guard conditions to ensure you can satisfy the advancement criteria and avoid locked funds");
                 break;
         }
     }
@@ -442,12 +1775,12 @@ function generateStakeholderAdvice(risks, scene) {
 }
 function generateGuardSummary(params) {
     const parts = [];
-    parts.push(`table 条目数: ${params.table.length}`);
+    parts.push(`table entries: ${params.table.length}`);
     const submissions = params.table.filter((e) => e.b_submission).length;
-    parts.push(`提交数据: ${submissions} 条`);
-    parts.push(`root 类型: ${params.root?.type ?? "unknown"}`);
+    parts.push(`submitted data: ${submissions} entries`);
+    parts.push(`root type: ${params.root?.type ?? "unknown"}`);
     if (params.rely) {
-        parts.push(`rely: ${params.rely.guards.length} 个依赖 (${params.rely.logic_or ? "OR" : "AND"})`);
+        parts.push(`rely: ${params.rely.guards.length} dependencies (${params.rely.logic_or ? "OR" : "AND"})`);
     }
     return parts.join(", ");
 }
@@ -472,3 +1805,12 @@ export function getRiskSummary(assessment) {
             .map((r) => r.title),
     };
 }
+export function getRiskRulesByDataSourceClass(dataSourceClass) {
+    return RISK_RULES.filter((r) => r.data_source_class === dataSourceClass);
+}
+export function getAllRiskRules() {
+    return RISK_RULES;
+}
+export function getRiskRulesCount() {
+    return RISK_RULES.length;
+}