BasedHardware/omi

This system is a comprehensive mobile and backend platform for managing AI-powered voice interactions with wearable hardware. It provides a Flutter-based mobile application that handles device connectivity via Bluetooth Low Energy, captures audio for speech-to-text processing, and manages user data including conversations, action items, and memories. The backend infrastructure supports self-hosted AI model deployment, WebSocket bridging, and scalable Kubernetes deployments for various microservices. The platform integrates with external services like ClickUp, GitHub, and Apple Health, while offering a modular plugin architecture for extending functionality.

83 changes.

This period was defined by the introduction of the Omi mobile application, featuring a complete Flutter codebase with native iOS and Android integrations for audio capture, BLE, and wearable connectivity. Concurrently, the backend evolved to support an agentic chat system with tool-use capabilities, while the plugin infrastructure was consolidated into a shared SDK.

70 changes.

This period focused on expanding the Omi ecosystem by introducing support for new hardware, including Apple Watch, Ray-Ban Meta glasses, and OmiGlass, alongside a comprehensive React Native SDK for third-party developers. The backend and app were updated to support a broader range of devices and integrations, while the web platform grew with an admin dashboard, app store, and persona chat interface. Infrastructure was also strengthened with new Helm charts, CI/CD scripts, and internal tooling to support the growing complexity of the platform.

125 changes.

This period focused on launching the V3 memory system, introducing a new LLM gateway, and modernizing the backend with Rust SDKs and Kubernetes charts. It also expanded the plugin ecosystem with numerous external integrations and added extensive test coverage for the new architecture.

A new standalone Omi chat tool is introduced in the plugins/omi-crossref-app directory, providing three no-auth endpoints for interacting with the Crossref API: searching scholarly works by keyword, fetching work details by DOI, and listing recent works by author. The app is a FastAPI service that exposes a /tools endpoint for tool discovery and a /.well-known/omi-tools.json manifest for Omi integration, with deployment configuration for Railway/Heroku-style hosts.

plugins/omi-crossref-app, plugins/omi-pubmed-app, plugins/omi-semantic-scholar-app · high confidence

A new standalone Omi app has been added to support currency conversion and reference exchange rate lookups using the public Frankfurter API. Users can now convert amounts between currencies, fetch the latest reference rates for a base currency, and list supported currencies directly through Omi chat tools, without requiring authentication or API keys.

plugins/omi-frankfurter-app · high confidence

A new standalone FastAPI service has been added in the plugins/omi-hacker-news-app directory, enabling Omi users to read the Hacker News front page, search stories by keyword, and fetch item discussions. The app exposes three chat tools—get\_front\_page, search\_stories, and get\_discussion—via a tools manifest at /.well-known/omi-tools.json, and includes deployment configuration for the Railway platform.

plugins/omi-hacker-news-app · high confidence

Introduces a new Helm chart for the LLM Gateway service, enabling deployment to Kubernetes environments. The chart includes configuration files for dev and prod environments, defining container specs, health checks, and autoscaling policies. It also includes templates for the Kubernetes Deployment, Service, Ingress, and Horizontal Pod Autoscaler, allowing the LLM Gateway to be deployed as a scalable, monitored service within the cluster.

backend/charts/llm-gateway · high confidence

A new module at backend/utils/imports/limitless.py introduces support for importing data from the Limitless lifelog format. This includes parsing markdown files to extract conversation titles, summaries, and transcript segments, as well as handling filename-based metadata extraction. The implementation converts Limitless data into internal Conversation and TranscriptSegment models, enabling users to import existing Limitless records directly into the system without AI processing.

backend/utils/imports · high confidence

A new standalone FastAPI service (plugins/omi-ms365-app) is introduced to integrate Microsoft 365 capabilities with Omi. It provides tools for Outlook Mail, Calendar, Teams, and OneDrive/SharePoint, exposing endpoints for OAuth setup, tool execution, and a tool manifest. The app handles Microsoft Graph API interactions, including throttling-aware retries and token caching (via Redis or in-memory storage).

plugins/omi-ms365-app · high confidence

Introduces a new Helm chart for the self-hosted NLLB translation service, providing Kubernetes manifests for deployment, horizontal pod autoscaling (scaling on active requests rather than just CPU), internal load-balanced ingress, and Prometheus monitoring with alerting rules for model health, error rates, latency, and SLO burn rates.

backend/charts/nllb-translation · high confidence

Introduces a new plugin at plugins/composio that enables users to connect their Notion accounts via OAuth, extract memories and facts from Notion pages and databases, and import them into their OMI account. The change adds a FastAPI-based backend (main.py, src/notion.py, src/omi\_api.py) with a SQLite database (src/db.py) to store credentials and extracted memories, along with HTML templates (templates/index.html, templates/notion\_import.html, templates/notion\_success.html) and static assets. The plugin exposes API endpoints for Notion authentication, memory extraction, and memory import, providing a mobile-optimized UI for the integration workflow.

plugins/composio · high confidence

The Deepgram self-hosted product now includes a new 'nova-2' Helm chart located in the backend directory, providing a standardized way to deploy the latest Deepgram models on Kubernetes. This update introduces a comprehensive set of configuration files, including a detailed GKE deployment guide, a changelog tracking version history, and sample values files for development and production environments. The chart supports autoscaling for the Engine and API components, allowing users to configure scaling metrics such as request capacity ratios and replica limits to optimize cost and performance.

backend/charts/deepgram-self-hosted · high confidence

Added the omi-twitter-app plugin, enabling voice-activated Twitter posting through an OMI device. The app uses FastAPI to handle OAuth 2.0 authentication with Twitter, processes voice segments via OpenAI's GPT-4o-mini to extract and clean tweet content, and posts to Twitter. It includes persistent storage for user tokens and sessions, with deployment configuration for Railway.

_plugins/\multion, plugins/omi-dropbox-app, plugins/omi-twitter-app · high confidence

Users can now ask Omi to call Uber for a ride. This new plugin exposes a \call\_uber\ tool that accepts a destination and optional pickup/dropoff coordinates, then returns a confirmation-safe deep link to the Uber app or mobile web. The integration uses Uber's public deep-link flow, meaning the user must review and confirm the ride inside Uber before any action is taken; no credentials or payment data are stored.

_plugins/uber\call · high confidence

A new plugin in the plugins/hume-ai directory introduces a Python FastAPI service that receives real-time audio streams from Omi devices, analyzes emotions using the Hume AI Speech Prosody Model, and sends automatic notifications via the Omi app. The implementation includes a live dashboard displaying emotion statistics and a 'Rizz Meter' score, configurable emotion notification thresholds, and background tasks for audio file cleanup and memory saving. The plugin is fully containerized with a Dockerfile and includes a Render deployment configuration, a startup script for local development with ngrok, and dedicated test scripts for notification and audio chunking.

plugins/hume-ai · high confidence

Users can now use Omi to look up packaged food facts, search for products by name or barcode, compare up to five products, and check for allergens or ingredients to avoid. The new app connects to the public Open Food Facts API to provide nutrition details, Nutri-Score, NOVA group, and Eco-Score data without requiring user authentication or API keys.

plugins/omi-openfoodfacts-app · high confidence

A new standalone FastAPI application has been added at plugins/omi-open-meteo-app, providing chat tools for current weather, short forecasts, and air-quality readings via the public Open-Meteo APIs. The app exposes endpoints for get\_current\_weather, get\_weather\_forecast, and get\_air\_quality, and includes deployment configuration for Railway and Heroku-style platforms.

plugins/omi-open-meteo-app · high confidence

Introduces a new OpenTofu-based infrastructure layer for managing GCP foundation resources, including a read-only development Workload Identity Federation (WIF) pilot. This adds the \infrastructure/opentofu\ directory with a \foundation\ module for durable GCP resources (GitHub WIF pools, service accounts, IAM grants) and a \pilots/development-wif-plan\ module that provisions a restricted, development-only GitHub OIDC identity for OpenTofu operations. The change includes backend configuration examples, provider lock files, and validation scripts to ensure the pilot remains isolated to the \based-hardware-dev\ project and specific GitHub repository/owner IDs, preventing unauthorized access or resource mutation.

infrastructure · high confidence

A new PostHogAnalyticsAdapter has been introduced to handle analytics events via the PostHog SDK. This implementation supports user identification, event tracking, and screen context registration, with lifecycle event capture explicitly disabled to allow manual control over when events are recorded.

app/lib/utils/analytics/adapters · high confidence

The app now includes a native iOS implementation for the Ray-Ban Meta glasses, enabling Bluetooth HFP microphone audio capture and device discovery. This adds a new \RayBanMetaAudioCapture\ class that handles audio routing, format conversion, and interruption handling, alongside a \RayBanMetaHostApiImpl\ that exposes these capabilities to the Flutter layer via Pigeon. The implementation supports two build modes: a 'full' mode with the Meta Wearables Device Access Toolkit (MWDAT) for camera and audio, and an 'audio\_only' mode that provides HFP microphone support without the SDK.

app/ios/Runner/RayBanMeta · high confidence

A new ReferralPage has been added to the app, displaying an embedded web view of the affiliate program at https://affiliate.omi.me/. The page includes a loading indicator while the web content loads and tracks the page opening via the analytics system.

app/lib/pages/referral · high confidence

A new standalone Omi app has been added in the plugins/omi-stack-overflow-app directory, enabling users to search Stack Overflow and read top answers from Omi conversations. The app exposes chat tools for searching questions by query and tags, fetching specific questions, and retrieving top answers via the public Stack Exchange API. It is configured for deployment on platforms like Railway or Heroku, using Python 3.11 and Uvicorn, and includes health check and tool manifest endpoints.

(repo-wide) · high confidence

The project now includes the necessary build configuration files to support native iOS and Android development. On the iOS/macOS side, new \Package.swift\ and \Package.resolved\ files define Swift Package Manager dependencies for AudioKit, swift-opus, and SwiftWhisper, enabling local speech-to-text and audio processing capabilities. Simultaneously, the Android build system has been updated with new \build.gradle\ and \settings.gradle\ files that configure the Android SDK, Kotlin, and Flutter plugins, ensuring the app can be built and deployed on Android devices.

(dependencies) · high confidence

A new Omi integration for querying the USGS earthquake catalog is now available. The app exposes three chat tools—recent\_earthquakes, nearby\_earthquakes, and earthquake\_details—allowing users to search for global or location-specific seismic activity without authentication. The service is configured for deployment on Railway and includes a /health endpoint and unit tests to verify tool manifests and response structures.

plugins/omi-usgs-earthquake-app · high confidence

The VAD (Voice Activity Detection) service is now deployable via a new Helm chart located in \backend/charts/vad\. This includes the core chart structure (\Chart.yaml\), default values, and environment-specific value files (\dev\_omi\_vad\_values.yaml\, \prod\_omi\_vad\_values.yaml\) that configure Kubernetes resources such as the Deployment, HorizontalPodAutoscaler, Ingress, and Service. The configuration enables autoscaling based on request latency and provides the necessary infrastructure for deploying the VAD service across different environments.

backend/charts/vad · high confidence

A new app detail page has been added at /apps/\[id\], featuring a responsive layout with hero section, rating display, and related apps. The page includes JSON-LD structured data for search engine optimization and includes metadata generation for social sharing.

web/app/src/app/(public)/apps/\[id\] · high confidence

Users can now browse apps by category. A new page at /apps/category/\[category\] displays apps in a given category, showing 'New/Recent' and 'Most Popular' sections, along with a full list of all apps in that category. The page includes SEO metadata and structured data for search engines.

web/frontend/src/app/apps/category · high confidence

Users can now configure a custom backend URL during onboarding via a new form that validates the URL format and requires a trailing slash. Additionally, new sign-in and sign-up forms have been introduced, featuring validation for email, password length, and password matching, with all UI text localized via l10n extensions.

_app/lib/pages/onboarding/custom\auth · high confidence

Users are now presented with a new 5-slide onboarding experience for their Omi device. This flow explains key device features including charging status (orange light), offline status (red light), connection status (blue light), voice interaction, and power control. The onboarding includes video tutorials for each step and tracks analytics events for each slide. Upon completion, the app marks the onboarding as finished and navigates to the home page.

_app/lib/pages/onboarding/device\onboarding · high confidence

Introduced three new external plugin applications—Hive, Linear, and ShipBob—each providing a dedicated integration for managing projects, issues, and inventory respectively. Each plugin includes a FastAPI-based backend (main.py, db.py, models.py) that handles authentication (API keys or OAuth), exposes chat tools for voice commands, and manages user settings and credentials. The apps are configured for deployment on Railway (railway.toml, Procfile) and include setup templates (templates/setup.html) and documentation (README.md) to guide users through connection and configuration.

(repo-wide) · high confidence

Added the \omi-clickup-app\ and \omi-github-app\ as external plugins, each providing voice-activated integration with their respective services. The ClickUp plugin enables voice commands to create tasks via AI extraction, OAuth 2.0 authentication, and OMI notifications. The GitHub plugin allows users to create issues from voice feedback, featuring repository selection, AI-powered title and description generation, and mobile-first UI. Both plugins include full deployment configurations (Railway, Docker), storage management, and documentation.

(repo-wide) · high confidence

A new utility file, folder\_icon\_mapper.dart, has been added to map folder icon strings (emojis) to FontAwesome icon data, providing a consistent set of icons for folder categories.

app/lib/utils/folders · high confidence

A new \ActionItemExportService\ has been introduced to handle the headless, single-item export logic for the bulk export flow. This service supports exporting action items to multiple integrations, including Apple Reminders, Asana, ClickUp, Google Tasks, and Todoist. It returns specific results for success, already-exported, or failure states, and logs analytics for each export attempt.

_app/lib/pages/action\items/services · high confidence

A new iOS lock screen widget has been added to display the Omi device's battery percentage and microphone mute state. The widget supports both rectangular and circular (compact 1×1) families, pulling real-time data from the app's shared defaults to show connection status, battery level, and mute state.

app/ios/BatteryWidget · high confidence

A new utility function has been added to rotate images based on their orientation metadata. The implementation decodes the image, applies the necessary rotation (90, 180, or 270 degrees), and re-encodes it as a JPEG. This provides a reliable fallback for correcting image orientation, noting that the current library does not support lossless JPEG rotation.

app/lib/utils/image · high confidence

A new Dart model for parsing firmware manifest files has been added to the app's utility layer. The \Manifest\ and \ManifestFile\ classes, generated via \json\_serializable\, define the structure for firmware metadata including format version, timestamps, and a list of image files. The parser enforces that every file in a multi-image firmware bundle must specify an \imageIndex\, ensuring that the application can correctly identify and process each component of the firmware update.

app/lib/utils/manifest · high confidence

Introduces the core of the memory ingestion pipeline, including the \verify\_output\ stage which validates generated memory structures. This stage enforces content-level grounding by ensuring that canonical text and memory text are substantiated by evidence quotes, flags confidence contradictions (e.g., high confidence with 'inferred\_not\_stated'), and prevents active memory mutations that lack sufficient quote overlap or have blocking uncertainty reasons.

_backend/utils/memory\ingestion/stages · medium confidence

Introduced several new plugin implementations: a Mem0 integration for memory extraction, a basic conversation feedback plugin using GPT-4o, a proactive mentoring plugin, a ChatGPT integration page, a manual fact-importer using GPT-4o, an IQ rating app, a 'Hey Omi' notification handler, and a Notion OAuth client. These add capabilities for memory storage, conversation analysis, proactive notifications, and external integrations.

(repo-wide) · high confidence

Users now see a new onboarding page where they can select the source of their acquisition (e.g., TikTok, YouTube, Instagram, X/Twitter, Reddit, LinkedIn, friend referral, coworker, event, app store, Google search, or other). The selected source is saved to local preferences and synced to Firestore, and the acquisition source is also sent to the analytics system for tracking.

_app/lib/pages/onboarding/found\omi · high confidence

A new onboarding flow has been introduced, featuring a 'Setup Questions' page where users can select their profession, usage context, and age range. Upon completion, the app tracks these preferences via the analytics system and navigates to the speech profile setup.

app/lib/pages/onboarding/setup · high confidence

A new \ResponsiveHelper\ utility class has been added to provide responsive layout calculations, screen size detection, and a dark theme color system. The class exposes properties for screen dimensions, breakpoints, and scaling factors, along with helper methods for calculating responsive widths, heights, typography, spacing, and grid configurations based on the device's screen size.

app/lib/utils/responsive · high confidence

Added new utility files (category.ts, metadata.ts) that define UI theme metadata for app categories and generate structured data (Schema.org) for product pages, app store listings, and breadcrumbs, improving SEO and visual consistency across the app store interface.

web/frontend/src/app/apps/utils · high confidence

Users now see a new 'LimitlessSyncCardWidget' that displays a progress bar and sync status for Limitless devices, with an option to manually trigger syncing. Additionally, 'SpeechProfileCardWidget' and 'UpdateFirmwareCardWidget' have been added to the capture page, allowing users to access speech profile settings and firmware update pages directly from the home screen.

app/lib/pages/capture/widgets · high confidence

A new CrashlyticsManager class has been introduced to integrate Firebase Crashlytics for crash reporting and logging. This adds the capability to initialize Crashlytics, identify users, log messages at various severity levels, and report crashes with stack traces, while automatically disabling collection in debug mode.

app/lib/utils/debugging · high confidence

The iOS build now includes LLDB helper scripts to improve debugging capabilities. A new Python module (flutter\_lldb\_helper.py) registers a breakpoint for NOTIFY\_DEBUGGER\_ABOUT\_RX\_PAGES to handle memory pages, and the corresponding LLDB initialization file (flutter\_lldbinit) imports this script, enabling automatic debugger integration for iOS development.

app/ios/Flutter/ephemeral · high confidence

Added comprehensive flashing instructions and firmware files for Omi firmware v3.0.8, including merged.hex, merged\_CPUNET.hex, and platform-specific J-Link scripts for both macOS and Windows. Enhanced user guidance with detailed steps for firmware replacement and verification, ensuring compatibility and functionality with the latest updates.

omi · high confidence

Developers can now use a new Rust-based test bench to simulate and interact with Omi firmware peripherals. This includes a Rust core library defining Bluetooth service UUIDs and button event types, a CLI tool for headless simulation, and a GUI emulator for scanning, connecting, and probing Bluetooth devices. The suite also provides C stubs and a Zephyr-based client for verifying device contracts, enabling automated testing of firmware behavior without physical hardware.

(repo-wide) · high confidence

Added a suite of Python scripts in backend/scripts/stt to support speech-to-text evaluation and speaker identification workflows. This includes a new \_generate\_speaker\_id\_npy.py script for generating speaker profiles from audio samples, alongside a series of benchmarking tools (l\_benchmark\_prerecorded.py, m\_benchmark\_streaming.py, n\_benchmark\_02\_prerecorded.py) that compare transcription performance across providers like Deepgram and Modulate. Additional scripts (c\_generate\_models.py, d\_test\_models.py) provide utilities for training and testing speaker embedding models, while helper scripts (e\_upload\_test\_samples.py, g\_pyannote\_api.py, h\_brainstorming.py, j\_apply\_vad\_to\_speech\_profiles.py, k\_compare\_transcripts\_performance.py) support data preparation, API integration, and performance analysis.

backend/scripts/stt · high confidence

Added new frontend pages for the app store: a dynamic route at /apps/\[id\] that renders a detailed view for individual apps (including metadata, structured data, and related apps) and a /apps/popular page that displays a grid of the most popular apps sorted by install count.

web/frontend/src/app/apps/\[id\] · high confidence

The backend now ships with the \node-feature-discovery\ and \gpu-operator\ Helm charts bundled directly within the \deepgram-self-hosted/nova-3/charts/gpu-operator\ directory. This includes the chart definitions, Kubernetes manifests (Deployments, Services, RBAC, CRDs), and helper templates for the Node Feature Discovery (NFD) components, enabling the platform to manage GPU resources and node feature discovery on self-hosted Kubernetes clusters.

(repo-wide) · high confidence

The cluster-autoscaler chart has been added to the \deepgram-self-hosted/nova-3\ directory, introducing the Kubernetes cluster-autoscaler as a managed component of the self-hosted deployment. This change enables automatic scaling of Kubernetes worker nodes within autoscaling groups, allowing the infrastructure to dynamically adjust to workload demands.

backend/charts/deepgram-self-hosted/nova-3/charts/cluster-autoscaler, backend/charts/deepgram-self-hosted/nova-3/charts/prometheus-adapter · high confidence

Users can now connect and interact with Apple Watch, Ray-Ban Meta glasses, and BLE peripherals through new bridge implementations. These bridges translate native platform callbacks into Dart-side events, enabling features like audio chunk streaming, battery level updates, camera state changes, and connection state monitoring for these specific devices.

app/lib/services/bridges · medium confidence

The backend now includes a suite of migration scripts to initialize and update user data. These scripts handle backfilling vector embeddings for memories and action items into Pinecone, migrating action items to a dedicated collection, populating historical usage statistics, and automatically setting transcription modes based on user language preferences. Additionally, a script is provided to backfill the genesis memory ledger.

backend/migrations · high confidence

Added prebuilt configuration files for Firebase and app signing to the app setup directory. This includes \GoogleService-Info.plist\ and \firebase\_options.dart\ for iOS/macOS/Android/Web Firebase initialization, \google-services.json\ for Android Firebase setup, and \key.properties\ for Android debug keystore configuration, enabling the app to connect to the 'based-hardware-dev' Firebase project and support web, iOS, macOS, and Android platforms.

app/setup/prebuilt · medium confidence

A new Python utility, build\_wav\_from\_bytes.py, has been added to the backend/scripts/vad directory. This script reads raw audio data from a text file containing hexadecimal strings and converts it into a standard 8kHz, mono, 16-bit WAV file. This tool allows users to reconstruct playable audio files from raw byte representations, which is useful for debugging or post-processing audio data in the VAD pipeline.

backend/scripts/vad · medium confidence

A new support script, find\_stripe\_entitlement\_mismatches.py, has been added to the backend/scripts/support directory. This tool scans for discrepancies between active Stripe subscriptions and Firestore user records, helping identify users whose paid status in the database does not match their active Stripe subscriptions. The script operates in a read-only mode, comparing Stripe subscription data against Firestore to surface potential consistency issues.

backend/scripts/support · high confidence

Added a new admin CLI script (backend/scripts/admin/reset\_transcription\_usage.py) that allows support operations to inspect a user's monthly transcription usage and reset their quota. The tool provides a 'show' command to view plan, used, limit, and remaining minutes, and a 'reset-month' command to zero out usage data, with dry-run support and durable audit logging.

backend/scripts/admin · high confidence

The admin dashboard now includes new pages for managing affiliates (listing, filtering, and viewing details), a Chat Lab for testing and evaluating system prompts, and a Fair Use management interface for handling flagged users and enforcement actions. These additions expand the admin's ability to monitor and manage third-party partners, refine chat system prompts, and enforce usage policies.

web/admin · high confidence

The Android app's native layer has been restructured and expanded. A new \NotificationOnKillService\ ensures users receive proactive feedback notifications even if the app is killed. The \MainActivity\ now registers native Pigeon APIs for BLE, phone-mic capture, and background audio streaming, while also managing the lifecycle of companion device connections. A new \WifiNetworkPlugin\ enables connecting to the Omi device's access point. The app also integrates Intercom for support and PostHog for analytics. Additionally, a native C library (\phonemicopus\) bridges the Kotlin \PhoneMicOpusEncoder\ to libopus for efficient phone-mic audio encoding, and the \MainActivity\ is configured with \singleTask\ launch mode to prevent duplicate instances in third-party apps.

app/android/app/src · high confidence

The Android example app for the React Native SDK has been fully scaffolded, adding the main activity, application class, and resource files (styles, colors, drawables) required for the app to run. The AndroidManifest.xml is configured with standard permissions (Internet, storage, vibration) and the main activity is set up to support the new architecture and Expo modules.

sdks/react-native/example/android · high confidence

The app now includes a dedicated Apple Watch application (omiWatchApp) that enables voice recording directly from the watch. This adds a new UI for starting and stopping recordings, manages audio streaming and buffering, and sends device information and battery status to the paired phone. The watch app also includes localization strings for accessibility labels in English and Japanese.

app/ios/omiWatchApp · high confidence

The monolithic \backend/deploy/runtime\_env.yaml\ is replaced by a system that composes environment-specific configurations from a shared base (\\_base.yaml\) and per-environment overlays (\dev.overlay.yaml\, \prod.overlay.yaml\) using new Python scripts (\\_generate\_runtime\_env\_sources.py\, \compose\_runtime\_env.py\). This change introduces a structured, template-based approach to managing backend runtime environment variables, secrets, and GKE/Cloud Run service definitions, making it easier to maintain consistent configurations across dev and prod environments while reducing manual editing of the final YAML.

backend/deploy · high confidence

The backend memory subsystem has been refactored to support a new canonical memory system alongside the legacy implementation. This includes a new architecture map, a canonical activation gate to route requests to the new system, and a bulk legacy-to-canonical backfill process. The change introduces a Typesense keyword index for long-term memory atoms, a bounded graph read for the canonical knowledge graph, and a consolidation pipeline for short-term memory. These files define the routing, state management, and data migration logic for the canonical cohort, while the legacy system remains available for non-enrolled users.

backend/utils/memory · high confidence

The backend/database module now centralizes the Firestore client initialization in a new \\_client.py\ file, which handles lazy initialization, environment-based configuration for the local emulator, and robust retry logic for expired transactions and query stream failures. Additionally, new modules \account\_deletion\_policy.py\, \account\_deletion\_projection\_fence.py\, and \account\_deletion\_transitions.py\ introduce a durable, transactional account deletion state machine that gates memory projections and manages wipe status transitions, ensuring that account deletion requests are handled consistently across the system.

backend/database · high confidence

The backend's LLM utilities are consolidated into the \backend/utils/llm\ directory, introducing a new architecture that routes all model calls through a shared gateway-first transport with a legacy direct-provider fallback. This change introduces dedicated modules for chat and conversation processing, proactive notifications, memory extraction, and AI-powered app generation. It also adds a new \app\_generator.py\ module that uses the LLM to create app configurations from natural language prompts, and a \byok\_errors.py\ module to handle and notify users about BYOK (Bring Your Own Key) LLM failures. The \clients.py\ module now manages LLM client construction and error callbacks, while \ARCHITECTURE.md\ documents the new modular structure.

backend/utils/llm · high confidence

The project now includes native support for the Cursor IDE through a new \.cursor\ configuration. This adds three shell hooks: \format.sh\ to automatically format code (Python, Dart, C/C++, TypeScript) using tools like Black, Dart, clang-format, and Prettier; \session-init.sh\ to verify the development environment (Python, Flutter, Node.js, and key tools); and \validate-shell.sh\ to block dangerous commands and warn about potential secret exposure. Additionally, Markdown rules define the Arc pipeline workflow, backend import and testing standards, common mistakes to avoid, Flutter localization guidelines, and formatting commands.

.cursor/rules · high confidence

The backend now includes dedicated Modal deployment configurations for the speech profile classification and voice activity detection (VAD) endpoints. New Dockerfiles (backend/modal/Dockerfile, .memory\_maintenance\_job, .notifications\_job) and Python modules (main.py, speech\_profile\_modal.py, vad\_modal.py, job.py, memory\_maintenance\_job.py) establish the runtime environment, including CUDA runtime 13.2.1 for GPU inference, and expose the /v1/speaker-identification and /v1/vad endpoints. The memory maintenance job is also containerized for Cloud Run Jobs execution.

backend/modal · high confidence

The app's localization files (app/lib/l10n) have been significantly expanded to support 49+ languages, including the addition of new locales such as Bengali, Bosnian, and Tagalog. This update introduces translation keys for a wide range of new features and UI elements, including device sync status, background mode, storage management, and onboarding flows. Users will see the app fully translated in their preferred language, with consistent terminology across all supported regions.

app/lib/l10n · high confidence

Added new utility classes for displaying alerts and snackbars. AppDialog provides a consistent way to show confirmation dialogs with localized text and platform-specific styling (Cupertino for iOS, Material for others). AppSnackbar offers methods to display success, error, and generic messages with appropriate colors and default durations.

app/lib/utils/alerts · high confidence

The app now uses a centralized \BtDevice\ schema to manage device connections and audio codecs. This change introduces a unified \BleAudioCodec\ enum supporting formats like Opus, PCM, AAC, and LC3, along with helper functions to map codec names, sample rates, and bit depths. It also defines a \DeviceType\ enum and an \ImageOrientation\ enum for camera devices. This standardization allows the app to support a wider range of hardware, including Omi, OpenGlass, Apple Watch, Plaud, Bee, Fieldy, Friend Pendant, Limitless, and Ray-Ban Meta devices, while providing a consistent interface for device discovery, connection, and audio processing.

_app/lib/backend/schema/bt\device · high confidence

Added a new Helm chart for the Diarizer service, including templates for a Kubernetes Deployment, HorizontalPodAutoscaler, Ingress, Service, and ServiceAccount. The chart is configured with environment-specific values for dev and prod, enabling the deployment of the diarization and embedding endpoints on GKE with GPU support and autoscaling based on request latency.

backend/charts/diarizer · high confidence

Added the complete Helm chart for the Pusher service, including the chart metadata, templates for Kubernetes resources (Deployment, HPA, Ingress, Service, BackendConfig, PDB), and environment-specific values files for dev and prod. This establishes the standard deployment configuration for the Pusher WebSocket service across environments.

backend/charts/pusher · high confidence

The backend-listen service is now packaged as a Helm chart, providing standardized Kubernetes manifests for both development and production environments. The chart includes Horizontal Pod Autoscaler (HPA) templates that support scaling based on CPU, memory, active WebSocket connections, and request rates. Additionally, CronJobs are introduced to automatically adjust the minimum replica count for the Horizontal Pod Autoscaler at specific times: in development, scaling down to 1 replica at 00:00 UTC and up to 2 at 12:00 UTC; in production, scaling down to 10 replicas at 01:00 UTC and up to 30 at 11:00 UTC. This enables cost optimization and resource management through scheduled scaling events.

backend/charts/backend-listen · high confidence

The backend now routes LLM traffic through a new LLM gateway, which provides centralized request routing, service authentication, credential management, and accounting. The gateway enforces canary rollout percentages via deterministic per-request sampling, supports last-known-good (LKG) fallbacks, and records provider-neutral, cache-aware accounting events for cost and usage tracking. Service authentication validates service tokens and allowed callers, while credential handling supports both OMI-managed and BYOK (Bring Your Own Key) modes. The gateway also applies output budgets and tracks metrics for latency, errors, and accounting delivery.

_backend/llm\gateway/gateway · high confidence

A new LLM gateway service has been added to the backend, providing the core application structure using FastAPI. This includes the main application entry point, request correlation via headers, and the inclusion of routers for health checks, OpenAI-compatible endpoints, Anthropic messages, and metrics. The service also implements a resilient shutdown process that drains accounting persistence tasks and closes client connections.

_backend/llm\gateway · high confidence

The Omi Plugin SDK is introduced as a shared Python library providing canonical data models for Omi webhooks, including ActionItem, Structured, Conversation, and Event. This centralizes the definition of these models, allowing plugins to import them directly (e.g., \from omi\_plugin\_sdk.models import ...\) rather than defining them locally. The SDK also includes tests to ensure correct parsing of legacy payloads and app results.

plugins/omi-plugin-sdk · high confidence

The Omi React Native SDK is now available, providing a TypeScript interface for connecting to Omi devices via Bluetooth Low Energy (BLE). The SDK exposes an \OmiConnection\ class for scanning, connecting, and managing device states, alongside utilities for handling audio codecs (PCM16, PCM8, Opus) and retrieving battery levels. Additionally, it includes a streaming speech-to-text (STT) module supporting Deepgram, Parakeet, and Whisper engines, allowing developers to process audio bytes and receive live transcripts within React Native applications.

sdks/react-native · high confidence

The app directory now contains the full Flutter mobile application codebase, including configuration files (.env templates, .editorconfig, analysis options), a setup script (setup.sh) for iOS and Android development, and a comprehensive Maestro E2E test suite covering login, onboarding, conversations, memories, chat, apps, settings, device connection, recording, and logout flows. The app supports dev and prod flavors with distinct Firebase configurations and bundle identifiers, and includes a Shorebird configuration for hot updates.

app · high confidence

Adds a new self-hosted speech-to-text service (Parakeet) that supports batch transcription, streaming via WebSocket, and server-side speaker diarization. The service runs on NVIDIA GPUs using the NeMo framework, with a separate Dockerfile for NVIDIA NIM-based deployment. Key features include dynamic batching, VRAM-aware batch sizing, and built-in speaker embedding for diarization. The service exposes /v1/transcribe for batch ASR, /v2/transcribe for batch with diarization, and /v3/stream for real-time streaming. Health checks and metrics are provided for monitoring.

backend/parakeet · high confidence

The Parakeet Helm chart is introduced to the backend, providing a standardized Kubernetes deployment for the new ASR GPU service. The chart includes templates for the Deployment, HorizontalPodAutoscaler, Ingress, and Service, along with environment-specific values files for dev and prod. The configuration enables GPU autoscaling, Prometheus metrics, and health checks, establishing the infrastructure for the Parakeet speech recognition service.

backend/charts/parakeet · high confidence

The agent VM backend is now implemented in Python (FastAPI) and runs inside a Docker container. The new Dockerfile installs Python 3.11, the uv package manager, and a lockfile of dependencies (including FastAPI, httpx, and the Claude agent SDK). The entrypoint script (startup.sh) fetches secrets from Google Secret Manager, starts the Docker container, and exposes port 8080 for the Uvicorn server. This change replaces the previous implementation with a self-contained Python service that handles runtime maintenance, database synchronization, and backend communication.

_backend/agent\vm · high confidence

Added a new set of scripts in backend/scripts/rag to support a Streamlit-based chat interface and memory extraction pipeline. The app.py script provides an interactive chat UI that retrieves context via RAG and generates embedding visualizations. The memories.py script handles extracting memories from conversations and saving them to the database, while basic.py and current.py provide visualization utilities for embeddings. The \_shared.py file contains shared utilities for querying Pinecone and generating Plotly-based HTML visualizations.

backend/scripts/rag · high confidence

Added a new Rust crate, \sdks/rust/omi-device\, which provides a high-level interface for interacting with Omi devices over Bluetooth. The library exposes service and characteristic UUIDs, defines traits for BLE adapters and connections, and implements a \Device\ struct that handles time synchronization, battery level retrieval, audio codec negotiation, and ring status management. This enables Rust applications to discover, connect to, and control Omi hardware.

sdks/rust/omi-device · high confidence

Users can now generate a 'Wrapped' summary for 2025, which analyzes their conversation data to determine a decision-style archetype and identify top phrases using LLMs. This new utility in backend/utils/wrapped computes analytics and generates personalized insights based on user activity.

backend/utils/wrapped · high confidence

The backend/charts/agent-proxy directory now contains a complete Helm chart (Chart.yaml, templates, and environment-specific values files) that deploys the agent-proxy service. This service acts as a WebSocket bridge connecting the mobile app to a user's agent VM. The chart includes Kubernetes resources such as Deployment, Service, Ingress, HorizontalPodAutoscaler, and BackendConfig, configured for both development and production environments with appropriate resource limits, health checks, and GCP credentials mounting.

backend/charts/agent-proxy · high confidence

The backend/agent-proxy service is introduced to handle WebSocket bridging between the mobile app and user agent VMs. This new component includes a Dockerfile for the service, a pylock.toml for Python dependency management, and Python source files (main.py, resilience.py) that implement circuit breaking, error classification, and session lease management. The proxy validates Firebase tokens, manages VM lifecycle (including restart logic and health checks), and handles chat history seeding.

backend/agent-proxy · high confidence

The chat backend now features a new agentic chat system that allows the AI to autonomously decide which tools to use to gather context and answer user questions. This includes a new \agentic.py\ module implementing a tool-calling agent with provider-specific streaming, a \graph.py\ router that dispatches to persona, file-chat, or agentic paths, and a \safety.py\ module that prevents infinite loops, context overflow, and excessive tool usage. Additionally, a \hybrid.py\ module adds BM25 + RRF hybrid reranking for retrieval, and \tool\_result\_boundaries.py\ enforces safety boundaries for chat tool results.

backend/utils/retrieval · high confidence

The chat assistant now has access to a suite of retrieval tools that allow it to fetch and display user data directly within the conversation. This includes searching and retrieving past conversations and memories, managing action items, and accessing external integrations like Google Calendar, Gmail, and Apple Health. The system also supports dynamic tools from third-party apps and provides inline chart visualizations for data. These capabilities are exposed through a centralized \tools\ package, enabling the LLM to autonomously decide when to use these tools to answer user queries about their personal data.

backend/utils/retrieval/tools · high confidence

Added a new search API route at /api/apps/search that fetches approved apps from the backend, caches the results for five minutes, and performs fuzzy searching on name, description, author, category, and capabilities using Fuse.js.

web/app/src/app/api/apps/search · high confidence

Added a suite of new backend scripts to manage the agent VM infrastructure. This includes a Python utility to activate Smart Tasks for a dogfood user, a reaper script to delete idle GCE VMs to reduce costs, and a manifest renderer for immutable release artifacts. Additionally, new shell and Python scripts handle the application of IAM policies, firewall rules, and Cloud Scheduler triggers for the agent VM reconciler, alongside readiness checks for the agent VM reachability and bootstrap configurations.

backend/scripts · high confidence

A new PlatformManager and PlatformService have been added to the app to centralize access to platform-specific services. The PlatformManager now provides a single point of access for analytics, Intercom, and Crashlytics, while also handling device identification and initialization. The PlatformService introduces utility methods to check platform support (Android, iOS, mobile, Apple) and conditionally execute functions based on platform availability.

app/lib/utils/platform · high confidence

A new ConversationCapturingPage has been added to the app, providing a dedicated interface for live conversation capture. This page manages the state of an active recording session, including a mute toggle that pauses or resumes audio capture from either the phone's microphone or an external Omi device. It also handles the logic for stopping a conversation, which triggers a confirmation dialog before processing the transcript and photos, and preserves the scroll state of the live transcript as the user navigates.

_app/lib/pages/conversation\capturing · medium confidence

Added a new \.cross-review-verify.json\ file that captures runtime evidence of the Omi Beta and omi desktop processes, their installed identities, and isolated storage roots to enforce the INV-BETA-1 side-by-side runtime invariant. Additionally, introduced a comprehensive agent instruction framework with \AGENTS.md\ as the single source of truth for all AI agents, supported by \CLAUDE.md\ as a pointer, along with supporting files like \.pre-commit-config.yaml\ for automated code quality checks, \.cursorignore\ and \.dockerignore\ for build artifacts, and \.envrc.example\ for environment configuration. These changes establish a structured approach to code quality, security, and AI agent behavior within the repository.

(repo-wide) · high confidence

Added backend/jobs/agent\_vm\_reconciler.py, a new Cloud Run job that performs declarative convergence of the Agent VM fleet, and backend/jobs/short\_term\_lifecycle\_worker.py, a new worker that evaluates and audits short-term memory lifecycle transitions. These jobs enable operators to manage VM rollouts and track short-term memory state changes through structured audit records.

backend/jobs · high confidence

The app now features a new ActionItemsPage that consolidates task management and goal tracking into a single, interactive interface. Users can create and edit goals directly from the tasks list, with each task displaying its associated goal title. The page supports drag-and-drop reordering and indentation of tasks, with the state persisted to Firestore. It also includes a search bar, category-based grouping (Today, Tomorrow, Later, No Deadline, Overdue), and triggers an app review prompt after the user completes their first action item.

_app/lib/pages/action\items · high confidence

The app now uses a new HTTP client layer in app/lib/backend/http, introducing HttpPoolManager for connection pooling and request deduplication, and ClockSkewDetector to parse and log 408 clock-skew errors from the server. This infrastructure supports improved error handling for transient network issues, automatic token refresh on 401 responses, and structured logging of clock-skew events.

app/lib/backend/http · high confidence

The application now features a dedicated \WalItemDetailPage\ that handles the display and interaction for individual audio recordings (WALs). This new page implements a two-phase sync workflow: it first presents a device transfer interface for recordings stored on external hardware (SD card or flash page), showing progress, speed, and estimated time of arrival, and then transitions to a playback interface for local files. The page integrates waveform generation, playback state management via the \SyncProvider\, and handles audio playback cleanup upon disposal.

_app/lib/pages/conversations/wal\_item\detail · high confidence

Added two new backend services: \agent\_vm\_lifecycle.py\ implements a declarative reconciler for managing Agent VM fleet state, including release validation, lease management, and metadata synchronization with GCE. Additionally, \conversation\_finalization.py\ provides durable dispatch and recovery mechanisms for listen conversation finalization, including stale processing reconciliation and job requeuing. These changes improve reliability by ensuring that conversation states and VM lifecycles are correctly persisted and recovered after crashes or failures.

backend/services · high confidence

Added a new isolated package at backend/utils/memory\_ingestion that provides a benchmark-only surface for Layer-1 extraction experiments, rollout dry-runs, and scoring, intentionally separated from the production memory path. This includes a CoreMemoryPipeline for processing memory events, a CLI for running extraction pipelines, an export runner for batch processing sessions, and rollout utilities for migrating legacy memories to a graph-based ledger. The package also introduces source routing scaffolding and redaction utilities to handle sensitive data before extraction.

_backend/utils/memory\ingestion · high confidence

Adds a new local dev harness under \scripts/dev-harness/\ that provides a self-contained, hermetic environment for running the desktop and backend locally. The harness includes shell scripts (\dev-up.sh\, \dev-down.sh\, \desktop-run-local.sh\, etc.) and a Python package (\dev\_harness\) to manage local services like Firebase Auth, Firestore, Redis, and Typesense. It introduces synthetic user fixtures (\memory\_scenarios\) for E2E testing, enforces secret boundaries via \check-public-client-secrets.py\, and supports Windows/macOS portability. This enables developers to run a full local stack without external cloud dependencies.

scripts · high confidence

Added MicArbiter to enforce single-owner access to the microphone, preventing concurrent recording attempts from different stacks. Implemented NativeMicRecorderService to bridge the iOS PhoneMic module, providing a native-level capture layer with session identity management to handle interruptions and stale events. This change ensures that only one component can record audio at a time, throwing a StateError if contention occurs, and introduces a new service for handling raw audio bytes from the native iOS implementation.

app/lib/services/mic · high confidence

The desktop agent daemon now uses a modular adapter interface to support multiple AI harnesses (Hermes, OpenClaw, and pi-mono) via a common runtime contract. The ACP adapter spawns external CLI processes with a strict environment allowlist that strips embedded credentials from proxy URLs before forwarding them to untrusted subprocesses. A new \LocalSubprocessRuntimeAdapter\ enforces a minimal, allowlisted environment for all external adapter subprocesses, preventing accidental leakage of cloud credentials or CI tokens. Additionally, the \OneShotCliRuntimeAdapter\ and \HermesRuntimeAdapter\ implement the new \HarnessAdapter\ interface, enabling pluggable model providers while maintaining strict security boundaries for tool execution and session management.

desktop/macos/agent · high confidence

A new backend service, Diarizer, is introduced to provide speaker diarization and speaker embedding capabilities. The service exposes endpoints for diarization (/v1/diarization) and speaker embedding (/v1/embedding, /v2/embedding). The implementation leverages the pyannote.audio library, specifically using the 'pyannote/speaker-diarization-community-1' model for diarization and 'pyannote/embedding'/'pyannote/wespeaker-voxceleb-resnet34-LM' models for embeddings. The Dockerfile configures the environment with Python 3.11 on Debian 14 (Forky), installs CUDA Runtime 13.2.1, and exposes port 8080. The code includes validation for audio duration to prevent crashes on short audio files.

backend/diarizer · high confidence

The omiGlass/sources directory now contains the core components of the omiGlass mobile application. This includes a theme configuration, a reusable RoundButton component, and the main application entry point that handles Bluetooth device connection. The DeviceView component enables users to view and interact with photos captured by the device, supporting image rotation based on firmware version 2.1.1 or higher.

omiGlass/sources · high confidence

Added the omiGlass project, an open-source smart glasses application and firmware. The change introduces an Expo-based React Native app (App.tsx, app.json, babel.config.js) that requires configuring API keys (Groq, OpenAI) and an Ollama URL via a new .env.template file. It also includes a comprehensive README with setup instructions for software and firmware installation on an ESP32 S3 board, along with the MIT license. Additionally, the commit adds the NimBLE-Arduino library (version 1.4.3) with its full source, examples (BLE Beacon Scanner, Eddystone TLM/URL Beacons), and CI/CD workflows to support the firmware's Bluetooth Low Energy capabilities.

omiGlass · high confidence

The app now supports on-device speech-to-text via Apple's native Speech framework and local Whisper models, alongside streaming transcription from Gemini Live. These new capabilities are enabled by a set of new core abstractions: \PureSocket\ and \PurePollingSocket\ provide a unified interface for WebSocket and polling-based audio transmission, while \CompositeTranscriptionSocket\ allows routing audio to multiple providers simultaneously. Additionally, \SchemaBasedSttProvider\ and \TranscriptSegmentSocketService\ standardize how transcription results are delivered to the UI, supporting both cloud-based and local processing.

app/lib/services/sockets · high confidence

Added a new PaymentMethodConfig class that defines the structure for payment method entries, including title, subtitle, icon, background color, and callback handlers. This includes static factory methods for Stripe and PayPal configurations, each specifying their respective icons and default colors. Additionally, a PayPalDetails model was introduced to handle email and link data, with serialization support via toJson and fromJson methods.

app/lib/pages/payments/models · high confidence

Users can now make and manage phone calls directly within the app. The new PhoneCallsPage provides a contacts list and dialpad, while the ActiveCallPage displays a live transcript, call status, and audio controls. A new ActiveCallBanner shows call details on the home screen. The flow includes a phone setup process (intro, number entry, and verification) and an upsell sheet for non-unlimited users.

_app/lib/pages/phone\calls · high confidence

A new OmiVoicePlaybackService has been added to handle spoken responses using a pipelined, chunked TTS architecture. This change introduces a 'Headphones-only' playback mode by default, which prevents the AI's voice from playing through the phone's speaker when no headphones are connected, ensuring privacy in public. The service also manages audio session activation, interruption handling, and queue-based playback to keep responses alive across notifications and recover from session failures.

_app/lib/services/voice\playback · high confidence

Added new Python modules under \backend/scripts/runtime\_env\validation/\ (\\\init\\_.py\, \cloud\_run.py\, \common.py\, \manifest.py\, \workflows.py\) to validate the runtime environment configuration. These scripts enforce that Cloud Run services and jobs have the correct environment variables, secret references, and network flags, and that the manifest structure matches expected shapes. This ensures that deployment pipelines fail fast if the environment configuration is invalid.

_backend/scripts/runtime\_env\validation · high confidence

A new self-hosted translation service using Meta's NLLB-200 model (via CTranslate2) has been added to the backend, replacing the previous Gemini-based approach for real-time transcript translation. The service exposes a FastAPI-based API on port 8080, supporting batch translation with configurable beam size, compute type, and thread counts. It includes Prometheus metrics for monitoring, health/readiness endpoints, and a comprehensive README with deployment instructions for GKE. The backend now uses this service when \TRANSLATION\_SERVICE\_MODELS\ includes 'nllb', falling back to Gemini if needed.

_backend/nllb\translation · high confidence

Added a new shared Rust library (desktop/shared-rust) containing model quality-of-service (QoS) policies and fallback label normalization. The library defines model tiers (Premium, Max) with distinct daily soft and hard usage limits, and routes requests to specific LLM providers (Vertex AI, AI Studio) with necessary body transformations. It also provides a centralized fallback outcome enum and safe label normalization for telemetry, ensuring consistent handling of unknown components and reasons.

desktop/shared-rust · high confidence

Users are now guided through a new speech profile onboarding flow that captures and manages their voice samples. This includes a dedicated page for recording and reviewing speech samples, a progress indicator for recording status, and the ability to play back or delete previously recorded samples. The onboarding process also integrates with primary language settings to ensure the profile is tailored to the user's language preferences.

_app/lib/pages/speech\profile · high confidence

Added a new \backend/utils/observability\ module that centralizes telemetry for fallbacks, live speech-to-text, and real-traffic journeys. This introduces a shared \record\_fallback\ contract for resilience tracking, instruments live STT and transcription outcomes with bounded labels, and integrates LangSmith tracing and prompt management for chat. Users gain improved visibility into system health, latency, and failure modes across voice, sync, and chat workflows.

backend/utils/observability · high confidence

Added a new backend module for task intelligence that implements a deterministic capture policy, a candidate lifecycle service, and a proactive intent engine. The capture policy (\capture\_policy.py\) enforces confidence and ownership thresholds to determine if a task should be proposed, updated, or completed. The candidate service (\candidate\_service.py\) manages the state transitions of these proposals, including integration with workstreams and task sync. The proactive engine (\proactive\_engine.py\) handles the generation of cold-start and daily opener intents for the Chat-first feature, gated by a new eligibility check (\chat\_first\_eligibility.py\) that validates rollout status and cohort membership. A new architecture document (\ARCHITECTURE.md\) and contract validation (\contracts.py\) ensure that all writers and adapters adhere to the defined schemas and source boundaries.

_backend/utils/task\intelligence · high confidence

Users can now select and copy text from AI-generated messages in the chat. This is enabled by adding a 'Select Text' screen that wraps message content in a Flutter SelectionArea, allowing users to highlight and copy text from the chat interface.

app/lib/pages/chat · high confidence

The backend now includes a new 'pusher' service, defined by a Dockerfile, Python entrypoint, and dependency lockfile. This service exposes HTTP health and readiness endpoints, initializes Firebase credentials, and manages background tasks and graceful shutdowns. It is built on Python 3.11, uses uvicorn with uvloop, and includes jemalloc to prevent memory fragmentation during high-churn WebSocket audio streams.

backend/pusher · high confidence

Added a new memory ingestion pipeline adapter that supports typed, structured memory extraction. The \production\_like\_model.py\ file introduces Pydantic models (\TypedProductionLikeMemory\, \TypedProductionLikeMemories\) that enforce a fixed vocabulary of predicates (e.g., \works\_on\, \is\_currently\_true\) and structured arguments, replacing the previous free-text extraction with a schema-enforced output. The \typed\_extraction\_prompt.py\ file provides the corresponding prompt template that guides the LLM to output these typed facts, including source-specific guidance and assistant-turn attribution rules. The \offline\_input.py\ file adds utilities for reading/writing pipeline inputs and outputs in JSONL/JSON formats, supporting the new pipeline's data flow.

_backend/utils/memory\ingestion/adapters · high confidence

Audio input is now handled through a new \AudioSource\ abstraction that standardizes how audio frames are produced for the Web Audio Library (WAL). This change introduces two concrete implementations: \PhoneMicSource\ for the phone's built-in microphone, which buffers incoming PCM16 data into 320-byte frames, and \BleDeviceSource\ for Omi/OpenGlass BLE devices, which strips 3-byte firmware headers to produce headerless audio payloads. Both sources use a \FrameSyncKey\ to enable WAL to match and synchronize frames, ensuring consistent behavior across different audio input methods.

_app/lib/services/audio\sources · high confidence

Added a new abstract DeviceTransport interface and three concrete implementations: NativeBleTransport for Bluetooth Low Energy devices, RayBanMetaTransport for Ray-Ban Meta glasses, and WatchTransport for Apple Watch. Each transport manages its own connection lifecycle, state management, and data streams (audio, photo, battery) via native bridges, providing a consistent API for device communication across different hardware types.

app/lib/services/devices/transports · high confidence

The web/admin directory now contains a fully functional Next.js admin dashboard. It provides an internal UI for managing apps, reviewing submissions, and configuring system settings. The dashboard enforces strict authentication via Firebase and uses a shared \useAuthToken\ hook for all API calls, ensuring that server-side credentials are never exposed to the client. Key features include an app management interface with search, filtering, and sorting, an agent prompt widget for local LLM interaction, and a comprehensive environment configuration template (\.env.example\) for local development.

web · high confidence

A new NameWidget is added to the onboarding flow, allowing users to enter their name. The component handles pre-filling the name from local storage, manages the text input and focus state, and updates the user's given name via the AuthService upon submission.

app/lib/pages/onboarding/name · high confidence

The app now uses a new \AnalyticsAdapter\ interface and \AnalyticsManager\ singleton to manage telemetry. This abstraction decouples the app's analytics calls from specific SDKs, allowing the system to route events to PostHog or Intercom through a single, consistent API. The new layer also includes a \RageClickContextTracker\ widget that captures Flutter UI context for native rage-click detection, and an \IntercomManager\ to handle Intercom-specific logic like displaying help articles and updating user attributes.

app/lib/utils/analytics · high confidence

The app's entry point and initialization are restructured to support distinct development and production environments, with a new \app\_globals.dart\ extracting the global navigator key to improve testability. A \flavors.dart\ module detects the current environment (dev vs. prod) to configure the app title and routing. Additionally, new Pigeon interfaces (\phone\_mic\_interface.dart\ and \pigeon\_interfaces.dart\) are introduced to manage native communication for phone microphone capture and Bluetooth Low Energy (BLE) device management, including detailed diagnostics and state tracking for BLE connections.

app/lib · high confidence

The app adds several new widgets to enhance the user interface: an animated loading button, a bottom navigation bar with four tabs (Home, Conversations, Tasks, Apps), a collapsible section widget, a reusable confirmation dialog supporting checkboxes and platform-specific styling, a connection guide sheet for pairing various devices, a device pairing sheet, a device animation widget, and a custom pull-to-refresh indicator. These components support the new bottom navigation structure and device integration flows.

app/lib/widgets · high confidence

The backend now includes several new utility modules in backend/utils/other: backoff.py provides a jittered exponential backoff calculator; chat\_file.py handles OpenAI file uploads and streaming chat with files, including safe parsing of malformed records; deferred\_delete.py implements a single-threaded scheduler for delayed file deletion, replacing the previous pattern of sleeping threads; endpoints.py centralizes user authentication, account deletion status enforcement, and client device/platform tracking; hume.py parses Hume AI emotion prediction responses; jobs.py orchestrates daily notification and X (Twitter) sync cron jobs; notifications.py manages daily summary generation and delivery with timezone-aware scheduling and duplicate prevention; storage.py manages speech profiles, audio processing, and GCS operations; task.py offers a safe background task creator; and timeout.py adds a middleware for request timeouts and clock-skew validation.

backend/utils/other · high confidence

The firmware now includes dedicated drivers for the device's physical and sensor hardware, adding support for the haptic motor, accelerometer, and IMU timestamping. A new battery driver replaces the previous implementation with a more accurate voltage-to-percentage mapping and charging control. Additionally, a structured LED feedback system is introduced to visually indicate system states and errors, while button handling is refactored to support single, double, and long-press gestures via a state machine.

omi/firmware/omi · high confidence

A new Japanese localization file (InfoPlist.strings) has been added for the iOS app, providing Japanese translations for various system permission descriptions, including Bluetooth, calendar, contacts, location, microphone, speech recognition, reminders, health, photo library, and camera access. This ensures that Japanese-speaking users see localized explanations for why the app requires these permissions.

app/ios/Runner/ja.lproj · high confidence

The backend now routes LLM requests through a new LLM gateway service. Users can now interact with Anthropic models via the /v1/messages endpoint and OpenAI-compatible chat completions via /v1/chat/completions. The gateway handles authentication, rate limiting (returning 429 for BYOK throttling), and telemetry for these new provider integrations.

_backend/llm\gateway/routers · medium confidence

The Omi Personas web application is now available, providing a full-featured chat interface for interacting with AI personas. The app includes a Google Sign-In flow, a chat page that streams responses from a new backend API, and a home page that fetches and displays a list of chatbot personas. Users can connect social media profiles (Twitter, LinkedIn) to create or find personas, with the app handling profile data fetching and metadata generation. The implementation introduces new server routes for chat, social profile lookups, and memory storage, alongside new client-side components for the chat interface, header, footer, and persona list.

web/personas-open-source · high confidence

The \mcp\ directory now contains a fully standalone Python MCP server (\mcp-server-omi\) that exposes tools for reading, searching, and manipulating user memories and conversations. The server implements tools including \get\_memories\, \search\_memories\, \create\_memory\, \delete\_memory\, \edit\_memory\, \get\_conversations\, \get\_conversation\_by\_id\, and \search\_conversations\. The release includes a Dockerfile for containerized deployment, a \release.sh\ script for publishing to PyPI and Docker Hub, and example applications demonstrating integration with DSPy, LangChain, and the OpenAI Agents SDK. The server is versioned at 0.1.9.

mcp · high confidence

Added new device SDKs for C++, Dart, Rust, and TypeScript that provide BLE transport and speech-to-text (STT) capabilities. Each SDK implements scanning for nearby devices, connecting to a target device, and listening for audio notifications. The C++ and Rust SDKs use native Bluetooth libraries (SimpleBLE and btleplug, respectively), while the Dart SDK uses flutter\_blue\_plus and the TypeScript SDK uses @stoprocent/noble. All SDKs include a common protocol helper to strip the 3-byte audio packet header. Additionally, each SDK provides STT transcribers for Deepgram, Parakeet, and Whisper engines, allowing developers to stream audio data to various speech recognition services.

(repo-wide) · high confidence

The iOS phone-mic capture path has been replaced with a native Swift implementation (PhoneMic) that supports both real-time streaming and a new batch recording mode. In batch mode, the native engine captures, encodes to Opus, and writes audio to disk, allowing for offline transcription. The controller manages the capture lifecycle, handling permissions, interruptions, and route changes, while the event emitter ensures frames are correctly routed to the Dart side with session identity.

app/ios/Runner/PhoneMic · high confidence

The settings area now includes a dedicated About page for privacy policy, website, and community links; a new AI App Generator page for creating and managing AI-generated apps; and detail pages for Apple Health and Asana integrations, each providing specific connection, sync, and configuration options within the settings drawer.

app/lib/pages/settings · high confidence

The App Store page now features a comprehensive set of new UI components for browsing and searching applications. This includes a main AppList with a fixed header, scrollable category navigation, and a search bar powered by Fuse.js. The update introduces distinct card layouts (FeaturedPluginCard, CompactPluginCard, and a standard PluginCard) to display app details, ratings, and install counts. Additional components include an AppHeader for displaying app metadata and capabilities, an AppStats component for ratings and downloads, a DeveloperBanner for developer outreach, and utility components like NewBadge and CapabilityLegend. The types.ts file defines the underlying data structures for plugins and capabilities.

web/frontend/src/app/apps/components · high confidence

The Memories page now features a complete overhaul of the user interface, introducing dedicated widgets for memory management and editing. Users can now edit and delete memories via a new bottom sheet and dialog interface, with support for marking memories as 'baseline' and managing visibility. The update also introduces a 'CategoryChip' for filtering memories by type (e.g., System, Interesting, Manual, Workflow) and a 'MemoryItem' widget that displays memory content, provenance, and associated conversation links. Additionally, a 3D force-directed graph visualization is added for exploring memory relationships, and the UI includes a confirmation dialog for deletions.

app/lib/pages/memories/widgets · high confidence

The app introduces a dedicated Payments page and a new PaymentMethodProvider to manage payment methods. Users can now view and set their active payment method, with the UI explicitly treating Stripe as the only valid active method while displaying a 'coming soon' placeholder for other options. The provider handles fetching supported countries, managing connection states for Stripe and PayPal, and polling for Stripe status. The PayPal setup page allows users to configure their PayPal.me link and email, while the Stripe setup page guides users through country selection and account linking.

app/lib/pages/payments · high confidence

A new 'About SD Card Sync' page has been added to explain how the SD card sync feature works, including descriptions of the audio file checks, sync process, and server processing. Additionally, a new SD card transfer progress screen has been introduced, featuring a dynamic circular progress indicator that flips to show the transfer percentage and remaining time, accompanied by a particle animation upon completion.

app/lib/pages/sdcard · high confidence

The iOS project now includes four new Xcode build schemes—dev, prod, raybanDat, and omiWatchApp—each defining specific build, test, and launch configurations. These schemes enable developers to build and run the main app for different environments (dev, prod, and Ray-Ban Dat) as well as the Omi Watch App, streamlining the development and testing workflow for these distinct build targets.

app/ios/Runner.xcodeproj/xcshareddata · high confidence

The app introduces a new set of widgets for managing action items, including a form sheet for creating and editing tasks, a tile widget for displaying individual items with due dates and completion states, a selection bar for bulk actions like export and delete, and a sheet for accepting shared tasks. These components enable users to create, edit, delete, and bulk-export action items, with support for due dates, completion tracking, and integration with external task apps.

_app/lib/pages/action\items/widgets · high confidence

The app now includes three new UI components for displaying announcements and updates: an AnnouncementDialog for modal pop-ups, a ChangelogSheet for a bottom-sheet view of version history, and a FeatureScreen for full-screen walkthroughs. These components handle the display of announcement content, including images, titles, body text, and call-to-action buttons, with support for both paged and list-based layouts.

app/lib/pages/announcements · high confidence

Added server actions for app creation (generate-description, get-app-initialization-data, submit-app, upload-thumbnail, upload-thumbnails) and shared content retrieval (get-shared-chat, get-shared-memory, get-shared-tasks, get-public-memories, get-community-plugins, get-trends). These enable new frontend pages for apps, chat, case status, and shared memories/tasks. Includes static contract tests verifying public shared conversation chat safety, app detail 404 handling, and case status logic.

web/frontend · high confidence

Added new SVG assets for the app's UI, including icons for AI magic, checkboxes, charts, clone chat, clone plus, and dollar, as well as logos for iMessage, link, and Stripe.

app/assets/images · high confidence

The app introduces several new services to handle core functionality: AgentChatService manages the WebSocket connection for AI chat interactions; AppReviewService prompts users to review the app after key milestones like their first conversation or action item; AnnouncementService handles in-app announcements and changelogs; AudioDownloadService manages downloading and combining audio files for conversations; AuthService handles authentication flows including Google, Apple, and OAuth; BatteryWidgetService bridges device state to iOS lock screen widgets; ClientDeviceService generates stable device identifiers for analytics; ConnectivityService monitors network status; CustomSttLogService logs speech-to-text events; DeviceService manages Bluetooth and other device connections; FreemiumTranscriptionService manages free on-device transcription options.

app/lib/services · high confidence

Added new audio utilities for handling audio timelines, transcoding (PCM, Opus, WAV), and combining WAV files, alongside a foreground service implementation that periodically retrieves and sends the device's location in the background.

app/lib/utils/audio · high confidence

Added new PowerShell setup scripts (initialsetup.ps1, release.ps1, setup.ps1) that automate the mobile development environment configuration. The setup script guides developers through installing Flutter dependencies, configuring Firebase and environment variables, and building the app for iOS or Android. The release script automates the build process for Android App Bundles and APKs. These scripts streamline the initial project setup and release workflows.

app/setup/scripts · high confidence

Added several new utility modules in the backend/utils directory. The aac.py module introduces an AACDecoder class for decoding AAC audio streams using PyAV. The agent.py module provides functions for executing agent-based chat streams, including an interactive chat stream and a single-message execution path. The analytics.py module adds functions for tracking user usage statistics, including transcription seconds, words transcribed, insights gained, and speech seconds. The api\_key\_families.py module introduces logic for recognizing and validating API key families (MCP, Developer, Firebase) to ensure proper authentication. The app\_integrations.py module adds extensive functionality for handling external app integrations, including webhook health tracking, proactive notifications, and app management. These modules collectively enhance the backend's capabilities for audio processing, agent interactions, usage tracking, and third-party integrations.

backend/utils · high confidence

The DevKit firmware now includes dedicated source files for button input handling, audio codec processing, LED control, and battery monitoring. The button module implements a state machine to detect single taps, double taps, and long presses, while the codec module manages Opus audio encoding via a dedicated thread. Additionally, new libraries provide GPIO-based LED control and ADC-based battery voltage/percentage tracking, establishing the core hardware abstraction layer for the device.

omi/firmware/devkit · high confidence

A new ConnectDevicePage has been added to the app, providing a dedicated interface for users to connect their Omi device. This page includes a scanning animation, a device status indicator, and a bottom navigation bar with a button to open the Omi store and a link to a connection guide. The implementation integrates with the OnboardingProvider to manage connection state and tracks user interactions through PlatformManager.instance.analytics, specifically calling connectDevicePageOpened() and connectionGuideOpened() to support telemetry.

app/lib/pages/capture · high confidence

The conversation detail page now features a suite of new bottom-sheet widgets for managing conversations, including audio download progress, markdown rendering, segment editing, speaker naming, contact sharing, and app summarization. A new template creation flow allows users to generate and install custom apps from conversations, with improved error handling to ensure failed installations are correctly reported as failures rather than successes.

_app/lib/pages/conversation\detail/widgets · high confidence

The backend now includes a dedicated \backend/utils/conversations\ package containing new modules for conversation lifecycle management (\lifecycle.py\, \finalization\_decision.py\), durable finalization (\finalizer.py\), Google Calendar auto-linking (\calendar\_linking.py\, \calendar\_utils.py\), and speaker analytics (\analytics.py\). These utilities centralize state transitions, enforce ownership fences for derived effects, and enable automatic association of conversations with overlapping Google Calendar events.

backend/utils/conversations · high confidence

A new country selection bottom sheet and a reusable payment method card widget have been added to the payments interface. The country picker allows users to search and select their country from a scrollable list, while the payment method card displays provider details with status indicators and action buttons for managing or activating payment methods.

app/lib/pages/payments/widgets · high confidence

The app introduces several new model classes to support updated backend capabilities. Announcement handling is supported via new \AnnouncementType\, \TriggerType\, \Targeting\, \Display\, \ChangelogItem\, and \ChangelogContent\ models. Subscription management is enhanced with \PlanType\ (including \architect\, \operator\, \plus\, and \unlimitedV2\), \SubscriptionStatus\, \PlanLimits\, \Subscription\, and \PricingOption\ models. Additionally, the app now tracks user usage statistics through \UsageStats\, \UsageHistoryPoint\, and \UserUsageResponse\ models. Transcription capabilities are expanded with \CustomSttConfig\ for custom speech-to-text providers, \SttProvider\ and \SttProviderConfig\ for managing different STT services, \SttResponseSchema\ for parsing various STT responses, and \SttResult\ for handling transcription outputs. Finally, sync state management is improved with \SyncState\ and \SyncPhase\ models, while \LocalRecording\ and \PlaybackState\ models support offline recording and playback features.

app/lib/models · high confidence

This change introduces a new multi-language device SDK located in \sdks/device/\, providing portable protocol helpers for BLE, audio, and STT (Deepgram, Whisper, Parakeet) across C++, Go, Rust, Dart, and TypeScript. It also adds the \omi-cli\ Python CLI, which exposes scoped, agent-friendly verbs for memories, conversations, action items, and goals, along with local desktop API access and profile management. The CLI supports JSON output, stable exit codes, and credential persistence for both browser-based OAuth and API key authentication.

sdks · high confidence

The device discovery layer has been refactored to support multiple transport types via a new \DeviceDiscoverer\ interface. This introduces a \DeviceLocator\ to distinguish between Bluetooth, Watch Connectivity, and Meta DAT transports. Specifically, the app now includes an \AppleWatchDiscoverer\ that checks for a paired and reachable Apple Watch, and a \RayBanMetaDiscoverer\ that supports both the full Meta Wearables Device Access Toolkit and an audio-only fallback for Bluetooth HFP inputs. The \NativeBluetoothDiscoverer\ has also been updated to use the new interface.

app/lib/services/devices/discovery · high confidence

The home screen has been restructured with a new \HomeContentPage\ that displays daily recaps, conversations, and a mind map preview, while introducing dedicated pages for device settings (\device.dart\), firmware updates (\firmware\_update.dart\), and OmiGlass OTA updates (\omiglass\_ota\_update.dart\). This includes a new \FirmwareMixin\ to handle firmware download and installation logic, and a \FirmwareUpdateSheet\ for pre-update warnings. The main \page.dart\ now integrates these components, providing a unified entry point for device management and home content.

app/lib/pages/home · high confidence

The app now supports connecting to Apple Health and Apple Reminders for native iOS/macOS data sync, alongside task management integrations for Asana, ClickUp, Google Tasks, and Todoist. A shared base service standardizes OAuth flows and connection status tracking, while Gmail and Google Calendar share a single Google OAuth grant. Users can authenticate, sync, and disconnect from these services directly from the Settings page.

app/lib/services/integrations · high confidence

Added a new interactive HTML page for the 'tab-navigation' end-to-end flow. This viewer displays a 6-step test sequence with video playback, step status indicators, and YAML source code, providing a visual way to inspect the flow's execution and results.

app/e2e/viewer · high confidence

A new interactive device onboarding wrapper has been added, guiding users through a series of device setup steps (transcription demo, single press, power cycle, and double-press configuration). The flow includes an introductory screen, animated step transitions, and persistent progress indicators. Users can skip or exit the tutorial at any time, with analytics tracking start, completion, and abandonment.

_app/lib/pages/onboarding/interactive\_device\onboarding · high confidence

The onboarding flow now includes four new interactive steps: a real-time transcription demo, a single-press voice question-and-answer simulation, a power cycle (off/on) demonstration, and a double-tap configuration step. Each step provides visual feedback and animations to guide the user through the device's core features.

_app/lib/pages/onboarding/interactive\_device\onboarding/steps · high confidence

The app now uses a new notification service architecture that separates platform-specific implementations (FCM for iOS/Android/macOS and a basic local-only service for Windows) behind a common interface. This change introduces dedicated handlers for scheduling and displaying notifications for action item reminders, important conversation completions, and conversation merges, each broadcasting events to update the UI. Users will see timely local notifications for these specific events, with proper handling for foreground/background states and platform differences.

app/lib/services/notifications · high confidence

The onboarding flow now includes a dedicated 'Get to Know Your Omi' intro screen that appears before the tutorial steps, featuring an animated ambient glow background. Additionally, the onboarding experience is enhanced with new interactive widgets: a live transcript display that shows real-time speech-to-text, a double-tap demo animation that visualizes device interactions, and a shared step scaffold with persistent progress dots to guide users through the setup process.

_app/lib/pages/onboarding/interactive\_device\onboarding/widgets · high confidence

A new permissions interstitial page has been added to the app, allowing users who have already completed onboarding but have not yet granted permissions to do so at any time. This screen requests background activity, location, and notification permissions, with platform-specific handling for Android and iOS. The implementation includes a dedicated widget for the permissions UI and a checker function to verify granted permissions.

app/lib/pages/onboarding/permissions · high confidence

The onboarding flow now includes a dedicated screen for selecting a primary language. This new widget allows users to search and choose their preferred language from a list, with the selection being passed to the home provider for persistence. The implementation includes a search filter for languages and handles the state of the selected language.

_app/lib/pages/onboarding/primary\language · high confidence

A new 'ProcessingConversationPage' has been added to display conversations that are currently being processed. This page features a tabbed interface allowing users to view the raw content (such as photos or transcript segments) and the generated summary. The UI dynamically adjusts the tab labels based on the conversation source (e.g., 'Photos' for OpenGlass, 'Raw Data' for Screenpipe) and displays appropriate empty states or processing status messages.

_app/lib/pages/processing\conversations · high confidence

Introduced new provider classes to manage application state for action items, in-app announcements, app listings, and authentication. The \ActionItemsProvider\ handles fetching, filtering, and sorting of tasks, including a migration from shared preferences to item-level sort order. The \AnnouncementProvider\ manages fetching and dismissing in-app announcements with version and device-specific targeting. The \AppProvider\ manages the list of available apps, including filtering by category, capability, and rating, as well as tracking user-installed apps. The \AuthenticationProvider\ centralizes Firebase auth state, token management, and session expiration handling. These changes consolidate state management for these features into dedicated provider classes.

app/lib/providers · high confidence

The app now includes a suite of new scripts in app/scripts to support Android CPU profiling, automated code analysis, and localization management. Developers can use the new profiling scripts (measure\_cpu\_android.sh, compare\_cpu\_builds.sh, profile\_flutter\_android.sh) and the accompanying CPU\_PROFILING\_GUIDE.md to measure and compare CPU usage on Android devices, with a focus on identifying battery-draining issues like shimmer animations. Additionally, the repository introduces an analyzer ratchet (analyze\_ratchet.sh) to enforce a baseline of Dart analyzer warnings and errors, a script (add-l10n-key.sh) to simplify adding new localization keys, and a test runner (test.sh) that integrates unit/widget tests with the new Maestro E2E functional test suite.

app/scripts · high confidence

The settings page now includes dedicated UI components for managing developer and MCP API keys, featuring new sheets for creation, lists for existing keys, and confirmation dialogs. Additionally, a new 3-step cancellation flow allows users to provide feedback when canceling their subscription.

app/lib/pages/settings/widgets · high confidence

Added new Dart extension methods to simplify common string and function operations. The String extension provides a safe decodeString getter that attempts to decode UTF-8 bytes, falling back to the original string on error, and a capitalize() method for title-casing. The Function extension adds a withPostFrameCallback helper to execute a function after the current frame, leveraging Flutter's WidgetsBinding. These utilities streamline string manipulation and asynchronous callback management in the widgets layer.

app/lib/widgets/extensions · high confidence

Added four new backend scripts in the users directory to support user analytics and data migration. apps\_count.py calculates and stores app usage statistics; chats\_analysis.py generates visualizations for message distribution, weekly retention cohorts, and message retention; memories\_fixes.py processes conversation durations and merges incorrectly separated memories; and retrieval.py migrates existing conversation data to a new structured vector format.

backend/scripts/users · high confidence

The app introduces several new utility files in the 'other' folder: a Debouncer class to manage delayed execution, string helpers for JSON extraction and Base64 decoding, and time formatting functions (secondsToHumanReadable, secondsToCompactDuration, secondsToHMS) that display durations in both human-readable and compact formats with internationalization support. Additionally, new validators are added for URLs, PayPal links, WebSocket URLs, and email addresses.

app/lib/utils/other · high confidence

The app introduces a suite of new utility modules in the \app/lib/utils\ directory to support core features. \app\_localizations\_helper.dart\ provides extension methods to fetch localized titles for categories, capabilities, triggers, actions, and notification scopes, falling back to API titles. \audio\_player\_utils.dart\ manages audio playback state, progress, and file caching. \batch\_recording.dart\ handles logic for offline/batch recordings, including auto-upload gating and filename parsing. \device.dart\ identifies device types (CV1, DevKit) and maps them to UI assets. \environment\_detector.dart\ detects TestFlight environments. \firmware\_update\_build\_policy.dart\ gates firmware update capabilities based on the app build (e.g., Ray-Ban DAT). \firmware\_update\_prompt\_coordinator.dart\ manages firmware update prompts. \hard\_secret\_detector.dart\ scans for sensitive data like API keys. \l10n\_extensions.dart\ simplifies localization access. \logger.dart\ integrates Crashlytics and Talker for error tracking. \mutex.dart\ provides a simple async mutex. \notification\_channel\_strings.dart\ handles localized Android notification channel names. \plan\_pricing.dart\ calculates subscription discounts. \debug\_log\_manager.dart\ manages debug logs. \conversation\_sync\_utils.dart\ handles conversation syncing. \browser.dart\ provides user agents. \constants.dart\ defines constants like \omiSpeakerId\. \enums.dart\ defines \RecordingState\. \file.dart\ handles audio file operations. \firmware\_update\_check\_session.dart\ manages firmware update sessions. \firmware\_update\_prompt\_coordinator.dart\ coordinates prompts. \hard\_secret\_detector.dart\ detects secrets. \l10n\_extensions.dart\ provides localization helpers. \logger.dart\ handles logging. \mutex.dart\ provides synchronization. \notification\_channel\_strings.dart\ localizes notifications. \plan\_pricing.dart\ calculates pricing. \debug\_log\_manager.dart\ manages logs. \conversation\_sync\_utils.dart\ syncs conversations. \browser.dart\ sets user agents. \constants.dart\ defines constants. \enums.dart\ defines states. \file.dart\ manages files. \firmware\_update\_build\_policy.dart\ controls firmware updates. \firmware\_update\_check\_session.dart\ manages sessions. \firmware\_update\_prompt\_coordinator.dart\ coordinates prompts. \hard\_secret\_detector.dart\ finds secrets. \l10n\_extensions.dart\ helps with localization. \logger.dart\ logs messages. \mutex.dart\ synchronizes access. \notification\_channel\_strings.dart\ localizes channels. \plan\_pricing.dart\ computes prices. \debug\_log\_manager.dart\ manages logs. \conversation\_sync\_utils.dart\ syncs data. \browser.dart\ sets headers. \constants.dart\ holds values. \enums.dart\ defines types. \file.dart\ handles files. \firmware\_update\_build\_policy.dart\ controls updates. \firmware\_update\_check\_session.dart\ manages sessions. \firmware\_update\_prompt\_coordinator.dart\ coordinates prompts. \hard\_secret\_detector.dart\ finds secrets. \l10n\_extensions.dart\ helps with localization. \logger.dart\ logs messages. \mutex.dart\ synchronizes access. \notification\_channel\_strings.dart\ localizes channels. \plan\_pricing.dart\ computes prices. \debug\_log\_manager.dart\ manages logs. \conversation\_sync\_utils.dart\ syncs data. \browser.dart\ sets headers. \constants.dart\ holds values. \enums.dart\ defines types. \file.dart\ handles files. \firmware\_update\_build\_policy.dart\ controls updates. \firmware\_update\_check\_session.dart\ manages sessions. \firmware\_update\_prompt\_coordinator.dart\ coordinates prompts. \hard\_secret\_detector.dart\ finds secrets. \l10n\_extensions.dart\ helps with localization. \logger.dart\ logs messages. \mutex.dart\ synchronizes access. \notification\_channel\_strings.dart\ localizes channels. \plan\_pricing.dart\ computes prices. \debug\_log\_manager.dart\ manages logs. \conversation\_sync\_utils.dart\ syncs data. \browser.dart\ sets headers. \constants.dart\ holds values. \enums.dart\ defines types. \file.dart\ handles files. \firmware\_update\_build\_policy.dart\ controls updates. \firmware\_update\_check\_session.dart\ manages sessions. \firmware\_update\_prompt\_coordinator.dart\ coordinates prompts. \hard\_secret\_detector.dart\ finds secrets. \l10n\_extensions.dart\ helps with localization. \logger.dart\ logs messages. \mutex.dart\ synchronizes access. \notification\_channel\_strings.dart\ localizes channels. \plan\_pricing.dart\ computes prices.

app/lib/utils · high confidence

The conversations page now features a suite of new UI components: a LiteCaptureWidget for streamlined capture status, a ConversationListItem with selection mode and swipe-to-delete, and a ConversationsGroupWidget that interleaves local recordings with conversations. Additionally, the app introduces a GoalTrackerWidget for tracking personal goals, a GoalsWidget for managing multiple goals, a DailyScoreWidget displaying task completion rates, and a CreateFolderBottomSheet for organizing conversations into folders. The folder tabs now support starred filters and daily summaries, while the daily summaries list allows for optimistic deletion and infinite scroll.

app/lib/pages/conversations/widgets · high confidence

The app detail page now includes dedicated widgets for user and owner reviews, a new add-review form, and an analytics card displaying install counts and earnings. A local initials-based avatar widget replaces the previous network-dependent image service, ensuring avatars always render. The capabilities card now uses FontAwesome icons for each capability type.

_app/lib/pages/apps/app\detail/widgets · high confidence

The OmiGlass firmware now supports audio streaming and over-the-air (OTA) updates. Users can now stream audio from the device via BLE, with the firmware handling Opus-encoded audio data. Additionally, the firmware includes a new OTA service that allows users to update the device's firmware wirelessly via WiFi, with status notifications for download and installation progress. The update also includes power optimization features to extend battery life, including aggressive CPU frequency management, light sleep modes, and reduced polling intervals for battery and BLE connections.

omiGlass/firmware · high confidence

The Apps section has been completely redesigned to offer a more streamlined experience. Users can now create and submit new apps via a dedicated AddAppPage, manage existing apps through a new ManageCreatePage, and explore available apps via a refreshed ExploreInstallPage. The update also introduces support for connecting external MCP servers, viewing app home pages in a web view, and managing app details including API keys and notification scopes. The previous 'Create Your Own App' hero card has been removed in favor of a cleaner, tabbed interface that separates installed apps from user-created ones.

app/lib/pages/apps · high confidence

The apps section has been completely redesigned to support browsing by capability (e.g., external integration, notifications) in addition to traditional categories. This introduces new pages and widgets for managing app metadata, API keys, and action fields. Users can now create and manage API keys for their apps, configure external integration scopes, and browse apps grouped by their capabilities. The app creation and editing flows have been updated to include fields for app name, description, category, and image, with improved validation and UI components like the capabilities chips widget and action fields widget.

app/lib/pages/apps/widgets · high confidence

The chat interface now features a complete overhaul of message rendering, introducing dedicated widgets for AI and user messages that support text selection, context display, and file handling. A new ChartMessageWidget enables inline rendering of bar and line charts within chat responses. The chat input area now includes a compact VoiceRecorderWidget with a dynamic audio waveform and transcription status. Additionally, a MessageActionMenu provides user actions like copy, share, and feedback, while a TypingIndicator widget visualizes the AI's thinking state with optimized animations.

app/lib/pages/chat/widgets · medium confidence

The conversation detail page has been completely rewritten to feature a tabbed interface for Transcript, Summary, and Action Items, along with a new Compare Transcripts page for side-by-side analysis of different transcription services (Deepgram, Soniox, SpeechMatics, Whisper-x). The update introduces in-page search functionality with result highlighting, a reusable Maps utility for location handling, and a dedicated share utility for conversation links.

_app/lib/pages/conversation\detail · high confidence

The onboarding experience has been redesigned with a new multi-step flow. Users now encounter a dedicated AI consent screen to agree to data and privacy policies before signing in. The sign-in process now features distinct buttons for Apple and Google, with platform-specific availability (e.g., Apple Sign-In on iOS/Android). A new 'You are all set' completion screen appears after the user finishes the onboarding steps, which include name entry, primary language selection, device connection, permissions, and a speech profile setup. The flow also includes a knowledge graph preview step and a 'found Omi' device detection step. The wrapper manages the state and transitions between these new pages.

app/lib/pages/onboarding · high confidence

The backend now provides distinct environment templates for different development stages: a local harness template for emulator-based development, an offline template for hermetic provider mocking, a remote dev template for the shared GCP/Firebase stack, and a production reference template. Each template isolates provider secrets and configuration, allowing developers to select the appropriate environment via the OMI\_ENV\_STAGE variable. Additionally, the backend's Python version is pinned to 3.11.15 to ensure consistency with the Dockerfile and lockfile.

backend · high confidence

The NimBLE-Arduino library has been updated to include new header and source files for BLE functionality. This adds support for HID keyboard types, HID types, BLE address handling, advertised device scanning, advertising management, attribute value storage, and iBeacon data structures. These changes enhance the library's capabilities for Bluetooth Low Energy communication on the Seeed Xiao ESP32S3.

_omiGlass/firmware/.pio/libdeps/seeed\_xiao\esp32s3/NimBLE-Arduino · high confidence

Added native iOS support for offline batch audio recording. For Omi devices, the new \OmiBatchAudioWriter\ captures audio from BLE notifications and writes it to local \.bin\ files, allowing the Flutter engine to remain idle instead of forwarding each packet. For Limitless pendants, the \LimitlessFlashDrainEngine\ periodically drains the device's onboard flash memory, extracting opus frames and appending them to \LimitlessBatchAudioWriter\ files. Both implementations use a shared \BaseBatchAudioWriter\ to handle file mechanics like atomic \.part\ promotion, periodic fsyncs, and storage-full guards.

app/ios/Runner/Batch · high confidence

The iOS app now includes native Swift services for Apple Health and Apple Reminders, exposing method channels for reading health data (steps, active energy, heart rate, sleep, workouts) and syncing reminders. The AppDelegate registers Pigeon-based interfaces for BLE, Ray-Ban Meta wearables, and phone microphone capture, while also handling deep links and environment detection. Configuration files (Info.plist, entitlements) are updated with usage descriptions and background modes for these features.

app/ios/Runner · high confidence

The iOS phone call implementation has been rewritten to use a new \OmiCallCoordinator\ protocol that abstracts the call lifecycle. For most regions, this uses Apple's CallKit to integrate with the system dialer and status bar. For regions where CallKit is restricted (e.g., China), the plugin automatically switches to a \OmiDirectCallCoordinator\ that manages audio sessions directly. The plugin now detects the device's region (via locale or carrier) to select the appropriate coordinator. Additional features include a proximity sensor to turn off the screen during calls, structured error reporting to Dart, and thread-safe audio state management.

app/ios/Runner/PhoneCalls · high confidence

The iOS app now includes an ImageNotification extension that processes incoming push notifications. By integrating with Firebase Messaging, the app can now download and display rich media (such as images) in notifications, enhancing the user experience with more engaging alert content.

app/ios/ImageNotification, app/ios/Runner.xcodeproj/project.xcworkspace · medium confidence

The app now uses a dedicated \SharedPreferencesUtil\ class to manage all persistent user preferences, including Bluetooth device state, background and batch capture modes, double-tap actions, and custom STT configurations. This change consolidates preference storage, ensuring that settings like device mute status, batch mode, and double-tap actions are reliably persisted across app restarts and device reconnections.

app/lib/backend · high confidence

The sync processing logic has been extracted from the main router into a new \backend/utils/sync/\ package, introducing dedicated modules for handling backfill admission and daily speech limits, generating and validating signed capture manifests, computing stable content and segment IDs, classifying uploads as fresh or backfill, and managing rate-limit telemetry. This refactoring isolates the sync pipeline, enforces input validation, and adds guards against refusing legitimate offline uploads by relying on the Cloud Tasks queue as the primary pacer.

backend/utils/sync · high confidence

The user service code has been reorganized into a new \backend/services/users/\ package, introducing \account\_deletion.py\ and \data\_export.py\ as distinct modules. This change isolates account deletion logic—including GCE VM cleanup, credential revocation, and derived data purging—from the monolithic user service file, and similarly separates the user data export functionality. The package initializer is kept dependency-free to prevent circular imports and ensure that importing one user service does not pull in unrelated integrations like Stripe.

backend/services/users · high confidence

The /v4/listen WebSocket router has been reorganized into a dedicated \backend/routers/listen\ package, separating concerns into distinct modules for contracts, runtime coordination, audio reception, conversation lifecycle, speaker matching, and parity capture. This refactoring isolates the long-lived session logic from the FastAPI router, allowing the session components to be tested independently and making the async/offload contract explicit through a dedicated persistence boundary. The change also introduces new files for parity pack capture and export, along with telemetry for the capture lifecycle.

backend/routers/listen · high confidence

The capture service has been refactored to improve modularity and device compatibility. The core logic has been split into a new \CaptureController\ that coordinates with extracted helper classes for metrics tracking, freemium thresholds, and location capture. The system now supports routing conversation capture to native recorders on Android and iOS, and explicitly maps the Ray-Ban Meta device as a first-class capture source. Additionally, the architecture introduces a \CaptureExternalActions\ interface to decouple the controller from external dependencies, allowing for better testability and separation of concerns.

app/lib/services/capture · high confidence

The Windows desktop application code has been migrated from the root-level 'windows' directory to the new 'desktop/windows' directory, aligning the project structure with the macOS app's location at 'desktop/macos'.

desktop/windows · high confidence

A change to existing behaviour in app/assets/integration\_app\_logos — 5 commits, 13 files.

_app/assets/integration\_app\logos · medium confidence · unverified

A new schema file for the 'conversations' collection has been added to the backend, defining fields for structured data, timestamps, user ID, and geolocation, with 'created\_at' as the default sorting field.

backend/typesense · medium confidence

A new Swift package file, FlutterGeneratedPluginSwiftPackage.swift, was added to the iOS build configuration. This file is a generated artifact that provides the necessary Swift package structure for Flutter plugins, ensuring that the iOS build process can correctly resolve and compile the generated plugin code.

app/ios/Flutter/ephemeral/Packages/FlutterGeneratedPluginSwiftPackage · low confidence

A new directory structure has been introduced at .cursor/plans with a .gitkeep file, establishing a location for product principles and an invariant registry intended to reduce open-source software (OSS) drift.

.cursor/plans · low confidence

The backend models in \backend/models\ have been migrated to strict Pydantic v2 schemas, introducing new request and response models for tasks, chat, and proactive intents. This change enforces stricter validation on incoming data, such as requiring unique IDs in question options and ensuring cold-start sequences are properly paired. It also introduces new fields and structures for action items, announcements, and chat messages, improving data integrity and type safety across the API boundaries.

backend/models · medium confidence

Environment variables are now managed through a centralized \Env\ class that supports runtime overrides for the API base URL and agent WebSocket URL, while sensitive keys (OpenAI, PostHog, Intercom, Google) are loaded from environment files and obfuscated. This refactoring simplifies configuration management, enforces production routing constraints, and removes unused or insecure secret handling.

app/lib/env · high confidence

The backend/config directory has been refactored to establish a single source of truth for several core systems. Memory feature rollout is now governed by the new memory\_rollout.py module, which defines a state machine for enabling writes, reads, and shadow modes based on environment variables and user cohorts. Speech-to-text routing is standardized via stt\_provider\_policy.py and prerecorded\_stt.py, which enforce provider availability, model selection, and environment contracts for Deepgram, Modulate, and Parakeet. Additionally, task intelligence is formalized through a JSON schema (task\_intelligence\_contract\_v1.json) and a source manifest (task\_intelligence\_sources\_v1.json) that map writer anchors and policy classes across the codebase. Finally, translation services are configured via translation.py, which manages provider selection between Gemini and NLLB, while canonical memory cohort membership is explicitly defined in canonical\_memory\_cohort.py.

backend/config · high confidence

The Windows scripts now use extracted helper modules to share code across multiple generators and harnesses. Dev-instance port derivation and worktree detection logic has been moved into lib/dev-ports.mjs, ensuring that the seed-auth and bootstrap scripts resolve instance ports and identify primary vs. linked worktrees using the same rules as the main application. Icon generation for tray and app icons now shares rasterization primitives (disc, ring, packIco) from lib/icon-raster.mjs to keep the two generators in lockstep. Additionally, lib/omi-auth.mjs provides a shared implementation for parsing .env files, decoding JWTs, and exchanging Firebase refresh tokens, preventing divergence between the diagnostic probe and the PTT live E2E suite.

desktop/windows/scripts · high confidence

The AppShell component was refactored to robustly handle deep links and OAuth callbacks for multiple integration services (Todoist, Asana, Google Tasks, ClickUp, and Google Calendar). The implementation adds specific routing for app, wrapped, tasks, and unlimited upgrade deep links, while also implementing dedicated handlers for OAuth success and error states for each supported service, ensuring users are correctly navigated or shown appropriate error messages.

app/lib/core · high confidence

The home screen UI has been restructured by extracting specific UI elements into their own widget files. This includes a new BatteryInfoWidget that displays device battery status and charging state, a CaptureModeChip for selecting recording modes, a ChatAppsDropdownWidget for managing chat app selection, a DailySummaryCard for displaying daily recaps with maps, and an OutOfCreditsWidget for subscription limits. These changes improve code organization and maintainability while preserving the existing functionality of the home page.

app/lib/pages/home/widgets · high confidence

Added a \clearAllUserState\ helper that wipes in-memory provider state across the app to prevent data leakage between users, and introduced a new \custom\_post\_auth\_page\ that displays a styled 'Authentication Complete' screen with a countdown and progress bar. Additionally, a utility was added to clear sessions for deleted accounts, ensuring proper cleanup of local storage and preferences.

app/lib/utils/auth · high confidence

The backend now includes a new V3 memory read implementation package under \backend/utils/memory/v3\. This adds a canonical read path for account generation, control state, and compatibility decisions, alongside new modules for visibility readiness, cursor handling, and composed GET services. Users will see a new, stricter read path for enrolled accounts that fails closed if control states, generation fences, or projection readiness are not met, while non-enrolled users continue to use the legacy primary path.

backend/utils/memory/v3 · high confidence

The device service layer now includes dedicated error-logging helpers that report crashes via the platform's crash reporter, and a new \ring\_protocol.dart\ file that parses the firmware's ring-buffer storage protocol (including audio payload parsing with corrected boundary checks). Additionally, \models.dart\ defines UUIDs and constants for various device services (Omi, Plaud, Bee, Friend Pendant, etc.), centralizing device-specific identifiers and OTA status codes.

app/lib/services/devices · high confidence

The backend's speech-to-text (STT) utilities were refactored to improve reliability and observability. A new \outcomes.py\ module defines a \TranscriptionFailure\ class that maps internal provider exceptions to a closed set of public, privacy-safe error codes and messages. This is paired with \live\_failure.py\ to standardize how live transcription sessions are terminated and reported when upstream providers fail. Additionally, \provider\_resilience.py\ introduces a process-local circuit breaker to prevent repeated connection attempts to unhealthy STT services, while \safe\_socket.py\ wraps the Deepgram connection with automatic keepalive and dead-connection detection. These changes collectively reduce the impact of provider outages and improve the clarity of error states for users.

backend/utils/stt · high confidence

For Ray-Ban DAT builds, the iOS plugin graph is now isolated from the standard Flutter plugin registry. The \rayban\_dat\_plugin\_boundary.rb\ script automatically removes the \mcumgr\_flutter\ plugin from the iOS build configuration, ensuring that this plugin is not included in the generated iOS plugin graph for these specific builds, while the Android plugin graph remains unchanged.

app/ios · high confidence

The Memories page has been restructured to include a dedicated view for each memory category, allowing users to filter and manage memories by type. The main Memories page now features a search bar, pull-to-refresh, and a bottom navigation bar with icons. A key behavioral change is the addition of an 'undo' option when deleting a memory, which appears as a temporary notification allowing users to restore recently deleted items. The page also integrates with the app's localization system for multi-language support.

app/lib/pages/memories · high confidence

The app's HTTP API client layer has been refactored to use generated wire schemas for all response and request models. New files in app/lib/backend/http/api/ (including action\_items.dart, agents.dart, announcements.dart, apps.dart, audio.dart, conversations.dart, dev\_api.dart, device.dart, folders.dart, goals.dart, and imports.dart) now parse backend JSON responses through generated Dart types (e.g., GeneratedActionItemsResponse, GeneratedAppCatalogResponse, GeneratedGoalResponse). This ensures consistent, type-safe data mapping across the app, replacing hand-written JSON decoding with auto-generated wire models for endpoints covering action items, agents, announcements, apps, audio, conversations, dev APIs, firmware, folders, goals, and imports.

app/lib/backend/http/api · high confidence

The app's backend schema layer has been refactored to use generated Dart wire types. Simple 1:1 mappings (like DevApiKey, McpApiKey, and ActionItemWithMetadata) are now typedefs to the generated types. More complex classes (like Person, Folder, and Memory) remain as deliberate adapters to handle custom logic, default values, and field name normalization. This change simplifies the codebase by removing hand-written boilerplate where possible while preserving necessary client-side behavior.

app/lib/backend/schema · high confidence

The mobile app's main routing logic has been refactored to include a new permissions gate. When a signed-in user has completed onboarding but not yet granted required permissions, they are now routed to a permissions interstitial page before accessing the home screen. Additionally, the app now detects session expiration and prompts the user to sign in again via an onboarding wrapper, ensuring users are not left in an invalid state.

app/lib/mobile · high confidence

The app submission and update interface has been refactored into a dedicated provider class that manages complex form states, including separate form keys for metadata, external integration, prompts, and pricing. The update flow now resets form state at the start of preparation to prevent stale dirty states, and includes specific logic to detect changes in thumbnails, visibility, paid plans, and authentication URLs. Additionally, the provider now supports pre-filling data for conversation analysis templates and external integrations, while also handling API key management and image caching for app thumbnails.

app/lib/pages/apps/providers · medium confidence

The app's offline audio sync has been restructured to support multiple storage backends (SD card, flash page, ring buffer, and multi-file storage) with improved reliability and error handling. A new \RecordingTransferCoordinator\ manages foreground recovery passes, while a \SyncRateLimiter\ persists fair-use cooldowns to prevent hammering the server after 429 errors. The \SyncReconciler\ now schedules background reconciliation with exponential backoff, and \LocalWalSync\ has been refactored to handle chunking, flushing, and state persistence more robustly. These changes ensure that sync failures are retried correctly, stale states are cleared, and users see accurate progress and error details during offline sync.

app/lib/services/wals · high confidence

The plugins directory has been restructured to support a shared Python SDK (\omi-plugin-sdk\) that centralizes webhook models and helper utilities. A new \plugins/.env.template\ file provides environment variable defaults for integrations like Notion, Groq, and Mem0. The \plugins/Dockerfile\ and \plugins/Dockerfile.datadog\ define the build and runtime environments for the plugin services. Documentation files (\README.md\, \LEGACY\_MONOLITH.md\, \PLUGING\_REFACTOR\_AUDIT.md\) explain the migration to the new SDK and the status of the legacy monolith. The \plugins/main.py\ file serves as the entry point, importing and mounting various plugin routers (e.g., Notion, Multion, ChatGPT). Helper modules like \plugins/db.py\ and \plugins/utils.py\ provide Redis interactions and token counting utilities. A new script \plugins/scripts/check\_plugin\_imports.py\ is added to validate plugin imports and generate OpenAPI schemas.

plugins · high confidence

The full-page recording detail screen has been replaced by a floating bottom sheet. This new interface provides playback controls, a waveform visualization, and access to share, details, and delete actions, offering a more compact and immediate way to interact with offline or batch recordings.

_app/lib/pages/conversations/recording\detail · high confidence

The backend templates for OAuth flows have been completely redesigned to provide a consistent, modern user interface across all authentication steps. This includes a new shared stylesheet for consistent styling, a redesigned authorization page that displays app permissions and supports email login, and a callback page that validates redirect URIs against a strict allowlist to prevent open redirect vulnerabilities. Additionally, the templates now support dynamic redirect URIs for mobile and CLI clients, and include a manual fallback link for users who need to open the app manually.

backend/templates · high confidence

The app detail page has been redesigned to include a dedicated reviews list page with filtering and sorting capabilities, allowing users to view and reply to reviews. The page also integrates chat functionality, enabling users to start a conversation with the app directly from the detail view. Additionally, the UI now supports auto-opening the app's home page after installation and includes analytics tracking for app interactions.

_app/lib/pages/apps/app\detail · high confidence

The onboarding welcome page has been redesigned to include medium haptic feedback on button presses and a new flow that requests Bluetooth permissions before proceeding. The UI now features animated transitions, including an expanding top section and fade-out effects for buttons, while handling permission denial by displaying a dialog to open device settings.

app/lib/pages/onboarding/welcome · high confidence

The conversations and sync pages have been completely redesigned to improve the user experience for managing recordings and sync status. The new auto-sync page features a polished status card that clearly displays sync phases (downloading, uploading, processing), rate-limiting states, and error conditions, while the conversations page now supports folder tabs, search, and displays unsynced recordings inline. The sync page also includes a redesigned manage storage sheet and improved handling of the sync cooldown state to ensure users are aware of rate limits. These changes are supported by a new local storage and private cloud sync settings pages, allowing users to toggle storage options directly from the app.

app/lib/pages/conversations · high confidence

The translation logic has been reorganized into a new \backend/utils/translation\_core\ package, introducing a canonical translation planner, execution engine, cache, and provider chain. This refactoring includes a new Redis-backed cache with an in-memory LRU layer, a translation engine that supports both whole-text and sentence-level modes, and a provider chain that routes translation requests through an LLM gateway (specifically using Gemini Flash-Lite) with fallback to NLLB. The change also adds comprehensive metrics collection for translation operations, errors, and cache hits/misses.

_backend/utils/translation\core · high confidence

The onboarding flow for finding and connecting to devices has been restructured into dedicated components (FoundDevices, FindDevicesPage) with improved state management via the OnboardingProvider. The device scanning process now explicitly handles Bluetooth and location permission dialogs, and the connection logic is unified for Ray-Ban Meta and Apple Watch devices, ensuring proper lifecycle management (e.g., stopping scans on disposal) and handling device-specific onboarding steps (e.g., microphone permissions for Apple Watch).

_app/lib/pages/onboarding/find\device · high confidence

The Dart wire models for the app-client API have been regenerated from the OpenAPI specification, introducing new or updated response schemas for action items, agents, announcements, API keys, apps, audio, conversations, device speech, and more. These generated classes now enforce stricter parsing and serialization of API responses, ensuring that client code correctly handles the latest contract definitions for features like action items, agent keepalives, announcements, API key management, app capabilities, audio processing, conversation transcripts, and firmware updates.

app/lib/backend/schema/gen · high confidence

The app's generated Dart code has been updated to reflect new and modified assets, fonts, and Pigeon interfaces. The assets generator now includes the 'limitless' logo and various other image and SVG assets, while the fonts generator exposes the 'SF Pro Display' family. Additionally, the Pigeon bindings have been regenerated to include the PhoneMic capture interface and BLE communicator interfaces, ensuring the Dart layer matches the current native platform contracts.

app/lib/gen · high confidence

The legacy consolidation implementation in the backend has been removed. The module now only contains a docstring indicating that canonical consolidation logic has been migrated to \\utils.memory.canonical\_consolidation\\.

backend/utils/consolidation · high confidence

The device connection implementation has been refactored into a modular connector architecture under the new \app/lib/services/devices/connectors/\ directory. A generic \CustomDeviceConnection\ base class was introduced to standardize the handling of custom BLE protocols, which is now used by the \BeeDeviceConnection\ and \FieldyDeviceConnection\ implementations. Additionally, specific connection handlers for Apple Watch, Friend Pendant, and other devices have been reorganized into this new structure, improving code maintainability and consistency across different device types.

app/lib/services/devices/connectors · high confidence

The backend now uses a new utility module (backend/utils/llms/memory.py) to fetch and format user memories for LLM prompts. This change introduces a structured approach to retrieving baseline, user-made, and generated memories, ensuring that baseline memories are prioritized in the context. The implementation includes safe creation of memory objects with legacy category handling and filters out locked memories.

backend/utils/llms · high confidence

The backend now centralizes retrieval logic for conversations, action items, and memories into a new \tool\_services\ package. This refactoring provides a single source of truth for formatting and fetching data, ensuring consistent behavior across LangChain tools and REST routers. The changes include adding shared service functions for each domain, implementing timezone-aware date formatting for user-facing timestamps, and introducing robust error handling for database failures and malformed documents.

_backend/utils/retrieval/tool\services · high confidence

The Android build system has been updated to use Gradle 8.14.2, which is required for compatibility with Android Gradle Plugin (AGP) 8+. This change ensures the project can be built with modern Android tooling and supports newer Java and Flutter versions.

app/android/gradle · medium confidence

The app's ProGuard configuration has been updated to suppress R8 missing-class errors for Firebase KTX and other libraries, while explicitly keeping classes for Flutter, Awesome Notification, Firebase, the foreground task service, Twilio SDK, and Lombok annotations. This change ensures that minification and obfuscation do not break functionality for these dependencies.

app/android/app · high confidence

The iOS application's user interface has been updated with new storyboard files. The launch screen now features a background image and a centered logo image, replacing the previous default splash screen. Additionally, the main storyboard has been updated to use the FlutterViewController, ensuring the app correctly initializes the Flutter engine. These changes affect the visual appearance of the app's startup and initial view on iOS devices.

app/ios/Runner/Base.lproj · medium confidence

The web application now includes a new index.html template that configures the app as a Progressive Web App (PWA) with a manifest.json file, enabling offline capabilities and home screen installation. Additionally, the splash screen has been improved with better styling and branding for iOS and Android devices, including maskable icons for a more polished launch experience.

app/web · medium confidence

The iOS Bluetooth Low Energy (BLE) functionality has been re-implemented using Apple's native CoreBluetooth framework, replacing the previous third-party library. This change introduces new Swift files (BleHostApiImpl.swift and OmiBleManager.swift) that bridge Flutter calls to a custom OmiBleManager, enabling better battery efficiency and background reliability. The new implementation handles scanning, peripheral connection, and characteristic read/write operations natively, addressing previous issues with broken BLE pairing and connection stability.

app/ios/Runner/Ble · high confidence

The iOS build system has been restructured to support the Omi app name and enable seamless integration with the Meta Wearables Device Access Toolkit (DAT). Developers can now build the app on their own iPhones without needing device registration via the Omi Apple Developer portal, as the configuration allows for local development environments. The setup includes new xcconfig files for various build modes (debug, release, profile) and specific configurations for Ray-Ban Meta devices, including the addition of a template for Meta credentials and a new AppFrameworkInfo.plist. This change also isolates Ray-Ban DAT SwiftProtobuf graph dependencies and updates the bundle identifiers and Google reverse client IDs to support the new branding and third-party integrations.

app/ios/Flutter · medium confidence

The iOS project configuration has been updated to embed the Apple Watch app, integrate the Ray-Ban Meta wearable SDK, and add native Swift modules for phone microphone capture and audio processing. This includes new build phases for embedding watch content and foundation extensions, linking WatchConnectivity and MWDATCore frameworks, and registering numerous Swift source files for features like BLE, batch audio writing, and call coordination.

app/ios/Runner.xcodeproj · medium confidence

Resolves a crash or failure caused by duplicate session inserts violating the database's UNIQUE constraint, ensuring session creation is idempotent and safe against race conditions.

desktop · high confidence

The backend routers now gracefully handle malformed or invalid records in the conversations, action items, and memories endpoints, preventing 500 errors and ensuring the API returns appropriate error responses (400/404) instead of crashing. This includes skipping malformed records in list endpoints, guarding against missing user documents, and validating input data before processing. These changes enhance the stability of the API, ensuring that issues with individual records do not disrupt the entire response.

backend/routers · high confidence

The apps stats API route now uses Promise.allSettled to fetch data from multiple sources, ensuring that a failure in one source does not crash the entire request. If all data sources fail, the API returns a 502 error. Additionally, the response now includes a 'partial' flag to indicate when some data sources failed but others succeeded, allowing the client to handle partial data gracefully.

web/admin/app/api/omi/apps/stats · high confidence

Adds a new \auth\_token\_result.dart\ file defining a sealed class hierarchy for authentication token outcomes, including success, transient failures, missing user/token states, and terminal failures. It also introduces an \AuthSessionExpiredEvent\ to track expiration reasons, an \AuthUserSnapshot\ for user data, a \RefreshedAuthToken\ wrapper, and an \AuthTokenGateway\ interface for token management. This refactors how authentication states and errors are represented and accessed within the auth service.

app/lib/services/auth · medium confidence

Add STT wire-fidelity replay oracle test; Add shared test fixtures for memory, Firestore, and release manifests; Add structural test for LLM gateway loopback; Add unit tests for account deletion and data export services; Added LC3 frame-cadence replay oracle test; Added LLM streaming wire-fidelity test harness; Added Phase 0A replay harness for offline-sync feasibility testing; Added a local Sync Cloud Tasks stack gauntlet for integration testing; Added backend schema and wire decode tests; Added chaos engineering harness to reproduce and verify memory leak fixes; Added container-level test suite for parakeet; Added contract tests for desktop backend parity; Added deterministic orb harness for automated visual regression testing; Added firmware test suite for hardware peripherals and BLE throughput; Added hermetic e2e test fakes for backend services; Added iOS test suite for Ray-Ban DAT build and plugin boundary; Added integration tests for animation performance, iOS auth refresh, and widget rebuild profiling; Added integration tests for fair-use, geocoding cache, and listen pipeline; Added local contract tests for memory-V3-F6 evidence pipeline; Added local listen-to-pusher stack gauntlet for high-fidelity integration testing; Added local parity-pack v0 testing infrastructure; Added proactive notification evaluation tests; Added smoke test to verify test harness without codegen dependencies; Added test coverage for BLE bridge pairing loss handling; Added test script for chat streaming functionality; Added test-only memory modules to the backend/testing/memory namespace; Added tests for WAL sync and recording transfer coordination; Added tests for agent chat service error handling; Added tests for app localizations, device detection, plan pricing, and audio combining; Added tests for audio URL parsing and auth header construction; Added tests for conversation rollback, import job lifecycle, and account deletion workflows; Added tests for desktop Beta admission emulator harness; Added tests for subscription plan mapping, conversation day-keying, and provider state management; Added unit tests for /v3 memory router behavior and integration; Added unit tests for capture service trackers; Added unit tests for the Listen Pusher Session; Added unit tests for v3 production read probes; Added widget tests for audio wave painter, device connectivity, and UI components; Backend test infrastructure: hermeticity enforcement, duration guards, and new unit tests; Expanded backend unit test coverage; Expanded unit test coverage for audio, sync, and auth flows; Introduce backend testing infrastructure for workflow contracts and test isolation; Introduce hermetic backend e2e test harness.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 52.

• Code Health 78
• Architecture 75
• Maturity 85
• Readiness 47
• Security 52
• Domain Modelling 57
• Accessibility 49

• 300 commits — 131 feature/other, 169 fixes

• (repo) — 82 commits
• desktop/macos — 62 commits
• backend/tests — 40 commits
• .github/scripts — 30 commits
• backend/scripts — 24 commits
• backend/routers — 10 commits
• app/lib — 9 commits
• backend/utils — 8 commits
• .github/workflows — 5 commits
• desktop/windows — 5 commits
• backend/database — 3 commits
• backend/llm_gateway — 3 commits
• backend/models — 3 commits
• (root) — 2 commits
• .github/checks-manifest.yaml — 2 commits
• .github/failure-classes — 2 commits
• backend/deploy — 2 commits
• backend/modal — 2 commits
• backend/testing — 2 commits
• app/ios — 1 commit

• fix: Fix macOS chat transcript layout and initial scroll
• fix: Merge origin/main into parity capture fix
• fix: Merge pull request #11111 from BasedHardware/fix/agent-vm-dev-bootstrap-followup
• fix: Merge pull request #11114 from BasedHardware/fix/agent-vm-bootstrap-runtime-followup
• fix: Merge remote-tracking branch 'origin/main' into agent/fix-ptt-web-search
• fix: Merge remote-tracking branch 'origin/main' into codex/pr-11029-review-fixes
• fix: Merge remote-tracking branch 'origin/main' into codex/pr-11029-review-fixes
• fix: chore(desktop): add changelog for review hardening fixes
• fix: chore(macos): document sustained chat scroll fix
• fix: chore: ratchet desktop line-count baselines for review fixes
• fix: ci: fix deploy source-admission checks for composite action
• fix: ci: fix typecheck for runtime env validation shim
• fix: fix graph enrichment type access
• fix: fix historical graph enrichment status types
• fix: fix withhold unverified gmail.readonly scope from the Google consent request (#10997)
• fix: fix(agent-vm): add declarative fleet reconciler
• fix: fix(agent-vm): add declarative fleet reconciler (#11126)
• fix: fix(agent-vm): address reconciler review findings
• fix: fix(agent-vm): address remaining reconciler review findings
• fix: fix(agent-vm): close remaining reconciler review gaps
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

BasedHardware/omi was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.