@glassly/engine 0.3.7 → 0.3.8-dev.1000

package/src/services/PhoneCalendarService.ts

@@ -49,9 +49,16 @@ export async function listPhoneCalendarEvents(request: CalendarListRequest): Pro
   if (calendars.length === 0) return {events: [], truncated: false}
 
   const rawEvents = await Calendar.listEvents(calendars, startsAt, endsAt)
+  const seen = new Set<string>()
   const events = rawEvents
     .map(normalizeCalendarEvent)
     .filter((event) => calendarEventOverlapsWindow(event, startsAt, endsAt))
+    .filter((event) => {
+      const key = `${event.title}\n${event.startsAt}\n${event.endsAt}\n${event.allDay}`
+      if (seen.has(key)) return false
+      seen.add(key)
+      return true
+    })
     .sort((a, b) => Date.parse(a.startsAt) - Date.parse(b.startsAt) || Date.parse(a.endsAt) - Date.parse(b.endsAt))
 
   return {

package/src/services/PhoneNotificationsSync.ts

@@ -91,6 +91,11 @@ export function nativeNotificationsSupported(): boolean {
   return getModelCapabilities(model).hasNativeNotifications === true
 }
 
+function notificationRelaySupported(): boolean {
+  const model = useGlassesStore.getState().deviceModel as DeviceTypes
+  return Platform.OS === "ios" && getModelCapabilities(model).hasNotificationRelay === true
+}
+
 /** Popup durations the firmware accepts, or an empty list when it takes any. */
 export function nativeNotificationPopupSeconds(): number[] {
   const model = useGlassesStore.getState().deviceModel as DeviceTypes
@@ -141,10 +146,10 @@ export function currentPresentationOwner(hostActive: boolean): PresentationOwner
  */
 export function captureAuthorization(): "granted" | "denied" | "unknown" | "not_needed" {
   if (Platform.OS !== "ios") return "not_needed"
-  if (!nativeNotificationsSupported()) return "not_needed"
+  if (!nativeNotificationsSupported() && !notificationRelaySupported()) return "not_needed"
   const glasses = useGlassesStore.getState()
   if (!isGlassesConnected(glasses.connection)) return "unknown"
-  return glasses.ancsAuthorized ? "granted" : "denied"
+  return glasses.ancsAuthorized ? "granted" : notificationRelaySupported() ? "unknown" : "denied"
 }
 
 /**
@@ -178,7 +183,7 @@ function pushListenerConfig(): void {
 }
 
 function pushGlassesConfig(): void {
-  if (!nativeNotificationsSupported()) return
+  if (!nativeNotificationsSupported() && !notificationRelaySupported()) return
   if (!isGlassesConnected(useGlassesStore.getState().connection)) return
   void Promise.resolve(BluetoothSdk.setGlassesNotificationConfig(desiredGlassesNotificationConfig())).catch(
     (err: unknown) =>

package/src/services/STTModelManager.ts

@@ -228,6 +228,12 @@ class STTModelManager {
     return this.currentLanguage
   }
 
+  currentModelLabel(): string {
+    const language = this.config(this.currentLanguage)
+    if (!language) return this.currentLanguage
+    return language.type === "apple" ? `Apple · ${language.displayName}` : language.displayName
+  }
+
   setCurrentLanguage(code: string): void {
     if (this.config(code)) {
       this.currentLanguage = code

package/src/services/SceneRenderer.ts

@@ -250,7 +250,7 @@ class SceneRenderer {
       return {kind: "legacy", layout, degraded, dropped}
     }
 
-    const processed = processScene(elements, caps, displayProcessor.getProfile())
+    const processed = processScene(elements, caps, displayProcessor.getSceneProfile())
     // A stale baseline means the glasses were cleared since the last commit —
     // diff from empty so everything repaints (the retained frame stays valid
     // as the replay source only).

package/src/services/appStateBackupFile.ts

@@ -0,0 +1,171 @@
+/**
+ * App state backup files: the share-sheet export and file-picker restore
+ * behind Settings > Profile > Backup. What goes in the file is decided in
+ * AppStateBackup.ts; this side reads and writes the live stores.
+ */
+
+import type {MemoryImportResult} from "@glassly/miniapp"
+import {File, Paths} from "expo-file-system"
+import {Platform} from "react-native"
+import Share from "react-native-share"
+
+import {SETTINGS, useSettingsStore} from "../stores/settings"
+import {useAppStatusStore} from "../stores/apps"
+import {storage} from "../utils/storage/storage"
+import appRegistry, {saveAlwaysOnOverride, saveWidgetExpandChoice} from "./AppRegistry"
+import {
+  AppStateBackupError,
+  collectAppStateBackup,
+  miniappPrefs,
+  miniappsWithStorage,
+  parseAppStateBackup,
+  restorableSettings,
+  restoreMiniappStorage,
+  type AppStateBackupBackend,
+} from "./AppStateBackup"
+import {cloudClientService} from "./CloudClientService"
+import {memoryStore} from "./memoryStoreInstance"
+import {respawnMiniapp, runningMiniappPackages, stopMiniapp} from "./MiniappEngine"
+
+export interface AppStateExportResult {
+  success: boolean
+  cancelled?: boolean
+}
+
+export interface AppStateRestoreResult {
+  /** Settings written. */
+  settings: number
+  /** Miniapps whose storage was restored. */
+  miniapps: number
+  memory: MemoryImportResult | null
+  /** Installed when the backup was made but not on this phone now. */
+  missing: string[]
+}
+
+export interface AppStateRestoreOptions {
+  /**
+   * Install what the backup had installed and this phone lacks. Runs before
+   * the restored miniapps start again, so the dashboard comes back with every
+   * widget provider its saved layout names: it drops unknown widgets from the
+   * layout the next time it saves it.
+   */
+  reinstall?: (packageNames: string[]) => Promise<void>
+}
+
+const PICK_MIME_TYPES =
+  Platform.OS === "android" ? ["application/json", "application/octet-stream"] : ["application/json"]
+
+const backend: AppStateBackupBackend = {
+  get(key) {
+    const result = storage.load<unknown>(key)
+    return result.is_ok() ? result.value : null
+  },
+  set(key, value) {
+    const result = storage.save(key, value)
+    if (result.is_error()) throw result.error
+  },
+  keys: () => storage.getAllKeys(),
+}
+
+export async function exportAppStateFile(): Promise<AppStateExportResult> {
+  const userId = await cloudClientService.resolveUserId()
+  const installed: Array<{packageName: string; version: string; source?: string}> = []
+  for (const app of await appRegistry.getInstalledMiniapps()) {
+    const version = await appRegistry.getActiveVersion(app.packageName)
+    if (!version) continue
+    installed.push({
+      packageName: app.packageName,
+      version,
+      source: appRegistry.getReleaseIdentity(app.packageName, version)?.source,
+    })
+  }
+  const backup = collectAppStateBackup({
+    backend,
+    userId,
+    settings: Object.values(SETTINGS),
+    installed,
+    memory: await memoryStore.exportBackup(),
+    now: Date.now(),
+  })
+
+  const filename = `glassly-backup-${localDate(backup.exportedAt)}.json`
+  const file = new File(Paths.cache, filename)
+  file.writeSync(JSON.stringify(backup))
+  try {
+    await Share.open({url: file.uri, type: "application/json", filename, title: "Glassly backup"})
+    return {success: true}
+  } catch (error: any) {
+    // react-native-share rejects when the user dismisses the sheet.
+    if (error?.message?.includes("User did not share")) return {success: false, cancelled: true}
+    throw error
+  }
+}
+
+/** Resolves null when the user cancels the picker. */
+export async function importAppStateFile(opts: AppStateRestoreOptions = {}): Promise<AppStateRestoreResult | null> {
+  const picked = await File.pickFileAsync({mimeTypes: PICK_MIME_TYPES})
+  if (picked.canceled) return null
+  let data: unknown
+  try {
+    data = JSON.parse(await picked.result.text())
+  } catch {
+    throw new AppStateBackupError("Not a Glassly app state backup")
+  }
+  const backup = parseAppStateBackup(data)
+  const userId = await cloudClientService.resolveUserId()
+
+  // First, so a memory section this build rejects fails the restore before anything is written.
+  const memory = backup.memory ? await memoryStore.importBackup(backup.memory) : null
+
+  const {plain, indexed} = restorableSettings(backup, Object.values(SETTINGS))
+  const written = await useSettingsStore.getState().setManyLocally(plain)
+  if (written.is_error()) throw written.error
+  // setManyLocally only takes registry keys; `key:index` values go to storage and the store directly.
+  for (const [key, value] of Object.entries(indexed)) backend.set(key, value)
+  if (Object.keys(indexed).length > 0) {
+    useSettingsStore.setState((state) => ({settings: {...state.settings, ...indexed}}))
+  }
+
+  // A running miniapp holds its old values in memory and could write them back over the
+  // restore, so the ones getting storage stop now and start again at the end.
+  const running = new Set(runningMiniappPackages())
+  const restarting = miniappsWithStorage(backup).filter((packageName) => running.has(packageName))
+  for (const packageName of restarting) await stopMiniapp(packageName)
+
+  try {
+    const restored = restoreMiniappStorage(backend, userId, backup)
+
+    const apps = useAppStatusStore.getState()
+    for (const [packageName, record] of Object.entries(backup.miniapps)) {
+      const prefs = miniappPrefs(record)
+      if (prefs.hidden !== undefined) apps.setHiddenStatus(packageName, prefs.hidden)
+      if (prefs.alwaysOn !== undefined) saveAlwaysOnOverride(packageName, prefs.alwaysOn)
+      for (const [widgetId, expand] of Object.entries(prefs.widgetExpand)) {
+        saveWidgetExpandChoice(packageName, widgetId, expand)
+      }
+    }
+    appRegistry.markRefreshNeeded()
+    await apps.refresh()
+
+    const installedNow = new Set((await appRegistry.getInstalledMiniapps()).map((app) => app.packageName))
+    const missing = Object.entries(backup.miniapps)
+      .filter(([packageName, record]) => record.installed && !installedNow.has(packageName))
+      .map(([packageName]) => packageName)
+    if (missing.length > 0) await opts.reinstall?.(missing)
+
+    return {
+      settings: Object.keys(plain).length + Object.keys(indexed).length,
+      miniapps: restored.packages.length,
+      memory,
+      missing,
+    }
+  } finally {
+    for (const packageName of restarting) await respawnMiniapp(packageName)
+  }
+}
+
+function localDate(ms: number): string {
+  const d = new Date(ms)
+  const pad = (n: number) => String(n).padStart(2, "0")
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
+}

package/src/services/controllers.ts

@@ -26,8 +26,8 @@ const NEURAL_BAND_SURFACE: InputSurface = {
   ],
 }
 
-/** The Apple Watch trackpad's taps and four-way swipes, and the Digital Crown as the dial. */
-const APPLE_WATCH_SURFACE: InputSurface = {
+/** A watch trackpad's taps and four-way swipes, and the crown (Apple) or rotary bezel (Wear OS) as the dial. */
+const WATCH_SURFACE: InputSurface = {
   type: "swipe2d",
   events: [
     "TAP",
@@ -42,10 +42,20 @@ const APPLE_WATCH_SURFACE: InputSurface = {
   ],
 }
 
+/** The Gamebrick's D-pad is four absolute swipes; A is the press lifecycle (tap and hold) and B a double tap. */
+const GAMEBRICK_SURFACE: InputSurface = {
+  type: "swipe2d",
+  events: ["TAP", "DOUBLE_TAP", "PRESS_HOLD", "SWIPE_UP", "SWIPE_DOWN", "SWIPE_LEFT", "SWIPE_RIGHT"],
+}
+
 // The R1 swipes up/down like the temples it stands in for, so it adds nothing.
 const INPUT_SURFACES: Readonly<Record<string, readonly InputSurface[]>> = {
   [ControllerTypes.NEURAL_BAND]: [NEURAL_BAND_SURFACE],
-  [ControllerTypes.APPLE_WATCH]: [APPLE_WATCH_SURFACE],
+  [ControllerTypes.APPLE_WATCH]: [WATCH_SURFACE],
+  [ControllerTypes.WEAR_OS]: [WATCH_SURFACE],
+  [ControllerTypes.GAMEBRICK]: [GAMEBRICK_SURFACE],
+  [ControllerTypes.IINE_ANANKE]: [GAMEBRICK_SURFACE],
+  [ControllerTypes.ZERO2]: [GAMEBRICK_SURFACE],
   [ControllerTypes.R1]: [],
 }
 

package/src/services/effectiveCapabilities.ts

@@ -61,6 +61,8 @@ function glassesCapabilities(model: DeviceTypes): Capabilities {
   // Glassly CFW supports the complete vector contract, including SVG and rotation.
   // Upstream g2flash publishes a raster canvas with sceneVector=false.
   const vector = useGlassesStore.getState().sceneVector === true
+  // Depth is a disparity between the lenses; one panel (MemoMind One) draws every element flat.
+  const stereo = (base.display.count ?? 1) >= 2
   return {
     ...(volumeGate ? withVolumeGate(base) : base),
     hasNativeNavigation: resolveNativeNavigation(base.hasNativeNavigation, true, forceNativeNavigationOnCfw()),
@@ -68,6 +70,9 @@ function glassesCapabilities(model: DeviceTypes): Capabilities {
       ...base.display,
       width: canvas.width,
       height: canvas.height,
+      // A Glassly CFW that publishes a canvas takes positioned elements, whatever
+      // the stock profile says (the G1's stock firmware degrades scenes to text walls).
+      canPosition: true,
       maxTextElements: Math.max(
         base.display.maxTextElements ?? 0,
         vector ? CFW_VECTOR_MAX_ELEMENTS : CFW_MAX_TEXT_ELEMENTS,
@@ -78,7 +83,7 @@ function glassesCapabilities(model: DeviceTypes): Capabilities {
         vector ? CFW_VECTOR_MAX_ELEMENTS : CFW_MAX_IMAGE_ELEMENTS,
       ),
       ...(vector
-        ? {shapes: [...ALL_DISPLAY_SHAPES, "svg" as const], animation: true, rotation: true, depth: true}
+        ? {shapes: [...ALL_DISPLAY_SHAPES, "svg" as const], animation: true, rotation: true, depth: stereo}
         : {}),
     },
   }

package/src/services/pages/pageEligibility.ts

@@ -13,7 +13,10 @@ import {isGlassesConnected} from "../GlassesReadiness"
 
 /** The SGC appends this marker after the firmware advertises Glassly CFW capabilities (G2, RayNeo iO). */
 export function isCfwFirmwareVersion(firmwareVersion: string | null | undefined): boolean {
-  return firmwareVersion?.toLowerCase().includes("glassly cfw") === true
+  return (
+    firmwareVersion?.toLowerCase().includes("glassly cfw") === true ||
+    /^GLASSLYCFW\/[0-9]+$/.test(firmwareVersion ?? "")
+  )
 }
 
 /**
@@ -23,6 +26,11 @@ export function isCfwFirmwareVersion(firmwareVersion: string | null | undefined)
  */
 export function isCustomDashboardEligible(info: {model?: string | null; firmwareVersion?: string | null}): boolean {
   if (!info.model) return false
+  if (info.model === DeviceTypes.MEMOMIND_ONE) {
+    const match = /^GLASSLYCFW\/([0-9]+)$/.exec(info.firmwareVersion ?? "")
+    const revision = match ? Number(match[1]) : 0
+    return Number.isSafeInteger(revision) && revision >= 10
+  }
   return (
     getModelCapabilities(info.model as DeviceTypes).hasCustomFirmware === true &&
     isCfwFirmwareVersion(info.firmwareVersion)

package/src/services/settingsBridge.ts

@@ -38,6 +38,7 @@ export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>
   notifications_enabled: "write",
   notifications_popups: "write",
   notifications_popup_seconds: "write",
+  notifications_batch_seconds: "write",
   notifications_hold_during_apps: "write",
   notifications_ignore_while_active: "write",
   notifications_blocklist: "write",

package/src/services/{appleWatch/AppleWatchLink.ts → watch/WatchLink.ts}

@@ -1,15 +1,15 @@
 /**
- * The Apple Watch remote's phone half: the watch app's status context (glasses, the miniapp in
+ * The watch remote's phone half, for the Apple Watch (iOS, WatchConnectivity) and a Wear OS
+ * watch (Android, Wearable Data Layer) alike: the watch app's status (glasses, the miniapp in
  * front, launchable miniapps, whether Assist takes questions, the mirror setting), mirror frames
  * while the setting is on, and the commands the watch sends back. Native adds whether the active
  * watch is paired and keeps the newest frame for when the watch app opens. Gestures ride
  * `touch_event` like any controller's.
  */
-import type {AppleWatchCommandEvent} from "@glassly/bluetooth-sdk"
+import type {WatchCommandEvent} from "@glassly/bluetooth-sdk"
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 import type {MirrorSnapshot} from "@glassly/miniapp"
 import {MiniappStreamType} from "@glassly/miniapp"
-import {Platform} from "react-native"
 
 import {useAppStatusStore} from "../../stores/apps"
 import {useGlassesStore} from "../../stores/glasses"
@@ -23,7 +23,7 @@ import {keyEventsForTextChange} from "../neuralBand/NeuralBandInput"
 
 export const ASSIST_PACKAGE = "com.glassly.assistant"
 export const ASSIST_ACTION = "ask"
-/** WatchConnectivity messages top out near 64 KB; frames past this are skipped, not truncated. */
+/** WatchConnectivity messages top out near 64 KB (Data Layer messages at 100 KB); frames past this are skipped, not truncated. */
 const MAX_FRAME_BYTES = 48_000
 const MAX_IMAGE_CHARS = 16_000
 const MAX_APPS = 24
@@ -142,7 +142,7 @@ export function mirrorFrame(snapshot: MirrorSnapshot): Record<string, unknown> |
   return JSON.stringify(frame).length > MAX_FRAME_BYTES ? null : frame
 }
 
-export interface AppleWatchCommandDeps {
+export interface WatchCommandDeps {
   apps: () => readonly ClientApp[]
   start: (app: ClientApp) => Promise<unknown>
   stop: (packageName: string) => Promise<unknown>
@@ -151,7 +151,7 @@ export interface AppleWatchCommandDeps {
   now: () => number
 }
 
-const defaultDeps: AppleWatchCommandDeps = {
+const defaultDeps: WatchCommandDeps = {
   apps: () => useAppStatusStore.getState().apps,
   start: (app) => useAppStatusStore.getState().start(app),
   stop: (packageName) => useAppStatusStore.getState().stop(packageName),
@@ -160,9 +160,9 @@ const defaultDeps: AppleWatchCommandDeps = {
   now: () => Date.now(),
 }
 
-export async function handleAppleWatchCommand(
-  event: AppleWatchCommandEvent,
-  deps: AppleWatchCommandDeps = defaultDeps,
+export async function handleWatchCommand(
+  event: WatchCommandEvent,
+  deps: WatchCommandDeps = defaultDeps,
 ): Promise<void> {
   switch (event.command) {
     case "launch": {
@@ -170,7 +170,7 @@ export async function handleAppleWatchCommand(
         ? deps.apps().find((entry) => entry.packageName === event.packageName)
         : undefined
       if (!app) {
-        console.warn(`AppleWatch: launch of unknown miniapp ${event.packageName}`)
+        console.warn(`Watch: launch of unknown miniapp ${event.packageName}`)
         return
       }
       await deps.start(app)
@@ -206,7 +206,7 @@ function currentState(): Record<string, unknown> {
     },
     apps: useAppStatusStore.getState().apps,
     assist: localMiniappRuntime.hostActionAvailable(ASSIST_PACKAGE, ASSIST_ACTION),
-    mirror: useSettingsStore.getState().getSetting(SETTINGS.apple_watch_mirror.key) === true,
+    mirror: useSettingsStore.getState().getSetting(SETTINGS.watch_mirror.key) === true,
   })
 }
 
@@ -226,7 +226,7 @@ function syncMirror(enabled: boolean): void {
   const send = (snapshot: MirrorSnapshot) => {
     lastSentAt = Date.now()
     void BluetoothSdk.setWatchMirror(mirrorFrame(snapshot)).catch((err) =>
-      console.warn("AppleWatch: mirror push failed:", err),
+      console.warn("Watch: mirror push failed:", err),
     )
   }
   const unsubscribe = mirrorService.subscribe((snapshot) => {
@@ -252,8 +252,8 @@ function syncMirror(enabled: boolean): void {
   }
 }
 
-export function startAppleWatchLink(): void {
-  if (Platform.OS !== "ios" || stops.length > 0) return
+export function startWatchLink(): void {
+  if (stops.length > 0) return
   let lastKey = ""
   let timer: ReturnType<typeof BgTimer.setTimeout> | null = null
   const push = () => {
@@ -262,21 +262,21 @@ export function startAppleWatchLink(): void {
     const key = JSON.stringify(state)
     if (key === lastKey) return
     lastKey = key
-    void BluetoothSdk.setWatchState(state).catch((err) => console.warn("AppleWatch: state push failed:", err))
+    void BluetoothSdk.setWatchState(state).catch((err) => console.warn("Watch: state push failed:", err))
   }
   const schedule = () => {
     timer ??= BgTimer.setTimeout(push, STATE_DEBOUNCE_MS)
   }
-  const mirrorEnabled = () => useSettingsStore.getState().getSetting(SETTINGS.apple_watch_mirror.key) === true
-  const commands = BluetoothSdk.addListener("apple_watch_command", (event) => {
-    handleAppleWatchCommand(event).catch((err) => console.warn(`AppleWatch: ${event.command} failed:`, err))
+  const mirrorEnabled = () => useSettingsStore.getState().getSetting(SETTINGS.watch_mirror.key) === true
+  const commands = BluetoothSdk.addListener("watch_command", (event) => {
+    handleWatchCommand(event).catch((err) => console.warn(`Watch: ${event.command} failed:`, err))
   })
   stops = [
     () => commands.remove(),
     useGlassesStore.subscribe(schedule),
     useAppStatusStore.subscribe(schedule),
     useSettingsStore.subscribe(
-      (s) => s.getSetting(SETTINGS.apple_watch_mirror.key),
+      (s) => s.getSetting(SETTINGS.watch_mirror.key),
       () => {
         syncMirror(mirrorEnabled())
         schedule()
@@ -291,7 +291,7 @@ export function startAppleWatchLink(): void {
   schedule()
 }
 
-export function stopAppleWatchLink(): void {
+export function stopWatchLink(): void {
   stops.splice(0).forEach((stop) => stop())
   syncMirror(false)
 }

package/src/stores/apps.ts

@@ -217,6 +217,7 @@ function projectApps(previousState: AppStatusState, localApps: ClientApp[]): Cli
     DeviceTypes.NONE
   const capabilities = getModelCapabilities(defaultWearable)
   const devToolsEnabled = useSettingsStore.getState().getSetting(SETTINGS.dev_tools.key) === true
+  const persistScreenshots = useSettingsStore.getState().getSetting(SETTINGS.persist_miniapp_screenshots.key) !== false
   const hasPairedGlasses = useSettingsStore.getState().getSetting(SETTINGS.has_paired_glasses.key) === true
 
   // Single pass: dedupe → screenshot carry-over → compat → hidden, all into
@@ -246,7 +247,10 @@ function projectApps(previousState: AppStatusState, localApps: ClientApp[]): Cli
     .map((app) => {
       const next: ClientApp = {
         ...app,
-        screenshot: previousByPackage.get(app.packageName)?.screenshot ?? app.screenshot,
+        // The registry's screenshot is the one restored from disk; only an
+        // in-memory capture carries over when persistence is off.
+        screenshot:
+          previousByPackage.get(app.packageName)?.screenshot ?? (persistScreenshots ? app.screenshot : undefined),
         compatibility: HardwareCompatibility.checkCompatibility(app.hardwareRequirements, capabilities),
         // A registry source can force an app off the primary home screen.
         // Compose that gate with the user's persisted home-screen layout instead
@@ -384,15 +388,6 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
     // owns the settings store).
     useSettingsStore.getState().setSetting(SETTINGS.has_ever_activated_app.key, true)
 
-    // If the tapped app is already running, this is a re-open: the nav/foreground
-    // above already drove the animation, and there's nothing to spawn. Short-
-    // circuit before the spawn pipeline. A promoted app keeps its context but
-    // still takes the foreground below.
-    if (app.running && !app.widgetOnly) {
-      saveLastOpenTime(packageName)
-      return true
-    }
-
     // Only-one rules: one standard app in the foreground, one dashboard
     // drawing the overlay. Starting another stops the one running. Widget-only
     // peers hold no foreground, so they stay.
@@ -405,6 +400,17 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       }
     }
 
+    // If the tapped app is already running, this is a re-open: the nav/foreground
+    // above already drove the animation, and there's nothing to spawn. Short-
+    // circuit before the spawn pipeline. A promoted app keeps its context but
+    // still takes the foreground below.
+    if (app.running && !app.widgetOnly) {
+      saveLastOpenTime(packageName)
+      // The running background only knows the source of its spawn.
+      if (app.local) miniappLauncher.notifyLaunch(packageName, opts?.launchSource ?? "phone")
+      return true
+    }
+
     set((s) => ({
       apps: s.apps.map((a) => (a.packageName === packageName ? {...a, running: true, loading: false} : a)),
     }))
@@ -543,7 +549,12 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
   },
 
   saveScreenshot: async (packageName: string, screenshot: string) => {
-    storage.save(`${packageName}_screenshot`, screenshot)
+    const key = `${packageName}_screenshot`
+    if (useSettingsStore.getState().getSetting(SETTINGS.persist_miniapp_screenshots.key) !== false) {
+      storage.save(key, screenshot)
+    } else {
+      storage.remove(key)
+    }
     set((s) => ({
       apps: s.apps.map((a) => (a.packageName === packageName ? {...a, screenshot} : a)),
     }))