Add smart assessment game mode dashboard

Author: P4ND4907

electron/main.mjs

@@ -11,6 +11,7 @@ import {
   isTrustedCueForgeUrl,
   validateIpcSender
 } from '../src/security/electronPolicy.js';
+import { detectRunningGame } from '../src/native/runningGameDetector.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -127,6 +128,11 @@ ipcMain.handle('cueforge:desktop-info', trustedIpc(() => ({
 
 ipcMain.handle('cueforge:read-bridge-report', trustedIpc(async () => readReport()));
 
+ipcMain.handle('cueforge:detect-game', trustedIpc(async () => {
+  const game = await detectRunningGame();
+  return game ? { id: game.id, exe: game.exe } : null;
+}));
+
 ipcMain.handle('cueforge:scan-audio-setup', trustedIpc(async () => {
   const script = scriptPath();
   const output = reportPath();

electron/preload.cjs

@@ -4,6 +4,7 @@ contextBridge.exposeInMainWorld('cueforgeDesktop', {
   isDesktop: true,
   info: () => ipcRenderer.invoke('cueforge:desktop-info'),
   getDesktopInfo: () => ipcRenderer.invoke('cueforge:desktop-info'),
+  detectGame: () => ipcRenderer.invoke('cueforge:detect-game'),
   scanAudioSetup: () => ipcRenderer.invoke('cueforge:scan-audio-setup'),
   readBridgeReport: () => ipcRenderer.invoke('cueforge:read-bridge-report'),
   openBridgeFolder: () => ipcRenderer.invoke('cueforge:open-bridge-folder'),

package-lock.json

@@ -83,6 +83,9 @@
   },
   "overrides": {
     "form-data": "4.0.6",
+    "@electron/get": {
+      "undici": "7.28.0"
+    },
     "js-yaml": "4.2.0",
     "tar": "7.5.16",
     "tmp": "0.2.7"

package.json

@@ -30,6 +30,7 @@ test('CueForge desktop bridge smoke', async () => {
     expect(String(desktopInfo?.reportPath || '').toLowerCase()).toContain('cueforge');
     expect(String(desktopInfo?.scriptPath || '')).toContain('Scan-AudioSetup.ps1');
     expect(bridgeKeys).toEqual([
+      'detectGame',
       'getDesktopInfo',
       'info',
       'isDesktop',

qa/playwright/electron/desktop-bridge-smoke.spec.mjs

@@ -0,0 +1 @@
+export { extractor, extractWavFeatures, WavFeatureExtractor } from '../wavFeatureExtractor.js';

src/audio-science/wavFeatureExtractor.js

@@ -0,0 +1,117 @@
+const highConflictIds = new Set([
+  'double-spatial-risk',
+  'native-spatial-stack-blocked',
+  'double-eq-risk',
+  'stacked-noise-suppression',
+  'missing-stream-limiter',
+  'stream-clipping-risk',
+  'bass-masking-footsteps',
+  'latency-budget-fail'
+]);
+
+export function detectBottleneck(detectData = {}) {
+  const findings = [];
+  const conflicts = Array.isArray(detectData.conflicts) ? detectData.conflicts : [];
+  const metrics = detectData.metrics || {};
+
+  if (detectData?.sonar && detectData?.discord) {
+    findings.push({
+      id: 'sonar-discord-conflict',
+      severity: 'high',
+      title: 'Sonar + Discord likely conflicting',
+      msg: 'Sonar + Discord likely conflicting',
+      fix: 'Pick one processing path for voice while testing, then confirm Discord input/output.'
+    });
+  }
+
+  if (Number(detectData?.micClip) > 0.6) {
+    findings.push({
+      id: 'mic-clipping-risk',
+      severity: 'high',
+      title: 'High mic clipping risk',
+      msg: 'High mic clipping risk - lower gain',
+      fix: 'Lower mic gain before trusting EQ, Sound Match, or Discord feedback.'
+    });
+  }
+
+  if (detectData?.iEm && !detectData?.eqActive) {
+    findings.push({
+      id: 'iem-eq-needed',
+      severity: 'medium',
+      title: 'IEMs usually need EQ',
+      msg: 'IEMs usually need EQ',
+      fix: 'Start from a safe IEM profile and verify comfort before boosting cue bands.'
+    });
+  }
+
+  conflicts.forEach((conflict) => {
+    findings.push({
+      id: conflict.id || 'conflict',
+      severity: conflict.severity || (highConflictIds.has(conflict.id) ? 'high' : 'medium'),
+      title: conflict.title || conflict.message || conflict.id || 'Audio conflict',
+      fix: conflict.fix || 'Resolve this before applying a profile.'
+    });
+  });
+
+  if (Number(metrics.cpuLoadPercent) >= 75) {
+    findings.push({
+      id: 'cpu-load-high',
+      severity: 'medium',
+      title: 'CPU load is high for live monitoring',
+      fix: 'Use Game Mode or close extra analyzers while playing.'
+    });
+  }
+
+  if (Number(metrics.audioLatencyMs) > 30) {
+    findings.push({
+      id: 'latency-budget-fail',
+      severity: 'high',
+      title: 'Latency budget is too high',
+      fix: 'Use one spatial layer, one EQ path, and a lower-latency output route.'
+    });
+  }
+
+  if (Number(metrics.droppedFrames) > 0 || Number(metrics.monitorDrops) > 0) {
+    findings.push({
+      id: 'monitor-drops',
+      severity: 'medium',
+      title: 'Monitoring loop dropped updates',
+      fix: 'Switch to Game Mode or reduce analyzer size.'
+    });
+  }
+
+  const sorted = findings.sort((a, b) => severityRank(b.severity) - severityRank(a.severity));
+  const primary = sorted[0] || {
+    id: 'none',
+    severity: 'low',
+    title: 'No bottleneck detected',
+    fix: 'Keep the current profile and run one controlled match test.'
+  };
+
+  return {
+    schema: 'cueforge.bottleneck-diagnosis.v1',
+    status: primary.severity === 'high' ? 'blocked' : sorted.length ? 'watch' : 'clear',
+    primary,
+    primaryBottleneck: {
+      severity: primary.severity,
+      msg: primary.msg || primary.title,
+      fix: primary.fix
+    },
+    issues: sorted.map((item) => ({
+      severity: item.severity,
+      msg: item.msg || item.title,
+      id: item.id,
+      fix: item.fix
+    })),
+    findings: sorted,
+    metrics: {
+      cpuLoadPercent: Number(metrics.cpuLoadPercent) || 0,
+      audioLatencyMs: Number(metrics.audioLatencyMs) || 0,
+      droppedFrames: Number(metrics.droppedFrames || metrics.monitorDrops) || 0
+    }
+  };
+}
+
+function severityRank(severity) {
+  return { high: 3, medium: 2, low: 1 }[severity] || 0;
+}

src/core/bottleneckDiagnosis.js

@@ -0,0 +1,30 @@
+import { detectBottleneck } from './bottleneckDiagnosis.js';
+import { getPerformanceProfileConfig } from '../settings/performanceSettings.js';
+
+export async function runSmartAssessment(mode = 'quick', {
+  detectData = {},
+  performanceProfile = 'balanced',
+  runningGame = null
+} = {}) {
+  const bottleneck = detectBottleneck(detectData);
+  const performance = getPerformanceProfileConfig(performanceProfile);
+  const ready = bottleneck.status === 'clear' && mode === 'full';
+
+  return {
+    schema: 'cueforge.smart-assessment.v1',
+    mode,
+    game: runningGame || detectData.runningGame || null,
+    performance: {
+      profile: performanceProfile,
+      ...performance
+    },
+    bottleneck,
+    apply: {
+      safeToApply: ready,
+      reason: ready
+        ? 'Full assessment is clear enough to stage a reversible profile.'
+        : 'Preview only until the full scan, game settings, and Sound Match evidence agree.'
+    },
+    nextAction: bottleneck.primary.fix
+  };
+}

src/core/smartAssessment.js

@@ -0,0 +1,40 @@
+export async function runQuickDetect({
+  desktop = globalThis.window?.cueforgeDesktop,
+  navigatorRef = globalThis.navigator
+} = {}) {
+  const devices = await safeEnumerateDevices(navigatorRef);
+  const labels = devices.map((device) => String(device.label || '')).join(' ');
+  const desktopGame = await safeDetectGame(desktop);
+
+  return {
+    schema: 'cueforge.quick-detect.v1',
+    completeChain: devices.some((device) => device.kind === 'audioinput') && devices.some((device) => device.kind === 'audiooutput'),
+    sonar: /sonar|steelseries/i.test(labels),
+    discord: /discord/i.test(labels),
+    iEm: /iem|in-ear|earbud/i.test(labels),
+    eqActive: /equalizer apo|peace|eq/i.test(labels),
+    runningGame: desktopGame?.id || desktopGame || null,
+    deviceCounts: {
+      inputs: devices.filter((device) => device.kind === 'audioinput').length,
+      outputs: devices.filter((device) => device.kind === 'audiooutput').length
+    }
+  };
+}
+
+async function safeEnumerateDevices(navigatorRef) {
+  try {
+    if (!navigatorRef?.mediaDevices?.enumerateDevices) return [];
+    return await navigatorRef.mediaDevices.enumerateDevices();
+  } catch {
+    return [];
+  }
+}
+
+async function safeDetectGame(desktop) {
+  try {
+    if (!desktop?.detectGame) return null;
+    return await desktop.detectGame();
+  } catch {
+    return null;
+  }
+}

src/detection/quickDetect.js

@@ -155,6 +155,9 @@ import { buildGameAudioSettingsCheck } from './core/gameAudioSettingsCheck.js';
 import { buildMicPlan } from './engines/micPlan.js';
 import { honestSpatialModes, spatialTruthWarning } from './engines/spatialPlan.js';
 import { GuidedSetupRunPanel, SetupCommandCenter } from './ui/SetupCommandCenter.jsx';
+import GameModeToggle from './ui/GameModeToggle.jsx';
+import MoonDashboard from './ui/MoonDashboard.jsx';
+import { createLowLatencyAudioContext } from './shared/audio/LowLatencyAudioContext.js';
 import './styles.css';
 
 const headsetProfiles = [
@@ -588,6 +591,7 @@ function buildEqFromSourceProfile(profile, fallbackEq = baseEq) {
 
 const SIMPLE_NAV_ITEMS = [
   ['dashboard', Gauge, 'Command Center'],
+  ['moon', Sparkles, 'Smart'],
   ['detect', Search, 'Auto Setup'],
   ['mic', Mic, 'Mic Check'],
   ['eq', SlidersHorizontal, 'Tune'],
@@ -599,6 +603,7 @@ const SIMPLE_NAV_ITEMS = [
 
 const EXPERT_NAV_ITEMS = [
   ['hub', Radio, 'Community Hub'],
+  ['moon', Sparkles, 'Moon'],
   ['dashboard', Gauge, 'Control'],
   ['selftest', TestTube2, 'Self Test'],
   ['dna', BrainCircuit, 'Audio DNA'],
@@ -1131,6 +1136,8 @@ function App() {
           />
         ))}
 
+        {active === 'moon' && <MoonDashboard />}
+
         {active === 'selftest' && <SelfTestRunner />}
 
         {active === 'dna' && <AudioDnaPage eq={eq} cueforgeState={cueforgeState.stateV2} />}
@@ -1482,9 +1489,7 @@ function UiNotePopover({ draft, onChange, onCancel, onSave }) {
 }
 
 function createBrowserAudioContext() {
-  const BrowserAudioContext = window.AudioContext || window.webkitAudioContext;
-  if (!BrowserAudioContext) throw new Error('Web Audio is unavailable');
-  return new BrowserAudioContext();
+  return createLowLatencyAudioContext({ target: window });
 }
 
 function pickEvidenceMimeType() {
@@ -3846,6 +3851,9 @@ function SettingsPage({ settings, onUpdate, onReset, onRerunSetup, onOpen, uiNot
 
       <Panel title="Player Mode" icon={Gauge}>
         <p>Simple Mode is the default player path. Expert Mode brings back the full lab, raw proof, system info, and developer repair tools.</p>
+        <div className="settings-stack compact-settings">
+          <GameModeToggle />
+        </div>
         <div className="mode-choice">
           <button
             className={normalized.interfaceMode === 'simple' ? 'selected' : ''}