@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/machine-risk.js

@@ -0,0 +1,644 @@
+import { USER_DEFINED_PERM_INDEX_START, MAX_NODE_COUNT } from "./onchain-constants.js";
+export const MACHINE_RISK_RULES = [
+    {
+        id: "R-M1-01",
+        name: "No entry point",
+        category: "structural",
+        severity: "critical",
+        description: "Machine has no Pair with prev_node='' (no entry point). Workflow cannot start.",
+        detection: "Check if any pair has prev_node === ''",
+        recommendation: "Add at least one Pair with prev_node='' to serve as entry point.",
+        auto_fixable: false,
+        related_constraint: "MC-S-01",
+    },
+    {
+        id: "R-M1-02",
+        name: "No terminal node",
+        category: "structural",
+        severity: "critical",
+        description: "Machine has no terminal node (all nodes have outgoing Pairs). Workflow never completes.",
+        detection: "Check if any node has no outgoing Pair",
+        recommendation: "Designate at least one node as terminal (no outgoing Pair) and bind Allocator to it.",
+        auto_fixable: false,
+        related_constraint: "MC-S-02",
+    },
+    {
+        id: "R-M1-03",
+        name: "Dead-end node (non-terminal)",
+        category: "structural",
+        severity: "medium",
+        description: "Non-terminal node has no outgoing Pair. Workflow stalls at this node.",
+        detection: "Find nodes with no outgoing Pair that are not intended terminals",
+        recommendation: "Add outgoing Pair or designate as terminal with Allocator.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M1-04",
+        name: "Orphaned node",
+        category: "structural",
+        severity: "high",
+        description: "Node has no incoming Pair (except entry). Unreachable.",
+        detection: "Find non-entry nodes with no incoming Pair",
+        recommendation: "Add Pair from existing node to this orphaned node, or remove it.",
+        auto_fixable: false,
+        related_constraint: "MC-S-03",
+    },
+    {
+        id: "R-M1-05",
+        name: "Dead branch (competing Pair always loses)",
+        category: "structural",
+        severity: "high",
+        description: "A competing Pair's threshold can never be met because users always prefer another path.",
+        detection: "Analyze threshold achievability across competing Pairs",
+        recommendation: "Make thresholds balanced, or remove the dead branch.",
+        auto_fixable: false,
+        related_constraint: "MC-S-04",
+    },
+    {
+        id: "R-M1-06",
+        name: "Cycle in DAG",
+        category: "structural",
+        severity: "critical",
+        description: "Workflow has a cycle. Nodes reference each other circularly.",
+        detection: "DFS cycle detection",
+        recommendation: "Break the cycle by removing one Pair.",
+        auto_fixable: false,
+        related_constraint: "MC-S-05",
+    },
+    {
+        id: "R-M1-07",
+        name: "Exceeds MAX_NODE_COUNT (100)",
+        category: "structural",
+        severity: "critical",
+        description: "Node count exceeds on-chain limit. Publish will fail.",
+        detection: `nodes.length > ${MAX_NODE_COUNT}`,
+        recommendation: "Reduce node count or split into multiple Machines.",
+        auto_fixable: false,
+        related_constraint: "MC-C-01",
+    },
+    {
+        id: "R-M1-08",
+        name: "Exceeds MAX_NODE_PAIR_COUNT (40)",
+        category: "structural",
+        severity: "high",
+        description: "A single node's Pairs exceed on-chain limit. Publish will fail.",
+        detection: "Find node where pairs.length > 40",
+        recommendation: "Split node or simplify branches to reduce Pair count per node.",
+        auto_fixable: false,
+        related_constraint: "MC-C-02",
+    },
+    {
+        id: "R-M1-09",
+        name: "Exceeds MAX_FORWARD_COUNT (20)",
+        category: "structural",
+        severity: "high",
+        description: "A single Pair's Forwards exceed on-chain limit. Publish will fail.",
+        detection: "Find Pair where forwards.length > 20",
+        recommendation: "Split Pair or merge Forwards to reduce Forward count per Pair.",
+        auto_fixable: false,
+        related_constraint: "MC-C-03",
+    },
+    {
+        id: "R-M1-10",
+        name: "Duplicate node name",
+        category: "structural",
+        severity: "critical",
+        description: "Two nodes have the same name. On-chain will reject.",
+        detection: "Find duplicate names in nodes array",
+        recommendation: "Rename one of the duplicates.",
+        auto_fixable: false,
+        related_constraint: "MC-C-04",
+    },
+    {
+        id: "R-M2-01",
+        name: "Guard not created",
+        category: "guard_integration",
+        severity: "critical",
+        description: "Forward references a Guard that is not yet created on-chain. Forward execution will fail Guard verification.",
+        detection: "Check forward.guard against published_guards set",
+        recommendation: "Create the Guard object before publishing this Machine.",
+        auto_fixable: false,
+        related_constraint: "MC-C-09",
+    },
+    {
+        id: "R-M2-02",
+        name: "Guard not tested via gen_passport",
+        category: "guard_integration",
+        severity: "high",
+        description: "Guard has not been tested via gen_passport. Guard may have bugs, cannot be fixed after publish.",
+        detection: "Check testnet test records for this Guard",
+        recommendation: "Run gen_passport on testnet before binding to Machine.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M2-03",
+        name: "Guard + Machine immutability deadlock",
+        category: "guard_integration",
+        severity: "critical",
+        description: "After Machine publish, a Guard bug is discovered. Guard is immutable (cannot be fixed), Machine is immutable (cannot be rebound).",
+        detection: "Verify all Guards tested before Machine publish",
+        recommendation: "Keep Machine unpublished until all Guards are verified.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M2-04",
+        name: "retained_submission index mismatch",
+        category: "guard_integration",
+        severity: "high",
+        description: "Forward's retained_submission key does not correspond to Guard table b_submission=true entry. Retained data fails or is incorrect.",
+        detection: "Cross-check forward.retained_submission against Guard table entries",
+        recommendation: "Align retained_submission key with Guard table b_submission=true identifier.",
+        auto_fixable: true,
+        related_constraint: "MC-C-11",
+    },
+    {
+        id: "R-M2-05",
+        name: "Guard reentry risk",
+        category: "guard_integration",
+        severity: "high",
+        description: "Guard lacks anti-reentry mechanism (see Guard R-X1-14). Risk of duplicate execution or vote manipulation.",
+        detection: "For each Guard scene, verify anti-reentry Guard is configured (see Guard semantic layer R-X1-14)",
+        recommendation: "Add anti-reentry Guard for each scenario (see Guard semantic layer R-X1-14).",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M2-06",
+        name: "Guard scene mismatch",
+        category: "guard_integration",
+        severity: "medium",
+        description: "Forward's bound Guard scene does not match Forward's business (e.g., Forward uses reward_guard instead of machine_forward_guard).",
+        detection: "Cross-check Guard scene against Forward business purpose",
+        recommendation: "Use the correct Guard scene (machine_forward_guard).",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M2-07",
+        name: "Cross-Machine Guard dependency cycle",
+        category: "guard_integration",
+        severity: "critical",
+        description: "Machine A depends on Machine B (via Guard), B depends on A. Circular dependency.",
+        detection: "Identify cross-Machine Guard references and detect cycles",
+        recommendation: "Ensure cross-Machine dependencies are unidirectional.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M2-08",
+        name: "Guard references unpublished object",
+        category: "guard_integration",
+        severity: "high",
+        description: "Guard table references an object (e.g., Service) that is not yet published.",
+        detection: "Cross-check Guard table object references against published objects set",
+        recommendation: "Use P16 circular reference pattern (name instead of address), or publish referenced objects first.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M3-01",
+        name: "Forward without permission",
+        category: "permission",
+        severity: "critical",
+        description: "Forward has neither namedOperator nor permissionIndex. Cannot be executed.",
+        detection: "Check each forward has at least one of namedOperator or permissionIndex",
+        recommendation: "Set namedOperator='' for OrderHolder, or set permissionIndex.",
+        auto_fixable: false,
+        related_constraint: "MC-C-07",
+    },
+    {
+        id: "R-M3-02",
+        name: "permissionIndex out of bounds",
+        category: "permission",
+        severity: "critical",
+        description: "Forward's permissionIndex >= Permission.indices.length. Execution will fail.",
+        detection: "Check permission_index < Permission.indices.length",
+        recommendation: "Use a valid permission index or extend Permission.indices.",
+        auto_fixable: false,
+        related_constraint: "MC-C-08",
+    },
+    {
+        id: "R-M3-03",
+        name: "Permission rotation failure",
+        category: "permission",
+        severity: "high",
+        description: "Permission object updated, indices order changed. Original permissionIndex now points to wrong permission.",
+        detection: "Detect Permission object update that reorders indices",
+        recommendation: "Use custom Permission; document index meanings; avoid frequent Permission updates.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M3-04",
+        name: "OrderHolder misuse",
+        category: "permission",
+        severity: "medium",
+        description: "namedOperator='' used in non-customer-operation scenarios. Non-intended personnel gain operation permission.",
+        detection: "Find Forwards with namedOperator='' on non-customer-operation nodes",
+        recommendation: "Clarify ''=OrderHolder (customer), not 'anyone'. Use namedOperator for specific roles.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M3-05",
+        name: "NamedOperator not assigned at Progress creation",
+        category: "permission",
+        severity: "high",
+        description: "Forward expects namedOperator role but Progress doesn't have it assigned. " +
+            "Note: MCP API layer supports progress_new.progress_namedOperator (SDK translates to namedOperator_add), " +
+            "but Move layer progress::new does NOT accept it (see 06 §14.5).",
+        detection: "Verify progress_namedOperator is provided in Progress creation",
+        recommendation: "Pass progress_namedOperator in progress_new, or call namedOperator_add separately.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M3-06",
+        name: "Permission game imbalance",
+        category: "permission",
+        severity: "medium",
+        description: "One party has excessive permission, can unilaterally advance workflow. Game theory imbalance.",
+        detection: "Analyze permission distribution across parties",
+        recommendation: "Use dual-signature (threshold=2) or multi-signature mechanism to balance power.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M3-07",
+        name: "Permission combination OR semantic misuse",
+        category: "permission",
+        severity: "medium",
+        description: "Both namedOperator and permissionIndex set, but OR semantic not understood. More people than expected can execute Forward.",
+        detection: "Find Forwards with both namedOperator and permissionIndex set",
+        recommendation: "Clarify that when both permissions are non-null, it is OR relation (either can execute).",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M3-08",
+        name: "permissionIndex below USER_DEFINED_PERM_INDEX_START (1000)",
+        category: "permission",
+        severity: "critical",
+        description: "Forward's permissionIndex < 1000. On-chain constant USER_DEFINED_PERM_INDEX_START = 1000 " +
+            "in permission.move reserves indexes 0-999 for built-in permissions. Using index < 1000 " +
+            "causes confusion with built-in permissions and is a hard on-chain constraint (see doc 06 §4.4).",
+        detection: "Check each forward with permission_index < 1000",
+        recommendation: "Use permission_index >= 1000 (e.g., 1000, 1001, 1002, ...). Reserve 0-999 for built-in permissions.",
+        auto_fixable: false,
+        related_constraint: "MC-C-08",
+    },
+    {
+        id: "R-M4-01",
+        name: "No backup before publish",
+        category: "immutability",
+        severity: "high",
+        description: "machineNode2file export not created before publish. Cannot restore if publish fails.",
+        detection: "Check backup_created flag",
+        recommendation: "Run machineNode2file before publish to create backup.",
+        auto_fixable: true,
+        related_constraint: "MC-P-02",
+    },
+    {
+        id: "R-M4-02",
+        name: "No testnet verification before mainnet",
+        category: "immutability",
+        severity: "medium",
+        description: "Directly publishing to mainnet without testnet verification. Potential bugs may cause fund loss.",
+        detection: "Check network === 'mainnet' && !testnet_test_passed",
+        recommendation: "Test on testnet first. Verify Progress runs end-to-end.",
+        auto_fixable: false,
+        related_constraint: "MC-P-03",
+    },
+    {
+        id: "R-M4-03",
+        name: "Guards not all created before publish",
+        category: "immutability",
+        severity: "critical",
+        description: "Some Forward.guard is still null, but design requires Guard. Cannot add Guard after publish (immutability deadlock).",
+        detection: "Check if all required Guards are created and bound",
+        recommendation: "Create and bind all Guards before publishing Machine.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M4-04",
+        name: "Publish order incorrect",
+        category: "immutability",
+        severity: "critical",
+        description: "Attempting to publish Machine before creating Guards. Guards cannot bind to already-published Machine.",
+        detection: "Verify dependency order: Permission → Machine(unpublished) → Guard → bind → publish",
+        recommendation: "Follow dependency order: Permission → Machine(unpublished) → Guard → bind → publish.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M4-05",
+        name: "Allocation not configured",
+        category: "immutability",
+        severity: "medium",
+        description: "Terminal node not mapped to Allocator. Funds cannot be distributed after workflow completes.",
+        detection: "Check if terminal nodes have Allocator mapping",
+        recommendation: "Configure Allocator for each terminal node.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M4-06",
+        name: "clear operation without backup",
+        category: "immutability",
+        severity: "high",
+        description: "Executing node clear before exporting backup. All node data lost, cannot recover.",
+        detection: "Check if machineNode2file backup created before clear operation",
+        recommendation: "Run machineNode2file backup before any clear operation.",
+        auto_fixable: true,
+    },
+    {
+        id: "R-M5-01",
+        name: "Service not created",
+        category: "environment",
+        severity: "high",
+        description: "Machine design complete but Service not created. Machine cannot bind to Service.",
+        detection: "Check if Service object is in published_services set",
+        recommendation: "Create Service first, then design/publish Machine.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M5-02",
+        name: "Permission object mismatch",
+        category: "environment",
+        severity: "high",
+        description: "Machine's Permission differs from Service's Permission. Permission organization inconsistent, may cause operation failure.",
+        detection: "Cross-check Machine's Permission against Service's Permission",
+        recommendation: "Use the same Permission for Machine and Service (or explicitly document different organizations).",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M5-03",
+        name: "Allocation configuration incomplete",
+        category: "environment",
+        severity: "high",
+        description: "Service's order_allocators not configured or misconfigured. Terminal node funds cannot be distributed.",
+        detection: "Check if Service.order_allocators is configured for each terminal node",
+        recommendation: "Configure Service.order_allocators, one Allocator per terminal node.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M5-04",
+        name: "Reward object not created",
+        category: "environment",
+        severity: "medium",
+        description: "Reward incentive scenario referenced but Reward object not created.",
+        detection: "Check if Reward object is in published_rewards set",
+        recommendation: "Create Reward object first, then design Guard.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M5-05",
+        name: "Arbitration object not created",
+        category: "environment",
+        severity: "medium",
+        description: "Arbitration scenario referenced but Arbitration object not created.",
+        detection: "Check if Arbitration object is in published_arbitrations set",
+        recommendation: "Create Arbitration object first.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M5-06",
+        name: "Cross-Machine dependency not published",
+        category: "environment",
+        severity: "critical",
+        description: "Machine A depends on Machine B, but B is not published. Guard query for Machine B's Progress will fail. " +
+            "Dependency verification: indirect via progress::new -> assert_published (see 06 §14.6).",
+        detection: "Check machine_ref against published_machines set",
+        recommendation: "Ensure upstream Machine is published first.",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M5-07",
+        name: "Repository not created",
+        category: "environment",
+        severity: "medium",
+        description: "Guard references Repository but not created. Guard query will fail.",
+        detection: "Check repository_ref against published repositories set",
+        recommendation: "Create and publish Repository first. Note: consensus_repositories is declarative-only (see 06 §14.4).",
+        auto_fixable: false,
+    },
+    {
+        id: "R-M5-08",
+        name: "Object dependency table incomplete",
+        category: "environment",
+        severity: "low",
+        description: "Project object dependency table missing some objects. Design decisions based on incomplete information.",
+        detection: "Scan project environment for missing object references",
+        recommendation: "Use machine-context.ts to scan complete project environment.",
+        auto_fixable: false,
+    },
+];
+export function assessMachineRisks(machine, context) {
+    const detected = [];
+    detected.push(...checkStructuralRisks(machine));
+    detected.push(...checkGuardIntegrationRisks(machine, context));
+    detected.push(...checkPermissionRisks(machine));
+    detected.push(...checkImmutabilityRisks(machine, context));
+    detected.push(...checkEnvironmentRisks(machine, context));
+    const summary = {
+        critical: detected.filter((r) => r.severity === "critical").length,
+        high: detected.filter((r) => r.severity === "high").length,
+        medium: detected.filter((r) => r.severity === "medium").length,
+        low: detected.filter((r) => r.severity === "low").length,
+    };
+    let overall_level = "low";
+    if (summary.critical > 0)
+        overall_level = "critical";
+    else if (summary.high > 0)
+        overall_level = "high";
+    else if (summary.medium > 0)
+        overall_level = "medium";
+    else if (summary.low > 0)
+        overall_level = "low";
+    let recommendation;
+    if (summary.critical > 0) {
+        recommendation = "do_not_publish";
+    }
+    else if (summary.high > 2) {
+        recommendation = "fix_first";
+    }
+    else {
+        recommendation = "publish";
+    }
+    return {
+        overall_level,
+        detected_risks: detected,
+        summary,
+        recommendation,
+    };
+}
+function checkStructuralRisks(machine) {
+    const risks = [];
+    const hasEntry = machine.pairs.some((p) => p.prev_node === "");
+    if (!hasEntry) {
+        risks.push(makeRisk("R-M1-01", "No Pair with prev_node='' found. Workflow cannot start."));
+    }
+    const allPrevNodesForTerminal = new Set(machine.pairs.map((p) => p.prev_node).filter((n) => n !== ""));
+    const allNodes = new Set(machine.nodes.map((n) => n.name));
+    const terminals = [...allNodes].filter((n) => !allPrevNodesForTerminal.has(n));
+    if (terminals.length === 0) {
+        risks.push(makeRisk("R-M1-02", "No terminal node found. Workflow never completes."));
+    }
+    const entryNodes = new Set(machine.pairs.filter((p) => p.prev_node === "").map((p) => p.next_node));
+    const allPrevNodes = new Set(machine.pairs.map((p) => p.prev_node).filter((n) => n !== ""));
+    for (const node of machine.nodes) {
+        if (!entryNodes.has(node.name) && !allPrevNodes.has(node.name)) {
+            const hasIncoming = machine.pairs.some((p) => p.next_node === node.name);
+            if (!hasIncoming) {
+                risks.push(makeRisk("R-M1-04", `Node "${node.name}" is orphaned (no incoming Pair).`));
+            }
+        }
+    }
+    if (machine.nodes.length > MAX_NODE_COUNT) {
+        risks.push(makeRisk("R-M1-07", `Node count ${machine.nodes.length} exceeds MAX_NODE_COUNT (${MAX_NODE_COUNT}).`));
+    }
+    const pairsPerNode = new Map();
+    for (const p of machine.pairs) {
+        pairsPerNode.set(p.next_node, (pairsPerNode.get(p.next_node) ?? 0) + 1);
+    }
+    for (const [nodeName, pairCount] of pairsPerNode) {
+        if (pairCount > 40) {
+            risks.push(makeRisk("R-M1-08", `Node "${nodeName}" has ${pairCount} Pairs, exceeds MAX_NODE_PAIR_COUNT (40).`));
+        }
+    }
+    for (const pair of machine.pairs) {
+        if (pair.forwards.length > 20) {
+            risks.push(makeRisk("R-M1-09", `Pair (${pair.prev_node} -> ${pair.next_node}) has ${pair.forwards.length} Forwards, exceeds MAX_FORWARD_COUNT (20).`));
+        }
+    }
+    const nodeNames = machine.nodes.map((n) => n.name);
+    const duplicates = nodeNames.filter((name, idx) => nodeNames.indexOf(name) !== idx);
+    if (duplicates.length > 0) {
+        risks.push(makeRisk("R-M1-10", `Duplicate node names: ${[...new Set(duplicates)].join(", ")}`));
+    }
+    return risks;
+}
+function checkGuardIntegrationRisks(machine, context) {
+    const risks = [];
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            if (fwd.guard && !context.published_guards.has(fwd.guard)) {
+                risks.push(makeRisk("R-M2-01", `Forward "${fwd.name}" references Guard "${fwd.guard}" not in published_guards.`));
+            }
+            if (fwd.retained_submission && !fwd.guard) {
+                risks.push(makeRisk("R-M2-04", `Forward "${fwd.name}" has retained_submission but no Guard. retained_submission requires a Guard.`));
+            }
+        }
+    }
+    return risks;
+}
+function checkPermissionRisks(machine) {
+    const risks = [];
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            const hasNamed = fwd.named_operator !== undefined && fwd.named_operator !== null;
+            const hasPerm = fwd.permission_index !== undefined && fwd.permission_index !== null;
+            if (!hasNamed && !hasPerm) {
+                risks.push(makeRisk("R-M3-01", `Forward "${fwd.name}" in Pair (${pair.prev_node} -> ${pair.next_node}) has no permission.`));
+            }
+        }
+    }
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            const hasNamed = fwd.named_operator !== undefined && fwd.named_operator !== null;
+            const hasPerm = fwd.permission_index !== undefined && fwd.permission_index !== null;
+            if (hasNamed && hasPerm) {
+                risks.push(makeRisk("R-M3-07", `Forward "${fwd.name}" in Pair (${pair.prev_node} -> ${pair.next_node}) has both namedOperator and permissionIndex (OR semantic).`));
+            }
+        }
+    }
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            if (fwd.permission_index !== undefined &&
+                fwd.permission_index !== null &&
+                fwd.permission_index < USER_DEFINED_PERM_INDEX_START) {
+                risks.push(makeRisk("R-M3-08", `Forward "${fwd.name}" in Pair (${pair.prev_node} -> ${pair.next_node}) ` +
+                    `has permission_index=${fwd.permission_index} < ${USER_DEFINED_PERM_INDEX_START}. ` +
+                    `Indexes 0-999 are reserved for built-in permissions.`));
+            }
+        }
+    }
+    return risks;
+}
+function checkImmutabilityRisks(machine, context) {
+    const risks = [];
+    if (context.network === "mainnet" && !context.testnet_test_passed) {
+        risks.push(makeRisk("R-M4-02", "Mainnet publish attempted without testnet test passing."));
+    }
+    const referencedGuards = new Set();
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            if (fwd.guard)
+                referencedGuards.add(fwd.guard);
+        }
+    }
+    const missingGuards = [...referencedGuards].filter((g) => !context.published_guards.has(g));
+    if (missingGuards.length > 0) {
+        risks.push(makeRisk("R-M4-03", `Guards not all created before publish. Missing: ${missingGuards.join(", ")}`));
+    }
+    return risks;
+}
+function checkEnvironmentRisks(machine, context) {
+    const risks = [];
+    const referencedGuards = new Set();
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            if (fwd.guard)
+                referencedGuards.add(fwd.guard);
+        }
+    }
+    const missingGuards = [...referencedGuards].filter((g) => !context.published_guards.has(g));
+    if (missingGuards.length > 0) {
+        risks.push(makeRisk("R-M5-08", `Object dependency table incomplete. Missing Guards: ${missingGuards.join(", ")}`));
+    }
+    return risks;
+}
+function makeRisk(ruleId, detail) {
+    const rule = MACHINE_RISK_RULES.find((r) => r.id === ruleId);
+    if (!rule) {
+        return {
+            rule_id: ruleId,
+            name: "Unknown",
+            severity: "low",
+            detail,
+            recommendation: "Investigate manually.",
+            auto_fixable: false,
+        };
+    }
+    return {
+        rule_id: rule.id,
+        name: rule.name,
+        severity: rule.severity,
+        detail,
+        recommendation: rule.recommendation,
+        auto_fixable: rule.auto_fixable,
+    };
+}
+export function getRiskRulesByCategory(category) {
+    return MACHINE_RISK_RULES.filter((r) => r.category === category);
+}
+export function getRiskRuleById(id) {
+    return MACHINE_RISK_RULES.find((r) => r.id === id);
+}
+export function getRiskRulesBySeverity(severity) {
+    return MACHINE_RISK_RULES.filter((r) => r.severity === severity);
+}
+export function getAutoFixableRules() {
+    return MACHINE_RISK_RULES.filter((r) => r.auto_fixable);
+}
+export function getRiskSummary(assessment) {
+    const lines = [
+        `Overall Risk Level: ${assessment.overall_level.toUpperCase()}`,
+        `Recommendation: ${assessment.recommendation}`,
+        "",
+        "Summary:",
+        `  Critical: ${assessment.summary.critical}`,
+        `  High:     ${assessment.summary.high}`,
+        `  Medium:   ${assessment.summary.medium}`,
+        `  Low:      ${assessment.summary.low}`,
+        "",
+        "Detected Risks:",
+    ];
+    for (const risk of assessment.detected_risks) {
+        lines.push(`  [${risk.severity.toUpperCase()}] ${risk.rule_id}: ${risk.name}`);
+        lines.push(`    Detail: ${risk.detail}`);
+        lines.push(`    Fix: ${risk.recommendation}`);
+    }
+    return lines.join("\n");
+}
+export const MACHINE_RISK_VERSION = "1.0.0";
+export const MACHINE_RISK_RULES_COUNT = MACHINE_RISK_RULES.length;