@glassly/engine 0.1.0-dev.62 → 0.1.0-dev.90

package/src/facades/phoneNotifications.ts

@@ -1,25 +1,40 @@
 /**
  * phoneNotifications facade — `engine.phoneNotifications`: forward phone
- * notifications to the glasses, with a per-app blocklist. Android-only (the
- * NotificationListenerService); the getters return sensible defaults on iOS.
+ * notifications to the glasses, with a per-app blocklist.
  *
- * The per-app blocklist is an engine setting (auto-synced to the native
- * listener); the installed-apps list + listener permission are CrustModule.
- * Capture itself is controlled only by Android notification access and the
- * hidden operational kill switch.
+ * Android: apps come from the NotificationListenerService's installed-apps
+ * enumeration and the blocklist filters capture phone-side.
+ * iOS: apps are the seeded catalog plus what the glasses' ANCS client has
+ * reported posting notifications (`ios_notification_seen_apps`); the blocklist
+ * is mapped onto the G2's on-glass allowlist by PhoneNotificationsSync.
+ * Capture itself is controlled by Android notification access / iOS ANCS
+ * authorization (`glasses.ancsAuthorized`), not by this facade.
  */
 import {Platform} from "react-native"
 import CrustModule from "@glassly/crust"
 import {useSettingsStore, SETTINGS} from "../stores/settings"
+import {useGlassesStore} from "../stores/glasses"
+import {getKnownNotificationApps} from "../services/PhoneNotificationsSync"
 
 export const phoneNotifications = {
-  /** The phone's installed apps (package, name, icon). (empty on iOS) */
+  /**
+   * Apps to show in the notification filter UI (package/bundle id, name, icon).
+   * Android: installed apps. iOS: seeded catalog ∪ glasses-reported apps
+   * (icons unavailable — iOS offers no cross-app icon lookup).
+   */
   installedApps: (): Promise<Array<{packageName: string; appName: string; icon: string | null}>> => {
-    if (Platform.OS !== "android") return Promise.resolve([])
-    return CrustModule.getInstalledApps()
+    if (Platform.OS === "android") return CrustModule.getInstalledApps()
+    if (Platform.OS !== "ios") return Promise.resolve([])
+    return Promise.resolve(
+      getKnownNotificationApps().map((app) => ({
+        packageName: app.appId,
+        appName: app.displayName,
+        icon: null,
+      })),
+    )
   },
 
-  /** The per-app blocklist (package names whose notifications are NOT forwarded). */
+  /** The per-app blocklist (package/bundle ids whose notifications are NOT forwarded). */
   blocklist: (): string[] => {
     const b = useSettingsStore.getState().getSetting(SETTINGS.notifications_blocklist.key)
     return Array.isArray(b) ? b : []
@@ -38,4 +53,11 @@ export const phoneNotifications = {
     if (Platform.OS !== "android") return
     return CrustModule.openNotificationListenerSettings()
   },
+
+  /**
+   * iOS: whether the connected glasses may read the phone's ANCS notification
+   * stream (the "Share System Notifications" Bluetooth consent). Always false
+   * on Android — Android capture is the notification listener instead.
+   */
+  ancsAuthorized: (): boolean => Boolean(useGlassesStore.getState().ancsAuthorized),
 }

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface EngineReleaseMetadata {
 export const ENGINE_RELEASE_METADATA: Readonly<EngineReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "0.1.0",
-  "releaseIdentity": "0.1.0-dev.62",
-  "releaseSetId": "glassly-0.1.0-dev.62",
-  "sourceCommit": "69eee438b882fca1c9b0ad466d71fc2c24053662",
+  "releaseIdentity": "0.1.0-dev.90",
+  "releaseSetId": "glassly-0.1.0-dev.90",
+  "sourceCommit": "1140c7490313353cb1d8da0782bf74c87d9119eb",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })

package/src/services/CustomDashboardService.ts

@@ -2,9 +2,8 @@
  * Scene API dashboard for G2 custom firmware.
  *
  * G2.swift marks the published firmware version after it detects the CFW
- * capability advertisement. The service retains a dashboard frame, owns
- * dashboard gestures while head-up is active, and leaves every other device
- * on its native behavior.
+ * capability advertisement. DashboardCoordinator owns open/close and display
+ * switching; this service renders the widgets and handles gestures while open.
  *
  * The dashboard is composed of user-orderable widgets (clock, calendar, apps
  * button, notifications button) stacked vertically on the CFW scene canvas.
@@ -19,6 +18,7 @@ import {useAppStatusStore} from "../stores/apps"
 import {useGlassesStore} from "../stores/glasses"
 import {SETTINGS, useSettingsStore} from "../stores/settings"
 import type {ClientApp} from "../types/applet"
+import {TextMeasurer} from "../utils/display/measurer"
 import type {SceneElementInput} from "../utils/display/scene"
 import {BgTimer} from "../utils/timers"
 import {
@@ -32,13 +32,17 @@ import {
   type DashboardWidgetSetting,
   type MenuAppSetting,
 } from "./CustomDashboardModel"
+import displayProcessor from "./DisplayProcessor"
 import {isGlassesConnected} from "./GlassesReadiness"
+import localDisplayManager from "./LocalDisplayManager"
 import {listPhoneCalendarEvents, PhoneCalendarError} from "./PhoneCalendarService"
 import sceneRenderer from "./SceneRenderer"
 
 const DASHBOARD_APP_ID = "system.custom-dashboard"
 const CLOCK_REFRESH_MS = 30_000
 const CALENDAR_REFRESH_MS = 5 * 60_000
+/** Matches the boot message's window; stops have no unmount-driven end signal. */
+const STOP_NOTICE_MS = 1500
 
 // CFW blits the stock compositor's 576×288 canvas; used when the firmware has
 // not reported scene capabilities yet.
@@ -49,6 +53,15 @@ const WIDGET_GAP = 10
 /** Row height for the glasses' builtin 20px font engine. */
 const LINE_H = 24
 const BUTTON_H = 34
+/**
+ * Selection marker: a text-hugging bar under the focused label instead of a
+ * boxed border. Drawn as a rect (h 3, border 2 — the strokes overlap into a
+ * solid bar) because mode 15 renders only glyphs; the bar must be in the
+ * raster or the firmware never shows it.
+ */
+const UNDERLINE_H = 3
+/** Row-top → underline-top: just under the builtin font's 27px line. */
+const UNDERLINE_OFFSET_Y = BUTTON_H - 4
 /**
  * App-menu icon grid: 2 rows × 4 columns per page. CFW rasterizes scenes
  * phone-side, so the stock firmware's 4-image container pool does not bound
@@ -73,6 +86,8 @@ function eventLine(event: CalendarEvent): string {
 class CustomDashboardService {
   private started = false
   private open = false
+  /** Set by DashboardCoordinator; asks it to close (and restore main content). */
+  public onRequestClose: (() => void) | null = null
   private view: "main" | "apps" = "main"
   private mainIndex = 0
   private appsIndex = 0
@@ -129,30 +144,22 @@ class CustomDashboardService {
       if (this.isEligible()) void this.refreshCalendarAndRender()
     }, CALENDAR_REFRESH_MS)
     this.eligible = this.isEligible()
-    if (this.eligible) {
-      this.ensureContextualDashboard()
-      void this.refreshCalendarAndRender()
-    }
   }
 
   /**
    * Track eligible⇄ineligible transitions from any trigger (setting toggle,
-   * connect/disconnect, firmware change). Entering enables the contextual
-   * dashboard once — not on every settings write, so a user's manual
-   * contextual-dashboard choice is no longer ratcheted back. Leaving closes
-   * the dashboard, blanks the glasses view, and drops the retained scene so a
-   * stale frame can't be replayed after the feature was turned off.
+   * connect/disconnect, firmware change). Leaving closes the dashboard via the
+   * coordinator (which restores main content) and drops the retained scene so
+   * a stale frame can't be replayed after the feature was turned off.
    */
   private syncEligibility(): boolean {
     const eligible = this.isEligible()
     if (eligible === this.eligible) return eligible
     this.eligible = eligible
-    if (eligible) {
-      this.ensureContextualDashboard()
-    } else {
+    if (!eligible) {
+      if (this.open) this.onRequestClose?.()
       this.open = false
       this.resetNavigation()
-      sceneRenderer.emitScene(DASHBOARD_APP_ID, "dashboard", [])
       sceneRenderer.clearApp(DASHBOARD_APP_ID)
     }
     return eligible
@@ -165,6 +172,7 @@ class CustomDashboardService {
     if (this.calendarTimer !== null) BgTimer.clearInterval(this.calendarTimer)
     this.clockTimer = null
     this.calendarTimer = null
+    if (this.open) this.onRequestClose?.()
     this.open = false
     this.eligible = false
     this.resetNavigation()
@@ -188,29 +196,17 @@ class CustomDashboardService {
     return this.open
   }
 
-  setHeadUp(up: boolean): void {
-    if (!this.isEligible()) {
-      this.open = false
-      return
-    }
-    if (up && !this.open) this.resetNavigation()
-    this.open = up
-    if (up) void this.refreshCalendarAndRender()
+  /** Coordinator opened the dashboard: render fresh from the top. */
+  show(): void {
+    this.open = true
+    this.resetNavigation()
+    void this.refreshCalendarAndRender()
   }
 
-  /** Toggle the custom dashboard for an eligible device. */
-  toggle(): boolean {
-    if (!this.isEligible()) return false
-    this.open = !this.open
-    if (this.open) {
-      this.resetNavigation()
-      void this.refreshCalendarAndRender()
-    }
-    void Promise.resolve(BluetoothSdk.toggleHeadUp()).catch((error) => {
-      this.open = !this.open
-      console.error("CustomDashboard: toggleHeadUp failed", error)
-    })
-    return true
+  /** Coordinator closed the dashboard. */
+  hide(): void {
+    this.open = false
+    this.resetNavigation()
   }
 
   /** Returns true when an open custom dashboard consumed the gesture. */
@@ -224,7 +220,8 @@ class CustomDashboardService {
         this.render()
         return true
       }
-      return this.toggle()
+      this.onRequestClose?.()
+      return true
     }
     if (this.view === "apps") return this.handleAppMenuGesture(gestureName)
     return this.handleMainGesture(gestureName)
@@ -288,26 +285,21 @@ class CustomDashboardService {
     return normalizeDashboardWidgets(useSettingsStore.getState().getSetting(SETTINGS.custom_dashboard_widgets.key))
   }
 
-  private async close(): Promise<void> {
-    if (!this.open) return
-    this.open = false
-    await Promise.resolve(BluetoothSdk.toggleHeadUp()).catch((error) => {
-      console.error("CustomDashboard: close failed", error)
-    })
-  }
-
   private async openNotificationsPanel(): Promise<void> {
-    await this.close()
+    this.onRequestClose?.()
     await BluetoothSdk.showNativeNotificationPanel().catch((error) => {
       console.error("CustomDashboard: notification panel failed", error)
     })
   }
 
   private async toggleApp(packageName: string): Promise<void> {
-    await this.close()
+    this.onRequestClose?.()
     const app = useAppStatusStore.getState().apps.find((candidate) => candidate.packageName === packageName)
     if (!app) return
     if (app.running) {
+      // Mirror the "Starting X…" boot message: without this the dashboard just
+      // closes and the stop is invisible on the glasses.
+      localDisplayManager.showSystemNotice(`Stopping ${app.name}…`, STOP_NOTICE_MS)
       await useAppStatusStore.getState().stop(app.packageName)
     } else {
       await useAppStatusStore.getState().start(app, {skipNavigation: true})
@@ -318,16 +310,8 @@ class CustomDashboardService {
     return this.widgets().some((widget) => widget.id === "calendar" && widget.enabled)
   }
 
-  private ensureContextualDashboard(): void {
-    const settings = useSettingsStore.getState()
-    if (settings.getSetting(SETTINGS.contextual_dashboard.key) !== true) {
-      // DeviceManager selects its retained dashboard Scene only while this is
-      // enabled. Custom firmware eligibility makes that dashboard automatic.
-      void settings.setSetting(SETTINGS.contextual_dashboard.key, true, false)
-    }
-  }
-
   private async refreshCalendarAndRender(): Promise<void> {
+    if (!this.open) return
     if (!this.calendarWidgetEnabled()) {
       this.calendarStatus = "loading"
       this.calendarEvents = []
@@ -360,6 +344,19 @@ class CustomDashboardService {
     this.render()
   }
 
+  /** Underline hugging a builtin-font label. x/rowY are the label box's origin. */
+  private labelUnderline(id: string, x: number, rowY: number, label: string): SceneElementInput {
+    // Same metrics processScene uses to ellipsize builtin text; the raster
+    // insets text by 2px, so the bar starts under the first glyph.
+    const textW = new TextMeasurer(displayProcessor.getProfile()).measureText(label)
+    return {
+      type: "rect",
+      id,
+      box: {x: x + 2, y: rowY + UNDERLINE_OFFSET_Y, w: textW + 4, h: UNDERLINE_H},
+      style: {border: 2},
+    }
+  }
+
   private canvas(): {width: number; height: number} {
     const {sceneCanvasWidth, sceneCanvasHeight} = useGlassesStore.getState()
     if (sceneCanvasWidth && sceneCanvasWidth > 0 && sceneCanvasHeight && sceneCanvasHeight > 0) {
@@ -369,7 +366,9 @@ class CustomDashboardService {
   }
 
   private render(): void {
-    if (!this.isEligible()) return
+    // Only while open: emitting into the single native view while closed
+    // would clobber the main content.
+    if (!this.open || !this.isEligible()) return
     const elements = this.view === "apps" ? this.appMenuElements() : this.mainElements()
     sceneRenderer.emitScene(DASHBOARD_APP_ID, "dashboard", elements)
   }
@@ -444,24 +443,26 @@ class CustomDashboardService {
           style: {font: "builtin", breakMode: "strict-word", overflow: "ellipsis"},
         })
       } else if (widget.id === "apps") {
-        const isSelected = selected?.kind === "apps-menu"
         elements.push({
           type: "text",
           id: "apps-button",
           box: {x: MARGIN_X, y, w: width, h: BUTTON_H},
           text: "Apps",
-          style: {font: "builtin", border: isSelected ? 2 : 0, radius: 8},
+          style: {font: "builtin"},
         })
+        if (selected?.kind === "apps-menu") elements.push(this.labelUnderline("apps-underline", MARGIN_X, y, "Apps"))
         y += BUTTON_H + WIDGET_GAP
       } else if (widget.id === "notifications") {
-        const isSelected = selected?.kind === "notifications"
         elements.push({
           type: "text",
           id: "notifications",
           box: {x: MARGIN_X, y, w: width, h: BUTTON_H},
           text: "Notifications",
-          style: {font: "builtin", border: isSelected ? 2 : 0, radius: 8},
+          style: {font: "builtin"},
         })
+        if (selected?.kind === "notifications") {
+          elements.push(this.labelUnderline("notifications-underline", MARGIN_X, y, "Notifications"))
+        }
         y += BUTTON_H + WIDGET_GAP
       }
     }
@@ -535,7 +536,7 @@ class CustomDashboardService {
       return elements
     }
 
-    // Icon grid, paged, row-major. Selection is the bordered cell.
+    // Icon grid, paged, row-major. Selection is the underlined cell.
     const perPage = APPS_PER_PAGE
     const pageStart = Math.floor(this.appsIndex / perPage) * perPage
     const page = apps.slice(pageStart, pageStart + perPage)
@@ -569,8 +570,8 @@ class CustomDashboardService {
         elements.push({
           type: "rect",
           id: "apps-selection",
-          box: {x, y, w: APP_CELL, h: APP_CELL},
-          style: {border: 2, radius: 6},
+          box: {x, y: y + APP_CELL + 2, w: APP_CELL, h: UNDERLINE_H},
+          style: {border: 2},
         })
       }
     })
@@ -584,7 +585,7 @@ class CustomDashboardService {
         type: "text",
         id: "apps-selected-name",
         box: {x: MARGIN_X, y: listTop + gridH + 12, w: width, h: LINE_H},
-        text: `${selectedApp.name}${selectedApp.running ? "  ●" : ""}`,
+        text: `${selectedApp.name}${selectedApp.running ? " (running)" : ""}`,
         style: {font: "builtin", breakMode: "strict-word", overflow: "ellipsis"},
       })
     }

package/src/services/DashboardCoordinator.ts

@@ -0,0 +1,121 @@
+/**
+ * Phone-side dashboard switching. Native retains a single display state; this
+ * service decides when the dashboard covers the main content (head-up,
+ * double-tap) and which renderer draws it: the CFW custom dashboard, or the
+ * legacy time/battery wall for stock devices.
+ */
+import {useGlassesStore} from "../stores/glasses"
+import {SETTINGS, useSettingsStore} from "../stores/settings"
+import {BgTimer} from "../utils/timers"
+import customDashboardService from "./CustomDashboardService"
+import {isGlassesConnected} from "./GlassesReadiness"
+import localDisplayManager from "./LocalDisplayManager"
+
+const LEGACY_CLOCK_REFRESH_MS = 30_000
+const LEGACY_DASHBOARD_PKG = "system.dashboard"
+
+class DashboardCoordinator {
+  private opened = false
+  private renderer: "custom" | "legacy" | null = null
+  private legacyTimer: number | null = null
+
+  start(): void {
+    customDashboardService.onRequestClose = () => this.close()
+  }
+
+  stop(): void {
+    this.close()
+    customDashboardService.onRequestClose = null
+  }
+
+  get isOpen(): boolean {
+    return this.opened
+  }
+
+  /** Head position (real or simulated). Opening respects contextual_dashboard. */
+  setHeadUp(up: boolean): void {
+    if (up === this.opened) return
+    if (up) {
+      if (useSettingsStore.getState().getSetting(SETTINGS.contextual_dashboard.key) === false) return
+      this.open()
+    } else {
+      this.close()
+    }
+  }
+
+  /** Double-tap on a CFW-eligible device. False when not eligible. */
+  toggleCustom(): boolean {
+    if (!customDashboardService.isEligible()) return false
+    if (this.opened) this.close()
+    else this.open()
+    return true
+  }
+
+  /** Double-tap fallback for devices without a firmware dashboard. */
+  toggleLegacy(): void {
+    if (this.opened) this.close()
+    else this.open()
+  }
+
+  /** True when an open dashboard consumed the gesture. */
+  handleGesture(gestureName: string): boolean {
+    if (!this.opened) return false
+    if (this.renderer === "custom") return customDashboardService.handleGesture(gestureName)
+    if (gestureName === "double_tap") {
+      this.close()
+      return true
+    }
+    return false
+  }
+
+  /** Show the dashboard over the main content (ignores contextual_dashboard). */
+  open(): void {
+    if (this.opened) return
+    if (!isGlassesConnected(useGlassesStore.getState().connection)) return
+    this.opened = true
+    localDisplayManager.setDashboardActive(true)
+    if (customDashboardService.isEligible()) {
+      this.renderer = "custom"
+      customDashboardService.show()
+    } else {
+      this.renderer = "legacy"
+      this.renderLegacy()
+      this.legacyTimer = BgTimer.setInterval(() => this.renderLegacy(), LEGACY_CLOCK_REFRESH_MS)
+    }
+  }
+
+  /** Close and restore the retained main content. */
+  close(): void {
+    if (!this.opened) return
+    this.opened = false
+    if (this.legacyTimer !== null) {
+      BgTimer.clearInterval(this.legacyTimer)
+      this.legacyTimer = null
+    }
+    if (this.renderer === "custom") customDashboardService.hide()
+    this.renderer = null
+    localDisplayManager.setDashboardActive(false)
+  }
+
+  /** Parity with the retired native head-up wall: time, date, battery. */
+  private renderLegacy(): void {
+    if (!this.opened) return
+    const now = new Date()
+    const time = new Intl.DateTimeFormat(undefined, {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: useSettingsStore.getState().getSetting(SETTINGS.twelve_hour_time.key) === true,
+    }).format(now)
+    const date = `${String(now.getMonth() + 1).padStart(2, "0")}/${String(now.getDate()).padStart(2, "0")}`
+    const level = useGlassesStore.getState().batteryLevel
+    const batt = typeof level === "number" && level >= 0 ? ` ${level}%` : ""
+    localDisplayManager.renderDashboard(LEGACY_DASHBOARD_PKG, {
+      view: "dashboard",
+      layout: {layoutType: "text_wall", text: `${time} ${date}${batt} Connected`},
+    })
+  }
+}
+
+const dashboardCoordinator = new DashboardCoordinator()
+export default dashboardCoordinator
+export {DashboardCoordinator}

package/src/services/DeviceEventRouter.ts

@@ -35,7 +35,7 @@ import {retirePendingSelectionOnPromotion} from "./PairingIdentity"
 import GlobalEventEmitter from "../utils/GlobalEventEmitter"
 import {BgTimer} from "../utils/timers"
 import {asgCameraApi} from "./asg/asgCameraApi"
-import customDashboardService from "./CustomDashboardService"
+import dashboardCoordinator from "./DashboardCoordinator"
 import gestureDotsService from "./GestureDotsService"
 
 let subs: Array<{remove: () => void}> = []
@@ -200,7 +200,7 @@ export function startDeviceEventRouter(): void {
     BluetoothSdk.addListener("touch_event", (event) => {
       // While the custom dashboard is visible it owns its focus/navigation
       // gestures; do not leak those into a miniapp running underneath it.
-      if (customDashboardService.handleGesture(event.gestureName)) return
+      if (dashboardCoordinator.handleGesture(event.gestureName)) return
 
       // Gesture-dots debug indicator (any device, gated by its setting). It
       // only paints while the screen is otherwise empty; the gesture still
@@ -227,7 +227,7 @@ export function startDeviceEventRouter(): void {
         if (miniappExitGesture.tryExitVisibleMiniapp()) return
 
         // Eligible G2 custom firmware replaces the native dashboard.
-        if (customDashboardService.toggle()) return
+        if (dashboardCoordinator.toggleCustom()) return
 
         const useNativeDashboard = useSettingsStore.getState().getSetting(SETTINGS.use_native_dashboard.key) !== false
         if (useNativeDashboard) {
@@ -238,9 +238,7 @@ export function startDeviceEventRouter(): void {
             })
           }
         } else {
-          void Promise.resolve(BluetoothSdk.toggleHeadUp()).catch((err) => {
-            console.error("DeviceEventRouter: toggleHeadUp failed:", err)
-          })
+          dashboardCoordinator.toggleLegacy()
         }
       }
     }),
@@ -259,7 +257,7 @@ export function startDeviceEventRouter(): void {
   // Head position — translate native {up:boolean} → SDK {position:"up"|"down"}.
   subs.push(
     BluetoothSdk.addListener("head_up", (event) => {
-      customDashboardService.setHeadUp(event.up)
+      dashboardCoordinator.setHeadUp(event.up)
       localMiniappRuntime.forwardEvent("head_up", {position: event.up ? "up" : "down", timestamp: Date.now()})
     }),
   )

package/src/services/LocalDisplayManager.ts

@@ -153,6 +153,9 @@ class LocalDisplayManager {
   private bootingApp: BootingApp | null = null
   private bootQueue: Map<string, {payload: DisplayPayload; resolve?: DisplayRequestResolver}> = new Map()
 
+  /** While true the dashboard owns the glasses: main frames are retained but not sent. */
+  private dashboardActive = false
+
   /** Miniapp whose visible frame is temporarily covered by an OS exit notice. */
   private exitingApp: {packageName: string; coveredDisplay: ActiveDisplay} | null = null
 
@@ -419,6 +422,47 @@ class LocalDisplayManager {
     this.finishMiniappExit(packageName)
   }
 
+  // ===========================================================================
+  // Dashboard switching (called from DashboardCoordinator)
+  // ===========================================================================
+
+  /**
+   * Dashboard cover state. On deactivate the retained main frame repaints
+   * (scenes replay create-based; legacy re-sends), or the glasses clear.
+   */
+  public setDashboardActive(active: boolean): void {
+    if (this.dashboardActive === active) return
+    this.dashboardActive = active
+    useDisplayStore.getState().setDashboardActive(active)
+    if (active) return
+    sceneRenderer.markViewStale("dashboard")
+    const current = this.currentDisplay
+    if (current && (current.expiresAt === null || this.now() < current.expiresAt)) {
+      this.replayCurrent()
+    } else {
+      this.sendClear()
+    }
+  }
+
+  /** Dashboard renderers only; bypasses arbitration and main ownership state. */
+  public renderDashboard(packageName: string, payload: DisplayPayload): void {
+    if (!this.dashboardActive) return
+    if (payload.scene) {
+      sceneRenderer.emitScene(packageName, "dashboard", payload.scene)
+      return
+    }
+    if (!payload.layout) return
+    const rawEvent = {view: "dashboard", layout: payload.layout}
+    let processedEvent: Record<string, unknown>
+    try {
+      processedEvent = displayProcessor.processDisplayEvent(rawEvent as any)
+    } catch (err) {
+      console.error(`${LOG_TAG}: DisplayProcessor error, using raw event:`, err)
+      processedEvent = rawEvent
+    }
+    this.pushToNative(processedEvent)
+  }
+
   // ===========================================================================
   // Display request API (called from LocalMiniappRuntime.handleDisplay)
   // ===========================================================================
@@ -440,10 +484,11 @@ class LocalDisplayManager {
       return
     }
 
-    // Dashboard view: pass straight through (no throttle/arbitration). Local
-    // dashboard rendering is currently a stub on the phone anyway.
+    // Dashboard view: only visible while the dashboard covers the glasses.
+    // Local miniapp dashboard content remains a stub.
     if (payload.view === "dashboard") {
-      this.sendNow(packageName, payload, resolve)
+      this.renderDashboard(packageName, payload)
+      resolve?.({status: "displayed"})
       return
     }
 
@@ -684,6 +729,23 @@ class LocalDisplayManager {
       processedEvent = rawEvent
     }
 
+    // While the dashboard covers the glasses, main frames only update the
+    // retained state; setDashboardActive(false) replays the latest.
+    if (!this.dashboardActive) this.pushToNative(processedEvent)
+
+    this.currentDisplay = {packageName, processedEvent, expiresAt}
+
+    this.clearExpiryTimer()
+    if (expiresAt !== null) {
+      const delay = Math.max(0, expiresAt - this.now())
+      this.expiryTimerId = BgTimer.setTimeout(() => {
+        this.expiryTimerId = null
+        this.handleExpiry(packageName)
+      }, delay)
+    }
+  }
+
+  private pushToNative(processedEvent: Record<string, unknown>): void {
     try {
       // The display output path is a direct btsdk call now (was a host sendDisplayEvent
       // hook) so a bare OEM renders to the glasses without wiring it.
@@ -696,17 +758,6 @@ class LocalDisplayManager {
     } catch (err) {
       console.error(`${LOG_TAG}: native display failed:`, err)
     }
-
-    this.currentDisplay = {packageName, processedEvent, expiresAt}
-
-    this.clearExpiryTimer()
-    if (expiresAt !== null) {
-      const delay = Math.max(0, expiresAt - this.now())
-      this.expiryTimerId = BgTimer.setTimeout(() => {
-        this.expiryTimerId = null
-        this.handleExpiry(packageName)
-      }, delay)
-    }
   }
 
   private handleExpiry(packageName: string): void {
@@ -913,6 +964,7 @@ class LocalDisplayManager {
     this.currentDisplay = null
     this.backgroundLock = null
     this.exitingApp = null
+    this.dashboardActive = false
     this.bootQueue.clear()
     this.now = () => Date.now()
     this.unsubscribeGlassesStatus?.()