moeru-ai/airi

This system is a multi-platform AI assistant framework that provides desktop, mobile, and web interfaces for interacting with large language models. It features real-time voice input with speech-to-text and voice activity detection, alongside a rich chat interface that supports streaming responses and dynamic component rendering. The platform also includes a desktop overlay mode for native computer use, allowing the AI to control local applications, and supports 3D avatar rendering via Live2D and VRM models.

111 changes.

The project underwent a major architectural overhaul, establishing a robust monorepo structure with dedicated server runtime, SDK, and shared packages while migrating deployment to Cloudflare Workers. This period saw the introduction of new client applications, including the Stage Pocket mobile app and an expanded Stage Tamagotchi desktop client with native capabilities, alongside the removal of legacy components and state management logic.

96 changes.

This period focused on expanding the AIRI platform through the introduction of a robust plugin SDK, new bot integrations, and mobile support for Android. Significant work was done to enhance the core application with advanced rendering capabilities, including Godot sidecar integration, Live2D procedural motion, and comprehensive model support. The infrastructure was also strengthened with dedicated authentication services, unified IPC contracts, and improved developer tooling.

The \services/computer-use-mcp\ package now includes comprehensive documentation (AGENTS.md, FEASIBILITY.md, README.md, airi-cli-architecture.md, mimic-baseline-training-boundary.md, planning-orchestration-contract.md, coding-plast-mem-bridge-contract.md) defining its role as AIRI's macOS desktop orchestration layer, its policy boundaries, and its integration contracts. Additionally, a read-only Chrome extension (background.js, content.js, msg\_bridge.js, manifest.json) has been added to provide DOM observation capabilities for the desktop grounding layer, stripping all DOM-mutating actions to rely on macOS OS-level input events instead. Test fixtures (fake-runner.mjs, interactive-echo.mjs, text-target.html) are also included to support deterministic testing of the service's execution and observation paths.

services · high confidence

The Stage Tamagotchi Electron app introduces a desktop computer-use capability that allows the AI to interact with local native applications via the AUV SDK, with a UI toggle to enable or disable this access per request. It also adds Apple Speech transcription on macOS for voice input. To support these features, the app includes a new Electron build configuration, a Flatpak manifest for Linux distribution, and a desktop entry file.

apps/stage-tamagotchi · high confidence

The API server application has been reorganized into its own independent workspace, complete with its own Dockerfile, Drizzle ORM configuration, and a comprehensive set of database migrations. This change introduces a new payment architecture that replaces the previous Stripe-specific tables (checkout sessions, invoices, subscriptions, customers) with a generic \payment\_order\ and \payment\_customer\ system, enabling support for multiple payment processors including a new Apple IAP channel. The database schema also adds support for LLM request tracking via a new \llm\_request\_attempt\ table, introduces user ban and session management fields, and adds optional S3 object storage capabilities for private file uploads.

server/apps/api · high confidence

The plugin now includes a new CLI executable (\src/run.ts\ / \src/cli.ts\) that listens for Claude Code hook events via stdin. When a \UserPromptSubmit\ event is received, the CLI parses the JSON input and forwards the user's prompt text to the AIRI Channel Server. This enables the plugin to integrate with Claude Code's hook system by acting as a bridge that pipes hook data into the AIRI infrastructure.

plugins/airi-plugin-claude-code · high confidence

A new \font-chillroundm\ package has been added, providing the 'ChillRoundM' typeface. The package includes the font files (TTF and OTF), a CSS definition with \font-display: swap\, and an entry point that imports the styles. It is licensed under the SIL Open Font License (Version 1.1) and is built using \tsdown\ to bundle the CSS and copy font assets to the distribution directory.

packages/font-chillroundm, packages/font-cjkfonts-allseto · high confidence

The \engines/stage-tamagotchi-godot\ directory now includes the V-Sekai MToon shader addon (version 3.4.0) and the VRM 1.0 GLTF document extensions. This enables the Godot sidecar to render avatars with toon shading and import VRM 1.0 models at runtime, including support for HDR emissive multipliers and MToon material properties via the \VRMC\_materials\_mtoon\ and \VRMC\_materials\_hdr\_emissiveMultiplier\ extensions.

engines · high confidence

Introduces the \@proj-airi/stage-ui-mmd\ package, enabling the stage to render PMX/PMD models with VMD/VPD motion support. This new renderer provides physics-driven secondary motion (hair, skirts), IK, and append-bone propagation via Ammo.js, alongside morph-based lip-sync, emotion expressions, and gaze tracking. It integrates with the existing stage contract, allowing users to load MMD models from ZIP packages or URLs and configure settings like physics gravity, IK, and gaze modes through the model settings panel.

packages/stage-ui-mmd · high confidence

The application now includes a dedicated callback page for handling OpenID Connect (OIDC) authentication flows. This page processes the authorization code and state from the URL, exchanges them for tokens via the backend, applies the OIDC tokens to the session, and redirects the user to the home page upon success. It also handles various error states (provider errors, missing parameters, token exchange failures) by displaying user-friendly error messages and offering a 'Try Again' button to restart the sign-in process.

apps/stage-web/src/pages/auth · high confidence

Users can now connect to a server channel by scanning a QR code. This change introduces a new connection settings page that includes a QR scanner component, utilizing the Capacitor barcode scanner to read QR payloads, validate them, and automatically configure the WebSocket connection details upon success.

apps/stage-pocket/src/pages/settings/connection · high confidence

Introduces a new Spotlight window manager that provides a floating, always-on-top search interface accessible via a configurable global keyboard shortcut (defaulting to Ctrl+Shift+A). The window is positioned near the cursor and supports hiding on blur. It integrates with the system notification center to display search results, allowing users to click notifications to open the main chat window, while enforcing strict IPC security to ensure only the Spotlight window can trigger specific hide and notification actions.

apps/stage-tamagotchi/src/main/windows/spotlight · high confidence

Introduces a new floating caption overlay window that can follow the main application window. The implementation includes logic to compute initial bounds based on display resolution breakpoints, persist relative positioning offsets per display configuration, and handle window visibility and always-on-top settings across platforms.

apps/stage-tamagotchi/src/main/windows/caption · high confidence

Introduces a new transparent, always-on-top overlay window that displays a ghost pointer, target bounding box, and confidence badges to provide visual grounding for desktop interactions. The overlay is gated by the AIRI\_DESKTOP\_OVERLAY environment variable, is click-through to avoid intercepting user input, and polls the MCP bridge for state updates.

apps/stage-tamagotchi/src/main/windows/desktop-overlay · high confidence

The devtools panel now includes a new Live2D ambient light section with controls to enable the feature, select the source (screen capture or forced color), choose the mode (window gradient or global), and adjust strength, squint, and shader parameters like dark base, base curve, and wrap intensity. A dedicated diagnostics tab provides real-time metrics on capture and sampling, a preview of the pixel frame with excluded regions, and visualizations of the target and applied light maps. Additionally, a new resource events table displays recent VRM model lifecycle events, including timestamps, phases, reasons, and memory usage, to aid in performance debugging.

apps/stage-tamagotchi/src/renderer/components/devtools · high confidence

This change introduces three new packages to handle game controller input. The \@proj-airi/input-gamepad\ package provides a framework-agnostic \StandardGamepadMonitor\ that polls the browser Gamepad API, normalizes W3C standard mapping inputs (buttons, sticks, triggers), and detects controller families (Xbox, PlayStation, Nintendo) for appropriate button labels. The \@proj-airi/input-gamepad-vueuse\ package exposes a \useStandardGamepad\ Vue composable that wraps the monitor, providing reactive state for buttons, sticks, and values, along with lifecycle management tied to Vue scopes. The \@proj-airi/input-playstation-dualsense-5\ package adds support for Sony DualSense controllers via WebHID, enabling raw input parsing for advanced features like motion sensors, touchpad, adaptive triggers, and rumble, as well as output control for lightbars and haptics.

packages/input-gamepad, packages/input-gamepad-vueuse, packages/input-playstation-dualsense-5 · high confidence

The onboarding flow now includes a dedicated permissions panel that displays the status of notification and microphone permissions. Users can view whether these permissions are granted or not, and request them directly from the interface. If a permission is denied, the app provides a button to open the device's system settings to allow the user to grant access manually. This component integrates with native platforms (Android/iOS) via Capacitor for accurate permission checking and settings navigation, while falling back to web-based permission queries on non-native platforms.

apps/stage-pocket/src/components/permissions · high confidence

Users now encounter a dedicated onboarding step to review and manage application permissions. This new UI component presents a description of the permissions, a panel for detailed permission settings, and navigation controls to proceed or go back within the onboarding flow.

apps/stage-pocket/src/components/onboarding · high confidence

The weather plugin now includes a new \Weather\ component that displays city, temperature, and condition data. It features a loading state with pulse and wave skeleton animations and renders a clear-day icon alongside the data in a styled grid layout. The component is registered via \defineCallingComponent\ with a Valibot schema for city, temperature, and condition, and is exported for use within the component-calling framework.

apps/component-calling/src/plugins/plugin-component-calling-weather · high confidence

A new DualEndRange Vue component has been introduced in the DataGui module, providing a custom range slider that supports multiple draggable thumbs. Users can now interact with a range control that clamps values within specified min/max bounds, respects step increments, and emits updates as thumbs are dragged, replacing any previous implementation or enabling new multi-thumb range selection capabilities in the stage-web application.

apps/stage-pocket/src/components/DataGui, apps/stage-web/src/components/DataGui · high confidence

The notice window now includes a new 'Fade on Hover' tutorial page that displays a video guide and explanation of the feature, allowing users to dismiss it permanently via a 'Don't show again' option.

apps/stage-tamagotchi/src/renderer/pages/notice · high confidence

The application now includes a new service for managing Model Context Protocol (MCP) servers via stdio transport. This change introduces a manager that handles server lifecycle operations (start, stop, restart), configuration file management (read, write, open), and tool invocation. A key behavioral addition is the inclusion of stderr output in test results when a server connection fails, allowing users to see diagnostic messages (such as missing environment variables) directly in the test outcome. This is supported by new unit tests verifying that connection errors and their associated stderr logs are correctly captured and reported.

apps/stage-tamagotchi/src/main/services/airi/mcp-servers · high confidence

A new Map widget has been introduced in the stage-tamagotchi renderer to visualize transit routes. This component displays a stylized map surface with an SVG-based route path, origin/destination markers, and stop points, alongside metadata such as ETA, mode, and status. It supports loading states with skeleton placeholders and allows customization via props for accent colors, labels, and route data, serving as a visual demo element for the application.

apps/stage-tamagotchi/src/renderer/widgets/map · high confidence

The Tamagotchi renderer now includes dedicated CSS files to manage its visual presentation. A new main stylesheet establishes the layout, applies dark mode support via CSS variables, and styles the NProgress loading bar with a specific pink accent color. Additionally, a transitions stylesheet defines slide-away animations for UI elements, allowing components to fade and shift vertically when entering or leaving the view.

apps/stage-tamagotchi/src/renderer/styles · high confidence

A new dashboard page component has been added to the renderer, providing the foundational structure for the dashboard view within the application.

apps/stage-tamagotchi/src/renderer/pages/dashboard · high confidence

A new \scripts/list-module-loc.mjs\ utility has been added to calculate lines of code per package by scanning \package.json\ files across the monorepo and running \scc\ on resolved source directories. Additionally, tests and configuration for the SponsorKit OpenCollective integration have been added, verifying that GraphQL requests correctly use the \Personal-Token\ header instead of the deprecated \Api-Key\ header.

scripts · high confidence

The bootkit library now provides a lifecycle management system that allows components to register cleanup hooks for application quit and window-close events. Users can subscribe to \onAppBeforeQuit\ and \onAppWindowAllClosed\ events, receiving a function to unregister their specific hook. This ensures that resources tied to specific windows or features are properly cleaned up when the application shuts down or windows are closed, preventing memory leaks and ensuring graceful shutdown behavior.

apps/stage-tamagotchi/src/main/libs/bootkit · high confidence

The application now includes a local loopback HTTP server to handle Electron OIDC authentication callbacks and serve plugin static assets securely. For authentication, the server listens on 127.0.0.1, validates the OIDC state to prevent forgery, and supports standard CORS for web relays. For plugin assets, it serves files from extension roots under a session-scoped path (\/\_airi/extensions/...\) using cookie-based authentication, enforcing strict path normalization to prevent directory traversal and symlink escapes, and applying security headers like \no-store\ and \nosniff\.

apps/stage-tamagotchi/src/main/services/airi/http-server · high confidence

The status island now displays a connection indicator that shows whether the WebSocket is connected or disconnected. When disconnected, the icon applies a flicker animation to visually signal the state. Clicking the indicator opens the connection settings page, and the tooltip provides context about the current status and the action to open settings.

apps/stage-tamagotchi/src/renderer/components/stage-islands/status-island · high confidence

Users can now control the Minecraft bot from desktop Stage runtimes through a new AIRI integration. The \AiriBridge\ routes high-level \spark:command\ events directly to the Minecraft decision loop (bypassing chat history) and drops them if the bot is offline, while the \MinecraftContextService\ publishes the bot's status and relay instructions to Stage instances. This enables desktop agents to invoke the \builtIn\_emitSparkCommand\ tool to instruct the bot, with the system automatically managing command availability based on the bot's online state.

integrations/minecraft · high confidence

This change introduces two new bridge modules in the renderer. The electron-auth-callback bridge registers persistent listeners to handle OIDC token exchange via the auth store, ensuring sign-in state is correctly synchronized across Electron windows and preventing race conditions with VueUse storage. The stage-three-runtime-trace bridge sets up a BroadcastChannel-based relay to forward VRM and Three.js runtime trace events (such as load, dispose, and frame updates) between renderer instances, enabling remote debugging and performance monitoring of 3D assets.

apps/stage-tamagotchi/src/renderer/bridges · high confidence

The Model Settings page now includes an experimental toggle to switch the stage renderer to a Godot-based sidecar. This change introduces a new settings model that validates display models (restricting input to VRM format), manages a throttled queue for camera and view-state patches sent to the Godot process, and handles session lifecycle events (start/stop) via Electron IPC. Users can now select Godot as the stage renderer, which triggers the sidecar process and allows real-time view adjustments, with appropriate error handling and state synchronization for the experimental feature.

apps/stage-tamagotchi/src/renderer/pages/settings/models · high confidence

The extension-ui widget area now renders plugin-provided UIs inside sandboxed iframes instead of a static placeholder. The new ExtensionUiHost component resolves the iframe source from the plugin module's config (supporting both src and srcdoc), handles the init/ready handshake with the iframe, and relays typed messages between the host and the plugin. It also bridges plugin 'spark notify' commentary requests to the stage's character reaction system and queues iframe invoke requests with timeouts and deduplication, ensuring that plugin widgets can deliver fully customizable, interactive interfaces.

apps/stage-tamagotchi/src/renderer/widgets/extension-ui · high confidence

The stage-pocket application now includes an Android build target, allowing users to run the app on Android devices (API 26+). This change introduces the native Android project structure, including Gradle build scripts, configuration files, and platform-specific assets, enabling the app to be compiled and deployed as an Android application.

apps/stage-pocket/android · high confidence

This change introduces the Nix build infrastructure for the AIRI desktop application, creating a reproducible build environment using pnpm 11 and Electron 41. The package definition (nix/common.nix and nix/package.nix) builds the stage-tamagotchi frontend, packages it with Electron, and installs the application binary along with necessary assets (VRM, Live2D) and desktop integration files. It also includes helper scripts to automatically update dependency and asset hashes for the Nix store.

nix · high confidence

The iOS application project for Stage Pocket has been established, introducing the native Xcode project file that defines the build configuration and source structure. This setup includes the core application entry point (AppDelegate), the main user interface (Main.storyboard), and the web view container resources. It also integrates specific native capabilities such as a WebSocket bridge for host communication, a custom web authentication plugin, and support for the Liquid Glass app icon style, alongside the standard Capacitor configuration files.

apps/stage-pocket/ios/App/App.xcodeproj · high confidence

Added a new \memory-pgvector\ package that initializes a server SDK client named 'memory-pgvector'. The process sets up global logging configuration and registers a handler for the \module:configure\ event, while ensuring graceful shutdown via SIGINT/SIGTERM signals. This serves as the foundational entry point for the memory-pgvector service within the broader system.

packages/memory-pgvector · high confidence

Establishes the foundational configuration for the monorepo, including pnpm workspace definitions, ESLint rules, and tooling setups (EditorConfig, Git attributes, Crowdin, CSpell). Adds a comprehensive Agent Guide (AGENTS.md) defining development workflows and code standards, and introduces Nix flake support for reproducible development environments and packaging.

(repo-wide) · high confidence

The \apps/ui-server-auth/public\ directory now contains the foundational static assets for the new server-auth UI application. This includes a custom 404 page, a site favicon, and configuration files for the hosting environment: \\headers\ to disable caching for asset directories (\/assets/\\ and \/assets-v2/\*\), \\_redirects\ to handle SPA routing by proxying \/ui\ paths to the root index, and \.assetsignore\ to exclude build artifacts.

apps/ui-server-auth/public · high confidence

The \packages/server-sdk\ package is now available, providing a TypeScript client for connecting to AIRI server components over WebSocket. It handles the full connection lifecycle—including authentication, module announcement, and heartbeat management—and supports both SuperJSON and plain JSON message formats. The SDK exposes a \Client\ class with status tracking (\connectionStatus\, \isReady\), reliable sending (\send\, \sendOrThrow\), and event listening, along with a \WebSocketExtensionPeer\ helper for managing extension-level protocol interactions. Tests are included to verify connection flow, codec parsing, and peer announcement logic.

packages/server-sdk · high confidence

This change introduces the new 'Component Calling' application, providing a standalone Vue-based interface for component interaction. The app is configured with Vite and Vue Router for module bundling and navigation, while UnoCSS (including the Chromatic preset) handles styling. It also includes a Netlify deployment configuration that sets the Node.js runtime to version 24 and defines the build and publish paths for the associated stream components.

apps/component-calling · high confidence

A new plugin package for Bilibili Laplace has been added to the project. The initial commit includes the standard TypeScript configuration (tsconfig.json) and build setup (tsdown.config.ts) required to compile the module, along with a placeholder entry point (src/index.ts) that currently outputs a 'WIP' warning. This establishes the structural foundation for the feature, though the actual implementation logic is not yet present.

plugins/airi-plugin-bilibili-laplace · high confidence

Added the initial project structure for the Home Assistant plugin, including a TypeScript configuration, a build configuration using tsdown, and a placeholder entry point that currently outputs a 'WIP' warning. This establishes the foundational setup for the plugin, though the implementation is not yet complete.

plugins/airi-plugin-homeassistant · high confidence

The core-character package has been added to the repository, providing the foundational structure for a headless pipeline and character role-playing feature. This initial commit establishes the build configuration using tsdown for bundling and TypeScript declaration generation, along with a standard tsconfig targeting ESNext. The package currently exports an empty module, serving as a placeholder for future implementation.

packages/core-character · high confidence

The server authentication application now includes its foundational CSS styles. This adds a main stylesheet that imports the shared UI library, defines CSS variables for light and dark theme backgrounds, and applies global resets such as disabling double-tap zoom on touch devices. It also configures the NProgress loading bar to respect the current theme and hides it when the app is running in standalone mode. Additionally, dedicated transition stylesheets are provided to handle slide-away animations and Vue-specific fade/slide transitions for page navigation.

apps/ui-server-auth/src/styles · high confidence

The renderer's i18n module is now initialized using vue-i18n, resolving the active locale from local storage settings or falling back to the browser's language, with English as the final fallback.

apps/stage-tamagotchi/src/renderer/modules · high confidence

The Inlay page now exposes controls to adjust the window's visual appearance. Users can select a vibrancy effect (such as titlebar, selection, or acrylic) via a combobox, which immediately applies the change. Additionally, on Windows, a new 'Background Material' combobox appears, allowing users to choose effects like mica, acrylic, or tabbed. A close button has also been added to the window header for easier dismissal.

apps/stage-tamagotchi/src/renderer/pages/inlay · high confidence

The new \@proj-airi/ccc\ package provides the core primitives for handling the Character Card V3 (CCv3) specification. It includes a forward-compatible codec that validates CCv3 JSON envelopes while preserving unknown fields for future versions, and exports helpers to convert character cards into JSON, PNG, and APNG formats. This enables importing, validating, and exporting community Character Cards without silently discarding data that the application does not yet understand.

packages/ccc · high confidence

Added the new \@proj-airi/electron-eventa\ package, which provides a centralized set of shared Eventa contract definitions for Electron IPC across AIRI applications. This package standardizes communication by exposing typed invoke and event channels for core Electron modules, including app lifecycle (quit, platform checks), window management (bounds, vibrancy, background material, resize), screen interactions (cursor point, display info), system preferences (media access), and power monitor events (lock/unlock, suspend/resume). It also includes specific contracts for the auto-updater, defining states, progress, diagnostics, and update actions, ensuring consistent and type-safe IPC patterns for these features.

packages/electron-eventa · high confidence

A new \packages/electron-vueuse\ package has been added to provide VueUse-style composables and helpers for Electron applications. This library exposes renderer-side utilities for common Electron behaviors, including mouse tracking (\useElectronMouse\, \useElectronMouseInElement\, \useElectronMouseAroundWindowBorder\), window bounds and resize handling (\useElectronWindowBounds\, \useElectronWindowResize\), display information (\useElectronAllDisplays\), and auto-update management (\useElectronAutoUpdater\). It also introduces an Eventa-based context and invoke pattern (\useElectronEventaContext\, \useElectronEventaInvoke\) to standardize IPC communication. Additionally, the package provides main-process loop utilities (\useLoop\, \createRendererLoop\) that manage execution cycles with safety checks for renderer availability and window visibility.

packages/electron-vueuse · high confidence

The new \@proj-airi/pipelines-audio\ package provides shared orchestration for speech playback, text chunking, and transcript buffering, decoupling these concerns from application UIs. It introduces a streaming control system that parses and dispatches special tokens (ACT, DELAY, CALL) to manage LLM interactions, alongside a playback manager that handles voice queuing, priority-based stealing, and owner-specific limits. The package also includes a TTS chunker that optimizes audio boost timing by enforcing minimum word counts and handles narrative stripping for CJK and other languages.

packages/pipelines-audio · high confidence

The new \@proj-airi/server-shared\ package provides shared TypeScript type definitions and error-handling utilities for all server-side packages in Project AIRI. It exports WebSocket event types (including \input:text\, \input:text:voice\, and \input:voice\) and a structured error classification system that parses server messages into codes (e.g., \invalid-token\, \module-not-found\) with metadata on whether errors are authentication-related, recoverable, or terminal. The package is built using \tsdown\ and includes a README documenting usage scenarios for distributed agents like Minecraft and Discord.

packages/server-shared · high confidence

A new shared package has been added to provide runtime-neutral helpers and serializable contracts for AIRI stage applications. It introduces beat-sync detection logic that adapts to Web, Capacitor, and Tamagotchi (Electron) environments, and adds PKCE-based authentication utilities for secure login flows. The package also includes composables for versioned and manual-reset local storage to prevent state synchronization issues, global shortcut accelerator parsing, and environment-specific configuration checks for features like Flux purchases and custom providers.

packages/stage-shared · high confidence

The application now includes a dedicated AIRI Dashboard window. This new window persists its position and size settings across sessions, supports window dragging (with a Linux-specific workaround bypass), and exposes IPC handlers to open the Settings, Chat, and Notice windows from the dashboard interface.

apps/stage-tamagotchi/src/main/windows/dashboard · high confidence

The \packages/plugin-sdk\ package now provides the runtime-agnostic SDK for AIRI extensions, replacing the legacy plugin model. Extensions must now use an \extension.airi.json\ manifest (Manifest v2) and define their entrypoint via \defineExtension()\. The SDK introduces scoped Eventa channels (\createExtensionChannelScope\, \createModuleChannelScope\) to isolate traffic per extension and module, and a Kit API (\ctx.kits.use\, \defineKit\) that allows extensions to consume host-provided capabilities with strict version and permission checks. The package also includes a strict manifest schema that rejects invalid versions, unsafe IDs, and legacy formats, along with design documentation for the capability orchestration and multi-transport architecture.

packages/plugin-sdk · high confidence

A new browser extension plugin has been added to capture and send web context (page titles, video metadata, and subtitles) from YouTube and Bilibili to the AIRI server. The extension includes a content script to detect site-specific context, a background service to manage WebSocket connections and settings, and a Vue-based popup UI for configuring connection details, toggling capture features, and viewing live status.

plugins/airi-plugin-web-extension · high confidence

A new 'Component Calling' application has been added to the workspace, providing a chat interface that demonstrates AI-driven component invocation. The app features a dark mode toggle powered by the shared UI theme system and supports streaming responses from LLMs. It includes a custom XML parser to interpret component calls and props from the model's output, allowing the UI to render dynamic widgets (such as a weather component) based on the conversation. The entry point uses Vue Router with hash history, and the main page integrates with the xsai library for text streaming.

apps/component-calling/src · high confidence

The application now includes a new Inlay window, implemented as a reusable Electron BrowserWindow instance that dynamically adjusts its size and position based on the user's display resolution and breakpoints. This window is configured with specific security and UI settings, including disabled macOS window buttons and privileged navigation protection. It establishes communication with the main process via IPC, setting up RPC handlers to interact with the server channel and internationalization services, ensuring the window is ready to display content from the renderer process.

apps/stage-tamagotchi/src/main/windows/inlay · high confidence

Adds a new experimental single-person motion-capture pipeline to the \model-driver-mediapipe\ package, enabling stage-web to drive VRM avatars using MediaPipe Tasks Vision. The package provides a backend adapter for pose, hand, and face landmark detection, a scheduler with per-task frame-rate control and dropped-frame handling, and utilities to map MediaPipe landmarks to VRM bone orientations. A debug canvas overlay visualizes the detected landmarks, and a build script downloads the required MediaPipe model assets with retry logic. This feature is accessible via the stage-web devtools page and the Settings → System → Developer “MediaPipe Workshop” menu entry.

packages/model-driver-mediapipe · high confidence

Added a new Notice window (1020x600) to the application, managed by a dedicated window manager in the main process. This window is used to display confirmation dialogs to the user, handling the 'confirm' action and safely closing the window upon interaction. The implementation includes proper navigation protection and integration with the i18n and server channel services.

apps/stage-tamagotchi/src/main/windows/notice · high confidence

The \packages/stage-ui/src/libs/pinia\ module now provides a \setupSynced\ helper that installs a Pinia plugin and Vue plugin to synchronize store state across multiple renderer processes using the \pinia-plugin-synced\ library, including a configurable leadership policy and a 5-minute call timeout. Additionally, a new \pinia-plugin-tracing\ development tool is introduced to monitor Pinia action and mutation rates in the browser console, emitting lifecycle events via a BroadcastChannel while ensuring that sensitive action arguments and results are never recorded.

packages/stage-ui/src/libs/pinia · high confidence

Adds the \@proj-airi/stage-ui-spine\ package, enabling the stage to render and control Spine 2D animated models. This includes Vue components (\SpineScene\, \SpineCanvas\, \SpineModel\) for rendering, a Pinia store for managing animation state and view controls, and LLM-callable tools for playing animations and switching skins. The package supports Spine versions 4.0, 4.1, and 4.2, and requires a valid Spine Editor license for development.

packages/stage-ui-spine · high confidence

Stage Pocket is a new application entry point that serves as a native-capable shell for the AIRI experience, built on Capacitor to support both iOS and Android targets. It provides a host-backed WebSocket bridge to enable native socket I/O for the server SDK while keeping the web page on secure origins, and includes specific UnoCSS utilities (pt-safe, pb-safe, etc.) to respect safe-area insets on mobile devices. The app is configured with its own Vite build pipeline, TypeScript settings, and Gradle wrapper for Android, allowing developers to run the web interface with native device capabilities.

apps/stage-pocket · high confidence

This change adds the \@proj-airi/stage-pocket\ package, a new mobile application built with Capacitor that enables QR code scanning to connect to the AIRI desktop client, along with the \@proj-airi/component-calling\ demo app for realtime audio interactions. The Stage Pocket entry point includes the full suite of shared UI, audio, and inference dependencies, while the Android and iOS native project files (Gradle, Swift Package Manager) are initialized to support the mobile runtime.

(dependencies) · high confidence

The \@proj-airi/stage-ui-tachie\ package is now available, providing a renderer for characters represented by a small set of complete, static emotion images. It loads \.tachie.zip\ archives (containing images like \neutral.png\, \happy.webp\, etc.) and renders them using PixiJS on a transparent, responsive canvas. The component supports AIRI's shared emotion vocabulary, allowing users to switch between states like happy, sad, or angry. It includes features such as theme-colored shadows, configurable render scales, and canvas capture for stage screenshots. This renderer is designed for low-asset characters and is distinct from layered or rigged animation systems like Live2D or Spine.

packages/stage-ui-tachie · high confidence

The stage-pocket app now includes core audio handling features. Users can select specific audio input devices and start/stop media streams via the new \useAudioInput\ composable. Audio recording is supported through \useAudioRecord\, which captures media and plays it back upon stopping. Additionally, a Voice Activity Detection (VAD) system has been added, utilizing a Silero VAD model (loaded via \@huggingface/transformers\) and an AudioWorklet processor to detect speech boundaries in real-time, exposing events for speech start and status updates.

apps/stage-pocket/src/composables, apps/stage-pocket/src/workers · high confidence

The new @proj-airi/cap-vite package provides a CLI that launches a Vite dev server and automatically runs \cap run\ for the specified platform (iOS or Android) in a single terminal session. It intelligently resolves the target device by checking platform-specific environment variables (CAPACITOR\_DEVICE\_ID\_IOS/ANDROID) or falling back to the first available device from \cap run --list\. The tool injects a Vite plugin to handle native file changes, automatically restarting the native app when source files in the platform directory are modified, and allows manual restarts by pressing 'R'. It also supports forwarding arguments to both Vite and Capacitor via a double-dash separator and configures the Capacitor server URL automatically.

packages/cap-vite · high confidence

The chat-sync library now supports mirroring local chat sessions to the cloud and syncing messages in real time. A new REST-based cloud mapper handles session reconciliation (claiming, creating, and adopting chats) and enforces schema validation on API responses. The WebSocket client has been upgraded to version 2, moving authentication to a post-connection step to prevent premature state exposure, and introduces robust reconnection logic with exponential backoff and specific handling for unauthorized closures. Message synchronization logic ensures that only user and completed assistant turns are synced, while tool calls and system prompts remain local, and incoming messages are merged into the local store with proper deduplication and ordering.

packages/stage-ui/src/libs/chat-sync · high confidence

A new standalone Vue/Vite application (\apps/ui-server-auth\) has been added to handle user-facing authentication flows for the hosted AIRI server, including sign-in, email verification, password reset, profile management, and Electron OIDC callback relaying. This UI is deployed separately to Cloudflare Pages at \accounts.airi.build\ and communicates with the server's \/api/auth/\*\ endpoints. The implementation includes specific configuration to prevent browser cache poisoning by serving static assets under a distinct \/assets-v2/\ namespace, integrates OpenPanel for analytics tracking, and provides a dedicated Electron callback parser to relay OIDC tokens from the browser back to the desktop application.

apps/ui-server-auth · high confidence

The \stage-ui-three\ package is introduced to host the shared Three.js scene root, VRM model lifecycle management, and camera controls for stage surfaces. It provides the \ThreeScene\ component, a Pinia model store, and explicit VRM loading and disposal logic to prevent memory leaks and ensure deterministic model switching. The package also includes an \OrbitControls\ component for camera interaction, an \Environment\ component for HDRI skybox and IBL lighting, and a local \trace\ submodule for runtime diagnostics.

packages/stage-ui-three · high confidence

Adds a new standalone Vue application for server-side authentication flows, bootstrapped via main.ts with Pinia, Vue Router, i18n, and OpenPanel analytics. The app root (App.vue) manages global language and theme settings and renders toast notifications, while routing is configured to support both standard and hash-based histories depending on the deployment target. A test suite validates Cloudflare Pages routing behavior, ensuring proper 404 handling for static assets and correct cache-control headers for asset revalidation.

apps/ui-server-auth/src · high confidence

The \apps/ui-server-auth/src/pages\ directory now contains a complete set of new Vue components for the server-auth application, replacing previous placeholder or undefined states. Users will now see fully implemented pages for signing in (with email and social provider flows), managing their profile (including name updates, password changes, and linked account management), and account deletion. The UI also includes dedicated screens for password reset, email verification (utilizing cross-tab signaling for smoother OIDC handoffs), and an Electron OAuth callback handler. A new \auth-notice\ component provides consistent status feedback across these flows, and a catch-all \\[...all\].vue\ page handles 404s with navigation back to sign-in.

apps/ui-server-auth/src/pages · high confidence

This change adds a new \electron-screen-capture\ package that provides utilities for screen capture within the Electron application. It introduces IPC-based APIs for getting available display sources, setting and resetting capture sources with mutex locking, and checking or requesting screen capture permissions specifically on macOS. The package includes main-process initialization logic to handle Electron's \desktopCapturer\ and feature flags (such as loopback audio support), a renderer-side setup function for invoking these capabilities, and a Vue composable (\useElectronScreenCapture\) to integrate screen capture flows into the UI. It also defines serializable types for desktop capturer sources to handle icons and thumbnails over IPC.

packages/electron-screen-capture · high confidence

Added a new service at \apps/stage-tamagotchi/src/main/services/airi/godot-stage\ that manages the lifecycle of an external Godot stage process. This implementation handles starting and stopping the Godot binary (using a pre-exported production binary or a local dev executable), bridges WebSocket communication for real-time status and view snapshots, and forwards scene input payloads (VRM models) to the stage. It exposes a manager interface for renderer windows to control the stage and subscribe to its state changes.

apps/stage-tamagotchi/src/main/services/airi/godot-stage · high confidence

The Android app now includes a native Kotlin implementation that bridges the Capacitor WebView to the host OS for critical capabilities. A new WebSocket bridge allows the web app to manage native WebSocket connections (connect, send, close) via a JavaScript interface, including support for local self-signed certificates used by development servers. Authentication is handled by opening the system browser for login flows, and microphone permissions are checked natively to support audio input device selection. These changes enable reliable real-time communication and media access on Android.

apps/stage-pocket/android/app · high confidence

A new shared package, @proj-airi/server-sdk-shared, has been added to define the contracts for the hosted chat WebSocket. It provides TypeScript schemas and validation utilities for chat operations, including sending and pulling messages, as well as handling post-connection authentication via the 'chat:authenticate' event. The package exposes types for wire messages and request/response payloads, supporting the v2 protocol structure where authentication occurs after the WebSocket connection is established.

server/packages/server-sdk-shared · high confidence

The new \@proj-airi/auth-shared\ package provides neutral authentication contracts shared between the resource API and the standalone auth service. It defines the PostgreSQL schema (including user, session, account, and OAuth tables) and the \AuthSession\ interface, ensuring that both processes use identical data structures for the authenticated principal and authorization policies like ban expiry handling without depending on each other's runtime.

server/packages/auth-shared · high confidence

A new, reusable AIRI Editor window has been added to the Tamagotchi application. This window operates independently from the main settings interface, launching at a dedicated /editor route with a minimal stage runtime and disabled synced leader mode. The implementation includes the main window manager logic and registers the necessary Electron IPC handlers to support future editor features.

apps/stage-tamagotchi/src/main/windows/editor · high confidence

Adds a new system tray menu that allows users to toggle the main window visibility, adjust its size (recommended, full height, half height, or full screen), and align it to specific positions (center, top-left, top-right, bottom-left, bottom-right) on the dominant display. The tray menu is localized via i18n and includes safeguards to prevent errors when the renderer is unavailable.

apps/stage-tamagotchi/src/main/tray · high confidence

The new \packages/audio\ package provides a centralized audio infrastructure for the application. It introduces an \AudioContext\ manager (\audio-context/index.ts\) that handles initialization, sample-rate management (defaulting to 48kHz), and the loading of Web Audio API worklets. This includes a \ResamplingAudioWorkletProcessor\ (\processor.worklet.ts\) that utilizes \@alexanderolsen/libsamplerate-js\ to resample audio streams in real-time, supporting configurable input/output sample rates and channel counts. Additionally, the package includes a WAV encoding module (\encoding/wav.ts\) with utilities to convert between Float32 and PCM16 formats and generate WAV files, accompanied by unit tests (\encoding/wav.test.ts\) to verify the correctness of these conversions.

packages/audio · high confidence

A new \unocss-preset-fonts\ package has been added to provide a UnoCSS preset that integrates three specific fonts: CJKFonts AllSeto, Departure Mono, and Xiaolai SC. The preset is configured to load these fonts without an external provider and includes preflight CSS imports for the corresponding local font packages (\@proj-airi/font-cjkfonts-allseto\, \@proj-airi/font-departure-mono\, and \@proj-airi/font-xiaolai\), ensuring they are available for styling within the application.

packages/unocss-preset-fonts · high confidence

The vision module in the stage-ui store now includes dedicated Pinia stores to manage vision capabilities. The new \useVisionOrchestratorStore\ coordinates frame capture and multimodal inference, ensuring stable context IDs for repeated updates from the same source and partitioning contexts by workload. The \useVisionProcessingStore\ handles the capture ticker, tracking metrics like tick counts, processing durations, and context update rates with configurable intervals. Additionally, the \useVisionStore\ centralizes vision settings, including active provider/model selection, Ollama thinking options, and chat integration toggles, with persistence and cross-window synchronization.

packages/stage-ui/src/stores/modules/vision · high confidence

A new \better-ws\ package provides runtime-agnostic WebSocket primitives for reliable realtime connections. It includes a client with automatic reconnect (exponential backoff) and a server with peer registry, broadcast, and named groups. The package ships with a CrossWS connector for browser and Node environments, allowing applications to build custom protocols on top of stable connection lifecycle management.

packages/stage-ui · high confidence

The channel-server module now supports configurable hostname, authentication tokens, and TLS certificates for secure WebSocket connections. Users can enable secure (WSS) connections via TLS configuration, and the server generates or accepts custom auth tokens to secure the channel. The server can bind to non-localhost addresses (e.g., 0.0.0.0) to allow external connections, with QR code generation providing reachable LAN addresses for device pairing.

apps/stage-tamagotchi/src/main/services/airi/channel-server · high confidence

The app now includes dedicated modules to handle platform-specific integrations: deep links are installed to route authentication callbacks via Capacitor, a new WebAuthentication plugin opens the system browser for login flows, and a WebSocket bridge connects the app to native Android hosts for reliable server communication. Additionally, microphone permission checks and server channel QR probing are now supported, while internationalization and PWA registration are standardized.

apps/stage-pocket/src/modules · high confidence

The application now uses a new reusable window manager in the main process that handles creating, caching, and closing Electron BrowserWindows. This logic ensures that if a window is closed while it is still initializing, the pending creation is discarded and a fresh window is created on the next request, preventing crashes or stale references. This infrastructure supports features like the floating chat window and settings page by providing a reliable way to manage window lifecycles.

apps/stage-tamagotchi/src/main/libs/electron/window-manager · high confidence

The \packages/server-runtime\ package now provides the core server runtime, including a CLI entry point (\bin/run.ts\) to start the H3-based WebSocket server. It enforces security by using constant-time comparison for authentication tokens and validates incoming WebSocket messages using SuperJSON (with a fallback to plain JSON). The runtime implements a consumer-based event delivery system that supports priority, sticky, and round-robin selection, along with a routing middleware that allows filtering peers via label selectors, glob patterns, and extension/instance identities.

packages/server-runtime · high confidence

The application now includes a dedicated onboarding window manager that handles the lifecycle and display of the initial 'Welcome to AIRI' setup experience. This component creates a resizable, 1000x650 window with specific styling (dark background, custom icon) and integrates authentication services and internationalization. It manages window visibility, handles safe closing via IPC events, and ensures the window is properly toggled and shown upon readiness, providing a structured entry point for new users.

apps/stage-tamagotchi/src/main/windows/onboarding · high confidence

The new Stage Pocket app provides a main stage interface that integrates voice input, VAD-based speech detection, and streaming transcription. Users can interact via voice, with the system automatically sending transcribed text to the chat using the currently selected provider, model, and configurable temperature/top\_p settings. The layout adapts to mobile and desktop, respects safe areas, and includes a WebSocket status indicator.

apps/stage-pocket/src/pages · high confidence

The server now includes a standalone Auth application (\server/apps/auth\) that handles authentication, identity, and session management. This service introduces native Google sign-in support via the \AUTH\_GOOGLE\_NATIVE\_CLIENT\_IDS\ environment variable, allowing Android Credential Manager and other native clients to authenticate using specific Google OAuth audiences. It also adds a new Steam OpenID 2.0 sign-in plugin, enabling users to link their Steam accounts. The service is containerized with a dedicated Dockerfile, includes OpenTelemetry instrumentation for observability, and manages its own database connection and email delivery via Resend.

server/apps/auth · high confidence

The Stage Web application is now available, providing a web-based interface for interacting with the AI assistant. This release introduces a new main page that supports voice input via both streaming transcription and Voice Activity Detection (VAD), allowing users to speak naturally to the model. It also includes a dedicated settings page for configuring the official chat provider, enabling users to select between different API protocols (such as Responses API and Chat Completions). Additionally, a fallback 404 page has been added to handle unknown routes gracefully.

apps/stage-web/src/pages · high confidence

The Live2D rendering logic has been reorganized into a new component hierarchy (Live2DScene, Live2DCanvas, Live2DModel) that integrates a screen ambient light filter for dynamic lighting effects and a new expression controller that properly scopes expressions to the currently loaded model. A dedicated diagnostic preview component has been added to visualize ambient light settings, and the rendering pipeline now includes a background scene layer that composites behind the model.

packages/stage-ui-live2d · high confidence

A new local test harness has been added to \apps/stage-tamagotchi/scripts/update-test\ to verify the AIRI updater workflow without relying on external servers. It includes a mock HTTP server (\start-server.ts\) and manifest generator (\generate-manifest.ts\) that create local fixtures for stable, beta, alpha, and nightly channels, along with orchestration scripts (\run-test.sh\, \run-matrix.sh\) to launch the app against these mocks. This allows developers to manually or automatically verify update discovery, download states, and channel switching (via \UPDATE\_SERVER\_URL\ and \AIRI\_UPDATE\_CHANNEL\) on the local machine.

apps/stage-tamagotchi/scripts/update-test · high confidence

The stage-web application has moved its hosting from Netlify to Cloudflare Workers, evidenced by the removal of the Netlify configuration and the addition of a Wrangler configuration file. A new Dockerfile has been introduced to support local and CI builds using Node.js 24 and Nginx for production serving. Additionally, a performance visualizer feature has been added, allowing users to view FPS history and export recordings to help identify animation performance issues.

apps/stage-web · high confidence

The iOS app now includes a native bridge that enables direct WebSocket communication with a local host (such as a Tamagotchi device) and supports system-level web authentication. This is implemented via new Swift components in the iOS project: a \DevBridgeViewController\ that configures the Capacitor WebView with a transparent background and gesture navigation, a \HostWebSocketBridge\ and \URLSessionHostWebSocketSession\ that manage WebSocket lifecycle and message passing between the web view and native code, and a \WebAuthenticationPlugin\ that leverages \ASWebAuthenticationSession\ for secure login flows. The \Info.plist\ has been updated with the necessary usage descriptions for camera, microphone, and local network access to support these features.

apps/stage-pocket/ios/App/App · high confidence

A new \@proj-airi/ui-loading-screens\ package has been introduced to provide visual feedback during application startup. It includes two distinct loading screen components: \LoadingLogoWithBar\, which displays a simple progress bar and status text, and \LoadingSciFiCircle\, a retro terminal-style loader featuring ASCII art, boot logs, and CRT effects. The Sci-Fi component supports a barrel distortion filter for a more immersive visual style and is available for preview in the package's playground.

packages/ui-loading-screens · high confidence

A new \@proj-airi/ui-transitions\ package has been added, providing a set of UI transition animations for fade-in and fade-out of scenes. The package includes several distinct transition components such as Arrow, Bubble Wave Out, Fantasy Fall, Multiple Blocks Reveal, and Rectangles Rotate, which can be configured with custom colors, durations, and directions. A dedicated playground application is included to demonstrate these transitions, featuring a dark mode toggle and navigation between different transition examples.

packages/ui-transitions · high confidence

A new Account Settings page has been added to the application, providing users with a dedicated interface to manage their account. This page integrates with the existing authentication store to handle login requests and includes a logout function that signs the user out and redirects them to the main settings view. The page is configured with specific metadata for layout, title, and icon display within the settings navigation.

apps/stage-web/src/pages/settings/account · high confidence

The provider catalog now includes Aliyun NLS for real-time streaming transcription (supporting multiple Chinese regions) and Apple Speech for native macOS transcription. The Aliyun provider handles WebSocket-based streaming with interim result corrections, while the Apple Speech provider integrates with the Electron desktop app to provide locale-aware transcription. Both providers are registered in the provider attributes system with appropriate pricing and deployment metadata.

packages/stage-ui/src/libs/providers · high confidence

This change introduces the backend service layer for the new Artistry image generation system and the core widget management service within the AIRI widgets module. The \artistry-bridge.ts\ file implements a provider-agnostic image generation engine that supports ComfyUI (local), Replicate (cloud), and Nano Banana (Google AI Studio), featuring request deduplication, job status polling, and configurable globals. Alongside this, \index.ts\ establishes the \createWidgetsService\ to handle Electron IPC invoke handlers for widget lifecycle operations (add, update, remove, open, hide) and iframe event routing, backed by strict payload validation in \validation.ts\ to ensure data integrity for widget properties and IDs.

apps/stage-tamagotchi/src/main/services/airi/widgets · high confidence

A new Artistry widget has been added to the stage-tamagotchi renderer, exposing the Comfy.vue component via index.ts. This widget provides a gallery interface for browsing generated images, setting them as character backgrounds, and displaying generation progress, integrating with the existing background and card stores.

apps/stage-tamagotchi/src/renderer/widgets/artistry · high confidence

A new Characters page has been added to the application settings, allowing users to view, search, create, edit, and delete their AI characters. The page features a list view with search filtering, a 'Create New' button to add characters, and a dialog for editing character details. It integrates with the character store to fetch and manage character data and tracks deletion events for analytics.

apps/stage-web/src/pages/settings/characters · high confidence

A new Data settings page has been added to the Tamagotchi app, providing a structured interface for managing application data. The page integrates several sub-sections: Chats (with a new feature to sync imported chat sessions via the chat session store), Desktop Folder management, Models/Modules, Desktop Reset, and a Danger section. A status banner component is used to display feedback for actions across these sections. The page is registered in the settings menu with a specific order and icon.

apps/stage-tamagotchi/src/renderer/pages/settings/data · high confidence

A new \font-departure-mono\ package has been introduced to the workspace, providing the Departure Mono typeface (v1.500) under the SIL Open Font License. This package bundles the font files, a CSS \@font-face\ definition for web usage, and a TypeScript entry point, configured to build using \tsdown\.

packages/font-departure-mono · high confidence

A new 'Developer' section has been added to the System settings page, providing a centralized hub for various debugging and testing utilities. This includes tools for audio recording, performance visualization, markdown stress testing, background theme blending, background removal (WebGPU), chat, gesture recognition, image processing, polaroid shots, context flow inspection, WebSocket traffic inspection, web haptics, plugin host debugging, magic keys, color extraction, Aliyun real-time transcription, VRM/TTS performance playground, and MediaPipe motion capture. The settings page also introduces a ripple grid interaction effect for navigating these options.

apps/stage-web/src/pages/settings/system · high confidence

This change introduces a new Discord bot adapter that enables voice chat capabilities, including joining voice channels, monitoring user speech, and transcribing audio via local Whisper or OpenAI models to send text responses. It also establishes the foundational architecture for the Minecraft integration, defining core bot management, a plugin runtime system, connection supervision for reconnection, and agent interfaces for actions, memory, and planning.

integrations/discord-bot, integrations/minecraft/src/libs/mineflayer, integrations/twitter-services · high confidence

The application now uses a new \src/main/index.ts\ entry point to initialize the Electron main process. This change establishes the core runtime environment by configuring logging via \@guiiai/logg\, setting up dependency injection with \injeca\, and initializing key services such as the built-in HTTP server, auto-updater, global shortcuts, and screen capture utilities. It also handles platform-specific configurations, including enabling WebGPU on Linux and supporting Wayland, while managing window lifecycles and single-instance guards.

apps/stage-tamagotchi/src/main · high confidence

The \apps/stage-tamagotchi/src/main/services/electron\ directory now contains a new set of main-process services that replace or supplement previous implementations. This includes an app service for opening the user data folder and quitting, a robust auto-updater that fetches release tags from the GitHub API and supports multiple update lanes (stable, beta, alpha, nightly) with platform-specific cache cleanup, and a global shortcut service that uses \uiohook-napi\ for key-up events (e.g., push-to-talk) while falling back to Electron's native shortcuts. Additionally, a media permission handler restricts audio capture and device access to local AIRI pages, and a system preferences service exposes platform detection. All these services are accompanied by extensive unit tests in \\*.test.ts\ files, verifying behaviors like updater channel selection, shortcut registration conflicts, and permission grant logic.

apps/stage-tamagotchi/src/main/services/electron · high confidence

This package introduces a dedicated Electron capture framework for generating documentation screenshots, built on top of the Vishot testing tool. It provides a structured API for automating interactions with the AIRI stage-tamagotchi application, including helpers for managing windows (main, settings, chat), controlling the UI island, navigating settings routes, and dismissing overlays. A key addition is a gesture primitive that supports swipe actions via both trusted Chromium CDP touch events and native wheel movements, ensuring reliable reproduction of touch-based UI interactions like swipe-to-reply in automated captures.

packages/scenarios-stage-tamagotchi-electron · high confidence

The Settings page now includes a dedicated module for configuring Model Context Protocol (MCP) servers. Users can manage server definitions through a structured form (specifying identifier, command, arguments, environment variables, and working directory) or via a raw JSON editor. The interface supports adding, removing, and editing multiple servers, validates configuration against the MCP schema, and allows users to test server connections to verify tool availability and diagnose errors.

apps/stage-tamagotchi/src/renderer/pages/settings/modules · high confidence

The \integrations/satori-bot\ module introduces a new bot adapter for the Satori protocol, enabling the system to connect to Satori-based messaging platforms via WebSocket. This integration features an LLM-driven action planner that dynamically decides between sending messages, reading unread events, or continuing loops based on conversation context and personality prompts. It includes a structured action registry (send, read, continue, break, sleep, list channels) with concurrency safety checks to prevent message collisions, and manages bot state through a persistent database for event queues and chat history.

integrations/satori-bot, integrations/telegram-bot · high confidence

The application now includes a dedicated Settings window, implemented via a new \SettingsWindowManager\ in the main process. This window is a reusable 600x800 pixel browser window that loads the \/settings\ route by default and supports navigation to other routes. It integrates with several existing services, including auto-updater, devtools, widgets, spotlight, global shortcuts, and various stage managers (Godot, MCP, server channel), while also initializing screen capture capabilities for the window.

apps/stage-tamagotchi/src/main/windows/settings · high confidence

The System settings section now includes dedicated pages for General configuration, Permissions management, and Developer tools. Users can access a new Developer menu offering quick links to various testing utilities (such as audio, chat, and WebSocket inspection) and toggle animation transitions. The Permissions page integrates a dedicated panel for managing app permissions, while the main System index provides navigation to these new sub-sections.

apps/stage-pocket/src/pages/settings/system · high confidence

The Tamagotchi devtools now include dedicated pages for testing and monitoring core subsystems. The Global Shortcut page allows registering, unregistering, and monitoring trigger events for global keyboard shortcuts. The Screen Capture page provides a UI to select and stream screen, window, or device sources. The Performance Visualizer page displays real-time diagnostics for the Stage Three runtime, including window lifecycle, Three.js render metrics, VRM update frame timings, and resource snapshots. Additional pages expose the Live2D ambient light controls, motion devtools, and the auto-updater diagnostics.

apps/stage-tamagotchi/src/renderer/pages/devtools · high confidence

This change introduces a new set of renderer components for the Tamagotchi application, including the main InteractiveArea for chat interactions, a ChatViewportLayout to manage the chat history and composer positioning, and an IconAnimation component for visual effects. It also adds ResizeHandler for window resizing, WindowRouterLink for navigation, and WithScreenCapture to handle macOS screen capture permissions. Additionally, browser tests are added for the InteractiveArea and ChatViewportLayout to ensure correct layout behavior and state synchronization.

apps/stage-tamagotchi/src/renderer/components · high confidence

The \@proj-airi/ui\ package introduces a new stylized UI component library built on Reka UI and UnoCSS. It provides a comprehensive set of form components, including \FieldInput\ (with native number modifier support), \FieldSelect\, \FieldComboboxSelect\, \FieldCheckbox\, \FieldRange\, and \FieldTextArea\, alongside primitive inputs like \Input\, \Checkbox\, and \Combobox\. The library also adds animation primitives such as \AnimatedContent\ for presence-based transitions and various transition components (\TransitionVertical\, \TransitionHorizontal\, \TransitionBidirectional\). Documentation is included in the package README.

packages/ui · high confidence

The \.agents\ directory now includes several new skill definitions that guide AI agents in specific workflows. The \agent-browser-electron\ skill provides instructions for inspecting and automating Electron apps via the Chrome DevTools Protocol, specifically addressing multi-window and lazy-loading scenarios. The \create-pr\ skill standardizes pull request creation with requirements for context evidence, visual diffs, and behavior diagrams. Additionally, new skills enforce project-specific standards: \enforce-rules-for-typescript\ for source code structure, \enforce-rules-for-unocss\ for styling, \enforce-rules-for-vitest\ for testing practices, and \enforce-rules-for-pinia-synced\ for cross-window state synchronization.

.agents · high confidence

Added AudioWaveform.vue, a new component that renders a real-time audio waveform on a canvas using the Web Audio API and adapts its colors to the current theme, and IconAnimation.vue, a new component that handles complex icon animations with configurable duration, direction, and completion callbacks.

apps/stage-web/src/components · high confidence

The renderer now ships three new built-in tools: a desktop computer-use tool that allows the agent to control native apps, inspect windows, and capture screenshots via IPC; an image-journal tool that generates images using the configured artistry providers (ComfyUI, Replicate, etc.) and manages them as background journal entries or overlay widgets; and a weather tool that fetches current conditions from the Open-Meteo API and displays them as an overlay widget. These additions expand the agent's capabilities beyond chat to include local system interaction, visual content creation, and real-time environmental data.

apps/stage-tamagotchi/src/renderer/stores/tools/builtin · high confidence

A new settings page has been added to the Tamagotchi app, dynamically listing all routes marked with a 'settingsEntry' meta property. The page displays these settings as a list of items with titles, descriptions, and icons, sorted by a defined order. It includes visual enhancements such as staggered entry animations for the list items and a background decorative icon, while also implementing custom page transition logic controlled by user settings.

apps/stage-tamagotchi/src/renderer/pages/settings · high confidence

The character settings page now includes dedicated Vue components for managing AI characters. Users can create new characters via a dedicated card interface, edit character details (including identity, LLM model, temperature, top\_p, and TTS settings) through a dialog with form validation, and view/manage existing characters using a list item component that displays version, model, and voice status. The implementation integrates with the character store for creation and updates, and tracks analytics events for character creation.

apps/stage-web/src/pages/settings/characters/components · high confidence

The application now includes four new composables in the \stage-web\ package to enhance user interaction and diagnostics. Users can now select specific audio input devices and record audio directly in the browser, with playback triggered upon stopping the recording. Page transitions and icon animations are now controllable via settings, respecting user preferences for disabling transitions. Additionally, a new performance lag sampler is available to monitor FPS, frame duration, long tasks, and memory usage, providing real-time performance metrics for debugging and optimization.

apps/stage-web/src/composables · high confidence

The application now persists specific user preferences via new configuration schemas. The Artistry module introduces settings for AI image generation providers (ComfyUI, Replicate, Nanobanana), allowing users to configure server URLs, API keys, default models, and aspect ratios. The Global app configuration adds support for saving the user's selected language, the keyboard shortcut for the Spotlight feature, and the software update channel (e.g., stable, beta, nightly).

apps/stage-tamagotchi/src/main/configs · high confidence

A new Connection settings page has been added to the Tamagotchi stage, allowing users to configure remote WebSocket connections. Key features include a toggle to enable/disable WebSocket TLS (WSS) security, a visible/copyable server authentication token field, and a checkbox to expose the server to all network interfaces (0.0.0.0) on desktop. Additionally, a QR code card is provided for device pairing, which is hardcoded to render as dark-on-light to ensure compatibility with mobile barcode scanners.

apps/stage-tamagotchi/src/renderer/pages/settings/connection · high confidence

The Settings \> Data page now includes dedicated sections for managing the desktop application's local state. Users can open the user data folder directly via a new button, reset the desktop application's persisted state to clear local settings, and re-center the main application window on the current display. These controls are presented with distinct visual styling and include confirmation steps for the reset action to prevent accidental data loss.

apps/stage-tamagotchi/src/renderer/pages/settings/data/components · high confidence

The Tamagotchi renderer now includes several new pages that enhance the desktop experience. A desktop overlay page visualizes the AI agent's ghost pointer and target candidates using screen-absolute coordinate mapping and MCP polling, with pure logic extracted for testability. A caption overlay page displays synchronized speaker and assistant text with fade-on-hover behavior. A floating chat window page allows users to resize and reposition the chat independently, while a standard chat page provides a fixed layout with scrollable history. These additions expand the stage's interactive capabilities on desktop.

apps/stage-tamagotchi/src/renderer/pages · high confidence

The devtools section now includes several new interactive pages: an audio recorder that captures and plays back WAV files, a background removal tool that processes images using a WebGPU/WASM adapter with auto-processing and hover preview, a background gradient blending page that extracts colors from images to update the UI theme, a gesture circle detector for testing input patterns, a MediaPipe model driver for real-time pose/hand/face tracking on VRM models, a performance playground for testing speech pipelines and emotions, and a performance visualizer that records and exports FPS, frame duration, long tasks, and memory metrics. Additionally, browser tests were added to verify imported Live2D and VRM model handling in the Polaroid component.

apps/stage-web/src/pages/devtools · high confidence

The devtools section now includes several new interactive pages to help test and debug specific capabilities. The audio-record page allows selecting an input device and recording audio to WAV files. The background-removal page provides a batch-processing interface for removing image backgrounds using a WebGPU/WASM adapter. The background-gradient-blending page tests color extraction from images using Node Vibrant and html2canvas to update the UI theme. The gesture-circle page visualizes pointer movement and detects circular gestures. The notifications page tests local notification scheduling via Capacitor. The performance-playground page offers a comprehensive environment for testing the speech pipeline, audio playback, and VRM character expressions. Finally, the use-magic-keys page serves as a visual test for keyboard input handling.

apps/stage-pocket/src/pages/devtools · high confidence

The application now exposes new eventa channels to support computer-use automation, a floating chat window with draft persistence, and spotlight shortcut configuration. Users can now invoke computer-use actions (run commands, read images) via the new \computer-use.ts\ module. The chat interface supports a new 'floating' mode that can be pinned, resized, and moved independently, with unsent drafts automatically carried over when switching between legacy and floating windows. Additionally, spotlight shortcuts can now be queried and set, and result notifications can be displayed.

apps/stage-tamagotchi/src/shared/eventa · high confidence

The Stage Tamagotchi extension host now supports importing extensions from local folders via the Extension management window, with a new \extension.airi.json\ manifest format (Manifest V2). It includes an optional auto-reload feature that watches extension files and triggers hot-reloads, a static asset service that mounts extension UI assets behind a local server with cookie-based session management, and a built-in gamelet kit that allows extensions to open and manage iframe-backed UI widgets. A sample devtools extension is provided to validate the new host lifecycle and import flow.

apps/stage-tamagotchi/src/main/services/airi/plugins · high confidence

The chat window now defaults to a new floating mode that attaches beside the main character window, intelligently choosing left or right sides and top or bottom anchors based on available screen space. This placement logic includes hysteresis to prevent jittery layout switching during window drags and ensures the chat remains fully visible within the work area of multi-monitor setups, even shrinking the chat if it exceeds the display bounds. A critical fix prevents main process crashes on Windows caused by negative zero coordinates in window positioning. Additionally, switching between the legacy and floating chat modes now safely preserves unsent composer drafts, ensuring text is not lost if the new window fails to load or restore the session.

apps/stage-tamagotchi/src/main/windows/chat · high confidence

A new package, font-xiaolai, has been added to provide the Xiaolai SC Regular font. This package includes the necessary CSS @font-face definition and build configuration (using tsdown) to bundle the font files and styles, making the font available for use in the application.

packages/font-xiaolai · high confidence

The i18n package now includes a structured glossary system to ensure consistent terminology across all supported languages. A new \terms.yaml\ file defines approved English terms, which are validated against a strict schema and converted into a TBX (TermBase eXchange) format for import into the Crowdin translation platform. This change also establishes the foundational English locale files (\base.yaml\, \stage.yaml\, \settings.yaml\, etc.) and provides utilities to normalize locale codes (e.g., mapping \zh-CN\ to \zh-Hans\), ensuring a consistent and high-quality translation workflow for the application's interface.

packages/i18n · high confidence

The application now initializes internationalization and PWA capabilities via dedicated module files. The new i18n module sets up vue-i18n using locale messages from the @proj-airi/i18n package, determining the active language by checking the 'settings/language' localStorage key or falling back to the browser's language, with English as the final fallback. Additionally, a new PWA module exports the registerSW function from virtual:pwa-register to handle service worker registration.

apps/stage-web/src/modules · high confidence

This change introduces four new standalone bot integrations into the \integrations/\ workspace. The Discord bot enables voice channel interaction with AI services like OpenAI and ElevenLabs. The Minecraft service provides a Mineflayer-based bot with a four-layer cognitive architecture (Perception, Reflex, Conscious, Action) and includes a local MCP debug server for inspecting bot state and injecting events. The Satori bot is a standalone, event-driven agent supporting multiple chat platforms (QQ, Telegram, Discord, Lark) via the Satori Protocol, featuring a temporary internal core and PGlite-based persistence. The Telegram bot allows AI interaction within Telegram, supporting vision models and embeddings via Ollama, and includes deployment configurations for Prometheus and Tempo monitoring.

integrations · high confidence

The Stage Tamagotchi Browser now includes a new macOS 26 platform simulation layer. This adds a \PlatformRoot\ component that renders a macOS-style desktop environment, complete with a \Dock\ and \MenuBar\. A key behavioral update is the \WindowRoot\ component, which now supports dock-aware window anchoring; when anchored to corners like 'bottom-right', windows automatically adjust their position to avoid overlapping the dock by calculating a usable work area. The simulation also features a 'liquid-glass' visual effect, implemented via SVG filters and a \Refractive\ component, to apply realistic glass-like refraction and specular highlights to window frames.

packages/scenarios-stage-tamagotchi-browser · high confidence

The app now includes dedicated modules in the main process to improve developer experience and runtime stability. A debugger module enables configurable remote CDP debugging via environment variables, allowing developers to attach external tools and optionally auto-open the inspector. A file logger creates timestamped session logs in the userData directory, ensuring persistent records for troubleshooting. Platform detection logic correctly resolves Wayland vs. X11 status by prioritizing explicit Ozone flags over environment variables, fixing display behavior on Wayland systems. Finally, a single-instance guard prevents duplicate desktop processes from launching, focusing the existing window instead to avoid resource conflicts.

apps/stage-tamagotchi/src/main/app · high confidence

The \packages/plugin-sdk-tamagotchi\ package has been introduced to provide extension authors with a structured API for building Tamagotchi plugins. It exposes a \gameletKit\ for mounting and orchestrating iframe-based gamelet UIs, and a \toolKit\ for registering tools and toolset prompts with the host. The SDK handles the underlying communication contracts, including a dedicated Eventa channel for gamelet iframe requests and a widget bridge for UI iframes, while managing the serialization of tool schemas and host data records.

packages/plugin-sdk-tamagotchi · high confidence

A new \@proj-airi/plugin-protocol\ package has been introduced to provide canonical protocol contracts for plugin-to-host communication. This package defines the WebSocket event names and payload types used for module and extension orchestration, including specific interfaces for plugin, module, extension, and kit identities, as well as dynamic module contributions and configuration schemas. It exposes these definitions via \@proj-airi/plugin-protocol/types\ to ensure event name stability and matching payload definitions across server and plugin runtimes, supported by unit tests that verify the distinct IDs for peer authentication and extension announcements.

packages/plugin-protocol · high confidence

The \apps/stage-tamagotchi/scripts\ directory now includes a suite of new scripts to manage release artifacts and update metadata. \rename-artifacts.ts\ and \artifacts-metadata.ts\ handle the renaming of build outputs to standardized release filenames and provide CLI utilities to query artifact details. \regenerate-windows-latest.ts\ and \merge-latest-mac.ts\ automate the generation and merging of auto-update manifest files (\latest.yml\/\latest-mac.yml\) for Windows and macOS, ensuring correct hashes and URLs. Additionally, \update-readme-download-links.ts\ automatically updates download links in README files to point to the latest GitHub releases, and \desktop-overlay-live-window-smoke.ts\ along with its test file introduces a new smoke test for the desktop overlay feature.

apps/stage-tamagotchi/scripts · high confidence

A new 'resource-status-island' component has been added to the stage interface, providing users with real-time feedback on module loading progress. This pill-shaped UI element displays a 'Resources loading...' or 'Ready!' status and, when clicked, opens a tooltip that lists individual modules, their specific file-level progress bars, and any availability reasons. The component is designed to be non-intrusive, using pointer-events-none on its container to ensure clicks pass through to the stage background when not interacting with the status pill itself.

apps/stage-tamagotchi/src/renderer/components/stage-islands/resource-status-island · high confidence

The \@proj-airi/stage-pages\ package is introduced to host route-level Vue pages shared across multiple AIRI stage applications, providing a centralized location for reusable page behavior and route structure. This release adds a comprehensive Context Flow devtools interface, featuring components to visualize active context buckets, track context lifecycle events, inspect prompt projections, and monitor runtime coordination (WebSocket status, pending sends, and broadcast activity). It also includes a Beat Sync playground for tuning animation styles and a general settings component that exposes theme, language, and analytics controls.

packages/stage-pages · high confidence

The shared module now includes a Zod-based validation layer for MCP stdio server configurations (mcp-config.ts), ensuring that JSON drafts and persisted files conform to the expected schema before use. It introduces a runtime communication channel (model-settings-runtime.ts) for synchronizing Live2D expression settings between the stage renderer and the UI. Additionally, new files provide diagnostic snapshots for screen ambient light capture (screen-ambient-light-diagnostics.ts), a helper to validate spotlight shortcut accelerators (spotlight-shortcut.ts), and infrastructure for a desktop overlay smoke test (desktop-overlay-live-window-smoke.ts and desktop-overlay-heartbeat.ts).

apps/stage-tamagotchi/src/shared · high confidence

The \apps/stage-tamagotchi/src/main/windows/shared\ directory now provides a suite of shared utilities for managing Electron windows. This includes an \Animator\ class that smoothly animates window position changes while applying target sizes and preventing animations on destroyed windows. Display utilities (\display.ts\) introduce robust logic for centering windows within work areas and anchoring resize operations to the dominant display, ensuring windows stay visible across multi-monitor setups. A \ReferencedWindowManager\ simplifies the creation and lifecycle management of named, reusable windows (such as notices or widgets) by handling context binding and safe closing. Additionally, \window.ts\ adds platform-aware always-on-top handling, safe external link navigation guards, and precise delta-based resize calculations that respect minimum size constraints.

apps/stage-tamagotchi/src/main/windows/shared · high confidence

The \apps/ui-server-auth/src/modules\ directory now contains the core logic for the standalone authentication UI, including a provider-neutral analytics client that tracks anonymous milestones (like \signup\_form\_completed\) separately from server-side canonical events, a cookie-based Better Auth client factory, and dedicated modules for email/password flows, user profile management, and social sign-in (including Steam OpenID). It also introduces a bootstrap context resolver that safely extracts trusted API server origins from server redirects and normalizes redirect paths under the \/ui\ base, ensuring secure and correct navigation for OIDC handoffs.

apps/ui-server-auth/src/modules · high confidence

The application introduces three new Pinia stores in the stage-web frontend. The \background\ store re-exports background-related types and logic from the shared \stage-layouts\ package to centralize background state. A new \devtools-lag\ store provides a performance visualizer that samples FPS, frame duration, long tasks, and memory usage, allowing users to record and analyze performance metrics over a sliding window. Additionally, a \pwa\ store handles service worker updates by displaying a toast notification (using \ToasterPWAUpdateReady\) when a new version is ready, with logic to skip this prompt in specific environments like Hugging Face Spaces.

apps/stage-web/src/stores · high confidence

The application now includes dedicated settings pages under the System section to manage developer utilities and global shortcuts. The Developer page provides a centralized menu to access various inspection and testing tools, including context flow, beat sync visualization, live2d motion, websocket inspection, plugin host debugging, and screen capture. Additionally, a new Window Shortcuts page allows users to configure and record global keyboard shortcuts for the spotlight feature, with validation and conflict handling.

apps/stage-tamagotchi/src/renderer/pages/settings/system · high confidence

This change introduces several new utility modules in the renderer's utils directory to support stage interaction logic, voice input lifecycle management, and safe resource handling. The \fade-on-hover\ and \stage-three-transparency\ utilities determine when the stage window should fade and allow click-through to underlying applications based on hover state and transparency. The \voice-input-lifecycle\ module serializes microphone start/stop operations to prevent race conditions and ensure errors are properly propagated, while \voice-input-suppression\ handles muting input during and after assistant speech to prevent echo. Additionally, \create-object-url-from-bytes\ provides a safe way to generate blob URLs from byte arrays without leaking buffer data, and \windows.ts\ provides stubs for click-through control.

apps/stage-tamagotchi/src/renderer/utils · high confidence

Added two new utility modules in the shared utils directory to handle window management logic. The \display.ts\ module introduces functions to calculate the dominant display area for cross-screen windows and to clamp window bounds within a specific rectangle, ensuring windows stay within usable screen areas. The \window-size.ts\ module provides a normalization function that sanitizes widget window size inputs by validating dimensions and flooring numeric values, preparing them for application in Electron windows.

apps/stage-tamagotchi/src/shared/utils · high confidence

The chat interface now includes a dedicated renderer for journal-related tool calls, providing structured and visual feedback for text and image entries. When a text journal is created, the UI displays a 'Saved to long-term memory' badge and renders the content as formatted Markdown. For image journals, it shows a status badge indicating the mode (e.g., 'Updating Scene' for background or 'Generating image' for inline), renders the prompt as Markdown, and displays the generated image in a clickable card that opens a preview. This component handles both successful results and error states, ensuring users see clear, contextual information for these specific AI actions.

apps/stage-tamagotchi/src/renderer/components/chat-tool-renderers · high confidence

The weather widget in the stage-tamagotchi app has been updated to include a new \Weather\ component that displays dynamic weather conditions using animated SVG icons (such as rotating suns for clear days) and supports various weather effects like rain, snow, and fog. The widget now features a \Skeleton\ component that provides pulse and wave animation placeholders during loading states, improving the user experience while data is being fetched. Additionally, the widget includes a comprehensive mapping system to normalize weather condition strings into specific icons and effects, ensuring consistent visual representation across different weather scenarios.

apps/stage-tamagotchi/src/renderer/widgets/weather · high confidence

This change introduces a new capability for generating procedural, AI-driven motion for Live2D characters. It adds the \@proj-airi/motion-driver-magic\ package, which fits VAR and AR-HMM statistical models to recorded motion sequences to produce continuous, seeded procedural motion frames. It also adds the \@proj-airi/model-driver-magic-live2d\ package, which drives the Live2D target with these generated poses, applying fixed-rate scheduling, output filtering (cutoff and EMA smoothing), and pose conversion. Additionally, a new \Live2DSystemAudioLipSyncDriver\ is added to the stage-tamagotchi app, enabling lipsync by capturing system audio via Electron's screen capture API and converting it into Live2D mouth movements.

(repo-wide) · high confidence

The chat window now explicitly registers its RPC services by invoking the widget and MCP server service creators, ensuring these capabilities are available to the renderer process. Additionally, a handler is defined to allow opening the main process devtools from the chat window interface.

apps/stage-tamagotchi/src/main/windows/chat/rpc · high confidence

The Stage Pocket application now initializes its core services, including analytics (via OpenPanel), authentication, and device settings, upon launch. Users will encounter a new onboarding flow that includes a permissions request step and an analytics notice, ensuring proper setup before accessing the main interface. The app also handles deep links for authentication and manages UI transitions and toast notifications.

apps/stage-pocket/src · high confidence

The application now supports opening the DevTools as a separate, detached window. This new capability allows users to specify custom dimensions (width, height) and screen coordinates (x, y) when opening the DevTools, enabling flexible window management. The implementation introduces a reusable window manager that handles window lifecycle, applies security protections for privileged navigation, and initializes screen capture capabilities for the detached view.

apps/stage-tamagotchi/src/main/windows/devtools · high confidence

The Tamagotchi application now includes dedicated Pinia stores to manage AI tools within its specific context. The new \useTamagotchiBuiltinToolsStore\ registers built-in capabilities such as image journaling, weather, widgets, and desktop computer use, with computer-use tools requiring explicit user selection. Additionally, \useTamagotchiMcpToolsStore\ and \useTamagotchiPluginToolsStore\ handle the dynamic loading, execution proxying, and cleanup of Model Context Protocol (MCP) tools and third-party plugin tools respectively. The plugin store includes a 5-second timeout to prevent startup hangs if tool listing fails, ensuring a smoother initialization experience.

apps/stage-tamagotchi/src/renderer/stores/tools · high confidence

The \apps/stage-tamagotchi/src/renderer/composables\ directory has been completely rewritten to support new Tamagotchi capabilities and fix platform-specific issues. Language persistence now correctly restores the user's locale from the main process on Electron restarts, preventing fallback to the OS locale (\#1658). Live2D expression settings are now properly synchronized between the settings window and the stage via a runtime owner channel, ensuring commands are applied to the correct model instance (\#2450). A new floating chat window feature includes click-through logic that correctly handles pointer events over transparent areas and dismisses overlays when the chat folds. Additionally, the renderer now supports chat draft handover between windows, ambient light diagnostics, and scroll position restoration across routes.

apps/stage-tamagotchi/src/renderer/composables · high confidence

The computer-use-mcp service now captures macOS application accessibility trees via an inline Swift script (using the AXUIElement API) and provides utilities to resolve application name aliases (e.g., mapping 'VS Code' to 'Visual Studio Code'). This includes new modules for formatting accessibility snapshots as text, finding nodes by unique ID, and normalizing app names for actions like opening or focusing applications.

services/computer-use-mcp · high confidence

The Live2D character viewer (Live2DViewer.vue) and the main chat interface with audio waveform visualization (MainStage.vue) have been removed from the application. This eliminates the interactive 3D avatar that previously synchronized its mouth movements with text-to-speech audio output, as well as the associated audio processing and streaming logic within the main stage component.

components · high confidence

The \useCount\ composable for managing a simple counter state and the \useUserStore\ Pinia store for managing user name history have been removed from the application. This cleanup eliminates unused state management logic related to counting and user profile tracking.

composables · high confidence

The constants file containing the application name ('Vitesse for Nuxt 3') and description has been deleted. This removes the centralized export of these string values, likely as part of a cleanup or refactoring effort where these constants are no longer needed or have been moved elsewhere.

constants · high confidence

The \@proj-airi/provider-inference\ package has been introduced to host runtime-neutral provider definitions, separating them from the \stage-ui\ application layer. This package provides a portable registry of cloud and local providers (such as OpenAI, Anthropic, and Amazon Bedrock) that can execute in both Node.js and Browser environments without depending on Vue, Pinia, or browser persistence APIs. It exposes a unified interface for listing providers, creating provider instances, and managing generation protocols (Chat Completions vs. Responses API), while explicitly excluding UI views, state management, and authentication concerns which remain in \stage-ui\.

packages/provider-inference · high confidence

The plugin inter-process communication (IPC) definitions in the shared Eventa layer have been split into focused modules (host, capabilities, tools, assets) to improve code organization. This change groups related contracts—such as plugin lifecycle management, capability state updates, tool definitions, and asset base URLs—into separate files while maintaining backward compatibility through a central barrel that re-exports all existing definitions. Users and developers importing from the shared eventa plugin module will see no functional changes, but the internal structure now clearly separates concerns for easier maintenance and future extension.

apps/stage-tamagotchi/src/shared/eventa/plugin · high confidence

The iOS application workspace has been initialized with standard Xcode configuration files, including the workspace data and IDE workspace checks plist. This establishes the foundational project structure for the iOS build environment.

apps/stage-pocket/ios/App/App.xcodeproj/project.xcworkspace · high confidence

The main window now uses a dedicated RPC setup module to register IPC invoke handlers for core features including the chat window, settings, editor, auto-updater, MCP servers, Godot stage, onboarding, and authentication. This centralizes how the main window communicates with the renderer process, replacing previous ad-hoc IPC registrations with a structured, context-based approach using the @moeru/eventa library.

apps/stage-tamagotchi/src/main/windows/main/rpc · high confidence

The Airi extension host now uses a dedicated \createBuiltInExtensionKitRuntime\ module to manage the registration of built-in kits (widget, gamelet, and tool kits). This change decouples kit registration logic from the host bootstrap process, providing a cleaner API for registering kit APIs and managing associated resources like the tool registry and gamelet orchestration runtime. Users benefit from a more modular and maintainable plugin system where kit integration is handled through a unified runtime interface.

apps/stage-tamagotchi/src/main/services/airi/plugins/kits · high confidence

The application now uses a centralized \main.css\ entry point that imports the UI library's base styles and defines global CSS variables for light and dark themes. This change introduces specific mobile optimizations, including disabling double-tap zoom and preventing overscroll behavior, while also ensuring the nprogress loading bar is hidden when the app is installed as a PWA. Additionally, dedicated CSS files for Vue transition animations (slide-away and fade-slide effects) have been added to standardize visual feedback during navigation.

apps/stage-web/src/styles · high confidence

The controls island has been completely rewritten to feature adaptive placement that automatically docks to the screen corner opposite the main window, with a smooth transition animation and a 1-second settle delay to prevent jitter. The new layout includes robust overflow handling to ensure all controls remain reachable in small windows, a fade-on-hover toggle to hide the island when not in use, and a speech mute button that stops playback. It also integrates a profile switcher, an authentication button showing user credits, and a chat toggle, all wrapped in a consistent UI with improved tooltips and icon sizing.

apps/stage-tamagotchi/src/renderer/components/stage-islands/controls-island · high confidence

This update applies several dependency patches to fix behaviors and improve stability. The @xsai-ext/responses SDK is patched to support native web search tools, handle reasoning text events, await asynchronous callbacks, and correctly translate chat tool outputs. The mineflayer pathfinding library is enhanced with lava avoidance, stuck detection with retry limits, and fixes for door collisions and block placement. The pixi-live2d-display library is patched to ignore the items\_pinned\_to\_model.json file during model loading and fix path validation. The uiohook-napi patch removes the build script to use prebuilt binaries, and the tab-election patch fixes race conditions in leader election and call delivery.

patches · high confidence

The desktop overlay window now exposes a readiness contract that allows the renderer to poll its boot status. The overlay initializes by setting up base window services and MCP tool services; it reports a 'ready' state once these are successfully wired, or a 'degraded' state with an error message if initialization fails, ensuring the window opens gracefully even when background services encounter issues.

apps/stage-tamagotchi/src/main/windows/desktop-overlay/rpc · high confidence

The extension host in the Tamagotchi app now supports importing plugins directly from local folders via a new directory importer that validates and copies extension packages into a managed registry. This importer enforces strict security limits (e.g., 512 MiB size cap, no symlinks) and uses a new manifest format (\extension.airi.json\). Additionally, the widget kit now handles rewriting iframe asset URLs to use mounted static asset paths, enabling proper asset serving for plugin widgets within the Electron environment.

apps/stage-tamagotchi/src/main/services/airi/plugins/host, apps/stage-tamagotchi/src/main/services/airi/plugins/kits/widget · high confidence

The title bar component now hides the info icon that was previously visible in the inactive state. This change ensures the interface remains uncluttered until the associated collapse feature is implemented, as indicated by the commented-out code and internal notes.

apps/stage-tamagotchi/src/renderer/components/Window · high confidence

The stage-layouts package now includes a new adaptive input geometry system that resolves mobile keyboard overlap and Safari-specific viewport issues, ensuring chat inputs remain visible and correctly positioned during keyboard open/close cycles. Additionally, a new dark mode logo asset has been added to support the application's branding in dark themes.

packages/stage-layouts · high confidence

The web application now launches with a first-time setup onboarding flow that guides users through initial configuration, including an analytics consent step. The app's visual theme is now dynamic, allowing users to adjust the primary color hue, which automatically updates the interface's primary, secondary, and tertiary colors in both light and dark modes. Additionally, the app initializes core services like authentication, chat, and inference preloading on mount, and integrates OpenPanel for analytics tracking.

apps/stage-web/src · high confidence

The beat-sync feature now runs in its own hidden Electron background window rather than being embedded in the main application window. This new window initializes screen capture utilities via the preload script and applies privileged navigation protection, isolating the audio detection and capture logic to improve stability and security boundaries.

apps/stage-tamagotchi/src/main/windows/beat-sync · high confidence

When the onboarding window is opened, the main application window now automatically animates to an adjacent position to prevent visual overlap. This behavior is triggered by the new onboarding service in the main process, which calculates a suitable adjacent position based on the onboarding window's bounds and the display's work area, then moves the main window using a 350ms animation. If the user manually moves or resizes the main window during this process, the automatic repositioning is cancelled. Once the onboarding window is closed, the main window animates back to its original position, provided the user did not move it manually.

apps/stage-tamagotchi/src/main/services/airi/onboarding · high confidence

The main application window now remembers its last position and size across restarts, restoring the window to the same location and dimensions when reopened. Additionally, clicking the close button no longer quits the application; instead, the window is hidden to the system tray, allowing users to quickly restore it without restarting the app.

apps/stage-tamagotchi/src/main/windows/main · high confidence

The renderer now uses dedicated Pinia stores to manage application state: a new controls-island store persists the user's preference for the 'Fade on Hover' feature and the 'Don't show again' notice; a resources store tracks module and component loading progress with delayed visibility flags; a window lifecycle store monitors window visibility and minimization to determine when the stage should pause (specifically avoiding pauses during virtual desktop switches); and a window store provides window dimensions and Live2D-specific mouse coordinates. Tests have been added for the diagnostics and lifecycle logic.

apps/stage-tamagotchi/src/renderer/stores · high confidence

The Stage Pocket app now includes a new WebSocket status button that displays the connection state (connected/disconnected) with distinct visual styling and tooltips, allowing users to quickly check connectivity and navigate to settings. Additionally, a new IconAnimation component has been introduced to stabilize the connection status animation, ensuring smoother visual feedback during state changes. The AudioWaveform component was also updated to use the shared theme store for dark mode detection and improved type safety for the analyser data buffer.

apps/stage-pocket/src/components · high confidence

The Stage Pocket app now includes a dedicated stylesheet (main.css) that defines light and dark mode background colors, disables double-tap zoom on touch devices, and enables a transparent background when the app is rendered within a native container (indicated by the .airi-native-transparent-surface class). Additionally, new transition styles have been added for slide-away animations and Vue-specific fade/slide effects, enhancing the visual feedback during navigation and state changes.

apps/stage-pocket/src/styles · high confidence

The Tamagotchi renderer now includes dedicated layout files (default, settings, and stage) to structure the user interface. The new settings layout introduces a window title bar, a page header with dynamic title/subtitle resolution (including provider-specific titles), and scroll-position restoration, while the default and stage layouts provide basic container structures for routing views.

apps/stage-tamagotchi/src/renderer/layouts · high confidence

The Devtools performance overlay now includes an FPS history chart that preserves time-based spacing to accurately represent frame stalls, along with min/max statistics. Additionally, the behavior for stopping a recording has been corrected: stopping the recording no longer triggers a CSV export, ensuring that recording and data export are distinct actions.

apps/stage-web/src/components/Devtools · high confidence

The Tamagotchi application now remembers the user's language preference across sessions. The i18n service initializes the locale from the persisted app configuration and registers handlers to save any language changes made during the runtime back to the configuration file, ensuring the setting is not lost when the application restarts.

apps/stage-tamagotchi/src/main/services/airi/i18n · high confidence

The About window implementation has been refactored to integrate the auto-updater service, allowing users to check for and receive updates directly from the About dialog. The window setup now uses a reusable window pattern and explicitly protects privileged navigation to prevent auxiliary renderer request storms. Additionally, the change hardens local service boundaries by registering IPC handlers before the window loads and applying sandboxing configurations, ensuring a more secure and stable user experience when accessing application information.

apps/stage-tamagotchi/src/main/windows/about · medium confidence

The application has removed the \stores/audio.ts\ and \stores/llm.ts\ files, eliminating the Pinia-based state management for the global AudioContext and the OpenAI LLM integration. This removes the ability to manage audio context and stream text via OpenAI directly from these specific store modules, indicating a shift away from this implementation or a consolidation of these capabilities elsewhere.

stores · high confidence

The application has removed the previous catch-all route handler (pages/\[...all\].vue) that displayed a generic 'Not found' warning and the main index page (pages/index.vue) which rendered the MainStage component with a loading fallback. These files are no longer part of the routing structure, indicating a shift in how navigation and the initial view are handled.

pages · high confidence

The application previously known as stage-capacitor has been renamed to stage-pocket. This change includes the addition of iOS launch and main storyboards, a Swift Package Manager configuration for Capacitor dependencies, and the introduction of a background store module that re-exports types and hooks from the stage-layouts package.

(repo-wide) · high confidence

The server source has been moved into a dedicated \server/\ directory, establishing a new project layout that separates the Resource API (\apps/api\) and Auth service (\apps/auth\) while keeping shared packages in \packages/\. To support local development, a \docker-compose.yaml\ file and a Caddy edge router configuration have been added, allowing the full backend stack (API, Auth, PostgreSQL, Redis, and Caddy) to be started with a single command. The move is accompanied by new \AGENTS.md\ and \README.md\ files that document the runtime contracts, architecture decision record (ADR) locations, and deployment boundaries. As part of this restructuring, the legacy \server/api/v1/llm/voice/text-to-speech.ts\ endpoint has been removed.

server · high confidence

The settings window now uses the Eventa framework to manage its IPC handlers, replacing the previous implementation. This change wires up core services—including widgets, auto-updater, MCP servers, Godot stage, and authentication—to the settings window context, and registers handlers for window centering, spotlight shortcuts, and devtools opening.

apps/stage-tamagotchi/src/main/windows/settings/rpc · high confidence

The spark-command and spark-notify agents have been relocated from the UI layer into the core-agent package, centralizing the scheduling, context composition, and generation logic. The spark-command tool now uses a provider-facing schema that avoids dynamic property names and preserves heterogeneous nullable metadata unions, ensuring compatibility with strict providers like Azure OpenAI while maintaining canonical forms for others. The spark-notify agent now supports configurable runtime policies that allow hosts to force text-only responses, force spark-command responses, or enable full tool execution, and it exposes composable plugins for handling reactions, observing runtime events, and managing built-in tools.

packages/core-agent · high confidence

The Stage Pocket application now includes its public asset directory, featuring a new SVG favicon, HTTP headers for long-term caching of static assets, and redirect rules that normalize legacy Chinese documentation URLs (e.g., /docs/zh-hans/) to the current locale format.

apps/stage-pocket/public · high confidence

The Tamagotchi renderer has been reorganized to support distinct window types (main, settings, widgets, spotlight, floating chat) via a new window-context system that resolves leadership and runtime scope from URL queries, preventing race conditions during initialization. A new background window for beat-sync has been introduced to handle audio detection independently, and the chat window style menu now correctly manages preference synchronization and UI state. These changes improve stability, reduce request storms, and enable specialized renderer behaviors for different Stage modes.

apps/stage-tamagotchi/src/renderer · high confidence

The browser-side inference layer has been restructured around a unified protocol, introducing dedicated adapters for Kokoro (TTS), Whisper (ASR), and background removal that offload processing to Web Workers and support cancellation via AbortController. To improve stability, adapters now feature automatic worker restarts on failure, track WebGPU device-loss events to trigger WASM fallbacks after repeated crashes, and use a centralized GPU resource coordinator to manage VRAM budgets and emit memory pressure warnings. A global load queue ensures models load sequentially with priority ordering, while new cache utilities allow users to view and clear stored model files.

packages/stage-ui/src/libs/inference · high confidence

The preload script now uses a shared module to consistently expose Electron APIs and platform information to the renderer process. It introduces a new \exposeWithCustomAPI\ function that allows specific custom APIs to be exposed alongside the standard Electron interface, improving type safety and structure for preload-to-renderer communication.

apps/stage-tamagotchi/src/preload · high confidence

The application's visual identity has been updated with new SVG logo files for both light and dark modes. The new designs feature a refined abstract shape with updated color palettes (including shades like \#F1D0DB, \#EC92AD, and \#FFF4F4) and structural changes to the paths, replacing the previous logo assets in the \apps/stage-web/src/assets\ directory.

apps/stage-web/src/assets · high confidence

The stage-web public directory now includes configuration files required for the migration to Cloudflare Workers. A new \_headers file sets long-term immutable caching for assets, while \_redirects handles internationalization by normalizing legacy zh-hans paths to zh-Hans and redirecting /docs/ to /docs/en/. The directory also introduces an .assetsignore file to exclude build artifacts and a new SVG favicon.

apps/stage-web/public · high confidence

The Voice Activity Detection implementation has been reorganized into a new \apps/stage-web/src/workers/vad\ directory. This change introduces a dedicated AudioWorklet processor (\process.worklet.ts\) for efficient audio chunk handling and a VAD class (\vad.ts\) that integrates the Silero VAD model via \@huggingface/transformers\. The module exports a state manager and types, centralizing the VAD functionality previously scattered across the application.

apps/stage-web/src/workers · high confidence

The widget system now enforces strict window lifecycle management and reliable iframe communication. Widget windows are properly destroyed when their time-to-live expires or when the widget is removed, preventing orphaned windows and stale renderer states. Each widget instance is isolated to its own window context, ensuring that updates or removals do not affect other widgets. Additionally, a new iframe request coordinator handles asynchronous communication between the main process and widget iframes, providing correlation, timeout handling, and cleanup when widgets are closed.

apps/stage-tamagotchi/src/main/windows/widgets · high confidence

The iOS project for Stage Pocket now includes essential configuration files to support code signing and archiving. An ExportOptions.plist file has been added to define the app-store-connect distribution method, manual signing style, and specific provisioning profiles for the team. A .gitignore file is introduced to exclude build artifacts, derived data, and generated Capacitor config files from version control. Additionally, a debug.xcconfig file enables Capacitor debug mode for the iOS target.

apps/stage-pocket/ios · high confidence

The macOS build configuration for the Tamagotchi app now includes an entitlements file that explicitly grants access to the microphone, camera, audio input, and Bluetooth. This change ensures the application can request these hardware permissions correctly during installation and runtime on macOS.

apps/stage-tamagotchi/build · high confidence

A fix in apps/stage-tamagotchi/src/renderer/public — 1 commit (1 fix), 1 file.

apps/stage-tamagotchi/src/renderer/public · low confidence · unverified

The \apps/stage-tamagotchi/src/main/libs/i18n/index.ts\ file has been added to provide the core context and translation function (\createI18n\) required for internationalization. This implementation wraps \@intlify/core\ to manage locale signals and translation keys, ensuring the main process has the necessary infrastructure to handle localized strings.

apps/stage-tamagotchi/src/main/libs/i18n · high confidence

A new account settings page has been added to the Stage Pocket application, accessible via the route defined in \apps/stage-pocket/src/pages/settings/account/index.vue\. This page integrates with the existing \AccountSettingsPage\ component and provides handlers for login and logout actions, utilizing the auth store and router to manage user sessions and navigation back to the main settings view.

apps/stage-pocket/src/pages/settings/account · high confidence

The Tamagotchi app now handles Electron hash-route navigation failures gracefully by catching and ignoring false-positive ERR\_ABORT errors, preventing crashes when loading routes like /settings. Additionally, configuration persistence has been hardened to use unique temporary files for each save operation, eliminating ENOENT errors caused by concurrent save attempts and ensuring config data is no longer lost during rapid updates.

apps/stage-tamagotchi/src/main/libs/electron · high confidence

The authentication service in the Stage Tamagotchi app now correctly handles concurrent login attempts, window closures, and logout actions by discarding stale token exchanges. Previously, closing a loopback server or starting a new login could leave orphaned requests or allow outdated tokens to overwrite current sessions. The new implementation ensures that only the most recent login attempt receives the authentication callback, and any in-flight exchanges are safely cancelled if the owning window closes or a new login begins.

apps/stage-tamagotchi/src/main/services/airi · high confidence

The server channel settings store now rolls back optimistic UI changes if applying the configuration to the main process fails, preventing the app from getting stuck in an invalid state. Additionally, the store now waits for the main process to fully accept the new configuration before updating the published state, which resolves issues where dependent components (like the QR card) would read stale or loopback values during the server restart.

apps/stage-tamagotchi/src/renderer/stores/settings · high confidence

Added test setup for Live2D Cubism runtime; Added tests for strict tool schema validation matchers; Added unit tests for environment parsing, request authentication, and WebSocket authorization.

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

• CAI 37 → 52 (+15.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 60 → 57 (-3.5)
• Architecture 47 → 68 (+21.4)
• Maturity 63 → 85 (+22.4)
• Readiness 20 → 41 (+21.9)
• Security 53 → 61 (+7.6)

• Boundary-crossing change coupling: App.vue ↔ App.vue (apps/stage-pocket/src/App.vue)
• Boundary-crossing change coupling: App.vue ↔ App.vue (apps/stage-pocket/src/App.vue)
• Boundary-crossing change coupling: Live2D.vue ↔ Stage.vue (packages/stage-ui-live2d/src/components/scenes/Live2D.vue)
• Boundary-crossing change coupling: Live2D.vue ↔ live2d.vue (packages/stage-ui-live2d/src/components/scenes/Live2D.vue)
• Boundary-crossing change coupling: developer.vue ↔ developer.vue (apps/stage-tamagotchi/src/renderer/pages/settings/system/developer.vue)
• Boundary-crossing change coupling: i18n.ts ↔ index.ts (apps/stage-web/src/modules/i18n.ts)
• Boundary-crossing change coupling: index.vue ↔ preview-stage.vue (apps/stage-tamagotchi/src/renderer/pages/index.vue)
• Boundary-crossing change coupling: main.ts ↔ main.ts (apps/stage-tamagotchi/src/renderer/main.ts)
• Change coupling: hearing-config-dialog.vue ↔ hearing-config.vue (packages/stage-ui/src/components/scenarios/dialogs/audio-input/hearing-config-dialog.vue)
• Change coupling: index.ts ↔ index.ts (apps/stage-tamagotchi/src/main/index.ts)
• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• …and 115 more

• (anonymous)::readInputValue (cognitive 18) (services/computer-use-mcp/chrome-extension/content.js)
• (anonymous)::readInputValue (cyclomatic 19) (services/computer-use-mcp/chrome-extension/content.js)
• AdaptiveInput.measure (cognitive 19) (packages/stage-layouts/src/browser/adaptive-input.ts)
• AdaptiveInput.measure (cyclomatic 16) (packages/stage-layouts/src/browser/adaptive-input.ts)
• Analytics.initialize (cognitive 17) (packages/stage-ui/src/libs/product-signals/index.ts)
• Analytics.initialize (cyclomatic 19) (packages/stage-ui/src/libs/product-signals/index.ts)
• Brain.buildUserMessage (cognitive 23) (integrations/minecraft/src/cognitive/conscious/brain.ts)
• Brain.processEvent (cognitive 45) (integrations/minecraft/src/cognitive/conscious/brain.ts)
• Brain.processEvent (cyclomatic 31) (integrations/minecraft/src/cognitive/conscious/brain.ts)
• Brain.runControlActionWorker (cognitive 23) (integrations/minecraft/src/cognitive/conscious/brain.ts)
• CI runs a third-party container image from a mutable tag (.github/workflows/autofix.yaml)
• Change coupling: api.ts ↔ auth.ts (packages/stage-ui/src/composables/api.ts)
• Change coupling: app.ts ↔ index.ts (server/apps/api/src/app.ts)
• Change coupling: brain.ts ↔ pipeline.ts (integrations/minecraft/src/cognitive/conscious/brain.ts)
• Change coupling: chats.ts ↔ auth.ts (server/apps/api/src/services/domain/chats.ts)
• Change coupling: definitions.ts ↔ redis-keys.ts (server/apps/api/src/services/adapters/config-kv/definitions.ts)
• Change coupling: env.ts ↔ origin.ts (server/apps/api/src/libs/env.ts)
• Change coupling: index.ts ↔ widgets.vue (apps/stage-tamagotchi/src/main/windows/widgets/index.ts)
• Change coupling: instrumentation.ts ↔ index.ts (server/apps/api/instrumentation.ts)
• Change coupling: task-executor.ts ↔ brain-prompt.ts (integrations/minecraft/src/cognitive/action/task-executor.ts)
• …and 1012 more

• 300 commits — 159 feature/other, 141 fixes

• packages/stage-ui — 78 commits
• server/apps — 37 commits
• apps/stage-tamagotchi — 33 commits
• (root) — 31 commits
• nix/pnpm-deps-hash.txt — 20 commits
• packages/stage-layouts — 15 commits
• docs/content — 11 commits
• apps/stage-pocket — 9 commits
• .github/workflows — 6 commits
• packages/stage-pages — 6 commits
• .agents/skills — 5 commits
• apps/stage-web — 5 commits
• packages/i18n — 5 commits
• packages/ui — 5 commits
• packages/stage-ui-live2d — 4 commits
• nix/assets-hash.txt — 3 commits
• packages/provider-inference — 3 commits
• .vscode/settings.json — 2 commits
• apps/ui-server-auth — 2 commits
• docs/README.zh-CN.md — 2 commits

• fix: Revert "fix(stage-layouts): avoid Safari Form Assistant (#2461)"
• fix: Revert "style: lint"
• fix: fix(analytics): remove TS product events table (#2306)
• fix: fix(analytics): remove model discovery events (#2312)
• fix: fix(analytics): trim automatic product events (#2325)
• fix: fix(api): allow Apple sandbox purchases for dedicated test accounts (#2674)
• fix: fix(api): correct gateway and database pool alerts (#2324)
• fix: fix(api): load Drizzle migrations at runtime (#2307)
• fix: fix(api): preserve Responses provider fields (#2601)
• fix: fix(api): recover completed OpenRouter Responses streams (#2593)
• fix: fix(api): route web search through OpenRouter (#2604)
• fix: fix(api-server): expire Flux balance cache after one minute (#2562)
• fix: fix(auth): avoid bridge sessions on token routes (#2614)
• fix: fix(auth): discard stale authentication requests (#2483)
• fix: fix(auth): preserve mobile provider hints (#2281)
• fix: fix(auth): publish login requests on the leader (#2656)
• fix: fix(auth-server): revoke social authorizations on account deletion (#2221)
• fix: fix(auth-ui): hide sign-in form during provider handoff (#2282)
• fix: fix(better-ws): publish the package so server-sdk installs (#2408)
• fix: fix(ci): pin Node.js to 26.7.0 (#2381)
• …and 280 more

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

moeru-ai/airi 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.