@minionry/minion 0.7.36

package/dist/server/mcp/security-analysis.js

@@ -0,0 +1,384 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { COMPANY_DENIED_OPERATIONS, isCompanyMode } from './company-patterns.js';
+import { CRITICAL_THREATS, DEPLOY_PATTERNS, matchesPattern, NEEDS_AI_REVIEW, normalizeOperation, SAFE_OPERATIONS, SENSITIVE_PATHS, } from './security-patterns.js';
+function containsChainOperators(operation) {
+    const commandPart = operation.replace(/^Bash:\s*/i, '');
+    return /;|&&|\|\||\||\n/.test(commandPart);
+}
+function containsDangerousPipe(operation) {
+    const commandPart = operation.replace(/^Bash:\s*/i, '');
+    return /\|\s*(nc|netcat|ncat|curl|wget|scp|bash|sh)\b/i.test(commandPart);
+}
+function containsSensitiveRedirect(operation) {
+    const commandPart = operation.replace(/^Bash:\s*/i, '');
+    return /(?:>>?|\btee\b(?:\s+-\w+)*)\s*~?\/?.*\/(authorized_keys|\.bashrc|\.bash_profile|\.zshrc|\.profile|\.ssh\/|\.aws\/|\.gnupg\/|ld\.so\.preload|crontab|sudoers)/i.test(commandPart)
+        || /(?:>>?|\btee\b(?:\s+-\w+)*)\s*\/etc\//i.test(commandPart);
+}
+function containsBashExpansion(operation) {
+    const commandPart = operation.replace(/^Bash:\s*/i, '');
+    return /`[^`]+`/.test(commandPart) || /\$\([^)]+\)/.test(commandPart);
+}
+function containsAnyExpansion(operation) {
+    const cmd = operation.replace(/^Bash:\s*/i, '');
+    return /\$\{[^}]+\}/.test(cmd) || /\$\([^)]+\)/.test(cmd) || /`[^`]+`/.test(cmd);
+}
+function matchingParen(text, open) {
+    let depth = 0;
+    for (let j = open; j < text.length; j++) {
+        if (text[j] === '(')
+            depth++;
+        else if (text[j] === ')') {
+            depth--;
+            if (depth === 0)
+                return j;
+        }
+    }
+    return -1;
+}
+function stripCommandSubstitutions(commandPart) {
+    const bodies = [];
+    let stripped = '';
+    let i = 0;
+    while (i < commandPart.length) {
+        if (commandPart[i] === '\\') {
+            stripped += commandPart.slice(i, i + 2);
+            i += 2;
+            continue;
+        }
+        const dollarParen = commandPart[i] === '$' && commandPart[i + 1] === '(';
+        const backtick = commandPart[i] === '`';
+        if (!dollarParen && !backtick) {
+            stripped += commandPart[i];
+            i++;
+            continue;
+        }
+        const end = dollarParen
+            ? matchingParen(commandPart, i + 1)
+            : commandPart.indexOf('`', i + 1);
+        if (end === -1)
+            return null;
+        bodies.push(commandPart.slice(dollarParen ? i + 2 : i + 1, end));
+        stripped += SUBSTITUTION_MARK;
+        i = end + 1;
+    }
+    return { stripped, bodies };
+}
+const SUBSTITUTION_MARK = '__SUBST__';
+function segmentCarriesExpansion(segment) {
+    return segment.includes(SUBSTITUTION_MARK) || /\$\{|\$[A-Za-z_]/.test(segment);
+}
+export function splitShellSegments(commandPart) {
+    const segments = [];
+    let current = '';
+    let i = 0;
+    while (i < commandPart.length) {
+        const ch = commandPart[i];
+        if (ch === '"' || ch === "'") {
+            const end = findQuoteEnd(commandPart, i);
+            if (end === -1)
+                return commandPart.split(/&&|\|\||;|\||\n/);
+            current += commandPart.slice(i, end + 1);
+            i = end + 1;
+            continue;
+        }
+        if (ch === '\\') {
+            current += commandPart.slice(i, i + 2);
+            i += 2;
+            continue;
+        }
+        const operatorLength = segmentOperatorAt(commandPart, i);
+        if (operatorLength > 0) {
+            segments.push(current);
+            current = '';
+            i += operatorLength;
+            continue;
+        }
+        current += ch;
+        i++;
+    }
+    segments.push(current);
+    return segments;
+}
+function findQuoteEnd(text, open) {
+    const quote = text[open];
+    for (let j = open + 1; j < text.length; j++) {
+        if (quote === '"' && text[j] === '\\') {
+            j++;
+            continue;
+        }
+        if (text[j] === quote)
+            return j;
+    }
+    return -1;
+}
+function segmentOperatorAt(text, i) {
+    const ch = text[i];
+    if (ch === '\n' || ch === ';')
+        return 1;
+    if (ch === '|')
+        return text[i + 1] === '|' ? 2 : 1;
+    if (ch === '&' && text[i + 1] === '&')
+        return 2;
+    return 0;
+}
+const CONTROL_FLOW_NOOP = /^(?:for\s+\w+\s+in(?:\s+[^`;|&<>][^`;|&<>]*)?|for\s+\w+|do|then|else|case\s+[^`\s]+\s+in|;;|:|(?:done|fi|esac|\}|\))(?:\s+\d?>{1,2}\s*\S+)*|[A-Za-z_]\w*=(?:"(?:[^"\\]|\\.)*"|'[^']*'|[^\s;|&<>`]*))$/i;
+function normalizeSegment(rawSegment) {
+    let segment = rawSegment.trim().replace(/^[({]\s*/, '').replace(/\s*[)}]$/, '').trim();
+    for (let i = 0; i < 3; i++) {
+        const next = segment.replace(/^(?:do|then|else|if|elif|while|until|!)\s+/i, '').trim();
+        if (next === segment)
+            break;
+        segment = next;
+    }
+    return segment;
+}
+function unwrapCommandPrefix(segment) {
+    let current = segment;
+    for (let i = 0; i < 3; i++) {
+        const next = current
+            .replace(/^timeout\s+(?:-{1,2}[\w-]+(?:[= ]\S+)?\s+)*\d+(?:\.\d+)?[smhd]?\s+/i, '')
+            .replace(/^nice\s+(?:-n\s*-?\d+\s+|--adjustment[= ]-?\d+\s+)?/i, '')
+            .replace(/^(?:nohup|stdbuf(?:\s+-[ioe]\S*)+|ionice(?:\s+-[cn]\s*\d+)*)\s+/i, '')
+            .replace(/^env\s+(?:(?:-i|--ignore-environment|-u\s+\w+)\s+)*(?:\w+=(?:"[^"]*"|'[^']*'|\S*)\s+)*/i, '')
+            .replace(/^xargs(?:\s+(?:-[0rtxp]+|--null|--no-run-if-empty|--verbose|-[nIPLdsEa]\s*\S+|--[\w-]+=\S+))*\s+/i, '')
+            .replace(/^git\s+(?:-C\s+\S+\s+|--no-pager\s+|--git-dir=\S+\s+|--work-tree=\S+\s+)+/i, 'git ');
+        if (next === current)
+            break;
+        current = next;
+    }
+    return current;
+}
+function segmentIsAllowlisted(rawSegment) {
+    const segment = normalizeSegment(rawSegment);
+    if (!segment || CONTROL_FLOW_NOOP.test(segment))
+        return true;
+    if (matchesPattern(`Bash: ${unwrapCommandPrefix(segment)}`, SAFE_OPERATIONS))
+        return true;
+    return segmentIsReadOnly(segment);
+}
+function allSegmentsPatternSafe(commandPart) {
+    for (const rawSegment of splitShellSegments(commandPart)) {
+        if (!segmentIsAllowlisted(rawSegment))
+            return false;
+    }
+    return true;
+}
+const READ_ONLY_BASH = /^(ls|pwd|cat|head|tail|wc|sort|uniq|nl|rev|cut|tr|comm|column|seq|echo|printf|date|whoami|id|groups|hostname|uname|uptime|df|du|free|ps|stat|file|readlink|realpath|basename|dirname|which|type|printenv|grep|egrep|fgrep|rg|ag|find|diff|jq|yq|sed|awk|gawk|md5sum|sha1sum|sha256sum|cksum|true|false|test|cd)($|\s)/i;
+const READ_ONLY_GIT = /^git\s+(status|log|diff|show|branch|describe|blame|rev-parse|rev-list|merge-base|ls-files|shortlog|count-objects|cat-file|symbolic-ref|for-each-ref|config\s+--get|remote\s+-v)($|\s)/i;
+const READ_ONLY_DISQUALIFIERS = [
+    /(^|\s)-(exec|execdir|ok|okdir|delete|fprint|fprintf)(\s|$)/i,
+    /\bsed\b[^|;&]*\s(-i\b|--in-place)/i,
+    /\bsystem\s*\(/i,
+    /\bxargs\b/i,
+    /(^|\s)\d?>>?\s*(?!&\d|\/dev\/null\b)\S/,
+    /^(env|nice|timeout|nohup|stdbuf|ionice|setsid|chroot|doas)(\s|$)/i,
+];
+const SENSITIVE_READ_TARGETS = /(\/etc\/(shadow|passwd|sudoers)|\.ssh\/|\.aws\/|\.gnupg\/|\.docker\/config|\.kube\/config|\.git-credentials|\.npmrc|\.netrc|\.pypirc|authorized_keys|id_rsa|id_ed25519|id_ecdsa|\.env(\.|\b)|credentials|\.pem\b|\.p12\b|\.keystore\b)/i;
+const CREDENTIAL_FILE_PATHS = /(\/etc\/(?:shadow|sudoers)\b|[~/]\.ssh\/|[~/]\.aws\/|[~/]\.gnupg\/|\.git-credentials\b|\.netrc\b|\.pypirc\b|authorized_keys\b|\bid_(?:rsa|ed25519|ecdsa|dsa)\b|\.pem\b|\.p12\b|\.pfx\b|\.keystore\b)/i;
+function segmentIsReadOnly(rawSegment) {
+    const segment = unwrapCommandPrefix(rawSegment.trim()).replace(/^\[\[?\s/, 'test ');
+    if (READ_ONLY_DISQUALIFIERS.some((p) => p.test(segment)))
+        return false;
+    if (SENSITIVE_READ_TARGETS.test(segment))
+        return false;
+    return READ_ONLY_BASH.test(segment) || READ_ONLY_GIT.test(segment);
+}
+function allSegmentsReadOnly(commandPart) {
+    for (const rawSegment of splitShellSegments(commandPart)) {
+        const segment = rawSegment.trim();
+        if (!segment)
+            continue;
+        if (!segmentIsReadOnly(segment))
+            return false;
+    }
+    return true;
+}
+function expansionCarryingSegmentsReadOnly(strippedCommand) {
+    for (const rawSegment of splitShellSegments(strippedCommand)) {
+        const segment = normalizeSegment(rawSegment);
+        if (!segment)
+            continue;
+        if (!segmentCarriesExpansion(segment))
+            continue;
+        if (CONTROL_FLOW_NOOP.test(segment))
+            continue;
+        if (!segmentIsReadOnly(segment))
+            return false;
+    }
+    return true;
+}
+function expansionBodiesReadOnly(bodies) {
+    for (const body of bodies) {
+        const inner = body.trim();
+        if (!inner)
+            return false;
+        const innerOp = `Bash: ${inner}`;
+        if (containsSensitiveRedirect(innerOp) || containsDangerousPipe(innerOp))
+            return false;
+        const nested = stripCommandSubstitutions(inner);
+        if (!nested)
+            return false;
+        if (nested.bodies.length > 0 && !expansionBodiesReadOnly(nested.bodies))
+            return false;
+        if (!allSegmentsReadOnly(nested.stripped))
+            return false;
+    }
+    return true;
+}
+export function isDeployMode() {
+    return process.env.BOUNCER_DEPLOY_MODE === 'true';
+}
+function bashHasUnsafeCompoundOps(op) {
+    return containsChainOperators(op) ||
+        containsDangerousPipe(op) ||
+        containsBashExpansion(op) ||
+        containsSensitiveRedirect(op);
+}
+function bashHasConcerningPatterns(op) {
+    if (/\*\*?/.test(op))
+        return true;
+    if (/^Bash:\s*\.\//.test(op))
+        return true;
+    return false;
+}
+function bashCompoundAllSegmentsSafe(operation) {
+    if (containsSensitiveRedirect(operation)) {
+        return false;
+    }
+    const commandPart = operation.replace(/^Bash:\s*/i, '');
+    const parsed = stripCommandSubstitutions(commandPart);
+    if (!parsed)
+        return false;
+    if (parsed.bodies.length > 0 && !expansionBodiesReadOnly(parsed.bodies))
+        return false;
+    return allSegmentsPatternSafe(parsed.stripped);
+}
+function bashExpansionIsReadOnlySafe(operation) {
+    const commandPart = operation.replace(/^Bash:\s*/i, '').trim();
+    if (/^(\$\{|\$\(|`)/.test(commandPart))
+        return false;
+    if (containsDangerousPipe(operation) || containsSensitiveRedirect(operation))
+        return false;
+    const parsed = stripCommandSubstitutions(commandPart);
+    if (!parsed)
+        return false;
+    if (parsed.bodies.length > 0 && !expansionBodiesReadOnly(parsed.bodies))
+        return false;
+    if (!allSegmentsPatternSafe(parsed.stripped))
+        return false;
+    return expansionCarryingSegmentsReadOnly(parsed.stripped);
+}
+const SAFE_RM_PATTERNS = [
+    /rm\s+-rf\s+(\.\/)?node_modules($|\s)/i,
+    /rm\s+-rf\s+(\.\/)?dist($|\s)/i,
+    /rm\s+-rf\s+(\.\/)?build($|\s)/i,
+    /rm\s+-rf\s+(\.\/)?\.cache($|\s)/i,
+    /rm\s+-rf\s+(\.\/)?\.next($|\s)/i,
+    /rm\s+-rf\s+(\.\/)?target($|\s)/i,
+    /rm\s+-rf\s+(\.\/)?__pycache__($|\s)/i,
+];
+function safeBashStillNeedsReview(op) {
+    if (CREDENTIAL_FILE_PATHS.test(op)) {
+        return true;
+    }
+    if (matchesPattern(op, NEEDS_AI_REVIEW) && !SAFE_RM_PATTERNS.some((p) => p.test(op))) {
+        return true;
+    }
+    if (bashHasUnsafeCompoundOps(op)) {
+        return !bashCompoundAllSegmentsSafe(op);
+    }
+    return false;
+}
+const INTERPRETER_INLINE_EVAL = 
+/(?<![.\w-])(?:python3?|ruby|perl|php|node|bun|deno|tsx|ts-node)\b[^\n;|&]*?\s(?:-c|-e|-r|-E|-p|--eval|--print)\b/i;
+function startsWithScaffolding(op) {
+    return /^Bash:\s*(?:for\s|while\s|until\s|if\s|case\s|\(|\{\s)/i.test(op);
+}
+function modeRequiresReview(op) {
+    if (isDeployMode() && matchesPattern(op, DEPLOY_PATTERNS))
+        return true;
+    return isCompanyMode() && matchesPattern(op, COMPANY_DENIED_OPERATIONS) !== null;
+}
+export function requiresAIReview(operation) {
+    const op = normalizeOperation(operation);
+    if (matchesPattern(op, SENSITIVE_PATHS))
+        return true;
+    if (/^Bash:/i.test(op) && containsAnyExpansion(op) && !bashExpansionIsReadOnlySafe(op)) {
+        return true;
+    }
+    if (/^Bash:/i.test(op) && INTERPRETER_INLINE_EVAL.test(op)) {
+        return true;
+    }
+    if (modeRequiresReview(op))
+        return true;
+    if (matchesPattern(op, SAFE_OPERATIONS)) {
+        return /^Bash:/i.test(op) && safeBashStillNeedsReview(op);
+    }
+    if (startsWithScaffolding(op)) {
+        return !bashCompoundAllSegmentsSafe(op);
+    }
+    if (matchesPattern(op, CRITICAL_THREATS))
+        return false;
+    if (matchesPattern(op, NEEDS_AI_REVIEW)) {
+        return !SAFE_RM_PATTERNS.some(p => p.test(op));
+    }
+    if (/^Bash:/.test(op) && bashHasConcerningPatterns(op))
+        return true;
+    return false;
+}
+export function isSensitivePath(operation) {
+    return matchesPattern(operation, SENSITIVE_PATHS);
+}
+export function classifyRisk(operation) {
+    const criticalThreat = matchesPattern(operation, CRITICAL_THREATS);
+    if (criticalThreat) {
+        return {
+            isDestructive: true,
+            riskLevel: 'critical',
+            reasons: [criticalThreat.reason || 'Critical threat detected']
+        };
+    }
+    const sensitivePath = matchesPattern(operation, SENSITIVE_PATHS);
+    if (sensitivePath) {
+        return {
+            isDestructive: false,
+            riskLevel: 'high',
+            reasons: [sensitivePath.reason || 'Sensitive path - requires clear user intent']
+        };
+    }
+    const elevatedPatterns = [
+        { pattern: /sudo/i, reason: 'Elevated privileges requested' },
+        { pattern: /DROP\s+(TABLE|DATABASE)/i, reason: 'Database deletion' },
+        { pattern: /chmod\s+777/i, reason: 'Dangerous permissions' },
+        { pattern: /(curl|wget).*\|.*(bash|sh)/i, reason: 'Remote code execution' },
+        { pattern: /pkill|killall/i, reason: 'Process termination' },
+        { pattern: /\|\s*(nc|netcat|ncat)\b/i, reason: 'Data exfiltration via netcat' },
+        { pattern: /\bscp\b.*@/i, reason: 'Data exfiltration via SCP' },
+        { pattern: /curl\b.*-d\s*@/i, reason: 'Data exfiltration via curl file upload' },
+    ];
+    for (const pattern of elevatedPatterns) {
+        if (pattern.pattern.test(operation)) {
+            return {
+                isDestructive: true,
+                riskLevel: 'high',
+                reasons: [pattern.reason || 'Elevated risk operation']
+            };
+        }
+    }
+    if (/rm\s+-rf/i.test(operation)) {
+        if (matchesPattern(operation, SAFE_OPERATIONS)) {
+            return { isDestructive: false, riskLevel: 'low', reasons: [] };
+        }
+        return {
+            isDestructive: true,
+            riskLevel: 'medium',
+            reasons: ['Recursive deletion']
+        };
+    }
+    return {
+        isDestructive: false,
+        riskLevel: 'low',
+        reasons: []
+    };
+}

package/dist/server/mcp/security-audit.js

@@ -0,0 +1,152 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, } from 'node:fs';
+import { join } from 'node:path';
+import { SPACE_DIRNAME, SPACE_LAYOUT } from '../services/space-layout.js';
+const DEFAULT_LOG_SUBDIR = join(SPACE_DIRNAME, SPACE_LAYOUT.logs);
+const USER_REQUEST_PREVIEW_CHARS = 160;
+export function slimAuditContext(context) {
+    if (!context || typeof context !== 'object')
+        return context;
+    const { userRequest, ...rest } = context;
+    if (typeof userRequest !== 'string')
+        return context;
+    return {
+        ...rest,
+        userRequestSha256: createHash('sha256').update(userRequest).digest('hex'),
+        userRequestPreview: userRequest.length > USER_REQUEST_PREVIEW_CHARS
+            ? `${userRequest.slice(0, USER_REQUEST_PREVIEW_CHARS)}…`
+            : userRequest,
+    };
+}
+export class SecurityAuditLogger {
+    logFile;
+    constructor(workingDir) {
+        const logDir = join(workingDir || process.cwd(), DEFAULT_LOG_SUBDIR);
+        this.logFile = join(logDir, 'bouncer-audit.jsonl');
+        if (!existsSync(logDir)) {
+            mkdirSync(logDir, { recursive: true });
+        }
+    }
+    log(entry) {
+        const logLine = `${JSON.stringify({
+            ...entry,
+            timestamp: entry.timestamp || new Date().toISOString()
+        })}\n`;
+        try {
+            appendFileSync(this.logFile, logLine, 'utf-8');
+        }
+        catch (error) {
+            console.error('[SecurityAudit] Failed to write log:', error);
+        }
+    }
+    read(opts) {
+        if (!existsSync(this.logFile))
+            return [];
+        let content;
+        try {
+            content = readFileSync(this.logFile, 'utf-8');
+        }
+        catch (error) {
+            console.error('[SecurityAudit] Failed to read log:', error);
+            return [];
+        }
+        const lines = content.split('\n').filter((line) => line.trim().length > 0);
+        const selected = opts?.limit && opts.limit > 0 ? lines.slice(-opts.limit) : lines;
+        const entries = [];
+        for (const line of selected) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+            }
+        }
+        return entries;
+    }
+    logDecision(operation, decision, confidence, reasoning, metadata) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            operation,
+            decision,
+            confidence,
+            reasoning,
+            ...metadata
+        });
+    }
+}
+let auditLogger = null;
+let auditLoggerWorkingDir;
+export function getAuditLogger(workingDir) {
+    if (!auditLogger || (workingDir && workingDir !== auditLoggerWorkingDir)) {
+        auditLogger = new SecurityAuditLogger(workingDir);
+        auditLoggerWorkingDir = workingDir;
+    }
+    return auditLogger;
+}
+export function readAuditEntries(workingDir, opts) {
+    return getAuditLogger(workingDir).read(opts);
+}
+function logClassifierConsole(metadata) {
+    const engine = metadata?.classifierEngine;
+    const model = metadata?.classifierModel;
+    if (engine || model) {
+        console.error(`[SecurityAudit]   Classifier: ${engine ?? '?'}/${model ?? '?'}`);
+    }
+    if (metadata?.classifierFallback === true) {
+        console.error('[SecurityAudit] ⚠️  CLASSIFIER DOWNGRADE: configured classifier unavailable — decision made by the Claude+Haiku floor.');
+    }
+}
+export function logBouncerDecision(operation, decision, confidence, reasoning, metadata) {
+    const safeDecision = decision ?? 'deny';
+    const validDecisions = ['allow', 'deny', 'warn_allow'];
+    const normalizedDecision = validDecisions.includes(safeDecision) ? safeDecision : 'deny';
+    const workingDir = metadata?.context?.workingDirectory;
+    const logger = getAuditLogger(workingDir);
+    const auditMetadata = metadata ? { ...metadata, context: slimAuditContext(metadata.context) } : undefined;
+    logger.logDecision(operation, normalizedDecision, confidence, reasoning, auditMetadata);
+    const emoji = normalizedDecision === 'allow' ? '✅' :
+        normalizedDecision === 'warn_allow' ? '⚠️' : '🚫';
+    const timestamp = new Date().toISOString();
+    const layerInfo = metadata?.layer ? ` [${metadata.layer}]` : '';
+    const latencyInfo = metadata?.latencyMs !== undefined ? ` (${metadata.latencyMs}ms)` : '';
+    console.error(`[SecurityAudit] ${timestamp} ${emoji} ${normalizedDecision.toUpperCase()}${layerInfo}${latencyInfo}`);
+    console.error(`[SecurityAudit]   Operation: ${operation}`);
+    console.error(`[SecurityAudit]   Confidence: ${confidence}%`);
+    console.error(`[SecurityAudit]   Reasoning: ${reasoning}`);
+    logClassifierConsole(metadata);
+    if (metadata?.threatLevel === 'critical' || normalizedDecision === 'deny') {
+        console.error(`[SecurityAudit] ⚠️  SECURITY ALERT: Dangerous operation ${normalizedDecision === 'deny' ? 'BLOCKED' : 'detected'}`);
+    }
+}
+export function logEnforcedBlock(details) {
+    const logger = getAuditLogger();
+    const logEntry = {
+        type: 'ENFORCED_BLOCK',
+        timestamp: details.timestamp || new Date().toISOString(),
+        operation: details.command,
+        decision: 'deny',
+        confidence: details.confidence,
+        reasoning: details.reason,
+        threatLevel: 'critical',
+        sessionId: details.sessionId,
+        movementId: details.movementId,
+        severity: 'CRITICAL'
+    };
+    logger.log(logEntry);
+    console.error('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.error('🚨 SECURITY ENFORCEMENT - OPERATION BLOCKED');
+    console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.error(`Timestamp:  ${logEntry.timestamp}`);
+    console.error(`Command:    ${details.command}`);
+    console.error(`Reason:     ${details.reason}`);
+    console.error(`Confidence: ${details.confidence}%`);
+    console.error(`Threat:     CRITICAL`);
+    if (details.sessionId) {
+        console.error(`Session:    ${details.sessionId}`);
+    }
+    if (details.movementId) {
+        console.error(`Movement:   ${details.movementId}`);
+    }
+    console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+}