@lobehub/chat 1.133.0 → 1.133.2

package/.cursor/rules/project-introduce.mdc

@@ -4,41 +4,35 @@ alwaysApply: true
 
 ## Project Description
 
-You are developing an open-source, modern-design AI chat framework: lobe chat.
+You are developing an open-source, modern-design AI chat framework: lobehub(previous lobe-chat).
 
-Emoji logo: 🤯
+support platforms:
+
+- web desktop/mobile
+- desktop(electron)
+- mobile app(react native). coming soon
+
+logo emoji: 🤯
 
 ## Project Technologies Stack
 
 read [package.json](mdc:package.json) to know all npm packages you can use.
 
-The project uses the following technologies:
-
-- pnpm as package manager
-- Next.js 15 for frontend and backend, using app router instead of pages router
-- react 19, using hooks, functional components, react server components
-- TypeScript programming language
-- antd, `@lobehub/ui` for component framework
+- Next.js 15
+- react 19
+- TypeScript
+- `@lobehub/ui`, antd for component framework
 - antd-style for css-in-js framework
-- react-layout-kit for flex layout
-- react-i18next for i18n
 - lucide-react, `@ant-design/icons` for icons
-- `@lobehub/icons` for AI provider/model logo icon
-- `@formkit/auto-animate` for react list animation
-- zustand for global state management
-- nuqs for type-safe search params state manager
-- SWR for react data fetch
+- react-layout-kit for flex layout component
+- react-i18next for i18n
+- zustand for state management
+- nuqs for search params management
+- SWR for data fetch
 - aHooks for react hooks library
-- dayjs for date and time library
+- dayjs for time library
 - lodash-es for utility library
-- fast-deep-equal for deep comparison of JavaScript objects
-- zod for data validation
 - TRPC for type safe backend
 - PGLite for client DB and PostgreSQL for backend DB
 - Drizzle ORM
-- Vitest for testing, testing-library for react component test
-- Prettier for code formatting
-- ESLint for code linting
-- Cursor AI for code editing and AI coding assistance
-
-Note: All tools and libraries used are the latest versions. The application only needs to be compatible with the latest browsers;
+- Vitest for testing

package/.cursor/rules/project-structure.mdc

@@ -5,235 +5,116 @@ alwaysApply: false
 
 # LobeChat Project Structure
 
-## Directory Structure
+note: some not very important files are not shown for simplicity.
 
-note: some files are not shown for simplicity.
+## Complete Project Structure
 
-```plaintext
-lobe-chat/
-├── apps/                           # Applications directory
-│   └── desktop/                    # Electron desktop application
-│       ├── src/                    # Desktop app source code
-│       └── resources/              # Desktop app resources
-├── docs/                           # Project documentation
-│   ├── development/                # Development docs
-│   ├── self-hosting/               # Self-hosting docs
-│   └── usage/                      # Usage guides
-├── locales/                        # Internationalization files (multiple locales)
-│   ├── en-US/                      # English (example)
-│   └── zh-CN/                      # Simplified Chinese (example)
-├── packages/                       # Monorepo packages directory
-│   ├── const/                      # Constants definition package
-│   ├── database/                   # Database related package
-│   ├── electron-client-ipc/        # Electron renderer ↔ main IPC client
-│   ├── electron-server-ipc/        # Electron main process IPC server
-│   ├── model-bank/                 # Built-in model presets/catalog exports
-│   ├── model-runtime/              # AI model runtime package
-│   ├── types/                      # TypeScript type definitions
-│   ├── utils/                      # Utility functions package
-│   ├── file-loaders/               # File processing packages
-│   ├── prompts/                    # AI prompt management
-│   └── web-crawler/                # Web crawling functionality
-├── public/                         # Static assets
-│   ├── icons/                      # Application icons
-│   ├── images/                     # Image resources
-│   └── screenshots/                # Application screenshots
-├── scripts/                        # Build and tool scripts
-├── src/                            # Main application source code (see below)
-├── .cursor/                        # Cursor AI configuration
-├── docker-compose/                 # Docker configuration
-├── package.json                    # Project dependencies
-├── pnpm-workspace.yaml            # pnpm monorepo configuration
-├── next.config.ts                  # Next.js configuration
-├── drizzle.config.ts              # Drizzle ORM configuration
-└── tsconfig.json                   # TypeScript configuration
-```
-
-## Core Source Directory (`src/`)
+this project use common monorepo structure. The workspace packages name use `@lobechat/` namespace.
 
 ```plaintext
-src/
-├── app/                            # Next.js App Router routes
-│   ├── (backend)/                  # Backend API routes
-│   │   ├── api/                    # REST API endpoints
-│   │   │   ├── auth/               # Authentication endpoints
-│   │   │   └── webhooks/           # Webhook handlers for various auth providers
-│   │   ├── middleware/             # Request middleware
-│   │   ├── oidc/                   # OpenID Connect endpoints
-│   │   ├── trpc/                   # tRPC API routes
-│   │   │   ├── async/              # Async tRPC endpoints
-│   │   │   ├── desktop/            # Desktop runtime endpoints
-│   │   │   ├── edge/               # Edge runtime endpoints
-│   │   │   ├── lambda/             # Lambda runtime endpoints
-│   │   │   └── tools/              # Tools-specific endpoints
-│   │   └── webapi/                 # Web API endpoints
-│   │       ├── chat/               # Chat-related APIs for various providers
-│   │       ├── models/             # Model management APIs
-│   │       ├── plugin/             # Plugin system APIs
-│   │       ├── stt/                # Speech-to-text APIs
-│   │       ├── text-to-image/      # Image generation APIs
-│   │       └── tts/                # Text-to-speech APIs
-│   ├── [variants]/                 # Page route variants
-│   │   ├── (main)/                 # Main application routes
-│   │   │   ├── chat/               # Chat interface and workspace
-│   │   │   ├── discover/           # Discover page (assistants, models, providers)
-│   │   │   ├── files/              # File management interface
-│   │   │   ├── image/              # Image generation interface
-│   │   │   ├── profile/            # User profile and stats
-│   │   │   ├── repos/              # Knowledge base repositories
-│   │   │   └── settings/           # Application settings
-│   │   └── @modal/                 # Modal routes
-│   └── manifest.ts                 # PWA configuration
-├── components/                     # Global shared components
-│   ├── Analytics/                  # Analytics tracking components
-│   ├── Error/                      # Error handling components
-│   └── Loading/                    # Loading state components
-├── config/                         # Application configuration
-│   ├── featureFlags/               # Feature flags & experiments
-│   └── modelProviders/             # Model provider configurations
-├── features/                       # Feature components (UI Layer)
-│   ├── AgentSetting/               # Agent configuration and management
-│   ├── ChatInput/                  # Chat input with file upload and tools
-│   ├── Conversation/               # Message display and interaction
-│   ├── FileManager/                # File upload and knowledge base
-│   └── PluginStore/                # Plugin marketplace and management
-├── hooks/                          # Custom React hooks
-├── layout/                         # Global layout components
-│   ├── AuthProvider/               # Authentication provider
-│   └── GlobalProvider/             # Global state provider
-├── libs/                           # External library integrations
-│   ├── analytics/                  # Analytics services integration
-│   ├── next-auth/                  # NextAuth.js configuration
-│   └── oidc-provider/              # OIDC provider implementation
-├── locales/                        # Internationalization resources
-│   └── default/                    # Default language definitions
-├── migrations/                     # Client-side data migrations
-├── server/                         # Server-side code
-│   ├── modules/                    # Server modules
-│   ├── routers/                    # tRPC routers
-│   └── services/                   # Server services
-├── services/                       # Service layer (per-domain, client/server split)
-│   ├── user/                       # User services
-│   │   ├── client.ts               # Client DB (PGLite) implementation
-│   │   └── server.ts               # Server DB implementation (via tRPC)
-│   ├── aiModel/                    # AI model services
-│   ├── session/                    # Session services
-│   └── message/                    # Message services
-├── store/                          # Zustand state management
-│   ├── agent/                      # Agent state
-│   ├── chat/                       # Chat state
-│   └── user/                       # User state
-├── styles/                         # Global styles
-├── tools/                          # Built-in tool system
-│   ├── artifacts/                  # Code artifacts and preview
-│   └── web-browsing/               # Web search and browsing
-├── types/                          # TypeScript type definitions
-└── utils/                          # Utility functions
-    ├── client/                     # Client-side utilities
-    └── server/                     # Server-side utilities
-```
-
-## Key Monorepo Packages
-
-```plaintext
-packages/
-├── const/                          # Global constants and configurations
-├── database/                       # Database schemas and models
-│   ├── src/models/                 # Data models (CRUD operations)
-│   ├── src/schemas/                # Drizzle database schemas
-│   ├── src/repositories/           # Complex query layer
-│   └── migrations/                 # Database migration files
-├── model-runtime/                  # AI model runtime
-│   └── src/
-│       ├── openai/                 # OpenAI provider integration
-│       ├── anthropic/              # Anthropic provider integration
-│       ├── google/                 # Google AI provider integration
-│       ├── ollama/                 # Ollama local model integration
-│       ├── types/                  # Runtime type definitions
-│       └── utils/                  # Runtime utilities
-├── types/                          # Shared TypeScript type definitions
-│   └── src/
-│       ├── agent/                  # Agent-related types
-│       ├── message/                # Message and chat types
-│       ├── user/                   # User and session types
-│       └── tool/                   # Tool and plugin types
-├── utils/                          # Shared utility functions
-│   └── src/
-│       ├── client/                 # Client-side utilities
-│       ├── server/                 # Server-side utilities
-│       ├── fetch/                  # HTTP request utilities
-│       └── tokenizer/              # Token counting utilities
-├── file-loaders/                   # File loaders (PDF, DOCX, etc.)
-├── prompts/                        # AI prompt management
-└── web-crawler/                    # Web crawling functionality
+lobe-chat/
+├── apps/
+│   └── desktop/
+├── docs/
+├── locales/
+│   ├── en-US/
+│   └── zh-CN/
+├── packages/
+│   ├── const/
+│   ├── context-engine/
+│   ├── database/
+│   │   ├── src/
+│   │   │   ├── models/
+│   │   │   ├── schemas/
+│   │   │   └── repositories/
+│   ├── model-bank/
+│   ├── model-runtime/
+│   │   └── src/
+│   │       ├── openai/
+│   │       └── anthropic/
+│   ├── types/
+│   │   └── src/
+│   │       ├── message/
+│   │       └── user/
+│   └── utils/
+├── public/
+├── scripts/
+├── src/
+│   ├── app/
+│   │   ├── (backend)/
+│   │   │   ├── api/
+│   │   │   │   ├── auth/
+│   │   │   │   └── webhooks/
+│   │   │   ├── middleware/
+│   │   │   ├── oidc/
+│   │   │   ├── trpc/
+│   │   │   └── webapi/
+│   │   │       ├── chat/
+│   │   │       └── tts/
+│   │   ├── [variants]/
+│   │   │   ├── (main)/
+│   │   │   │   ├── chat/
+│   │   │   │   └── settings/
+│   │   │   └── @modal/
+│   │   └── manifest.ts
+│   ├── components/
+│   ├── config/
+│   ├── features/
+│   │   └── ChatInput/
+│   ├── hooks/
+│   ├── layout/
+│   │   ├── AuthProvider/
+│   │   └── GlobalProvider/
+│   ├── libs/
+│   │   └── oidc-provider/
+│   ├── locales/
+│   │   └── default/
+│   ├── server/
+│   │   ├── modules/
+│   │   ├── routers/
+│   │   │   ├── async/
+│   │   │   ├── desktop/
+│   │   │   ├── edge/
+│   │   │   └── lambda/
+│   │   └── services/
+│   ├── services/
+│   │   ├── user/
+│   │   │   ├── client.ts
+│   │   │   └── server.ts
+│   │   └── message/
+│   ├── store/
+│   │   ├── agent/
+│   │   ├── chat/
+│   │   └── user/
+│   ├── styles/
+│   └── utils/
+└── package.json
 ```
 
 ## Architecture Map
 
-- Presentation: `src/features`, `src/components`, `src/layout` — UI composition, global providers
-- State: `src/store` — Zustand slices, selectors, middleware
-- Client Services: `src/services/<domain>/{client|server}.ts` — client: PGLite; server: tRPC bridge
-- API Routers: `src/app/(backend)/webapi` (REST), `src/app/(backend)/trpc/{edge|lambda|async|desktop|tools}`; Lambda router triggers Async router for long-running tasks (e.g., image)
-- Server Services: `src/server/services` (business logic), `src/server/modules` (infra adapters)
-- Data Access: `packages/database/src/{schemas,models,repositories}` — Schema (Drizzle), Model (CRUD), Repository (complex queries)
-- Integrations: `src/libs` — analytics, auth, trpc, logging, runtime helpers
+- UI Components: `src/components`, `src/features`
+- Global providers: `src/layout`
+- Zustand stores: `src/store`
+- Client Services: `src/services/`
+  - clientDB: `src/services/<domain>/client.ts`
+  - serverDB: `src/services/<domain>/server.ts`
+- API Routers:
+  - `src/app/(backend)/webapi` (REST)
+  - `src/server/routers/{edge|lambda|async|desktop|tools}` (tRPC)
+- Server:
+  - Services(can access serverDB): `src/server/services`
+  - Modules(can't access db): `src/server/modules` (Server only Third-party Service Module)
+- Database:
+  - Schema (Drizzle): `packages/database/src/schemas`
+  - Model (CRUD): `packages/database/src/models`
+  - Repository (bff-queries): `packages/database/src/repositories`
+- Third-party Integrations: `src/libs` — analytics, oidc etc.
 
 ## Data Flow Architecture
 
-### Unified Flow Pattern
-
-```
-UI Layer → State Management → Client Service → [Environment Branch] → Database
-   ↓              ↓               ↓                    ↓                ↓
- React         Zustand     Environment         Local/Remote        PGLite/
-Components      Store      Adaptation            Routing          PostgreSQL
-```
-
-### Environment-Specific Routing
-
-| Mode            | UI       | Service Route          | Database            |
-| --------------- | -------- | ---------------------- | ------------------- |
-| **Browser/PWA** | React    | Direct Model Access    | PGLite (Local)      |
-| **Server**      | React    | tRPC → Server Services | PostgreSQL (Remote) |
-| **Desktop**     | Electron | tRPC → Local Node.js   | PGLite/PostgreSQL\* |
-
-_\*Depends on cloud sync configuration_
-
-### Key Characteristics
-
-- **Type Safety**: End-to-end type safety via tRPC and Drizzle ORM
-- **Local/Remote Dual Mode**: PGLite enables user data ownership and local control
-
-## Quick Map
-
-- App Routes: `src/app` — UI routes (App Router) and backend routes under `(backend)`
-- Web API: `src/app/(backend)/webapi` — REST-like endpoints
-- tRPC Routers: `src/server/routers` — typed RPC endpoints by runtime
-- Client Services: `src/services` — environment-adaptive client-side business logic
-- Server Services: `src/server/services` — platform-agnostic business logic
-- Database: `packages/database` — schemas/models/repositories/migrations
-- State: `src/store` — Zustand stores and slices
-- Integrations: `src/libs` — analytics/auth/trpc/logging/runtime helpers
-- Tools: `src/tools` — built-in tool system
-
-## Common Tasks
-
-- Add Web API route: `src/app/(backend)/webapi/<module>/route.ts`
-- Add tRPC endpoint: `src/server/routers/{edge|lambda|desktop}/...`
-- Add client/server service: `src/services/<domain>/{client|server}.ts` (client: PGLite; server: tRPC)
-- Add server service: `src/server/services/<domain>`
-- Add a new model/provider: `src/config/modelProviders/<provider>.ts` + `packages/model-bank/src/aiModels/<provider>.ts` + `packages/model-runtime/src/<provider>/index.ts`
-- Add DB schema/model/repository: `packages/database/src/{schemas|models|repositories}`
-- Add Zustand slice: `src/store/<domain>/slices`
-
-## Env Modes
-
-- `NEXT_PUBLIC_CLIENT_DB`: selects client DB mode (e.g., `pglite`) vs server-backed
-- `NEXT_PUBLIC_IS_DESKTOP_APP`: enables desktop-specific routes and behavior
-- `NEXT_PUBLIC_SERVICE_MODE`: controls service routing preference (client/server)
-
-## Boundaries
-
-- Keep client logic in `src/services`; server-only logic stays in `src/server/services`
-- Don’t mix Web API (`webapi/`) with tRPC (`src/server/routers/`)
-- Place business UI under `src/features`, global reusable UI under `src/components`
+- **Browser/PWA**: React UI → Client Service → Direct Model Access → PGLite (Web WASM)
+- **Server**: React UI → Client Service → tRPC Lambda → Server Services → PostgreSQL (Remote)
+- **Desktop**:
+  - Cloud sync disabled: Electron UI → Client Service → tRPC Lambda → Local Server Services → PGLite (Node WASM)
+  - Cloud sync enabled: Electron UI → Client Service → tRPC Lambda → Cloud Server Services → PostgreSQL (Remote)

package/.cursor/rules/{rules-attach.mdc → rules-index.mdc}

@@ -4,20 +4,12 @@ globs:
 alwaysApply: true
 ---
 
-# 📋 Available Rules Index
+# Available project rules index
 
-The following rules are available via `read_file` from the `.cursor/rules/` directory:
-
-## General
-
-- `project-introduce.mdc` – Project description and tech stack
-- `cursor-rules.mdc` – Cursor rules authoring and optimization guide
-- `code-review.mdc` – How to code review
+All following rules are saved under `.cursor/rules/` directory:
 
 ## Backend
 
-- `backend-architecture.mdc` – Backend layer architecture and design guidelines
-- `define-database-model.mdc` – Database model definition guidelines
 - `drizzle-schema-style-guide.mdc` – Style guide for defining Drizzle ORM schemas
 
 ## Frontend
@@ -42,7 +34,6 @@ The following rules are available via `read_file` from the `.cursor/rules/` dire
 
 ## Debugging
 
-- `debug.mdc` – General debugging guide
 - `debug-usage.mdc` – Using the debug package and namespace conventions
 
 ## Testing

package/.cursor/rules/typescript.mdc

@@ -10,61 +10,11 @@ alwaysApply: false
 
 - avoid explicit type annotations when TypeScript can infer types.
 - avoid implicitly `any` variables; explicitly type when necessary (e.g., `let a: number` instead of `let a`).
-- use the most accurate type possible (e.g., prefer `Record<PropertyKey, unknown>` over `object`).
+- use the most accurate type possible (e.g., prefer `Record<PropertyKey, unknown>` over `object` and `any`).
 - prefer `interface` over `type` for object shapes (e.g., React component props). Keep `type` for unions, intersections, and utility types.
 - prefer `as const satisfies XyzInterface` over plain `as const` when suitable.
-- prefer `@ts-expect-error` over `@ts-ignore`
-- prefer `Record<string, any>` over `any`
-
-- **Avoid unnecessary null checks**: Before adding `xxx !== null`, `?.`, `??`, or `!.`, read the type definition to confirm the necessary. **Example:**
-
-  ```typescript
-  // ❌ Wrong: budget.spend and budget.maxBudget is number, not number | null
-  if (budget.spend !== null && budget.maxBudget !== null && budget.spend >= budget.maxBudget) {
-    // ...
-  }
-
-  // ✅ Right
-  if (budget.spend >= budget.maxBudget) {
-    // ...
-  }
-  ```
-
-- **Avoid redundant runtime checks**: Don't add runtime validation for conditions already guaranteed by types or previous checks. Trust the type system and calling contract. **Example:**
-
-  ```typescript
-  // ❌ Wrong: Adding impossible-to-fail checks
-  const due = await db.query.budgets.findMany({
-    where: and(isNotNull(budgets.budgetDuration)), // Already filtered non-null
-  });
-  const result = due.map(b => {
-    const nextReset = computeNextResetAt(b.budgetResetAt!, b.budgetDuration!);
-    if (!nextReset) { // This check is impossible to fail
-      throw new Error(`Unexpected null nextResetAt`);
-    }
-    return nextReset;
-  });
-
-  // ✅ Right: Trust the contract
-  const due = await db.query.budgets.findMany({
-    where: and(isNotNull(budgets.budgetDuration)),
-  });
-  const result = due.map(b => computeNextResetAt(b.budgetResetAt!, b.budgetDuration!));
-  ```
-
-- **Avoid meaningless null/undefined parameters**: Don't accept null/undefined for parameters that have no business meaning when null. Design strict function contracts. **Example:**
-
-  ```typescript
-  // ❌ Wrong: Function accepts meaningless null input
-  function computeNextResetAt(currentResetAt: Date, durationStr: string | null): Date | null {
-    if (!durationStr) return null; // Why accept null if it just returns null?
-  }
-
-  // ✅ Right: Strict contract, clear responsibility
-  function computeNextResetAt(currentResetAt: Date, durationStr: string): Date {
-    // Function has single clear purpose, caller ensures valid input
-  }
-  ```
+- prefer `@ts-expect-error` over `@ts-ignore` over `as any`
+- Avoid meaningless null/undefined parameters; design strict function contracts.
 
 ## Imports and Modules
 

package/.vscode/settings.json

@@ -11,6 +11,7 @@
     { "rule": "prettier/prettier", "severity": "off" },
     { "rule": "react/jsx-sort-props", "severity": "off" },
     { "rule": "sort-keys-fix/sort-keys-fix", "severity": "off" },
+    { "rule": "simple-import-sort/exports", "severity": "off" },
     { "rule": "typescript-sort-keys/interface", "severity": "off" }
   ],
   "eslint.validate": [
@@ -81,7 +82,7 @@
 
     "**/src/config/modelProviders/*.ts": "${filename} • provider",
     "**/packages/model-bank/src/aiModels/*.ts": "${filename} • model",
-    "**/packages/model-runtime/src/*/index.ts": "${dirname} • runtime",
+    "**/packages/model-runtime/src/providers/*/index.ts": "${dirname} • runtime",
 
     "**/src/server/services/*/index.ts": "${dirname} • server/service",
     "**/src/server/routers/lambda/*.ts": "${filename} • lambda",

package/AGENTS.md

@@ -44,21 +44,7 @@ The project follows a well-organized monorepo structure:
 
 #### TypeScript
 
-- Follow strict TypeScript practices for type safety and code quality
-- Use proper type annotations
 - Prefer interfaces over types for object shapes
-- Use generics for reusable components
-
-#### React Components
-
-- Use functional components with hooks
-
-#### Database Schema
-
-- Follow Drizzle ORM naming conventions
-- Use plural snake_case for table names
-- Implement proper foreign key relationships
-- Follow the schema style guide
 
 ### Testing Strategy
 
@@ -67,64 +53,57 @@ The project follows a well-organized monorepo structure:
 **Commands**:
 
 - Web: `bunx vitest run --silent='passed-only' '[file-path-pattern]'`
-- Packages: `cd packages/[package-name] && bunx vitest run --silent='passed-only' '[file-path-pattern]'`
+- Packages: `cd packages/[package-name] && bunx vitest run --silent='passed-only' '[file-path-pattern]'` (each subpackage contains its own vitest.config.mts)
 
 **Important Notes**:
 
 - Wrap file paths in single quotes to avoid shell expansion
-- Never run `bun run test` - this runs all tests and takes ~10 minutes
-- If a test fails twice, stop and ask for help
-- Always add tests for new code
+- Never run `bun run test` - this runs all tests and takes \~10 minutes
 
 ### Type Checking
 
 - Use `bun run type-check` to check for type errors
-- Ensure all TypeScript errors are resolved before committing
 
-### Internationalization
+### i18n
 
-- Add new keys to `src/locales/default/namespace.ts`
-- Translate at least `zh-CN` files for development preview
-- Use hierarchical nested objects, not flat keys
-- Don't run `pnpm i18n` manually (handled by CI)
+- **Keys**: Add to `src/locales/default/namespace.ts`
+- **Dev**: Translate `locales/zh-CN/namespace.json` locale file only for preview
+- DON'T run `pnpm i18n`, let CI auto handle it
 
-## Available Development Rules
+## Project Rules Index
 
-The project provides comprehensive rules in `.cursor/rules/` directory:
+All following rules are saved under `.cursor/rules/` directory:
 
-### Core Development
+### Backend
 
-- `backend-architecture.mdc` - Three-layer architecture and data flow
-- `react-component.mdc` - Component patterns and UI library usage
-- `drizzle-schema-style-guide.mdc` - Database schema conventions
-- `define-database-model.mdc` - Model templates and CRUD patterns
-- `i18n.mdc` - Internationalization workflow
+- `drizzle-schema-style-guide.mdc` – Style guide for defining Drizzle ORM schemas
 
-### State Management & UI
+### Frontend
 
-- `zustand-slice-organization.mdc` - Store organization patterns
-- `zustand-action-patterns.mdc` - Action implementation patterns
-- `packages/react-layout-kit.mdc` - Flex layout component usage
+- `react-component.mdc` – React component style guide and conventions
+- `i18n.mdc` – Internationalization guide using react-i18next
+- `typescript.mdc` – TypeScript code style guide
+- `packages/react-layout-kit.mdc` – Usage guide for react-layout-kit
 
-### Testing & Quality
+### State Management
 
-- `testing-guide/testing-guide.mdc` - Comprehensive testing strategy
-- `code-review.mdc` - Code review process and standards
+- `zustand-action-patterns.mdc` – Recommended patterns for organizing Zustand actions
+- `zustand-slice-organization.mdc` – Best practices for structuring Zustand slices
 
 ### Desktop (Electron)
 
-- `desktop-feature-implementation.mdc` - Main/renderer process patterns
-- `desktop-local-tools-implement.mdc` - Tool integration workflow
-- `desktop-menu-configuration.mdc` - Menu system configuration
-- `desktop-window-management.mdc` - Window management patterns
-- `desktop-controller-tests.mdc` - Controller testing guide
-
-## Best Practices
-
-- **Conservative for existing code, modern approaches for new features**
-- **Code Language**: Use Chinese for files with existing Chinese comments, American English for new files
-- Always add tests for new functionality
-- Follow the established patterns in the codebase
-- Use proper error handling and logging
-- Implement proper accessibility features
-- Consider internationalization from the start
+- `desktop-feature-implementation.mdc` – Implementing new Electron desktop features
+- `desktop-controller-tests.mdc` – Desktop controller unit testing guide
+- `desktop-local-tools-implement.mdc` – Workflow to add new desktop local tools
+- `desktop-menu-configuration.mdc` – Desktop menu configuration guide
+- `desktop-window-management.mdc` – Desktop window management guide
+
+### Debugging
+
+- `debug-usage.mdc` – Using the debug package and namespace conventions
+
+### Testing
+
+- `testing-guide/testing-guide.mdc` – Comprehensive testing guide for Vitest
+- `testing-guide/electron-ipc-test.mdc` – Electron IPC interface testing strategy
+- `testing-guide/db-model-test.mdc` – Database Model testing guide