guard-scanner 2.0.0 → 3.1.0

package/dist/scanner.js

@@ -0,0 +1,1043 @@
+"use strict";
+/**
+ * guard-scanner v3.0.0 — Core Scanner (TypeScript)
+ *
+ * Full TypeScript rewrite of guard-scanner v2.1.0 + hbg-scan features.
+ * Adds: Compaction Persistence check, Signature hash matching, typed interfaces.
+ *
+ * Zero dependencies. MIT License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardScanner = exports.VERSION = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const ioc_db_js_1 = require("./ioc-db.js");
+const patterns_js_1 = require("./patterns.js");
+// ── Constants ───────────────────────────────────────────────────────────────
+exports.VERSION = '3.0.0';
+const THRESHOLDS_MAP = {
+    normal: { suspicious: 30, malicious: 80 },
+    strict: { suspicious: 20, malicious: 60 },
+};
+const SEVERITY_WEIGHTS = {
+    CRITICAL: 40, HIGH: 15, MEDIUM: 5, LOW: 2,
+};
+const CODE_EXTENSIONS = new Set([
+    '.js', '.ts', '.mjs', '.cjs', '.py', '.sh', '.bash', '.ps1',
+    '.rb', '.go', '.rs', '.php', '.pl',
+]);
+const DOC_EXTENSIONS = new Set(['.md', '.txt', '.rst', '.adoc']);
+const DATA_EXTENSIONS = new Set(['.json', '.yaml', '.yml', '.toml', '.xml', '.csv']);
+const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.ttf',
+    '.eot', '.wasm', '.wav', '.mp3', '.mp4', '.webm', '.ogg', '.pdf',
+    '.zip', '.tar', '.gz', '.bz2', '.7z', '.exe', '.dll', '.so', '.dylib',
+]);
+const GENERATED_REPORT_FILES = new Set([
+    'guard-scanner-report.json', 'guard-scanner-report.html', 'guard-scanner.sarif',
+]);
+// ── GuardScanner ────────────────────────────────────────────────────────────
+class GuardScanner {
+    verbose;
+    selfExclude;
+    strict;
+    summaryOnly;
+    checkDeps;
+    thresholds;
+    findings = [];
+    stats = { scanned: 0, clean: 0, low: 0, suspicious: 0, malicious: 0 };
+    scannerDir;
+    ignoredSkills = new Set();
+    ignoredPatterns = new Set();
+    customRules = [];
+    constructor(options = {}) {
+        this.verbose = options.verbose ?? false;
+        this.selfExclude = options.selfExclude ?? false;
+        this.strict = options.strict ?? false;
+        this.summaryOnly = options.summaryOnly ?? false;
+        this.checkDeps = options.checkDeps ?? false;
+        this.scannerDir = path.resolve(__dirname);
+        this.thresholds = this.strict ? THRESHOLDS_MAP.strict : THRESHOLDS_MAP.normal;
+        if (options.plugins) {
+            for (const plugin of options.plugins) {
+                this.loadPlugin(plugin);
+            }
+        }
+        if (options.rulesFile) {
+            this.loadCustomRules(options.rulesFile);
+        }
+    }
+    // ── Plugin System ───────────────────────────────────────────────────────
+    loadPlugin(pluginPath) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const plugin = require(path.resolve(pluginPath));
+            if (plugin.patterns && Array.isArray(plugin.patterns)) {
+                for (const p of plugin.patterns) {
+                    if (p.id && p.regex && p.severity && p.cat && p.desc) {
+                        this.customRules.push(p);
+                    }
+                }
+                if (!this.summaryOnly) {
+                    console.log(`🔌 Plugin loaded: ${plugin.name || pluginPath} (${plugin.patterns.length} rule(s))`);
+                }
+            }
+        }
+        catch (e) {
+            console.error(`⚠️  Failed to load plugin ${pluginPath}: ${e.message}`);
+        }
+    }
+    loadCustomRules(rulesFile) {
+        try {
+            const content = fs.readFileSync(rulesFile, 'utf-8');
+            const rules = JSON.parse(content);
+            if (!Array.isArray(rules)) {
+                console.error('⚠️  Custom rules file must be a JSON array');
+                return;
+            }
+            for (const rule of rules) {
+                if (!rule.id || !rule.pattern || !rule.severity || !rule.cat || !rule.desc) {
+                    console.error(`⚠️  Skipping invalid rule: ${JSON.stringify(rule).substring(0, 80)}`);
+                    continue;
+                }
+                try {
+                    const flags = rule.flags || 'gi';
+                    this.customRules.push({
+                        id: rule.id,
+                        cat: rule.cat,
+                        regex: new RegExp(rule.pattern, flags),
+                        severity: rule.severity,
+                        desc: rule.desc,
+                        codeOnly: rule.codeOnly ?? false,
+                        docOnly: rule.docOnly ?? false,
+                        all: !rule.codeOnly && !rule.docOnly,
+                    });
+                }
+                catch (e) {
+                    console.error(`⚠️  Invalid regex in rule ${rule.id}: ${e.message}`);
+                }
+            }
+            if (!this.summaryOnly && this.customRules.length > 0) {
+                console.log(`📏 Loaded ${this.customRules.length} custom rule(s) from ${rulesFile}`);
+            }
+        }
+        catch (e) {
+            console.error(`⚠️  Failed to load custom rules: ${e.message}`);
+        }
+    }
+    // ── Ignore System ───────────────────────────────────────────────────────
+    loadIgnoreFile(scanDir) {
+        const ignorePaths = [
+            path.join(scanDir, '.guard-scanner-ignore'),
+            path.join(scanDir, '.guava-guard-ignore'),
+        ];
+        for (const ignorePath of ignorePaths) {
+            if (!fs.existsSync(ignorePath))
+                continue;
+            const lines = fs.readFileSync(ignorePath, 'utf-8').split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                if (trimmed.startsWith('pattern:')) {
+                    this.ignoredPatterns.add(trimmed.replace('pattern:', '').trim());
+                }
+                else {
+                    this.ignoredSkills.add(trimmed);
+                }
+            }
+            if (this.verbose && (this.ignoredSkills.size || this.ignoredPatterns.size)) {
+                console.log(`📋 Loaded ignore file: ${this.ignoredSkills.size} skills, ${this.ignoredPatterns.size} patterns`);
+            }
+            break;
+        }
+    }
+    // ── Main Scan ─────────────────────────────────────────────────────────
+    scanDirectory(dir) {
+        if (!fs.existsSync(dir)) {
+            console.error(`❌ Directory not found: ${dir}`);
+            process.exit(2);
+        }
+        this.loadIgnoreFile(dir);
+        const skills = fs.readdirSync(dir).filter((f) => {
+            const p = path.join(dir, f);
+            return fs.statSync(p).isDirectory();
+        });
+        console.log(`\n🛡️  guard-scanner v${exports.VERSION}`);
+        console.log(`${'═'.repeat(54)}`);
+        console.log(`📂 Scanning: ${dir}`);
+        console.log(`📦 Skills found: ${skills.length}`);
+        if (this.strict)
+            console.log('⚡ Strict mode enabled');
+        console.log();
+        for (const skill of skills) {
+            const skillPath = path.join(dir, skill);
+            if (this.selfExclude && path.resolve(skillPath) === this.scannerDir) {
+                if (!this.summaryOnly)
+                    console.log(`⏭️  ${skill} — SELF (excluded)`);
+                continue;
+            }
+            if (this.ignoredSkills.has(skill)) {
+                if (!this.summaryOnly)
+                    console.log(`⏭️  ${skill} — IGNORED`);
+                continue;
+            }
+            this.scanSkill(skillPath, skill);
+        }
+        this.printSummary();
+        return this.findings;
+    }
+    // ── Skill Scanner ─────────────────────────────────────────────────────
+    scanSkill(skillPath, skillName) {
+        this.stats.scanned++;
+        const skillFindings = [];
+        // Check: Known typosquat
+        if (ioc_db_js_1.KNOWN_MALICIOUS.typosquats.includes(skillName.toLowerCase())) {
+            skillFindings.push({
+                severity: 'CRITICAL', id: 'KNOWN_TYPOSQUAT', cat: 'malicious-code',
+                desc: 'Known malicious/typosquat skill name', file: 'SKILL NAME',
+            });
+        }
+        // Scan all files
+        const files = this.getFiles(skillPath);
+        for (const file of files) {
+            const ext = path.extname(file).toLowerCase();
+            const relFile = path.relative(skillPath, file);
+            if (relFile.includes('node_modules') || relFile.startsWith('.git'))
+                continue;
+            if (BINARY_EXTENSIONS.has(ext))
+                continue;
+            let content;
+            try {
+                content = fs.readFileSync(file, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            if (content.length > 500_000)
+                continue;
+            const fileType = this.classifyFile(ext, relFile);
+            this.checkIoCs(content, relFile, skillFindings);
+            this.checkPatterns(content, relFile, fileType, skillFindings);
+            this.checkSignatures(content, file, skillFindings); // NEW: hbg-scan compatible
+            if (this.customRules.length > 0) {
+                this.checkPatterns(content, relFile, fileType, skillFindings, this.customRules);
+            }
+            // Secret detection (skip lock files)
+            const baseName = path.basename(relFile).toLowerCase();
+            const skipSecret = baseName.endsWith('-lock.json') || baseName === 'package-lock.json' ||
+                baseName === 'yarn.lock' || baseName === 'pnpm-lock.yaml' ||
+                baseName === '_meta.json' || baseName === '.package-lock.json';
+            if (fileType === 'code' && !skipSecret) {
+                this.checkHardcodedSecrets(content, relFile, skillFindings);
+            }
+            // JS data flow
+            if (['.js', '.mjs', '.cjs', '.ts'].includes(ext) && content.length < 200_000) {
+                this.checkJSDataFlow(content, relFile, skillFindings);
+            }
+        }
+        // Structural checks
+        this.checkStructure(skillPath, skillName, skillFindings);
+        if (this.checkDeps)
+            this.checkDependencies(skillPath, skillName, skillFindings);
+        this.checkHiddenFiles(skillPath, skillName, skillFindings);
+        this.checkCrossFile(skillPath, skillName, skillFindings);
+        this.checkSkillManifest(skillPath, skillName, skillFindings);
+        this.checkComplexity(skillPath, skillName, skillFindings);
+        this.checkConfigImpact(skillPath, skillName, skillFindings);
+        this.checkCompactionPersistence(skillPath, skillName, skillFindings); // NEW
+        // Filter & score
+        const filtered = skillFindings.filter(f => !this.ignoredPatterns.has(f.id));
+        const risk = this.calculateRisk(filtered);
+        const verdict = this.getVerdict(risk);
+        this.stats[verdict.stat]++;
+        if (!this.summaryOnly) {
+            console.log(`${verdict.icon} ${skillName} — ${verdict.label} (risk: ${risk})`);
+            if (this.verbose && filtered.length > 0) {
+                const byCat = {};
+                for (const f of filtered)
+                    (byCat[f.cat] = byCat[f.cat] || []).push(f);
+                for (const [cat, findings] of Object.entries(byCat)) {
+                    console.log(`   📁 ${cat}`);
+                    for (const f of findings) {
+                        const icon = f.severity === 'CRITICAL' ? '💀' : f.severity === 'HIGH' ? '🔴' : f.severity === 'MEDIUM' ? '🟡' : '⚪';
+                        const loc = f.line ? `${f.file}:${f.line}` : f.file;
+                        console.log(`      ${icon} [${f.severity}] ${f.desc} — ${loc}`);
+                        if (f.sample)
+                            console.log(`         └─ "${f.sample}"`);
+                    }
+                }
+            }
+        }
+        if (filtered.length > 0) {
+            this.findings.push({ skill: skillName, risk, verdict: verdict.label, findings: filtered });
+        }
+    }
+    // ── Check Methods ─────────────────────────────────────────────────────
+    classifyFile(ext, relFile) {
+        if (CODE_EXTENSIONS.has(ext))
+            return 'code';
+        if (DOC_EXTENSIONS.has(ext))
+            return 'doc';
+        if (DATA_EXTENSIONS.has(ext))
+            return 'data';
+        const base = path.basename(relFile).toLowerCase();
+        if (base === 'skill.md' || base === 'readme.md')
+            return 'skill-doc';
+        return 'other';
+    }
+    checkIoCs(content, relFile, findings) {
+        const contentLower = content.toLowerCase();
+        for (const ip of ioc_db_js_1.KNOWN_MALICIOUS.ips) {
+            if (content.includes(ip)) {
+                findings.push({ severity: 'CRITICAL', id: 'IOC_IP', cat: 'malicious-code', desc: `Known malicious IP: ${ip}`, file: relFile });
+            }
+        }
+        for (const url of ioc_db_js_1.KNOWN_MALICIOUS.urls) {
+            if (contentLower.includes(url.toLowerCase())) {
+                findings.push({ severity: 'CRITICAL', id: 'IOC_URL', cat: 'malicious-code', desc: `Known malicious URL: ${url}`, file: relFile });
+            }
+        }
+        for (const domain of ioc_db_js_1.KNOWN_MALICIOUS.domains) {
+            const domainRegex = new RegExp(`(?:https?://|[\\s'"\`(]|^)${domain.replace(/\./g, '\\.')}`, 'gi');
+            if (domainRegex.test(content)) {
+                findings.push({ severity: 'HIGH', id: 'IOC_DOMAIN', cat: 'exfiltration', desc: `Suspicious domain: ${domain}`, file: relFile });
+            }
+        }
+        for (const fname of ioc_db_js_1.KNOWN_MALICIOUS.filenames) {
+            if (contentLower.includes(fname.toLowerCase())) {
+                findings.push({ severity: 'CRITICAL', id: 'IOC_FILE', cat: 'suspicious-download', desc: `Known malicious filename: ${fname}`, file: relFile });
+            }
+        }
+        for (const user of ioc_db_js_1.KNOWN_MALICIOUS.usernames) {
+            if (contentLower.includes(user.toLowerCase())) {
+                findings.push({ severity: 'HIGH', id: 'IOC_USER', cat: 'malicious-code', desc: `Known malicious username: ${user}`, file: relFile });
+            }
+        }
+    }
+    checkPatterns(content, relFile, fileType, findings, patterns = patterns_js_1.PATTERNS) {
+        for (const pattern of patterns) {
+            if (pattern.codeOnly && fileType !== 'code')
+                continue;
+            if (pattern.docOnly && fileType !== 'doc' && fileType !== 'skill-doc')
+                continue;
+            if (!pattern.all && !pattern.codeOnly && !pattern.docOnly)
+                continue;
+            pattern.regex.lastIndex = 0;
+            const matches = content.match(pattern.regex);
+            if (!matches)
+                continue;
+            pattern.regex.lastIndex = 0;
+            const idx = content.search(pattern.regex);
+            const lineNum = idx >= 0 ? content.substring(0, idx).split('\n').length : undefined;
+            let adjustedSeverity = pattern.severity;
+            if ((fileType === 'doc' || fileType === 'skill-doc') && pattern.all && !pattern.docOnly) {
+                if (adjustedSeverity === 'HIGH')
+                    adjustedSeverity = 'MEDIUM';
+                else if (adjustedSeverity === 'MEDIUM')
+                    adjustedSeverity = 'LOW';
+            }
+            findings.push({
+                severity: adjustedSeverity, id: pattern.id, cat: pattern.cat,
+                desc: pattern.desc, file: relFile, line: lineNum,
+                matchCount: matches.length, sample: matches[0].substring(0, 80),
+            });
+        }
+    }
+    /** NEW: hbg-scan compatible signature matching (hash + pattern + domain) */
+    checkSignatures(content, filePath, findings) {
+        const contentHash = crypto.createHash('sha256').update(content).digest('hex');
+        const relFile = path.basename(filePath);
+        for (const sig of ioc_db_js_1.SIGNATURES_DB.signatures) {
+            // Hash match
+            if (sig.hash && sig.hash === contentHash) {
+                findings.push({
+                    severity: sig.severity, id: `SIG_${sig.id}`, cat: 'signature-match',
+                    desc: `[${sig.id}] ${sig.name} — exact hash match`, file: relFile,
+                });
+                continue;
+            }
+            // Pattern match
+            if (sig.patterns) {
+                for (const pat of sig.patterns) {
+                    if (content.includes(pat)) {
+                        const idx = content.indexOf(pat);
+                        const lineNum = content.substring(0, idx).split('\n').length;
+                        findings.push({
+                            severity: sig.severity, id: `SIG_${sig.id}`, cat: 'signature-match',
+                            desc: `[${sig.id}] ${sig.name}`, file: relFile, line: lineNum,
+                            sample: content.split('\n')[lineNum - 1]?.trim().substring(0, 120),
+                        });
+                        break; // One finding per sig per file
+                    }
+                }
+            }
+            // Domain match
+            if (sig.domains) {
+                for (const domain of sig.domains) {
+                    if (content.includes(domain)) {
+                        const idx = content.indexOf(domain);
+                        const lineNum = content.substring(0, idx).split('\n').length;
+                        findings.push({
+                            severity: sig.severity, id: `SIG_${sig.id}`, cat: 'signature-match',
+                            desc: `[${sig.id}] Suspicious domain: ${domain}`, file: relFile, line: lineNum,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /** NEW: Compaction Layer Persistence check (hbg-scan Check 5) */
+    checkCompactionPersistence(skillPath, skillName, findings) {
+        const files = this.getFiles(skillPath);
+        for (const file of files) {
+            const ext = path.extname(file).toLowerCase();
+            if (BINARY_EXTENSIONS.has(ext))
+                continue;
+            const relFile = path.relative(skillPath, file);
+            if (relFile.includes('node_modules') || relFile.startsWith('.git'))
+                continue;
+            let content;
+            try {
+                content = fs.readFileSync(file, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            if (content.length > 500_000)
+                continue;
+            // Post-compaction audit patterns
+            const compactionPatterns = [
+                { regex: /post-?compaction\s+audit/gi, label: 'Post-compaction audit trigger', severity: 'CRITICAL' },
+                { regex: /WORKFLOW_AUTO/g, label: 'WORKFLOW_AUTO marker', severity: 'CRITICAL' },
+                { regex: /⚠️\s*post-?compaction/gi, label: 'Post-compaction emoji warning', severity: 'CRITICAL' },
+                { regex: /after\s+compaction/gi, label: 'After-compaction trigger', severity: 'HIGH' },
+                { regex: /survive\s+compaction/gi, label: 'Compaction survival pattern', severity: 'HIGH' },
+                { regex: /HEARTBEAT\.md/g, label: 'HEARTBEAT.md reference', severity: 'HIGH' },
+                { regex: /BOOTSTRAP\.md/g, label: 'BOOTSTRAP.md reference', severity: 'HIGH' },
+                { regex: /persistent\s+instructions/gi, label: 'Persistent instructions pattern', severity: 'HIGH' },
+                { regex: /setTimeout\s*\([^)]*(?:86400|604800|2592000)/g, label: 'Very long timer delay (persistence)', severity: 'MEDIUM' },
+            ];
+            for (const pat of compactionPatterns) {
+                pat.regex.lastIndex = 0;
+                const match = pat.regex.exec(content);
+                if (match) {
+                    const lineNum = content.substring(0, match.index).split('\n').length;
+                    findings.push({
+                        severity: pat.severity,
+                        id: 'COMPACTION_PERSISTENCE',
+                        cat: 'compaction-persistence',
+                        desc: pat.label,
+                        file: relFile,
+                        line: lineNum,
+                        sample: content.split('\n')[lineNum - 1]?.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+    }
+    checkHardcodedSecrets(content, relFile, findings) {
+        const assignmentRegex = /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]\s*['"]([a-zA-Z0-9_\-+/=]{16,})['"]|['"]([a-zA-Z0-9_\-+/=]{32,})['"]/gi;
+        let match;
+        while ((match = assignmentRegex.exec(content)) !== null) {
+            const value = match[1] || match[2];
+            if (!value)
+                continue;
+            if (/^[A-Z_]+$/.test(value))
+                continue;
+            if (/^(true|false|null|undefined|none|default|example|test|placeholder|your[_-])/i.test(value))
+                continue;
+            if (/^x{4,}|\.{4,}|_{4,}|0{8,}$/i.test(value))
+                continue;
+            if (/^projects\/|^gs:\/\/|^https?:\/\//i.test(value))
+                continue;
+            if (/^[a-z]+-[a-z]+-[a-z0-9]+$/i.test(value))
+                continue;
+            const entropy = this.shannonEntropy(value);
+            if (entropy > 3.5 && value.length >= 20) {
+                const lineNum = content.substring(0, match.index).split('\n').length;
+                findings.push({
+                    severity: 'HIGH', id: 'SECRET_ENTROPY', cat: 'secret-detection',
+                    desc: `High-entropy string (possible leaked secret, entropy=${entropy.toFixed(1)})`,
+                    file: relFile, line: lineNum,
+                    sample: value.substring(0, 8) + '...' + value.substring(value.length - 4),
+                });
+            }
+        }
+    }
+    shannonEntropy(str) {
+        const freq = {};
+        for (const c of str)
+            freq[c] = (freq[c] || 0) + 1;
+        const len = str.length;
+        let entropy = 0;
+        for (const count of Object.values(freq)) {
+            const p = count / len;
+            if (p > 0)
+                entropy -= p * Math.log2(p);
+        }
+        return entropy;
+    }
+    checkStructure(skillPath, skillName, findings) {
+        const skillMd = path.join(skillPath, 'SKILL.md');
+        if (!fs.existsSync(skillMd)) {
+            findings.push({ severity: 'LOW', id: 'STRUCT_NO_SKILLMD', cat: 'structural', desc: 'No SKILL.md found', file: skillName });
+            return;
+        }
+        const content = fs.readFileSync(skillMd, 'utf-8');
+        if (content.length < 50) {
+            findings.push({ severity: 'MEDIUM', id: 'STRUCT_TINY_SKILLMD', cat: 'structural', desc: 'Suspiciously short SKILL.md (< 50 chars)', file: 'SKILL.md' });
+        }
+        const scriptsDir = path.join(skillPath, 'scripts');
+        if (fs.existsSync(scriptsDir)) {
+            const scripts = fs.readdirSync(scriptsDir).filter((f) => CODE_EXTENSIONS.has(path.extname(f).toLowerCase()));
+            if (scripts.length > 0 && !content.includes('scripts/')) {
+                findings.push({ severity: 'MEDIUM', id: 'STRUCT_UNDOCUMENTED_SCRIPTS', cat: 'structural', desc: `${scripts.length} script(s) in scripts/ not referenced in SKILL.md`, file: 'scripts/' });
+            }
+        }
+    }
+    checkDependencies(skillPath, skillName, findings) {
+        const pkgPath = path.join(skillPath, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return;
+        let pkg;
+        try {
+            pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        }
+        catch {
+            return;
+        }
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.optionalDependencies };
+        const RISKY_PACKAGES = new Set([
+            'node-ipc', 'colors', 'faker', 'event-stream', 'ua-parser-js', 'coa', 'rc',
+        ]);
+        for (const [dep, version] of Object.entries(allDeps)) {
+            if (RISKY_PACKAGES.has(dep)) {
+                findings.push({ severity: 'HIGH', id: 'DEP_RISKY', cat: 'dependency-chain', desc: `Known risky dependency: ${dep}@${version}`, file: 'package.json' });
+            }
+            if (typeof version === 'string' && (version.startsWith('git+') || version.startsWith('http') || version.startsWith('github:') || version.includes('.tar.gz'))) {
+                findings.push({ severity: 'HIGH', id: 'DEP_REMOTE', cat: 'dependency-chain', desc: `Remote/git dependency: ${dep}@${version}`, file: 'package.json' });
+            }
+            if (version === '*' || version === 'latest') {
+                findings.push({ severity: 'MEDIUM', id: 'DEP_WILDCARD', cat: 'dependency-chain', desc: `Wildcard version: ${dep}@${version}`, file: 'package.json' });
+            }
+        }
+        const RISKY_SCRIPTS = ['preinstall', 'postinstall', 'preuninstall', 'postuninstall', 'prepare'];
+        if (pkg.scripts) {
+            for (const scriptName of RISKY_SCRIPTS) {
+                const cmd = pkg.scripts[scriptName];
+                if (cmd) {
+                    findings.push({ severity: 'HIGH', id: 'DEP_LIFECYCLE', cat: 'dependency-chain', desc: `Lifecycle script "${scriptName}": ${cmd.substring(0, 80)}`, file: 'package.json' });
+                    if (/curl|wget|node\s+-e|eval|exec|bash\s+-c/i.test(cmd)) {
+                        findings.push({ severity: 'CRITICAL', id: 'DEP_LIFECYCLE_EXEC', cat: 'dependency-chain', desc: `Lifecycle script "${scriptName}" downloads/executes code`, file: 'package.json', sample: cmd.substring(0, 80) });
+                    }
+                }
+            }
+        }
+    }
+    checkSkillManifest(skillPath, skillName, findings) {
+        const skillMd = path.join(skillPath, 'SKILL.md');
+        if (!fs.existsSync(skillMd))
+            return;
+        let content;
+        try {
+            content = fs.readFileSync(skillMd, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!fmMatch)
+            return;
+        const fm = fmMatch[1];
+        const DANGEROUS_BINS = new Set([
+            'sudo', 'rm', 'rmdir', 'chmod', 'chown', 'kill', 'pkill',
+            'curl', 'wget', 'nc', 'ncat', 'socat', 'ssh', 'scp',
+            'dd', 'mkfs', 'fdisk', 'mount', 'umount',
+            'iptables', 'ufw', 'firewall-cmd', 'docker', 'kubectl', 'systemctl',
+        ]);
+        const binsMatch = fm.match(/bins:\s*\n((?:\s+-\s+[^\n]+\n?)*)/i);
+        if (binsMatch) {
+            const bins = binsMatch[1].match(/- ([^\n]+)/g) || [];
+            for (const binLine of bins) {
+                const bin = binLine.replace(/^-\s*/, '').trim().toLowerCase();
+                if (DANGEROUS_BINS.has(bin)) {
+                    findings.push({ severity: 'HIGH', id: 'MANIFEST_DANGEROUS_BIN', cat: 'sandbox-validation', desc: `SKILL.md requires dangerous binary: ${bin}`, file: 'SKILL.md' });
+                }
+            }
+        }
+        const filesMatch = fm.match(/files:\s*\[([^\]]+)\]/i) || fm.match(/files:\s*\n((?:\s+-\s+[^\n]+\n?)*)/i);
+        if (filesMatch && /\*\*\/\*|\*\.\*|"\*"/i.test(filesMatch[1])) {
+            findings.push({ severity: 'HIGH', id: 'MANIFEST_BROAD_FILES', cat: 'sandbox-validation', desc: 'SKILL.md declares overly broad file scope (e.g. **/*)', file: 'SKILL.md' });
+        }
+        const SENSITIVE_ENV = /(?:SECRET|PASSWORD|CREDENTIAL|PRIVATE_KEY|AWS_SECRET|GITHUB_TOKEN)/i;
+        const envMatch = fm.match(/env:\s*\n((?:\s+-\s+[^\n]+\n?)*)/i);
+        if (envMatch) {
+            const envVars = envMatch[1].match(/- ([^\n]+)/g) || [];
+            for (const envLine of envVars) {
+                const envVar = envLine.replace(/^-\s*/, '').trim();
+                if (SENSITIVE_ENV.test(envVar)) {
+                    findings.push({ severity: 'HIGH', id: 'MANIFEST_SENSITIVE_ENV', cat: 'sandbox-validation', desc: `SKILL.md requires sensitive env var: ${envVar}`, file: 'SKILL.md' });
+                }
+            }
+        }
+        if (/exec:\s*(?:true|yes|enabled|'\*'|"\*")/i.test(fm)) {
+            findings.push({ severity: 'MEDIUM', id: 'MANIFEST_EXEC_DECLARED', cat: 'sandbox-validation', desc: 'SKILL.md declares exec capability', file: 'SKILL.md' });
+        }
+        if (/network:\s*(?:true|yes|enabled|'\*'|"\*"|all|any)/i.test(fm)) {
+            findings.push({ severity: 'MEDIUM', id: 'MANIFEST_NETWORK_DECLARED', cat: 'sandbox-validation', desc: 'SKILL.md declares unrestricted network access', file: 'SKILL.md' });
+        }
+    }
+    checkComplexity(skillPath, skillName, findings) {
+        const files = this.getFiles(skillPath);
+        const MAX_LINES = 1000;
+        const MAX_NESTING = 5;
+        const MAX_EVAL_DENSITY = 0.02;
+        for (const file of files) {
+            const ext = path.extname(file).toLowerCase();
+            if (!CODE_EXTENSIONS.has(ext))
+                continue;
+            const relFile = path.relative(skillPath, file);
+            if (relFile.includes('node_modules') || relFile.startsWith('.git'))
+                continue;
+            let content;
+            try {
+                content = fs.readFileSync(file, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const lines = content.split('\n');
+            if (lines.length > MAX_LINES) {
+                findings.push({ severity: 'MEDIUM', id: 'COMPLEXITY_LONG_FILE', cat: 'complexity', desc: `File exceeds ${MAX_LINES} lines (${lines.length} lines)`, file: relFile });
+            }
+            let maxDepth = 0, currentDepth = 0, deepestLine = 0;
+            for (let i = 0; i < lines.length; i++) {
+                for (const ch of lines[i]) {
+                    if (ch === '{')
+                        currentDepth++;
+                    if (ch === '}')
+                        currentDepth = Math.max(0, currentDepth - 1);
+                }
+                if (currentDepth > maxDepth) {
+                    maxDepth = currentDepth;
+                    deepestLine = i + 1;
+                }
+            }
+            if (maxDepth > MAX_NESTING) {
+                findings.push({ severity: 'MEDIUM', id: 'COMPLEXITY_DEEP_NESTING', cat: 'complexity', desc: `Deep nesting: ${maxDepth} levels (max: ${MAX_NESTING})`, file: relFile, line: deepestLine });
+            }
+            const evalMatches = content.match(/\b(?:eval|exec|execSync|spawn|Function)\s*\(/g) || [];
+            const density = lines.length > 0 ? evalMatches.length / lines.length : 0;
+            if (density > MAX_EVAL_DENSITY && evalMatches.length >= 3) {
+                findings.push({ severity: 'HIGH', id: 'COMPLEXITY_EVAL_DENSITY', cat: 'complexity', desc: `High eval/exec density: ${evalMatches.length} calls in ${lines.length} lines (${(density * 100).toFixed(1)}%)`, file: relFile });
+            }
+        }
+    }
+    checkConfigImpact(skillPath, skillName, findings) {
+        const files = this.getFiles(skillPath);
+        for (const file of files) {
+            const ext = path.extname(file).toLowerCase();
+            if (!CODE_EXTENSIONS.has(ext) && ext !== '.json')
+                continue;
+            const relFile = path.relative(skillPath, file);
+            if (relFile.includes('node_modules') || relFile.startsWith('.git'))
+                continue;
+            let content;
+            try {
+                content = fs.readFileSync(file, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const hasConfigRef = /openclaw\.json/i.test(content);
+            const hasWriteOp = /(?:writeFileSync|writeFile|fs\.write)\s*\(/i.test(content);
+            if (hasConfigRef && hasWriteOp) {
+                const clines = content.split('\n');
+                let writeLine = 0;
+                for (let i = 0; i < clines.length; i++) {
+                    if (/(?:writeFileSync|writeFile|fs\.write)\s*\(/i.test(clines[i])) {
+                        writeLine = i + 1;
+                        break;
+                    }
+                }
+                findings.push({ severity: 'CRITICAL', id: 'CFG_WRITE_DETECTED', cat: 'config-impact', desc: 'Code writes to openclaw.json', file: relFile, line: writeLine });
+            }
+            const DANGEROUS_CFG = [
+                { regex: /exec\.approvals?\s*[:=]\s*['"]?(off|false|disabled|none)/gi, id: 'CFG_EXEC_APPROVAL_OFF', desc: 'Disables exec approval', severity: 'CRITICAL' },
+                { regex: /tools\.exec\.host\s*[:=]\s*['"]gateway['"]/gi, id: 'CFG_EXEC_HOST_GATEWAY', desc: 'Sets exec host to gateway', severity: 'CRITICAL' },
+                { regex: /hooks\s*\.\s*internal\s*\.\s*entries\s*[:=]/gi, id: 'CFG_HOOKS_INTERNAL', desc: 'Modifies internal hooks', severity: 'HIGH' },
+                { regex: /network\.allowedDomains\s*[:=]\s*\[?\s*['"]\*['"]/gi, id: 'CFG_NET_WILDCARD', desc: 'Sets network domains to wildcard', severity: 'HIGH' },
+            ];
+            for (const check of DANGEROUS_CFG) {
+                check.regex.lastIndex = 0;
+                if (check.regex.test(content)) {
+                    findings.push({ severity: check.severity, id: check.id, cat: 'config-impact', desc: check.desc, file: relFile });
+                }
+            }
+        }
+    }
+    checkHiddenFiles(skillPath, skillName, findings) {
+        try {
+            const entries = fs.readdirSync(skillPath);
+            for (const entry of entries) {
+                if (entry.startsWith('.') && entry !== '.guard-scanner-ignore' && entry !== '.guava-guard-ignore' && entry !== '.gitignore' && entry !== '.git') {
+                    const fullPath = path.join(skillPath, entry);
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isFile()) {
+                        const ext = path.extname(entry).toLowerCase();
+                        if (CODE_EXTENSIONS.has(ext) || ext === '' || ext === '.sh') {
+                            findings.push({ severity: 'MEDIUM', id: 'STRUCT_HIDDEN_EXEC', cat: 'structural', desc: `Hidden executable file: ${entry}`, file: entry });
+                        }
+                    }
+                    else if (stat.isDirectory() && entry !== '.git') {
+                        findings.push({ severity: 'LOW', id: 'STRUCT_HIDDEN_DIR', cat: 'structural', desc: `Hidden directory: ${entry}/`, file: entry });
+                    }
+                }
+            }
+        }
+        catch { /* empty */ }
+    }
+    checkJSDataFlow(content, relFile, findings) {
+        const lines = content.split('\n');
+        const imports = new Map();
+        const sensitiveReads = [];
+        const networkCalls = [];
+        const execCalls = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            const reqMatch = line.match(/(?:const|let|var)\s+(?:\{[^}]+\}|\w+)\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (reqMatch) {
+                const varMatch = line.match(/(?:const|let|var)\s+(\{[^}]+\}|\w+)/);
+                if (varMatch)
+                    imports.set(varMatch[1].trim(), reqMatch[1]);
+            }
+            if (/(?:readFileSync|readFile)\s*\([^)]*(?:\.env|\.ssh|id_rsa|\.clawdbot|\.openclaw(?!\/workspace))/i.test(line)) {
+                sensitiveReads.push({ line: lineNum, text: line.trim() });
+            }
+            if (/process\.env\.[A-Z_]*(?:KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL)/i.test(line)) {
+                sensitiveReads.push({ line: lineNum, text: line.trim() });
+            }
+            if (/(?:fetch|axios|request|http\.request|https\.request|got)\s*\(/i.test(line) || /\.post\s*\(|\.put\s*\(|\.patch\s*\(/i.test(line)) {
+                networkCalls.push({ line: lineNum, text: line.trim() });
+            }
+            if (/(?:exec|execSync|spawn|spawnSync|execFile)\s*\(/i.test(line)) {
+                execCalls.push({ line: lineNum, text: line.trim() });
+            }
+        }
+        if (sensitiveReads.length > 0 && networkCalls.length > 0) {
+            findings.push({ severity: 'CRITICAL', id: 'AST_CRED_TO_NET', cat: 'data-flow', desc: `Data flow: secret read (L${sensitiveReads[0].line}) → network call (L${networkCalls[0].line})`, file: relFile, line: sensitiveReads[0].line, sample: sensitiveReads[0].text.substring(0, 60) });
+        }
+        if (sensitiveReads.length > 0 && execCalls.length > 0) {
+            findings.push({ severity: 'HIGH', id: 'AST_CRED_TO_EXEC', cat: 'data-flow', desc: `Data flow: secret read (L${sensitiveReads[0].line}) → command exec (L${execCalls[0].line})`, file: relFile, line: sensitiveReads[0].line, sample: sensitiveReads[0].text.substring(0, 60) });
+        }
+        const importedModules = new Set([...imports.values()]);
+        if (importedModules.has('child_process') && (importedModules.has('https') || importedModules.has('http') || importedModules.has('node-fetch'))) {
+            findings.push({ severity: 'HIGH', id: 'AST_SUSPICIOUS_IMPORTS', cat: 'data-flow', desc: 'Suspicious: child_process + network module', file: relFile });
+        }
+        if (importedModules.has('fs') && importedModules.has('child_process') && (importedModules.has('https') || importedModules.has('http'))) {
+            findings.push({ severity: 'CRITICAL', id: 'AST_EXFIL_TRIFECTA', cat: 'data-flow', desc: 'Exfiltration trifecta: fs + child_process + network', file: relFile });
+        }
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (/`[^`]*\$\{.*(?:env|key|token|secret|password).*\}[^`]*`\s*(?:\)|,)/i.test(line) && /(?:fetch|request|axios|http|url)/i.test(line)) {
+                findings.push({ severity: 'CRITICAL', id: 'AST_SECRET_IN_URL', cat: 'data-flow', desc: 'Secret interpolated into URL', file: relFile, line: i + 1, sample: line.trim().substring(0, 80) });
+            }
+        }
+    }
+    checkCrossFile(skillPath, skillName, findings) {
+        const files = this.getFiles(skillPath);
+        const allContent = {};
+        for (const file of files) {
+            const ext = path.extname(file).toLowerCase();
+            if (BINARY_EXTENSIONS.has(ext))
+                continue;
+            const relFile = path.relative(skillPath, file);
+            if (relFile.includes('node_modules') || relFile.startsWith('.git'))
+                continue;
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                if (content.length < 500_000)
+                    allContent[relFile] = content;
+            }
+            catch { /* empty */ }
+        }
+        const skillMd = allContent['SKILL.md'] || '';
+        const codeFileRefs = skillMd.match(/(?:scripts?\/|\.\/)[a-zA-Z0-9_\-.\/]+\.(js|py|sh|ts)/gi) || [];
+        for (const ref of codeFileRefs) {
+            const cleanRef = ref.replace(/^\.\//, '');
+            if (!allContent[cleanRef] && !files.some(f => path.relative(skillPath, f) === cleanRef)) {
+                findings.push({ severity: 'MEDIUM', id: 'XFILE_PHANTOM_REF', cat: 'structural', desc: `SKILL.md references non-existent: ${cleanRef}`, file: 'SKILL.md' });
+            }
+        }
+        const b64Fragments = [];
+        for (const [file, content] of Object.entries(allContent)) {
+            const matches = content.match(/[A-Za-z0-9+/]{20,}={0,2}/g) || [];
+            for (const m of matches) {
+                if (m.length > 40)
+                    b64Fragments.push({ file, fragment: m.substring(0, 30) });
+            }
+        }
+        if (b64Fragments.length > 3 && new Set(b64Fragments.map(f => f.file)).size > 1) {
+            findings.push({ severity: 'HIGH', id: 'XFILE_FRAGMENT_B64', cat: 'obfuscation', desc: `Base64 fragments across ${new Set(b64Fragments.map(f => f.file)).size} files`, file: skillName });
+        }
+        if (/(?:read|load|source|import)\s+(?:the\s+)?(?:script|file|code)\s+(?:from|at|in)\s+(?:scripts?\/)/gi.test(skillMd)) {
+            const hasExec = Object.values(allContent).some(c => /(?:eval|exec|spawn)\s*\(/i.test(c));
+            if (hasExec) {
+                findings.push({ severity: 'MEDIUM', id: 'XFILE_LOAD_EXEC', cat: 'data-flow', desc: 'SKILL.md references scripts with exec/eval', file: 'SKILL.md' });
+            }
+        }
+    }
+    // ── Risk Scoring ──────────────────────────────────────────────────────
+    calculateRisk(findings) {
+        if (findings.length === 0)
+            return 0;
+        let score = 0;
+        for (const f of findings) {
+            score += SEVERITY_WEIGHTS[f.severity] || 0;
+        }
+        const ids = new Set(findings.map(f => f.id));
+        const cats = new Set(findings.map(f => f.cat));
+        // Amplifiers
+        if (cats.has('credential-handling') && cats.has('exfiltration'))
+            score = Math.round(score * 2);
+        if (cats.has('credential-handling') && findings.some(f => f.id === 'MAL_CHILD' || f.id === 'MAL_EXEC'))
+            score = Math.round(score * 1.5);
+        if (cats.has('obfuscation') && (cats.has('malicious-code') || cats.has('credential-handling')))
+            score = Math.round(score * 2);
+        if (ids.has('DEP_LIFECYCLE_EXEC'))
+            score = Math.round(score * 2);
+        if (ids.has('PI_BIDI') && findings.length > 1)
+            score = Math.round(score * 1.5);
+        if (cats.has('leaky-skills') && (cats.has('exfiltration') || cats.has('malicious-code')))
+            score = Math.round(score * 2);
+        if (cats.has('memory-poisoning'))
+            score = Math.round(score * 1.5);
+        if (cats.has('prompt-worm'))
+            score = Math.round(score * 2);
+        if (cats.has('cve-patterns'))
+            score = Math.max(score, 70);
+        if (cats.has('persistence') && (cats.has('malicious-code') || cats.has('credential-handling') || cats.has('memory-poisoning')))
+            score = Math.round(score * 1.5);
+        if (cats.has('identity-hijack'))
+            score = Math.round(score * 2);
+        if (cats.has('identity-hijack') && (cats.has('persistence') || cats.has('memory-poisoning')))
+            score = Math.max(score, 90);
+        if (ids.has('IOC_IP') || ids.has('IOC_URL') || ids.has('KNOWN_TYPOSQUAT'))
+            score = 100;
+        // v1.1
+        if (cats.has('config-impact'))
+            score = Math.round(score * 2);
+        if (cats.has('config-impact') && cats.has('sandbox-validation'))
+            score = Math.max(score, 70);
+        if (cats.has('complexity') && (cats.has('malicious-code') || cats.has('obfuscation')))
+            score = Math.round(score * 1.5);
+        // v2.1 PII
+        if (cats.has('pii-exposure') && cats.has('exfiltration'))
+            score = Math.round(score * 3);
+        if (cats.has('pii-exposure') && (ids.has('SHADOW_AI_OPENAI') || ids.has('SHADOW_AI_ANTHROPIC') || ids.has('SHADOW_AI_GENERIC')))
+            score = Math.round(score * 2.5);
+        if (cats.has('pii-exposure') && cats.has('credential-handling'))
+            score = Math.round(score * 2);
+        // v3.0 Compaction persistence
+        if (cats.has('compaction-persistence'))
+            score = Math.round(score * 2);
+        if (cats.has('compaction-persistence') && cats.has('prompt-injection'))
+            score = Math.max(score, 90);
+        if (cats.has('signature-match'))
+            score = Math.max(score, 70);
+        return Math.min(100, score);
+    }
+    getVerdict(risk) {
+        if (risk >= this.thresholds.malicious)
+            return { icon: '🔴', label: 'MALICIOUS', stat: 'malicious' };
+        if (risk >= this.thresholds.suspicious)
+            return { icon: '🟡', label: 'SUSPICIOUS', stat: 'suspicious' };
+        if (risk > 0)
+            return { icon: '🟢', label: 'LOW RISK', stat: 'low' };
+        return { icon: '🟢', label: 'CLEAN', stat: 'clean' };
+    }
+    // ── File Discovery ────────────────────────────────────────────────────
+    getFiles(dir) {
+        const results = [];
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name === '.git' || entry.name === 'node_modules')
+                        continue;
+                    results.push(...this.getFiles(fullPath));
+                }
+                else {
+                    if (GENERATED_REPORT_FILES.has(entry.name.toLowerCase()))
+                        continue;
+                    results.push(fullPath);
+                }
+            }
+        }
+        catch { /* empty */ }
+        return results;
+    }
+    // ── Output ────────────────────────────────────────────────────────────
+    printSummary() {
+        const total = this.stats.scanned;
+        const safe = this.stats.clean + this.stats.low;
+        console.log(`\n${'═'.repeat(54)}`);
+        console.log(`📊 guard-scanner v${exports.VERSION} Scan Summary`);
+        console.log(`${'─'.repeat(54)}`);
+        console.log(`   Scanned:      ${total}`);
+        console.log(`   🟢 Clean:       ${this.stats.clean}`);
+        console.log(`   🟢 Low Risk:    ${this.stats.low}`);
+        console.log(`   🟡 Suspicious:  ${this.stats.suspicious}`);
+        console.log(`   🔴 Malicious:   ${this.stats.malicious}`);
+        console.log(`   Safety Rate:  ${total ? Math.round(safe / total * 100) : 0}%`);
+        console.log(`${'═'.repeat(54)}`);
+        if (this.stats.malicious > 0) {
+            console.log(`\n⚠️  CRITICAL: ${this.stats.malicious} malicious skill(s) detected!`);
+        }
+        else if (this.stats.suspicious > 0) {
+            console.log(`\n⚡ ${this.stats.suspicious} suspicious skill(s) found — review recommended.`);
+        }
+        else {
+            console.log('\n✅ All clear! No threats detected.');
+        }
+    }
+    toJSON() {
+        const recommendations = [];
+        for (const sr of this.findings) {
+            const actions = [];
+            const cats = new Set(sr.findings.map(f => f.cat));
+            if (cats.has('prompt-injection'))
+                actions.push('🛑 Contains prompt injection patterns.');
+            if (cats.has('malicious-code'))
+                actions.push('🛑 Contains potentially malicious code.');
+            if (cats.has('credential-handling') && cats.has('exfiltration'))
+                actions.push('💀 CRITICAL: Credential + exfiltration. DO NOT INSTALL.');
+            if (cats.has('dependency-chain'))
+                actions.push('📦 Suspicious dependency chain.');
+            if (cats.has('obfuscation'))
+                actions.push('🔍 Code obfuscation detected.');
+            if (cats.has('secret-detection'))
+                actions.push('🔑 Possible hardcoded secrets.');
+            if (cats.has('memory-poisoning'))
+                actions.push('🧠 MEMORY POISONING: Agent memory modification.');
+            if (cats.has('prompt-worm'))
+                actions.push('🪱 PROMPT WORM: Self-replicating instructions.');
+            if (cats.has('data-flow'))
+                actions.push('🔀 Suspicious data flow patterns.');
+            if (cats.has('identity-hijack'))
+                actions.push('🔒 IDENTITY HIJACK: Agent soul file tampering.');
+            if (cats.has('compaction-persistence'))
+                actions.push('⏰ COMPACTION PERSISTENCE: Survives context compaction.');
+            if (cats.has('signature-match'))
+                actions.push('🎯 SIGNATURE MATCH: Known threat signature detected.');
+            if (cats.has('config-impact'))
+                actions.push('⚙️ CONFIG IMPACT: Modifies OpenClaw configuration.');
+            if (cats.has('pii-exposure'))
+                actions.push('🆔 PII EXPOSURE: Handles personal information.');
+            if (actions.length > 0)
+                recommendations.push({ skill: sr.skill, actions });
+        }
+        return {
+            timestamp: new Date().toISOString(),
+            scanner: `guard-scanner v${exports.VERSION}`,
+            mode: this.strict ? 'strict' : 'normal',
+            stats: this.stats,
+            thresholds: this.thresholds,
+            findings: this.findings,
+            recommendations,
+            iocVersion: '2026-02-21',
+            signaturesVersion: ioc_db_js_1.SIGNATURES_DB.version,
+        };
+    }
+    toSARIF(scanDir) {
+        const rules = [];
+        const ruleIndex = {};
+        const results = [];
+        for (const sr of this.findings) {
+            for (const f of sr.findings) {
+                if (!ruleIndex[f.id] && ruleIndex[f.id] !== 0) {
+                    ruleIndex[f.id] = rules.length;
+                    // Look up OWASP mapping from PATTERNS
+                    const patternDef = patterns_js_1.PATTERNS.find((p) => p.id === f.id);
+                    const owaspTag = patternDef?.owasp;
+                    const tags = ['security', f.cat];
+                    if (owaspTag)
+                        tags.push(`OWASP/${owaspTag}`);
+                    rules.push({
+                        id: f.id, name: f.id,
+                        shortDescription: { text: f.desc },
+                        defaultConfiguration: { level: f.severity === 'CRITICAL' || f.severity === 'HIGH' ? 'error' : f.severity === 'MEDIUM' ? 'warning' : 'note' },
+                        properties: {
+                            tags,
+                            'security-severity': f.severity === 'CRITICAL' ? '9.0' : f.severity === 'HIGH' ? '7.0' : f.severity === 'MEDIUM' ? '4.0' : '1.0',
+                        },
+                    });
+                }
+                const normalizedFile = String(f.file || '').replaceAll('\\', '/').replace(/^\/+/, '');
+                const artifactUri = `${sr.skill}/${normalizedFile}`;
+                const seed = `${f.id}|${artifactUri}|${f.line || 0}|${(f.sample || '').slice(0, 200)}`;
+                const lineHash = crypto.createHash('sha256').update(seed).digest('hex').slice(0, 24);
+                results.push({
+                    ruleId: f.id, ruleIndex: ruleIndex[f.id],
+                    level: f.severity === 'CRITICAL' || f.severity === 'HIGH' ? 'error' : f.severity === 'MEDIUM' ? 'warning' : 'note',
+                    message: { text: `[${sr.skill}] ${f.desc}${f.sample ? ` — "${f.sample}"` : ''}` },
+                    partialFingerprints: { primaryLocationLineHash: lineHash },
+                    locations: [{
+                            physicalLocation: {
+                                artifactLocation: { uri: artifactUri, uriBaseId: '%SRCROOT%' },
+                                region: f.line ? { startLine: f.line } : undefined,
+                            },
+                        }],
+                });
+            }
+        }
+        return {
+            version: '2.1.0',
+            $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
+            runs: [{
+                    tool: { driver: { name: 'guard-scanner', version: exports.VERSION, informationUri: 'https://github.com/koatora20/guard-scanner', rules } },
+                    results,
+                    invocations: [{ executionSuccessful: true, endTimeUtc: new Date().toISOString() }],
+                }],
+        };
+    }
+}
+exports.GuardScanner = GuardScanner;
+//# sourceMappingURL=scanner.js.map