opena2a-cli 0.1.2 → 0.2.0

package/dist/commands/shield.js

@@ -12,12 +12,48 @@
  * - recover:   Exit lockdown mode
  * - report:    Generate a security posture report
  * - session:   Show current AI coding assistant session identity
+ * - baseline:  View adaptive enforcement baselines for agents
  * - suggest:   LLM-powered policy suggestions from observed behavior
  * - explain:   LLM-powered anomaly explanations for events
  * - triage:    LLM-powered incident classification and response
  */
+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.shield = shield;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const colors_js_1 = require("../util/colors.js");
 // --- Core dispatcher ---
 async function shield(options) {
@@ -41,15 +77,19 @@ async function shield(options) {
             return handleReport(options);
         case 'session':
             return handleSession(options);
+        case 'baseline':
+            return handleBaseline(options);
         case 'suggest':
             return handleSuggest(options);
         case 'explain':
             return handleExplain(options);
         case 'triage':
             return handleTriage(options);
+        case 'monitor':
+            return handleMonitor(options);
         default:
             process.stderr.write((0, colors_js_1.red)(`Unknown subcommand: ${options.subcommand}\n`));
-            process.stderr.write('Usage: opena2a shield <init|status|log|selfcheck|policy|evaluate|recover|report|session|suggest|explain|triage>\n');
+            process.stderr.write('Usage: opena2a shield <init|status|log|selfcheck|policy|evaluate|recover|report|monitor|session|baseline|suggest|explain|triage>\n');
             return 1;
     }
 }
@@ -164,6 +204,7 @@ async function handlePolicy(options) {
 }
 async function handleEvaluate(options) {
     const { loadPolicy, evaluatePolicy } = await import('../shield/policy.js');
+    const { writeEvent } = await import('../shield/events.js');
     const isJson = options.format === 'json';
     const policy = loadPolicy(options.dir);
     if (!policy) {
@@ -175,17 +216,68 @@ async function handleEvaluate(options) {
         }
         return 1;
     }
-    const category = options.category ?? 'processes';
+    // Determine the command string from positional args or fall back to category-based evaluation.
+    const commandString = options.args && options.args.length > 0
+        ? options.args.join(' ')
+        : null;
     const agent = options.agent ?? null;
-    const target = '';
+    let category;
+    let target;
+    if (commandString) {
+        // Shell hook mode: parse the command to extract the binary name (first word).
+        // Handle pipes, subshells, and quoted strings by taking the first token.
+        const trimmed = commandString.trim();
+        const firstWord = trimmed.split(/[\s|;&]/)[0] ?? trimmed;
+        category = 'processes';
+        target = firstWord;
+    }
+    else {
+        // Explicit category mode (used by direct API calls)
+        category = options.category ?? 'processes';
+        target = '';
+    }
     const decision = evaluatePolicy(policy, agent, category, target);
+    // Write enforcement events for non-allowed decisions
+    if (decision.outcome === 'blocked') {
+        writeEvent({
+            source: 'shield',
+            category: 'enforcement',
+            severity: 'high',
+            agent,
+            sessionId: null,
+            action: 'command.blocked',
+            target: commandString ?? target,
+            outcome: 'blocked',
+            detail: { rule: decision.rule, mode: policy.mode },
+            orgId: null,
+            managed: false,
+            agentId: null,
+        });
+        process.stderr.write(`[shield] blocked: ${commandString ?? target} (rule: ${decision.rule})\n`);
+    }
+    else if (decision.outcome === 'monitored') {
+        writeEvent({
+            source: 'shield',
+            category: 'enforcement',
+            severity: 'medium',
+            agent,
+            sessionId: null,
+            action: 'command.monitored',
+            target: commandString ?? target,
+            outcome: 'monitored',
+            detail: { rule: decision.rule, mode: policy.mode },
+            orgId: null,
+            managed: false,
+            agentId: null,
+        });
+    }
     if (isJson) {
         process.stdout.write(JSON.stringify(decision, null, 2) + '\n');
     }
-    else {
+    else if (decision.outcome !== 'blocked') {
+        // Only print non-blocked outcomes to stdout (blocked warning goes to stderr above)
         const outcomeLabel = decision.outcome === 'allowed' ? (0, colors_js_1.green)('ALLOWED')
-            : decision.outcome === 'blocked' ? (0, colors_js_1.red)('BLOCKED')
-                : (0, colors_js_1.yellow)('MONITORED');
+            : (0, colors_js_1.yellow)('MONITORED');
         process.stdout.write(`${outcomeLabel}  rule=${decision.rule}\n`);
     }
     return decision.outcome === 'blocked' ? 1 : 0;
@@ -272,6 +364,56 @@ async function handleReport(options) {
         .map(([name, count]) => ({ name, count }));
     const topAgents = topN(byAgent, 10);
     const topActions = topN(byAction, 10);
+    // --- Classify events into findings ---
+    const { classifyEvents, classifyViolation } = await import('../shield/findings.js');
+    const classifiedFindings = classifyEvents(events);
+    // --- SARIF output ---
+    if (options.format === 'sarif') {
+        const { toSarif } = await import('../shield/sarif.js');
+        const { getVersion } = await import('../util/version.js');
+        const sarif = toSarif(classifiedFindings, getVersion());
+        const sarifJson = JSON.stringify(sarif, null, 2);
+        if (options.report) {
+            const reportPath = path.resolve(options.report);
+            fs.writeFileSync(reportPath, sarifJson, 'utf-8');
+            process.stdout.write(`SARIF report written to ${reportPath}\n`);
+        }
+        else {
+            process.stdout.write(sarifJson + '\n');
+        }
+        return 0;
+    }
+    // --- HTML report output ---
+    if (options.report) {
+        const weeklyReport = await buildWeeklyReport(events, since, bySeverity, byOutcome, byAgent, topActions);
+        // Enrich violations with finding data
+        for (const v of weeklyReport.policyEvaluation.topViolations) {
+            const finding = classifyViolation(v);
+            if (finding) {
+                v.findingId = finding.id;
+                v.remediationCommand = finding.remediation;
+                v.compliance = [finding.owaspAgentic, finding.mitreAtlas];
+            }
+        }
+        // Compute trend from snapshot history
+        const trendData = await computeTrend(weeklyReport);
+        if (trendData) {
+            weeklyReport.posture.trend = trendData;
+        }
+        // Save snapshot for future trend comparisons
+        await saveReportSnapshot(weeklyReport, classifiedFindings);
+        let narrative = null;
+        if (options.analyze) {
+            const { generateNarrative } = await import('../shield/llm.js');
+            narrative = await generateNarrative(weeklyReport);
+        }
+        const { generateShieldHtmlReport } = await import('../shield/report-html.js');
+        const html = generateShieldHtmlReport(weeklyReport, narrative, classifiedFindings, trendData);
+        const reportPath = path.resolve(options.report);
+        fs.writeFileSync(reportPath, html, 'utf-8');
+        process.stdout.write(`Report written to ${reportPath}\n`);
+        return 0;
+    }
     if (isJson) {
         const data = {
             periodSince: since,
@@ -369,12 +511,80 @@ async function handleReport(options) {
     process.stdout.write((0, colors_js_1.gray)('-'.repeat(50)) + '\n');
     return 0;
 }
+// --- Snapshot Persistence for Trend Analysis ---
+async function saveReportSnapshot(report, findings) {
+    const { getShieldDir } = await import('../shield/events.js');
+    const { SHIELD_SNAPSHOTS_FILE } = await import('../shield/types.js');
+    const findingCounts = {};
+    for (const f of findings) {
+        const sev = f.finding.severity;
+        findingCounts[sev] = (findingCounts[sev] ?? 0) + f.count;
+    }
+    const snapshot = {
+        timestamp: report.generatedAt,
+        score: report.posture.score,
+        grade: report.posture.grade,
+        findingCounts,
+        totalFindings: findings.reduce((sum, f) => sum + f.count, 0),
+    };
+    const dir = getShieldDir();
+    const filePath = path.join(dir, SHIELD_SNAPSHOTS_FILE);
+    fs.appendFileSync(filePath, JSON.stringify(snapshot) + '\n', 'utf-8');
+}
+async function loadPreviousSnapshot() {
+    const { getShieldDir } = await import('../shield/events.js');
+    const { SHIELD_SNAPSHOTS_FILE } = await import('../shield/types.js');
+    const dir = getShieldDir();
+    const filePath = path.join(dir, SHIELD_SNAPSHOTS_FILE);
+    if (!fs.existsSync(filePath))
+        return null;
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const lines = content.split('\n').filter(l => l.trim().length > 0);
+    if (lines.length === 0)
+        return null;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+            return JSON.parse(lines[i]);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function computeTrend(report) {
+    const previous = await loadPreviousSnapshot();
+    if (!previous)
+        return null;
+    const delta = report.posture.score - previous.score;
+    const periodMs = new Date(report.generatedAt).getTime() - new Date(previous.timestamp).getTime();
+    const periodDays = Math.max(1, Math.round(periodMs / (24 * 60 * 60 * 1000)));
+    let direction;
+    if (delta > 3)
+        direction = 'improving';
+    else if (delta < -3)
+        direction = 'declining';
+    else
+        direction = 'stable';
+    return {
+        previousScore: previous.score,
+        previousGrade: previous.grade,
+        delta,
+        direction,
+        periodDays,
+    };
+}
 /**
- * Build a WeeklyReport from aggregated event data and call generateNarrative().
- * Returns the narrative or null if LLM is unavailable.
+ * Build a WeeklyReport from aggregated event data.
  */
-async function buildNarrative(events, since, bySeverity, byOutcome, byAgent, topActions) {
-    const { generateNarrative } = await import('../shield/llm.js');
+async function buildWeeklyReport(events, since, bySeverity, byOutcome, byAgent, topActions) {
+    const { getARPStats } = await import('../shield/arp-bridge.js');
     const { hostname } = await import('node:os');
     const now = new Date();
     const sinceMatch = since.match(/^(\d+)([dwm])$/);
@@ -484,17 +694,32 @@ async function buildNarrative(events, since, bySeverity, byOutcome, byAgent, top
                 blockedInstalls += 1;
         }
     }
-    const criticalCount = bySeverity['critical'] ?? 0;
-    const highCount = bySeverity['high'] ?? 0;
-    const mediumCount = bySeverity['medium'] ?? 0;
+    // Posture score: only count external threat events, not Shield's own diagnostic scans.
+    // Shield events (posture-assessment, credential-finding, shield.init) are informational.
+    const threatEvents = events.filter(e => e.source !== 'shield');
+    const threatSeverity = {};
+    for (const e of threatEvents) {
+        threatSeverity[e.severity] = (threatSeverity[e.severity] ?? 0) + 1;
+    }
+    const criticalCount = threatSeverity['critical'] ?? 0;
+    const highCount = threatSeverity['high'] ?? 0;
+    const mediumCount = threatSeverity['medium'] ?? 0;
     const blockedCount = byOutcome['blocked'] ?? 0;
-    let score = 100;
-    score -= criticalCount * 15;
-    score -= highCount * 8;
-    score -= mediumCount * 3;
-    score += blockedCount * 2;
+    const agentCount = Object.keys(byAgent).length;
+    // Weighted factor scoring: severity (50%), enforcement (25%), coverage (25%).
+    // Severity uses capped penalties so a few events don't destroy the entire score.
+    const severityPenalty = Math.min(60, criticalCount * 12 + highCount * 5 + mediumCount * 2);
+    const severityScore = 100 - severityPenalty;
+    // Enforcement: actively blocking threats is a strong positive signal.
+    const enforcementScore = blockedCount > 0
+        ? Math.min(100, 60 + Math.min(40, blockedCount * 5))
+        : (threatEvents.length > 0 ? 30 : 50);
+    // Coverage: more agents monitored = better visibility.
+    const coverageScore = agentCount >= 3 ? 80 : agentCount > 0 ? 60 : 30;
+    let score = Math.round(severityScore * 0.5 + enforcementScore * 0.25 + coverageScore * 0.25);
     score = Math.max(0, Math.min(100, score));
     const grade = score >= 90 ? 'A' : score >= 80 ? 'B' : score >= 70 ? 'C' : score >= 60 ? 'D' : 'F';
+    const arpStats = getARPStats(since);
     const report = {
         version: 1,
         generatedAt: now.toISOString(),
@@ -524,31 +749,114 @@ async function buildNarrative(events, since, bySeverity, byOutcome, byAgent, top
             blockedInstalls,
             lowTrustPackages: [],
         },
-        configIntegrity: {
-            filesMonitored: 0,
-            tamperedFiles: [],
-            signatureStatus: 'unsigned',
-        },
+        configIntegrity: await (async () => {
+            try {
+                const mod = await import('./guard.js');
+                const fn = mod.verifyConfigIntegrity ?? mod.default?.verifyConfigIntegrity;
+                if (fn)
+                    return fn();
+                return { filesMonitored: 0, tamperedFiles: [], signatureStatus: 'unsigned' };
+            }
+            catch {
+                return { filesMonitored: 0, tamperedFiles: [], signatureStatus: 'unsigned' };
+            }
+        })(),
         runtimeProtection: {
-            arpActive: false,
-            processesSpawned: 0,
-            networkConnections: 0,
-            anomalies: 0,
+            arpActive: arpStats.totalEvents > 0,
+            processesSpawned: arpStats.processEvents,
+            networkConnections: arpStats.networkEvents,
+            anomalies: arpStats.anomalies + arpStats.violations + arpStats.threats,
         },
         posture: {
             score,
             grade,
             factors: [
-                { name: 'severity', score: Math.max(0, 100 - criticalCount * 15 - highCount * 8), weight: 0.4, detail: `${criticalCount} critical, ${highCount} high` },
-                { name: 'enforcement', score: blockedCount > 0 ? 80 : 50, weight: 0.3, detail: `${blockedCount} blocked` },
-                { name: 'coverage', score: Object.keys(byAgent).length > 0 ? 70 : 30, weight: 0.3, detail: `${Object.keys(byAgent).length} agents monitored` },
+                { name: 'severity', score: severityScore, weight: 0.5, detail: `${criticalCount} critical, ${highCount} high, ${mediumCount} medium` },
+                { name: 'enforcement', score: enforcementScore, weight: 0.25, detail: `${blockedCount} blocked` },
+                { name: 'coverage', score: coverageScore, weight: 0.25, detail: `${agentCount} agents monitored` },
             ],
             trend: null,
             comparative: null,
         },
     };
+    return report;
+}
+/**
+ * Build a WeeklyReport and call generateNarrative().
+ * Returns the narrative or null if LLM is unavailable.
+ */
+async function buildNarrative(events, since, bySeverity, byOutcome, byAgent, topActions) {
+    const { generateNarrative } = await import('../shield/llm.js');
+    const report = await buildWeeklyReport(events, since, bySeverity, byOutcome, byAgent, topActions);
     return generateNarrative(report);
 }
+// --- Monitor ---
+async function handleMonitor(options) {
+    const { importARPEvents, getARPStats } = await import('../shield/arp-bridge.js');
+    const isJson = options.format === 'json';
+    const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
+    // Step 1: Import any existing ARP events into Shield's hash chain
+    const result = importARPEvents(targetDir, options.agent);
+    // Step 2: Get ARP stats from Shield's unified log
+    const stats = getARPStats(options.since ?? '7d');
+    if (isJson) {
+        process.stdout.write(JSON.stringify({
+            import: result,
+            stats,
+        }, null, 2) + '\n');
+        return 0;
+    }
+    process.stdout.write((0, colors_js_1.bold)('Shield ARP Monitor') + '\n');
+    process.stdout.write((0, colors_js_1.gray)('-'.repeat(50)) + '\n');
+    // Import results
+    if (result.total > 0) {
+        process.stdout.write((0, colors_js_1.bold)('  Event Import') + '\n');
+        if (result.imported > 0) {
+            process.stdout.write(`    ${(0, colors_js_1.green)(`${result.imported} new events`)} imported into Shield log\n`);
+        }
+        if (result.skipped > 0) {
+            process.stdout.write(`    ${(0, colors_js_1.dim)(`${result.skipped} already imported`)}\n`);
+        }
+        if (result.errors > 0) {
+            process.stdout.write(`    ${(0, colors_js_1.yellow)(`${result.errors} parse errors`)}\n`);
+        }
+        process.stdout.write('\n');
+    }
+    else {
+        process.stdout.write((0, colors_js_1.dim)('  No ARP events found.') + '\n');
+        process.stdout.write((0, colors_js_1.dim)('  Start ARP monitoring: opena2a runtime start') + '\n\n');
+    }
+    // ARP stats from Shield's unified log
+    if (stats.totalEvents > 0) {
+        process.stdout.write((0, colors_js_1.bold)('  Runtime Protection Summary') + '\n');
+        process.stdout.write(`    ${(0, colors_js_1.dim)('Total events')}       ${stats.totalEvents}\n`);
+        process.stdout.write(`    ${(0, colors_js_1.dim)('Process events')}     ${stats.processEvents}\n`);
+        process.stdout.write(`    ${(0, colors_js_1.dim)('Network events')}     ${stats.networkEvents}\n`);
+        process.stdout.write(`    ${(0, colors_js_1.dim)('Filesystem events')}  ${stats.filesystemEvents}\n`);
+        process.stdout.write(`    ${(0, colors_js_1.dim)('Prompt events')}      ${stats.promptEvents}\n`);
+        if (stats.anomalies > 0 || stats.violations > 0 || stats.threats > 0) {
+            process.stdout.write('\n');
+            process.stdout.write((0, colors_js_1.bold)('  Detections') + '\n');
+            if (stats.anomalies > 0) {
+                process.stdout.write(`    ${(0, colors_js_1.yellow)(`${stats.anomalies} anomalies`)}\n`);
+            }
+            if (stats.violations > 0) {
+                process.stdout.write(`    ${(0, colors_js_1.red)(`${stats.violations} violations`)}\n`);
+            }
+            if (stats.threats > 0) {
+                process.stdout.write(`    ${(0, colors_js_1.bold)((0, colors_js_1.red)(`${stats.threats} threats`))}\n`);
+            }
+            if (stats.enforcements > 0) {
+                process.stdout.write(`    ${(0, colors_js_1.cyan)(`${stats.enforcements} enforcements`)}\n`);
+            }
+        }
+        else {
+            process.stdout.write(`    ${(0, colors_js_1.green)('No anomalies or threats detected')}\n`);
+        }
+    }
+    process.stdout.write((0, colors_js_1.gray)('-'.repeat(50)) + '\n');
+    return 0;
+}
 // --- Session ---
 async function handleSession(options) {
     const { identifySession, collectSignals } = await import('../shield/session.js');
@@ -589,6 +897,126 @@ async function handleSession(options) {
     process.stdout.write((0, colors_js_1.gray)('-'.repeat(40)) + '\n');
     return 0;
 }
+// --- Baseline ---
+async function handleBaseline(options) {
+    const { listBaselines, getBaseline, computeStability, checkPhaseTransition } = await import('../shield/baselines.js');
+    const isJson = options.format === 'json';
+    if (options.agent) {
+        // Detailed view for a single agent
+        const baseline = getBaseline(options.agent);
+        const stability = computeStability(baseline);
+        const transition = checkPhaseTransition(baseline);
+        if (isJson) {
+            process.stdout.write(JSON.stringify({
+                ...baseline,
+                stabilityScore: stability,
+                transition,
+            }, null, 2) + '\n');
+            return 0;
+        }
+        process.stdout.write((0, colors_js_1.bold)('Agent Baseline') + '\n');
+        process.stdout.write((0, colors_js_1.gray)('-'.repeat(50)) + '\n');
+        process.stdout.write(`  Agent:          ${(0, colors_js_1.cyan)(baseline.agent)}\n`);
+        process.stdout.write(`  Phase:          ${phaseColor(baseline.phase)}\n`);
+        process.stdout.write(`  Stability:      ${stabilityBar(stability)}\n`);
+        process.stdout.write(`  Total actions:  ${String(baseline.totalActions)}\n`);
+        process.stdout.write(`  Total sessions: ${String(baseline.totalSessions)}\n`);
+        process.stdout.write(`  Observed since: ${(0, colors_js_1.dim)(baseline.observationStart)}\n`);
+        process.stdout.write(`  Last activity:  ${(0, colors_js_1.dim)(baseline.observationEnd)}\n`);
+        if (baseline.lastNewBehaviorAt) {
+            process.stdout.write(`  Last new behavior: ${(0, colors_js_1.dim)(baseline.lastNewBehaviorAt)}\n`);
+        }
+        process.stdout.write('\n');
+        process.stdout.write((0, colors_js_1.bold)('  Observed Behavior') + '\n');
+        const buckets = [
+            ['Processes', baseline.observed.processes],
+            ['Credentials', baseline.observed.credentials],
+            ['Filesystem', baseline.observed.filesystemPaths],
+            ['Network', baseline.observed.networkHosts],
+            ['MCP Servers', baseline.observed.mcpServers],
+        ];
+        for (const [label, entries] of buckets) {
+            const keys = Object.keys(entries);
+            if (keys.length === 0)
+                continue;
+            process.stdout.write(`    ${label} (${keys.length}):\n`);
+            const sorted = Object.entries(entries).sort((a, b) => b[1] - a[1]);
+            for (const [name, count] of sorted.slice(0, 10)) {
+                process.stdout.write(`      ${name.padEnd(40)} ${(0, colors_js_1.dim)(String(count) + 'x')}\n`);
+            }
+            if (sorted.length > 10) {
+                process.stdout.write((0, colors_js_1.dim)(`      ... and ${sorted.length - 10} more\n`));
+            }
+        }
+        process.stdout.write('\n');
+        process.stdout.write(`  Transition: ${(0, colors_js_1.dim)(transition.reason)}\n`);
+        if (baseline.recommended) {
+            process.stdout.write('\n');
+            process.stdout.write((0, colors_js_1.bold)('  Recommended Policy') + '\n');
+            if (baseline.recommended.processes?.allow?.length) {
+                process.stdout.write(`    Allow processes: ${baseline.recommended.processes.allow.length}\n`);
+            }
+            if (baseline.recommended.credentials?.allow?.length) {
+                process.stdout.write(`    Allow credentials: ${baseline.recommended.credentials.allow.length}\n`);
+            }
+            if (baseline.recommended.network?.allow?.length) {
+                process.stdout.write(`    Allow network: ${baseline.recommended.network.allow.length}\n`);
+            }
+        }
+        process.stdout.write((0, colors_js_1.gray)('-'.repeat(50)) + '\n');
+        return 0;
+    }
+    // List all baselines
+    const baselines = listBaselines();
+    if (baselines.length === 0) {
+        if (isJson) {
+            process.stdout.write(JSON.stringify([], null, 2) + '\n');
+        }
+        else {
+            process.stdout.write((0, colors_js_1.dim)('No baselines found. Shield will create baselines as agent activity is observed.\n'));
+        }
+        return 0;
+    }
+    if (isJson) {
+        process.stdout.write(JSON.stringify(baselines, null, 2) + '\n');
+        return 0;
+    }
+    process.stdout.write((0, colors_js_1.bold)('Agent Baselines') + '\n');
+    process.stdout.write((0, colors_js_1.gray)('-'.repeat(70)) + '\n');
+    process.stdout.write(`  ${'Agent'.padEnd(20)} ${'Phase'.padEnd(10)} ${'Stability'.padEnd(12)} ${'Actions'.padEnd(10)} Sessions\n`);
+    process.stdout.write((0, colors_js_1.gray)('-'.repeat(70)) + '\n');
+    for (const bl of baselines) {
+        process.stdout.write(`  ${bl.agent.padEnd(20)} ${phaseColor(bl.phase).padEnd(10 + colorPadding(bl.phase))} ` +
+            `${bl.stabilityScore.toFixed(2).padEnd(12)} ` +
+            `${String(bl.totalActions).padEnd(10)} ` +
+            `${String(bl.totalSessions)}\n`);
+    }
+    process.stdout.write((0, colors_js_1.gray)('-'.repeat(70)) + '\n');
+    return 0;
+}
+function phaseColor(phase) {
+    switch (phase) {
+        case 'learn': return (0, colors_js_1.cyan)(phase);
+        case 'suggest': return (0, colors_js_1.yellow)(phase);
+        case 'protect': return (0, colors_js_1.green)(phase);
+        default: return (0, colors_js_1.dim)(phase);
+    }
+}
+/** ANSI codes add invisible characters; compute extra length for padding. */
+function colorPadding(phase) {
+    return phaseColor(phase).length - phase.length;
+}
+function stabilityBar(score) {
+    const filled = Math.round(score * 10);
+    const empty = 10 - filled;
+    const bar = '#'.repeat(filled) + '-'.repeat(empty);
+    const label = (score * 100).toFixed(0) + '%';
+    if (score >= 0.8)
+        return (0, colors_js_1.green)(`[${bar}] ${label}`);
+    if (score >= 0.5)
+        return (0, colors_js_1.yellow)(`[${bar}] ${label}`);
+    return (0, colors_js_1.dim)(`[${bar}] ${label}`);
+}
 // --- LLM intelligence handlers ---
 async function handleSuggest(options) {
     const { checkLlmAvailable, suggestPolicy } = await import('../shield/llm.js');