@goplus/agentguard 1.1.8 → 1.1.9

package/README.md

@@ -68,20 +68,24 @@ printf '{"tool_name":"Bash","tool_input":{"command":"curl https://example.com/in
 AGENTGUARD_API_KEY=ag_live_xxxxx agentguard connect --url https://agentguard.gopluslabs.io
 
 # Optional: subscribe to AgentGuard's threat-intelligence feed. Pulls newly
-# published advisories from Cloud, runs a self-check against your installed
-# skills, and reports matches back. Run in cron / on boot.
+# published advisories from Cloud and asks you to review them.
 agentguard subscribe
 
-# Optional: after one subscribe run, install an OpenClaw isolated cron job that
-# repeats the feed self-check every 15 minutes and only notifies on matches.
+# Run the full quiet flow once: pull advisories, self-check local skills, and
+# report local matches back to Cloud.
+agentguard subscribe --quiet
+
+# Optional: install an OpenClaw isolated cron job that checks every hour and
+# asks you to review newly published advisories.
 # Requires the local OpenClaw Gateway at 127.0.0.1:18789.
-agentguard subscribe --install-cron
+agentguard subscribe --cron "0 * * * *"
 
-# Override the interval if needed
-agentguard subscribe --install-cron --interval-minutes 5
+# Or install the hourly cron in quiet mode so matches are self-checked and
+# reported automatically.
+agentguard subscribe --cron "0 * * * *" --quiet
 
 # Replace an existing OpenClaw cron job with the same name
-agentguard subscribe --install-cron --force
+agentguard subscribe --cron "0 * * * *" --force
 
 # Machine-readable output always includes a cron status object:
 # cron.requested, cron.installed, and optional cron.result when installation succeeds.

package/dist/cli.js

@@ -2,6 +2,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
 const commander_1 = require("commander");
 const client_js_1 = require("./cloud/client.js");
 const config_js_1 = require("./config.js");
@@ -219,10 +222,10 @@ async function main() {
         .description('Pull new threat-feed advisories from AgentGuard Cloud and run a self-check against locally installed skills')
         .option('--since <iso>', 'Override the persisted last-pulled timestamp')
         .option('--json', 'Emit machine-readable summary instead of human text')
+        .option('--quiet', 'Run the full pull, self-check, and match-reporting flow with minimal output')
         .option('--no-report', 'Skip uploading self-check results back to Cloud')
-        .option('--install-cron', 'After this run, install an OpenClaw cron job that reruns subscribe on the configured interval')
+        .option('--cron <expr>', 'Install an OpenClaw cron job with a five-field cron expression, for example "0 * * * *"')
         .option('--cron-name <name>', 'OpenClaw cron job name', 'agentguard-threat-feed')
-        .option('--interval-minutes <minutes>', 'OpenClaw cron interval in minutes', '15')
         .option('--force', 'Replace an existing OpenClaw cron job with the same name')
         .option('--cron-run', 'Internal: run from the OpenClaw cron prompt without trying to install cron again')
         .action(async (options) => {
@@ -230,6 +233,10 @@ async function main() {
         const client = new client_js_1.AgentGuardCloudClient(config);
         const state = (0, state_js_1.loadFeedState)();
         const since = options.since ?? state.lastPulledAt;
+        const quiet = Boolean(options.quiet);
+        const cronExpression = options.cron && !options.cronRun
+            ? (0, cron_js_1.validateCronExpression)(options.cron)
+            : undefined;
         let advisories;
         try {
             advisories = await client.pullAdvisories(since);
@@ -244,7 +251,7 @@ async function main() {
             if (options.json) {
                 console.log(JSON.stringify({ supported: false, shouldNotify: false, results: [], cron: { requested: false, installed: false } }));
             }
-            else {
+            else if (!quiet) {
                 console.log('AgentGuard Cloud does not expose /api/v1/feed/advisories yet — nothing to do.');
             }
             return;
@@ -259,48 +266,58 @@ async function main() {
         let cursorOk = true; // stops advancing on the first hard failure
         let latestPublishedAt = state.lastPulledAt;
         let hardFailures = 0;
-        for (const advisory of fresh) {
-            let processed = true;
-            let result;
-            try {
-                result = await (0, selfcheck_js_1.runSelfCheckForAdvisory)(advisory);
-            }
-            catch (err) {
-                // runSelfCheck shouldn't throw, but if it does the advisory has
-                // not been evaluated — don't mark it seen and don't advance.
-                console.error(`! Self-check threw for ${advisory.id}: ${err.message}`);
-                hardFailures += 1;
-                cursorOk = false;
-                continue;
-            }
-            results.push(result);
-            if (options.report !== false && client.connected && result.matchedArtifacts.length > 0) {
-                // Report is on the critical path — if Cloud doesn't see the
-                // match, we must NOT mark the advisory seen, otherwise a
-                // transient network blip silently buries a real hit.
+        if (quiet) {
+            for (const advisory of fresh) {
+                let processed = true;
+                let result;
                 try {
-                    await client.reportSelfCheck(advisory.id, result.matchedArtifacts, {
-                        elapsedMs: result.elapsedMs,
-                        warnings: result.warnings,
-                    });
+                    result = await (0, selfcheck_js_1.runSelfCheckForAdvisory)(advisory);
                 }
                 catch (err) {
-                    console.error(`! Failed to report self-check for ${advisory.id}: ${err.message}`);
-                    processed = false;
+                    // runSelfCheck shouldn't throw, but if it does the advisory has
+                    // not been evaluated — don't mark it seen and don't advance.
+                    console.error(`! Self-check threw for ${advisory.id}: ${err.message}`);
                     hardFailures += 1;
+                    cursorOk = false;
+                    continue;
+                }
+                results.push(result);
+                if (options.report !== false && client.connected && result.matchedArtifacts.length > 0) {
+                    // Report is on the critical path — if Cloud doesn't see the
+                    // match, we must NOT mark the advisory seen, otherwise a
+                    // transient network blip silently buries a real hit.
+                    try {
+                        await client.reportSelfCheck(advisory.id, result.matchedArtifacts, {
+                            elapsedMs: result.elapsedMs,
+                            warnings: result.warnings,
+                        });
+                    }
+                    catch (err) {
+                        console.error(`! Failed to report self-check for ${advisory.id}: ${err.message}`);
+                        processed = false;
+                        hardFailures += 1;
+                    }
+                }
+                if (processed) {
+                    Object.assign(state, (0, state_js_1.markAdvisorySeen)(state, advisory.id));
+                    if (cursorOk && (!latestPublishedAt || advisory.publishedAt > latestPublishedAt)) {
+                        latestPublishedAt = advisory.publishedAt;
+                    }
+                }
+                else {
+                    // From this point we no longer advance the pull cursor — the
+                    // failed advisory must be re-pulled on the next run.
+                    cursorOk = false;
                 }
             }
-            if (processed) {
+        }
+        else {
+            for (const advisory of fresh) {
                 Object.assign(state, (0, state_js_1.markAdvisorySeen)(state, advisory.id));
                 if (cursorOk && (!latestPublishedAt || advisory.publishedAt > latestPublishedAt)) {
                     latestPublishedAt = advisory.publishedAt;
                 }
             }
-            else {
-                // From this point we no longer advance the pull cursor — the
-                // failed advisory must be re-pulled on the next run.
-                cursorOk = false;
-            }
         }
         state.lastPulledAt = latestPublishedAt;
         (0, state_js_1.saveFeedState)(state);
@@ -309,15 +326,18 @@ async function main() {
             supported: true,
             pulled: advisories.length,
             fresh: fresh.length,
+            freshAdvisories: fresh,
             results,
             hardFailures,
+            quiet,
         });
-        if (options.installCron && !options.cronRun) {
+        if (options.cron && !options.cronRun) {
             summary.cron.requested = true;
             try {
                 summary.cron.result = await (0, cron_js_1.installOpenClawThreatFeedCron)({
                     name: options.cronName,
-                    intervalMinutes: (0, cron_js_1.parseIntervalMinutes)(options.intervalMinutes),
+                    cronExpression: cronExpression,
+                    quiet,
                     force: Boolean(options.force),
                 });
                 summary.cron.installed = true;
@@ -331,8 +351,18 @@ async function main() {
             console.log(JSON.stringify(summary, null, 2));
             return;
         }
+        if (quiet && fresh.length === 0 && !summary.cron.result) {
+            process.exitCode = 0;
+            return;
+        }
         console.log(`Pulled ${advisories.length} advisory record(s); ${fresh.length} new.`);
-        if (fresh.length > 0) {
+        if (!quiet && fresh.length > 0) {
+            console.log('New threat-feed advisories found. Review and handle them manually:');
+            for (const advisory of fresh) {
+                console.log(`  - ${advisory.id} [${advisory.severity}] ${advisory.summary}`);
+            }
+        }
+        else if (quiet && fresh.length > 0) {
             console.log(`Self-check found ${totalMatches} match(es) across the new advisories.`);
             for (const r of results) {
                 if (r.matchedArtifacts.length === 0)
@@ -345,8 +375,8 @@ async function main() {
         }
         if (summary.cron.result) {
             const action = summary.cron.result.created ? 'Installed' : 'OpenClaw cron job already exists';
-            console.log(`${action} "${summary.cron.result.name}" (${summary.cron.result.schedule}).`);
-            console.log('Notification rule: only send a message from the isolated cron session when threat-feed matches are found.');
+            console.log(`${action} "${summary.cron.result.name}" (${summary.cron.result.schedule}, ${summary.cron.result.timezone}).`);
+            console.log('Notification rule: non-quiet cron notifies on new advisories; quiet cron notifies on local matches.');
         }
         // Exit codes: 2 = matches found, 1 = at least one advisory failed
         // to evaluate or report (cursor was held back), 0 = clean.
@@ -354,7 +384,7 @@ async function main() {
             console.error(`! ${hardFailures} advisory record(s) failed to process and will be re-pulled next run.`);
             process.exitCode = 1;
         }
-        else if (totalMatches > 0) {
+        else if (quiet && totalMatches > 0) {
             process.exitCode = 2;
         }
         else {
@@ -363,16 +393,38 @@ async function main() {
     });
     program
         .command('checkup')
-        .description('Run a self-check immediately. Without --against-advisory, scans for everything in the feed cache.')
+        .description('Run a local agent health checkup. Use --against-advisory only for targeted threat-feed self-checks.')
         .option('--against-advisory <id>', 'Restrict the check to a single advisory id (fetches it from Cloud if needed)')
         .option('--json', 'Emit machine-readable result')
         .action(async (options) => {
         const config = (0, config_js_1.ensureConfig)();
-        const client = new client_js_1.AgentGuardCloudClient(config);
         const advisoryId = options.againstAdvisory;
         if (!advisoryId) {
-            console.log('Tip: pass --against-advisory <id> for now. A broader, full-fleet checkup is coming.');
-            console.log('Meanwhile, run `agentguard subscribe` to pull the feed and self-check new entries.');
+            const report = await runLocalHealthCheckup(config);
+            if (options.json) {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            else {
+                const htmlPath = await generateCheckupHtml(report).catch((err) => {
+                    console.error(`! Could not generate visual checkup report: ${err.message}`);
+                    return null;
+                });
+                printHealthCheckupSummary(report, htmlPath);
+            }
+            appendCheckupAudit(config.auditPath, report);
+            process.exitCode = 0;
+            return;
+        }
+        const client = new client_js_1.AgentGuardCloudClient(config);
+        if (!client.connected) {
+            const message = 'AgentGuard Cloud is not connected. Run `agentguard connect --key <key>` first.';
+            if (options.json) {
+                console.log(JSON.stringify({ success: false, error: message }, null, 2));
+            }
+            else {
+                console.error(message);
+            }
+            process.exitCode = 1;
             return;
         }
         let advisory = null;
@@ -418,9 +470,349 @@ function readStdinIfAvailable() {
         return '';
     }
 }
+async function runLocalHealthCheckup(config) {
+    const skillRoots = [
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.claude', 'skills'),
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.openclaw', 'skills'),
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.openclaw', 'workspace', 'skills'),
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.qclaw', 'skills'),
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.qclaw', 'workspace', 'skills'),
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.hermes', 'skills'),
+    ];
+    const skillDirs = discoverSkillDirs(skillRoots);
+    const scanner = new index_js_1.SkillScanner({ useExternalScanner: false });
+    const codeFindings = [];
+    let codeScore = skillDirs.length === 0 ? 70 : 100;
+    if (skillDirs.length === 0) {
+        codeFindings.push({ severity: 'LOW', text: 'No installed third-party skills were found to audit.' });
+    }
+    for (const dir of skillDirs) {
+        const result = await scanner.quickScan(dir);
+        const name = dir.split(/[\\/]/).pop() || dir;
+        if (result.risk_level === 'critical')
+            codeScore -= 15;
+        if (result.risk_level === 'high')
+            codeScore -= 8;
+        if (result.risk_level === 'medium')
+            codeScore -= 3;
+        if (result.risk_level !== 'low') {
+            codeFindings.push({
+                severity: riskLevelToSeverity(result.risk_level),
+                text: `${name}: ${result.summary}${result.risk_tags.length ? ` (${result.risk_tags.join(', ')})` : ''}`,
+            });
+        }
+    }
+    codeScore = clampScore(codeScore);
+    const credential = checkCredentialSafety(skillDirs);
+    const network = await checkNetworkExposure(config);
+    const runtime = checkRuntimeProtection(config, skillDirs.length);
+    const web3 = checkWeb3Safety(skillDirs);
+    const dimensions = {
+        code_safety: {
+            score: codeScore,
+            findings: codeFindings,
+            details: `${skillDirs.length} installed skill(s) scanned with AgentGuard rules.`,
+        },
+        credential_safety: credential,
+        network_exposure: network,
+        runtime_protection: runtime,
+        web3_safety: web3,
+    };
+    const composite = calculateCompositeScore(dimensions);
+    const recommendations = Object.values(dimensions)
+        .flatMap((d) => d.findings)
+        .filter((f) => f.severity !== 'LOW')
+        .slice(0, 8);
+    return {
+        timestamp: new Date().toISOString(),
+        composite_score: composite,
+        tier: tierForScore(composite),
+        dimensions,
+        skills_scanned: skillDirs.length,
+        protection_level: config.level,
+        analysis: buildHealthAnalysis(composite, dimensions),
+        recommendations,
+    };
+}
+function discoverSkillDirs(roots) {
+    const dirs = [];
+    for (const root of roots) {
+        if (!(0, node_fs_1.existsSync)(root))
+            continue;
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const dir = (0, node_path_1.join)(root, entry.name);
+            if ((0, node_fs_1.existsSync)((0, node_path_1.join)(dir, 'SKILL.md')))
+                dirs.push(dir);
+        }
+    }
+    return dirs;
+}
+function checkCredentialSafety(skillDirs) {
+    let score = 100;
+    const findings = [];
+    for (const [path, severity] of [
+        [(0, node_path_1.join)((0, node_os_1.homedir)(), '.ssh'), 'HIGH'],
+        [(0, node_path_1.join)((0, node_os_1.homedir)(), '.gnupg'), 'MEDIUM'],
+    ]) {
+        const mode = permissionMode(path);
+        if (mode !== null && mode > 0o700) {
+            score -= severity === 'HIGH' ? 25 : 15;
+            findings.push({ severity, text: `${path} permissions are ${mode.toString(8)}; expected 700 or stricter.` });
+        }
+    }
+    const secretPatterns = [
+        { re: /0x[a-fA-F0-9]{64}|-----BEGIN [A-Z ]*PRIVATE KEY-----/, severity: 'CRITICAL', label: 'Plaintext private key pattern' },
+        { re: /\b(seed_phrase|mnemonic)\b/i, severity: 'CRITICAL', label: 'Mnemonic or seed phrase marker' },
+        { re: /\bAKIA[0-9A-Z]{16}\b|\bgh[pousr]_[A-Za-z0-9_]{20,}\b/, severity: 'HIGH', label: 'API key or token pattern' },
+    ];
+    for (const dir of skillDirs) {
+        const manifest = (0, node_path_1.join)(dir, 'SKILL.md');
+        if (!(0, node_fs_1.existsSync)(manifest))
+            continue;
+        let body = '';
+        try {
+            body = (0, node_fs_1.readFileSync)(manifest, 'utf8').slice(0, 256 * 1024);
+        }
+        catch {
+            continue;
+        }
+        for (const pattern of secretPatterns) {
+            if (!pattern.re.test(body))
+                continue;
+            score -= pattern.severity === 'CRITICAL' ? 25 : 15;
+            findings.push({ severity: pattern.severity, text: `${pattern.label} found in ${manifest}.` });
+        }
+    }
+    return {
+        score: clampScore(score),
+        findings,
+        details: findings.length ? `${findings.length} credential hygiene issue(s) found.` : 'Credential permissions and scanned manifests look clean.',
+    };
+}
+async function checkNetworkExposure(config) {
+    let score = 100;
+    const findings = [];
+    const listeners = await runCommandText('lsof', ['-i', '-P', '-n']);
+    for (const port of ['2375', '3306', '6379', '27017']) {
+        const exposed = new RegExp(`(\\*|0\\.0\\.0\\.0):${port}\\b`).test(listeners);
+        if (exposed) {
+            score -= 25;
+            findings.push({ severity: 'HIGH', text: `High-risk service appears exposed on 0.0.0.0:${port}.` });
+        }
+    }
+    const cron = await runCommandText('crontab', ['-l']);
+    if (/(curl\b.*\|\s*(bash|sh)|wget\b.*\|\s*(bash|sh)|\.ssh)/i.test(cron)) {
+        score -= 30;
+        findings.push({ severity: 'HIGH', text: 'Suspicious cron entry found that downloads shell code or accesses SSH material.' });
+    }
+    const sensitiveEnvNames = Object.keys(process.env).filter((name) => /PRIVATE_KEY|MNEMONIC|SECRET|PASSWORD/i.test(name));
+    if (sensitiveEnvNames.length > 0) {
+        score -= 20;
+        findings.push({ severity: 'MEDIUM', text: `Sensitive environment variable names are present: ${sensitiveEnvNames.slice(0, 8).join(', ')}.` });
+    }
+    for (const path of [(0, node_path_1.join)((0, node_os_1.homedir)(), '.openclaw', 'openclaw.json'), (0, node_path_1.join)((0, node_os_1.homedir)(), '.openclaw', 'devices', 'paired.json')]) {
+        const mode = permissionMode(path);
+        if (mode !== null && mode > 0o600) {
+            score -= 15;
+            findings.push({ severity: 'MEDIUM', text: `${path} permissions are ${mode.toString(8)}; expected 600 or stricter.` });
+        }
+    }
+    return {
+        score: clampScore(score),
+        findings,
+        details: findings.length ? `${findings.length} network/system exposure issue(s) found.` : 'No dangerous ports, cron entries, or config permission issues found.',
+    };
+}
+function checkRuntimeProtection(config, skillsScanned) {
+    let score = 0;
+    const findings = [];
+    const hookFiles = [
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.claude', 'settings.json'),
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.openclaw', 'openclaw.json'),
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.hermes', 'config.yaml'),
+    ];
+    const hasHook = hookFiles.some((path) => {
+        if (!(0, node_fs_1.existsSync)(path))
+            return false;
+        try {
+            return /agentguard|guard-hook|hermes-hook/i.test((0, node_fs_1.readFileSync)(path, 'utf8'));
+        }
+        catch {
+            return false;
+        }
+    });
+    if (hasHook)
+        score += 40;
+    else
+        findings.push({ severity: 'HIGH', text: 'No AgentGuard runtime hook was detected in known agent configuration files.' });
+    if ((0, node_fs_1.existsSync)(config.auditPath))
+        score += 30;
+    else
+        findings.push({ severity: 'MEDIUM', text: 'No AgentGuard audit log exists yet, so runtime threat history is unavailable.' });
+    if (skillsScanned > 0)
+        score += 30;
+    else
+        findings.push({ severity: 'MEDIUM', text: 'No installed skills were scanned during this checkup.' });
+    return {
+        score: clampScore(score),
+        findings,
+        details: findings.length ? `${findings.length} runtime protection gap(s) found.` : 'Runtime hooks, audit logging, and skill scanning are present.',
+    };
+}
+function checkWeb3Safety(skillDirs) {
+    const web3Detected = ['GOPLUS_API_KEY', 'CHAIN_ID', 'RPC_URL'].some((name) => process.env[name]) ||
+        skillDirs.some((dir) => /web3|wallet|chain|defi|token/i.test(dir));
+    if (!web3Detected) {
+        return { score: null, na: true, findings: [], details: 'No Web3 usage detected.' };
+    }
+    const findings = [];
+    let score = process.env.GOPLUS_API_KEY ? 100 : 70;
+    if (!process.env.GOPLUS_API_KEY) {
+        findings.push({ severity: 'MEDIUM', text: 'Web3 usage detected but GOPLUS_API_KEY is not configured for transaction checks.' });
+    }
+    return {
+        score,
+        findings,
+        details: findings.length ? 'Web3 usage detected with missing transaction security configuration.' : 'Web3 safety configuration is present.',
+    };
+}
+function permissionMode(path) {
+    if (!(0, node_fs_1.existsSync)(path))
+        return null;
+    try {
+        return (0, node_fs_1.statSync)(path).mode & 0o777;
+    }
+    catch {
+        return null;
+    }
+}
+function runCommandText(command, args) {
+    return new Promise((resolvePromise) => {
+        try {
+            const child = (0, node_child_process_1.execFile)(command, args, { timeout: 2000 }, (error, stdout, stderr) => {
+                if (error)
+                    resolvePromise('');
+                else
+                    resolvePromise(`${stdout || ''}${stderr || ''}`);
+            });
+            child.on('error', () => resolvePromise(''));
+        }
+        catch {
+            resolvePromise('');
+        }
+    });
+}
+function calculateCompositeScore(dimensions) {
+    const web3Score = dimensions.web3_safety.score;
+    if (web3Score === null || dimensions.web3_safety.na) {
+        return Math.round((dimensions.code_safety.score ?? 0) * 0.294 +
+            (dimensions.credential_safety.score ?? 0) * 0.294 +
+            (dimensions.network_exposure.score ?? 0) * 0.235 +
+            (dimensions.runtime_protection.score ?? 0) * 0.176);
+    }
+    return Math.round((dimensions.code_safety.score ?? 0) * 0.25 +
+        (dimensions.credential_safety.score ?? 0) * 0.25 +
+        (dimensions.network_exposure.score ?? 0) * 0.20 +
+        (dimensions.runtime_protection.score ?? 0) * 0.15 +
+        web3Score * 0.15);
+}
+async function generateCheckupHtml(report) {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentguard-checkup-'));
+    const dataPath = (0, node_path_1.join)(tempDir, 'data.json');
+    (0, node_fs_1.writeFileSync)(dataPath, JSON.stringify(report, null, 2), 'utf8');
+    const scriptPath = process.env.AGENTGUARD_CHECKUP_REPORT_SCRIPT
+        ? (0, node_path_1.resolve)(process.env.AGENTGUARD_CHECKUP_REPORT_SCRIPT)
+        : (0, node_path_1.resolve)(__dirname, '..', 'skills', 'agentguard', 'scripts', 'checkup-report.js');
+    if (!(0, node_fs_1.existsSync)(scriptPath)) {
+        throw new Error(`report generator not found at ${scriptPath}`);
+    }
+    return new Promise((resolvePromise, reject) => {
+        (0, node_child_process_1.execFile)('node', [scriptPath, '--file', dataPath], { timeout: 6000 }, (error, stdout, stderr) => {
+            if (error)
+                reject(new Error(stderr || error.message));
+            else
+                resolvePromise(stdout.trim().split(/\r?\n/).pop() || '');
+        });
+    });
+}
+function printHealthCheckupSummary(report, htmlPath) {
+    const totalFindings = Object.values(report.dimensions).reduce((sum, dim) => sum + dim.findings.length, 0);
+    console.log('AgentGuard Health Checkup');
+    console.log(`Overall Health Score: ${report.composite_score}/100 (Tier ${report.tier})`);
+    console.log(`Findings: ${totalFindings}`);
+    console.log(`Skills scanned: ${report.skills_scanned}`);
+    for (const [name, dim] of Object.entries(report.dimensions)) {
+        const score = dim.na || dim.score === null ? 'N/A' : `${dim.score}/100`;
+        console.log(`- ${name}: ${score} - ${dim.details}`);
+    }
+    if (htmlPath) {
+        console.log(`Full visual report: ${htmlPath}`);
+    }
+    else {
+        console.log('Full visual report: unavailable (text summary shown above)');
+    }
+}
+function appendCheckupAudit(auditPath, report) {
+    const totalFindings = Object.values(report.dimensions).reduce((sum, dim) => sum + dim.findings.length, 0);
+    try {
+        (0, node_fs_1.appendFileSync)(auditPath, `${JSON.stringify({
+            timestamp: report.timestamp,
+            event: 'checkup',
+            composite_score: report.composite_score,
+            tier: report.tier,
+            checks: 5,
+            findings: totalFindings,
+            skills_scanned: report.skills_scanned,
+        })}\n`, { mode: 0o600 });
+    }
+    catch {
+        // Checkup should still succeed if audit logging is unavailable.
+    }
+}
+function buildHealthAnalysis(score, dimensions) {
+    const weak = Object.entries(dimensions)
+        .filter(([, dim]) => !dim.na && dim.score !== null && dim.score < 70)
+        .map(([name]) => name.replace(/_/g, ' '));
+    if (weak.length === 0) {
+        return `Overall posture is healthy at ${score}/100. AgentGuard did not find major weaknesses across the local skill, credential, network, and runtime checks.`;
+    }
+    return `Overall posture is ${score}/100. The areas needing attention are ${weak.join(', ')}; review the findings and fix the highest-severity items first.`;
+}
+function tierForScore(score) {
+    if (score >= 90)
+        return 'S';
+    if (score >= 70)
+        return 'A';
+    if (score >= 50)
+        return 'B';
+    return 'F';
+}
+function clampScore(score) {
+    return Math.max(0, Math.min(100, Math.round(score)));
+}
+function riskLevelToSeverity(risk) {
+    if (risk === 'critical')
+        return 'CRITICAL';
+    if (risk === 'high')
+        return 'HIGH';
+    if (risk === 'medium')
+        return 'MEDIUM';
+    return 'LOW';
+}
 function buildSubscribeSummary(options) {
     const matched = options.results.reduce((acc, r) => acc + r.matchedArtifacts.length, 0);
-    const shouldNotify = options.supported && matched > 0 && options.hardFailures === 0;
+    const shouldNotify = options.supported
+        && options.hardFailures === 0
+        && (options.quiet ? matched > 0 : options.fresh > 0);
     const summary = {
         supported: options.supported,
         pulled: options.pulled,
@@ -434,14 +826,31 @@ function buildSubscribeSummary(options) {
             installed: false,
         },
     };
-    if (shouldNotify) {
+    if (shouldNotify && options.quiet) {
         summary.notification = {
             title: `AgentGuard detected ${matched} threat-feed match${matched === 1 ? '' : 'es'}`,
             body: formatThreatFeedNotification(options.results),
         };
     }
+    else if (shouldNotify) {
+        summary.notification = {
+            title: `AgentGuard found ${options.fresh} new threat-feed advisor${options.fresh === 1 ? 'y' : 'ies'}`,
+            body: formatNewAdvisoryNotification(options.freshAdvisories),
+        };
+    }
     return summary;
 }
+function formatNewAdvisoryNotification(advisories) {
+    const lines = ['AgentGuard found new threat-feed advisories that need manual review:'];
+    for (const advisory of advisories.slice(0, 10)) {
+        lines.push(`- ${advisory.id} [${advisory.severity}] ${advisory.summary}`);
+    }
+    if (advisories.length > 10) {
+        lines.push(`- ... ${advisories.length - 10} more`);
+    }
+    lines.push('Run `agentguard subscribe --quiet` to execute the local self-check and report matches automatically.');
+    return lines.join('\n');
+}
 function formatThreatFeedNotification(results) {
     const lines = ['AgentGuard threat-feed self-check found local matches:'];
     for (const result of results) {