@momo-kits/native-kits 0.157.1-skill.3-debug → 0.157.1-skill.6-debug

package/.claude/skills/momo-native-kits-skills/scripts/rules/chip.js

@@ -0,0 +1,59 @@
+/**
+ * Chip validation rules
+ */
+
+module.exports = [
+    {
+        id: 'chip-no-text',
+        category: 'Chip',
+        name: 'Chip uses "label" (not "text")',
+        severity: 'error',
+        applies: (content) => /\bChip\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Chip\s*\([^)]*\btext\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Chip has no "text" — use "label" instead' };
+            }
+            return { passed: true, evidence: 'Chip uses correct "label" param' };
+        }
+    },
+    {
+        id: 'chip-no-isSelected',
+        category: 'Chip',
+        name: 'Chip uses "selected" (not "isSelected")',
+        severity: 'error',
+        applies: (content) => /\bChip\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Chip\s*\([^)]*\bisSelected\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Chip has no "isSelected" — use "selected" instead' };
+            }
+            return { passed: true, evidence: 'Chip uses correct "selected" param' };
+        }
+    },
+    {
+        id: 'chip-no-leadingIcon',
+        category: 'Chip',
+        name: 'Chip uses "iconLeft" (not "leadingIcon")',
+        severity: 'error',
+        applies: (content) => /\bChip\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Chip\s*\([^)]*\bleadingIcon\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Chip has no "leadingIcon" — use "iconLeft" instead' };
+            }
+            return { passed: true, evidence: 'Chip uses correct icon param names' };
+        }
+    },
+    {
+        id: 'chip-size-enum',
+        category: 'Chip',
+        name: 'Chip uses ChipSize enum',
+        severity: 'error',
+        applies: (content) => /\bChip\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            // Check for wrong Size enum (Button's enum) used on Chip
+            if (/Chip\s*\([^)]*\bsize\s*=\s*Size\./s.test(content)) {
+                return { passed: false, evidence: 'Chip uses Size.X — should use ChipSize.SMALL or ChipSize.LARGE' };
+            }
+            return { passed: true, evidence: 'Chip size enum looks correct' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/divider.js

@@ -0,0 +1,19 @@
+/**
+ * Divider validation rules
+ */
+
+module.exports = [
+    {
+        id: 'divider-no-params',
+        category: 'Divider',
+        name: 'Divider() takes no parameters',
+        severity: 'warning',
+        applies: (content) => /\bDivider\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Divider\s*\([^)]+\)/s.test(content)) {
+                return { passed: false, evidence: 'Divider() takes no parameters' };
+            }
+            return { passed: true, evidence: 'Divider() called correctly' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/global.js

@@ -0,0 +1,61 @@
+/**
+ * Global validation rules
+ * - No Material Design imports
+ * - No Material components used
+ * - Uses vn.momo.kits imports
+ */
+
+module.exports = [
+    {
+        id: 'no-material-import',
+        category: 'Global',
+        name: 'No Material Design imports',
+        severity: 'error',
+        validate(content) {
+            const patterns = [
+                { regex: /import\s+androidx\.compose\.material\b/, label: 'androidx.compose.material' },
+                { regex: /import\s+androidx\.compose\.material3\b/, label: 'androidx.compose.material3' },
+            ];
+            for (const p of patterns) {
+                if (p.regex.test(content)) {
+                    return { passed: false, evidence: `Found forbidden import: ${p.label}` };
+                }
+            }
+            return { passed: true, evidence: 'No Material imports found' };
+        }
+    },
+    {
+        id: 'no-material-components',
+        category: 'Global',
+        name: 'No Material components used',
+        severity: 'error',
+        validate(content) {
+            // Only flag Material-specific components that don't exist in MoMo
+            // Note: Switch, CheckBox exist in both Material and MoMo - handled by component-specific rules
+            const materialComponents = [
+                'RadioButton', 'MaterialTheme', 'TextField', 'OutlinedTextField',
+                'AlertDialog', 'FloatingActionButton', 'TopAppBar', 'BottomNavigation',
+                'NavigationBar', 'Scaffold',
+            ];
+            for (const comp of materialComponents) {
+                const regex = new RegExp(`\\b${comp}\\s*\\(`);
+                if (regex.test(content)) {
+                    return { passed: false, evidence: `Found Material component: ${comp}()` };
+                }
+            }
+            return { passed: true, evidence: 'No Material components used' };
+        }
+    },
+    {
+        id: 'momo-kits-import',
+        category: 'Global',
+        name: 'Uses vn.momo.kits imports',
+        severity: 'warning',
+        validate(content) {
+            if (/import\s+vn\.momo\.kits\./.test(content)) {
+                return { passed: true, evidence: 'Found vn.momo.kits imports' };
+            }
+            return { passed: false, evidence: 'No vn.momo.kits imports found' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/index.js

@@ -0,0 +1,54 @@
+/**
+ * File: scripts/rules/index.js
+ * Created At: 2026-03-16 10:00:00 +07:00
+ * Created By: AI
+ * AI Agent: Claude
+ * Model: opus-4-6
+ *
+ * All validation rules
+ * Export all rule files for MoMo Native Kits validation
+ */
+
+// AI-GENERATED START: export all validation rules
+const global = require('./global');
+const button = require('./button');
+const checkbox = require('./checkbox');
+const switch_ = require('./switch');
+const chip = require('./chip');
+const badge = require('./badge');
+const skeleton = require('./skeleton');
+const tooltip = require('./tooltip');
+const snackbar = require('./snackbar');
+const trustbanner = require('./trustbanner');
+const divider = require('./divider');
+const radio = require('./radio');
+const popup = require('./popup');
+const input = require('./input');
+const bottomtab = require('./bottomtab');
+const text = require('./text');
+const state = require('./state');
+const card = require('./card');
+const navigation = require('./navigation');
+
+module.exports = [
+    ...global,
+    ...button,
+    ...checkbox,
+    ...switch_,
+    ...chip,
+    ...badge,
+    ...skeleton,
+    ...tooltip,
+    ...snackbar,
+    ...trustbanner,
+    ...divider,
+    ...radio,
+    ...popup,
+    ...input,
+    ...bottomtab,
+    ...text,
+    ...state,
+    ...card,
+    ...navigation,
+];
+// AI-GENERATED END: export all validation rules

package/.claude/skills/momo-native-kits-skills/scripts/rules/input.js

@@ -0,0 +1,32 @@
+/**
+ * InputPhoneNumber validation rules
+ */
+
+module.exports = [
+    {
+        id: 'phone-no-floatingValue',
+        category: 'InputPhoneNumber',
+        name: 'InputPhoneNumber has no floatingValue',
+        severity: 'error',
+        applies: (content) => /InputPhoneNumber\s*\(/.test(content),
+        validate(content) {
+            if (/InputPhoneNumber[^)]*floatingValue\s*=/.test(content)) {
+                return { passed: false, evidence: 'floatingValue does not exist on InputPhoneNumber' };
+            }
+            return { passed: true, evidence: 'No invalid floatingValue usage' };
+        }
+    },
+    {
+        id: 'phone-no-countryCode',
+        category: 'InputPhoneNumber',
+        name: 'InputPhoneNumber has no countryCode',
+        severity: 'error',
+        applies: (content) => /InputPhoneNumber\s*\(/.test(content),
+        validate(content) {
+            if (/InputPhoneNumber[^)]*countryCode\s*=/.test(content)) {
+                return { passed: false, evidence: 'countryCode does not exist — country code +84 is hardcoded' };
+            }
+            return { passed: true, evidence: 'No invalid countryCode usage' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/navigation.js

@@ -0,0 +1,48 @@
+/**
+ * Navigation validation rules
+ */
+
+module.exports = [
+    {
+        id: 'nav-single-container',
+        category: 'Navigation',
+        name: 'Only one NavigationContainer per file',
+        severity: 'warning',
+        applies: (content) => /NavigationContainer\s*\(/.test(content),
+        validate(content) {
+            const count = (content.match(/NavigationContainer\s*\(/g) || []).length;
+            if (count > 1) {
+                return { passed: false, evidence: `Found ${count} NavigationContainer — should be only 1 per Fragment` };
+            }
+            return { passed: true, evidence: 'Single NavigationContainer found' };
+        }
+    },
+    {
+        id: 'nav-setOptions-in-launched',
+        category: 'Navigation',
+        name: 'setOptions inside LaunchedEffect',
+        severity: 'warning',
+        applies: (content) => /setOptions\s*\(/.test(content),
+        validate(content) {
+            const hasLaunchedEffect = /LaunchedEffect[\s\S]*setOptions/.test(content);
+            const hasOnClick = /onClick[\s\S]{0,100}setOptions/.test(content);
+            if (!hasLaunchedEffect && !hasOnClick) {
+                return { passed: false, evidence: 'setOptions should be called inside LaunchedEffect(Unit) or event handler' };
+            }
+            return { passed: true, evidence: 'setOptions used in correct scope' };
+        }
+    },
+    {
+        id: 'nav-no-scaffold',
+        category: 'Navigation',
+        name: 'No Scaffold (use NavigationContainer)',
+        severity: 'error',
+        applies: (content) => /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/\bScaffold\s*\(/.test(content)) {
+                return { passed: false, evidence: 'Scaffold is Material — use NavigationContainer instead' };
+            }
+            return { passed: true, evidence: 'No Scaffold usage' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/popup.js

@@ -0,0 +1,45 @@
+/**
+ * PopupNotify validation rules
+ */
+
+module.exports = [
+    {
+        id: 'popup-no-message',
+        category: 'PopupNotify',
+        name: 'PopupNotify uses description (not message)',
+        severity: 'error',
+        applies: (content) => /PopupNotifyProps/.test(content),
+        validate(content) {
+            if (/PopupNotifyProps\s*\([^)]*\bmessage\s*=/s.test(content)) {
+                return { passed: false, evidence: 'PopupNotifyProps uses "message" — should be "description"' };
+            }
+            return { passed: true, evidence: 'Uses "description" correctly' };
+        }
+    },
+    {
+        id: 'popup-no-type',
+        category: 'PopupNotify',
+        name: 'No PopupNotifyType (does not exist)',
+        severity: 'error',
+        applies: (content) => /PopupNotify/.test(content),
+        validate(content) {
+            if (/PopupNotifyType/.test(content)) {
+                return { passed: false, evidence: 'PopupNotifyType does not exist — remove type param' };
+            }
+            return { passed: true, evidence: 'No invalid PopupNotifyType usage' };
+        }
+    },
+    {
+        id: 'popup-onIconClose',
+        category: 'PopupNotify',
+        name: 'PopupNotify has onIconClose (required)',
+        severity: 'error',
+        applies: (content) => /PopupNotifyProps\s*\(/.test(content),
+        validate(content) {
+            if (!/onIconClose\s*=/.test(content)) {
+                return { passed: false, evidence: 'Missing required onIconClose in PopupNotifyProps' };
+            }
+            return { passed: true, evidence: 'onIconClose provided' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/radio.js

@@ -0,0 +1,105 @@
+/**
+ * Radio validation rules
+ */
+
+module.exports = [
+    {
+        id: 'radio-onChange',
+        category: 'Radio',
+        name: 'Radio onChange is () -> Unit',
+        severity: 'error',
+        applies: (content) => /\bRadio\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/onChange\s*=\s*\{[^}]*=\s*it\s*\}/.test(content)) {
+                return { passed: false, evidence: 'onChange uses "it" — Radio.onChange is () -> Unit, not (T) -> Unit' };
+            }
+            return { passed: true, evidence: 'Radio onChange signature correct' };
+        }
+    },
+    {
+        id: 'radio-no-onSelect',
+        category: 'Radio',
+        name: 'Radio uses "onChange" (not "onSelect")',
+        severity: 'error',
+        applies: (content) => /\bRadio\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Radio\s*\([^)]*\bonSelect\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Radio has no "onSelect" — use "onChange" instead' };
+            }
+            return { passed: true, evidence: 'Radio uses correct callback name' };
+        }
+    },
+    {
+        id: 'radio-no-generic-type',
+        category: 'Radio',
+        name: 'No generic type parameter on Radio',
+        severity: 'error',
+        applies: (content) => /\bRadio\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            const genericPattern = /Radio\s*<[A-Za-z]+>\s*\(/;
+            if (genericPattern.test(content)) {
+                return { passed: false, evidence: 'Radio is not generic — remove type parameter (e.g., Radio<String>(...) → Radio(...))' };
+            }
+            return { passed: true, evidence: 'No generic type parameter found' };
+        }
+    },
+    {
+        id: 'radio-value-groupValue',
+        category: 'Radio',
+        name: 'Radio has both value and groupValue',
+        severity: 'error',
+        applies: (content) => /\bRadio\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            const radioCallRegex = /Radio\s*\(([\s\S]*?)\n\s*\)/g;
+            let match;
+            let callIndex = 0;
+            let allPassed = true;
+
+            while ((match = radioCallRegex.exec(content)) !== null) {
+                callIndex++;
+                const args = match[1];
+
+                const hasValue = /\bvalue\s*=/.test(args);
+                const hasGroupValue = /\bgroupValue\s*=/.test(args);
+
+                if (!hasValue || !hasGroupValue) {
+                    const missing = [];
+                    if (!hasValue) missing.push('value');
+                    if (!hasGroupValue) missing.push('groupValue');
+                    allPassed = false;
+                    return { passed: false, evidence: `Radio #${callIndex} missing: ${missing.join(', ')}` };
+                }
+            }
+
+            if (callIndex === 0) {
+                return { passed: true, evidence: 'No Radio calls found' };
+            }
+            return { passed: allPassed, evidence: `All ${callIndex} Radio call(s) have value and groupValue` };
+        }
+    },
+    {
+        id: 'radio-group-pattern',
+        category: 'Radio',
+        name: 'Radio used in group (2+ Radio with shared groupValue)',
+        severity: 'warning',
+        applies: (content) => /\bRadio\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            const radioCount = (content.match(/Radio\s*\(/g) || []).length;
+
+            if (radioCount === 0) {
+                return { passed: true, evidence: 'No Radio usage' };
+            } else if (radioCount === 1) {
+                // Check if it's inside a forEach/for loop (dynamic group)
+                const hasDynamicGroup = /\.forEach\s*\{[\s\S]*Radio\s*\(/.test(content)
+                    || /for\s*\([\s\S]*Radio\s*\(/.test(content)
+                    || /entries\.forEach/.test(content);
+
+                if (hasDynamicGroup) {
+                    return { passed: true, evidence: 'Radio inside loop — dynamic group detected' };
+                }
+                return { passed: false, evidence: 'Only 1 Radio found — should be in groups of 2+' };
+            }
+            return { passed: true, evidence: `${radioCount} Radio calls found — group pattern OK` };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/skeleton.js

@@ -0,0 +1,20 @@
+/**
+ * Skeleton validation rules
+ */
+
+module.exports = [
+    {
+        id: 'skeleton-no-params',
+        category: 'Skeleton',
+        name: 'Skeleton() takes no parameters',
+        severity: 'error',
+        applies: (content) => /\bSkeleton\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            // Skeleton() has no params — any param usage is wrong
+            if (/Skeleton\s*\([^)]+\)/s.test(content)) {
+                return { passed: false, evidence: 'Skeleton() takes no parameters — use Box with modifier for sizing' };
+            }
+            return { passed: true, evidence: 'Skeleton() called correctly with no params' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/snackbar.js

@@ -0,0 +1,32 @@
+/**
+ * SnackBar validation rules
+ */
+
+module.exports = [
+    {
+        id: 'snackbar-no-message',
+        category: 'SnackBar',
+        name: 'SnackBar is sealed class (not function with message)',
+        severity: 'error',
+        applies: (content) => /\bSnackBar\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/SnackBar\s*\([^)]*\bmessage\s*=/s.test(content)) {
+                return { passed: false, evidence: 'SnackBar has no "message" param — use SnackBar.Custom(content = { ... }) or SnackBar.Toast()' };
+            }
+            return { passed: true, evidence: 'SnackBar API usage looks correct' };
+        }
+    },
+    {
+        id: 'snackbar-no-duration-enum',
+        category: 'SnackBar',
+        name: 'No SnackBarDuration enum (does not exist)',
+        severity: 'error',
+        applies: (content) => /SnackBar/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/SnackBarDuration/.test(content)) {
+                return { passed: false, evidence: 'SnackBarDuration does not exist — use duration: Long? (millis) directly' };
+            }
+            return { passed: true, evidence: 'No invalid SnackBarDuration usage' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/state.js

@@ -0,0 +1,21 @@
+/**
+ * State management validation rules
+ */
+
+module.exports = [
+    {
+        id: 'state-remember',
+        category: 'State',
+        name: 'MutableState uses remember',
+        severity: 'warning',
+        applies: (content) => /mutableStateOf/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            const unremembered = /(?<!remember\s*\{\s*)mutableStateOf/.test(content);
+            const hasRemember = /remember\s*\{?\s*mutableStateOf/.test(content) || /by\s+remember/.test(content);
+            if (!hasRemember && unremembered) {
+                return { passed: false, evidence: 'mutableStateOf without remember — state will reset on recomposition' };
+            }
+            return { passed: true, evidence: 'State properly wrapped in remember' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/switch.js

@@ -0,0 +1,45 @@
+/**
+ * Switch validation rules
+ */
+
+module.exports = [
+    {
+        id: 'switch-no-checked',
+        category: 'Switch',
+        name: 'Switch uses "value" (not "checked")',
+        severity: 'error',
+        applies: (content) => /\bSwitch\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Switch\s*\([^)]*\bchecked\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Switch has no "checked" — use "value" instead' };
+            }
+            return { passed: true, evidence: 'Switch uses correct "value" param' };
+        }
+    },
+    {
+        id: 'switch-no-onCheckedChange',
+        category: 'Switch',
+        name: 'Switch uses "onChange" (not "onCheckedChange")',
+        severity: 'error',
+        applies: (content) => /\bSwitch\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Switch\s*\([^)]*\bonCheckedChange\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Switch has no "onCheckedChange" — use "onChange" instead' };
+            }
+            return { passed: true, evidence: 'Switch uses correct "onChange" param' };
+        }
+    },
+    {
+        id: 'switch-no-enabled',
+        category: 'Switch',
+        name: 'Switch uses "disabled" (not "enabled")',
+        severity: 'error',
+        applies: (content) => /\bSwitch\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Switch\s*\([^)]*\benabled\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Switch has no "enabled" — use "disabled = true" instead' };
+            }
+            return { passed: true, evidence: 'Switch uses correct "disabled" param' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/text.js

@@ -0,0 +1,19 @@
+/**
+ * Text validation rules
+ */
+
+module.exports = [
+    {
+        id: 'text-no-fontSize',
+        category: 'Text',
+        name: 'Text uses "style" (not "fontSize")',
+        severity: 'warning',
+        applies: (content) => /\bText\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Text\s*\([^)]*\bfontSize\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Text has no "fontSize" — use "style = Typography.xxx" instead' };
+            }
+            return { passed: true, evidence: 'Text typography usage looks correct' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/tooltip.js

@@ -0,0 +1,45 @@
+/**
+ * Tooltip validation rules
+ */
+
+module.exports = [
+    {
+        id: 'tooltip-no-text',
+        category: 'Tooltip',
+        name: 'Tooltip uses "description" (not "text")',
+        severity: 'error',
+        applies: (content) => /\bTooltip\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/Tooltip\s*\([^)]*\btext\s*=/s.test(content)) {
+                return { passed: false, evidence: 'Tooltip has no "text" — use "description" instead' };
+            }
+            return { passed: true, evidence: 'Tooltip uses correct param names' };
+        }
+    },
+    {
+        id: 'tooltip-no-position',
+        category: 'Tooltip',
+        name: 'No TooltipPosition (use TooltipPlacement)',
+        severity: 'error',
+        applies: (content) => /\bTooltip\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (/TooltipPosition/.test(content)) {
+                return { passed: false, evidence: 'TooltipPosition does not exist — use TooltipPlacement (TOP/BOTTOM/LEFT/RIGHT)' };
+            }
+            return { passed: true, evidence: 'No invalid TooltipPosition usage' };
+        }
+    },
+    {
+        id: 'tooltip-requires-state',
+        category: 'Tooltip',
+        name: 'Tooltip requires TooltipState',
+        severity: 'error',
+        applies: (content) => /\bTooltip\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            if (!/rememberTooltipState|TooltipState/.test(content)) {
+                return { passed: false, evidence: 'Tooltip requires "state: TooltipState" — use rememberTooltipState()' };
+            }
+            return { passed: true, evidence: 'TooltipState is used' };
+        }
+    },
+];

package/.claude/skills/momo-native-kits-skills/scripts/rules/trustbanner.js

@@ -0,0 +1,22 @@
+/**
+ * TrustBanner validation rules
+ */
+
+module.exports = [
+    {
+        id: 'trustbanner-no-title',
+        category: 'TrustBanner',
+        name: 'TrustBanner has no title/description/icon',
+        severity: 'error',
+        applies: (content) => /\bTrustBanner\s*\(/.test(content) && /vn\.momo\.kits/.test(content),
+        validate(content) {
+            const wrongParams = ['title', 'description', 'icon'];
+            for (const param of wrongParams) {
+                if (new RegExp(`TrustBanner\\s*\\([^)]*\\b${param}\\s*=`, 's').test(content)) {
+                    return { passed: false, evidence: `TrustBanner has no "${param}" — use serviceName, screenName, onPress, trackEvent` };
+                }
+            }
+            return { passed: true, evidence: 'TrustBanner params look correct' };
+        }
+    },
+];