neoagent 3.1.1-beta.8 → 3.2.0

package/server/routes/auth.js

@@ -62,6 +62,8 @@ const passwordResetLimiter = rateLimit({
   legacyHeaders: false,
 });
 
+const WEARABLE_SESSION_MAX_AGE_MS = 90 * 24 * 60 * 60 * 1000;
+
 function getAuthProviderManager(req) {
   return req.app?.locals?.authProviderManager;
 }
@@ -81,7 +83,7 @@ function toUserPayload(user) {
   };
 }
 
-function establishSession(req, res, user) {
+function establishSession(req, res, user, options = {}) {
   req.session.regenerate((regenerateError) => {
     if (regenerateError) {
       console.error('Auth session regenerate error:', regenerateError);
@@ -90,6 +92,9 @@ function establishSession(req, res, user) {
 
     req.session.userId = user.id;
     req.session.username = user.username;
+    if (Number.isFinite(options.maxAgeMs) && options.maxAgeMs > 0) {
+      req.session.cookie.maxAge = options.maxAgeMs;
+    }
     req.session.save((saveError) => {
       if (saveError) {
         console.error('Auth session save error:', saveError);
@@ -648,7 +653,11 @@ router.post('/api/auth/qr-login/challenge/:id/claim', qrLoginClaimLimiter, (req,
       pollToken,
     });
     updateLastLogin(result.user.id);
-    return establishSession(req, res, result.user);
+    const requestedPlatform = String(result.challenge?.requestedDevice?.metadata?.platform || '');
+    const sessionOptions = requestedPlatform === 'esp32-s3-amoled'
+      ? { maxAgeMs: WEARABLE_SESSION_MAX_AGE_MS }
+      : {};
+    return establishSession(req, res, result.user, sessionOptions);
   } catch (error) {
     const statusCode = Number(error?.statusCode || 500);
     return res.status(statusCode).json({

package/server/routes/settings.js

@@ -44,11 +44,6 @@ const AGENT_SETTING_KEYS = new Set([
   'subagent_max_children_per_run',
   'assistant_behavior_notes',
   'auto_skill_learning',
-  'auto_recording_insights',
-  'default_recording_transcription_provider',
-  'default_recording_transcription_model',
-  'default_recording_summary_provider',
-  'default_recording_summary_model',
   'fallback_model_id',
   'smarter_model_selector',
   'ai_provider_configs',

package/server/routes/voice_assistant.js

@@ -2,140 +2,13 @@ const express = require('express');
 
 const { requireAuth } = require('../middleware/auth');
 const { sanitizeError } = require('../utils/security');
-const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
-const { TurnCoordinator } = require('../services/voice/turnCoordinator');
-const { normalizeVoiceSynthesisOptions, transcribeVoiceInput } = require('../services/voice/providers');
+const { transcribeVoiceInput } = require('../services/voice/providers');
 const { writeTempAudioFile, removeTempFile } = require('../services/voice/liveAudio');
-const { runVoiceTranscriptTurn } = require('../services/voice/turnRunner');
 
 const router = express.Router();
-const turnCoordinator = new TurnCoordinator();
 
 router.use(requireAuth);
 
-async function resolveCompletedVoiceSession(recordingManager, userId, sessionId) {
-  let session = recordingManager.getSession(userId, sessionId);
-  if (session.status === 'recording') {
-    session = recordingManager.finalizeSession(userId, sessionId, {
-      stopReason: 'voice_assistant',
-      autoProcess: false,
-      includeInsights: false,
-    });
-  }
-  if (session.status === 'processing') {
-    await recordingManager.processSession(userId, sessionId, {
-      includeInsights: false,
-    });
-    session = recordingManager.getSession(userId, sessionId);
-  }
-  if (session.status !== 'completed') {
-    throw new Error(`Recording session is not ready for assistant response (status: ${session.status}).`);
-  }
-  return session;
-}
-
-router.post('/respond', async (req, res) => {
-  try {
-    const userId = req.session.userId;
-    const recordingManager = req.app?.locals?.recordingManager;
-    const agentEngine = req.app?.locals?.agentEngine;
-    const memoryManager = req.app?.locals?.memoryManager;
-    if (!recordingManager || !agentEngine || !memoryManager) {
-      return res.status(500).json({ error: 'Voice assistant service is not initialized.' });
-    }
-
-    const sessionId = String(req.body?.sessionId || '').trim();
-    if (!sessionId) {
-      return res.status(400).json({ error: 'sessionId is required.' });
-    }
-
-    const voiceOptions = normalizeVoiceSynthesisOptions({
-      provider: req.body?.ttsProvider,
-      model: req.body?.ttsModel,
-      voice: req.body?.ttsVoice,
-    });
-    const promptHint = String(req.body?.promptHint || '').trim();
-    const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
-
-    let screenshotData = {};
-    if (req.body?.screenshotBase64 || req.body?.screenshotMimeType) {
-      if (!req.body?.screenshotBase64 || !req.body?.screenshotMimeType) {
-        return res.status(400).json({
-          error: 'Both screenshotBase64 and screenshotMimeType must be provided together.',
-        });
-      }
-
-      const mimeType = String(req.body.screenshotMimeType || '').trim().toLowerCase();
-      const allowedMimeTypes = new Set(['image/png', 'image/jpeg', 'image/jpg', 'image/webp']);
-      if (!allowedMimeTypes.has(mimeType)) {
-        return res.status(400).json({
-          error: `Invalid screenshot MIME type. Allowed types: ${Array.from(allowedMimeTypes).join(', ')}`,
-        });
-      }
-
-      const screenshotBase64 = String(req.body.screenshotBase64 || '').trim();
-      const base64Regex = /^[A-Za-z0-9+/]+={0,2}$/;
-      if (!base64Regex.test(screenshotBase64)) {
-        return res.status(400).json({ error: 'Invalid base64 format for screenshot.' });
-      }
-
-      const maxSizeBytes = 5 * 1024 * 1024;
-      const approximateSize = (screenshotBase64.length * 3) / 4;
-      if (approximateSize > maxSizeBytes) {
-        return res.status(400).json({
-          error: 'Screenshot size exceeds maximum allowed size of 5MB.',
-        });
-      }
-
-      screenshotData = {
-        screenshotBase64,
-        screenshotMimeType: mimeType,
-      };
-    }
-
-    const responsePayload = await turnCoordinator.run(sessionId, async () => {
-      const session = await resolveCompletedVoiceSession(
-        recordingManager,
-        userId,
-        sessionId,
-      );
-
-      const transcript = String(session.transcriptText || '').trim();
-      if (!transcript) {
-        throw new Error('Recording transcript is empty. Please retry transcription or record again.');
-      }
-
-      const turnResult = await runVoiceTranscriptTurn({
-        userId,
-        agentId,
-        transcript,
-        promptHint,
-        platform: 'voice_assistant',
-        metadata: {
-          recordingSessionId: sessionId,
-          ...screenshotData,
-        },
-        agentEngine,
-        memoryManager,
-        ttsProvider: voiceOptions.provider,
-        ttsModel: voiceOptions.model,
-        ttsVoice: voiceOptions.voice,
-      });
-
-      return {
-        session,
-        ...turnResult,
-      };
-    });
-
-    return res.json(responsePayload);
-  } catch (err) {
-    const message = sanitizeError(err);
-    const statusCode = /not ready|empty/i.test(message) ? 400 : 500;
-    return res.status(statusCode).json({ error: message });
-  }
-});
-
 router.post('/transcribe', async (req, res) => {
   try {
     const audioBase64 = String(req.body?.audioBase64 || '').trim();

package/server/services/account/erasure.js

@@ -60,9 +60,6 @@ function deleteChildRows(uid) {
     'DELETE FROM conversation_messages WHERE conversation_id IN (SELECT id FROM conversations WHERE user_id = ?)',
     'DELETE FROM agent_steps WHERE run_id IN (SELECT id FROM agent_runs WHERE user_id = ?)',
     'DELETE FROM ai_widget_snapshots WHERE widget_id IN (SELECT id FROM ai_widgets WHERE user_id = ?)',
-    'DELETE FROM recording_transcript_segments WHERE session_id IN (SELECT id FROM recording_sessions WHERE user_id = ?)',
-    'DELETE FROM recording_chunks WHERE source_id IN (SELECT s.id FROM recording_sources s JOIN recording_sessions rs ON s.session_id = rs.id WHERE rs.user_id = ?)',
-    'DELETE FROM recording_sources WHERE session_id IN (SELECT id FROM recording_sessions WHERE user_id = ?)',
     'DELETE FROM memory_source_links WHERE memory_id IN (SELECT id FROM memories WHERE user_id = ?)',
   ];
   for (const sql of childDeletes) {

package/server/services/ai/deliverables/artifact_helpers.js

@@ -124,7 +124,7 @@ const ARTIFACT_CONTAINER_KEYS = new Set([
 
 const CONTAINER_URL_KEYS = new Set(['url', 'urls', 'uri', 'uris', 'href', 'hrefs']);
 
-const EVIDENCE_RESULT_TOOLS = /^(execute_command|github_|list_|search_|read_|get_|find_|http_request|web_search|browser_get|browser_read|code_navigate|query_structured_data|memory_|session_search|recordings_|read_health_data)/;
+const EVIDENCE_RESULT_TOOLS = /^(execute_command|github_|list_|search_|read_|get_|find_|http_request|web_search|browser_get|browser_read|code_navigate|query_structured_data|memory_|session_search|read_health_data)/;
 
 function allowsGenericCandidateKeys(toolName = '') {
   return !EVIDENCE_RESULT_TOOLS.test(String(toolName || ''));

package/server/services/ai/loop/conversation_loop.js

@@ -440,7 +440,10 @@ async function getProviderForUser(userId, task = '', isSubagent = false, modelOv
 
   if (modelOverride && typeof modelOverride === 'string') {
     const requested = models.find((m) => m.id === modelOverride.trim());
-    if (requested && requested.available !== false && enabledIds.includes(requested.id)) {
+    // An explicit override (e.g. a failure fallback picked by getFailureFallbackModelId)
+    // may intentionally sit outside the user's enabled_models pool — that's the whole
+    // point when no in-pool cross-provider option exists. Only require availability.
+    if (requested && requested.available !== false) {
       selectedModelDef = requested;
       return {
         provider: createProviderInstance(selectedModelDef.provider, userId, providerConfig),
@@ -569,6 +572,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
   let failedStepCount = 0;
   let toolExecutions = [];
   let deliverableWorkflow = null;
+  let runTitle;
   const timelineService = app?.locals?.timelineService || null;
 
   const { releaseReservation } = enforceRateLimits(userId, {
@@ -638,7 +642,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     }
   };
 
-  const runTitle = generateTitle(userMessage);
+  runTitle = generateTitle(userMessage);
   const initialRunMetadata = buildInitialRunMetadata(options);
   db.prepare(`INSERT INTO agent_runs(
     id, user_id, agent_id, title, status, trigger_type, trigger_source, model, metadata_json

package/server/services/ai/loop/tool_dispatch.js

@@ -32,9 +32,6 @@ function isReadOnlyToolCall(toolCall) {
     'list_tasks',
     'list_skills',
     'list_subagents',
-    'recordings_list',
-    'recordings_get',
-    'recordings_search',
     'read_health_data',
   ]);
   if (name === 'http_request') {

package/server/services/ai/messagingFallback.js

@@ -88,7 +88,7 @@ function toolWorkDescription(toolName) {
   if (name === 'web_search' || name === 'http_request') return 'looked up supporting information';
   if (name.startsWith('browser_')) return 'checked the browser state';
   if (name.startsWith('android_')) return 'checked the Android state';
-  if (name === 'read_health_data' || name.startsWith('recordings_')) return 'checked stored data';
+  if (name === 'read_health_data') return 'checked stored data';
   return '';
 }
 

package/server/services/ai/settings.js

@@ -152,11 +152,6 @@ function createDefaultAiSettings() {
     subagent_max_children_per_run: 10,
     assistant_behavior_notes: '',
     auto_skill_learning: false,
-    auto_recording_insights: true,
-    default_recording_transcription_provider: 'deepgram',
-    default_recording_transcription_model: 'nova-3',
-    default_recording_summary_provider: 'auto',
-    default_recording_summary_model: 'auto',
     fallback_model_id: 'gpt-5-nano',
     smarter_model_selector: true,
     enabled_models: [],
@@ -343,7 +338,6 @@ function getAiSettings(userId, agentId = null) {
     ? settings.assistant_behavior_notes
     : DEFAULT_AI_SETTINGS.assistant_behavior_notes;
   settings.auto_skill_learning = settings.auto_skill_learning !== false && settings.auto_skill_learning !== 'false';
-  settings.auto_recording_insights = settings.auto_recording_insights !== false && settings.auto_recording_insights !== 'false';
   settings.smarter_model_selector = settings.smarter_model_selector !== false && settings.smarter_model_selector !== 'false';
   settings.fallback_model_id = typeof settings.fallback_model_id === 'string' ? settings.fallback_model_id : DEFAULT_AI_SETTINGS.fallback_model_id;
   settings.enabled_models = Array.isArray(settings.enabled_models) ? settings.enabled_models : DEFAULT_AI_SETTINGS.enabled_models;

package/server/services/ai/toolEvidence.js

@@ -29,7 +29,7 @@ const EVIDENCE_SOURCE_RULES = [
   { source: 'skills', match: (name) => name.includes('skill') },
   { source: 'tasks', match: (name) => name === 'create_task' || name === 'update_task' || name === 'delete_task' || name === 'list_tasks' || name.includes('widget') },
   { source: 'messaging', match: (name) => name === 'send_message' || name === 'make_call' },
-  { source: 'data', match: (name) => name.startsWith('recordings_') || name === 'read_health_data' },
+  { source: 'data', match: (name) => name === 'read_health_data' },
   { source: 'vision', match: (name) => name === 'analyze_image' },
   { source: 'subagent', match: (name) => name.includes('subagent') },
 ];
@@ -55,9 +55,6 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
     'memory_recall',
     'analyze_image',
     'read_health_data',
-    'recordings_list',
-    'recordings_get',
-    'recordings_search',
     'list_tasks',
     'wait_subagent',
   ]);

package/server/services/ai/tools.js

@@ -25,46 +25,6 @@ function compactText(text, maxChars = 120) {
     return `${trimmed.trim()}...`;
 }
 
-function compactTranscript(text, maxChars = 1200) {
-    const str = String(text || '').replace(/\s+/g, ' ').trim();
-    if (!str) return '';
-    if (str.length <= maxChars) return str;
-    return `${str.slice(0, maxChars).trim()}...`;
-}
-
-function compactRecordingSession(session, options = {}) {
-    const includeTranscript = options.includeTranscript === true;
-    return {
-        id: session.id,
-        title: session.title,
-        platform: session.platform,
-        status: session.status,
-        startedAt: session.startedAt,
-        endedAt: session.endedAt,
-        durationMs: Number(session.durationMs) || 0,
-        sourceCount: Number(session.sourceCount) || 0,
-        transcriptLanguage: session.transcriptLanguage || null,
-        transcriptModel: session.transcriptModel || null,
-        hasTranscript: !!String(session.transcriptText || '').trim(),
-        transcriptPreview: includeTranscript ? compactTranscript(session.transcriptText || '', 1200) : undefined,
-        structuredContent: session.structuredContent || null,
-        lastError: session.lastError || null,
-    };
-}
-
-function mapRecordingSource(source) {
-    return {
-        id: source.id,
-        sourceKey: source.sourceKey,
-        sourceKind: source.sourceKind,
-        mediaKind: source.mediaKind,
-        mimeType: source.mimeType,
-        status: source.status,
-        chunkCount: source.chunkCount,
-        durationMs: source.durationMs,
-    };
-}
-
 function compactToolDefinition(tool, options = {}) {
     const compact = {
         name: tool.name,
@@ -1464,46 +1424,6 @@ function getAvailableTools(app, options = {}) {
                 }
             }
         },
-        {
-            name: 'recordings_list',
-            description: 'List the user\'s recording sessions with status, timing, and transcript availability.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    limit: { type: 'number', description: 'Maximum number of sessions to return (default 12, max 50).' },
-                    status: { type: 'string', description: 'Optional status filter: recording, processing, completed, failed, cancelled.' },
-                    platform: { type: 'string', description: 'Optional platform filter: wearable, web, android, unknown.' },
-                    include_transcript_previews: { type: 'boolean', description: 'Include short transcript previews (default false).' }
-                }
-            }
-        },
-        {
-            name: 'recordings_get',
-            description: 'Get one recording session in detail, including transcript text, sources, and optional transcript segments.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string', description: 'Recording session ID.' },
-                    include_segments: { type: 'boolean', description: 'Include transcript segments (default true).' },
-                    segment_limit: { type: 'number', description: 'Maximum number of transcript segments to return (default 80, max 300).' },
-                    include_full_transcript: { type: 'boolean', description: 'Include full transcript text (default true). If false, returns only preview.' }
-                },
-                required: ['session_id']
-            }
-        },
-        {
-            name: 'recordings_search',
-            description: 'Search recording transcripts by keyword and return matching snippets with session references.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string', description: 'Search query for transcript text.' },
-                    limit: { type: 'number', description: 'Maximum number of matches to return (default 20, max 100).' },
-                    status: { type: 'string', description: 'Optional status filter for sessions.' }
-                },
-                required: ['query']
-            }
-        },
         {
             name: 'list_chats',
             description: 'List all known groups and conversations across connected messaging platforms. Use this when the user doesn\'t know the exact group name or chat ID — it returns every chat that has ever sent a message, with platform, chat ID, display name, and whether it\'s a group or DM.',
@@ -1745,7 +1665,6 @@ async function executeTool(toolName, args, context, engine) {
     const integrations = () => app?.locals?.integrationManager || null;
     const sk = () => app?.locals?.skillRunner || engine.skillRunner;
     const taskRuntime = () => app?.locals?.taskRuntime || engine.taskRuntime;
-    const rec = () => app?.locals?.recordingManager || null;
     const socialVideo = () => app?.locals?.socialVideoService || null;
     const socialReach = () => app?.locals?.socialReachService || null;
     const widgets = () => app?.locals?.widgetService || null;
@@ -1848,7 +1767,6 @@ async function executeTool(toolName, args, context, engine) {
         case 'browser_extract': {
             const { provider, backend } = await bc();
             if (!provider) return { error: 'Browser controller not available' };
-            if (!args.selector) return { error: 'browser_extract requires a "selector" argument' };
             return { ...await provider.extract(args.selector, args.attribute, args.all), backend };
         }
 
@@ -2182,158 +2100,6 @@ async function executeTool(toolName, args, context, engine) {
             return result;
         }
 
-        case 'recordings_list': {
-            const manager = rec();
-            if (!manager) return { error: 'Recording manager not available' };
-
-            const limit = Math.max(1, Math.min(Number(args.limit) || 12, 50));
-            const includeTranscript = args.include_transcript_previews === true;
-            const statusFilter = typeof args.status === 'string' ? args.status.trim().toLowerCase() : null;
-            const platformFilter = typeof args.platform === 'string' ? args.platform.trim().toLowerCase() : null;
-
-            let sessions = manager.listSessions(userId, { limit: Math.max(limit * 3, limit) });
-
-            if (statusFilter) {
-                sessions = sessions.filter((session) => String(session.status || '').toLowerCase() === statusFilter);
-            }
-            if (platformFilter) {
-                sessions = sessions.filter((session) => String(session.platform || '').toLowerCase() === platformFilter);
-            }
-
-            const filtered = sessions.slice(0, limit).map((session) => compactRecordingSession(session, {
-                includeTranscript,
-            }));
-
-            return {
-                count: filtered.length,
-                filters: {
-                    status: statusFilter || null,
-                    platform: platformFilter || null,
-                },
-                sessions: filtered,
-            };
-        }
-
-        case 'recordings_get': {
-            const manager = rec();
-            if (!manager) return { error: 'Recording manager not available' };
-
-            const sessionId = `${args.session_id || ''}`.trim();
-            if (!sessionId) return { error: 'session_id is required' };
-
-            try {
-                const session = manager.getSession(userId, sessionId);
-                const includeSegments = args.include_segments !== false;
-                const includeFullTranscript = args.include_full_transcript !== false;
-                const segmentLimit = Math.max(1, Math.min(Number(args.segment_limit) || 80, 300));
-
-                const result = {
-                    session: compactRecordingSession(session, {
-                        includeTranscript: !includeFullTranscript,
-                    }),
-                    transcriptText: includeFullTranscript
-                        ? String(session.transcriptText || '')
-                        : compactTranscript(session.transcriptText || '', 1600),
-                    sources: (Array.isArray(session.sources) ? session.sources : []).map(mapRecordingSource),
-                    segmentCount: Array.isArray(session.transcriptSegments) ? session.transcriptSegments.length : 0,
-                };
-
-                if (includeSegments) {
-                    const segments = Array.isArray(session.transcriptSegments) ? session.transcriptSegments : [];
-                    result.segments = segments.slice(0, segmentLimit).map((segment) => ({
-                        id: segment.id,
-                        speaker: segment.speaker,
-                        sourceKey: segment.sourceKey,
-                        startMs: segment.startMs,
-                        endMs: segment.endMs,
-                        confidence: segment.confidence,
-                        text: segment.text,
-                    }));
-                    result.segmentsTruncated = segments.length > segmentLimit;
-                }
-
-                return result;
-            } catch (err) {
-                return { error: err.message };
-            }
-        }
-
-        case 'recordings_search': {
-            const query = `${args.query || ''}`.trim();
-            if (!query) return { error: 'query is required' };
-
-            const limit = Math.max(1, Math.min(Number(args.limit) || 20, 100));
-            const statusFilter = typeof args.status === 'string' ? args.status.trim().toLowerCase() : null;
-            const like = `%${query.replace(/[%_]/g, (m) => `\\${m}`)}%`;
-
-            const statusClause = statusFilter ? 'AND s.status = ?' : '';
-            const params = statusFilter
-                ? [userId, like, like, statusFilter, limit]
-                : [userId, like, like, limit];
-
-            const rows = db.prepare(`
-              SELECT
-                s.id AS session_id,
-                s.title,
-                s.platform,
-                s.status,
-                s.started_at,
-                s.ended_at,
-                s.duration_ms,
-                seg.id AS segment_id,
-                seg.start_ms,
-                seg.end_ms,
-                seg.speaker,
-                seg.text AS segment_text,
-                s.transcript_text
-              FROM recording_sessions s
-              LEFT JOIN recording_transcript_segments seg
-                ON seg.session_id = s.id
-              WHERE s.user_id = ?
-                AND (
-                  LOWER(COALESCE(seg.text, '')) LIKE LOWER(?) ESCAPE '\\'
-                  OR LOWER(COALESCE(s.transcript_text, '')) LIKE LOWER(?) ESCAPE '\\'
-                )
-                ${statusClause}
-              ORDER BY datetime(s.created_at) DESC, seg.start_ms ASC, seg.id ASC
-              LIMIT ?
-            `).all(...params);
-
-            const matches = rows.map((row) => {
-                const baseText = row.segment_text || row.transcript_text || '';
-                const idx = baseText.toLowerCase().indexOf(query.toLowerCase());
-                let snippet = baseText;
-                if (idx >= 0) {
-                    const left = Math.max(0, idx - 120);
-                    const right = Math.min(baseText.length, idx + query.length + 120);
-                    snippet = baseText.slice(left, right);
-                    if (left > 0) snippet = `...${snippet}`;
-                    if (right < baseText.length) snippet = `${snippet}...`;
-                }
-
-                return {
-                    sessionId: row.session_id,
-                    title: row.title,
-                    platform: row.platform,
-                    status: row.status,
-                    startedAt: row.started_at,
-                    endedAt: row.ended_at,
-                    durationMs: Number(row.duration_ms) || 0,
-                    segmentId: row.segment_id == null ? null : Number(row.segment_id),
-                    startMs: row.start_ms == null ? null : Number(row.start_ms),
-                    endMs: row.end_ms == null ? null : Number(row.end_ms),
-                    speaker: row.speaker || null,
-                    snippet: compactTranscript(snippet, 400),
-                };
-            });
-
-            return {
-                query,
-                count: matches.length,
-                matches,
-            };
-        }
-
         case 'list_chats': {
             const listPlatform = typeof args.platform === 'string' ? args.platform.trim().toLowerCase() : null;
 

package/server/services/desktop/auth.js

@@ -29,9 +29,6 @@ function normalizeDesktopHello(message) {
       : {},
     displays: Array.isArray(device.displays) ? device.displays : [],
     activeDisplayId: String(device.activeDisplayId || '').trim(),
-    passiveHistoryEnabled: device.passiveHistoryEnabled === true,
-    passiveHistoryLastUploadedAt: String(device.passiveHistoryLastUploadedAt || '').trim(),
-    passiveHistoryLastError: String(device.passiveHistoryLastError || '').trim(),
     metadata: device.metadata && typeof device.metadata === 'object'
       ? device.metadata
       : {},