@mentra/engine 3.2.0-dev.181 → 3.2.0-dev.190

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/engine",
-  "version": "3.2.0-dev.181",
+  "version": "3.2.0-dev.190",
   "description": "Mentra Engine — miniapp registry, WebView bridge, and miniapp store",
   "main": "build/index.js",
   "react-native": "src/index.ts",
@@ -97,12 +97,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@mentra/acs-meeting": "3.2.0-dev.181",
-    "@mentra/bluetooth-sdk": "3.2.0-dev.181",
-    "@mentra/cloud-client": "3.2.0-dev.181",
-    "@mentra/cloud-protocol": "3.2.0-dev.181",
-    "@mentra/crust": "3.2.0-dev.181",
-    "@mentra/miniapp": "3.2.0-dev.181",
+    "@mentra/acs-meeting": "3.2.0-dev.190",
+    "@mentra/bluetooth-sdk": "3.2.0-dev.190",
+    "@mentra/cloud-client": "3.2.0-dev.190",
+    "@mentra/cloud-protocol": "3.2.0-dev.190",
+    "@mentra/crust": "3.2.0-dev.190",
+    "@mentra/miniapp": "3.2.0-dev.190",
     "buffer": "^6.0.3",
     "events": "^3.3.0",
     "react-native-marked": "8.1.1",

package/src/facades/dev.ts

@@ -19,6 +19,7 @@ import {getConfigValues} from "../runtime/bootstrap"
 import {decideDevLaunchRoute} from "../utils/devMiniappLaunch"
 import {registerDevApp, DEV_APP_PACKAGE_NAME, type DevAppRecord} from "../services/AppRegistry"
 import {useAppStatusStore} from "../stores/apps"
+import {scopeCloudUrlOverrides} from "../services/cloudEndpointPolicy"
 
 type CloudUrlOverrides = {core?: string; runtime?: string}
 
@@ -28,6 +29,11 @@ type CloudUrlOverrides = {core?: string; runtime?: string}
  * host's Metro/env URL resolution); both empty clears the live override.
  */
 function applyCloudUrlReconnect(urls: CloudUrlOverrides = currentCloudUrlOverrides()): void {
+  const hostResolver = getConfigValues().resolveCloudEndpoints
+  if (hostResolver) {
+    cloudClientService.reconnect(null)
+    return
+  }
   const resolved = resolveCloudUrlReconnectTarget(urls)
   if (resolved === undefined) {
     cloudClientService.reconnect(null)
@@ -91,6 +97,32 @@ export const dev = {
   },
   /** Override the cloud-v2 URLs and reconnect the live client onto them. */
   setCloudUrls: (urls: {core?: string; runtime?: string}) => {
+    const config = getConfigValues()
+    if (config.resolveCloudEndpoints) {
+      const scope = config.cloudDebugScope ?? ""
+      const scoped = scopeCloudUrlOverrides(
+        {
+          scope: useSettingsStore.getState().getSetting(SETTINGS.cloud_url_deployment.key),
+          ...currentCloudUrlOverrides(),
+        },
+        scope,
+        urls,
+      )
+      const values: Record<string, unknown> = {
+        [SETTINGS.cloud_url_deployment.key]: scope,
+        [SETTINGS.cloud_core_url.key]: scoped.core,
+        [SETTINGS.cloud_runtime_url.key]: scoped.runtime,
+        [SETTINGS.cached_required_version.key]: "",
+      }
+      void useSettingsStore
+        .getState()
+        .setManyLocally(values)
+        .then((result) => {
+          if (result.is_error()) console.error("engine.dev.setCloudUrls: could not save URLs", result.error)
+          else applyCloudUrlReconnect()
+        })
+      return
+    }
     const next = {...currentCloudUrlOverrides(), ...urls}
     const resolved = resolveCloudUrlReconnectTarget(next)
     if (resolved === null) {

package/src/facades/phoneNotifications.ts

@@ -10,9 +10,30 @@
  */
 import {Platform} from "react-native"
 import CrustModule from "@mentra/crust"
+import BluetoothSdk from "@mentra/bluetooth-sdk/internal"
+import type {NativeNotificationStatus, NativeNotificationDelivery} from "@mentra/bluetooth-sdk"
+import {
+  nativeNotificationCapabilities,
+  setPhoneNotificationPresentationActive,
+  usesNativeNotificationPresentation,
+  presentNativePhoneNotification,
+} from "../services/PhoneNotificationsSync"
 import {useSettingsStore, SETTINGS} from "../stores/settings"
 
 export const phoneNotifications = {
+  nativeCapabilities: nativeNotificationCapabilities,
+  setPresentationActive: setPhoneNotificationPresentationActive,
+  usesNativePresentation: usesNativeNotificationPresentation,
+  presentNative: presentNativePhoneNotification,
+  nativeStatus: (): Promise<NativeNotificationStatus> => BluetoothSdk.getNativeNotificationStatus(),
+  onNativeStatus: (listener: (status: NativeNotificationStatus) => void) => {
+    const subscription = BluetoothSdk.addListener("native_notification_status", listener)
+    return () => subscription.remove()
+  },
+  onNativeDelivery: (listener: (event: NativeNotificationDelivery) => void) => {
+    const subscription = BluetoothSdk.addListener("native_notification_delivery", listener)
+    return () => subscription.remove()
+  },
   /** The phone's installed apps (package, name, icon). (empty on iOS) */
   installedApps: (): Promise<Array<{packageName: string; appName: string; icon: string | null}>> => {
     if (Platform.OS !== "android") return Promise.resolve([])

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface EngineReleaseMetadata {
 export const ENGINE_RELEASE_METADATA: Readonly<EngineReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.0",
-  "releaseIdentity": "3.2.0-dev.181",
-  "releaseSetId": "mentra-3.2.0-dev.181",
-  "sourceCommit": "89a4792321ce95bd16aadd721bc3dbc20e338861",
-  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.181.json",
-  "otaManifestSha256": "d9a100cc81733d02848a86c7617eff154f4cd9d714d1d36407789aeebbf71251"
+  "releaseIdentity": "3.2.0-dev.190",
+  "releaseSetId": "mentra-3.2.0-dev.190",
+  "sourceCommit": "9cec54c1238d6d52a90e2edc84f0b99692b8a81a",
+  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.190.json",
+  "otaManifestSha256": "00504171cce268dae2a22d9c4156cb7bac0b8a4397b35a3890ed561c619e5df0"
 })

package/src/runtime/bootstrap.ts

@@ -28,6 +28,10 @@ export interface IslandConfigValues {
   coreUrl?: string | null
   /** cloud-v2 runtime service base URL. */
   runtimeUrl?: string | null
+  /** Host's live manifest/override resolver, also used on automatic reconnects. */
+  resolveCloudEndpoints?: () => {core: string; runtime: string}
+  /** Scope for debug settings written through engine.dev. */
+  cloudDebugScope?: string
   /** Open Runtime's live WebSocket/audio session. Defaults to true. */
   runtimeRealtimeSession?: boolean
   /** Complete allowlist for bundled/local miniapps; null or omitted allows all. */
@@ -40,6 +44,8 @@ export interface IslandConfigValues {
   cloudAuthStorageKey?: string
   /** Deployment-pinned Mentra Live OTA manifest; explicit null disables remote OTA. */
   otaManifestUrl?: string | null
+  /** Official deployments retain the legacy-device and embedded release fallback. */
+  allowLegacyOtaFallback?: boolean
   /** Deployment capability policy. Omitted entries preserve consumer behavior. */
   features?: Partial<Record<IslandFeatureName, boolean>>
   /** OEM identifier (Mentra is OEM #0); reserved for OEM auth/telemetry. */

package/src/services/CloudClientService.ts

@@ -34,6 +34,7 @@ import {BgTimer} from "../utils/timers"
 import {logCloudV2TranscriptMetric} from "./CloudTranscriptE2EMetrics"
 import {LocalMiniappUserIdentity} from "./LocalMiniappUserIdentity"
 import {nativeHttpResponseBody} from "./NativeHttpResponse"
+import {resolveCloudEndpoints} from "./cloudEndpointPolicy"
 
 const LOG_TAG = "cloudClient"
 type CloudCore = NonNullable<CloudClient["core"]>
@@ -56,11 +57,6 @@ function clearPersistentFailureAlarm(): void {
 
 type Lc3FrameSizeBytes = 20 | 40 | 60
 
-// Neutral last-ditch fallbacks (reachable under `adb reverse`) for when the host
-// passes no endpoints. The host normally resolves the real URLs (dev override /
-// Metro host / env) and hands them in via `engine.configure({config})`.
-const FALLBACK_CORE_URL = "http://localhost:3000"
-const FALLBACK_RUNTIME_URL = "http://localhost:3001"
 const LOCAL_AUTH_PORT = 3002
 
 let client: CloudClient | null = null
@@ -100,15 +96,7 @@ const statusListeners = new Set<(snapshot: CloudClientStatusSnapshot) => void>()
 const connectionListeners = new Set<(connected: boolean) => void>()
 
 function resolveEndpoints(): {core?: string; runtime: string} {
-  if (endpointsOverride) return endpointsOverride
-  const cfg = getConfigValues()
-  const runtime = cfg.runtimeUrl === null ? "" : cfg.runtimeUrl?.trim() || FALLBACK_RUNTIME_URL
-  if (!runtime) throw new Error("cloudClient: Runtime endpoint is not configured")
-  const core = cfg.coreUrl === null ? undefined : cfg.coreUrl?.trim() || FALLBACK_CORE_URL
-  return {
-    ...(core ? {core} : {}),
-    runtime,
-  }
+  return resolveCloudEndpoints(getConfigValues(), endpointsOverride)
 }
 
 function getCoreClient(): CloudCore {
@@ -554,7 +542,7 @@ export const cloudClientService = {
 
   /**
    * Tear down + rebuild. Pass new endpoints to switch URLs; pass `null` to CLEAR
-   * a prior override and fall back to the boot config (so cleared/default cloud
+   * a prior override and resume the host resolver or boot config (so cleared/default cloud
    * URLs don't keep reconnecting to a stale override); omit to keep the current.
    */
   reconnect(endpoints?: {core?: string; runtime: string} | null): void {

package/src/services/NativeNotificationPolicy.ts

@@ -0,0 +1,24 @@
+import type {NativeNotificationConfig} from "@mentra/bluetooth-sdk"
+
+export interface NotificationPolicyInput {
+  supported: boolean
+  selected: boolean
+  presentationActive: boolean
+  sourceEnabled: boolean
+  autoDisplay: boolean
+  durationSeconds: number
+  doNotDisturb: boolean
+  blockedApps: string[]
+}
+
+export function nativeNotificationConfig(input: NotificationPolicyInput): NativeNotificationConfig {
+  return {
+    enabled: input.supported && input.selected && input.presentationActive && input.sourceEnabled,
+    autoDisplay: input.autoDisplay,
+    durationSeconds: Number.isFinite(input.durationSeconds)
+      ? Math.min(30, Math.max(1, Math.round(input.durationSeconds)))
+      : 5,
+    doNotDisturb: input.doNotDisturb,
+    blockedApps: input.blockedApps,
+  }
+}

package/src/services/PhoneNotificationsSync.ts

@@ -1,46 +1,130 @@
-/**
- * Phone-notifications sync — engine-owned. Pushes the notification-forwarding
- * operational kill switch + config (`android_notification_listener_enabled`
- * and `notifications_blocklist`) to the native
- * NotificationListener via `CrustModule.setNotificationConfig`, so
- * the blocklist reaches the listener for ANY host — not just the Mentra App,
- * where this used to live in MantleManager. The Android service is desired by
- * default now that its cold start is isolated from React Native. Native code
- * keeps the component discoverable in Android's notification-access Settings,
- * but only binds the service after access is granted. The debug setting remains
- * a hidden emergency kill switch; Notify's running state gates presentation,
- * not capture. Android-only; a no-op elsewhere. Started by `engine.start()`.
- */
+/** One engine-owned notification policy: capture remains independent of presentation. */
+import {Platform} from "react-native"
 import {shallow} from "zustand/shallow"
 import CrustModule from "@mentra/crust"
+import BluetoothSdk from "@mentra/bluetooth-sdk/internal"
+import type {PhoneNotificationEvent} from "@mentra/crust"
 
 import {useSettingsStore, SETTINGS} from "../stores/settings"
+import {useGlassesStore, isGlassesReady} from "../stores/glasses"
+import {DeviceTypes} from "../types/enums"
+import {getModelCapabilities} from "../types/hardware"
+import {nativeNotificationConfig} from "./NativeNotificationPolicy"
 
-let unsubscribe: (() => void) | null = null
+let unsubscribers: Array<() => void> = []
+let presentationActive = false
 
-function pushConfig(): void {
-  const s = useSettingsStore.getState()
-  const listenerEnabled = Boolean(s.getSetting(SETTINGS.android_notification_listener_enabled.key))
-  const blocklist = s.getSetting(SETTINGS.notifications_blocklist.key)
-  CrustModule.setNotificationConfig(listenerEnabled, Array.isArray(blocklist) ? blocklist : []).catch((err: unknown) =>
-    console.warn(`PhoneNotificationsSync: setNotificationConfig failed: ${(err as Error)?.message ?? err}`),
+export function nativeNotificationCapabilities() {
+  const supported = Boolean(
+    getModelCapabilities(useGlassesStore.getState().deviceModel as DeviceTypes)?.hasNativeNotifications,
+  )
+  return {
+    supported,
+    source: Platform.OS === "ios" ? ("ancs" as const) : ("phone" as const),
+    contentAccess:
+      Platform.OS === "android" ? ("full" as const) : supported ? ("app_identity" as const) : ("unsupported" as const),
+    perAppFiltering: Platform.OS === "android",
+    removal: false, // The verified G2 protocol does not yet include a removal command.
+  }
+}
+
+function desiredConfig() {
+  const settings = useSettingsStore.getState()
+  return nativeNotificationConfig({
+    supported: nativeNotificationCapabilities().supported,
+    selected: Boolean(settings.getSetting(SETTINGS.native_notifications_enabled.key)),
+    presentationActive,
+    sourceEnabled:
+      Platform.OS !== "android" || Boolean(settings.getSetting(SETTINGS.android_notification_listener_enabled.key)),
+    autoDisplay: Boolean(settings.getSetting(SETTINGS.native_notifications_auto_display.key)),
+    durationSeconds: Number(settings.getSetting(SETTINGS.native_notifications_duration.key)),
+    doNotDisturb: Boolean(settings.getSetting(SETTINGS.native_notifications_do_not_disturb.key)),
+    blockedApps: Platform.OS === "android" ? settings.getSetting(SETTINGS.notifications_blocklist.key) : [],
+  })
+}
+
+function pushNativeConfig(): void {
+  if (!nativeNotificationCapabilities().supported) return
+  void BluetoothSdk.configureNativeNotifications(desiredConfig()).catch((error: unknown) => {
+    if (isGlassesReady(useGlassesStore.getState().connection)) {
+      console.warn("PhoneNotificationsSync: native notification configuration failed", error)
+    }
+  })
+}
+
+/** Hosts activate their presentation owner (Notify in the Mentra App) through this seam. */
+export function setPhoneNotificationPresentationActive(active: boolean): void {
+  if (active === presentationActive) return
+  presentationActive = active
+  pushNativeConfig()
+}
+
+export function usesNativeNotificationPresentation(): boolean {
+  return (
+    nativeNotificationCapabilities().supported &&
+    presentationActive &&
+    Boolean(useSettingsStore.getState().getSetting(SETTINGS.native_notifications_enabled.key))
   )
 }
 
+/** Return true when the selected firmware presentation owns this event, including quiet/history mode. */
+export async function presentNativePhoneNotification(event: PhoneNotificationEvent): Promise<boolean> {
+  if (!usesNativeNotificationPresentation()) return false
+  if (!desiredConfig().enabled) return true
+  if (Platform.OS !== "android") return true // G2 receives ANCS directly; never upload metadata back.
+  const blocked = useSettingsStore.getState().getSetting(SETTINGS.notifications_blocklist.key)
+  if (Array.isArray(blocked) && blocked.includes(event.packageName)) return true
+  if (!isGlassesReady(useGlassesStore.getState().connection)) return true
+  await BluetoothSdk.sendPhoneNotification({
+    notificationId: String(event.notificationId ?? ""),
+    packageName: String(event.packageName ?? ""),
+    appName: String(event.app ?? ""),
+    title: String(event.title ?? ""),
+    subtitle: "",
+    body: String(event.content ?? ""),
+    timestampMs: Number(event.timestamp ?? Date.now()),
+    action: 0,
+  })
+  return true
+}
+
+function pushConfig(): void {
+  const settings = useSettingsStore.getState()
+  if (Platform.OS === "android") {
+    const enabled = Boolean(settings.getSetting(SETTINGS.android_notification_listener_enabled.key))
+    const blocklist = settings.getSetting(SETTINGS.notifications_blocklist.key)
+    void CrustModule.setNotificationConfig(enabled, Array.isArray(blocklist) ? blocklist : []).catch((error: unknown) =>
+      console.warn("PhoneNotificationsSync: listener configuration failed", error),
+    )
+  }
+  pushNativeConfig()
+}
+
 export function startPhoneNotificationsSync(): void {
-  if (unsubscribe) return
-  pushConfig() // initial sync so the listener has the current config
-  unsubscribe = useSettingsStore.subscribe(
-    (state) => ({
-      listenerEnabled: state.getSetting(SETTINGS.android_notification_listener_enabled.key),
-      blocklist: state.getSetting(SETTINGS.notifications_blocklist.key),
+  if (unsubscribers.length) return
+  pushConfig()
+  unsubscribers = [
+    useSettingsStore.subscribe(
+      (state) =>
+        [
+          SETTINGS.android_notification_listener_enabled,
+          SETTINGS.notifications_blocklist,
+          SETTINGS.native_notifications_enabled,
+          SETTINGS.native_notifications_auto_display,
+          SETTINGS.native_notifications_duration,
+          SETTINGS.native_notifications_do_not_disturb,
+        ].map((setting) => state.getSetting(setting.key)),
+      pushConfig,
+      {equalityFn: shallow},
+    ),
+    useGlassesStore.subscribe((state) => ({model: state.deviceModel, connection: state.connection}), pushNativeConfig, {
+      equalityFn: shallow,
     }),
-    () => pushConfig(),
-    {equalityFn: shallow},
-  )
+  ]
 }
 
 export function stopPhoneNotificationsSync(): void {
-  unsubscribe?.()
-  unsubscribe = null
+  setPhoneNotificationPresentationActive(false)
+  unsubscribers.forEach((unsubscribe) => unsubscribe())
+  unsubscribers = []
 }

package/src/services/cloudEndpointPolicy.ts

@@ -0,0 +1,25 @@
+import type {IslandConfigValues} from "../runtime/bootstrap"
+
+export type CloudEndpoints = {core?: string; runtime: string}
+
+/** Explicit reconnect pins win; clearing a pin resumes the live host resolver. */
+export function resolveCloudEndpoints(config: IslandConfigValues, override: CloudEndpoints | null): CloudEndpoints {
+  if (override) return override
+  if (config.resolveCloudEndpoints) return config.resolveCloudEndpoints()
+  const runtime = config.runtimeUrl === null ? "" : config.runtimeUrl?.trim() || "http://localhost:3001"
+  if (!runtime) throw new Error("cloudClient: Runtime endpoint is not configured")
+  const core = config.coreUrl === null ? undefined : config.coreUrl?.trim() || "http://localhost:3000"
+  return {...(core ? {core} : {}), runtime}
+}
+
+export function scopeCloudUrlOverrides(
+  current: {scope: unknown; core?: string; runtime?: string},
+  scope: string,
+  update: {core?: string; runtime?: string},
+): {core: string; runtime: string} {
+  const sameScope = current.scope === scope || (!current.scope && scope === "consumer")
+  return {
+    core: update.core ?? (sameScope ? (current.core ?? "") : ""),
+    runtime: update.runtime ?? (sameScope ? (current.runtime ?? "") : ""),
+  }
+}

package/src/services/otaManifestPolicy.ts

@@ -48,6 +48,6 @@ export function resolveDeploymentAwareOtaManifestPolicy({
   // A selected deployment is authoritative for every glasses generation. An
   // explicit null is a deliberate OTA-off policy, not permission to inherit a
   // device-reported URL or Mentra's legacy public default.
-  if (hostPolicyConfigured) return trimmed(policy.hostReleasePin)
+  if (hostPolicyConfigured) return trimmed(policy.developerOverride) || trimmed(policy.hostReleasePin)
   return resolveOtaManifestPolicy(policy)
 }

package/src/services/otaManifestUrl.ts

@@ -22,7 +22,8 @@ function getHostReleasePin(): string | null {
 }
 
 function hasDeploymentOtaPolicy(): boolean {
-  return getConfigValues().otaManifestUrl !== undefined
+  const config = getConfigValues()
+  return config.otaManifestUrl !== undefined && !config.allowLegacyOtaFallback
 }
 
 function getEmbeddedEngineReleasePin(): string | null {

package/src/stores/settings.ts

@@ -166,6 +166,36 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
+  // Select firmware-owned presentation instead of the Mentra card. Notify still
+  // controls whether presentation is running on either phone platform.
+  native_notifications_enabled: {
+    key: "native_notifications_enabled",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  native_notifications_auto_display: {
+    key: "native_notifications_auto_display",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  native_notifications_duration: {
+    key: "native_notifications_duration",
+    defaultValue: () => 5,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  native_notifications_do_not_disturb: {
+    key: "native_notifications_do_not_disturb",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
   china_deployment: {
     key: "china_deployment",
     defaultValue: () => (process.env.EXPO_PUBLIC_DEPLOYMENT_REGION === "china" ? true : false),
@@ -196,6 +226,14 @@ export const SETTINGS: Record<string, Setting> = {
     persist: true,
     resetOnBuildEnvChange: true,
   },
+  cloud_url_deployment: {
+    key: "cloud_url_deployment",
+    defaultValue: () => "",
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+    resetOnBuildEnvChange: true,
+  },
   // Bookmarked Cloud V2 endpoint pairs. Each entry is {label, coreUrl,
   // runtimeUrl} — core + runtime are saved together because they are always
   // applied as a matched set (presets fill both; Save & Test verifies both).
@@ -793,13 +831,10 @@ export interface SettingsState {
 }
 
 const getDefaultSettings = () =>
-  Object.keys(SETTINGS).reduce(
-    (acc, key) => {
-      acc[key] = SETTINGS[key].defaultValue()
-      return acc
-    },
-    {} as Record<string, any>,
-  )
+  Object.keys(SETTINGS).reduce((acc, key) => {
+    acc[key] = SETTINGS[key].defaultValue()
+    return acc
+  }, {} as Record<string, any>)
 
 // Single-flight for loadAllSettings: the host fires it at module load and
 // engine.start()'s device-store hydration awaits it — without the memo the
@@ -901,12 +936,13 @@ export const useSettingsStore = create<SettingsState>()(
         }
         // console.log("SETTINGS: SET MANY LOCALLY: ", settingsToLoad)
 
-        set((state) => ({
-          settings: {...state.settings, ...settingsToLoad},
-        }))
-
-        // save to storage:
-        await Promise.all(Object.entries(settingsToLoad).map(([key, value]) => storage.save(key, value)))
+        // MMKV writes are synchronous Results, not rejecting Promises. Check
+        // each result before publishing the new in-memory settings.
+        for (const [key, value] of Object.entries(settingsToLoad)) {
+          const saved = storage.save(key, value)
+          if (saved.is_error()) throw saved.error
+        }
+        set((state) => ({settings: {...state.settings, ...settingsToLoad}}))
       })
     },
     // loads any preferences that have been changed from the default and saved to DISK!

package/src/types/capabilities/even-realities-g2.ts

@@ -88,4 +88,5 @@ export const evenRealitiesG2: Capabilities = {
   // Dashboard - G2 renders Even Realities' native dashboard in firmware, so
   // MentraOS does not manage the dashboard or expose dashboard settings for it
   hasNativeDashboard: true,
+  hasNativeNotifications: true,
 };

package/src/types/hardware.ts

@@ -122,6 +122,8 @@ export interface PowerCapabilities {
  * Complete information about what hardware a device has
  */
 export interface Capabilities {
+  /** Firmware-owned notification history and popups; content relay is separate. */
+  hasNativeNotifications?: boolean;
   modelName: string;
 
   // Camera capabilities