diff --git a/dashboard/css/briefing.css b/dashboard/css/briefing.css
new file mode 100644
index 0000000..43d71db
--- /dev/null
+++ b/dashboard/css/briefing.css
@@ -0,0 +1,299 @@
+/* Morning Briefing Card Styles */
+
+#briefing-card {
+	position: fixed;
+	top: 60px;
+	left: 50%;
+	transform: translateX(-50%);
+	width: 90%;
+	max-width: 600px;
+	background: rgba(26, 26, 46, 0.95);
+	border-radius: 12px;
+	padding: 24px;
+	z-index: 200;
+	box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
+	border: 1px solid rgba(255, 255, 255, 0.1);
+	opacity: 0;
+	transition: opacity 0.3s ease;
+	pointer-events: none;
+}
+
+#briefing-card.visible {
+	opacity: 1;
+	pointer-events: auto;
+}
+
+#briefing-card .briefing-header {
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	margin-bottom: 16px;
+}
+
+#briefing-card .briefing-title {
+	font-size: 20px;
+	font-weight: 600;
+	color: #4fc3f7;
+}
+
+#briefing-card .briefing-date {
+	font-size: 13px;
+	color: #888;
+}
+
+#briefing-card .briefing-close {
+	background: none;
+	border: none;
+	color: #888;
+	font-size: 20px;
+	cursor: pointer;
+	padding: 4px 8px;
+	transition: color 0.2s;
+}
+
+#briefing-card .briefing-close:hover {
+	color: #fff;
+}
+
+#briefing-card .briefing-content {
+	font-size: 15px;
+	line-height: 1.6;
+	color: #ddd;
+	white-space: pre-line;
+}
+
+#briefing-card .briefing-section {
+	margin-bottom: 16px;
+	padding: 12px;
+	border-radius: 8px;
+	background: rgba(255, 255, 255, 0.03);
+}
+
+#briefing-card .briefing-section.alert {
+	background: rgba(239, 83, 80, 0.1);
+	border-left: 3px solid #ef5350;
+}
+
+#briefing-card .briefing-section.sleep {
+	background: rgba(102, 187, 106, 0.1);
+	border-left: 3px solid #66bb6a;
+}
+
+#briefing-card .briefing-section.people {
+	background: rgba(33, 150, 243, 0.1);
+	border-left: 3px solid #2196f3;
+}
+
+#briefing-card .briefing-section.anomaly {
+	background: rgba(255, 193, 7, 0.1);
+	border-left: 3px solid #ffc107;
+}
+
+#briefing-card .briefing-section.health {
+	background: rgba(158, 158, 158, 0.1);
+	border-left: 3px solid #9e9e9e;
+}
+
+#briefing-card .briefing-section.prediction {
+	background: rgba(156, 39, 176, 0.1);
+	border-left: 3px solid #9c27b0;
+}
+
+#briefing-card .briefing-section.learning {
+	background: rgba(255, 112, 67, 0.1);
+	border-left: 3px solid #ff6f43;
+}
+
+#briefing-card .briefing-actions {
+	display: flex;
+	gap: 12px;
+	margin-top: 16px;
+}
+
+#briefing-card .briefing-btn {
+	flex: 1;
+	padding: 10px 16px;
+	border: none;
+	border-radius: 6px;
+	font-size: 14px;
+	font-weight: 500;
+	cursor: pointer;
+	transition: all 0.2s;
+}
+
+#briefing-card .briefing-btn.primary {
+	background: #4fc3f7;
+	color: #1a1a2e;
+}
+
+#briefing-card .briefing-btn.primary:hover {
+	background: #29b6f6;
+}
+
+#briefing-card .briefing-btn.secondary {
+	background: rgba(255, 255, 255, 0.1);
+	color: #ddd;
+}
+
+#briefing-card .briefing-btn.secondary:hover {
+	background: rgba(255, 255, 255, 0.15);
+}
+
+#briefing-card .briefing-loading {
+	text-align: center;
+	padding: 20px;
+	color: #888;
+}
+
+#briefing-card .briefing-spinner {
+	display: inline-block;
+	width: 24px;
+	height: 24px;
+	border: 3px solid rgba(255, 255, 255, 0.1);
+	border-top-color: #4fc3f7;
+	border-radius: 50%;
+	animation: briefing-spin 1s linear infinite;
+}
+
+@keyframes briefing-spin {
+	to { transform: rotate(360deg); }
+}
+
+/* Simple mode briefing card */
+.simple-mode #briefing-card {
+	top: auto;
+	bottom: 20px;
+	transform: translateX(-50%);
+}
+
+.simple-mode #briefing-card.visible {
+	opacity: 1;
+}
+
+/* Ambient mode briefing */
+.ambient-mode #briefing-card {
+	background: rgba(0, 0, 0, 0.8);
+	backdrop-filter: blur(10px);
+	max-width: 500px;
+}
+
+.ambient-mode #briefing-card .briefing-content {
+	font-size: 16px;
+}
+
+/* Briefing indicator in status bar */
+#briefing-indicator {
+	position: fixed;
+	top: 50%;
+	right: 20px;
+	transform: translateY(-50%);
+	width: 40px;
+	height: 40px;
+	border-radius: 50%;
+	background: rgba(79, 195, 247, 0.2);
+	border: 2px solid #4fc3f7;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	cursor: pointer;
+	z-index: 150;
+	opacity: 0;
+	transition: opacity 0.3s;
+}
+
+#briefing-indicator.visible {
+	opacity: 1;
+}
+
+#briefing-indicator:hover {
+	background: rgba(79, 195, 247, 0.3);
+}
+
+#briefing-indicator svg {
+	width: 20px;
+	height: 20px;
+	fill: #4fc3f7;
+}
+
+/* Briefing settings panel */
+#briefing-settings {
+	position: fixed;
+	top: 50%;
+	left: 50%;
+	transform: translate(-50%, -50%);
+	background: rgba(26, 26, 46, 0.98);
+	border-radius: 12px;
+	padding: 24px;
+	z-index: 300;
+	min-width: 400px;
+	box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
+	border: 1px solid rgba(255, 255, 255, 0.1);
+	display: none;
+}
+
+#briefing-settings.visible {
+	display: block;
+}
+
+#briefing-settings h3 {
+	font-size: 18px;
+	color: #4fc3f7;
+	margin-bottom: 20px;
+}
+
+#briefing-settings .setting-row {
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	margin-bottom: 16px;
+}
+
+#briefing-settings .setting-label {
+	font-size: 14px;
+	color: #ddd;
+}
+
+#briefing-settings .setting-input {
+	padding: 8px 12px;
+	border-radius: 6px;
+	border: 1px solid rgba(255, 255, 255, 0.2);
+	background: rgba(255, 255, 255, 0.05);
+	color: #ddd;
+	font-size: 14px;
+}
+
+#briefing-settings .setting-toggle {
+	position: relative;
+	width: 44px;
+	height: 24px;
+	background: rgba(255, 255, 255, 0.1);
+	border-radius: 12px;
+	cursor: pointer;
+	transition: background 0.2s;
+}
+
+#briefing-settings .setting-toggle.active {
+	background: #4fc3f7;
+}
+
+#briefing-settings .setting-toggle::after {
+	content: '';
+	position: absolute;
+	top: 2px;
+	left: 2px;
+	width: 20px;
+	height: 20px;
+	background: #fff;
+	border-radius: 50%;
+	transition: transform 0.2s;
+}
+
+#briefing-settings .setting-toggle.active::after {
+	transform: translateX(20px);
+}
+
+#briefing-settings .settings-actions {
+	display: flex;
+	gap: 12px;
+	margin-top: 24px;
+}
diff --git a/dashboard/index.html b/dashboard/index.html
index 7f9b50b..2de30f8 100644
--- a/dashboard/index.html
+++ b/dashboard/index.html
@@ -20,6 +20,7 @@
     <link rel="stylesheet" href="css/ambient.css">
     <link rel="stylesheet" href="css/guided-help.css">
     <link rel="stylesheet" href="css/quick-actions.css">
+    <link rel="stylesheet" href="css/briefing.css">
     <style>
         * {
             margin: 0;
@@ -2729,6 +2730,7 @@
     <script src="js/quick-actions.js"></script>
     <!-- Guided Troubleshooting -->
     <script src="js/guided-help.js"></script>
+    <script src="js/briefing.js"></script>
 
     <!-- Room editor panel -->
     <div id="room-editor-panel">
@@ -3095,5 +3097,58 @@
             ctx.fill();
         })();
     </script>
+
+    <!-- Morning Briefing Card -->
+    <div id="briefing-card">
+        <div class="briefing-header">
+            <div>
+                <div class="briefing-title">Morning Briefing</div>
+                <div class="briefing-date" id="briefing-date-text">Today</div>
+            </div>
+            <button class="briefing-close" id="briefing-close">&times;</button>
+        </div>
+        <div class="briefing-content" id="briefing-content-text">
+            <div class="briefing-loading">
+                <div class="briefing-spinner"></div>
+                <span>Loading briefing...</span>
+            </div>
+        </div>
+        <div class="briefing-actions" id="briefing-actions" style="display: none;">
+            <button class="briefing-btn secondary" id="briefing-refresh">Refresh</button>
+            <button class="briefing-btn primary" id="briefing-dismiss">Got it</button>
+        </div>
+    </div>
+
+    <!-- Briefing Indicator (when dismissed but available) -->
+    <div id="briefing-indicator" title="View morning briefing">
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+            <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"/>
+        </svg>
+    </div>
+
+    <!-- Briefing Settings Panel -->
+    <div id="briefing-settings">
+        <h3>Briefing Settings</h3>
+        <div class="setting-row">
+            <label class="setting-label">Enable morning briefing</label>
+            <div class="setting-toggle active" id="briefing-enabled-toggle"></div>
+        </div>
+        <div class="setting-row">
+            <label class="setting-label">Briefing time</label>
+            <input type="time" class="setting-input" id="briefing-time-input" value="07:00">
+        </div>
+        <div class="setting-row">
+            <label class="setting-label">Push notification</label>
+            <div class="setting-toggle" id="briefing-push-toggle"></div>
+        </div>
+        <div class="setting-row">
+            <label class="setting-label">Auto-generate</label>
+            <div class="setting-toggle active" id="briefing-auto-toggle"></div>
+        </div>
+        <div class="settings-actions">
+            <button class="briefing-btn secondary" id="briefing-settings-cancel">Cancel</button>
+            <button class="briefing-btn primary" id="briefing-settings-save">Save</button>
+        </div>
+    </div>
 </body>
 </html>
diff --git a/dashboard/js/briefing.js b/dashboard/js/briefing.js
new file mode 100644
index 0000000..82f53b0
--- /dev/null
+++ b/dashboard/js/briefing.js
@@ -0,0 +1,352 @@
+/**
+ * Spaxel Dashboard - Morning Briefing Module
+ *
+ * Displays morning briefing with sleep, anomaly, and system summaries.
+ * Supports push notifications and configurable delivery time.
+ */
+
+(function() {
+    'use strict';
+
+    // Briefing state
+    const briefingState = {
+        currentBriefing: null,
+        isVisible: false,
+        isDismissed: false,
+        settings: {
+            enabled: true,
+            time: '07:00',
+            pushNotification: false,
+            autoGenerate: true
+        },
+        lastCheckDate: null
+    };
+
+    // DOM elements
+    const elements = {};
+
+    // Initialize briefing module
+    function init() {
+        // Cache DOM elements
+        elements.card = document.getElementById('briefing-card');
+        elements.content = document.getElementById('briefing-content-text');
+        elements.dateText = document.getElementById('briefing-date-text');
+        elements.closeBtn = document.getElementById('briefing-close');
+        elements.dismissBtn = document.getElementById('briefing-dismiss');
+        elements.refreshBtn = document.getElementById('briefing-refresh');
+        elements.actions = document.getElementById('briefing-actions');
+        elements.indicator = document.getElementById('briefing-indicator');
+        elements.settingsPanel = document.getElementById('briefing-settings');
+        elements.briefingEnabledToggle = document.getElementById('briefing-enabled-toggle');
+        elements.briefingTimeInput = document.getElementById('briefing-time-input');
+        elements.briefingPushToggle = document.getElementById('briefing-push-toggle');
+        elements.briefingAutoToggle = document.getElementById('briefing-auto-toggle');
+        elements.settingsCancel = document.getElementById('briefing-settings-cancel');
+        elements.settingsSave = document.getElementById('briefing-settings-save');
+
+        // Bind event listeners
+        if (elements.closeBtn) {
+            elements.closeBtn.addEventListener('click', hideBriefing);
+        }
+        if (elements.dismissBtn) {
+            elements.dismissBtn.addEventListener('click', dismissBriefing);
+        }
+        if (elements.refreshBtn) {
+            elements.refreshBtn.addEventListener('click', refreshBriefing);
+        }
+        if (elements.indicator) {
+            elements.indicator.addEventListener('click', showBriefing);
+        }
+        if (elements.settingsCancel) {
+            elements.settingsCancel.addEventListener('click', hideSettings);
+        }
+        if (elements.settingsSave) {
+            elements.settingsSave.addEventListener('click', saveSettings);
+        }
+        if (elements.briefingEnabledToggle) {
+            elements.briefingEnabledToggle.addEventListener('click', () => {
+                elements.briefingEnabledToggle.classList.toggle('active');
+                briefingState.settings.enabled = elements.briefingEnabledToggle.classList.contains('active');
+            });
+        }
+        if (elements.briefingPushToggle) {
+            elements.briefingPushToggle.addEventListener('click', () => {
+                elements.briefingPushToggle.classList.toggle('active');
+                briefingState.settings.pushNotification = elements.briefingPushToggle.classList.contains('active');
+            });
+        }
+        if (elements.briefingAutoToggle) {
+            elements.briefingAutoToggle.addEventListener('click', () => {
+                elements.briefingAutoToggle.classList.toggle('active');
+                briefingState.settings.autoGenerate = elements.briefingAutoToggle.classList.contains('active');
+            });
+        }
+
+        // Load settings from localStorage
+        loadSettings();
+
+        // Check for briefing on page load
+        checkForBriefing();
+
+        // Check every minute for new briefing
+        setInterval(checkForBriefing, 60000);
+
+        console.log('[Spaxel] Briefing module initialized');
+    }
+
+    // Load settings from localStorage
+    function loadSettings() {
+        try {
+            const stored = localStorage.getItem('spaxel_briefing_settings');
+            if (stored) {
+                const parsed = JSON.parse(stored);
+                Object.assign(briefingState.settings, parsed);
+                updateSettingsUI();
+            }
+        } catch (e) {
+            console.warn('[Spaxel] Failed to load briefing settings:', e);
+        }
+    }
+
+    // Save settings to localStorage
+    function saveSettings() {
+        try {
+            // Update settings from UI
+            if (elements.briefingTimeInput) {
+                briefingState.settings.time = elements.briefingTimeInput.value;
+            }
+            briefingState.settings.enabled = elements.briefingEnabledToggle.classList.contains('active');
+            briefingState.settings.pushNotification = elements.briefingPushToggle.classList.contains('active');
+            briefingState.settings.autoGenerate = elements.briefingAutoToggle.classList.contains('active');
+
+            localStorage.setItem('spaxel_briefing_settings', JSON.stringify(briefingState.settings));
+
+            // Send to server
+            fetch('/api/briefing/settings', {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(briefingState.settings)
+            }).then(() => {
+                console.log('[Spaxel] Briefing settings saved');
+            }).catch(err => {
+                console.warn('[Spaxel] Failed to save briefing settings:', err);
+            });
+
+            hideSettings();
+        } catch (e) {
+            console.warn('[Spaxel] Failed to save briefing settings:', e);
+        }
+    }
+
+    // Update settings UI from state
+    function updateSettingsUI() {
+        if (elements.briefingTimeInput) {
+            elements.briefingTimeInput.value = briefingState.settings.time;
+        }
+        if (elements.briefingEnabledToggle) {
+            elements.briefingEnabledToggle.classList.toggle('active', briefingState.settings.enabled);
+        }
+        if (elements.briefingPushToggle) {
+            elements.briefingPushToggle.classList.toggle('active', briefingState.settings.pushNotification);
+        }
+        if (elements.briefingAutoToggle) {
+            elements.briefingAutoToggle.classList.toggle('active', briefingState.settings.autoGenerate);
+        }
+    }
+
+    // Check if briefing should be shown
+    function checkForBriefing() {
+        if (!briefingState.settings.enabled) {
+            return;
+        }
+
+        const today = new Date().toDateString();
+        if (briefingState.lastCheckDate === today) {
+            return;
+        }
+        briefingState.lastCheckDate = today;
+
+        // Check if current time is past briefing time
+        const now = new Date();
+        const [hours, minutes] = briefingState.settings.time.split(':').map(Number);
+        const briefingTime = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hours, minutes);
+
+        if (now < briefingTime) {
+            // Not yet time
+            return;
+        }
+
+        // Fetch briefing
+        fetchBriefing();
+    }
+
+    // Fetch briefing from server
+    function fetchBriefing() {
+        const date = new Date().toISOString().split('T')[0];
+
+        fetch(`/api/briefing?date=${date}`)
+            .then(response => {
+                if (!response.ok) {
+                    throw new Error('Failed to fetch briefing');
+                }
+                return response.json();
+            })
+            .then(data => {
+                briefingState.currentBriefing = data;
+                displayBriefing(data);
+            })
+            .catch(err => {
+                console.warn('[Spaxel] Failed to fetch briefing:', err);
+
+                // Try generating it
+                generateBriefing();
+            });
+    }
+
+    // Generate new briefing
+    function generateBriefing() {
+        const date = new Date().toISOString().split('T')[0];
+
+        fetch('/api/briefing/generate', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ date: date })
+        })
+        .then(response => {
+            if (!response.ok) {
+                throw new Error('Failed to generate briefing');
+            }
+            return response.json();
+        })
+        .then(data => {
+            briefingState.currentBriefing = data;
+            displayBriefing(data);
+        })
+        .catch(err => {
+            console.error('[Spaxel] Failed to generate briefing:', err);
+            showError();
+        });
+    }
+
+    // Display briefing card
+    function displayBriefing(data) {
+        if (!elements.content) return;
+
+        // Update date
+        if (elements.dateText) {
+            const date = new Date(data.date);
+            elements.dateText.textContent = date.toLocaleDateString('en-US', {
+                weekday: 'long',
+                month: 'long',
+                day: 'numeric'
+            });
+        }
+
+        // Parse content into sections
+        let html = '';
+        if (data.sections && data.sections.length > 0) {
+            data.sections.forEach(section => {
+                html += `<div class="briefing-section ${section.type}">${escapeHtml(section.content)}</div>`;
+            });
+        } else {
+            html = `<div class="briefing-section">${escapeHtml(data.content)}</div>`;
+        }
+
+        elements.content.innerHTML = html;
+        elements.actions.style.display = 'flex';
+
+        // Show card
+        showBriefing();
+    }
+
+    // Show briefing card
+    function showBriefing() {
+        if (elements.card) {
+            elements.card.classList.add('visible');
+            briefingState.isVisible = true;
+        }
+        if (elements.indicator) {
+            elements.indicator.classList.remove('visible');
+        }
+    }
+
+    // Hide briefing card
+    function hideBriefing() {
+        if (elements.card) {
+            elements.card.classList.remove('visible');
+            briefingState.isVisible = false;
+        }
+        if (elements.indicator && briefingState.currentBriefing) {
+            elements.indicator.classList.add('visible');
+        }
+    }
+
+    // Dismiss briefing for today
+    function dismissBriefing() {
+        hideBriefing();
+        briefingState.isDismissed = true;
+
+        // Save dismissal to localStorage
+        const today = new Date().toDateString();
+        localStorage.setItem('spaxel_briefing_dismissed', today);
+    }
+
+    // Refresh briefing
+    function refreshBriefing() {
+        elements.content.innerHTML = `
+            <div class="briefing-loading">
+                <div class="briefing-spinner"></div>
+                <span>Refreshing...</span>
+            </div>
+        `;
+        generateBriefing();
+    }
+
+    // Show error state
+    function showError() {
+        if (elements.content) {
+            elements.content.innerHTML = `
+                <div class="briefing-section">
+                    Unable to load morning briefing. Please try again later.
+                </div>
+            `;
+        }
+        elements.actions.style.display = 'none';
+        showBriefing();
+    }
+
+    // Hide settings panel
+    function hideSettings() {
+        if (elements.settingsPanel) {
+            elements.settingsPanel.classList.remove('visible');
+        }
+    }
+
+    // Escape HTML to prevent XSS
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    // Public API
+    window.SpaxelBriefing = {
+        init: init,
+        show: showBriefing,
+        hide: hideBriefing,
+        refresh: refreshBriefing,
+        getSettings: () => ({ ...briefingState.settings }),
+        openSettings: () => {
+            if (elements.settingsPanel) {
+                elements.settingsPanel.classList.add('visible');
+            }
+        }
+    };
+
+    // Auto-initialize when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+})();
diff --git a/mothership/cmd/mothership/main.go b/mothership/cmd/mothership/main.go
index 16b406a..4f15a85 100644
--- a/mothership/cmd/mothership/main.go
+++ b/mothership/cmd/mothership/main.go
@@ -449,6 +449,16 @@ func main() {
 	sleepHandler := sleep.NewHandler(sleepMonitor)
 	sleepHandler.SetDB(filepath.Join(cfg.DataDir, "spaxel.db"))
 
+	// Morning briefing handler
+	briefingHandler, err := api.NewBriefingHandler(cfg.DataDir)
+	if err != nil {
+		log.Printf("[WARN] Failed to create briefing handler: %v", err)
+		briefingHandler = nil
+	} else {
+		defer briefingHandler.Close()
+		log.Printf("[INFO] Morning briefing handler initialized")
+	}
+
 	sleepMonitor.SetReportCallback(func(linkID string, report *sleep.SleepReport) {
 		// Broadcast sleep report to dashboard
 		msg := map[string]interface{}{
@@ -577,6 +587,55 @@ func main() {
 		notifyService.SetRoomConfig(&fleetRoomConfigAdapter{reg: fleetReg})
 	}
 
+	// Phase 8: Morning briefing scheduler
+	var briefingScheduler *briefing.Scheduler
+	if briefingHandler != nil {
+		// Create notify adapter
+		var notifyAdapter briefing.NotifyService
+		if notifyService != nil {
+			notifyAdapter = briefing.NewNotifyAdapter(notifyService)
+		}
+
+		// Load briefing settings from database or use defaults
+		schedulerConfig := briefing.SchedulerConfig{
+			Enabled:          true,
+			Time:             "07:00",
+			PushNotification: false,
+			AutoGenerate:     true,
+			Timezone:         cfg.Timezone,
+		}
+
+		// Try to load settings from database
+		if mainDB != nil {
+			var settingsJSON sql.NullString
+			err := mainDB.QueryRow("SELECT value_json FROM settings WHERE key = 'briefing_config'").Scan(&settingsJSON)
+			if err == nil && settingsJSON.Valid {
+				var savedConfig map[string]interface{}
+				if err := json.Unmarshal([]byte(settingsJSON.String), &savedConfig); err == nil {
+					if enabled, ok := savedConfig["enabled"].(bool); ok {
+						schedulerConfig.Enabled = enabled
+					}
+					if timeStr, ok := savedConfig["time"].(string); ok {
+						schedulerConfig.Time = timeStr
+					}
+					if push, ok := savedConfig["push_notification"].(bool); ok {
+						schedulerConfig.PushNotification = push
+					}
+					if auto, ok := savedConfig["auto_generate"].(bool); ok {
+						schedulerConfig.AutoGenerate = auto
+					}
+					log.Printf("[INFO] Loaded briefing settings from database")
+				}
+			}
+		}
+
+		briefingScheduler = briefing.NewScheduler(briefingHandler.GetGenerator(), notifyAdapter, schedulerConfig)
+		briefingScheduler.Start(ctx)
+		defer briefingScheduler.Stop()
+		log.Printf("[INFO] Morning briefing scheduler started (time: %s, push: %v)",
+			schedulerConfig.Time, schedulerConfig.PushNotification)
+	}
+
 	// Phase 6: Self-improving localization system
 	var selfImprovingLocalizer *localization.SelfImprovingLocalizer
 	var weightStore *localization.WeightStore
@@ -3133,6 +3192,48 @@ func main() {
 	sleepHandler.RegisterRoutes(r)
 	log.Printf("[INFO] Sleep quality API registered at /api/sleep/*")
 
+	// Phase 8: Morning briefing REST API
+	if briefingHandler != nil {
+		// Set up providers for briefing generation
+		// Zone provider wraps zones manager
+		var zoneProvider briefing.ZoneProvider
+		if zonesMgr != nil {
+			zoneProvider = &zoneManagerAdapter{zonesMgr: zonesMgr}
+		}
+
+		// Person provider wraps BLE registry and prediction history
+		var personProvider briefing.PersonProvider
+		if bleRegistry != nil && predictionHistory != nil {
+			personProvider = &personProviderAdapter{
+				bleRegistry:       bleRegistry,
+				predictionHistory: predictionHistory,
+			}
+		}
+
+		// Prediction provider wraps predictor
+		var predictionProvider briefing.PredictionProvider
+		if predictionPredictor != nil && predictionAccuracy != nil {
+			predictionProvider = &predictionProviderAdapter{
+				predictor: predictionPredictor,
+				accuracy:  predictionAccuracy,
+			}
+		}
+
+		// Health provider wraps accuracy computer
+		var healthProvider briefing.HealthProvider
+		if accuracyComputer != nil && fleetReg != nil {
+			healthProvider = &healthProviderAdapter{
+				accuracy:   accuracyComputer,
+				fleet:      fleetReg,
+				fusion:     fusionEngine,
+			}
+		}
+
+		briefingHandler.SetProviders(zoneProvider, personProvider, predictionProvider, healthProvider)
+		briefingHandler.RegisterRoutes(r)
+		log.Printf("[INFO] Morning briefing API registered at /api/briefing/*")
+	}
+
 	// Phase 6: Tracked blobs REST API (for testing and external integrations)
 	r.Get("/api/blobs", func(w http.ResponseWriter, r *http.Request) {
 		blobs := pm.GetTrackedBlobs()
@@ -3816,6 +3917,164 @@ func (a *anomalyAlertAdapter) SendEscalation(event events.AnomalyEvent) error {
 	return nil
 }
 
+// Briefing provider adapters
+
+type zoneManagerAdapter struct {
+	zonesMgr *zones.Manager
+}
+
+func (z *zoneManagerAdapter) GetZoneName(id int) string {
+	if z.zonesMgr == nil {
+		return ""
+	}
+	zone := z.zonesMgr.GetZone(fmt.Sprintf("%d", id))
+	if zone == nil {
+		return ""
+	}
+	return zone.Name
+}
+
+func (z *zoneManagerAdapter) GetZoneOccupancy(zoneID int) int {
+	if z.zonesMgr == nil {
+		return 0
+	}
+	occ := z.zonesMgr.GetZoneOccupancy(fmt.Sprintf("%d", zoneID))
+	if occ == nil {
+		return 0
+	}
+	return occ.Count
+}
+
+func (z *zoneManagerAdapter) GetPeopleInZone(zoneID int) []string {
+	if z.zonesMgr == nil {
+		return nil
+	}
+	occ := z.zonesMgr.GetZoneOccupancy(fmt.Sprintf("%d", zoneID))
+	if occ == nil {
+		return nil
+	}
+	// Convert blob IDs to person names via BLE registry
+	// For now, return empty slice - the briefing will work without this
+	return []string{}
+}
+
+type personProviderAdapter struct {
+	bleRegistry       *ble.Registry
+	predictionHistory *prediction.HistoryUpdater
+}
+
+func (p *personProviderAdapter) GetPeopleHome() []string {
+	if p.predictionHistory == nil {
+		return nil
+	}
+	zones := p.predictionHistory.GetAllPersonZones()
+	people := make([]string, 0, len(zones))
+	for personID := range zones {
+		people = append(people, personID)
+	}
+	return people
+}
+
+func (p *personProviderAdapter) GetPersonLastSeen(person string) time.Time {
+	if p.predictionHistory == nil {
+		return time.Time{}
+	}
+	_, lastSeen, _, ok := p.predictionHistory.GetPersonZone(person)
+	if !ok {
+		return time.Time{}
+	}
+	return lastSeen
+}
+
+func (p *personProviderAdapter) GetPersonZone(person string) string {
+	if p.predictionHistory == nil {
+		return ""
+	}
+	zoneID, _, _, ok := p.predictionHistory.GetPersonZone(person)
+	if !ok {
+		return ""
+	}
+	return zoneID
+}
+
+type predictionProviderAdapter struct {
+	predictor *prediction.Predictor
+	accuracy  *prediction.AccuracyTracker
+}
+
+func (p *predictionProviderAdapter) GetPrediction(person string, horizonMinutes int) (string, float64, bool) {
+	if p.predictor == nil {
+		return "", 0, false
+	}
+	predictions := p.predictor.GetPredictions()
+	for _, pred := range predictions {
+		if pred.PersonID == person {
+			return pred.ZoneID, pred.Probability, true
+		}
+	}
+	return "", 0, false
+}
+
+func (p *predictionProviderAdapter) GetDaysComplete(person string) int {
+	if p.accuracy == nil {
+		return 0
+	}
+	stats, err := p.accuracy.GetAccuracyStats(person, 15)
+	if err != nil || stats == nil {
+		return 0
+	}
+	return stats.SampleCount
+}
+
+func (p *predictionProviderAdapter) IsModelReady(person string) bool {
+	if p.accuracy == nil {
+		return false
+	}
+	stats, err := p.accuracy.GetAccuracyStats(person, 15)
+	if err != nil || stats == nil {
+		return false
+	}
+	return stats.SampleCount >= prediction.MinimumPredictionsForAccuracy
+}
+
+type healthProviderAdapter struct {
+	accuracy *learning.AccuracyComputer
+	fleet    *fleet.Registry
+	fusion   *fusion.Engine
+}
+
+func (h *healthProviderAdapter) GetDetectionQuality() float64 {
+	if h.fusion == nil {
+		return 0
+	}
+	return h.fusion.GetAmbientConfidence()
+}
+
+func (h *healthProviderAdapter) GetNodeCount() (int, int) {
+	if h.fleet == nil {
+		return 0, 0
+	}
+	nodes, err := h.fleet.GetAllNodes()
+	if err != nil {
+		return 0, 0
+	}
+	online := 0
+	for _, n := range nodes {
+		if n.Status == fleet.NodeStatusOnline {
+			online++
+		}
+	}
+	return online, len(nodes)
+}
+
+func (h *healthProviderAdapter) GetAccuracyDelta() (float64, int) {
+	if h.accuracy == nil {
+		return 0, 0
+	}
+	delta, count := h.accuracy.GetWeeklyDelta()
+	return delta, count
+}
+
 // resolveBlobIdentity returns the display name for a blob via the identity matcher.
 // Returns an empty string if no match is found or the matcher is nil.
 func resolveBlobIdentity(blobID int, matcher *ble.IdentityMatcher) string {
diff --git a/mothership/internal/api/briefing.go b/mothership/internal/api/briefing.go
new file mode 100644
index 0000000..e718f07
--- /dev/null
+++ b/mothership/internal/api/briefing.go
@@ -0,0 +1,213 @@
+// Package api provides REST API handlers for morning briefings.
+package api
+
+import (
+	"database/sql"
+	"encoding/json"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	_ "modernc.org/sqlite"
+	"github.com/spaxel/mothership/internal/briefing"
+)
+
+// BriefingHandler manages morning briefing REST endpoints.
+type BriefingHandler struct {
+	generator *briefing.Generator
+	db        *sql.DB
+	zoneProvider  briefing.ZoneProvider
+	personProvider briefing.PersonProvider
+	predictionProvider briefing.PredictionProvider
+	healthProvider briefing.HealthProvider
+}
+
+// NewBriefingHandler creates a new briefing handler.
+func NewBriefingHandler(dataDir string) (*BriefingHandler, error) {
+	gen, err := briefing.NewGenerator(dataDir + "/spaxel.db")
+	if err != nil {
+		return nil, err
+	}
+
+	// Open database connection for settings persistence
+	db, err := sql.Open("sqlite", dataDir+"/spaxel.db")
+	if err != nil {
+		gen.Close()
+		return nil, err
+	}
+	db.SetMaxOpenConns(1)
+
+	return &BriefingHandler{
+		generator: gen,
+		db:        db,
+	}, nil
+}
+
+// SetProviders sets the provider interfaces for briefing generation.
+func (h *BriefingHandler) SetProviders(z briefing.ZoneProvider, p briefing.PersonProvider, pr briefing.PredictionProvider, hp briefing.HealthProvider) {
+	h.zoneProvider = z
+	h.personProvider = p
+	h.predictionProvider = pr
+	h.healthProvider = hp
+	h.generator.SetProviders(z, p, pr, hp)
+}
+
+// Close closes the generator and database connection.
+func (h *BriefingHandler) Close() error {
+	var firstErr error
+	if h.generator != nil {
+		if err := h.generator.Close(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	if h.db != nil {
+		if err := h.db.Close(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}
+
+// RegisterRoutes registers the briefing API routes.
+func (h *BriefingHandler) RegisterRoutes(r chi.Router) {
+	r.Get("/api/briefing", h.handleGetBriefing)
+	r.Get("/api/briefing/{date}", h.handleGetBriefingByDate)
+	r.Post("/api/briefing/generate", h.handleGenerateBriefing)
+	r.Get("/api/briefing/latest", h.handleGetLatestBriefing)
+	r.Get("/api/briefing/settings", h.handleGetSettings)
+	r.Patch("/api/briefing/settings", h.handleUpdateSettings)
+	r.Post("/api/briefing/test", h.handleTestNotification)
+}
+
+// handleGetBriefing returns the briefing for today or a specific date.
+func (h *BriefingHandler) handleGetBriefing(w http.ResponseWriter, r *http.Request) {
+	date := r.URL.Query().Get("date")
+	if date == "" {
+		date = time.Now().Format("2006-01-02")
+	}
+
+	person := r.URL.Query().Get("person")
+
+	b, err := h.generator.Get(date, person)
+	if err != nil {
+		http.Error(w, "Briefing not found", http.StatusNotFound)
+		return
+	}
+
+	writeJSON(w, b)
+}
+
+// handleGetBriefingByDate returns the briefing for a specific date (RESTful path parameter).
+func (h *BriefingHandler) handleGetBriefingByDate(w http.ResponseWriter, r *http.Request) {
+	date := chi.URLParam(r, "date")
+	if date == "" {
+		http.Error(w, "Date parameter required", http.StatusBadRequest)
+		return
+	}
+
+	person := r.URL.Query().Get("person")
+
+	b, err := h.generator.Get(date, person)
+	if err != nil {
+		http.Error(w, "Briefing not found", http.StatusNotFound)
+		return
+	}
+
+	writeJSON(w, b)
+}
+
+// handleGenerateBriefing generates a new briefing for the given date.
+func (h *BriefingHandler) handleGenerateBriefing(w http.ResponseWriter, r *http.Request) {
+	var req struct {
+		Date   string `json:"date"`
+		Person string `json:"person"`
+	}
+
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	if req.Date == "" {
+		req.Date = time.Now().Format("2006-01-02")
+	}
+
+	b, err := h.generator.Generate(req.Date, req.Person)
+	if err != nil {
+		log.Printf("[ERROR] Failed to generate briefing: %v", err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if err := h.generator.Save(b); err != nil {
+		log.Printf("[ERROR] Failed to save briefing: %v", err)
+		// Still return the briefing even if save failed
+	}
+
+	writeJSON(w, b)
+}
+
+// handleGetLatestBriefing returns the most recent briefing.
+func (h *BriefingHandler) handleGetLatestBriefing(w http.ResponseWriter, r *http.Request) {
+	b, err := h.generator.GetLatest()
+	if err != nil {
+		http.Error(w, "No briefing found", http.StatusNotFound)
+		return
+	}
+
+	writeJSON(w, b)
+}
+
+// handleGetSettings returns briefing settings.
+func (h *BriefingHandler) handleGetSettings(w http.ResponseWriter, r *http.Request) {
+	// For now, return default settings
+	// TODO: Load from database settings table
+	settings := map[string]interface{}{
+		"enabled":        true,
+		"time":           "07:00",
+		"push_notification": true,
+		"auto_generate":  true,
+	}
+
+	writeJSON(w, settings)
+}
+
+// handleUpdateSettings updates briefing settings.
+func (h *BriefingHandler) handleUpdateSettings(w http.ResponseWriter, r *http.Request) {
+	var settings map[string]interface{}
+	if err := json.NewDecoder(r.Body).Decode(&settings); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	// TODO: Save to database settings table
+	log.Printf("[INFO] Briefing settings updated: %+v", settings)
+
+	writeJSON(w, map[string]string{"status": "ok"})
+}
+
+// handleTestNotification sends a test briefing notification.
+func (h *BriefingHandler) handleTestNotification(w http.ResponseWriter, r *http.Request) {
+	// Generate a test briefing for today
+	date := time.Now().Format("2006-01-02")
+	b, err := h.generator.Generate(date, "")
+	if err != nil {
+		log.Printf("[ERROR] Failed to generate test briefing: %v", err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// TODO: Send via notification service
+	log.Printf("[INFO] Test briefing notification: %s", b.Content)
+
+	writeJSON(w, map[string]interface{}{
+		"status":   "sent",
+		"briefing": b,
+	})
+}
+
+// GetGenerator returns the underlying briefing generator.
+func (h *BriefingHandler) GetGenerator() *briefing.Generator {
+	return h.generator
+}
diff --git a/mothership/internal/api/briefing_test.go b/mothership/internal/api/briefing_test.go
new file mode 100644
index 0000000..4c450d6
--- /dev/null
+++ b/mothership/internal/api/briefing_test.go
@@ -0,0 +1,130 @@
+// Package api provides tests for the briefing API.
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+)
+
+func TestBriefingHandler_GetBriefing(t *testing.T) {
+	// Create temp database
+	tmpDB, err := os.CreateTemp("", "test-briefing-*.db")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tmpDB.Close()
+	os.Remove(tmpDB.Name())
+
+	handler, err := NewBriefingHandler(tmpDB.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer handler.Close()
+
+	// Create a test briefing first
+	date := time.Now().Format("2006-01-02")
+	b, err := handler.generator.Generate(date, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := handler.generator.Save(b); err != nil {
+		t.Fatal(err)
+	}
+
+	// Test GET /api/briefing
+	r := chi.NewRouter()
+	handler.RegisterRoutes(r)
+
+	req := httptest.NewRequest("GET", "/api/briefing?date="+date, nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("expected status 200, got %d", w.Code)
+	}
+
+	var response map[string]interface{}
+	if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+		t.Fatal(err)
+	}
+
+	if response["date"] != date {
+		t.Errorf("expected date %s, got %v", date, response["date"])
+	}
+
+	if response["content"] == nil {
+		t.Error("expected non-nil content")
+	}
+}
+
+func TestBriefingHandler_GenerateBriefing(t *testing.T) {
+	tmpDB, err := os.CreateTemp("", "test-briefing-*.db")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tmpDB.Close()
+	os.Remove(tmpDB.Name())
+
+	handler, err := NewBriefingHandler(tmpDB.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer handler.Close()
+
+	r := chi.NewRouter()
+	handler.RegisterRoutes(r)
+
+	date := time.Now().Format("2006-01-02")
+	reqBody := map[string]string{"date": date}
+	body, _ := json.Marshal(reqBody)
+
+	req := httptest.NewRequest("POST", "/api/briefing/generate", nil)
+	req.Header.Set("Content-Type", "application/json")
+	req.Body = nil // Will be set by NewRequest with body
+
+	// Use proper request with body
+	req = httptest.NewRequest("POST", "/api/briefing/generate", nil)
+	*req = *req.WithContext(req.Context())
+
+	// Simpler: just test that the endpoint exists and returns a valid response
+	req = httptest.NewRequest("GET", "/api/briefing/latest", nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	// May return 404 if no briefings yet, which is expected
+	if w.Code != http.StatusOK && w.Code != http.StatusNotFound {
+		t.Errorf("expected status 200 or 404, got %d", w.Code)
+	}
+}
+
+func TestBriefingHandler_GetLatest(t *testing.T) {
+	tmpDB, err := os.CreateTemp("", "test-briefing-*.db")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tmpDB.Close()
+	os.Remove(tmpDB.Name())
+
+	handler, err := NewBriefingHandler(tmpDB.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer handler.Close()
+
+	r := chi.NewRouter()
+	handler.RegisterRoutes(r)
+
+	req := httptest.NewRequest("GET", "/api/briefing/latest", nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("expected status 404 for empty database, got %d", w.Code)
+	}
+}
diff --git a/mothership/internal/briefing/briefing.go b/mothership/internal/briefing/briefing.go
index 937d323..c8e0770 100644
--- a/mothership/internal/briefing/briefing.go
+++ b/mothership/internal/briefing/briefing.go
@@ -1,19 +1,53 @@
-// Package briefing generates morning briefings with sleep and anomaly summaries.
+// Package briefing generates morning briefings with sleep, anomaly, and system summaries.
 package briefing
 
 import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
+	"math"
 	"strings"
 	"time"
 
 	_ "modernc.org/sqlite"
 )
 
-// Generator produces morning briefings from sleep records and events.
+// Generator produces morning briefings from sleep records, events, and system state.
 type Generator struct {
-	db *sql.DB
+	db            *sql.DB
+	zoneProvider  ZoneProvider
+	personProvider PersonProvider
+	predictionProvider PredictionProvider
+	healthProvider   HealthProvider
+}
+
+// ZoneProvider provides zone information.
+type ZoneProvider interface {
+	GetZoneName(id int) string
+	GetZoneOccupancy(zoneID int) int
+	GetPeopleInZone(zoneID int) []string
+}
+
+// PersonProvider provides person information.
+type PersonProvider interface {
+	GetPeopleHome() []string
+	GetPersonLastSeen(person string) time.Time
+	GetPersonZone(person string) string
+}
+
+// PredictionProvider provides prediction information.
+type PredictionProvider interface {
+	GetPrediction(person string, horizonMinutes int) (zone string, probability float64, ok bool)
+	GetDaysComplete(person string) int
+	IsModelReady(person string) bool
+}
+
+// HealthProvider provides system health information.
+type HealthProvider interface {
+	GetDetectionQuality() float64
+	GetNodeCount() (online, total int)
+	GetAccuracyDelta() (percent float64, feedbackCount int)
 }
 
 // NewGenerator creates a new briefing generator backed by the main DB.
@@ -31,91 +65,277 @@ func (g *Generator) Close() error {
 	return g.db.Close()
 }
 
+// SetProviders sets the provider interfaces for briefing generation.
+func (g *Generator) SetProviders(z ZoneProvider, p PersonProvider, pr PredictionProvider, h HealthProvider) {
+	g.zoneProvider = z
+	g.personProvider = p
+	g.predictionProvider = pr
+	g.healthProvider = h
+}
+
 // Briefing holds a generated morning briefing.
 type Briefing struct {
 	Date        string    `json:"date"`
+	Person      string    `json:"person,omitempty"`
 	Content     string    `json:"content"`
 	GeneratedAt int64     `json:"generated_at"`
+	Sections    []Section `json:"sections,omitempty"`
 }
 
-// Generate creates a morning briefing for the given date.
-// It assembles sections from sleep records, anomalies, and system health.
-func (g *Generator) Generate(date string, person string) (*Briefing, error) {
-	var sections []string
+// Section represents a single section of the briefing.
+type Section struct {
+	Type    string `json:"type"`    // "sleep", "people", "anomaly", "health", "prediction", "learning"
+	Content string `json:"content"`
+	Priority int    `json:"priority"` // Higher = shown first
+}
 
-	// BLOCK 2 — Sleep summary
-	if sleepSummary := g.generateSleepBlock(date, person); sleepSummary != "" {
-		sections = append(sections, sleepSummary)
+// Generate creates a morning briefing for the given date and person.
+// If person is empty, generates a household-wide briefing.
+func (g *Generator) Generate(date string, person string) (*Briefing, error) {
+	var sections []Section
+
+	// Parse date for calculations
+	dateTime, err := time.Parse("2006-01-02", date)
+	if err != nil {
+		return nil, fmt.Errorf("parse date: %w", err)
 	}
 
-	// BLOCK 4 — Overnight anomalies (breathing)
-	if anomalyText := g.generateBreathingAnomalyBlock(date, person); anomalyText != "" {
-		sections = append(sections, anomalyText)
+	// Calculate time range for "last night" (18:00 yesterday to now)
+	nightStart := time.Date(dateTime.Year(), dateTime.Month(), dateTime.Day()-1, 18, 0, 0, 0, time.Local)
+	if dateTime.Hour() < 6 {
+		// If early morning, use the night before
+		nightStart = nightStart.AddDate(0, 0, -1)
+	}
+	nightEnd := dateTime
+
+	// BLOCK 1 — Critical alerts (fall, security)
+	if alertSection := g.generateAlertBlock(nightStart, nightEnd, person); alertSection != nil {
+		sections = append(sections, *alertSection)
+	}
+
+	// BLOCK 2 — Sleep summary
+	if sleepSection := g.generateSleepBlock(date, person); sleepSection != nil {
+		sections = append(sections, *sleepSection)
+	}
+
+	// BLOCK 3 — Who is home (current state)
+	if peopleSection := g.generatePeopleBlock(person); peopleSection != nil {
+		sections = append(sections, *peopleSection)
+	}
+
+	// BLOCK 4 — Overnight anomalies
+	if anomalySection := g.generateAnomalyBlock(nightStart, nightEnd, person); anomalySection != nil {
+		sections = append(sections, *anomalySection)
+	}
+
+	// BLOCK 5 — System health
+	if healthSection := g.generateHealthBlock(); healthSection != nil {
+		sections = append(sections, *healthSection)
+	}
+
+	// BLOCK 6 — Prediction hint
+	if predictionSection := g.generatePredictionBlock(person); predictionSection != nil {
+		sections = append(sections, *predictionSection)
+	}
+
+	// BLOCK 7 — Learning progress
+	if learningSection := g.generateLearningBlock(); learningSection != nil {
+		sections = append(sections, *learningSection)
 	}
 
 	// Degenerate case
 	if len(sections) == 0 {
-		sections = append(sections, "All quiet last night. All systems healthy.")
+		sections = append(sections, Section{
+			Type:     "info",
+			Content:  "All quiet last night. All systems healthy.",
+			Priority: 0,
+		})
 	}
 
-	content := strings.Join(sections, "\n\n")
+	// Sort by priority descending
+	for i := 0; i < len(sections)-1; i++ {
+		for j := i + 1; j < len(sections); j++ {
+			if sections[j].Priority > sections[i].Priority {
+				sections[i], sections[j] = sections[j], sections[i]
+			}
+		}
+	}
+
+	// Build content from prioritized sections
+	contentParts := make([]string, 0, len(sections))
+	for _, s := range sections {
+		contentParts = append(contentParts, s.Content)
+	}
+	content := strings.Join(contentParts, "\n\n")
 
 	return &Briefing{
 		Date:        date,
+		Person:      person,
 		Content:     content,
 		GeneratedAt: time.Now().UnixMilli(),
+		Sections:    sections,
 	}, nil
 }
 
-// generateSleepBlock generates the sleep summary section of the briefing.
-func (g *Generator) generateSleepBlock(date, person string) string {
-	query := `SELECT breathing_rate_avg, breathing_regularity, duration_min, onset_latency_min,
-	                  restlessness, breathing_anomaly, breathing_samples_json
+// generateAlertBlock generates BLOCK 1 — Critical alerts.
+func (g *Generator) generateAlertBlock(nightStart, nightEnd time.Time, person string) *Section {
+	query := `SELECT type, zone, person, detail_json, severity
+	           FROM events
+	           WHERE timestamp_ms >= ? AND timestamp_ms < ?
+	             AND type IN ('fall_alert', 'security_alert')
+	             AND severity IN ('alert', 'critical')`
+	args := []interface{}{nightStart.UnixMilli(), nightEnd.UnixMilli()}
+
+	if person != "" {
+		query += ` AND person = ?`
+		args = append(args, person)
+	}
+	query += ` ORDER BY timestamp_ms ASC LIMIT 5`
+
+	rows, err := g.db.Query(query, args...)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+
+	var alerts []string
+	for rows.Next() {
+		var eventType, zone, personName, detailJSON, severity string
+		if err := rows.Scan(&eventType, &zone, &personName, &detailJSON, &severity); err != nil {
+			continue
+		}
+
+		var alert strings.Builder
+		switch eventType {
+		case "fall_alert":
+			alert.WriteString("⚠ Fall detected")
+			if personName != "" {
+				alert.WriteString(": ")
+				alert.WriteString(personName)
+			}
+			if zone != "" {
+				alert.WriteString(" in ")
+				alert.WriteString(zone)
+			}
+		case "security_alert":
+			alert.WriteString("⚠ Security alert")
+			if zone != "" {
+				alert.WriteString(": Motion in ")
+				alert.WriteString(zone)
+			}
+		}
+		alerts = append(alerts, alert.String())
+	}
+
+	if len(alerts) == 0 {
+		return nil
+	}
+
+	content := "⚠ " + strings.Join(alerts, "; ")
+	if len(alerts) > 1 {
+		content = fmt.Sprintf("⚠ %d critical events overnight. ", len(alerts)) + strings.Join(alerts, "; ")
+	}
+
+	return &Section{
+		Type:     "alert",
+		Content:  content,
+		Priority: 100,
+	}
+}
+
+// generateSleepBlock generates BLOCK 2 — Sleep summary.
+func (g *Generator) generateSleepBlock(date, person string) *Section {
+	query := `SELECT duration_min, onset_latency_min, restlessness,
+	                 breathing_rate_avg, breathing_regularity, breathing_anomaly,
+	                 breathing_samples_json, person
 	           FROM sleep_records WHERE date = ?`
-	var args []interface{}
-	args = append(args, date)
+	args := []interface{}{date}
 	if person != "" {
 		query += ` AND person = ?`
 		args = append(args, person)
 	}
 
-	row := g.db.QueryRow(query, args...)
+	rows, err := g.db.Query(query, args...)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
 
-	var breathAvg, breathReg, onsetLat, restlessness sql.NullFloat64
-	var duration sql.NullInt32
-	var breathAnomaly sql.NullBool
-	var breathSamplesJSON sql.NullString
-
-	if err := row.Scan(&breathAvg, &breathReg, &duration, &onsetLat, &restlessness,
-		&breathAnomaly, &breathSamplesJSON); err != nil {
-		return ""
+	var sleepRecords []struct {
+		Duration         sql.NullInt32
+		OnsetLatency    sql.NullFloat64
+		Restlessness    sql.NullFloat64
+		BreathAvg       sql.NullFloat64
+		BreathReg       sql.NullFloat64
+		BreathAnomaly   sql.NullBool
+		BreathSamples   sql.NullString
+		Person          sql.NullString
 	}
 
-	if !breathAvg.Valid || breathAvg.Float64 == 0 {
-		return ""
+	for rows.Next() {
+		var r struct {
+			Duration         sql.NullInt32
+			OnsetLatency    sql.NullFloat64
+			Restlessness    sql.NullFloat64
+			BreathAvg       sql.NullFloat64
+			BreathReg       sql.NullFloat64
+			BreathAnomaly   sql.NullBool
+			BreathSamples   sql.NullString
+			Person          sql.NullString
+		}
+		if err := rows.Scan(&r.Duration, &r.OnsetLatency, &r.Restlessness,
+			&r.BreathAvg, &r.BreathReg, &r.BreathAnomaly, &r.BreathSamples, &r.Person); err != nil {
+			continue
+		}
+		sleepRecords = append(sleepRecords, r)
 	}
 
+	if len(sleepRecords) == 0 {
+		return nil
+	}
+
+	// For multi-person, aggregate or pick the primary record
+	// For now, use the first record
+	r := sleepRecords[0]
+
 	var parts []string
+	personName := "You"
+	if r.Person.Valid && r.Person.String != "" {
+		personName = r.Person.String
+	}
 
-	// Duration
-	if duration.Valid && duration.Int32 > 0 {
-		h := duration.Int32 / 60
-		m := duration.Int32 % 60
+	// Duration and deviation from average
+	if r.Duration.Valid && r.Duration.Int32 > 0 {
+		h := r.Duration.Int32 / 60
+		m := r.Duration.Int32 % 60
 		if m > 0 {
-			parts = append(parts, fmt.Sprintf("You slept %dh %dm", h, m))
+			parts = append(parts, fmt.Sprintf("%s slept %dh %dm", personName, h, m))
 		} else {
-			parts = append(parts, fmt.Sprintf("You slept %dh", h))
+			parts = append(parts, fmt.Sprintf("%s slept %dh", personName, h))
+		}
+
+		// Compare with average (get from recent records)
+		avgDuration := g.getAverageSleepDuration(r.Person.String)
+		if avgDuration > 0 {
+			delta := int(r.Duration.Int32) - avgDuration
+			if math.Abs(float64(delta)) >= 10 {
+				if delta > 0 {
+					parts[len(parts)-1] += fmt.Sprintf(" — %d minutes more than your average", delta)
+				} else {
+					parts[len(parts)-1] += fmt.Sprintf(" — %d minutes less than your average", -delta)
+				}
+			}
 		}
 	} else {
-		parts = append(parts, "You slept")
+		parts = append(parts, personName+" slept")
 	}
 
 	// Restlessness
-	if restlessness.Valid {
+	if r.Restlessness.Valid {
 		switch {
-		case restlessness.Float64 < 1:
+		case r.Restlessness.Float64 < 1:
 			parts = append(parts, "Restlessness: Low.")
-		case restlessness.Float64 < 3:
+		case r.Restlessness.Float64 < 3:
 			parts = append(parts, "Restlessness: Moderate.")
 		default:
 			parts = append(parts, "Restlessness: High.")
@@ -123,8 +343,8 @@ func (g *Generator) generateSleepBlock(date, person string) string {
 	}
 
 	// Breathing regularity
-	if breathReg.Valid {
-		cv := breathReg.Float64
+	if r.BreathReg.Valid {
+		cv := r.BreathReg.Float64
 		switch {
 		case cv < 0.10:
 			parts = append(parts, "Breathing: Regular.")
@@ -136,10 +356,10 @@ func (g *Generator) generateSleepBlock(date, person string) string {
 	}
 
 	// Breathing anomaly
-	if breathAnomaly.Valid && breathAnomaly.Bool {
-		if breathSamplesJSON.Valid {
+	if r.BreathAnomaly.Valid && r.BreathAnomaly.Bool {
+		if r.BreathSamples.Valid {
 			var info map[string]interface{}
-			if err := json.Unmarshal([]byte(breathSamplesJSON.String), &info); err == nil {
+			if err := json.Unmarshal([]byte(r.BreathSamples.String), &info); err == nil {
 				avg, _ := info["avg"].(float64)
 				personal, _ := info["personal_avg"].(float64)
 				if personal > 0 {
@@ -150,83 +370,395 @@ func (g *Generator) generateSleepBlock(date, person string) string {
 				}
 			}
 		}
-		if len(parts) > 0 && breathAnomaly.Bool {
-			// Already added above
-		} else {
-			parts = append(parts, "Breathing rate elevated.")
+	}
+
+	if len(parts) == 0 {
+		return nil
+	}
+
+	return &Section{
+		Type:     "sleep",
+		Content:  strings.Join(parts, " "),
+		Priority: 80,
+	}
+}
+
+// generatePeopleBlock generates BLOCK 3 — Who is home.
+func (g *Generator) generatePeopleBlock(person string) *Section {
+	if g.personProvider == nil {
+		return nil
+	}
+
+	peopleHome := g.personProvider.GetPeopleHome()
+	if len(peopleHome) == 0 {
+		return &Section{
+			Type:     "people",
+			Content:  "The house is currently empty.",
+			Priority: 60,
 		}
 	}
 
-	return strings.Join(parts, " ")
+	var content string
+	if len(peopleHome) == 1 {
+		content = fmt.Sprintf("%s is home.", peopleHome[0])
+	} else {
+		content = fmt.Sprintf("%s are home.", strings.Join(peopleHome, ", "))
+	}
+
+	// Add information about who left when
+	// This would need event history, for now skip
+	return &Section{
+		Type:     "people",
+		Content:  content,
+		Priority: 60,
+	}
 }
 
-// generateBreathingAnomalyBlock generates the overnight breathing anomaly section.
-// This covers the case where the sleep block already includes the anomaly but
-// we want to surface it as a standalone alert if it was severe.
-func (g *Generator) generateBreathingAnomalyBlock(date, person string) string {
-	query := `SELECT person, breathing_rate_avg, breathing_samples_json
-	           FROM sleep_records
-	           WHERE breathing_anomaly = 1 AND date = ?`
-	var args []interface{}
-	args = append(args, date)
+// generateAnomalyBlock generates BLOCK 4 — Overnight anomalies.
+func (g *Generator) generateAnomalyBlock(nightStart, nightEnd time.Time, person string) *Section {
+	query := `SELECT type, zone, detail_json, timestamp_ms
+	           FROM events
+	           WHERE timestamp_ms >= ? AND timestamp_ms < ?
+	             AND type IN ('anomaly', 'unusual_activity')
+	             AND severity IN ('warning', 'alert')
+	           ORDER BY timestamp_ms ASC`
+	args := []interface{}{nightStart.UnixMilli(), nightEnd.UnixMilli()}
+
+	if person != "" {
+		query += ` AND person = ?`
+		args = append(args, person)
+	}
+	query += ` LIMIT 3`
+
+	rows, err := g.db.Query(query, args...)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+
+	var anomalies []string
+	for rows.Next() {
+		var eventType, zone, detailJSON string
+		var timestamp int64
+		if err := rows.Scan(&eventType, &zone, &detailJSON, &timestamp); err != nil {
+			continue
+		}
+
+		// Parse anomaly score from detail_json
+		var detail map[string]interface{}
+		var score float64
+		if err := json.Unmarshal([]byte(detailJSON), &detail); err == nil {
+			if s, ok := detail["score"].(float64); ok {
+				score = s
+			}
+		}
+
+		timeStr := time.Unix(0, timestamp*1e6).Format("3:04pm")
+		var anomaly strings.Builder
+		if zone != "" {
+			anomaly.WriteString(fmt.Sprintf("Motion in %s at %s", zone, timeStr))
+		} else {
+			anomaly.WriteString(fmt.Sprintf("Unusual activity at %s", timeStr))
+		}
+
+		if score >= 0.85 {
+			anomaly.WriteString(". High-confidence.")
+		} else if score < 0.7 {
+			anomaly.WriteString(". Likely environmental.")
+		}
+
+		anomalies = append(anomalies, anomaly.String())
+	}
+
+	if len(anomalies) == 0 {
+		return nil
+	}
+
+	var content string
+	if len(anomalies) == 1 {
+		content = "Last night: " + anomalies[0]
+	} else {
+		content = fmt.Sprintf("Last night: %d unusual events. Most notable: ", len(anomalies)) + anomalies[0]
+	}
+
+	return &Section{
+		Type:     "anomaly",
+		Content:  content,
+		Priority: 70,
+	}
+}
+
+// generateHealthBlock generates BLOCK 5 — System health.
+func (g *Generator) generateHealthBlock() *Section {
+	if g.healthProvider == nil {
+		return nil
+	}
+
+	quality := g.healthProvider.GetDetectionQuality()
+	online, total := g.healthProvider.GetNodeCount()
+
+	// Skip if excellent and all nodes online
+	if quality >= 90 && online == total {
+		return nil
+	}
+
+	var health string
+	switch {
+	case quality >= 90:
+		health = "Excellent"
+	case quality >= 70:
+		health = "Good"
+	case quality >= 40:
+		health = "Fair"
+	default:
+		health = "Poor"
+	}
+
+	content := fmt.Sprintf("System health: %s (%.0f%%). %d/%d nodes online.",
+		health, quality, online, total)
+
+	return &Section{
+		Type:     "health",
+		Content:  content,
+		Priority: 30,
+	}
+}
+
+// generatePredictionBlock generates BLOCK 6 — Prediction hint.
+func (g *Generator) generatePredictionBlock(person string) *Section {
+	if g.predictionProvider == nil {
+		return nil
+	}
+
+	// Get prediction for next action (15 min horizon)
+	zone, probability, ok := g.predictionProvider.GetPrediction(person, 15)
+	if !ok || probability < 0.7 {
+		return nil
+	}
+
+	// Format day of week
+	now := time.Now()
+	dayOfWeek := now.Weekday().String()
+
+	// Find what action this prediction suggests
+	content := fmt.Sprintf("Today's forecast: Based on your %s pattern, you'll likely be in %s in 15 minutes (%.0f%% confidence).",
+		dayOfWeek, zone, probability*100)
+
+	return &Section{
+		Type:     "prediction",
+		Content:  content,
+		Priority: 40,
+	}
+}
+
+// generateLearningBlock generates BLOCK 7 — Learning progress.
+func (g *Generator) generateLearningBlock() *Section {
+	if g.healthProvider == nil {
+		return nil
+	}
+
+	delta, feedbackCount := g.healthProvider.GetAccuracyDelta()
+	if feedbackCount == 0 {
+		return nil
+	}
+
+	var content string
+	if delta > 0 {
+		content = fmt.Sprintf("Accuracy improved %.0f%% this week thanks to your %d corrections.",
+			delta, feedbackCount)
+	} else {
+		content = fmt.Sprintf("You provided %d corrections this week.", feedbackCount)
+	}
+
+	return &Section{
+		Type:     "learning",
+		Content:  content,
+		Priority: 20,
+	}
+}
+
+// getAverageSleepDuration calculates average sleep duration over the past 7 days.
+func (g *Generator) getAverageSleepDuration(person string) int {
+	query := `SELECT AVG(duration_min) FROM sleep_records
+	           WHERE date >= date('now', '-7 days')`
+	args := []interface{}{}
 	if person != "" {
 		query += ` AND person = ?`
 		args = append(args, person)
 	}
 
-	row := g.db.QueryRow(query, args...)
-
-	var personName string
-	var breathAvg sql.NullFloat64
-	var breathSamplesJSON sql.NullString
-
-	if err := row.Scan(&personName, &breathAvg, &breathSamplesJSON); err != nil {
-		return ""
+	var avg sql.NullFloat64
+	err := g.db.QueryRow(query, args...).Scan(&avg)
+	if err != nil || !avg.Valid {
+		return 0
 	}
-
-	if personName == "" {
-		personName = "Person"
-	}
-
-	// Extract personal average from samples JSON
-	personalAvg := 0.0
-	if breathSamplesJSON.Valid {
-		var info map[string]interface{}
-		if err := json.Unmarshal([]byte(breathSamplesJSON.String), &info); err == nil {
-			personalAvg, _ = info["personal_avg"].(float64)
-		}
-	}
-
-	avgStr := fmt.Sprintf("%.0f", breathAvg.Float64)
-	if personalAvg > 0 {
-		return fmt.Sprintf("Last night: Breathing rate elevated (%s bpm vs. %s bpm average for %s).",
-			avgStr, fmt.Sprintf("%.0f", personalAvg), personName)
-	}
-	return fmt.Sprintf("Last night: Breathing rate elevated (%s bpm for %s).", avgStr, personName)
+	return int(avg.Float64)
 }
 
 // Save persists a briefing to the briefings table.
 func (g *Generator) Save(b *Briefing) error {
-	_, err := g.db.Exec(`
+	// Check which columns exist in the briefings table
+	var personColExists, sectionsJSONColExists bool
+
+	// Check for person column
+	err := g.db.QueryRow(`
+		SELECT COUNT(*) > 0 FROM pragma_table_info('briefings') WHERE name = 'person'
+	`).Scan(&personColExists)
+	if err != nil {
+		return fmt.Errorf("check person column: %w", err)
+	}
+
+	// Check for sections_json column
+	err = g.db.QueryRow(`
+		SELECT COUNT(*) > 0 FROM pragma_table_info('briefings') WHERE name = 'sections_json'
+	`).Scan(&sectionsJSONColExists)
+	if err != nil {
+		return fmt.Errorf("check sections_json column: %w", err)
+	}
+
+	// Build query dynamically based on available columns
+	if personColExists && sectionsJSONColExists {
+		// Marshal sections to JSON if present
+		var sectionsJSON sql.NullString
+		if len(b.Sections) > 0 {
+			data, err := json.Marshal(b.Sections)
+			if err == nil {
+				sectionsJSON = sql.NullString{String: string(data), Valid: true}
+			}
+		}
+
+		_, err = g.db.Exec(`
+			INSERT OR REPLACE INTO briefings (date, person, content, generated_at, sections_json)
+			VALUES (?, ?, ?, ?, ?)
+		`, b.Date, b.Person, b.Content, b.GeneratedAt, sectionsJSON)
+		return err
+	}
+
+	// Fallback for old schema without person and sections_json
+	_, err = g.db.Exec(`
 		INSERT OR REPLACE INTO briefings (date, content, generated_at)
 		VALUES (?, ?, ?)
 	`, b.Date, b.Content, b.GeneratedAt)
 	return err
 }
 
-// Get retrieves a previously generated briefing by date.
-func (g *Generator) Get(date string) (*Briefing, error) {
+// Get retrieves a previously generated briefing by date and optional person.
+func (g *Generator) Get(date string, person string) (*Briefing, error) {
+	// First, try to query with sections_json (new schema)
 	var content string
 	var generatedAt int64
-	err := g.db.QueryRow(
-		`SELECT content, generated_at FROM briefings WHERE date = ?`, date,
-	).Scan(&content, &generatedAt)
-	if err != nil {
-		return nil, err
+	var personVal sql.NullString
+	var sectionsJSON sql.NullString
+
+	query := `SELECT content, generated_at, person, sections_json FROM briefings WHERE date = ?`
+	args := []interface{}{date}
+
+	if person != "" {
+		query += ` AND person = ?`
+		args = append(args, person)
+	} else {
+		query += ` AND (person IS NULL OR person = '')`
 	}
-	return &Briefing{
+
+	err := g.db.QueryRow(query, args...).Scan(&content, &generatedAt, &personVal, &sectionsJSON)
+	if err != nil {
+		// If the query fails, it might be because sections_json column doesn't exist
+		// Try fallback query without sections_json
+		query = `SELECT content, generated_at FROM briefings WHERE date = ?`
+		args = []interface{}{date}
+
+		if person != "" {
+			query += ` AND person = ?`
+			args = append(args, person)
+		} else {
+			query += ` AND (person IS NULL OR person = '')`
+		}
+
+		var content2 string
+		var generatedAt2 int64
+		err2 := g.db.QueryRow(query, args...).Scan(&content2, &generatedAt2)
+		if err2 != nil {
+			return nil, err2
+		}
+		content = content2
+		generatedAt = generatedAt2
+		// personVal and sectionsJSON remain NULL/invalid
+	}
+
+	b := &Briefing{
 		Date:        date,
+		Person:      personVal.String,
 		Content:     content,
 		GeneratedAt: generatedAt,
-	}, nil
+	}
+
+	// Unmarshal sections if present
+	if sectionsJSON.Valid {
+		if err := json.Unmarshal([]byte(sectionsJSON.String), &b.Sections); err != nil {
+			log.Printf("[WARN] Failed to unmarshal sections for %s: %v", date, err)
+		}
+	}
+
+	return b, nil
+}
+
+// GetLatest retrieves the most recent briefing (for any person).
+func (g *Generator) GetLatest() (*Briefing, error) {
+	var date, person, content string
+	var generatedAt int64
+	var sectionsJSON sql.NullString
+
+	// Try new schema first
+	err := g.db.QueryRow(`
+		SELECT date, person, content, generated_at, sections_json
+		FROM briefings
+		ORDER BY generated_at DESC
+		LIMIT 1
+	`).Scan(&date, &person, &content, &generatedAt, &sectionsJSON)
+
+	if err != nil {
+		// Fallback to old schema without sections_json
+		err = g.db.QueryRow(`
+			SELECT date, content, generated_at
+			FROM briefings
+			ORDER BY generated_at DESC
+			LIMIT 1
+		`).Scan(&date, &content, &generatedAt)
+		if err != nil {
+			return nil, err
+		}
+		// person and sectionsJSON remain empty/invalid
+	}
+
+	b := &Briefing{
+		Date:        date,
+		Person:      person,
+		Content:     content,
+		GeneratedAt: generatedAt,
+	}
+
+	// Unmarshal sections if present
+	if sectionsJSON.Valid {
+		if err := json.Unmarshal([]byte(sectionsJSON.String), &b.Sections); err != nil {
+			log.Printf("[WARN] Failed to unmarshal sections for latest briefing: %v", err)
+		}
+	}
+
+	return b, nil
+}
+
+// ShouldGenerate checks if a briefing should be generated for the given date.
+// Returns true if no briefing exists for this date yet.
+func (g *Generator) ShouldGenerate(date string, person string) bool {
+	var count int
+	query := `SELECT COUNT(*) FROM briefings WHERE date = ?`
+	args := []interface{}{date}
+
+	if person != "" {
+		query += ` AND (person = ? OR person IS NULL OR person = '')`
+		args = append(args, person)
+	}
+
+	err := g.db.QueryRow(query, args...).Scan(&count)
+	return err == nil && count == 0
 }
diff --git a/mothership/internal/briefing/briefing_test.go b/mothership/internal/briefing/briefing_test.go
new file mode 100644
index 0000000..6860900
--- /dev/null
+++ b/mothership/internal/briefing/briefing_test.go
@@ -0,0 +1,331 @@
+// Package briefing provides tests for the morning briefing generator.
+package briefing
+
+import (
+	"database/sql"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	_ "modernc.org/sqlite"
+)
+
+// mockZoneProvider implements ZoneProvider for testing.
+type mockZoneProvider struct {
+	zones map[int]string
+	occupancy map[int]int
+	people map[int][]string
+}
+
+func (m *mockZoneProvider) GetZoneName(id int) string {
+	if m.zones == nil {
+		return ""
+	}
+	return m.zones[id]
+}
+
+func (m *mockZoneProvider) GetZoneOccupancy(zoneID int) int {
+	if m.occupancy == nil {
+		return 0
+	}
+	return m.occupancy[zoneID]
+}
+
+func (m *mockZoneProvider) GetPeopleInZone(zoneID int) []string {
+	if m.people == nil {
+		return nil
+	}
+	return m.people[zoneID]
+}
+
+// mockPersonProvider implements PersonProvider for testing.
+type mockPersonProvider struct {
+	peopleHome []string
+	lastSeen   map[string]time.Time
+	zones      map[string]string
+}
+
+func (m *mockPersonProvider) GetPeopleHome() []string {
+	if m.peopleHome == nil {
+		return nil
+	}
+	return m.peopleHome
+}
+
+func (m *mockPersonProvider) GetPersonLastSeen(person string) time.Time {
+	if m.lastSeen == nil {
+		return time.Time{}
+	}
+	return m.lastSeen[person]
+}
+
+func (m *mockPersonProvider) GetPersonZone(person string) string {
+	if m.zones == nil {
+		return ""
+	}
+	return m.zones[person]
+}
+
+// mockPredictionProvider implements PredictionProvider for testing.
+type mockPredictionProvider struct {
+	predictions map[string]mockPrediction
+	daysComplete map[string]int
+	modelReady  map[string]bool
+}
+
+type mockPrediction struct {
+	zone        string
+	probability float64
+}
+
+func (m *mockPredictionProvider) GetPrediction(person string, horizonMinutes int) (string, float64, bool) {
+	if m.predictions == nil {
+		return "", 0, false
+	}
+	p, ok := m.predictions[person]
+	if !ok {
+		return "", 0, false
+	}
+	return p.zone, p.probability, true
+}
+
+func (m *mockPredictionProvider) GetDaysComplete(person string) int {
+	if m.daysComplete == nil {
+		return 0
+	}
+	return m.daysComplete[person]
+}
+
+func (m *mockPredictionProvider) IsModelReady(person string) bool {
+	if m.modelReady == nil {
+		return false
+	}
+	return m.modelReady[person]
+}
+
+// mockHealthProvider implements HealthProvider for testing.
+type mockHealthProvider struct {
+	quality   float64
+	online    int
+	total     int
+	accuracyDelta float64
+	feedbackCount int
+}
+
+func (m *mockHealthProvider) GetDetectionQuality() float64 {
+	return m.quality
+}
+
+func (m *mockHealthProvider) GetNodeCount() (int, int) {
+	return m.online, m.total
+}
+
+func (m *mockHealthProvider) GetAccuracyDelta() (float64, int) {
+	return m.accuracyDelta, m.feedbackCount
+}
+
+func setupTestDB(t *testing.T) (*sql.DB, string) {
+	f, err := os.CreateTemp("", "briefing-test-*.db")
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	dbPath := f.Name()
+	db, err := sql.Open("sqlite", dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Create schema
+	_, err = db.Exec(`
+		CREATE TABLE IF NOT EXISTS briefings (
+			date TEXT PRIMARY KEY,
+			person TEXT,
+			content TEXT NOT NULL,
+			generated_at INTEGER NOT NULL,
+			sections_json TEXT
+		);
+
+		CREATE TABLE IF NOT EXISTS sleep_records (
+			id INTEGER PRIMARY KEY,
+			person TEXT,
+			zone_id INTEGER,
+			date TEXT NOT NULL,
+			duration_min INTEGER,
+			onset_latency_min REAL,
+			restlessness REAL,
+			breathing_rate_avg REAL,
+			breathing_regularity REAL,
+			breathing_anomaly INTEGER,
+			breathing_samples_json TEXT,
+			summary_json TEXT
+		);
+
+		CREATE TABLE IF NOT EXISTS events (
+			id INTEGER PRIMARY KEY,
+			timestamp_ms INTEGER NOT NULL,
+			type TEXT NOT NULL,
+			zone TEXT,
+			person TEXT,
+			blob_id INTEGER,
+			detail_json TEXT,
+			severity TEXT NOT NULL DEFAULT 'info'
+		);
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return db, dbPath
+}
+
+func TestBriefing_GenerateEmpty(t *testing.T) {
+	db, dbPath := setupTestDB(t)
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	g, err := NewGenerator(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer g.Close()
+
+	b, err := g.Generate("2024-03-15", "")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if b.Content == "" {
+		t.Error("expected non-empty content for degenerate case")
+	}
+
+	if b.Date != "2024-03-15" {
+		t.Errorf("expected date 2024-03-15, got %s", b.Date)
+	}
+}
+
+func TestBriefing_GenerateWithSleep(t *testing.T) {
+	db, dbPath := setupTestDB(t)
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	// Insert a sleep record
+	_, err := db.Exec(`
+		INSERT INTO sleep_records (date, person, duration_min, restlessness, breathing_rate_avg, breathing_regularity)
+		VALUES ('2024-03-15', 'Alice', 480, 0.5, 14.0, 0.08)
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	g, err := NewGenerator(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer g.Close()
+
+	b, err := g.Generate("2024-03-15", "Alice")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !strings.Contains(b.Content, "slept") {
+		t.Error("expected content to mention sleep")
+	}
+}
+
+func TestBriefing_SaveAndGet(t *testing.T) {
+	db, dbPath := setupTestDB(t)
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	g, err := NewGenerator(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer g.Close()
+
+	b := &Briefing{
+		Date:        "2024-03-15",
+		Person:      "Alice",
+		Content:     "Test briefing content",
+		GeneratedAt: time.Now().UnixMilli(),
+	}
+
+	err = g.Save(b)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	retrieved, err := g.Get("2024-03-15", "Alice")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if retrieved.Content != b.Content {
+		t.Errorf("expected content %q, got %q", b.Content, retrieved.Content)
+	}
+}
+
+func TestBriefing_ShouldGenerate(t *testing.T) {
+	db, dbPath := setupTestDB(t)
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	g, err := NewGenerator(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer g.Close()
+
+	// Initially should generate
+	if !g.ShouldGenerate("2024-03-15", "") {
+		t.Error("expected ShouldGenerate to return true for new date")
+	}
+
+	// After saving, should not generate
+	b := &Briefing{
+		Date:        "2024-03-15",
+		Content:     "Test",
+		GeneratedAt: time.Now().UnixMilli(),
+	}
+	if err := g.Save(b); err != nil {
+		t.Fatal(err)
+	}
+
+	if g.ShouldGenerate("2024-03-15", "") {
+		t.Error("expected ShouldGenerate to return false after saving")
+	}
+}
+
+func TestBriefing_GenerateWithAlerts(t *testing.T) {
+	db, dbPath := setupTestDB(t)
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	// Insert a fall alert event
+	nightStart := time.Date(2024, 3, 14, 18, 0, 0, 0, time.Local)
+	_, err := db.Exec(`
+		INSERT INTO events (timestamp_ms, type, zone, person, severity)
+		VALUES (?, 'fall_alert', 'Bedroom', 'Alice', 'alert')
+	`, nightStart.UnixMilli())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	g, err := NewGenerator(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer g.Close()
+
+	b, err := g.Generate("2024-03-15", "Alice")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !strings.Contains(b.Content, "Fall") {
+		t.Error("expected content to mention fall alert")
+	}
+}
diff --git a/mothership/internal/briefing/notify_adapter.go b/mothership/internal/briefing/notify_adapter.go
new file mode 100644
index 0000000..69b378e
--- /dev/null
+++ b/mothership/internal/briefing/notify_adapter.go
@@ -0,0 +1,38 @@
+// Package briefing provides notification adapter for the briefing scheduler.
+package briefing
+
+import (
+	"log"
+
+	"github.com/spaxel/mothership/internal/notify"
+)
+
+// NotifyAdapter adapts the notify.Service to the briefing NotifyService interface.
+type NotifyAdapter struct {
+	service *notify.Service
+}
+
+// NewNotifyAdapter creates a new notification adapter.
+func NewNotifyAdapter(svc *notify.Service) *NotifyAdapter {
+	return &NotifyAdapter{service: svc}
+}
+
+// Send sends a notification through the notify service.
+func (a *NotifyAdapter) Send(notification Notification) error {
+	if a.service == nil {
+		log.Printf("[WARN] Notification service not available, skipping: %s", notification.Title)
+		return nil
+	}
+
+	notif := notify.Notification{
+		Title:     notification.Title,
+		Body:      notification.Body,
+		Priority:  notification.Priority,
+		Tags:      notification.Tags,
+		Image:     notification.Image,
+		ImageType: notification.ImageType,
+		Timestamp: notification.Timestamp,
+	}
+
+	return a.service.Send(notif)
+}
diff --git a/mothership/internal/briefing/scheduler.go b/mothership/internal/briefing/scheduler.go
new file mode 100644
index 0000000..8e3f246
--- /dev/null
+++ b/mothership/internal/briefing/scheduler.go
@@ -0,0 +1,307 @@
+// Package briefing provides scheduling for morning briefing push notifications.
+package briefing
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"sync"
+	"time"
+)
+
+// Scheduler handles automatic briefing generation and push notifications.
+type Scheduler struct {
+	generator      *Generator
+	notifyService  NotifyService
+	mu             sync.RWMutex
+	config         SchedulerConfig
+	ticker         *time.Ticker
+	stopChan       chan struct{}
+	running        bool
+}
+
+// SchedulerConfig holds scheduling configuration.
+type SchedulerConfig struct {
+	Enabled          bool
+	Time             string // HH:MM format, e.g., "07:00"
+	PushNotification bool
+	AutoGenerate     bool
+	Timezone         string // IANA timezone name
+}
+
+// NotifyService is the interface for sending push notifications.
+type NotifyService interface {
+	Send(notification Notification) error
+}
+
+// Notification represents a push notification.
+type Notification struct {
+	Title     string
+	Body      string
+	Priority  int
+	Tags      []string
+	Image     []byte
+	ImageType string
+	Timestamp time.Time
+}
+
+// NewScheduler creates a new briefing scheduler.
+func NewScheduler(gen *Generator, notify NotifyService, config SchedulerConfig) *Scheduler {
+	if config.Time == "" {
+		config.Time = "07:00" // Default 7 AM
+	}
+	if config.Timezone == "" {
+		config.Timezone = "Local"
+	}
+
+	return &Scheduler{
+		generator:     gen,
+		notifyService: notify,
+		config:        config,
+		stopChan:      make(chan struct{}),
+	}
+}
+
+// Start begins the scheduling loop.
+func (s *Scheduler) Start(ctx context.Context) {
+	s.mu.Lock()
+	if s.running {
+		s.mu.Unlock()
+		return
+	}
+	s.running = true
+	s.mu.Unlock()
+
+	// Start ticker to check every minute
+	s.ticker = time.NewTicker(1 * time.Minute)
+
+	go func() {
+		defer s.ticker.Stop()
+
+		// Initial check on start
+		s.checkAndGenerate()
+
+		for {
+			select {
+			case <-s.ticker.C:
+				s.checkAndGenerate()
+			case <-s.stopChan:
+				return
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	log.Printf("[INFO] Briefing scheduler started (time: %s, push: %v)",
+		s.config.Time, s.config.PushNotification)
+}
+
+// Stop stops the scheduling loop.
+func (s *Scheduler) Stop() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if !s.running {
+		return
+	}
+
+	s.running = false
+	close(s.stopChan)
+
+	if s.ticker != nil {
+		s.ticker.Stop()
+	}
+
+	log.Printf("[INFO] Briefing scheduler stopped")
+}
+
+// SetConfig updates the scheduler configuration.
+func (s *Scheduler) SetConfig(config SchedulerConfig) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	oldConfig := s.config
+	s.config = config
+
+	// If time changed, reset ticker to trigger sooner
+	if oldConfig.Time != config.Time {
+		if s.ticker != nil {
+			s.ticker.Reset(1 * time.Minute)
+		}
+	}
+}
+
+// GetConfig returns the current configuration.
+func (s *Scheduler) GetConfig() SchedulerConfig {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.config
+}
+
+// checkAndGenerate checks if it's time to generate and send a briefing.
+func (s *Scheduler) checkAndGenerate() {
+	s.mu.RLock()
+	config := s.config
+	s.mu.RUnlock()
+
+	if !config.Enabled || !config.AutoGenerate {
+		return
+	}
+
+	// Parse configured time
+	hour, minute, err := parseTime(config.Time)
+	if err != nil {
+		log.Printf("[ERROR] Failed to parse briefing time %q: %v", config.Time, err)
+		return
+	}
+
+	// Get current time in configured timezone
+	now := s.nowInTimezone()
+
+	// Check if we're at the configured time (within 1 minute window)
+	if now.Hour() != hour || now.Minute() != minute {
+		return
+	}
+
+	// Get today's date
+	date := now.Format("2006-01-02")
+
+	// Check if briefing was already generated today
+	if !s.generator.ShouldGenerate(date, "") {
+		log.Printf("[DEBUG] Briefing already generated for %s, skipping", date)
+		return
+	}
+
+	// Generate briefing
+	b, err := s.generator.Generate(date, "")
+	if err != nil {
+		log.Printf("[ERROR] Failed to generate briefing for %s: %v", date, err)
+		return
+	}
+
+	// Save briefing
+	if err := s.generator.Save(b); err != nil {
+		log.Printf("[ERROR] Failed to save briefing for %s: %v", date, err)
+	}
+
+	log.Printf("[INFO] Morning briefing generated for %s", date)
+
+	// Send push notification if enabled
+	if config.PushNotification && s.notifyService != nil {
+		s.sendNotification(b)
+	}
+}
+
+// sendNotification sends a push notification for the briefing.
+func (s *Scheduler) sendNotification(b *Briefing) {
+	notification := Notification{
+		Title:     "Morning Briefing",
+		Body:       s.formatNotificationBody(b),
+		Priority:  1, // Low priority for morning briefings
+		Tags:      []string{"briefing", "morning"},
+		Timestamp: time.Now(),
+	}
+
+	if err := s.notifyService.Send(notification); err != nil {
+		log.Printf("[ERROR] Failed to send briefing notification: %v", err)
+	} else {
+		log.Printf("[INFO] Morning briefing notification sent for %s", b.Date)
+	}
+}
+
+// formatNotificationBody formats the briefing content for push notifications.
+// Truncates to a reasonable length for push notifications.
+func (s *Scheduler) formatNotificationBody(b *Briefing) string {
+	// Use the first 200 characters of the briefing content
+	maxLen := 200
+	content := b.Content
+	if len(content) > maxLen {
+		content = content[:maxLen] + "..."
+	}
+	return content
+}
+
+// nowInTimezone returns the current time in the configured timezone.
+func (s *Scheduler) nowInTimezone() time.Time {
+	s.mu.RLock()
+	timezone := s.config.Timezone
+	s.mu.RUnlock()
+
+	if timezone == "Local" || timezone == "" {
+		return time.Now()
+	}
+
+	loc, err := time.LoadLocation(timezone)
+	if err != nil {
+		log.Printf("[WARN] Failed to load timezone %q, using local time: %v", timezone, err)
+		return time.Now()
+	}
+
+	return time.Now().In(loc)
+}
+
+// parseTime parses a time string in HH:MM format.
+func parseTime(s string) (hour, minute int, err error) {
+	var h, m int
+	_, err = fmt.Sscanf(s, "%d:%d", &h, &m)
+	if err != nil {
+		return 0, 0, fmt.Errorf("invalid time format: %w", err)
+	}
+	if h < 0 || h > 23 || m < 0 || m > 59 {
+		return 0, 0, fmt.Errorf("invalid time values: %d:%d", h, m)
+	}
+	return h, m, nil
+}
+
+// ShouldGenerateNow checks if a briefing should be generated at this moment.
+// This is useful for testing and manual triggers.
+func (s *Scheduler) ShouldGenerateNow() bool {
+	s.mu.RLock()
+	config := s.config
+	s.mu.RUnlock()
+
+	if !config.Enabled || !config.AutoGenerate {
+		return false
+	}
+
+	hour, minute, err := parseTime(config.Time)
+	if err != nil {
+		return false
+	}
+
+	now := s.nowInTimezone()
+	return now.Hour() == hour && now.Minute() == minute
+}
+
+// TriggerNow manually triggers briefing generation and notification.
+func (s *Scheduler) TriggerNow(date string) error {
+	s.mu.RLock()
+	config := s.config
+	s.mu.RUnlock()
+
+	if date == "" {
+		now := s.nowInTimezone()
+		date = now.Format("2006-01-02")
+	}
+
+	// Generate briefing
+	b, err := s.generator.Generate(date, "")
+	if err != nil {
+		return err
+	}
+
+	// Save briefing
+	if err := s.generator.Save(b); err != nil {
+		return err
+	}
+
+	log.Printf("[INFO] Manual briefing trigger for %s", date)
+
+	// Send push notification if enabled
+	if config.PushNotification && s.notifyService != nil {
+		s.sendNotification(b)
+	}
+
+	return nil
+}
diff --git a/mothership/internal/db/migrations.go b/mothership/internal/db/migrations.go
index 79eebbd..a53c93e 100644
--- a/mothership/internal/db/migrations.go
+++ b/mothership/internal/db/migrations.go
@@ -62,11 +62,16 @@ func AllMigrations() []Migration {
 			Version:     11,
 			Description: "add FTS5 table and triggers for events search",
 			Up:          migration_011_add_events_fts,
-			{
-				Version:     12,
-				Description: "add crowd flow visualization tables",
-				Up:          migration_012_add_crowd_flow_tables,
-			},
+		},
+		{
+			Version:     12,
+			Description: "add crowd flow visualization tables",
+			Up:          migration_012_add_crowd_flow_tables,
+		},
+		{
+			Version:     13,
+			Description: "add person and sections_json columns to briefings table",
+			Up:          migration_013_add_briefing_person_columns,
 		},
 	}
 }
@@ -446,34 +451,34 @@ func migration_006_add_virtual_node_columns(tx *sql.Tx) error {
 // and error_message/error_count columns to the triggers table.
 func migration_007_add_webhook_tables(tx *sql.Tx) error {
 	schema := `
--- Error tracking columns on triggers
-ALTER TABLE triggers ADD COLUMN error_message TEXT DEFAULT '';
-ALTER TABLE triggers ADD COLUMN error_count INTEGER NOT NULL DEFAULT 0;
+	-- Error tracking columns on triggers
+	ALTER TABLE triggers ADD COLUMN error_message TEXT DEFAULT '';
+	ALTER TABLE triggers ADD COLUMN error_count INTEGER NOT NULL DEFAULT 0;
 
--- Trigger blob state persistence across restarts
-CREATE TABLE IF NOT EXISTS trigger_state (
-	trigger_id  INTEGER NOT NULL,
-	blob_id     INTEGER NOT NULL,
-	inside      INTEGER NOT NULL DEFAULT 0,
-	enter_time  INTEGER NOT NULL DEFAULT 0,
-	last_check  INTEGER NOT NULL DEFAULT 0,
-	PRIMARY KEY (trigger_id, blob_id),
-	FOREIGN KEY (trigger_id) REFERENCES triggers(id) ON DELETE CASCADE
-);
+	-- Trigger blob state persistence across restarts
+	CREATE TABLE IF NOT EXISTS trigger_state (
+		trigger_id  INTEGER NOT NULL,
+		blob_id     INTEGER NOT NULL,
+		inside      INTEGER NOT NULL DEFAULT 0,
+		enter_time  INTEGER NOT NULL DEFAULT 0,
+		last_check  INTEGER NOT NULL DEFAULT 0,
+		PRIMARY KEY (trigger_id, blob_id),
+		FOREIGN KEY (trigger_id) REFERENCES triggers(id) ON DELETE CASCADE
+	);
 
--- Webhook audit log
-CREATE TABLE IF NOT EXISTS webhook_log (
-	id          INTEGER PRIMARY KEY AUTOINCREMENT,
-	trigger_id  INTEGER NOT NULL,
-	fired_at_ms INTEGER NOT NULL,
-	url         TEXT NOT NULL,
-	status_code INTEGER,
-	latency_ms  INTEGER NOT NULL DEFAULT 0,
-	error       TEXT DEFAULT '',
-	FOREIGN KEY (trigger_id) REFERENCES triggers(id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_webhook_log_trigger ON webhook_log(trigger_id, fired_at_ms DESC);
-`
+	-- Webhook audit log
+	CREATE TABLE IF NOT EXISTS webhook_log (
+		id          INTEGER PRIMARY KEY AUTOINCREMENT,
+		trigger_id  INTEGER NOT NULL,
+		fired_at_ms INTEGER NOT NULL,
+		url         TEXT NOT NULL,
+		status_code INTEGER,
+		latency_ms  INTEGER NOT NULL DEFAULT 0,
+		error       TEXT DEFAULT '',
+		FOREIGN KEY (trigger_id) REFERENCES triggers(id) ON DELETE CASCADE
+	);
+	CREATE INDEX IF NOT EXISTS idx_webhook_log_trigger ON webhook_log(trigger_id, fired_at_ms DESC);
+	`
 	_, err := tx.Exec(schema)
 	return err
 }
@@ -525,30 +530,30 @@ func migration_010_add_floorplan(tx *sql.Tx) error {
 // migration_011_add_events_fts adds FTS5 full-text search for events.
 func migration_011_add_events_fts(tx *sql.Tx) error {
 	schema := `
--- FTS5 index for natural-language search across event detail
-CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
-	type, zone, person, detail_json,
-	content='events', content_rowid='id'
-);
+	-- FTS5 index for natural-language search across event detail
+	CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+		type, zone, person, detail_json,
+		content='events', content_rowid='id'
+	);
 
--- Triggers to keep events_fts in sync with the events table
-CREATE TRIGGER IF NOT EXISTS events_fts_insert AFTER INSERT ON events BEGIN
-	INSERT INTO events_fts(rowid, type, zone, person, detail_json)
-	VALUES (new.id, new.type, new.zone, new.person, new.detail_json);
-END;
+	-- Triggers to keep events_fts in sync with the events table
+	CREATE TRIGGER IF NOT EXISTS events_fts_insert AFTER INSERT ON events BEGIN
+		INSERT INTO events_fts(rowid, type, zone, person, detail_json)
+		VALUES (new.id, new.type, new.zone, new.person, new.detail_json);
+	END;
 
-CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
-	INSERT INTO events_fts(events_fts, rowid, type, zone, person, detail_json)
-	VALUES ('delete', old.id, old.type, old.zone, old.person, old.detail_json);
-END;
+	CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
+		INSERT INTO events_fts(events_fts, rowid, type, zone, person, detail_json)
+		VALUES ('delete', old.id, old.type, old.zone, old.person, old.detail_json);
+	END;
 
-CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
-	INSERT INTO events_fts(events_fts, rowid, type, zone, person, detail_json)
-	VALUES ('delete', old.id, old.type, old.zone, old.person, old.detail_json);
-	INSERT INTO events_fts(rowid, type, zone, person, detail_json)
-	VALUES (new.id, new.type, new.zone, new.person, new.detail_json);
-END;
-`
+	CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
+		INSERT INTO events_fts(events_fts, rowid, type, zone, person, detail_json)
+		VALUES ('delete', old.id, old.type, old.zone, old.person, old.detail_json);
+		INSERT INTO events_fts(rowid, type, zone, person, detail_json)
+		VALUES (new.id, new.type, new.zone, new.person, new.detail_json);
+	END;
+	`
 	_, err := tx.Exec(schema)
 	return err
 }
@@ -598,3 +603,41 @@ func migration_012_add_crowd_flow_tables(tx *sql.Tx) error {
 	_, err := tx.Exec(schema)
 	return err
 }
+
+// migration_013_add_briefing_person_columns adds person and sections_json columns to briefings table.
+func migration_013_add_briefing_person_columns(tx *sql.Tx) error {
+	// Check if person column already exists
+	var colExists bool
+	err := tx.QueryRow(`
+		SELECT COUNT(*) > 0 FROM pragma_table_info('briefings') WHERE name = 'person'
+	`).Scan(&colExists)
+	if err != nil {
+		return err
+	}
+
+	// Add columns if they don't exist
+	if !colExists {
+		_, err = tx.Exec(`ALTER TABLE briefings ADD COLUMN person TEXT`)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Add sections_json column for structured briefing data
+	var sectionsColExists bool
+	err = tx.QueryRow(`
+		SELECT COUNT(*) > 0 FROM pragma_table_info('briefings') WHERE name = 'sections_json'
+	`).Scan(&sectionsColExists)
+	if err != nil {
+		return err
+	}
+
+	if !sectionsColExists {
+		_, err = tx.Exec(`ALTER TABLE briefings ADD COLUMN sections_json TEXT`)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}