chore(hf): sync HomePilot to HF Space

.gitattributes

@@ -1,9 +1,9 @@
 *.hpersona filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.svg filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
-*.svg filter=lfs diff=lfs merge=lfs -text
-*.woff2 filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
 *.woff filter=lfs diff=lfs merge=lfs -text
+*.woff2 filter=lfs diff=lfs merge=lfs -text
 *.ico filter=lfs diff=lfs merge=lfs -text

frontend/.cache-bust

@@ -1 +1 @@
-1789232245
+1789232300

frontend/index.html

@@ -18,6 +18,9 @@
     <!-- MS29. The recorder. Inert until `hpMeetingSense.start()` is called, so loading it
          costs a parse and changes nothing until somebody presses record. -->
     <script src="/js/homepilot-meetingsense.js"></script>
+    <!-- Media routing owns browser device acquisition so preflight capture switches and the
+         Audio & Video microphone preference are authoritative for MeetingSense. -->
+    <script src="/js/homepilot-meetingsense-media.js"></script>
     <script type="module" src="/src/main.tsx"></script>
   </body>
 </html>

frontend/public/js/homepilot-meetingsense-media.js

@@ -0,0 +1,237 @@
+/**
+ * MeetingSense media-routing contract.
+ *
+ * Loaded immediately after homepilot-meetingsense.js. It keeps the recorder's proven audio
+ * graph/socket implementation, but owns device acquisition so the meeting preflight and the
+ * Audio & Video settings are actually authoritative.
+ */
+(function () {
+    'use strict';
+
+    var recorder = window.hpMeetingSense;
+    if (!recorder || recorder.__homepilotMediaRoutingV1) return;
+
+    var STORAGE_KEY = 'homepilot_media_preferences_v1';
+    var originalStartWithStreams =
+        typeof recorder.startWithStreams === 'function' ? recorder.startWithStreams.bind(recorder) : null;
+    var originalMediaClock =
+        typeof recorder._mediaClockMs === 'function' ? recorder._mediaClockMs.bind(recorder) : null;
+
+    function stopStream(stream) {
+        if (!stream || !stream.getTracks) return;
+        stream.getTracks().forEach(function (track) {
+            try { track.stop(); } catch (_) { /* already stopped */ }
+        });
+    }
+
+    function readPreferences() {
+        var raw = {};
+        try {
+            raw = JSON.parse(window.localStorage.getItem(STORAGE_KEY) || '{}') || {};
+        } catch (_) {
+            raw = {};
+        }
+        return {
+            microphoneDeviceId: typeof raw.microphoneDeviceId === 'string' ? raw.microphoneDeviceId : '',
+            echoCancellation: typeof raw.echoCancellation === 'boolean' ? raw.echoCancellation : true,
+            noiseSuppression: typeof raw.noiseSuppression === 'boolean' ? raw.noiseSuppression : true,
+            autoGainControl: typeof raw.autoGainControl === 'boolean' ? raw.autoGainControl : true,
+        };
+    }
+
+    function capturePlan(options) {
+        var opts = options || {};
+        return {
+            meetingAudio: opts.audio !== false,
+            microphone: opts.mic !== false,
+            screen: !!opts.watch,
+        };
+    }
+
+    function microphoneConstraints(options) {
+        var opts = options || {};
+        var saved = readPreferences();
+        var constraints = {
+            echoCancellation:
+                typeof opts.echoCancellation === 'boolean' ? opts.echoCancellation : saved.echoCancellation,
+            noiseSuppression:
+                typeof opts.noiseSuppression === 'boolean' ? opts.noiseSuppression : saved.noiseSuppression,
+            autoGainControl:
+                typeof opts.autoGainControl === 'boolean' ? opts.autoGainControl : saved.autoGainControl,
+        };
+        var deviceId =
+            typeof opts.microphoneDeviceId === 'string' ? opts.microphoneDeviceId : saved.microphoneDeviceId;
+        if (deviceId) constraints.deviceId = { exact: deviceId };
+        return constraints;
+    }
+
+    function errorText(source, error) {
+        var name = error && error.name ? String(error.name) : 'CaptureError';
+        var message = error && error.message ? String(error.message) : '';
+        var suffix = message && message !== name ? ': ' + message : '';
+        return source + ' could not be opened (' + name + ')' + suffix;
+    }
+
+    function trackLabel(stream) {
+        try {
+            if (recorder.internals && typeof recorder.internals.trackLabel === 'function') {
+                return recorder.internals.trackLabel(stream);
+            }
+            var track = stream && stream.getVideoTracks && stream.getVideoTracks()[0];
+            return (track && track.label ? track.label : '').trim();
+        } catch (_) {
+            return '';
+        }
+    }
+
+    async function acquire(options) {
+        var opts = options || {};
+        var plan = capturePlan(opts);
+        var display = null;
+        var mic = null;
+
+        if ((plan.meetingAudio || plan.screen) &&
+            (!navigator.mediaDevices || typeof navigator.mediaDevices.getDisplayMedia !== 'function')) {
+            return { ok: false, error: 'Screen / meeting-audio capture is not supported by this browser.' };
+        }
+        if (plan.microphone &&
+            (!navigator.mediaDevices || typeof navigator.mediaDevices.getUserMedia !== 'function')) {
+            return { ok: false, error: 'Microphone capture is not supported by this browser.' };
+        }
+
+        if (plan.meetingAudio || plan.screen) {
+            try {
+                display = await navigator.mediaDevices.getDisplayMedia({
+                    video: true,
+                    audio: plan.meetingAudio,
+                });
+            } catch (error) {
+                return {
+                    ok: false,
+                    error: errorText(plan.meetingAudio ? 'Meeting audio / screen share' : 'Screen share', error),
+                };
+            }
+
+            if (plan.meetingAudio && !display.getAudioTracks().length) {
+                stopStream(display);
+                return {
+                    ok: false,
+                    error: 'Meeting audio was enabled, but the shared source has no audio track. Share a browser tab and enable “Share audio”, or turn Meeting audio off.',
+                };
+            }
+        }
+
+        if (plan.microphone) {
+            try {
+                mic = await navigator.mediaDevices.getUserMedia({
+                    audio: microphoneConstraints(opts),
+                    video: false,
+                });
+            } catch (error) {
+                stopStream(display);
+                return { ok: false, error: errorText('Selected microphone', error) };
+            }
+        }
+
+        return { ok: true, display: display, mic: mic, plan: plan };
+    }
+
+    async function startScreenOnly(screen, options) {
+        var opts = options || {};
+        if (!screen || !screen.getVideoTracks || !screen.getVideoTracks().length) {
+            stopStream(screen);
+            return { ok: false, error: 'Screen & slides is enabled, but no live screen track was returned.' };
+        }
+        if (typeof recorder._connect !== 'function' || typeof recorder._startWatching !== 'function') {
+            stopStream(screen);
+            return { ok: false, error: 'This MeetingSense build cannot start a screen-only meeting.' };
+        }
+
+        recorder._windowTitle = opts.windowTitle || trackLabel(screen);
+        recorder.audioMode = 'none';
+        recorder._channels = 1;
+        recorder._opts = opts;
+        recorder._elapsedSamples = 0;
+        recorder._screenOnlyStartedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        recorder._tracks = recorder._tracks || [];
+        screen.getTracks().forEach(function (track) {
+            recorder._tracks.push(track);
+        });
+
+        var opened = await recorder._connect(opts);
+        if (!opened || !opened.ok) {
+            if (typeof recorder._teardown === 'function') recorder._teardown();
+            else stopStream(screen);
+            return opened || { ok: false, error: 'The meeting session could not start.' };
+        }
+
+        recorder.recording = true;
+        var watching = recorder._startWatching(screen, opts);
+        return {
+            ok: true,
+            meetingId: recorder.meetingId,
+            audioMode: 'none',
+            watching: watching,
+        };
+    }
+
+    // A screen-only meeting has no audio sample clock. Keep slide timestamps meaningful by
+    // using elapsed wall time only while audioMode is explicitly `none`.
+    if (originalMediaClock) {
+        recorder._mediaClockMs = function () {
+            if (this.audioMode === 'none' && this._screenOnlyStartedAt != null) {
+                var now = typeof performance !== 'undefined' ? performance.now() : Date.now();
+                return Math.max(0, Math.round(now - this._screenOnlyStartedAt));
+            }
+            return originalMediaClock();
+        };
+    }
+
+    recorder.start = async function (options) {
+        var opts = options || {};
+        if (this.recording) return { ok: false, error: 'already recording' };
+        if (!opts.conversationId) return { ok: false, error: 'conversationId is required' };
+
+        var acquired = await acquire(opts);
+        if (!acquired.ok) return acquired;
+
+        var display = acquired.display;
+        var mic = acquired.mic;
+        var plan = acquired.plan;
+        var hasSystemAudio = !!(display && display.getAudioTracks && display.getAudioTracks().length);
+
+        if (!hasSystemAudio && !mic) {
+            if (plan.screen && display) return startScreenOnly(display, opts);
+            stopStream(display);
+            return {
+                ok: false,
+                error: 'Choose at least one capture source: Meeting audio, My microphone, or Screen & slides.',
+                audioMode: 'none',
+            };
+        }
+
+        if (!originalStartWithStreams) {
+            stopStream(display);
+            stopStream(mic);
+            return { ok: false, error: 'This MeetingSense build cannot accept routed media streams.' };
+        }
+
+        var result = await originalStartWithStreams({ screen: display, mic: mic }, opts);
+        if (!result || !result.ok) {
+            // startWithStreams normally tears down what it accepted on failure. This is a
+            // second idempotent stop so an older recorder cannot leave a granted device open.
+            stopStream(display);
+            stopStream(mic);
+        }
+        return result;
+    };
+
+    recorder.__homepilotMediaRoutingV1 = true;
+    recorder.mediaRouting = {
+        capturePlan: capturePlan,
+        microphoneConstraints: microphoneConstraints,
+        readPreferences: readPreferences,
+        errorText: errorText,
+        acquire: acquire,
+    };
+})();

frontend/src/test/meetingsenseMediaRouting.test.js

@@ -0,0 +1,204 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
+const SHIPPED = resolve(ROOT, 'frontend/public/js/homepilot-meetingsense-media.js');
+const MIRROR = resolve(ROOT, 'community/addons/meetingsense/homepilot-meetingsense-media.js');
+const INDEX = resolve(ROOT, 'frontend/index.html');
+const SOURCE = readFileSync(SHIPPED, 'utf8');
+
+function fakeTrack(kind, label = '') {
+    return { kind, label, readyState: 'live', stop: vi.fn() };
+}
+
+function fakeStream({ audio = 0, video = 0 } = {}) {
+    const audioTracks = Array.from({ length: audio }, () => fakeTrack('audio'));
+    const videoTracks = Array.from({ length: video }, () => fakeTrack('video', 'Shared screen'));
+    return {
+        getAudioTracks: () => audioTracks,
+        getVideoTracks: () => videoTracks,
+        getTracks: () => [...audioTracks, ...videoTracks],
+    };
+}
+
+function install({ displayStream = fakeStream({ audio: 1, video: 1 }), micStream = fakeStream({ audio: 1 }) } = {}) {
+    const recorder = {
+        recording: false,
+        meetingId: 'meeting-1',
+        audioMode: 'none',
+        _elapsedSamples: 0,
+        _tracks: [],
+        _mediaClockMs: vi.fn(() => 0),
+        _connect: vi.fn(async () => ({ ok: true })),
+        _startWatching: vi.fn(() => true),
+        _teardown: vi.fn(),
+        startWithStreams: vi.fn(async () => ({ ok: true, meetingId: 'meeting-1', audioMode: 'system+mic' })),
+        internals: { trackLabel: vi.fn(() => 'Shared screen') },
+    };
+    const getDisplayMedia = vi.fn(async () => displayStream);
+    const getUserMedia = vi.fn(async () => micStream);
+    Object.defineProperty(navigator, 'mediaDevices', {
+        configurable: true,
+        value: { getDisplayMedia, getUserMedia },
+    });
+    window.hpMeetingSense = recorder;
+    // eslint-disable-next-line no-new-func
+    new Function(SOURCE).call(window);
+    return { recorder, getDisplayMedia, getUserMedia, displayStream, micStream };
+}
+
+beforeEach(() => {
+    localStorage.clear();
+    delete window.hpMeetingSense;
+});
+
+describe('MeetingSense media routing', () => {
+    it('ships the same routing contract in public and community addon copies', () => {
+        const digest = (path) => createHash('sha256').update(readFileSync(path)).digest('hex');
+        expect(digest(MIRROR)).toBe(digest(SHIPPED));
+    });
+
+    it('loads the routing contract after the recorder and before React', () => {
+        const html = readFileSync(INDEX, 'utf8');
+        const recorderAt = html.indexOf('/js/homepilot-meetingsense.js');
+        const routingAt = html.indexOf('/js/homepilot-meetingsense-media.js');
+        const reactAt = html.indexOf('/src/main.tsx');
+        expect(recorderAt).toBeGreaterThan(-1);
+        expect(routingAt).toBeGreaterThan(recorderAt);
+        expect(reactAt).toBeGreaterThan(routingAt);
+    });
+
+    it('does not open a microphone when My microphone is off', async () => {
+        const { recorder, getDisplayMedia, getUserMedia } = install();
+        const result = await window.hpMeetingSense.start({
+            conversationId: 'chat-1',
+            audio: true,
+            mic: false,
+            watch: false,
+        });
+
+        expect(result.ok).toBe(true);
+        expect(getDisplayMedia).toHaveBeenCalledWith({ video: true, audio: true });
+        expect(getUserMedia).not.toHaveBeenCalled();
+        expect(recorder.startWithStreams).toHaveBeenCalledTimes(1);
+        expect(recorder.startWithStreams.mock.calls[0][0].mic).toBe(null);
+    });
+
+    it('uses the selected microphone and saved DSP settings for mic-only meetings', async () => {
+        localStorage.setItem('homepilot_media_preferences_v1', JSON.stringify({
+            microphoneDeviceId: 'usb-mic-42',
+            echoCancellation: false,
+            noiseSuppression: true,
+            autoGainControl: false,
+        }));
+        const { recorder, getDisplayMedia, getUserMedia } = install();
+
+        const result = await window.hpMeetingSense.start({
+            conversationId: 'chat-1',
+            audio: false,
+            mic: true,
+            watch: false,
+        });
+
+        expect(result.ok).toBe(true);
+        expect(getDisplayMedia).not.toHaveBeenCalled();
+        expect(getUserMedia).toHaveBeenCalledWith({
+            video: false,
+            audio: {
+                deviceId: { exact: 'usb-mic-42' },
+                echoCancellation: false,
+                noiseSuppression: true,
+                autoGainControl: false,
+            },
+        });
+        expect(recorder.startWithStreams).toHaveBeenCalledTimes(1);
+    });
+
+    it('requests screen video without display audio when Meeting audio is off', async () => {
+        const display = fakeStream({ video: 1 });
+        const { getDisplayMedia } = install({ displayStream: display });
+
+        const result = await window.hpMeetingSense.start({
+            conversationId: 'chat-1',
+            audio: false,
+            mic: true,
+            watch: true,
+        });
+
+        expect(result.ok).toBe(true);
+        expect(getDisplayMedia).toHaveBeenCalledWith({ video: true, audio: false });
+    });
+
+    it('starts a screen-only meeting when both audio sources are off', async () => {
+        const display = fakeStream({ video: 1 });
+        const { recorder, getDisplayMedia, getUserMedia } = install({ displayStream: display });
+
+        const result = await window.hpMeetingSense.start({
+            conversationId: 'chat-1',
+            audio: false,
+            mic: false,
+            watch: true,
+        });
+
+        expect(result).toMatchObject({ ok: true, audioMode: 'none', watching: true });
+        expect(getDisplayMedia).toHaveBeenCalledWith({ video: true, audio: false });
+        expect(getUserMedia).not.toHaveBeenCalled();
+        expect(recorder.startWithStreams).not.toHaveBeenCalled();
+        expect(recorder._connect).toHaveBeenCalledTimes(1);
+        expect(recorder._startWatching).toHaveBeenCalledWith(display, expect.objectContaining({ watch: true }));
+    });
+
+    it('opens no browser capture when every source is off', async () => {
+        const { getDisplayMedia, getUserMedia } = install();
+        const result = await window.hpMeetingSense.start({
+            conversationId: 'chat-1',
+            audio: false,
+            mic: false,
+            watch: false,
+        });
+
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Choose at least one capture source');
+        expect(getDisplayMedia).not.toHaveBeenCalled();
+        expect(getUserMedia).not.toHaveBeenCalled();
+    });
+
+    it('reports the real microphone error instead of silently continuing', async () => {
+        const display = fakeStream({ audio: 1, video: 1 });
+        const { getUserMedia } = install({ displayStream: display });
+        const error = new Error('device is already busy');
+        error.name = 'NotReadableError';
+        getUserMedia.mockRejectedValueOnce(error);
+
+        const result = await window.hpMeetingSense.start({
+            conversationId: 'chat-1',
+            audio: true,
+            mic: true,
+            watch: true,
+        });
+
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Selected microphone could not be opened (NotReadableError)');
+        display.getTracks().forEach((track) => expect(track.stop).toHaveBeenCalledTimes(1));
+    });
+
+    it('fails clearly when Meeting audio was requested but the chosen share has no audio track', async () => {
+        const display = fakeStream({ video: 1 });
+        const { getUserMedia } = install({ displayStream: display });
+
+        const result = await window.hpMeetingSense.start({
+            conversationId: 'chat-1',
+            audio: true,
+            mic: true,
+            watch: true,
+        });
+
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('shared source has no audio track');
+        expect(getUserMedia).not.toHaveBeenCalled();
+        display.getTracks().forEach((track) => expect(track.stop).toHaveBeenCalledTimes(1));
+    });
+});

frontend/src/ui/components/AudioVideoSettings.tsx

@@ -37,6 +37,12 @@ type SinkAudioContext = AudioContext & {
   setSinkId?: (sinkId: string) => Promise<void>;
 };
 
+type AudioTrackSettings = MediaTrackSettings & {
+  echoCancellation?: boolean;
+  noiseSuppression?: boolean;
+  autoGainControl?: boolean;
+};
+
 function Switch({ checked, label, onChange, disabled = false }: {
   checked: boolean;
   label: string;
@@ -129,37 +135,40 @@ function TestBadge({ state, idleLabel, runningLabel = 'Testing…', okLabel = 'W
   );
 }
 
-function friendlyError(error: unknown): string {
+function friendlyError(error: unknown, subject = 'device'): string {
   const err = error as { name?: string; message?: string } | null;
   if (err?.name === 'NotAllowedError' || err?.name === 'PermissionDeniedError') {
-    return 'Permission was blocked. Allow camera/microphone access in your browser, then try again.';
+    return `${subject} permission was blocked. Allow it in your browser, then try again.`;
   }
   if (err?.name === 'NotFoundError' || err?.name === 'DevicesNotFoundError') {
-    return 'The selected device is no longer available. Choose another device or System default.';
+    return `The selected ${subject.toLowerCase()} is no longer available. Choose another device or System default.`;
   }
   if (err?.name === 'OverconstrainedError') {
-    return 'The selected device cannot satisfy this configuration. Choose another device.';
+    return `The selected ${subject.toLowerCase()} cannot satisfy this configuration. Choose another device.`;
   }
   if (err?.name === 'NotReadableError' || err?.name === 'TrackStartError') {
-    return 'The device is busy in another app or could not be started.';
+    return `The ${subject.toLowerCase()} is busy in another app or could not be started.`;
   }
-  return err?.message || 'The media test could not start.';
+  return err?.message || `The ${subject.toLowerCase()} test could not start.`;
 }
 
 export default function AudioVideoSettings() {
   const [preferences, setPreferences] = useState<MediaPreferences>(() => getMediaPreferences());
   const [devices, setDevices] = useState<MediaDeviceInfo[]>([]);
   const [deviceError, setDeviceError] = useState<string | null>(null);
-  const [previewState, setPreviewState] = useState<TestState>('idle');
+  const [cameraState, setCameraState] = useState<TestState>('idle');
+  const [microphoneState, setMicrophoneState] = useState<TestState>('idle');
   const [speakerState, setSpeakerState] = useState<TestState>('idle');
   const [screenState, setScreenState] = useState<TestState>('idle');
-  const [previewMessage, setPreviewMessage] = useState<string | null>(null);
+  const [cameraMessage, setCameraMessage] = useState<string | null>(null);
+  const [microphoneMessage, setMicrophoneMessage] = useState<string | null>(null);
   const [speakerMessage, setSpeakerMessage] = useState<string | null>(null);
   const [screenMessage, setScreenMessage] = useState<string | null>(null);
   const [micLevel, setMicLevel] = useState(0);
 
   const videoRef = useRef<HTMLVideoElement | null>(null);
-  const streamRef = useRef<MediaStream | null>(null);
+  const cameraStreamRef = useRef<MediaStream | null>(null);
+  const microphoneStreamRef = useRef<MediaStream | null>(null);
   const audioContextRef = useRef<AudioContext | null>(null);
   const animationRef = useRef<number>(0);
 
@@ -178,12 +187,17 @@ export default function AudioVideoSettings() {
   const speakers = devices.filter((device) => device.kind === 'audiooutput');
 
   const persist = useCallback((patch: Partial<MediaPreferences>) => {
-    setPreferences((current) => {
-      const next = setMediaPreferences({ ...current, ...patch });
-      return next;
-    });
-    if (streamRef.current) {
-      setPreviewMessage('Settings changed. Restart the camera & microphone test to verify the new source.');
+    setPreferences((current) => setMediaPreferences({ ...current, ...patch }));
+
+    if (cameraStreamRef.current && Object.prototype.hasOwnProperty.call(patch, 'cameraDeviceId')) {
+      setCameraMessage('Camera changed. Restart the camera test to verify the new source.');
+    }
+    if (
+      microphoneStreamRef.current &&
+      ['microphoneDeviceId', 'echoCancellation', 'noiseSuppression', 'autoGainControl']
+        .some((key) => Object.prototype.hasOwnProperty.call(patch, key))
+    ) {
+      setMicrophoneMessage('Microphone settings changed. Restart the microphone test to verify them.');
     }
   }, []);
 
@@ -193,26 +207,42 @@ export default function AudioVideoSettings() {
       setDeviceError(null);
       setDevices(await navigator.mediaDevices.enumerateDevices());
     } catch (error) {
-      setDeviceError(friendlyError(error));
+      setDeviceError(friendlyError(error, 'Device discovery'));
     }
   }, []);
 
-  const stopPreview = useCallback(() => {
+  const releaseCamera = useCallback(() => {
+    cameraStreamRef.current?.getTracks().forEach((track) => track.stop());
+    cameraStreamRef.current = null;
+    if (videoRef.current) videoRef.current.srcObject = null;
+  }, []);
+
+  const releaseMicrophone = useCallback(() => {
     if (animationRef.current) {
       cancelAnimationFrame(animationRef.current);
       animationRef.current = 0;
     }
-    streamRef.current?.getTracks().forEach((track) => track.stop());
-    streamRef.current = null;
-    if (videoRef.current) videoRef.current.srcObject = null;
+    microphoneStreamRef.current?.getTracks().forEach((track) => track.stop());
+    microphoneStreamRef.current = null;
     if (audioContextRef.current && audioContextRef.current.state !== 'closed') {
       audioContextRef.current.close().catch(() => {});
     }
     audioContextRef.current = null;
     setMicLevel(0);
-    setPreviewState('idle');
   }, []);
 
+  const stopCamera = useCallback(() => {
+    releaseCamera();
+    setCameraState('idle');
+    setCameraMessage('Camera test stopped.');
+  }, [releaseCamera]);
+
+  const stopMicrophone = useCallback(() => {
+    releaseMicrophone();
+    setMicrophoneState('idle');
+    setMicrophoneMessage('Microphone test stopped.');
+  }, [releaseMicrophone]);
+
   useEffect(() => {
     if (!mediaSupported) return;
     void refreshDevices();
@@ -220,28 +250,58 @@ export default function AudioVideoSettings() {
     navigator.mediaDevices.addEventListener?.('devicechange', onDeviceChange);
     return () => {
       navigator.mediaDevices.removeEventListener?.('devicechange', onDeviceChange);
-      stopPreview();
+      releaseCamera();
+      releaseMicrophone();
     };
-  }, [mediaSupported, refreshDevices, stopPreview]);
+  }, [mediaSupported, refreshDevices, releaseCamera, releaseMicrophone]);
 
-  const startPreview = useCallback(async () => {
+  const startCameraTest = useCallback(async () => {
     if (!mediaSupported) return;
-    stopPreview();
-    setPreviewState('running');
-    setPreviewMessage(null);
+    releaseCamera();
+    setCameraState('running');
+    setCameraMessage(null);
 
     try {
       const stream = await navigator.mediaDevices.getUserMedia({
         video: buildVideoConstraints(preferences),
-        audio: buildAudioConstraints(preferences),
+        audio: false,
       });
-      streamRef.current = stream;
+      const track = stream.getVideoTracks()[0];
+      if (!track || track.readyState !== 'live') throw new Error('No live camera track was returned.');
+      cameraStreamRef.current = stream;
 
       if (videoRef.current) {
         videoRef.current.srcObject = stream;
         await videoRef.current.play().catch(() => undefined);
       }
 
+      const settings = track.getSettings();
+      const size = settings.width && settings.height ? `${settings.width}×${settings.height}` : 'live video';
+      setCameraState('ok');
+      setCameraMessage(`Camera is live (${size}). This test did not open the microphone.`);
+      await refreshDevices();
+    } catch (error) {
+      releaseCamera();
+      setCameraState('error');
+      setCameraMessage(friendlyError(error, 'Camera'));
+    }
+  }, [mediaSupported, preferences, refreshDevices, releaseCamera]);
+
+  const startMicrophoneTest = useCallback(async () => {
+    if (!mediaSupported) return;
+    releaseMicrophone();
+    setMicrophoneState('running');
+    setMicrophoneMessage(null);
+
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({
+        video: false,
+        audio: buildAudioConstraints(preferences),
+      });
+      const track = stream.getAudioTracks()[0];
+      if (!track || track.readyState !== 'live') throw new Error('No live microphone track was returned.');
+      microphoneStreamRef.current = stream;
+
       const AudioContextCtor = window.AudioContext || (window as typeof window & { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;
       if (AudioContextCtor) {
         const ctx = new AudioContextCtor();
@@ -255,7 +315,7 @@ export default function AudioVideoSettings() {
         const data = new Uint8Array(analyser.fftSize);
 
         const readLevel = () => {
-          if (!streamRef.current || audioContextRef.current !== ctx) return;
+          if (!microphoneStreamRef.current || audioContextRef.current !== ctx) return;
           analyser.getByteTimeDomainData(data);
           let sum = 0;
           for (let i = 0; i < data.length; i += 1) {
@@ -269,21 +329,24 @@ export default function AudioVideoSettings() {
         readLevel();
       }
 
-      const videoSettings = stream.getVideoTracks()[0]?.getSettings();
-      const audioSettings = stream.getAudioTracks()[0]?.getSettings();
-      const parts = [
-        videoSettings?.width && videoSettings?.height ? `${videoSettings.width}×${videoSettings.height}` : null,
-        audioSettings?.sampleRate ? `${Math.round(audioSettings.sampleRate / 1000)} kHz mic` : 'microphone active',
+      const settings = track.getSettings() as AudioTrackSettings;
+      const sampleRate = settings.sampleRate ? `${Math.round(settings.sampleRate / 1000)} kHz` : 'live input';
+      const processing = [
+        settings.echoCancellation === true ? 'echo cancellation' : null,
+        settings.noiseSuppression === true ? 'noise suppression' : null,
+        settings.autoGainControl === true ? 'auto gain' : null,
       ].filter(Boolean);
-      setPreviewMessage(`Live test is using the selected devices${parts.length ? ` (${parts.join(', ')})` : ''}.`);
-      setPreviewState('ok');
+      setMicrophoneState('ok');
+      setMicrophoneMessage(
+        `Microphone is live (${sampleRate}${processing.length ? `; ${processing.join(', ')}` : ''}). This test did not open the camera.`,
+      );
       await refreshDevices();
     } catch (error) {
-      stopPreview();
-      setPreviewState('error');
-      setPreviewMessage(friendlyError(error));
+      releaseMicrophone();
+      setMicrophoneState('error');
+      setMicrophoneMessage(friendlyError(error, 'Microphone'));
     }
-  }, [mediaSupported, preferences, refreshDevices, stopPreview]);
+  }, [mediaSupported, preferences, refreshDevices, releaseMicrophone]);
 
   const chooseSpeaker = useCallback(async () => {
     const outputDevices = navigator.mediaDevices as OutputMediaDevices;
@@ -303,7 +366,7 @@ export default function AudioVideoSettings() {
     } catch (error) {
       if ((error as { name?: string })?.name === 'NotAllowedError') return;
       setSpeakerState('error');
-      setSpeakerMessage(friendlyError(error));
+      setSpeakerMessage(friendlyError(error, 'Speaker'));
     }
   }, [persist, preferences.speakerDeviceId, refreshDevices]);
 
@@ -336,7 +399,7 @@ export default function AudioVideoSettings() {
       setSpeakerMessage('Test tone played. If you heard it, speaker output is working.');
     } catch (error) {
       setSpeakerState('error');
-      setSpeakerMessage(friendlyError(error));
+      setSpeakerMessage(friendlyError(error, 'Speaker'));
     } finally {
       await ctx?.close().catch(() => undefined);
     }
@@ -363,7 +426,7 @@ export default function AudioVideoSettings() {
         setScreenMessage('Screen-share test cancelled.');
       } else {
         setScreenState('error');
-        setScreenMessage(friendlyError(error));
+        setScreenMessage(friendlyError(error, 'Screen sharing'));
       }
     } finally {
       stream?.getTracks().forEach((track) => track.stop());
@@ -372,13 +435,13 @@ export default function AudioVideoSettings() {
 
   const deviceLabel = (device: MediaDeviceInfo, index: number, fallback: string) => device.label || `${fallback} ${index + 1}`;
   const selectedSpeaker = speakers.find((speaker) => speaker.deviceId === preferences.speakerDeviceId);
-  const selectAudioOutputSupported = !!(navigator.mediaDevices as OutputMediaDevices | undefined)?.selectAudioOutput;
+  const selectAudioOutputSupported = typeof navigator !== 'undefined' && !!(navigator.mediaDevices as OutputMediaDevices | undefined)?.selectAudioOutput;
 
   if (!mediaSupported || !secureEnough) {
     return (
       <Card
         title="Audio & Video"
-        description="Choose and verify the devices HomePilot uses for live conversations."
+        description="Choose and verify the devices HomePilot uses for live conversations and meetings."
         icon={<Camera size={16} />}
       >
         <div className="rounded-xl border border-amber-500/25 bg-amber-500/10 p-4 text-xs text-amber-200/90 leading-relaxed">
@@ -394,10 +457,10 @@ export default function AudioVideoSettings() {
     <div className="space-y-4">
       <Card
         title="Camera"
-        description="Select the camera used for live video and verify the real capture before a conversation."
+        description="Select and test video independently. Testing the camera never opens your microphone."
         icon={<Camera size={16} />}
       >
-        <SettingRow label="Camera" description="Device labels appear after you grant media permission." stack>
+        <SettingRow label="Camera" description="Device labels appear after you grant camera permission." stack>
           <div className="flex flex-col sm:flex-row gap-2">
             <select
               aria-label="Camera"
@@ -429,26 +492,39 @@ export default function AudioVideoSettings() {
             className={[
               'w-full h-full object-cover',
               preferences.mirrorCameraPreview ? '-scale-x-100' : '',
-              previewState === 'ok' ? 'opacity-100' : 'opacity-40',
+              cameraState === 'ok' ? 'opacity-100' : 'opacity-40',
             ].join(' ')}
           />
-          {previewState !== 'ok' && (
+          {cameraState !== 'ok' && (
             <div className="absolute inset-0 flex items-center justify-center text-center p-6">
               <div>
                 <Camera size={24} className="mx-auto text-white/25 mb-2" />
-                <div className="text-xs text-white/45">Start the device test to see your camera.</div>
+                <div className="text-xs text-white/45">Run the camera test to see your preview.</div>
               </div>
             </div>
           )}
         </div>
+
+        <div className="flex flex-col sm:flex-row sm:items-center gap-3">
+          {cameraState === 'ok' ? (
+            <button type="button" className={BUTTON_CLS} onClick={stopCamera}><Square size={14} /> Stop camera test</button>
+          ) : (
+            <button type="button" className={BUTTON_CLS} onClick={() => void startCameraTest()} disabled={cameraState === 'running'}>
+              {cameraState === 'running' ? <RefreshCw size={14} className="animate-spin" /> : <Play size={14} />}
+              Test camera
+            </button>
+          )}
+          <TestBadge state={cameraState} idleLabel="Not tested" okLabel="Live" />
+        </div>
+        {cameraMessage ? <p className={cameraState === 'error' ? 'text-xs text-red-300/80' : 'text-xs text-white/45'}>{cameraMessage}</p> : null}
       </Card>
 
       <Card
         title="Microphone"
-        description="HomePilot Voice uses this same microphone and the same processing settings below."
+        description="Select and test audio independently. HomePilot Voice and MeetingSense use these same microphone preferences."
         icon={<Mic2 size={16} />}
       >
-        <SettingRow label="Microphone" stack>
+        <SettingRow label="Microphone" description="The test opens only this audio input; it does not start the camera." stack>
           <select
             aria-label="Microphone"
             className={SELECT_CLS}
@@ -462,14 +538,14 @@ export default function AudioVideoSettings() {
           </select>
         </SettingRow>
 
-        <SettingRow label="Input level" description="Speak normally. The meter should move without staying pinned at 100%.">
+        <SettingRow label="Input level" description="Speak normally. During a microphone test the meter should move without staying pinned at 100%.">
           <div className="h-2.5 rounded-full bg-white/10 overflow-hidden border border-white/[0.06]" aria-label={`Microphone input level ${Math.round(micLevel * 100)}%`}>
-            <div className="h-full bg-[#9b5cff] transition-[width] duration-75" style={{ width: `${Math.max(2, micLevel * 100)}%` }} />
+            <div className="h-full bg-[#9b5cff] transition-[width] duration-75" style={{ width: `${microphoneState === 'ok' ? Math.max(2, micLevel * 100) : 0}%` }} />
           </div>
         </SettingRow>
 
         <div className="border-t border-white/[0.06] pt-4 space-y-4">
-          <SettingRow label="Echo cancellation" description="Reduces sound from HomePilot or other speakers feeding back into your mic.">
+          <SettingRow label="Echo cancellation" description="Reduces sound from speakers feeding back into your microphone.">
             <Switch
               checked={preferences.echoCancellation}
               label="Echo cancellation"
@@ -496,17 +572,17 @@ export default function AudioVideoSettings() {
         </div>
 
         <div className="flex flex-col sm:flex-row sm:items-center gap-3 pt-1">
-          {previewState === 'ok' ? (
-            <button type="button" className={BUTTON_CLS} onClick={stopPreview}><Square size={14} /> Stop camera &amp; mic test</button>
+          {microphoneState === 'ok' ? (
+            <button type="button" className={BUTTON_CLS} onClick={stopMicrophone}><Square size={14} /> Stop microphone test</button>
           ) : (
-            <button type="button" className={BUTTON_CLS} onClick={() => void startPreview()} disabled={previewState === 'running'}>
-              {previewState === 'running' ? <RefreshCw size={14} className="animate-spin" /> : <Play size={14} />}
-              Test camera &amp; microphone
+            <button type="button" className={BUTTON_CLS} onClick={() => void startMicrophoneTest()} disabled={microphoneState === 'running'}>
+              {microphoneState === 'running' ? <RefreshCw size={14} className="animate-spin" /> : <Play size={14} />}
+              Test microphone
             </button>
           )}
-          <TestBadge state={previewState} idleLabel="Not tested" okLabel="Live" />
+          <TestBadge state={microphoneState} idleLabel="Not tested" okLabel="Listening" />
         </div>
-        {previewMessage ? <p className={previewState === 'error' ? 'text-xs text-red-300/80' : 'text-xs text-white/45'}>{previewMessage}</p> : null}
+        {microphoneMessage ? <p className={microphoneState === 'error' ? 'text-xs text-red-300/80' : 'text-xs text-white/45'}>{microphoneMessage}</p> : null}
       </Card>
 
       <Card
@@ -536,31 +612,42 @@ export default function AudioVideoSettings() {
 
       <Card
         title="Troubleshooting"
-        description="Verify the browser permissions and capture paths HomePilot depends on."
+        description="Run audio, video, and screen-sharing tests independently so a failure identifies the exact capture path."
         icon={<ShieldCheck size={16} />}
       >
-        <div className="grid gap-3 sm:grid-cols-2">
+        <div className="grid gap-3 sm:grid-cols-2 xl:grid-cols-3">
           <div className="rounded-xl bg-[#050505] border border-white/10 p-4 space-y-3">
             <div className="flex items-center justify-between gap-2">
-              <div className="flex items-center gap-2 text-sm text-white/80"><Camera size={15} /> Camera &amp; microphone</div>
-              <TestBadge state={previewState} idleLabel="Not tested" />
+              <div className="flex items-center gap-2 text-sm text-white/80"><Camera size={15} /> Camera</div>
+              <TestBadge state={cameraState} idleLabel="Not tested" />
             </div>
-            <p className="text-[11px] text-white/40 leading-relaxed">Checks real camera frames, microphone capture, the input meter, and your selected DSP constraints.</p>
-            <button type="button" className={BUTTON_CLS + ' w-full'} onClick={() => void startPreview()} disabled={previewState === 'running'}>Run test</button>
+            <p className="text-[11px] text-white/40 leading-relaxed">Checks the selected camera and real video frames only. It never opens the microphone.</p>
+            <button type="button" className={BUTTON_CLS + ' w-full'} onClick={() => void startCameraTest()} disabled={cameraState === 'running'}>Run video test</button>
           </div>
+
+          <div className="rounded-xl bg-[#050505] border border-white/10 p-4 space-y-3">
+            <div className="flex items-center justify-between gap-2">
+              <div className="flex items-center gap-2 text-sm text-white/80"><Mic2 size={15} /> Microphone</div>
+              <TestBadge state={microphoneState} idleLabel="Not tested" />
+            </div>
+            <p className="text-[11px] text-white/40 leading-relaxed">Checks the selected microphone, input meter, and DSP constraints only. It never opens the camera.</p>
+            <button type="button" className={BUTTON_CLS + ' w-full'} onClick={() => void startMicrophoneTest()} disabled={microphoneState === 'running'}>Run audio test</button>
+          </div>
+
           <div className="rounded-xl bg-[#050505] border border-white/10 p-4 space-y-3">
             <div className="flex items-center justify-between gap-2">
               <div className="flex items-center gap-2 text-sm text-white/80"><MonitorUp size={15} /> Screen sharing</div>
               <TestBadge state={screenState} idleLabel="Not tested" />
             </div>
-            <p className="text-[11px] text-white/40 leading-relaxed">Opens the browser's screen picker, verifies a live display track, then stops the test immediately.</p>
-            <button type="button" className={BUTTON_CLS + ' w-full'} onClick={() => void testScreenSharing()} disabled={screenState === 'running'}>Run test</button>
+            <p className="text-[11px] text-white/40 leading-relaxed">Opens the browser screen picker, verifies a live display track, then stops the test immediately.</p>
+            <button type="button" className={BUTTON_CLS + ' w-full'} onClick={() => void testScreenSharing()} disabled={screenState === 'running'}>Run screen test</button>
           </div>
         </div>
+
         {screenMessage ? <p className={screenState === 'error' ? 'text-xs text-red-300/80' : 'text-xs text-white/45'}>{screenMessage}</p> : null}
         {deviceError ? <p className="text-xs text-red-300/80">Device discovery: {deviceError}</p> : null}
         <div className="rounded-xl border border-white/[0.07] bg-white/[0.025] px-3.5 py-3 text-[11px] text-white/40 leading-relaxed">
-          Device choices and microphone processing are saved automatically on this browser. HomePilot Voice reads the same microphone source and processing preferences when it starts listening.
+          Device choices and microphone processing are saved automatically on this browser. HomePilot Voice and MeetingSense both use the same selected microphone and processing preferences.
         </div>
       </Card>
     </div>