Merge branch 'main' into fix/1543

- Add crisis detection module for Nexus world chat
- Add js/crisis-detector.js with crisis detection features
- Add tests (10 tests, all passing)
- Add script to index.html

Features:
1. Crisis keyword detection (30+ keywords)
2. Pattern matching for crisis phrases
3. 988 crisis overlay display
4. Crisis metrics tracking
5. localStorage persistence

Addresses issue #1543: feat: Nexus → the-door crisis bridge — detect distress in world chat

Crisis detection:
- Detects keywords like 'suicide', 'kill myself', etc.
- Detects patterns like 'I want to die', etc.
- Shows 988 crisis overlay when detected
- Logs crisis events to localStorage

Overlay features:
- 988 Suicide & Crisis Lifeline information
- Crisis Text Line (741741)
- Grounding exercise instructions
- Close and Call 988 buttons

Tested:
- Keyword detection
- Pattern matching
- Metrics tracking
- Overlay visibility
- Crisis handler

index.html

@@ -395,6 +395,7 @@
 <div id="memory-connections-panel" class="memory-connections-panel" style="display:none;" aria-label="Memory Connections Panel"></div>
 
 <script src="./boot.js"></script>
+<script src="./js/crisis-detector.js"></script>
 <script src="./avatar-customization.js"></script>
 <script src="./lod-system.js"></script>
 <script>

js/crisis-detector.js

@@ -0,0 +1,351 @@
+/**
+ * Crisis Detection Module for The Nexus
+ * Issue #1543: feat: Nexus → the-door crisis bridge — detect distress in world chat
+ * 
+ * Detects crisis signals in chat messages and shows 988 overlay.
+ * Based on crisis detection from multi_user_bridge.py
+ */
+
+class CrisisDetector {
+    constructor(options = {}) {
+        this.crisisKeywords = options.crisisKeywords || [
+            'suicide', 'kill myself', 'end it all', 'want to die', 'better off dead',
+            'no reason to live', 'can\'t go on', 'give up', 'hopeless', 'helpless',
+            'worthless', 'burden', 'trapped', 'pain unbearable', 'no way out',
+            'self-harm', 'cut myself', 'hurt myself', 'overdose', 'jump off',
+            'hang myself', 'shoot myself', 'drown myself', 'end my life',
+            'tired of living', 'don\'t want to be here', 'disappear forever',
+            'nobody cares', 'world without me', 'last resort', 'final goodbye'
+        ];
+        
+        this.crisisPatterns = options.crisisPatterns || [
+            /\b(i\s+want\s+to\s+die)\b/i,
+            /\b(i\'m\s+going\s+to\s+kill\s+myself)\b/i,
+            /\b(i\s+should\s+just\s+die)\b/i,
+            /\b(nobody\s+would\s+miss\s+me)\b/i,
+            /\b(i\s+can\'t\s+take\s+it\s+anymore)\b/i,
+            /\b(i\'m\s+done\s+with\s+life)\b/i,
+            /\b(i\s+hate\s+my\s+life)\b/i,
+            /\b(i\s+wish\s+i\s+was\s+dead)\b/i,
+            /\b(i\'m\s+going\s+to\s+end\s+it)\b/i,
+            /\b(i\s+have\s+nothing\s+to\s+live\s+for)\b/i
+        ];
+        
+        this.overlayVisible = false;
+        this.metrics = {
+            totalChecks: 0,
+            crisesDetected: 0,
+            lastDetection: null
+        };
+        
+        this.onCrisisDetected = options.onCrisisDetected || this.defaultCrisisHandler.bind(this);
+    }
+    
+    /**
+     * Check if a message contains crisis signals
+     * @param {string} message - The chat message to check
+     * @returns {boolean} True if crisis detected
+     */
+    detectCrisis(message) {
+        if (!message || typeof message !== 'string') {
+            return false;
+        }
+        
+        this.metrics.totalChecks++;
+        
+        const lowerMessage = message.toLowerCase();
+        
+        // Check for keyword matches
+        for (const keyword of this.crisisKeywords) {
+            if (lowerMessage.includes(keyword.toLowerCase())) {
+                this.logCrisisDetection(message, keyword);
+                this.onCrisisDetected(message);
+                return true;
+            }
+        }
+        
+        // Check for pattern matches
+        for (const pattern of this.crisisPatterns) {
+            if (pattern.test(message)) {
+                this.logCrisisDetection(message, pattern.toString());
+                this.onCrisisDetected(message);
+                return true;
+            }
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Log crisis detection event
+     * @param {string} message - The original message
+     * @param {string} trigger - What triggered the detection
+     */
+    logCrisisDetection(message, trigger) {
+        this.metrics.crisesDetected++;
+        this.metrics.lastDetection = {
+            timestamp: Date.now(),
+            message: message,
+            trigger: trigger
+        };
+        
+        console.warn('[CRISIS DETECTED]', {
+            message: message,
+            trigger: trigger,
+            timestamp: new Date().toISOString()
+        });
+        
+        // Log to crisis metrics
+        this.logToMetrics({
+            type: 'crisis_detected',
+            message: message,
+            trigger: trigger,
+            timestamp: Date.now()
+        });
+    }
+    
+    /**
+     * Log event to crisis metrics
+     * @param {Object} event - The event to log
+     */
+    logToMetrics(event) {
+        // Store in localStorage for persistence
+        try {
+            const metrics = JSON.parse(localStorage.getItem('nexus-crisis-metrics') || '[]');
+            metrics.push(event);
+            
+            // Keep only last 100 events
+            if (metrics.length > 100) {
+                metrics.splice(0, metrics.length - 100);
+            }
+            
+            localStorage.setItem('nexus-crisis-metrics', JSON.stringify(metrics));
+        } catch (error) {
+            console.error('Failed to log crisis metrics:', error);
+        }
+        
+        // Also log to console for debugging
+        console.log('[Crisis Metrics]', event);
+    }
+    
+    /**
+     * Default crisis handler
+     * @param {string} message - The crisis message
+     */
+    defaultCrisisHandler(message) {
+        console.warn('Crisis detected in message:', message);
+        this.show988Overlay();
+    }
+    
+    /**
+     * Show the 988 crisis overlay
+     */
+    show988Overlay() {
+        if (this.overlayVisible) {
+            return; // Already showing
+        }
+        
+        this.overlayVisible = true;
+        
+        // Create overlay element
+        const overlay = document.createElement('div');
+        overlay.id = 'crisis-overlay';
+        overlay.style.cssText = `
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: rgba(0, 0, 0, 0.95);
+            z-index: 10000;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-family: 'SF Mono', 'Cascadia Code', 'Fira Code', monospace;
+            text-align: center;
+            padding: 20px;
+        `;
+        
+        overlay.innerHTML = `
+            <div style="max-width: 600px;">
+                <h1 style="color: #ff4466; font-size: 32px; margin-bottom: 20px;">
+                    🆘 CRISIS SUPPORT
+                </h1>
+                
+                <p style="font-size: 18px; margin-bottom: 30px; line-height: 1.6;">
+                    We detected you might be in distress. You're not alone.
+                </p>
+                
+                <div style="background: rgba(255, 68, 102, 0.1); border: 2px solid #ff4466; border-radius: 8px; padding: 20px; margin-bottom: 30px;">
+                    <h2 style="color: #ff4466; font-size: 24px; margin-bottom: 15px;">
+                        988 Suicide & Crisis Lifeline
+                    </h2>
+                    <p style="font-size: 36px; font-weight: bold; margin-bottom: 10px;">
+                        Call or Text: 988
+                    </p>
+                    <p style="font-size: 16px; color: #aaa;">
+                        Available 24/7 • Free • Confidential
+                    </p>
+                </div>
+                
+                <div style="background: rgba(74, 158, 255, 0.1); border: 2px solid #4a9eff; border-radius: 8px; padding: 20px; margin-bottom: 30px;">
+                    <h3 style="color: #4a9eff; font-size: 20px; margin-bottom: 15px;">
+                        Crisis Text Line
+                    </h3>
+                    <p style="font-size: 24px; font-weight: bold; margin-bottom: 10px;">
+                        Text HOME to 741741
+                    </p>
+                    <p style="font-size: 16px; color: #aaa;">
+                        Free • 24/7 • Confidential
+                    </p>
+                </div>
+                
+                <div style="margin-bottom: 30px;">
+                    <h3 style="color: #4af0c0; font-size: 18px; margin-bottom: 15px;">
+                        Grounding Exercise
+                    </h3>
+                    <p style="font-size: 16px; line-height: 1.6; text-align: left; max-width: 400px; margin: 0 auto;">
+                        Name:<br>
+                        • 5 things you can see<br>
+                        • 4 things you can touch<br>
+                        • 3 things you can hear<br>
+                        • 2 things you can smell<br>
+                        • 1 thing you can taste
+                    </p>
+                </div>
+                
+                <button id="close-crisis-overlay" style="
+                    background: #4af0c0;
+                    color: #080810;
+                    border: none;
+                    padding: 12px 24px;
+                    font-size: 16px;
+                    font-weight: bold;
+                    border-radius: 4px;
+                    cursor: pointer;
+                    font-family: inherit;
+                    margin-right: 10px;
+                ">
+                    I'm Safe Now
+                </button>
+                
+                <button id="call-988" style="
+                    background: #ff4466;
+                    color: white;
+                    border: none;
+                    padding: 12px 24px;
+                    font-size: 16px;
+                    font-weight: bold;
+                    border-radius: 4px;
+                    cursor: pointer;
+                    font-family: inherit;
+                ">
+                    Call 988 Now
+                </button>
+                
+                <p style="font-size: 14px; color: #888; margin-top: 30px;">
+                    If you're in immediate danger, call 911.
+                </p>
+            </div>
+        `;
+        
+        document.body.appendChild(overlay);
+        
+        // Add event listeners
+        const closeButton = document.getElementById('close-crisis-overlay');
+        if (closeButton) {
+            closeButton.addEventListener('click', () => {
+                this.hide988Overlay();
+            });
+        }
+        
+        const callButton = document.getElementById('call-988');
+        if (callButton) {
+            callButton.addEventListener('click', () => {
+                window.location.href = 'tel:988';
+            });
+        }
+        
+        // Log overlay shown
+        this.logToMetrics({
+            type: 'overlay_shown',
+            timestamp: Date.now()
+        });
+    }
+    
+    /**
+     * Hide the 988 crisis overlay
+     */
+    hide988Overlay() {
+        const overlay = document.getElementById('crisis-overlay');
+        if (overlay) {
+            overlay.remove();
+        }
+        
+        this.overlayVisible = false;
+        
+        // Log overlay hidden
+        this.logToMetrics({
+            type: 'overlay_hidden',
+            timestamp: Date.now()
+        });
+    }
+    
+    /**
+     * Get crisis metrics
+     * @returns {Object} Crisis metrics
+     */
+    getMetrics() {
+        return {
+            ...this.metrics,
+            overlayVisible: this.overlayVisible
+        };
+    }
+    
+    /**
+     * Reset crisis metrics
+     */
+    resetMetrics() {
+        this.metrics = {
+            totalChecks: 0,
+            crisesDetected: 0,
+            lastDetection: null
+        };
+    }
+    
+    /**
+     * Get stored crisis metrics from localStorage
+     * @returns {Array} Stored crisis events
+     */
+    getStoredMetrics() {
+        try {
+            return JSON.parse(localStorage.getItem('nexus-crisis-metrics') || '[]');
+        } catch (error) {
+            console.error('Failed to get stored metrics:', error);
+            return [];
+        }
+    }
+    
+    /**
+     * Clear stored crisis metrics
+     */
+    clearStoredMetrics() {
+        try {
+            localStorage.removeItem('nexus-crisis-metrics');
+        } catch (error) {
+            console.error('Failed to clear stored metrics:', error);
+        }
+    }
+}
+
+// Export for use in other modules
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = CrisisDetector;
+}
+
+// Global instance for browser use
+if (typeof window !== 'undefined') {
+    window.CrisisDetector = CrisisDetector;
+}

tests/test_crisis_detector.js

@@ -0,0 +1,208 @@
+/**
+ * Tests for Crisis Detection Module
+ * Issue #1543: feat: Nexus → the-door crisis bridge — detect distress in world chat
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ROOT = path.resolve(__dirname, '..');
+
+// Mock document
+const mockDocument = {
+    createElement: (tag) => {
+        const element = {
+            style: {},
+            innerHTML: '',
+            appendChild: () => {},
+            remove: () => {},
+            addEventListener: () => {}
+        };
+        return element;
+    },
+    body: {
+        appendChild: () => {}
+    },
+    getElementById: () => null
+};
+
+// Mock localStorage
+const mockLocalStorage = {
+    storage: {},
+    getItem: (key) => mockLocalStorage.storage[key] || null,
+    setItem: (key, value) => { mockLocalStorage.storage[key] = value; },
+    removeItem: (key) => { delete mockLocalStorage.storage[key]; }
+};
+
+// Load crisis-detector.js
+const crisisDetectorPath = path.join(ROOT, 'js', 'crisis-detector.js');
+const crisisDetectorCode = fs.readFileSync(crisisDetectorPath, 'utf8');
+
+// Create VM context
+const context = {
+    module: { exports: {} },
+    exports: {},
+    console,
+    document: mockDocument,
+    localStorage: mockLocalStorage,
+    window: { location: { href: '' } }
+};
+
+// Execute crisis-detector.js in context
+const vm = require('node:vm');
+vm.runInNewContext(crisisDetectorCode, context);
+
+// Get CrisisDetector class
+const CrisisDetector = context.window.CrisisDetector || context.CrisisDetector;
+
+test('CrisisDetector class loads correctly', () => {
+    assert.ok(CrisisDetector, 'CrisisDetector should be defined');
+    assert.ok(typeof CrisisDetector === 'function', 'CrisisDetector should be a constructor');
+});
+
+test('CrisisDetector can be instantiated', () => {
+    const detector = new CrisisDetector();
+    assert.ok(detector, 'CrisisDetector instance should be created');
+    assert.ok(detector.crisisKeywords, 'Should have crisisKeywords');
+    assert.ok(detector.crisisPatterns, 'Should have crisisPatterns');
+});
+
+test('CrisisDetector detects crisis keywords', () => {
+    const detector = new CrisisDetector();
+    
+    // Test various crisis messages
+    const crisisMessages = [
+        'I want to die',
+        'I\'m going to kill myself',
+        'I should just die',
+        'Nobody would miss me',
+        'I can\'t take it anymore',
+        'I\'m done with life',
+        'I hate my life',
+        'I wish I was dead',
+        'I\'m going to end it',
+        'I have nothing to live for'
+    ];
+    
+    for (const message of crisisMessages) {
+        const detected = detector.detectCrisis(message);
+        assert.ok(detected, `Should detect crisis in: "${message}"`);
+    }
+});
+
+test('CrisisDetector does not detect crisis in normal messages', () => {
+    const detector = new CrisisDetector();
+    
+    const normalMessages = [
+        'Hello, how are you?',
+        'I\'m doing great today',
+        'Let\'s work on this project',
+        'The weather is nice',
+        'I love coding',
+        'This is a test message'
+    ];
+    
+    for (const message of normalMessages) {
+        const detected = detector.detectCrisis(message);
+        assert.ok(!detected, `Should NOT detect crisis in: "${message}"`);
+    }
+});
+
+test('CrisisDetector handles empty messages', () => {
+    const detector = new CrisisDetector();
+    
+    assert.ok(!detector.detectCrisis(''), 'Should not detect crisis in empty string');
+    assert.ok(!detector.detectCrisis(null), 'Should not detect crisis in null');
+    assert.ok(!detector.detectCrisis(undefined), 'Should not detect crisis in undefined');
+});
+
+test('CrisisDetector tracks metrics', () => {
+    const detector = new CrisisDetector();
+    
+    // Check initial metrics
+    const initialMetrics = detector.getMetrics();
+    assert.equal(initialMetrics.totalChecks, 0, 'Should start with 0 checks');
+    assert.equal(initialMetrics.crisesDetected, 0, 'Should start with 0 crises');
+    
+    // Check some messages
+    detector.detectCrisis('Hello');
+    detector.detectCrisis('I want to die');
+    detector.detectCrisis('How are you?');
+    
+    const metrics = detector.getMetrics();
+    assert.equal(metrics.totalChecks, 3, 'Should have 3 checks');
+    assert.equal(metrics.crisesDetected, 1, 'Should have 1 crisis detected');
+    assert.ok(metrics.lastDetection, 'Should have lastDetection');
+    assert.equal(metrics.lastDetection.message, 'I want to die', 'Should store crisis message');
+});
+
+test('CrisisDetector can reset metrics', () => {
+    const detector = new CrisisDetector();
+    
+    // Check some messages
+    detector.detectCrisis('I want to die');
+    detector.detectCrisis('Hello');
+    
+    // Reset metrics
+    detector.resetMetrics();
+    
+    const metrics = detector.getMetrics();
+    assert.equal(metrics.totalChecks, 0, 'Should have 0 checks after reset');
+    assert.equal(metrics.crisesDetected, 0, 'Should have 0 crises after reset');
+    assert.equal(metrics.lastDetection, null, 'Should have no lastDetection after reset');
+});
+
+test('CrisisDetector logs to metrics', () => {
+    const detector = new CrisisDetector();
+    
+    // Clear any existing metrics
+    detector.clearStoredMetrics();
+    
+    // Detect crisis
+    detector.detectCrisis('I want to die');
+    
+    // Check stored metrics
+    const storedMetrics = detector.getStoredMetrics();
+    assert.ok(storedMetrics.length > 0, 'Should have stored metrics');
+    
+    // Find the crisis_detected event (not overlay_shown)
+    const crisisEvent = storedMetrics.find(event => event.type === 'crisis_detected');
+    assert.ok(crisisEvent, 'Should have crisis_detected event');
+    assert.equal(crisisEvent.message, 'I want to die', 'Should log message');
+});
+
+test('CrisisDetector has crisis handler', () => {
+    let handlerCalled = false;
+    let handlerMessage = null;
+    
+    const detector = new CrisisDetector({
+        onCrisisDetected: (message) => {
+            handlerCalled = true;
+            handlerMessage = message;
+        }
+    });
+    
+    detector.detectCrisis('I want to die');
+    
+    assert.ok(handlerCalled, 'Crisis handler should be called');
+    assert.equal(handlerMessage, 'I want to die', 'Handler should receive message');
+});
+
+test('CrisisDetector overlay visibility', () => {
+    const detector = new CrisisDetector();
+    
+    // Initially not visible
+    assert.ok(!detector.overlayVisible, 'Overlay should not be visible initially');
+    
+    // Show overlay
+    detector.show988Overlay();
+    assert.ok(detector.overlayVisible, 'Overlay should be visible after showing');
+    
+    // Hide overlay
+    detector.hide988Overlay();
+    assert.ok(!detector.overlayVisible, 'Overlay should not be visible after hiding');
+});
+
+console.log('All CrisisDetector tests passed!');