Zackriya-Solutions/meetily

Meetily is a self-contained, cross-platform desktop application built with Tauri, Rust, and Next.js that records meetings and generates AI-powered summaries locally. It features a modular audio pipeline supporting multiple transcription engines like Whisper and Parakeet, alongside a flexible summary system that leverages both local LLMs and remote providers such as OpenAI and Ollama. The application manages the entire lifecycle of meeting data, from capture and storage in a local SQLite database to retrieval, editing, and export, while handling platform-specific audio permissions and hardware acceleration.

51 changes.

The project migrated from a legacy backend to a self-contained Tauri desktop application, introducing a comprehensive Rust-based audio processing pipeline with GPU acceleration and multi-engine transcription support. This period focused on rebuilding the core infrastructure to handle local AI inference, robust data persistence, and professional-grade audio capture across Windows, macOS, and Linux.

6 changes.

This period focused on implementing audio file import capabilities and integrating backend support for external AI model providers like OpenAI, Anthropic, and Groq. The work also included bundling essential runtime binaries such as FFmpeg and ONNX to improve build reliability, alongside centralizing configuration constants and expanding test coverage for core features.

Users can now recover meetings that were interrupted before completion. A new modal dialog lists recoverable meetings stored in IndexedDB, allowing users to preview transcript snippets and choose to recover or delete the interrupted session.

frontend/src/components/TranscriptRecovery · high confidence

Users can now import external audio files via a new ImportAudioDialog component and a global drag-and-drop overlay (ImportDropOverlay). The dialog allows selecting files, choosing a transcription model and language, and viewing import progress, while the overlay provides visual feedback when dragging files onto the page. The implementation includes logic to prevent dialog re-initialization on configuration changes using a previous-open reference, ensuring stable state during the import workflow.

frontend/src/components/ImportAudio · high confidence

The application now includes backend modules for OpenAI, Anthropic, and Groq that expose Tauri commands to fetch available chat-capable models directly from their respective APIs. These modules implement a 5-minute in-memory cache to reduce API calls and provide a hardcoded fallback list of models if the API is unreachable or returns an error, ensuring the frontend always has a list of selectable models.

frontend/src-tauri/src/anthropic, frontend/src-tauri/src/groq, frontend/src-tauri/src/openai · high confidence

This release introduces three new scripts to support the Meetily v0.2.0 update and data workflows. The \generate-update-manifest-github.js\ script automates the creation of Tauri-compatible update manifests by scanning local bundle directories for platform-specific files (macOS, Windows, Linux) and generating the required \latest.json\ with GitHub release URLs and signatures. To facilitate testing, \test-update-locally.js\ provides a local HTTP server that serves this manifest, allowing developers to verify the over-the-air (OTA) update flow before publishing to GitHub. Additionally, \inject\_transcript.py\ enables the programmatic injection of CSV-based meeting transcripts into the local SQLite database, creating meeting entries with estimated audio timings for testing or data migration purposes.

scripts · high confidence

A new PowerShell script (sign-windows.ps1) has been added to handle code signing for Windows builds. It uses the DigiCert smctl tool to sign executable files when the DIGICERT\_KEYPAIR\_ALIAS environment variable is set, and includes a verification step to ensure the signature is valid before completing.

frontend/src-tauri/scripts · high confidence

A new \DownloadProgressToast\ component has been introduced to provide real-time feedback during model downloads. This feature displays a progress bar with percentage, downloaded size, and speed, while also categorizing error messages (such as network, server, or storage issues) into user-friendly explanations to improve the onboarding experience.

frontend/src/components/shared · high confidence

Users on Windows and macOS can now explicitly show, hide, or toggle the application's debug console window via new Tauri commands. On Windows, this utilizes native kernel32 APIs to allocate or hide the console window, while on macOS, it opens or closes a Terminal window displaying live application logs via \log stream\. These utilities are exposed through the \console\_utils\ module to assist with debugging and log monitoring.

_frontend/src-tauri/src/console\utils · high confidence

The build and development scripts now automatically detect available GPU hardware (NVIDIA CUDA, AMD ROCm, Apple Metal/CoreML, or Vulkan) and configure the Tauri build process to enable the corresponding hardware acceleration features. This removes the need for manual configuration of GPU features, allowing the application to leverage hardware acceleration on supported platforms while falling back to CPU-only mode if no compatible GPU is found.

frontend/scripts · high confidence

The database import flow now includes an automatic detection step for legacy Meetily data stored in Homebrew directories on macOS. The new HomebrewDatabaseDetector component checks standard paths for both Apple Silicon (/opt/homebrew) and Intel (/usr/local) Macs; if a previous database is found, users are presented with a prompt to automatically import their meetings and transcripts, or to decline and proceed with manual selection via the existing LegacyDatabaseImport dialog.

frontend/src/components/DatabaseImport · high confidence

The application now uses dedicated constant files to manage core configuration data, improving maintainability and ensuring consistency with the backend. \audioFormats.ts\ defines the supported audio extensions (MP4, M4A, WAV, MP3, FLAC, OGG, AAC, MKV, WebM, WMA) and provides helper functions for validation and UI display, keeping them in sync with the Rust backend. \languages.ts\ lists the ISO 639-1 language codes supported by the Whisper engine, including auto-detection and translation options. \modelDefaults.ts\ establishes the default transcription models, specifically \large-v3-turbo\ for Whisper and \parakeet-tdt-0.6b-v3-int8\ for Parakeet, ensuring these defaults align with the Rust configuration.

frontend/src/constants · high confidence

The frontend now uses dedicated service classes in \frontend/src/services\ to handle all Tauri backend interactions, replacing scattered direct API calls. This introduces a structured approach to managing app configuration (including support for custom OpenAI endpoints), recording lifecycles (with improved timeout handling for device enumeration), and transcript operations. Additionally, a new IndexedDB service enables local transcript recovery in case of crashes, and an update service automates software version checks and installations.

frontend/src/services · high confidence

The onboarding component now guides users through a structured 4-step setup process: a welcome screen, a system overview, a background model download progress indicator, and a permissions request. The flow includes a specific check for macOS to conditionally display the permissions step, ensuring users only see requests for microphone and system audio access when running on that platform.

frontend/src/components/onboarding · high confidence

Added a new Parakeet (NVIDIA NeMo) speech-to-text engine as a high-performance alternative to Whisper, leveraging ONNX Runtime for real-time transcription with Int8 quantization. This change introduces the core Rust implementation for model management, including downloading, caching, and loading Parakeet V2 and V3 models, along with Tauri commands to expose engine initialization, model discovery, and loading status to the frontend.

_frontend/src-tauri/src/parakeet\engine · high confidence

Users can now generate meeting summaries using a built-in local AI engine instead of relying solely on external providers. This change adds a new summary engine module that manages the lifecycle of the llama-helper sidecar, handles downloading and caching of local GGUF models (specifically Qwen 3.5 2B and 4B, plus Gemma 3), and exposes Tauri commands for model management and text generation. The system automatically recommends a model based on system RAM and provides detailed download progress tracking with speed metrics in the UI.

_frontend/src-tauri/src/summary/summary\engine · high confidence

The application now supports structured meeting summaries via a new template system located in the summary module. Two built-in templates—'daily\_standup' and 'standard\_meeting'—are embedded in the binary as fallbacks. Users can also place custom JSON templates in the platform-specific application data directory (e.g., \\~/.config/Meetily/templates/\ on Linux), which take precedence over the built-in ones. The system validates template structures and generates specific instructions for the LLM to extract content into defined sections.

frontend/src-tauri/src/summary/templates · high confidence

The desktop application now features a system tray that allows users to start, pause, resume, and stop recordings without opening the main window, and keeps the app running in the background when closed. A new onboarding process guides users through initial setup and model configuration, while the app also integrates with OpenRouter to fetch and manage available AI models directly from the backend.

frontend/src-tauri/src · high confidence

A new \llama-helper\ component has been added to the system, providing a Rust-based service that communicates via JSON over stdin/stdout to manage local Large Language Model inference. This helper handles request parsing for generation parameters (such as temperature, top\_k, and penalties), implements VRAM detection for macOS (Metal) and NVIDIA (CUDA) platforms to optimize GPU layer allocation, and manages the lifecycle of the \llama-cpp\ backend. This change introduces the underlying infrastructure for running local models, distinct from any existing remote or summary-specific logic.

llama-helper · high confidence

The meeting details view has been updated to automatically generate summaries when navigating from a recording, provided the user's auto-summary preference is enabled and a model is configured (defaulting to gemma3:1b via Ollama if none exists). Additionally, transcript loading now uses pagination to improve performance for large meetings, and the page tracks analytics events for page views.

frontend/src/app/meeting-details · high confidence

The summary generation engine now supports producing meeting summaries in languages other than English. It automatically detects the language of the transcript using the \whatlang\ library and allows users to override the output language via per-meeting metadata. The system uses a two-pass pipeline: it first generates a base summary in English (which is cached to avoid redundant work) and then translates or normalizes it to the target language. The implementation includes robust handling of LLM reasoning blocks (stripping them for Ollama and Claude models), fallback logic for unsupported languages, and specific Tauri commands to manage language preferences and detected language metadata.

frontend/src-tauri/src/summary · high confidence

The frontend now includes a dedicated About page that displays the app version, highlights key features, and provides a 'Check for Updates' button. A new analytics consent flow has been added, featuring a switch to enable usage analytics (off by default), a modal explaining what data is collected, and a user ID display for support. Additionally, an audio backend selector component allows users to choose between different system audio capture methods, and a Bluetooth playback warning alerts users if they are using a Bluetooth device for playback, which may cause audio distortion.

frontend/src/components · high confidence

The application now includes a new rich text editing capability powered by the BlockNote library. A reusable Editor component has been added to handle content initialization, real-time change notifications, and editable state management, while a BasicBlockNoteTest component demonstrates the integration by allowing users to convert Markdown input into the block-based editor view.

frontend/src/components/BlockNoteEditor · high confidence

The frontend now includes a comprehensive set of build scripts for Windows (batch and PowerShell) and Unix-like systems (bash), introducing dedicated GPU-accelerated workflows for both development and production builds. These scripts automatically detect the local GPU capabilities to configure the Rust \llama-helper\ sidecar with the appropriate acceleration features (such as Vulkan or CUDA) and manage the Visual Studio environment setup. Additionally, a new \.env.example\ file documents the required Tauri code signing configuration, and a PowerShell wrapper (\build.ps1\) has been added to load these signing credentials and execute the build process, enabling signed application releases.

frontend · high confidence

The audio subsystem has been replaced with a new architecture designed to improve performance and reliability during recording and transcription. Key additions include an asynchronous logger to prevent log writes from blocking audio threads, a buffer pool to reduce memory allocation overhead, and a batch processor to optimize metric collection. The pipeline now features professional-grade audio processing with EBU R128 loudness normalization and true peak limiting, alongside high-quality chunked sinc resampling for large files to preserve VAD accuracy. Device handling has been enhanced with a multi-layer detection system for Bluetooth vs. wired inputs, adaptive buffering, and robust monitoring for disconnect/reconnect events. Additionally, the system now supports a wider range of import formats (including MKV, WebM, and WMA via FFmpeg) and includes utilities for atomic transcript saving and intelligent speech segment splitting at silence boundaries.

frontend/src-tauri/src/audio · high confidence

This change introduces several new React context providers in the frontend to centralize state management and improve reliability. The ConfigContext now handles model configurations, provider API keys, and beta feature flags, while the OnboardingContext manages the initial setup flow, including background model downloads and permission checks. A new RecordingStateContext provides a single source of truth for recording lifecycle status (starting, recording, stopping) that syncs with the backend, and the RecordingPostProcessingProvider ensures post-recording actions are handled correctly regardless of the current UI page. Additionally, the OllamaDownloadContext tracks model download progress persistently, and the ImportDialogContext gates the import feature behind a beta flag.

frontend/src/contexts · high confidence

The application now uses a new Rust-based SQLite database layer (via sqlx) to store meeting transcripts, summaries, and settings. For existing users, the app can automatically detect and import legacy database files (meeting\_minutes.db) from the app data directory, Homebrew installations, or user-selected paths, migrating the data to the new format. First-time users are guided through an onboarding flow to initialize a fresh database. The system also includes defensive handling for corrupted WAL files and graceful cleanup on shutdown.

frontend/src-tauri/src/database · high confidence

This change introduces a suite of new React hooks in the frontend to support enhanced media and data handling. The \useAudioPlayer\ hook enables local audio playback via the Web Audio API and Tauri file commands, while \useImportAudio\ manages the end-to-end workflow for importing external audio files, including progress tracking and analytics. To improve performance with large datasets, \usePaginatedTranscripts\ implements server-side pagination and debouncing for transcript loading. Additionally, \useAutoScroll\ provides intelligent scrolling behavior for live transcripts, \useProcessingProgress\ tracks chunk-level transcription status, and \useModalState\ centralizes modal management for system events like transcription errors and model downloads.

frontend/src/hooks · high confidence

This change introduces a suite of new TypeScript modules in the frontend library to support core application features. The new \analytics.ts\ module provides a client-side interface for tracking user events, sessions, and device information via Tauri commands, with persistent user ID storage. New modules for AI and transcription (\builtin-ai.ts\, \parakeet.ts\, \whisper.ts\) define types, model configurations (including quantized variants for Whisper), and API wrappers for managing local AI model downloads, status, and usage. Supporting libraries handle summary content parsing and validation (\summary-content.ts\), language preference management (\summary-language-preferences.ts\, \summary-languages.ts\), onboarding model status resolution (\onboarding-summary-model.ts\), and transcription model readiness checks (\transcription-model-readiness.ts\). Additionally, \blocknote-markdown.ts\ adds safe markdown conversion for the editor, \recordingNotification.tsx\ implements the recording start notification UI, and \utils.ts\ provides helper functions for Ollama error detection and class name merging.

frontend/src/lib · high confidence

The meeting details view now uses a set of dedicated React hooks to manage its state and side effects. useMeetingData centralizes meeting metadata, transcript access, and summary persistence, ensuring the UI stays in sync with the backend. useCopyOperations replaces inline logic to provide robust copying of full transcripts (fetching all records regardless of pagination) and AI summaries (with fallbacks for legacy formats). useSummaryGeneration handles the complex lifecycle of AI summary creation, including language detection, polling, cancellation, and error recovery. Additional hooks manage model configuration (useModelConfiguration), template selection (useTemplates), and file system operations (useMeetingOperations).

frontend/src/hooks/meeting-details · high confidence

The application introduces a new, modular audio processing system in the \audio\_v2\ module, designed to replace the legacy audio handling. This new system provides professional-grade features including dynamic audio mixing (with Fixed, Dynamic, and Professional modes that support ducking and crossfading), EBU R128 audio normalization, true peak limiting, and timestamp-based audio synchronization. It also features a compatibility layer (\LegacyBridge\) that allows users to switch between the legacy and modern audio systems or run them in parallel for comparison. While the core infrastructure for async stream-based recording and mixing is implemented, several advanced processing components (such as the true peak limiter, dynamic resampler, and full synchronization engine) are currently placeholders with basic fallback logic.

_frontend/src-tauri/src/audio\v2 · high confidence

The application now includes a dedicated notification subsystem that manages system-level alerts for recording events (start, stop, pause, resume), transcription completion, meeting reminders, and system errors. Users can configure specific preferences for each event type, enable or disable notification sounds, and control Do Not Disturb modes (including manual override and respect for system DND). The system handles permission requests and persists settings locally, ensuring notifications are only shown when consent is granted and settings allow.

frontend/src-tauri/src/notifications · high confidence

The application now includes a comprehensive set of UI components sourced from shadcn/ui, providing a consistent and accessible design system. This addition introduces foundational elements such as Accordion, Alert, Button, Dialog, Dropdown Menu, Form, Input, Label, Popover, Progress, Scroll Area, Select, Separator, Sheet, Switch, Tabs, Textarea, and Tooltip. These components are built on top of Radix UI primitives and styled with Tailwind CSS, enabling developers to compose complex interfaces with standardized behavior and appearance.

frontend/src/components/ui · high confidence

This change introduces new TypeScript type definitions in the frontend to support several new capabilities. It adds a beta feature system (betaFeatures.ts) that allows users to toggle the 'Import Audio & Retranscribe' feature via localStorage, and defines the structure for a 4-step onboarding flow with permission checks (onboarding.ts). Additionally, it significantly expands the transcript data model (index.ts) by adding fields for recording-relative timestamps, confidence scores, and partial status to support playback sync and virtualized pagination, while also introducing new types for summary processing states and API responses.

frontend/src/types · high confidence

The Ollama module has been restructured to include robust model management capabilities. It now fetches and caches model metadata (such as context size) from the Ollama API with a 5-minute TTL to improve performance and reduce redundant network calls. Additionally, the system tracks models currently being downloaded to prevent duplicate operations and provides detailed error handling for network issues, timeouts, and invalid endpoints, ensuring users receive clear feedback when interacting with local or remote Ollama instances.

frontend/src-tauri/src/ollama · high confidence

The whisper engine now supports parallel processing of audio chunks to improve transcription speed for large files, governed by a system monitor that dynamically calculates a safe worker count based on available memory, CPU usage, and core count (capped at 4 workers). GPU acceleration is now explicitly detected and configured at runtime, supporting Metal, CUDA, Vulkan, and HIP BLAS backends with optional Flash Attention for high-performance tiers. The engine also introduces robust model management, including directory initialization, status discovery, and event-driven loading states, while suppressing verbose C library logs to reduce console noise.

_frontend/src-tauri/src/whisper\engine · high confidence

The Meeting Details view has been restructured into a new split-pane layout that displays the transcript and AI summary side-by-side on desktop, with a draggable, keyboard-accessible separator and a tabbed interface for mobile. The summary experience now includes a dedicated button group for generating, stopping, and regenerating summaries, selecting templates, and configuring the AI model, along with a language picker that persists the chosen summary language to meeting metadata or local storage. The transcript panel now uses a virtualized view for improved performance and includes a custom prompt input for providing context to the AI. Additionally, a new retranscription feature allows users to re-process meeting audio to enhance transcripts, gated behind a beta feature flag and exposed via a dialog with progress tracking and model selection.

frontend/src/components/MeetingDetails · high confidence

The Tauri backend's API layer has been reorganized into a single, unified module. Command handlers and data structures (such as meeting, transcript, and model configuration types) are now defined directly in \api.rs\, while \commands.rs\ serves only as a compatibility shim to maintain module structure. This consolidation simplifies the codebase by removing duplication between the command dispatch and API definition layers.

frontend/src-tauri/src/api · high confidence

A change to existing behaviour in frontend/src-tauri/icons — 3 commits, 28 files.

frontend/src-tauri/icons · medium confidence · unverified

The analytics module in the Tauri frontend has been updated so that tracking is disabled by default. The \AnalyticsConfig\ struct now sets \enabled\ to \false\ by default, meaning no data is sent to PostHog unless explicitly enabled. This change ensures user privacy is respected out-of-the-box, requiring an explicit action to activate analytics collection.

frontend/src-tauri/src/analytics · high confidence

The application root has been restructured to include a guided onboarding flow for new users, comprehensive analytics tracking via PostHog, and a beta audio import feature (with drag-and-drop support) gated by configuration. The layout now manages global state for recording, transcripts, and model downloads, while the home page implements automatic recovery of interrupted meetings and cleanup of stale data. Visually, the app adopts a new neutral color palette (replacing the previous blue-dominant theme), introduces custom animations (vibrate, fade-in), and applies a custom scrollbar style.

frontend/src/app · high confidence

The backend directory is now explicitly archived and unsupported for new installations or production use. Documentation files (README, API docs, scripts) clarify that the current supported application is a self-contained Tauri desktop app where the Next.js UI communicates with the Rust core via Tauri commands and events, handling local transcription, meeting storage, and summaries. The old unauthenticated FastAPI API and its CORS behavior are no longer supported and must not be used as a basis for new deployments. Dockerfiles for the app and Whisper server (CPU, GPU, macOS) and build scripts remain in the archive for historical reference and migration context only.

backend · high confidence

The local database schema has been updated to support new application capabilities and provider integrations. Key changes include adding a \meeting\_notes\ table for user notes, introducing audio synchronization fields (\audio\_start\_time\, \audio\_end\_time\, \duration\) and a \speaker\ field to transcripts for improved playback and identification, and adding a \folder\_path\ to meetings for file organization. Provider support has been expanded with new API key columns for OpenRouter, Ollama (including endpoint configuration), and Google Gemini in the settings table, as well as a \customOpenAIConfig\ column for Pro license custom configurations. The licensing system was also restructured to support RSA-based keys and per-license grace periods, while summary process tracking now includes backup columns to preserve results during regeneration failures.

frontend/src-tauri/migrations · high confidence

The AI Summary component now supports smarter block editing: pressing Enter splits a block at the cursor (passing remaining content to a new block), and Backspace at the start of a non-empty block merges its content with the previous block instead of deleting it. The view also introduces animated transitions for sections and blocks using Framer Motion, improved visual feedback with shadows and transitions on selection, and a new BlockNote-based view that safely converts markdown to blocks and preserves BlockNote JSON during saves.

frontend/src/components/AISummary · high confidence

The MainContent component now enforces strict width and overflow handling to prevent layout breaking. The root \<main\> element includes 'min-w-0' and 'overflow-hidden' to ensure it respects flex constraints, while the inner wrapper div now explicitly sets 'w-full', 'max-w-full', 'min-w-0', and 'overflow-hidden'. This prevents content from overflowing its container and ensures the sidebar collapse/expand transitions work correctly without causing horizontal scrollbars or layout shifts.

frontend/src/components/MainContent · high confidence

This release introduces several key improvements to the Tauri backend. On macOS, the app now explicitly requests microphone, screen recording, and system audio capture permissions via Info.plist and entitlements, ensuring compliance with modern OS security requirements. To improve reliability and startup speed, FFmpeg and ONNX Runtime binaries are now bundled at build-time rather than downloaded at runtime, with the build script also detecting GPU capabilities to guide performance tuning. Additionally, transcription latency is reduced by optimizing the logging system: hot-path debug logs are removed or batched, and a non-blocking async logger prevents I/O blocking in audio processing threads. The app version is updated to 0.4.1.

frontend/src-tauri · high confidence

The \frontend/src-tauri/src/audio/devices\ module has been restructured into a dedicated device management layer. This change introduces automatic detection of built-in input (microphone) and output (speaker) devices by filtering out Bluetooth and virtual audio devices, ensuring stable sample rates and higher audio quality. It also adds a \verify\_microphone\_access\ function that actively tests microphone permission status before recording starts, preventing silent failures on macOS where permissions might be denied but the stream creation succeeds. The module exposes a unified API for listing devices, triggering permission dialogs, and resolving platform-specific audio configurations.

frontend/src-tauri/src/audio/devices · high confidence

The application now uses a dedicated Rust repository layer in \frontend/src-tauri/src/database/repositories\ to manage SQLite data access. This change introduces structured persistence for meeting metadata and paginated transcript segments (supporting virtualization performance), configurable provider settings (including custom OpenAI and Ollama endpoints), and a robust summary generation lifecycle that backs up existing summaries before regeneration and restores them on failure or cancellation. It also adds transcript search capabilities and transcript chunk storage for AI processing.

frontend/src-tauri/src/database/repositories · high confidence

The application now uses dedicated platform modules to discover and configure audio devices, replacing previous generic or platform-agnostic logic. On Windows, it leverages the WASAPI host for robust input/output and loopback device detection with fallbacks to the default host. On macOS, it utilizes Core Audio via the default host while filtering out built-in speakers to improve system audio capture reliability. On Linux, it employs ALSA/PulseAudio to enumerate input devices and specifically identifies PulseAudio monitor sources to enable system audio recording. This change ensures that audio device selection and configuration are handled correctly according to each operating system's native capabilities.

frontend/src-tauri/src/audio/devices/platform · high confidence

The onboarding experience has been restructured into a simplified four-step wizard (Welcome, Setup Overview, Download Progress, Permissions) with a new shared UI library for progress and status indicators. The Download Progress step now supports background downloads for AI models, displaying real-time speed and progress, and allows retrying failed downloads. A dedicated Permissions step introduces explicit user actions to grant microphone and system audio access, with platform-specific logic (e.g., opening system settings on macOS if denied) and the ability to skip permissions for later configuration.

frontend/src/components/onboarding/steps · high confidence

The application's frontend interface has been restructured into three new, dedicated components within the \_components directory to improve organization and maintainability. The SettingsModal.tsx file consolidates all user configuration interfaces—including AI model selection, device settings, and language preferences—into a single modal system driven by context. StatusOverlays.tsx introduces a unified, non-intrusive notification layer that displays processing and saving states at the bottom of the screen, adapting to sidebar layout changes. TranscriptPanel.tsx now serves as the primary container for the transcript view, integrating virtualized rendering, permission warnings (with specific handling for Linux environments), and action buttons for copying and language selection. This change represents a significant architectural shift in how the UI is composed, moving from monolithic page structures to reusable, context-aware sub-components.

_frontend/src/app/\components · high confidence

The Settings page has been redesigned from a flat list of sections into a tabbed interface with five categories: General, Recordings, Transcription, Summary, and Beta. This change introduces specific sub-components for each category, including a new Summary model settings tab and a Beta features tab. Additionally, the Transcription tab now automatically loads and persists the user's selected transcript model configuration (provider, model, and API key) from the backend on page load, ensuring the UI reflects saved preferences.

frontend/src/app/settings · high confidence

The sidebar no longer displays static, hardcoded meeting entries; instead, it fetches the list of meetings from the backend API upon initialization and updates the navigation menu dynamically as the list changes. Additionally, a new transcript search capability has been introduced, allowing users to query meeting content via a search input in the sidebar, with results displayed in a dedicated list. The recording toggle logic has also been refined to handle navigation and state synchronization more robustly when initiating a recording from the sidebar.

frontend/src/components/Sidebar · high confidence

The local transcription engine has been refactored to support multiple providers through a unified \TranscriptionProvider\ trait, allowing the system to switch between Whisper and Parakeet engines. Parakeet is now the default provider when no configuration is present, and the new architecture ensures that transcripts are emitted regardless of confidence scores, preventing the loss of low-confidence text that occurred previously. This change introduces a modular engine structure (\engine.rs\, \provider.rs\) that standardizes how audio chunks are processed and validated before transcription.

frontend/src-tauri/src/audio/transcription · high confidence

On macOS, system audio recording now uses the Core Audio backend by default instead of ScreenCaptureKit. This change fixes a bug where system audio (such as YouTube playback) was captured twice, causing a noticeable echo in recordings. The new implementation uses a Core Audio aggregate device with a process tap to capture system output cleanly, while ScreenCaptureKit remains available as a fallback or selectable alternative.

frontend/src-tauri/src/audio/capture · high confidence

The build process now downloads and bundles FFmpeg and ONNX Runtime (v1.22.0) binaries at compile time to eliminate runtime download delays and improve reliability. FFmpeg binaries are fetched from Zackriya-Solutions GitHub releases for Windows, macOS (Intel/Apple Silicon), and Linux (x86\_64/ARM64), with caching and verification logic to skip re-downloads if the cached binary is valid. ONNX Runtime is bundled exclusively for Windows x64, downloading from Microsoft's official releases, verifying SHA-256 checksums, and extracting specific DLLs (onnxruntime.dll, onnxruntime\_providers\_shared.dll) into the binaries directory. Both modules include robust error handling, timeout configurations, and cleanup of temporary files.

frontend/src-tauri/build · high confidence

1 commit adding/updating tests in frontend/src-tauri/tests; Added test coverage for meeting details, summary generation, and transcription hooks.

This change updates dependencies across the project's build manifests. The Rust backend (frontend/src-tauri/Cargo.toml) upgrades Tauri to v2.6.2 and its plugins (fs, dialog, store, notification, updater, process) to v2.x, adds whisper-rs v0.13.2 with platform-specific GPU features (Metal, CoreML, CUDA, Vulkan, OpenBLAS), and updates ort, sqlx, and other crates. The frontend (frontend/package.json) migrates from Electron to Tauri, adding @tauri-apps packages, BlockNote, Radix UI, cmdk, and other UI libraries, while removing Electron dependencies. The Python backend (backend/requirements.txt) upgrades FastAPI, Uvicorn, Pydantic, and replaces openai-whisper with pydantic-ai and ollama.

(dependencies) · high confidence

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

• CAI 32 → 44 (+11.6)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 54 → 65 (+10.8)
• Architecture 94 → 97 (+3.5)
• Maturity 73 → 76 (+3.2)
• Readiness 10 → 30 (+19.7)
• Security 37 → 55 (+18.1)
• Domain Modelling 100 (new)
• Event-Driven 80 (new)
• Event Sourcing 100 (new)
• Accessibility 42 (new)

• Boundary-crossing change coupling: DownloadProgressStep.tsx ↔ OnboardingContext.tsx (frontend/src/components/onboarding/steps/DownloadProgressStep.tsx)
• Boundary-crossing change coupling: LanguagePickerPopover.tsx ↔ useImportAudio.ts (frontend/src/components/LanguagePickerPopover.tsx)
• Boundary-crossing change coupling: LanguagePickerPopover.tsx ↔ useSummaryGeneration.ts (frontend/src/components/LanguagePickerPopover.tsx)
• Boundary-crossing change coupling: OnboardingFlow.tsx ↔ OnboardingContext.tsx (frontend/src/components/onboarding/OnboardingFlow.tsx)
• Boundary-crossing change coupling: RetranscribeDialog.tsx ↔ useImportAudio.ts (frontend/src/components/MeetingDetails/RetranscribeDialog.tsx)
• Boundary-crossing change coupling: SummaryPanel.tsx ↔ useRecordingStop.ts (frontend/src/components/MeetingDetails/SummaryPanel.tsx)
• Boundary-crossing change coupling: TranscriptButtonGroup.tsx ↔ useImportAudio.ts (frontend/src/components/MeetingDetails/TranscriptButtonGroup.tsx)
• Boundary-crossing change coupling: page-content.tsx ↔ LanguageSelection.tsx (frontend/src/app/meeting-details/page-content.tsx)
• Boundary-crossing change coupling: page-content.tsx ↔ TranscriptButtonGroup.tsx (frontend/src/app/meeting-details/page-content.tsx)
• Critical CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (backend/app/db.py)
• Duplicated block (10 lines × 4) (backend/app/schema_validator.py)
• Duplicated block (14 lines × 2) (backend/app/db.py)
• High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (backend/requirements.txt)
• High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (backend/requirements.txt)
• …and 119 more

• Ambiguous and overlapping lifecycle management methods. It is unclear what the semantic difference is between stopping streams vs stopping recording vs cleaning up without saving. 'stop_streams_and_force_flush' implies a specific side effect not present in 'stop_recording', but both likely terminate the recording session.
• AnalyticsConsentSwitch.AnalyticsConsentSwitch (cognitive 20) (frontend/src/components/AnalyticsConsentSwitch.tsx)
• AnalyticsConsentSwitch.AnalyticsConsentSwitch (cyclomatic 17) (frontend/src/components/AnalyticsConsentSwitch.tsx)
• AudioCapture::new (cognitive 28) (frontend/src-tauri/src/audio/pipeline.rs)
• AudioCapture::new (cyclomatic 16) (frontend/src-tauri/src/audio/pipeline.rs)
• AudioCapture::process_audio_data (cognitive 105) (frontend/src-tauri/src/audio/pipeline.rs)
• AudioCapture::process_audio_data (cyclomatic 36) (frontend/src-tauri/src/audio/pipeline.rs)
• AudioDeviceMonitor::monitor_loop (cognitive 46) (frontend/src-tauri/src/audio/device_monitor.rs)
• AudioDeviceMonitor::monitor_loop (cyclomatic 17) (frontend/src-tauri/src/audio/device_monitor.rs)
• AudioLevelMonitor::find_device_by_name (cognitive 20) (frontend/src-tauri/src/audio/level_monitor.rs)
• AudioMixer::mix (cognitive 34) (frontend/src-tauri/src/audio_v2/mixer.rs)
• AudioPipeline::run (cognitive 53) (frontend/src-tauri/src/audio/pipeline.rs)
• AudioStream::from_device (cognitive 70) (frontend/src-tauri/src/audio/core-old.rs)
• AudioStream::from_device (cyclomatic 37) (frontend/src-tauri/src/audio/core-old.rs)
• Block.BlockComponent (cognitive 74) (frontend/src/components/AISummary/Block.tsx)
• Block.BlockComponent (cyclomatic 54) (frontend/src/components/AISummary/Block.tsx)
• BlockNoteSummaryView.BlockNoteSummaryView (cognitive 35) (frontend/src/components/AISummary/BlockNoteSummaryView.tsx)
• BlockNoteSummaryView.BlockNoteSummaryView (cyclomatic 32) (frontend/src/components/AISummary/BlockNoteSummaryView.tsx)
• BuiltInModelManager.BuiltInModelManager (cognitive 37) (frontend/src/components/BuiltInModelManager.tsx)
• BuiltInModelManager.BuiltInModelManager (cyclomatic 53) (frontend/src/components/BuiltInModelManager.tsx)
• …and 725 more

• 96 commits — 19 feature/other, 77 fixes

• frontend/src — 36 commits
• frontend/src-tauri — 32 commits
• (repo) — 22 commits
• .github/workflows — 3 commits
• (root) — 2 commits
• frontend/tests — 1 commit

• fix: Merge pull request #603 from ShiroKSH/fix/summary-chunk-coverage
• fix: Merge pull request #608 from iphixit/fix/heaac-import-half-duration
• fix: Merge pull request #639 from tianrking/agent/fix-provider-aware-recording-readiness
• fix: Merge pull request #665 from aliCamargo/fix/issue-592-summary-layout-ollama
• fix: Merge pull request #679 from Hus-Mek/fix/vad-fragmentation-and-hallucination-filter
• fix: Merge pull request #682 from VictorMaxWang/fix/issue-662-preserve-model-downloads
• fix: Merge pull request #694 from davertor/fix/claude-thinking-block-parsing
• fix: Merge pull request #737 from Zackriya-Solutions/fix/followup-608-639
• fix: Merge pull request #748 from Zackriya-Solutions/fix/450-bt-mic-cold-start
• fix: Merge pull request #767 from Zackriya-Solutions/fix/avx2-crash
• fix: Merge pull request #779 from Zackriya-Solutions/fix/t12-audio-permission-detection
• fix: Merge pull request #784 from Zackriya-Solutions/fix/instrumentation
• fix: Merge pull request #794 from Zackriya-Solutions/hotfix/0.4.1-logo-fix
• fix: Merge pull request #795 from Zackriya-Solutions/fix/test-types-v0.4.1
• fix: Revert "fix(audio): wake Bluetooth output before microphone access check"
• fix: fix(audio): fall back to default mic when the selected device is unavailable
• fix: fix(audio): guard mic-disconnect fallback with session identity to stop it muting a later recording
• fix: fix(audio): make stop-tail flag panic-safe, session-gate fallback error branches, dedup start finalize
• fix: fix(audio): preserve system audio recording without a microphone
• fix: fix(audio): re-arm mic-disconnect detection after a failed hot-swap
• …and 76 more

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

Zackriya-Solutions/meetily 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.