css refactor

+Svelte specific
ai base
2026-02-19 18:24:36 +03:00 · 2026-02-19 17:47:24 +03:00 · 2026-02-19 17:43:45 +03:00 · 2026-02-19 16:05:59 +03:00 · 2026-02-19 13:33:20 +03:00 · 2026-02-19 13:33:10 +03:00
203 changed files with 79368 additions and 62233 deletions
--- a/specs/project_map.md
+++ b/specs/project_map.md
@@ -131,6 +131,74 @@
      - 📝 Clears authentication state and storage.
    - ƒ **setLoading** (`Function`)
      - 📝 Updates the loading state.
+- 📦 **debounce** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/lib/utils/debounce.js
+  - 🏗️ Layer: Unknown
+  - ƒ **debounce** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 🗄️ **taskDrawer** (`Store`) `[CRITICAL]`
+  - 📝 Manage Task Drawer visibility and resource-to-task mapping
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: resourceTaskMap always reflects current task associations
+- 📦 **taskDrawer** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/lib/stores/taskDrawer.js
+  - 🏗️ Layer: Unknown
+  - ƒ **openDrawerForTask** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **openDrawer** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **closeDrawer** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **updateResourceTask** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **getTaskForResource** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 🗄️ **sidebar** (`Store`)
+  - 📝 Manage sidebar visibility and navigation state
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: isExpanded state is always synced with localStorage
+- 📦 **sidebar** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/lib/stores/sidebar.js
+  - 🏗️ Layer: Unknown
+  - ƒ **toggleSidebar** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **setActiveItem** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **setMobileOpen** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **closeMobile** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **toggleMobileSidebar** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 🗄️ **activity** (`Store`)
+  - 📝 Track active task count for navbar indicator
+  - 🏗️ Layer: UI
+  - 🔗 DEPENDS_ON -> `WebSocket connection, taskDrawer store`
+- 📦 **frontend.src.lib.stores.__tests__.test_sidebar** (`Module`)
+  - 📝 Unit tests for sidebar store
+  - 🏗️ Layer: UI
+- 📦 **frontend.src.lib.stores.__tests__.sidebar** (`Module`)
+  - 📝 Unit tests for sidebar store
+  - 🏗️ Layer: Domain (Tests)
+  - ƒ **test_sidebar_initial_state** (`Function`)
+    - ƒ **test_toggleSidebar** (`Function`)
+      - ƒ **test_setActiveItem** (`Function`)
+- 📦 **frontend.src.lib.stores.__tests__.test_activity** (`Module`)
+  - 📝 Unit tests for activity store
+  - 🏗️ Layer: UI
+  - 🔗 DEPENDS_ON -> `frontend.src.lib.stores.taskDrawer`
+- 📦 **setupTests** (`Module`)
+  - 📝 Global test setup with mocks for SvelteKit modules
+  - 🏗️ Layer: UI
+- 📦 **frontend.src.lib.stores.__tests__.test_taskDrawer** (`Module`) `[CRITICAL]`
+  - 📝 Unit tests for task drawer store
+  - 🏗️ Layer: UI
+- 📦 **navigation** (`Mock`)
+  - 📝 Mock for $app/navigation in tests
+- 📦 **stores** (`Mock`)
+  - 📝 Mock for $app/stores in tests
+- 📦 **environment** (`Mock`)
+  - 📝 Mock for $app/environment in tests
 - 🧩 **Select** (`Component`) `[TRIVIAL]`
  - 📝 Standardized dropdown selection component.
  - 🏗️ Layer: Atom
@@ -172,12 +240,101 @@
    - 📝 Holds the current active locale string.
  - 🗄️ **t** (`Store`)
    - 📝 Derived store providing the translation dictionary.
- ƒ **selectPlugin** (`Function`)
-  - 📝 Handles plugin selection and navigation.
- ƒ **handleFormSubmit** (`Function`)
-  - 📝 Handles task creation from dynamic form submission.
+  - ƒ **_** (`Function`)
+    - 📝 Get translation by key path.
+- 🧩 **Sidebar** (`Component`) `[CRITICAL]`
+  - 📝 Persistent left sidebar with resource categories navigation
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: Always shows active category and item
+  - ⬅️ READS_FROM `app`
+  - ⬅️ READS_FROM `lib`
+  - ⬅️ READS_FROM `t`
+- 📦 **Sidebar** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/lib/components/layout/Sidebar.svelte
+  - 🏗️ Layer: Unknown
+  - ƒ **handleItemClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleCategoryToggle** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleSubItemClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleToggleClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleOverlayClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 🧩 **TopNavbar** (`Component`) `[CRITICAL]`
+  - 📝 Unified top navigation bar with Logo, Search, Activity, and User menu
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: Always visible on non-login pages
+  - ⚡ Events: activityClick
+  - ⬅️ READS_FROM `app`
+  - ⬅️ READS_FROM `lib`
+  - ⬅️ READS_FROM `sidebarStore`
+- 📦 **TopNavbar** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/lib/components/layout/TopNavbar.svelte
+  - 🏗️ Layer: Unknown
+  - ƒ **toggleUserMenu** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **closeUserMenu** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleLogout** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleActivityClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleSearchFocus** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleSearchBlur** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleDocumentClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleHamburgerClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 🧩 **Breadcrumbs** (`Component`)
+  - 📝 Display page hierarchy navigation
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: Always shows current page path
+  - 📥 Props: maxVisible: any
+  - ⬅️ READS_FROM `app`
+  - ⬅️ READS_FROM `lib`
+  - ⬅️ READS_FROM `page`
+- 📦 **Breadcrumbs** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/lib/components/layout/Breadcrumbs.svelte
+  - 🏗️ Layer: Unknown
+  - ƒ **getBreadcrumbs** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **formatBreadcrumbLabel** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 🧩 **TaskDrawer** (`Component`) `[CRITICAL]`
+  - 📝 Global task drawer for monitoring background operations
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: Drawer shows logs for active task or remains closed
+  - ⬅️ READS_FROM `lib`
+  - ⬅️ READS_FROM `taskDrawerStore`
+  - ➡️ WRITES_TO `taskDrawerStore`
+  - ƒ **loadRecentTasks** (`Function`)
+    - 📝 Load recent tasks for list mode display
+  - ƒ **selectTask** (`Function`)
+    - 📝 Select a task from list to view details
+  - ƒ **goBackToList** (`Function`)
+    - 📝 Return to task list view from task details
+- 📦 **TaskDrawer** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/lib/components/layout/TaskDrawer.svelte
+  - 🏗️ Layer: Unknown
+  - ƒ **handleClose** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleOverlayClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **connectWebSocket** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **disconnectWebSocket** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 📦 **HomePage** (`Page`) `[CRITICAL]`
+  - 📝 Redirect to Dashboard Hub as per UX requirements
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: Always redirects to /dashboards
 - ƒ **load** (`Function`)
  - 📝 Loads initial plugin data for the dashboard.
+- 📦 **layout** (`Module`)
 - 🧩 **TaskManagementPage** (`Component`)
  - 📝 Page for managing and monitoring tasks.
  - 🏗️ Layer: Page
@@ -192,6 +349,62 @@
    - 📝 Updates the selected task ID when a task is clicked.
  - ƒ **handleRunBackup** (`Function`)
    - 📝 Triggers a manual backup task for the selected environment.
+- 📦 **DatasetHub** (`Page`) `[CRITICAL]`
+  - 📝 Dataset Hub - Dedicated hub for datasets with mapping progress
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: Always shows environment selector and dataset grid
+- 📦 **+page** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/routes/datasets/+page.svelte
+  - 🏗️ Layer: Unknown
+  - ƒ **loadEnvironments** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **loadDatasets** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleEnvChange** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleSearch** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handlePageChange** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handlePageSizeChange** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **updateSelectionState** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleCheckboxChange** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleSelectAll** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleSelectVisible** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleAction** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleBulkMapColumns** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleBulkGenerateDocs** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleTaskStatusClick** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **getTaskStatusIcon** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **getMappingProgressClass** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 📦 **DatasetDetail** (`Page`) `[CRITICAL]`
+  - 📝 Dataset Detail View - Shows detailed dataset information with columns, SQL, and linked dashboards
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: Always shows dataset details when loaded
+- 📦 **+page** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/routes/datasets/[id]/+page.svelte
+  - 🏗️ Layer: Unknown
+  - ƒ **loadDatasetDetail** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **navigateToDashboard** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **goBack** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **getColumnTypeClass** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **getMappingProgress** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 🧩 **LoginPage** (`Component`)
  - 📝 Provides the user interface for local and ADFS authentication.
  - 🏗️ Layer: UI
@@ -202,6 +415,15 @@
    - 📝 Submits the local login form to the backend.
  - ƒ **handleADFSLogin** (`Function`)
    - 📝 Redirects the user to the ADFS login endpoint.
+- 📦 **StorageIndexPage** (`Page`) `[TRIVIAL]`
+  - 📝 Redirect to the backups page as the default storage view.
+  - 🏗️ Layer: Page
+  - 🔒 Invariant: Always redirects to /storage/backups.
+- 📦 **StorageReposPage** (`Page`)
+  - ƒ **fetchEnvironments** (`Function`)
+    - 📝 Fetches the list of available environments.
+  - ƒ **fetchDashboards** (`Function`)
+    - 📝 Fetches dashboards for a specific environment.
 - 🧩 **AdminRolesPage** (`Component`)
  - 📝 UI for managing system roles and their permissions.
  - 🏗️ Layer: Domain
@@ -317,20 +539,31 @@
  - 📝 Page for system diagnostics and debugging.
  - 🏗️ Layer: UI
  - ⬅️ READS_FROM `lib`
- ƒ **handleSaveGlobal** (`Function`)
-  - 📝 Saves global application settings.
- ƒ **handleSaveStorage** (`Function`)
-  - 📝 Saves storage-specific settings.
- ƒ **handleAddOrUpdateEnv** (`Function`)
-  - 📝 Adds a new environment or updates an existing one.
- ƒ **handleDeleteEnv** (`Function`)
-  - 📝 Deletes a Superset environment.
- ƒ **handleTestEnv** (`Function`)
-  - 📝 Tests the connection to a Superset environment.
- ƒ **editEnv** (`Function`)
-  - 📝 Populates the environment form for editing.
- ƒ **resetEnvForm** (`Function`)
-  - 📝 Resets the environment creation/edit form to default state.
+- 📦 **SettingsPage** (`Page`) `[CRITICAL]`
+  - 📝 Consolidated Settings Page - All settings in one place with tabbed navigation
+  - 🏗️ Layer: UI
+  - 🔒 Invariant: Always shows tabbed interface with all settings categories
+- 📦 **+page** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for frontend/src/routes/settings/+page.svelte
+  - 🏗️ Layer: Unknown
+  - ƒ **loadSettings** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleTabChange** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **getTabClass** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleSave** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleTestEnv** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **editEnv** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **resetEnvForm** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleAddOrUpdateEnv** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **handleDeleteEnv** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - ƒ **load** (`Function`)
  - 📝 Loads application settings and environment list.
 - 🧩 **ConnectionsSettingsPage** (`Component`)
@@ -474,24 +707,24 @@
    - 📝 Updates a mapping for a specific source database.
  - ƒ **getSuggestion** (`Function`)
    - 📝 Finds a suggestion for a source database.
- 🧩 **TaskLogViewer** (`Component`)
-  - 📝 Displays detailed logs for a specific task in a modal or inline using TaskLogPanel.
+- 🧩 **TaskLogViewer** (`Component`) `[CRITICAL]`
+  - 📝 Displays detailed logs for a specific task inline or in a modal using TaskLogPanel.
  - 🏗️ Layer: UI
-  - 📥 Props: show: any, inline: any, taskId: any, taskStatus: any
+  - 🔒 Invariant: Real-time logs are always appended without duplicates.
+  - 📥 Props: show: any, inline: any, taskId: any, taskStatus: any, realTimeLogs: any
  - ⚡ Events: close
  - ⬅️ READS_FROM `t`
-  - ➡️ WRITES_TO `t`
+  - 📦 **handleRealTimeLogs** (`Action`)
+    - 📝 Append real-time logs as they arrive from WebSocket, preventing duplicates */
  - ƒ **fetchLogs** (`Function`)
-    - 📝 Fetches logs for the current task.
-  - ƒ **close** (`Function`)
-    - 📝 Closes the log viewer modal.
-  - ƒ **onDestroy** (`Function`)
-    - 📝 Cleans up the polling interval.
+    - 📝 Fetches logs for the current task from API (polling fallback).
 - 📦 **TaskLogViewer** (`Module`) `[TRIVIAL]`
  - 📝 Auto-generated module for frontend/src/components/TaskLogViewer.svelte
  - 🏗️ Layer: Unknown
  - ƒ **handleFilterChange** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
+  - ƒ **handleRefresh** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 🧩 **Footer** (`Component`) `[TRIVIAL]`
  - 📝 Displays the application footer with copyright information.
  - 🏗️ Layer: UI
@@ -617,21 +850,25 @@
  - ⬅️ READS_FROM `app`
  - ⬅️ READS_FROM `auth`
 - 🧩 **TaskLogPanel** (`Component`)
-  - 📝 Scrolls the log container to the bottom.
+  - 📝 Component properties and state.
  - 🏗️ Layer: UI
  - 🔒 Invariant: Must always display logs in chronological order and respect auto-scroll preference.
-  - 📥 Props: taskId: any, logs: any, autoScroll: any
+  - 📥 Props: logs: any, autoScroll: any
  - ⚡ Events: filterChange
 - 📦 **TaskLogPanel** (`Module`) `[TRIVIAL]`
  - 📝 Auto-generated module for frontend/src/components/tasks/TaskLogPanel.svelte
  - 🏗️ Layer: Unknown
+  - ƒ **filterLogs** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
  - ƒ **handleFilterChange** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
  - ƒ **scrollToBottom** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
+  - ƒ **toggleAutoScroll** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 🧩 **LogFilterBar** (`Component`)
-  - 📝 UI component for filtering logs by level, source, and text search. -->
-  - 🏗️ Layer: UI -->
+  - 📝 Compact filter toolbar for logs — level, source, and text search in a single dense row.
+  - 🏗️ Layer: UI
  - 📥 Props: availableSources: any, selectedLevel: any, selectedSource: any, searchText: any
 - 📦 **LogFilterBar** (`Module`) `[TRIVIAL]`
  - 📝 Auto-generated module for frontend/src/components/tasks/LogFilterBar.svelte
@@ -645,14 +882,14 @@
  - ƒ **clearFilters** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
 - 🧩 **LogEntryRow** (`Component`)
-  - 📝 Optimized row rendering for a single log entry with color coding and progress bar support. -->
-  - 🏗️ Layer: UI -->
+  - 📝 Renders a single log entry with stacked layout optimized for narrow drawer panels.
+  - 🏗️ Layer: UI
  - 📥 Props: log: any, showSource: any
+  - ƒ **formatTime** (`Function`)
+    - 📝 Format ISO timestamp to HH:MM:SS */
 - 📦 **LogEntryRow** (`Module`) `[TRIVIAL]`
  - 📝 Auto-generated module for frontend/src/components/tasks/LogEntryRow.svelte
  - 🏗️ Layer: Unknown
-  - ƒ **formatTime** (`Function`) `[TRIVIAL]`
-    - 📝 Auto-detected function (orphan)
  - ƒ **getLevelClass** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
  - ƒ **getSourceClass** (`Function`) `[TRIVIAL]`
@@ -855,37 +1092,49 @@
    - 📝 Handles application shutdown tasks, such as stopping the scheduler.
  - ƒ **log_requests** (`Function`)
    - 📝 Middleware to log incoming HTTP requests and their response status.
+  - 📦 **api.include_routers** (`Action`)
+    - 📝 Registers all API routers with the FastAPI application.
+    - 🏗️ Layer: API
  - ƒ **websocket_endpoint** (`Function`) `[CRITICAL]`
    - 📝 Provides a WebSocket endpoint for real-time log streaming of a task with server-side filtering.
  - 📦 **StaticFiles** (`Mount`)
    - 📝 Mounts the frontend build directory to serve static assets.
-    - ƒ **serve_spa** (`Function`)
-      - 📝 Serves frontend static files or index.html for SPA routing.
    - ƒ **read_root** (`Function`)
      - 📝 A simple root endpoint to confirm that the API is running when frontend is missing.
  - ƒ **network_error_handler** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
  - ƒ **matches_filters** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
+  - ƒ **serve_spa** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 📦 **Dependencies** (`Module`)
-  - 📝 Manages the creation and provision of shared application dependencies, such as the PluginLoader and TaskManager, to avoid circular imports.
+  - 📝 Manages creation and provision of shared application dependencies, such as PluginLoader and TaskManager, to avoid circular imports.
  - 🏗️ Layer: Core
  - ƒ **get_config_manager** (`Function`)
-    - 📝 Dependency injector for the ConfigManager.
+    - 📝 Dependency injector for ConfigManager.
  - ƒ **get_plugin_loader** (`Function`)
-    - 📝 Dependency injector for the PluginLoader.
+    - 📝 Dependency injector for PluginLoader.
  - ƒ **get_task_manager** (`Function`)
-    - 📝 Dependency injector for the TaskManager.
+    - 📝 Dependency injector for TaskManager.
  - ƒ **get_scheduler_service** (`Function`)
-    - 📝 Dependency injector for the SchedulerService.
+    - 📝 Dependency injector for SchedulerService.
+  - ƒ **get_resource_service** (`Function`)
+    - 📝 Dependency injector for ResourceService.
+  - ƒ **get_mapping_service** (`Function`)
+    - 📝 Dependency injector for MappingService.
  - 📦 **oauth2_scheme** (`Variable`)
    - 📝 OAuth2 password bearer scheme for token extraction.
  - ƒ **get_current_user** (`Function`)
-    - 📝 Dependency for retrieving the currently authenticated user from a JWT.
+    - 📝 Dependency for retrieving currently authenticated user from a JWT.
  - ƒ **has_permission** (`Function`)
    - 📝 Dependency for checking if the current user has a specific permission.
  - ƒ **permission_checker** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
+- 📦 **test_dataset_dashboard_relations** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for backend/src/scripts/test_dataset_dashboard_relations.py
+  - 🏗️ Layer: Unknown
+  - ƒ **test_dashboard_dataset_relations** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 📦 **backend.src.scripts.seed_permissions** (`Module`)
  - 📝 Populates the auth database with initial system permissions.
  - 🏗️ Layer: Scripts
@@ -959,6 +1208,12 @@
      - 📝 Удаляет дашборд по его ID или slug.
    - ƒ **get_datasets** (`Function`)
      - 📝 Получает полный список датасетов, автоматически обрабатывая пагинацию.
+    - ƒ **get_datasets_summary** (`Function`)
+      - 📝 Fetches dataset metadata optimized for the Dataset Hub grid.
+    - ƒ **get_dataset_detail** (`Function`)
+      - 📝 Fetches detailed dataset information including columns and linked dashboards
+      - 🔗 CALLS -> `self.get_dataset`
+      - 🔗 CALLS -> `self.network.request (for related_objects)`
    - ƒ **get_dataset** (`Function`)
      - 📝 Получает информацию о конкретном датасете по его ID.
    - ƒ **update_dataset** (`Function`)
@@ -1237,6 +1492,27 @@
      - 📝 Retrieves a permission by resource and action.
    - ƒ **list_permissions** (`Function`)
      - 📝 Lists all available permissions.
+- 📦 **test_auth** (`Module`)
+  - 📝 Unit tests for authentication module
+  - 🏗️ Layer: Domain
+  - ƒ **db_session** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **auth_service** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **auth_repo** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_create_user** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_authenticate_user** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_create_session** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_role_permission_association** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_user_role_association** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_ad_group_mapping** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 📦 **backend.core.utils.fileio** (`Module`)
  - 📝 Предоставляет набор утилит для управления файловыми операциями, включая работу с временными файлами, архивами ZIP, файлами YAML и очистку директорий.
  - 🏗️ Layer: Infra
@@ -1326,6 +1602,8 @@
      - 📝 Получает общее количество элементов для пагинации.
    - ƒ **fetch_paginated_data** (`Function`)
      - 📝 Автоматически собирает данные со всех страниц пагинированного эндпоинта.
+  - ƒ **init_poolmanager** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 📦 **backend.src.core.utils.matching** (`Module`)
  - 📝 Provides utility functions for fuzzy matching database names.
  - 🏗️ Layer: Core
@@ -1353,6 +1631,25 @@
      - 🔗 CALLS -> `self.load_excel_mappings`
      - 🔗 CALLS -> `superset_client.get_dataset`
      - 🔗 CALLS -> `superset_client.update_dataset`
+- 📦 **test_logger** (`Module`)
+  - 📝 Unit tests for logger module
+  - 🏗️ Layer: Infra
+  - ƒ **test_belief_scope_logs_entry_action_exit_at_debug** (`Function`)
+    - 📝 Test that belief_scope generates [ID][Entry], [ID][Action], and [ID][Exit] logs at DEBUG level.
+  - ƒ **test_belief_scope_error_handling** (`Function`)
+    - 📝 Test that belief_scope logs Coherence:Failed on exception.
+  - ƒ **test_belief_scope_success_coherence** (`Function`)
+    - 📝 Test that belief_scope logs Coherence:OK on success.
+  - ƒ **test_belief_scope_not_visible_at_info** (`Function`)
+    - 📝 Test that belief_scope Entry/Exit/Coherence logs are NOT visible at INFO level.
+  - ƒ **test_task_log_level_default** (`Function`)
+    - 📝 Test that default task log level is INFO.
+  - ƒ **test_should_log_task_level** (`Function`)
+    - 📝 Test that should_log_task_level correctly filters log levels.
+  - ƒ **test_configure_logger_task_log_level** (`Function`)
+    - 📝 Test that configure_logger updates task_log_level.
+  - ƒ **test_enable_belief_state_flag** (`Function`)
+    - 📝 Test that enable_belief_state flag controls belief_scope logging.
 - 📦 **TaskLoggerModule** (`Module`) `[CRITICAL]`
  - 📝 Provides a dedicated logger for tasks with automatic source attribution.
  - 🏗️ Layer: Core
@@ -1551,6 +1848,40 @@
  - 📝 Test connection to an LLM provider.
 - ƒ **test_provider_config** (`Function`)
  - 📝 Test connection with a provided configuration (not yet saved).
+- 📦 **backend.src.api.routes.datasets** (`Module`)
+  - 📝 API endpoints for the Dataset Hub - listing datasets with mapping progress
+  - 🏗️ Layer: API
+  - 🔒 Invariant: All dataset responses include last_task metadata
+  - 🔗 DEPENDS_ON -> `backend.src.dependencies`
+  - 🔗 DEPENDS_ON -> `backend.src.services.resource_service`
+  - 🔗 DEPENDS_ON -> `backend.src.core.superset_client`
+  - 📦 **MappedFields** (`DataClass`)
+  - 📦 **LastTask** (`DataClass`)
+  - 📦 **DatasetItem** (`DataClass`)
+  - 📦 **LinkedDashboard** (`DataClass`)
+  - 📦 **DatasetColumn** (`DataClass`)
+  - 📦 **DatasetDetailResponse** (`DataClass`)
+  - 📦 **DatasetsResponse** (`DataClass`)
+  - 📦 **TaskResponse** (`DataClass`)
+  - ƒ **get_dataset_ids** (`Function`)
+    - 📝 Fetch list of all dataset IDs from a specific environment (without pagination)
+    - 🔗 CALLS -> `ResourceService.get_datasets_with_status`
+  - ƒ **get_datasets** (`Function`)
+    - 📝 Fetch list of datasets from a specific environment with mapping progress
+    - 🔗 CALLS -> `ResourceService.get_datasets_with_status`
+  - 📦 **MapColumnsRequest** (`DataClass`)
+  - ƒ **map_columns** (`Function`)
+    - 📝 Trigger bulk column mapping for datasets
+    - 🔗 DISPATCHES -> `MapperPlugin`
+    - 🔗 CALLS -> `task_manager.create_task`
+  - 📦 **GenerateDocsRequest** (`DataClass`)
+  - ƒ **generate_docs** (`Function`)
+    - 📝 Trigger bulk documentation generation for datasets
+    - 🔗 DISPATCHES -> `LLMAnalysisPlugin`
+    - 🔗 CALLS -> `task_manager.create_task`
+  - ƒ **get_dataset_detail** (`Function`)
+    - 📝 Get detailed dataset information including columns and linked dashboards
+    - 🔗 CALLS -> `SupersetClient.get_dataset_detail`
 - 📦 **backend.src.api.routes.git** (`Module`)
  - 📝 Provides FastAPI endpoints for Git integration operations.
  - 🏗️ Layer: API
@@ -1615,10 +1946,13 @@
  - 📦 **DatabaseResponse** (`DataClass`)
  - ƒ **get_environments** (`Function`)
    - 📝 List all configured environments.
+    - 🏗️ Layer: API
  - ƒ **update_environment_schedule** (`Function`)
    - 📝 Update backup schedule for an environment.
+    - 🏗️ Layer: API
  - ƒ **get_environment_databases** (`Function`)
    - 📝 Fetch the list of databases from a specific environment.
+    - 🏗️ Layer: API
 - 📦 **backend.src.api.routes.migration** (`Module`)
  - 📝 API endpoints for migration operations.
  - 🏗️ Layer: API
@@ -1679,6 +2013,11 @@
    - 📝 Retrieves current logging configuration.
  - ƒ **update_logging_config** (`Function`)
    - 📝 Updates logging configuration.
+  - ℂ **ConsolidatedSettingsResponse** (`Class`)
+  - ƒ **get_consolidated_settings** (`Function`)
+    - 📝 Retrieves all settings categories in a single call
+  - ƒ **update_consolidated_settings** (`Function`)
+    - 📝 Bulk update application settings from the consolidated view.
 - 📦 **backend.src.api.routes.admin** (`Module`)
  - 📝 Admin API endpoints for user and role management.
  - 🏗️ Layer: API
@@ -1760,6 +2099,11 @@
  - ƒ **download_file** (`Function`)
    - 📝 Retrieve a file for download.
    - 🔗 CALLS -> `StoragePlugin.get_file_path`
+- 📦 **__init__** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for backend/src/api/routes/__init__.py
+  - 🏗️ Layer: Unknown
+  - ƒ **__getattr__** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 📦 **TasksRouter** (`Module`)
  - 📝 Defines the FastAPI router for task-related endpoints, allowing clients to create, list, and get the status of tasks.
  - 🏗️ Layer: UI (API)
@@ -1781,6 +2125,60 @@
    - 📝 Resume a task that is awaiting input (e.g., passwords).
  - ƒ **clear_tasks** (`Function`)
    - 📝 Clear tasks matching the status filter.
+- 📦 **backend.src.api.routes.dashboards** (`Module`)
+  - 📝 API endpoints for the Dashboard Hub - listing dashboards with Git and task status
+  - 🏗️ Layer: API
+  - 🔒 Invariant: All dashboard responses include git_status and last_task metadata
+  - 🔗 DEPENDS_ON -> `backend.src.dependencies`
+  - 🔗 DEPENDS_ON -> `backend.src.services.resource_service`
+  - 🔗 DEPENDS_ON -> `backend.src.core.superset_client`
+  - 📦 **GitStatus** (`DataClass`)
+  - 📦 **LastTask** (`DataClass`)
+  - 📦 **DashboardItem** (`DataClass`)
+  - 📦 **DashboardsResponse** (`DataClass`)
+  - ƒ **get_dashboards** (`Function`)
+    - 📝 Fetch list of dashboards from a specific environment with Git status and last task status
+    - 🔗 CALLS -> `ResourceService.get_dashboards_with_status`
+  - 📦 **MigrateRequest** (`DataClass`)
+  - 📦 **TaskResponse** (`DataClass`)
+  - ƒ **migrate_dashboards** (`Function`)
+    - 📝 Trigger bulk migration of dashboards from source to target environment
+    - 🔗 DISPATCHES -> `MigrationPlugin`
+    - 🔗 CALLS -> `task_manager.create_task`
+  - 📦 **BackupRequest** (`DataClass`)
+  - ƒ **backup_dashboards** (`Function`)
+    - 📝 Trigger bulk backup of dashboards with optional cron schedule
+    - 🔗 DISPATCHES -> `BackupPlugin`
+    - 🔗 CALLS -> `task_manager.create_task`
+  - 📦 **DatabaseMapping** (`DataClass`)
+  - 📦 **DatabaseMappingsResponse** (`DataClass`)
+  - ƒ **get_database_mappings** (`Function`)
+    - 📝 Get database mapping suggestions between source and target environments
+    - 🔗 CALLS -> `MappingService.get_suggestions`
+- 📦 **backend.src.api.routes.__tests__.test_dashboards** (`Module`)
+  - 📝 Unit tests for Dashboards API endpoints
+  - 🏗️ Layer: API
+  - ƒ **test_get_dashboards_success** (`Function`)
+  - ƒ **test_get_dashboards_with_search** (`Function`)
+  - ƒ **test_get_dashboards_env_not_found** (`Function`)
+  - ƒ **test_get_dashboards_invalid_pagination** (`Function`)
+  - ƒ **test_migrate_dashboards_success** (`Function`)
+  - ƒ **test_migrate_dashboards_no_ids** (`Function`)
+  - ƒ **test_backup_dashboards_success** (`Function`)
+  - ƒ **test_get_database_mappings_success** (`Function`)
+  - ƒ **mock_get_dashboards** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **mock_get_dashboards** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+- 📦 **backend.src.api.routes.__tests__.test_datasets** (`Module`)
+  - 📝 Unit tests for Datasets API endpoints
+  - 🏗️ Layer: API
+  - ƒ **test_get_datasets_success** (`Function`)
+  - ƒ **test_get_datasets_env_not_found** (`Function`)
+  - ƒ **test_get_datasets_invalid_pagination** (`Function`)
+  - ƒ **test_map_columns_success** (`Function`)
+  - ƒ **test_map_columns_invalid_source_type** (`Function`)
+  - ƒ **test_generate_docs_success** (`Function`)
 - 📦 **backend.src.models.llm** (`Module`)
  - 📝 SQLAlchemy models for LLM provider configuration and validation results.
  - 🏗️ Layer: Domain
@@ -1865,6 +2263,42 @@
  - ℂ **ADGroupMapping** (`Class`)
    - 📝 Maps an Active Directory group to a local System Role.
    - 🔗 DEPENDS_ON -> `Role`
+- 📦 **test_models** (`Module`) `[TRIVIAL]`
+  - 📝 Unit tests for data models
+  - 🏗️ Layer: Domain
+  - ƒ **test_environment_model** (`Function`)
+    - 📝 Tests that Environment model correctly stores values.
+- 📦 **backend.src.services.resource_service** (`Module`)
+  - 📝 Shared service for fetching resource data with Git status and task status
+  - 🏗️ Layer: Service
+  - 🔒 Invariant: All resources include metadata about their current state
+  - 🔗 DEPENDS_ON -> `backend.src.core.superset_client`
+  - 🔗 DEPENDS_ON -> `backend.src.core.task_manager`
+  - 🔗 DEPENDS_ON -> `backend.src.services.git_service`
+  - ℂ **ResourceService** (`Class`)
+    - 📝 Provides centralized access to resource data with enhanced metadata
+    - ƒ **__init__** (`Function`)
+      - 📝 Initialize the resource service with dependencies
+    - ƒ **get_dashboards_with_status** (`Function`)
+      - 📝 Fetch dashboards from environment with Git status and last task status
+      - 🔗 CALLS -> `SupersetClient.get_dashboards_summary`
+      - 🔗 CALLS -> `self._get_git_status_for_dashboard`
+      - 🔗 CALLS -> `self._get_last_task_for_resource`
+    - ƒ **get_datasets_with_status** (`Function`)
+      - 📝 Fetch datasets from environment with mapping progress and last task status
+      - 🔗 CALLS -> `SupersetClient.get_datasets_summary`
+      - 🔗 CALLS -> `self._get_last_task_for_resource`
+    - ƒ **get_activity_summary** (`Function`)
+      - 📝 Get summary of active and recent tasks for the activity indicator
+    - ƒ **_get_git_status_for_dashboard** (`Function`)
+      - 📝 Get Git sync status for a dashboard
+      - 🔗 CALLS -> `GitService.get_repo`
+    - ƒ **_get_last_task_for_resource** (`Function`)
+      - 📝 Get the most recent task for a specific resource
+    - ƒ **_extract_resource_name_from_task** (`Function`)
+      - 📝 Extract resource name from task params
+    - ƒ **_extract_resource_type_from_task** (`Function`)
+      - 📝 Extract resource type from task params
 - 📦 **backend.src.services.llm_provider** (`Module`)
  - 📝 Service for managing LLM provider configurations with encrypted API keys.
  - 🏗️ Layer: Domain
@@ -1903,6 +2337,11 @@
    - 📝 Auto-detected function (orphan)
  - ƒ **__init__** (`Function`) `[TRIVIAL]`
    - 📝 Auto-detected function (orphan)
+- 📦 **backend.src.services** (`Module`)
+  - 📝 Package initialization for services module
+  - 🏗️ Layer: Core
+  - ƒ **__getattr__** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 📦 **backend.src.services.auth_service** (`Module`)
  - 📝 Orchestrates authentication business logic.
  - 🏗️ Layer: Service
@@ -1965,6 +2404,15 @@
      - 📝 Helper to get an initialized SupersetClient for an environment.
    - ƒ **get_suggestions** (`Function`)
      - 📝 Fetches databases from both environments and returns fuzzy matching suggestions.
+- 📦 **backend.src.services.__tests__.test_resource_service** (`Module`)
+  - 📝 Unit tests for ResourceService
+  - 🏗️ Layer: Service
+  - ƒ **test_get_dashboards_with_status** (`Function`)
+  - ƒ **test_get_datasets_with_status** (`Function`)
+  - ƒ **test_get_activity_summary** (`Function`)
+  - ƒ **test_get_git_status_for_dashboard_no_repo** (`Function`)
+  - ƒ **test_get_last_task_for_resource** (`Function`)
+  - ƒ **test_extract_resource_name_from_task** (`Function`)
 - 📦 **BackupPlugin** (`Module`)
  - 📝 A plugin that provides functionality to back up Superset dashboards.
  - 🏗️ Layer: App
@@ -2247,6 +2695,34 @@
    - 📝 Auto-detected function (orphan)
 - ƒ **test_environment_model** (`Function`)
  - 📝 Tests that Environment model correctly stores values.
+- 📦 **backend.tests.test_dashboards_api** (`Module`)
+  - 📝 Contract-driven tests for Dashboard Hub API
+  - 🏗️ Layer: Domain (Tests)
+  - ƒ **test_get_dashboards_success** (`Function`)
+  - ƒ **test_get_dashboards_env_not_found** (`Function`)
+- 📦 **test_dashboards_api** (`Test`)
+  - 📝 Verify GET /api/dashboards contract compliance
+- 📦 **test_datasets_api** (`Test`)
+  - 📝 Verify GET /api/datasets contract compliance
+- 📦 **test_resource_hubs** (`Module`) `[TRIVIAL]`
+  - 📝 Auto-generated module for backend/tests/test_resource_hubs.py
+  - 🏗️ Layer: Unknown
+  - ƒ **mock_deps** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_get_dashboards_success** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_get_dashboards_not_found** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_get_dashboards_search** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_get_datasets_success** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_get_datasets_not_found** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_get_datasets_search** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
+  - ƒ **test_get_datasets_service_failure** (`Function`) `[TRIVIAL]`
+    - 📝 Auto-detected function (orphan)
 - 📦 **test_task_logger** (`Module`)
  - 📝 Unit tests for TaskLogger and TaskContext.
  - 🏗️ Layer: Test
--- a/.ai/ROOT.md
+++ b/.ai/ROOT.md
@@ -0,0 +1,37 @@
+# [DEF:Project_Knowledge_Map:Root]
+# @TIER: CRITICAL
+# @PURPOSE: Global navigation map for AI-Agent (GRACE Knowledge Graph).
+# @LAST_UPDATE: 2026-02-19
+
+## 1. SYSTEM STANDARDS (Rules of the Game)
+Strict policies and formatting rules.
+*   **Constitution:** High-level architectural and business invariants.
+    *   Ref: `.ai/standards/constitution.md` -> `[DEF:Std:Constitution]`
+*   **Architecture:** Service boundaries and tech stack decisions.
+    *   Ref: `.ai/standards/architecture.md` -> `[DEF:Std:Architecture]`
+*   **Plugin Design:** Rules for building and integrating Plugins.
+    *   Ref: `.ai/standards/plugin_design.md` -> `[DEF:Std:Plugin]`
+*   **API Design:** Rules for FastAPI endpoints and Pydantic models.
+    *   Ref: `.ai/standards/api_design.md` -> `[DEF:Std:API_FastAPI]`
+*   **UI Design:** SvelteKit and Tailwind CSS component standards.
+    *   Ref: `.ai/standards/ui_design.md` -> `[DEF:Std:UI_Svelte]`
+*   **Semantic Mapping:** Using `[DEF:]` and belief scopes.
+    *   Ref: `.ai/standards/semantics.md` -> `[DEF:Std:Semantics]`
+
+## 2. FEW-SHOT EXAMPLES (Patterns)
+Use these for code generation (Style Transfer).
+*   **FastAPI Route:** Reference implementation of a task-based route.
+    *   Ref: `.ai/shots/backend_route.py` -> `[DEF:Shot:FastAPI_Route]`
+*   **Svelte Component:** Reference implementation of a sidebar/navigation component.
+    *   Ref: `.ai/shots/frontend_component.svelte` -> `[DEF:Shot:Svelte_Component]`
+*   **Plugin Module:** Reference implementation of a task plugin.
+    *   Ref: `.ai/shots/plugin_example.py` -> `[DEF:Shot:Plugin_Example]`
+
+## 3. DOMAIN MAP (Modules)
+*   **Project Map:** `.ai/PROJECT_MAP.md` -> `[DEF:Project_Map]`
+*   **Backend Core:** `backend/src/core` -> `[DEF:Module:Backend_Core]`
+*   **Backend API:** `backend/src/api` -> `[DEF:Module:Backend_API]`
+*   **Frontend Lib:** `frontend/src/lib` -> `[DEF:Module:Frontend_Lib]`
+*   **Specifications:** `specs/` -> `[DEF:Module:Specs]`
+
+# [/DEF:Project_Knowledge_Map]
--- a/.ai/shots/backend_route.py
+++ b/.ai/shots/backend_route.py
@@ -0,0 +1,57 @@
+# [DEF:Shot:FastAPI_Route:Example]
+# @PURPOSE: Reference implementation of a task-based route using GRACE-Poly.
+# @RELATION: IMPLEMENTS -> [DEF:Std:API_FastAPI]
+
+from typing import List, Dict, Any, Optional
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+from ...core.logger import belief_scope
+from ...core.task_manager import TaskManager, Task
+from ...core.config_manager import ConfigManager
+from ...dependencies import get_task_manager, get_config_manager, has_permission, get_current_user
+
+router = APIRouter()
+
+class CreateTaskRequest(BaseModel):
+    plugin_id: str
+    params: Dict[str, Any]
+
+@router.post("/tasks", response_model=Task, status_code=status.HTTP_201_CREATED)
+# [DEF:create_task:Function]
+# @PURPOSE: Create and start a new task using TaskManager. Non-blocking.
+# @PARAM: request (CreateTaskRequest) - Plugin and params.
+# @PARAM: task_manager (TaskManager) - Async task executor.
+# @PARAM: config (ConfigManager) - Centralized configuration.
+# @PRE: plugin_id must exist; config must be initialized.
+# @POST: A new task is spawned; Task ID returned immediately.
+async def create_task(
+    request: CreateTaskRequest,
+    task_manager: TaskManager = Depends(get_task_manager),
+    config: ConfigManager = Depends(get_config_manager),
+    current_user = Depends(get_current_user)
+):
+    # RBAC: Dynamic permission check
+    has_permission(f"plugin:{request.plugin_id}", "EXECUTE")(current_user)
+    
+    with belief_scope("create_task"):
+        try:
+            # 1. Action: Resolve setting using ConfigManager (Example)
+            timeout = config.get("TASKS_DEFAULT_TIMEOUT", 3600)
+
+            # 2. Action: Spawn async task via TaskManager
+            # @RELATION: CALLS -> task_manager.create_task
+            task = await task_manager.create_task(
+                plugin_id=request.plugin_id,
+                params={**request.params, "timeout": timeout}
+            )
+            return task
+        except Exception as e:
+            # Evaluation: Proper error mapping and logging
+            # @UX_STATE: Error feedback to frontend
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, 
+                detail=f"Task creation failed: {str(e)}"
+            )
+# [/DEF:create_task:Function]
+
+# [/DEF:Shot:FastAPI_Route]
--- a/.ai/shots/frontend_component.svelte
+++ b/.ai/shots/frontend_component.svelte
@@ -0,0 +1,63 @@
+<!-- [DEF:Shot:Svelte_Component:Example] -->
+# @PURPOSE: Reference implementation of a task-spawning component using Constitution rules.
+# @RELATION: IMPLEMENTS -> [DEF:Std:UI_Svelte]
+
+<script>
+  /**
+   * @TIER: STANDARD
+   * @PURPOSE: Action button to spawn a new task.
+   * @LAYER: UI
+   * @SEMANTICS: Task, Creation, Button
+   * @RELATION: CALLS -> postApi
+   * 
+   * @UX_STATE: Idle -> Button enabled with primary color.
+   * @UX_STATE: Loading -> Button disabled with spinner while postApi resolves.
+   * @UX_FEEDBACK: toast.success on completion; toast.error on failure.
+   * @UX_TEST: Idle -> {click: spawnTask, expected: loading state then success}
+   */
+  import { postApi } from "$lib/api.js";
+  import { t } from "$lib/i18n";
+  import { toast } from "$lib/stores/toast";
+
+  export let plugin_id = "";
+  export let params = {};
+
+  let isLoading = false;
+
+  async def spawnTask() {
+    isLoading = true;
+    try {
+      // 1. Action: Constitution Rule - MUST use postApi wrapper
+      const response = await postApi("/api/tasks", {
+        plugin_id,
+        params
+      });
+
+      // 2. Feedback: UX state management
+      if (response.task_id) {
+        toast.success($t.tasks.spawned_success);
+      }
+    } catch (error) {
+      // 3. Recovery: Evaluation & UI reporting
+      toast.error(`${$t.errors.task_failed}: ${error.message}`);
+    } finally {
+      isLoading = false;
+    }
+  }
+</script>
+
+<button 
+  on:click={spawnTask}
+  disabled={isLoading}
+  class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-lg flex items-center gap-2"
+>
+  {#if isLoading}
+    <span class="animate-spin text-sm">🌀</span>
+  {/if}
+  <span>{$t.actions.start_task}</span>
+</button>
+
+<style>
+  /* Local styles minimized as per Constitution Rule III */
+</style>
+<!-- [/DEF:Shot:Svelte_Component] -->
--- a/.ai/shots/plugin_example.py
+++ b/.ai/shots/plugin_example.py
@@ -0,0 +1,67 @@
+# [DEF:Shot:Plugin_Example:Example]
+# @PURPOSE: Reference implementation of a plugin following GRACE standards.
+# @RELATION: IMPLEMENTS -> [DEF:Std:Plugin]
+
+from typing import Dict, Any, Optional
+from ..core.plugin_base import PluginBase
+from ..core.task_manager.context import TaskContext
+
+class ExamplePlugin(PluginBase):
+    @property
+    def id(self) -> str:
+        return "example-plugin"
+
+    @property
+    def name(self) -> str:
+        return "Example Plugin"
+
+    @property
+    def description(self) -> str:
+        return "A simple plugin that demonstrates structured logging and progress tracking."
+
+    @property
+    def version(self) -> str:
+        return "1.0.0"
+
+    # [DEF:get_schema:Function]
+    # @PURPOSE: Defines input validation schema.
+    def get_schema(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "title": "Message",
+                    "description": "A message to log.",
+                    "default": "Hello, GRACE!",
+                }
+            },
+            "required": ["message"],
+        }
+    # [/DEF:get_schema:Function]
+
+    # [DEF:execute:Function]
+    # @PURPOSE: Core plugin logic with structured logging and progress reporting.
+    # @PARAM: params (Dict) - Validated input parameters.
+    # @PARAM: context (TaskContext) - Execution context with logging and progress tools.
+    async def execute(self, params: Dict[str, Any], context: Optional[TaskContext] = None):
+        message = params["message"]
+        
+        # 1. Action: Structured Logging with Source Attribution
+        if context:
+            log = context.logger.with_source("example_plugin")
+            log.info(f"Starting execution with message: {message}")
+
+            # 2. Action: Progress Reporting
+            log.progress("Processing step 1...", percent=25)
+            # Simulating some async work...
+            # await some_async_op()
+
+            log.progress("Processing step 2...", percent=75)
+            log.info("Execution completed successfully.")
+        else:
+            # Fallback for manual/standalone execution
+            print(f"Standalone execution: {message}")
+    # [/DEF:execute:Function]
+
+# [/DEF:Shot:Plugin_Example]
--- a/.ai/standards/api_design.md
+++ b/.ai/standards/api_design.md
@@ -0,0 +1,47 @@
+# [DEF:Std:API_FastAPI:Standard]
+# @TIER: CRITICAL
+# @PURPOSE: Unification of all FastAPI endpoints following GRACE-Poly.
+# @LAYER: UI (API)
+# @INVARIANT: All non-trivial route logic must be wrapped in `belief_scope`.
+# @INVARIANT: Every module and function MUST have `[DEF:]` anchors and metadata.
+
+## 1. ROUTE MODULE DEFINITION
+Every API route file must start with a module definition header:
+```python
+# [DEF:ModuleName:Module]
+# @TIER: [CRITICAL | STANDARD | TRIVIAL]
+# @SEMANTICS: list, of, keywords
+# @PURPOSE: High-level purpose of the module.
+# @LAYER: UI (API)
+# @RELATION: DEPENDS_ON -> [OtherModule]
+```
+
+## 2. FUNCTION DEFINITION & CONTRACT
+Every endpoint handler must be decorated with `[DEF:]` and explicit metadata before the implementation:
+```python
+@router.post("/endpoint", response_model=ModelOut)
+# [DEF:function_name:Function]
+# @PURPOSE: What it does (brief, high-entropy).
+# @PARAM: param_name (Type) - Description.
+# @PRE: Conditions before execution (e.g., auth, existence).
+# @POST: Expected state after execution.
+# @RETURN: What it returns.
+async def function_name(...):
+    with belief_scope("function_name"):
+        # Implementation
+        pass
+# [/DEF:function_name:Function]
+```
+
+## 3. DEPENDENCY INJECTION & CORE SERVICES
+*   **Auth:** `Depends(get_current_user)` for authentication.
+*   **Perms:** `Depends(has_permission("resource", "ACTION"))` for RBAC.
+*   **Config:** Use `Depends(get_config_manager)` for settings. Hardcoding is FORBIDDEN.
+*   **Tasks:** Long-running operations must be executed via `TaskManager`. API routes should return Task ID and be non-blocking.
+
+## 4. ERROR HANDLING
+*   Raise `HTTPException` from the router layer.
+*   Use `try-except` blocks within `belief_scope` to ensure proper error logging and classification.
+*   Do not leak internal implementation details in error responses.
+
+# [/DEF:Std:API_FastAPI]
--- a/.ai/standards/architecture.md
+++ b/.ai/standards/architecture.md
@@ -0,0 +1,25 @@
+# [DEF:Std:Architecture:Standard]
+# @TIER: CRITICAL
+# @PURPOSE: Core architectural decisions and service boundaries.
+# @LAYER: Infra
+# @INVARIANT: ss-tools MUST remain a standalone service (Orchestrator).
+# @INVARIANT: Backend: FastAPI, Frontend: SvelteKit.
+
+## 1. ORCHESTRATOR VS INSTANCE
+*   **Role:** ss-tools is a "Manager of Managers". It sits ABOVE Superset environments.
+*   **Isolation:** Do not integrate directly into Superset as a plugin to maintain multi-environment management capability.
+*   **Tech Stack:** 
+    *   Backend: Python 3.9+ with FastAPI (Asynchronous logic).
+    *   Frontend: SvelteKit + Tailwind CSS (Reactive UX).
+
+## 2. COMPONENT BOUNDARIES
+*   **Plugins:** All business logic must be encapsulated in Plugins (`backend/src/plugins/`).
+*   **TaskManager:** All long-running operations MUST be handled by the TaskManager.
+*   **Security:** Independent RBAC system managed in `auth.db`.
+
+## 3. INTEGRATION STRATEGY
+*   **Superset API:** Communication via REST API.
+*   **Database:** Local SQLite for metadata (`tasks.db`, `auth.db`, `migrations.db`).
+*   **Filesystem:** Local storage for backups and git repositories.
+
+# [/DEF:Std:Architecture]
--- a/.ai/standards/constitution.md
+++ b/.ai/standards/constitution.md
@@ -0,0 +1,36 @@
+# [DEF:Std:Constitution:Standard]
+# @TIER: CRITICAL
+# @PURPOSE: Supreme Law of the Repository. High-level architectural and business invariants.
+# @VERSION: 2.3.0
+# @LAST_UPDATE: 2026-02-19
+# @INVARIANT: Any deviation from this Constitution constitutes a build failure.
+
+## 1. CORE PRINCIPLES
+
+### I. Semantic Protocol Compliance
+*   **Ref:** `[DEF:Std:Semantics]` (formerly `semantic_protocol.md`)
+*   **Law:** All code must adhere to the Axioms (Meaning First, Contract First, etc.).
+*   **Compliance:** Strict matching of Anchors (`[DEF]`), Tags (`@KEY`), and structures is mandatory.
+
+### II. Modular Plugin Architecture
+*   **Pattern:** Everything is a Plugin inheriting from `PluginBase`.
+*   **Centralized Config:** Use `ConfigManager` via `get_config_manager()`. Hardcoding is FORBIDDEN.
+
+### III. Unified Frontend Experience
+*   **Styling:** Tailwind CSS First. Minimize scoped `<style>`.
+*   **i18n:** All user-facing text must be in `src/lib/i18n`.
+*   **API:** Use `requestApi` / `fetchApi` wrappers. Native `fetch` is FORBIDDEN.
+
+### IV. Security & RBAC
+*   **Permissions:** Every Plugin must define unique permission strings (e.g., `plugin:name:execute`).
+*   **Auth:** Mandatory registration in `auth.db`.
+
+### V. Independent Testability
+*   **Requirement:** Every feature must define "Independent Tests" for isolated verification.
+
+### VI. Asynchronous Execution
+*   **TaskManager:** Long-running operations must be async tasks.
+*   **Non-Blocking:** API endpoints return Task ID immediately.
+*   **Observability:** Real-time updates via WebSocket.
+
+# [/DEF:Std:Constitution]
--- a/.ai/standards/plugin_design.md
+++ b/.ai/standards/plugin_design.md
@@ -0,0 +1,32 @@
+# [DEF:Std:Plugin:Standard]
+# @TIER: CRITICAL
+# @PURPOSE: Standards for building and integrating Plugins.
+# @LAYER: Domain (Plugin)
+# @INVARIANT: All plugins MUST inherit from `PluginBase`.
+# @INVARIANT: All plugins MUST be located in `backend/src/plugins/`.
+
+## 1. PLUGIN CONTRACT
+Every plugin must implement the following properties and methods:
+*   `id`: Unique string (e.g., `"my-plugin"`).
+*   `name`: Human-readable name.
+*   `description`: Brief purpose.
+*   `version`: Semantic version.
+*   `get_schema()`: Returns JSON schema for input validation.
+*   `execute(params: Dict[str, Any], context: TaskContext)`: Core async logic.
+
+## 2. STRUCTURED LOGGING (TASKCONTEXT)
+Plugins MUST use `TaskContext` for logging to ensure proper source attribution:
+*   **Source Attribution:** Use `context.logger.with_source("src_name")` for specific operations (e.g., `"superset_api"`, `"git"`, `"llm"`).
+*   **Levels:**
+    *   `DEBUG`: Detailed diagnostics (API responses).
+    *   `INFO`: Operational milestones (start/end).
+    *   `WARNING`: Recoverable issues.
+    *   `ERROR`: Failures stopping execution.
+*   **Progress:** Use `context.logger.progress("msg", percent=XX)` for long-running tasks.
+
+## 3. BEST PRACTICES
+1. **Asynchronous Execution:** Always use `async/await` for I/O operations.
+2. **Schema Validation:** Ensure the `get_schema()` precisely matches the `execute()` input expectations.
+3. **Isolation:** Plugins should be self-contained and not depend on other plugins directly. Use core services (`ConfigManager`, `TaskManager`) via dependency injection or the provided `context`.
+
+# [/DEF:Std:Plugin]
--- a/.ai/standards/semantics.md
+++ b/.ai/standards/semantics.md
@@ -0,0 +1,97 @@
+### **SYSTEM STANDARD: GRACE-Poly (UX Edition)**
+
+ЗАДАЧА: Генерация кода (Python/Svelte).
+РЕЖИМ: Строгий. Детерминированный. Без болтовни.
+
+#### I. ЗАКОН (АКСИОМЫ)
+1. Смысл первичен. Код вторичен.
+2. Контракт (@PRE/@POST) — источник истины.
+**3. UX — это логика, а не декор. Состояния интерфейса — часть контракта.**
+4. Структура `[DEF]...[/DEF]` — нерушима.
+5. Архитектура в Header — неизменяема.
+6. Сложность фрактала ограничена: модуль < 300 строк.
+
+#### II. СИНТАКСИС (ЖЕСТКИЙ ФОРМАТ)
+ЯКОРЬ (Контейнер):
+  Начало: `# [DEF:id:Type]` (Python) | `<!-- [DEF:id:Type] -->` (Svelte)
+  Конец:  `# [/DEF:id:Type]` (Python) | `<!-- [/DEF:id:Type] -->` (Svelte) (ОБЯЗАТЕЛЬНО для аккумуляции)
+  Типы:   Module, Class, Function, Component, Store.
+
+ТЕГ (Метаданные):
+  Вид: `# @KEY: Value` (внутри DEF, до кода).
+
+ГРАФ (Связи):
+  Вид: `# @RELATION: PREDICATE -> TARGET_ID`
+  Предикаты: DEPENDS_ON, CALLS, INHERITS, IMPLEMENTS, DISPATCHES, **BINDS_TO**.
+
+#### III. СТРУКТУРА ФАЙЛА
+1. HEADER (Всегда первый):
+   [DEF:filename:Module]
+   @TIER: [CRITICAL|STANDARD|TRIVIAL] (Дефолт: STANDARD)
+   @SEMANTICS: [keywords]
+   @PURPOSE: [Главная цель]
+   @LAYER: [Domain/UI/Infra]
+   @RELATION: [Зависимости]
+   @INVARIANT: [Незыблемое правило]
+   
+2. BODY: Импорты -> Реализация.
+3. FOOTER: [/DEF:filename]
+
+#### IV. КОНТРАКТ (DBC & UX)
+Расположение: Внутри [DEF], ПЕРЕД кодом.
+Стиль Python: Комментарии `# @TAG`.
+Стиль Svelte: JSDoc `/** @tag */` внутри `<script>`.
+
+**Базовые Теги:**
+  @PURPOSE: Суть (High Entropy).
+  @PRE: Входные условия.
+  @POST: Гарантии выхода.
+  @SIDE_EFFECT: Мутации, IO.
+  
+**UX Теги (Svelte/Frontend):**
+  **@UX_STATE:** `[StateName] -> Визуальное поведение` (Idle, Loading, Error).
+  **@UX_FEEDBACK:** Реакция системы (Toast, Shake, Red Border).
+  **@UX_RECOVERY:** Механизм исправления ошибки пользователем (Retry, Clear Input).
+  
+**UX Testing Tags (для Tester Agent):**
+  **@UX_TEST:** Спецификация теста для UX состояния.
+  Формат: `@UX_TEST: [state] -> {action, expected}`
+  Пример: `@UX_TEST: Idle -> {click: toggle, expected: isExpanded=true}`
+  
+Правило: Не используй `assert` в коде, используй `if/raise` или `guards`.
+
+#### V. АДАПТАЦИЯ (TIERS)
+Определяется тегом `@TIER` в Header.
+
+1. **CRITICAL** (Core/Security/**Complex UI**):
+   - Требование: Полный контракт (включая **все @UX теги**), Граф, Инварианты, Строгие Логи.
+   - **@TEST_DATA**: Обязательные эталонные данные для тестирования. Формат:
+     ```
+     @TEST_DATA: fixture_name -> {JSON_PATH} | {INLINE_DATA}
+     ```
+     Примеры:
+     - `@TEST_DATA: valid_user -> {./fixtures/users.json#valid}`
+     - `@TEST_DATA: empty_state -> {"dashboards": [], "total": 0}`
+   - Tester Agent **ОБЯЗАН** использовать @TEST_DATA при написании тестов для CRITICAL модулей.
+2. **STANDARD** (BizLogic/**Forms**):
+   - Требование: Базовый контракт (@PURPOSE, @UX_STATE), Логи, @RELATION.
+   - @TEST_DATA: Рекомендуется для Complex Forms.
+3. **TRIVIAL** (DTO/**Atoms**):
+   - Требование: Только Якоря [DEF] и @PURPOSE.
+
+#### VI. ЛОГИРОВАНИЕ (BELIEF STATE & TASK LOGS)
+Цель: Трассировка для самокоррекции и пользовательский мониторинг.
+Python: 
+  - Системные логи: Context Manager `with belief_scope("ID"):`.
+  - Логи задач: `context.logger.info("msg", source="component")`.
+Svelte: `console.log("[ID][STATE] Msg")`.
+Состояния: Entry -> Action -> Coherence:OK / Failed -> Exit.
+Инвариант: Каждый лог задачи должен иметь атрибут `source` для фильтрации.
+
+#### VII. АЛГОРИТМ ГЕНЕРАЦИИ
+1. АНАЛИЗ. Оцени TIER, слой и UX-требования.
+2. КАРКАС. Создай `[DEF]`, Header и Контракты.
+3. РЕАЛИЗАЦИЯ. Напиши логику, удовлетворяющую Контракту (и UX-состояниям).
+4. ЗАМЫКАНИЕ. Закрой все `[/DEF]`.
+
+ЕСЛИ ошибка или противоречие -> СТОП. Выведи `[COHERENCE_CHECK_FAILED]`.
--- a/.ai/standards/ui_design.md
+++ b/.ai/standards/ui_design.md
@@ -0,0 +1,75 @@
+# [DEF:Std:UI_Svelte:Standard]
+# @TIER: CRITICAL
+# @PURPOSE: Unification of all Svelte components following GRACE-Poly (UX Edition).
+# @LAYER: UI
+# @INVARIANT: Every component MUST have `<!-- [DEF:] -->` anchors and UX tags.
+# @INVARIANT: Use Tailwind CSS for all styling (no custom CSS without justification).
+
+## 1. UX PHILOSOPHY: RESOURCE-CENTRIC & SVELTE 5
+*   **Version:** Project uses Svelte 5.
+*   **Runes:** Use Svelte 5 Runes for reactivity: `$state()`, `$derived()`, `$effect()`, `$props()`. Traditional `let` (for reactivity) and `export let` (for props) are DEPRECATED in favor of runes.
+*   **Definition:** Navigation and actions revolve around Resources.
+*   **Traceability:** Every action must be linked to a Task ID with visible logs in the Task Drawer.
+
+## 2. COMPONENT ARCHITECTURE: GLOBAL TASK DRAWER
+*   **Role:** A single, persistent slide-out panel (`GlobalTaskDrawer.svelte`) in `+layout.svelte`.
+*   **Triggering:** Opens automatically when a task starts or when a user clicks a status badge.
+*   **Interaction:** Interactive elements (Password prompts, Mapping tables) MUST be rendered INSIDE the Drawer, not as center-screen modals.
+
+## 3. COMPONENT STRUCTURE & CORE RULES
+*   **Styling:** Tailwind CSS utility classes are MANDATORY. Minimize scoped `<style>`.
+*   **Localization:** All user-facing text must use `$t` from `src/lib/i18n`.
+*   **API Calls:** Use `requestApi` / `fetchApi` wrappers. Native `fetch` is FORBIDDEN.
+*   **Anchors:** Every component MUST have `<!-- [DEF:] -->` anchors and UX tags.
+
+## 2. COMPONENT TEMPLATE
+Each Svelte file must follow this structure:
+```html
+<!-- [DEF:ComponentName:Component] -->
+<script>
+  /**
+   * @TIER: [CRITICAL | STANDARD | TRIVIAL]
+   * @PURPOSE: Brief description of the component purpose.
+   * @LAYER: UI
+   * @SEMANTICS: list, of, keywords
+   * @RELATION: DEPENDS_ON -> [OtherComponent|Store]
+   * 
+   * @UX_STATE: [StateName] -> Visual behavior description.
+   * @UX_FEEDBACK: System reaction (e.g., Toast, Shake).
+   * @UX_RECOVERY: Error recovery mechanism.
+   * @UX_TEST: [state] -> {action, expected}
+   */
+  import { ... } from "...";
+  
+  // Exports (Props)
+  export let prop_name = "...";
+  
+  // Logic
+</script>
+
+<!-- HTML Template -->
+<div class="...">
+  ...
+</div>
+
+<style>
+  /* Optional: Local styles using @apply only */
+</style>
+<!-- [/DEF:ComponentName:Component] -->
+```
+
+## 2. STATE MANAGEMENT & STORES
+*   **Subscription:** Use `$` prefix for reactive store access (e.g., `$sidebarStore`).
+*   **Data Flow:** Mark store interactions in `[DEF:]` metadata:
+    *   `# @RELATION: BINDS_TO -> store_id`
+
+## 3. UI/UX BEST PRACTICES
+*   **Transitions:** Use Svelte built-in transitions for UI state changes.
+*   **Feedback:** Always provide visual feedback for async actions (Loading spinners, skeleton loaders).
+*   **Modularity:** Break down components into "Atoms" (Trivial) and "Orchestrators" (Critical).
+
+## 4. ACCESSIBILITY (A11Y)
+*   Ensure proper ARIA roles and keyboard navigation for interactive elements.
+*   Use semantic HTML tags (`<nav>`, `<header>`, `<main>`, `<footer>`).
+
+# [/DEF:Std:UI_Svelte]
--- a/.gitignore
+++ b/.gitignore
@@ -10,8 +10,6 @@ dist/
 downloads/
 eggs/
 .eggs/
-lib/
-lib64/
 parts/
 sdist/
 var/
@@ -69,3 +67,4 @@ backend/tasks.db
 backend/logs
 backend/auth.db
 semantics/reports
+backend/tasks.db
--- a/.kilocode/rules/specify-rules.md
+++ b/.kilocode/rules/specify-rules.md
@@ -2,6 +2,12 @@

 Auto-generated from all feature plans. Last updated: 2025-12-19

+## Knowledge Graph (GRACE)
+**CRITICAL**: This project uses a GRACE Knowledge Graph for context. Always load the root map first:
+- **Root Map**: `.ai/ROOT.md` -> `[DEF:Project_Knowledge_Map:Root]`
+- **Project Map**: `.ai/PROJECT_MAP.md` -> `[DEF:Project_Map]`
+- **Standards**: Read `.ai/standards/` for architecture and style rules.
+
 ## Active Technologies
 - Python 3.9+, Node.js 18+ + `uvicorn`, `npm`, `bash` (003-project-launch-script)
 - Python 3.9+, Node.js 18+ + SvelteKit, FastAPI, Tailwind CSS (inferred from existing frontend) (004-integrate-svelte-kit)
@@ -33,6 +39,8 @@ Auto-generated from all feature plans. Last updated: 2025-12-19
 - N/A (UI reorganization and API integration) (015-frontend-nav-redesign)
 - SQLite (`auth.db`) for Users, Roles, Permissions, and Mappings. (016-multi-user-auth)
 - SQLite (existing `tasks.db` for results, `auth.db` for permissions, `mappings.db` or new `plugins.db` for provider config/metadata) (017-llm-analysis-plugin)
+- Python 3.9+ (Backend), Node.js 18+ (Frontend) + FastAPI, SvelteKit, Tailwind CSS, SQLAlchemy, WebSocket (existing) (019-superset-ux-redesign)
+- SQLite (tasks.db, auth.db, migrations.db) - no new database tables required (019-superset-ux-redesign)

 - Python 3.9+ (Backend), Node.js 18+ (Frontend Build) (001-plugin-arch-svelte-ui)

@@ -53,9 +61,9 @@ cd src; pytest; ruff check .
 Python 3.9+ (Backend), Node.js 18+ (Frontend Build): Follow standard conventions

 ## Recent Changes
+- 019-superset-ux-redesign: Added Python 3.9+ (Backend), Node.js 18+ (Frontend) + FastAPI, SvelteKit, Tailwind CSS, SQLAlchemy, WebSocket (existing)
 - 017-llm-analysis-plugin: Added Python 3.9+ (Backend), Node.js 18+ (Frontend)
 - 016-multi-user-auth: Added Python 3.9+ (Backend), Node.js 18+ (Frontend)
- 015-frontend-nav-redesign: Added Python 3.9+ (Backend), Node.js 18+ (Frontend) + FastAPI (Backend), SvelteKit + Tailwind CSS (Frontend)


 <!-- MANUAL ADDITIONS START -->
--- a/.kilocode/workflows/read_semantic.md
+++ b/.kilocode/workflows/read_semantic.md
@@ -1,4 +1,4 @@
 ---
 description: USE SEMANTIC
 ---
-Прочитай semantic_protocol.md. ОБЯЗАТЕЛЬНО используй его при разработке
+Прочитай .ai/standards/semantics.md. ОБЯЗАТЕЛЬНО используй его при разработке
--- a/.kilocode/workflows/speckit.analyze.md
+++ b/.kilocode/workflows/speckit.analyze.md
@@ -18,7 +18,7 @@ Identify inconsistencies, duplications, ambiguities, and underspecified items ac

 **STRICTLY READ-ONLY**: Do **not** modify any files. Output a structured analysis report. Offer an optional remediation plan (user must explicitly approve before any follow-up editing commands would be invoked manually).

-**Constitution Authority**: The project constitution (`.specify/memory/constitution.md`) is **non-negotiable** within this analysis scope. Constitution conflicts are automatically CRITICAL and require adjustment of the spec, plan, or tasks—not dilution, reinterpretation, or silent ignoring of the principle. If a principle itself needs to change, that must occur in a separate, explicit constitution update outside `/speckit.analyze`.
+**Constitution Authority**: The project constitution (`.ai/standards/constitution.md`) is **non-negotiable** within this analysis scope. Constitution conflicts are automatically CRITICAL and require adjustment of the spec, plan, or tasks—not dilution, reinterpretation, or silent ignoring of the principle. If a principle itself needs to change, that must occur in a separate, explicit constitution update outside `/speckit.analyze`.

 ## Execution Steps

@@ -62,8 +62,8 @@ Load only the minimal necessary context from each artifact:

 **From constitution:**

- Load `.specify/memory/constitution.md` for principle validation
- Load `semantic_protocol.md` for technical standard validation
+- Load `.ai/standards/constitution.md` for principle validation
+- Load `.ai/standards/semantics.md` for technical standard validation

 ### 3. Build Semantic Models

--- a/.kilocode/workflows/speckit.constitution.md
+++ b/.kilocode/workflows/speckit.constitution.md
@@ -16,11 +16,11 @@ You **MUST** consider the user input before proceeding (if not empty).

 ## Outline

-You are updating the project constitution at `.specify/memory/constitution.md`. This file is a TEMPLATE containing placeholder tokens in square brackets (e.g. `[PROJECT_NAME]`, `[PRINCIPLE_1_NAME]`). Your job is to (a) collect/derive concrete values, (b) fill the template precisely, and (c) propagate any amendments across dependent artifacts.
+You are updating the project constitution at `.ai/standards/constitution.md`. This file is a TEMPLATE containing placeholder tokens in square brackets (e.g. `[PROJECT_NAME]`, `[PRINCIPLE_1_NAME]`). Your job is to (a) collect/derive concrete values, (b) fill the template precisely, and (c) propagate any amendments across dependent artifacts.

 Follow this execution flow:

-1. Load the existing constitution template at `.specify/memory/constitution.md`.
+1. Load the existing constitution template at `.ai/standards/constitution.md`.
   - Identify every placeholder token of the form `[ALL_CAPS_IDENTIFIER]`.
   **IMPORTANT**: The user might require less or more principles than the ones used in the template. If a number is specified, respect that - follow the general template. You will update the doc accordingly.

@@ -61,7 +61,7 @@ Follow this execution flow:
   - Dates ISO format YYYY-MM-DD.
   - Principles are declarative, testable, and free of vague language ("should" → replace with MUST/SHOULD rationale where appropriate).

-7. Write the completed constitution back to `.specify/memory/constitution.md` (overwrite).
+7. Write the completed constitution back to `.ai/standards/constitution.md` (overwrite).

 8. Output a final summary to the user with:
   - New version and bump rationale.
@@ -79,4 +79,4 @@ If the user supplies partial updates (e.g., only one principle revision), still

 If critical info missing (e.g., ratification date truly unknown), insert `TODO(<FIELD_NAME>): explanation` and include in the Sync Impact Report under deferred items.

-Do not create a new template; always operate on the existing `.specify/memory/constitution.md` file.
+Do not create a new template; always operate on the existing `.ai/standards/constitution.md` file.
--- a/.kilocode/workflows/speckit.fix.md
+++ b/.kilocode/workflows/speckit.fix.md
@@ -0,0 +1,199 @@
+---
+
+description: Fix failing tests and implementation issues based on test reports
+
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Goal
+
+Analyze test failure reports, identify root causes, and fix implementation issues while preserving semantic protocol compliance.
+
+## Operating Constraints
+
+1. **USE CODER MODE**: Always switch to `coder` mode for code fixes
+2. **SEMANTIC PROTOCOL**: Never remove semantic annotations ([DEF], @TAGS). Only update code logic.
+3. **TEST DATA**: If tests use @TEST_DATA fixtures, preserve them when fixing
+4. **NO DELETION**: Never delete existing tests or semantic annotations
+5. **REPORT FIRST**: Always write a fix report before making changes
+
+## Execution Steps
+
+### 1. Load Test Report
+
+**Required**: Test report file path (e.g., `specs/<feature>/tests/reports/2026-02-19-report.md`)
+
+**Parse the report for**:
+- Failed test cases
+- Error messages
+- Stack traces
+- Expected vs actual behavior
+- Affected modules/files
+
+### 2. Analyze Root Causes
+
+For each failed test:
+
+1. **Read the test file** to understand what it's testing
+2. **Read the implementation file** to find the bug
+3. **Check semantic protocol compliance**:
+   - Does the implementation have correct [DEF] anchors?
+   - Are @TAGS (@PRE, @POST, @UX_STATE, etc.) present?
+   - Does the code match the TIER requirements?
+4. **Identify the fix**:
+   - Logic error in implementation
+   - Missing error handling
+   - Incorrect API usage
+   - State management issue
+
+### 3. Write Fix Report
+
+Create a structured fix report:
+
+```markdown
+# Fix Report: [FEATURE]
+
+**Date**: [YYYY-MM-DD]
+**Report**: [Test Report Path]
+**Fixer**: Coder Agent
+
+## Summary
+
+- Total Failed Tests: [X]
+- Total Fixed: [X]
+- Total Skipped: [X]
+
+## Failed Tests Analysis
+
+### Test: [Test Name]
+
+**File**: `path/to/test.py`
+**Error**: [Error message]
+
+**Root Cause**: [Explanation of why test failed]
+
+**Fix Required**: [Description of fix]
+
+**Status**: [Pending/In Progress/Completed]
+
+## Fixes Applied
+
+### Fix 1: [Description]
+
+**Affected File**: `path/to/file.py`
+**Test Affected**: `[Test Name]`
+
+**Changes**:
+```diff
+<<<<<<< SEARCH
+[Original Code]
+=======
+[Fixed Code]
+>>>>>>> REPLACE
+```
+
+**Verification**: [How to verify fix works]
+
+**Semantic Integrity**: [Confirmed annotations preserved]
+
+## Next Steps
+
+- [ ] Run tests to verify fix: `cd backend && .venv/bin/python3 -m pytest`
+- [ ] Check for related failing tests
+- [ ] Update test documentation if needed
+```
+
+### 4. Apply Fixes (in Coder Mode)
+
+Switch to `coder` mode and apply fixes:
+
+1. **Read the implementation file** to get exact content
+2. **Apply the fix** using apply_diff
+3. **Preserve all semantic annotations**:
+   - Keep [DEF:...] and [/DEF:...] anchors
+   - Keep all @TAGS (@PURPOSE, @LAYER, @TIER, @RELATION, @PRE, @POST, @UX_STATE, @UX_FEEDBACK, @UX_RECOVERY)
+4. **Only update code logic** to fix the bug
+5. **Run tests** to verify the fix
+
+### 5. Verification
+
+After applying fixes:
+
+1. **Run tests**:
+   ```bash
+   cd backend && .venv/bin/python3 -m pytest -v
+   ```
+   or
+   ```bash
+   cd frontend && npm run test
+   ```
+
+2. **Check test results**:
+   - Failed tests should now pass
+   - No new tests should fail
+   - Coverage should not decrease
+
+3. **Update fix report** with results:
+   - Mark fixes as completed
+   - Add verification steps
+   - Note any remaining issues
+
+## Output
+
+Generate final fix report:
+
+```markdown
+# Fix Report: [FEATURE] - COMPLETED
+
+**Date**: [YYYY-MM-DD]
+**Report**: [Test Report Path]
+**Fixer**: Coder Agent
+
+## Summary
+
+- Total Failed Tests: [X]
+- Total Fixed: [X] ✅
+- Total Skipped: [X]
+
+## Fixes Applied
+
+### Fix 1: [Description] ✅
+
+**Affected File**: `path/to/file.py`
+**Test Affected**: `[Test Name]`
+
+**Changes**: [Summary of changes]
+
+**Verification**: All tests pass ✅
+
+**Semantic Integrity**: Preserved ✅
+
+## Test Results
+
+```
+[Full test output showing all passing tests]
+```
+
+## Recommendations
+
+- [ ] Monitor for similar issues
+- [ ] Update documentation if needed
+- [ ] Consider adding more tests for edge cases
+
+## Related Files
+
+- Test Report: [path]
+- Implementation: [path]
+- Test File: [path]
+```
+
+## Context for Fixing
+
+$ARGUMENTS
--- a/.kilocode/workflows/speckit.implement.md
+++ b/.kilocode/workflows/speckit.implement.md
@@ -51,7 +51,7 @@ You **MUST** consider the user input before proceeding (if not empty).
     - Automatically proceed to step 3

 3. Load and analyze the implementation context:
-   - **REQUIRED**: Read `semantic_protocol.md` for strict coding standards and contract requirements
+   - **REQUIRED**: Read `.ai/standards/semantics.md` for strict coding standards and contract requirements
   - **REQUIRED**: Read tasks.md for the complete task list and execution plan
   - **REQUIRED**: Read plan.md for tech stack, architecture, and file structure
   - **IF EXISTS**: Read data-model.md for entities and relationships
@@ -117,7 +117,8 @@ You **MUST** consider the user input before proceeding (if not empty).
   - **Validation checkpoints**: Verify each phase completion before proceeding

 7. Implementation execution rules:
-   - **Strict Adherence**: Apply `semantic_protocol.md` rules - every file must start with [DEF] header, include @TIER, and define contracts
+   - **Strict Adherence**: Apply `.ai/standards/semantics.md` rules - every file must start with [DEF] header, include @TIER, and define contracts.
+   - **CRITICAL Contracts**: If a task description contains a contract summary (e.g., `CRITICAL: PRE: ..., POST: ...`), these constraints are **MANDATORY** and must be strictly implemented in the code using guards/assertions (if applicable per protocol).
   - **Setup first**: Initialize project structure, dependencies, configuration
   - **Tests before code**: If you need to write tests for contracts, entities, and integration scenarios
   - **Core development**: Implement models, services, CLI commands, endpoints
--- a/.kilocode/workflows/speckit.plan.md
+++ b/.kilocode/workflows/speckit.plan.md
@@ -22,7 +22,7 @@ You **MUST** consider the user input before proceeding (if not empty).

 1. **Setup**: Run `.specify/scripts/bash/setup-plan.sh --json` from repo root and parse JSON for FEATURE_SPEC, IMPL_PLAN, SPECS_DIR, BRANCH. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").

-2. **Load context**: Read FEATURE_SPEC, `ux_reference.md`, `semantic_protocol.md` and `.specify/memory/constitution.md`. Load IMPL_PLAN template (already copied).
+2. **Load context**: Read `.ai/ROOT.md` and `.ai/PROJECT_MAP.md` to understand the project structure and navigation. Then read required standards: `.ai/standards/constitution.md` and `.ai/standards/semantics.md`. Load IMPL_PLAN template.

 3. **Execute plan workflow**: Follow the structure in IMPL_PLAN template to:
   - Fill Technical Context (mark unknowns as "NEEDS CLARIFICATION")
@@ -66,25 +66,30 @@ You **MUST** consider the user input before proceeding (if not empty).

 0. **Validate Design against UX Reference**:
   - Check if the proposed architecture supports the latency, interactivity, and flow defined in `ux_reference.md`.
-   - **CRITICAL**: If the technical plan requires compromising the UX defined in `ux_reference.md` (e.g. "We can't do real-time validation because X"), you **MUST STOP** and warn the user. Do not proceed until resolved.
+   - **Linkage**: Ensure key UI states from `ux_reference.md` map to Component Contracts (`@UX_STATE`).
+   - **CRITICAL**: If the technical plan compromises the UX (e.g. "We can't do real-time validation"), you **MUST STOP** and warn the user.

 1. **Extract entities from feature spec** → `data-model.md`:
-   - Entity name, fields, relationships
-   - Validation rules from requirements
-   - State transitions if applicable
+   - Entity name, fields, relationships, validation rules.

-2. **Define Module & Function Contracts (Semantic Protocol)**:
-   - **MANDATORY**: For every new module, define the [DEF] Header and Module-level Contract (@TIER, @PURPOSE, @INVARIANT) as per `semantic_protocol.md`.
-   - **REQUIRED**: Define Function Contracts (@PRE, @POST) for critical logic.
-   - Output specific contract definitions to `contracts/modules.md` or append to `data-model.md` to guide implementation.
-   - Ensure strict adherence to `semantic_protocol.md` syntax.
+2. **Design & Verify Contracts (Semantic Protocol)**:
+   - **Drafting**: Define [DEF] Headers and Contracts for all new modules based on `.ai/standards/semantics.md`.
+   - **TIER Classification**: Explicitly assign `@TIER: [CRITICAL|STANDARD|TRIVIAL]` to each module.
+   - **CRITICAL Requirements**: For all CRITICAL modules, define full `@PRE`, `@POST`, and (if UI) `@UX_STATE` contracts.
+   - **Self-Review**:
+     - *Completeness*: Do `@PRE`/`@POST` cover edge cases identified in Research?
+     - *Connectivity*: Do `@RELATION` tags form a coherent graph?
+     - *Compliance*: Does syntax match `[DEF:id:Type]` exactly?
+   - **Output**: Write verified contracts to `contracts/modules.md`.

-3. **Generate API contracts** from functional requirements:
-   - For each user action → endpoint
-   - Use standard REST/GraphQL patterns
-   - Output OpenAPI/GraphQL schema to `/contracts/`
+3. **Simulate Contract Usage**:
+   - Trace one key user scenario through the defined contracts to ensure data flow continuity.
+   - If a contract interface mismatch is found, fix it immediately.

-3. **Agent context update**:
+4. **Generate API contracts**:
+   - Output OpenAPI/GraphQL schema to `/contracts/` for backend-frontend sync.
+
+5. **Agent context update**:
   - Run `.specify/scripts/bash/update-agent-context.sh kilocode`
   - These scripts detect which AI agent is in use
   - Update the appropriate agent-specific context file
--- a/.kilocode/workflows/speckit.tasks.md
+++ b/.kilocode/workflows/speckit.tasks.md
@@ -119,7 +119,10 @@ Every task MUST strictly follow this format:
     - If tests requested: Tests specific to that story
   - Mark story dependencies (most stories should be independent)

-2. **From Contracts**:
+2. **From Contracts (CRITICAL TIER)**:
+   - Identify components marked as `@TIER: CRITICAL` in `contracts/modules.md`.
+   - For these components, **MUST** append the summary of `@PRE`, `@POST`, and `@UX_STATE` contracts directly to the task description.
+   - Example: `- [ ] T005 [P] [US1] Implement Auth (CRITICAL: PRE: token exists, POST: returns User) in src/auth.py`
   - Map each contract/endpoint → to the user story it serves
   - If tests requested: Each contract → contract test task [P] before implementation in that story's phase

--- a/.kilocode/workflows/speckit.test.md
+++ b/.kilocode/workflows/speckit.test.md
@@ -1,10 +1,7 @@
 ---
-description: Run semantic validation and functional tests for a specific feature, module, or file.
-handoffs: 
-  - label: Fix Implementation
-    agent: speckit.implement
-    prompt: Fix the issues found during testing...
-    send: true
+
+description: Generate tests, manage test documentation, and ensure maximum code coverage
+
 ---

 ## User Input
@@ -13,54 +10,169 @@ handoffs:
 $ARGUMENTS
 ```

-**Input format:** Can be a file path, a directory, or a feature name.
+You **MUST** consider the user input before proceeding (if not empty).

-## Outline
+## Goal

-1. **Context Analysis**:
-   - Determine the target scope (Backend vs Frontend vs Full Feature).
-   - Read `semantic_protocol.md` to load validation rules.
+Execute full testing cycle: analyze code for testable modules, write tests with proper coverage, maintain test documentation, and ensure no test duplication or deletion.

-2. **Phase 1: Semantic Static Analysis (The "Compiler" Check)**
-   - **Command:** Use `grep` or script to verify Protocol compliance before running code.
-   - **Check:**
-     - Does the file start with `[DEF:...]` header?
-     - Are `@TIER` and `@PURPOSE` defined?
-     - Are imports located *after* the contracts?
-     - Do functions marked "Critical" have `@PRE`/`@POST` tags?
-   - **Action:** If this phase fails, **STOP** and report "Semantic Compilation Failed". Do not run runtime tests.
+## Operating Constraints

-3. **Phase 2: Environment Prep**
-   - Detect project type:
-     - **Python**: Check if `.venv` is active.
-     - **Svelte**: Check if `node_modules` exists.
-   - **Command:** Run linter (e.g., `ruff check`, `eslint`) to catch syntax errors immediately.
+1. **NEVER delete existing tests** - Only update if they fail due to bugs in the test or implementation
+2. **NEVER duplicate tests** - Check existing tests first before creating new ones
+3. **Use TEST_DATA fixtures** - For CRITICAL tier modules, read @TEST_DATA from .ai/standards/semantics.md
+4. **Co-location required** - Write tests in `__tests__` directories relative to the code being tested

-4. **Phase 3: Test Execution (Runtime)**
-   - Select the test runner based on the file path:
-     - **Backend (`*.py`)**:
-       - Command: `pytest <path_to_test_file> -v`
-       - If no specific test file exists, try to find it by convention: `tests/test_<module_name>.py`.
-     - **Frontend (`*.svelte`, `*.ts`)**:
-       - Command: `npm run test -- <path_to_component>`
-   
-   - **Verification**:
-     - Analyze output logs.
-     - If tests fail, summarize the failure (AssertionError, Timeout, etc.).
+## Execution Steps

-5. **Phase 4: Contract Coverage Check (Manual/LLM verify)**
-   - Review the test cases executed.
-   - **Question**: Do the tests explicitly verify the `@POST` guarantees defined in the module header?
-   - **Report**: Mark as "Weak Coverage" if contracts exist but aren't tested.
+### 1. Analyze Context

-## Execution Rules
+Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS.

- **Fail Fast**: If semantic headers are missing, don't waste time running pytest.
- **No Silent Failures**: Always output the full error log if a command fails.
- **Auto-Correction Hint**: If a test fails, suggest the specific `speckit.implement` command to fix it.
+Determine:
+- FEATURE_DIR - where the feature is located
+- TASKS_FILE - path to tasks.md
+- Which modules need testing based on task status

-## Example Commands
+### 2. Load Relevant Artifacts

- **Python**: `pytest backend/tests/test_auth.py`
- **Svelte**: `npm run test:unit -- src/components/Button.svelte`
- **Lint**: `ruff check backend/src/api/`
+**From tasks.md:**
+- Identify completed implementation tasks (not test tasks)
+- Extract file paths that need tests
+
+**From .ai/standards/semantics.md:**
+- Read @TIER annotations for modules
+- For CRITICAL modules: Read @TEST_DATA fixtures
+
+**From existing tests:**
+- Scan `__tests__` directories for existing tests
+- Identify test patterns and coverage gaps
+
+### 3. Test Coverage Analysis
+
+Create coverage matrix:
+
+| Module | File | Has Tests | TIER | TEST_DATA Available |
+|--------|------|-----------|------|-------------------|
+| ... | ... | ... | ... | ... |
+
+### 4. Write Tests (TDD Approach)
+
+For each module requiring tests:
+
+1. **Check existing tests**: Scan `__tests__/` for duplicates
+2. **Read TEST_DATA**: If CRITICAL tier, read @TEST_DATA from .ai/standards/semantics.md
+3. **Write test**: Follow co-location strategy
+   - Python: `src/module/__tests__/test_module.py`
+   - Svelte: `src/lib/components/__tests__/test_component.test.js`
+4. **Use mocks**: Use `unittest.mock.MagicMock` for external dependencies
+
+### 4a. UX Contract Testing (Frontend Components)
+
+For Svelte components with `@UX_STATE`, `@UX_FEEDBACK`, `@UX_RECOVERY` tags:
+
+1. **Parse UX tags**: Read component file and extract all `@UX_*` annotations
+2. **Generate UX tests**: Create tests for each UX state transition
+   ```javascript
+   // Example: Testing @UX_STATE: Idle -> Expanded
+   it('should transition from Idle to Expanded on toggle click', async () => {
+     render(Sidebar);
+     const toggleBtn = screen.getByRole('button', { name: /toggle/i });
+     await fireEvent.click(toggleBtn);
+     expect(screen.getByTestId('sidebar')).toHaveClass('expanded');
+   });
+   ```
+3. **Test @UX_FEEDBACK**: Verify visual feedback (toast, shake, color changes)
+4. **Test @UX_RECOVERY**: Verify error recovery mechanisms (retry, clear input)
+5. **Use @UX_TEST fixtures**: If component has `@UX_TEST` tags, use them as test specifications
+
+**UX Test Template:**
+```javascript
+// [DEF:__tests__/test_Component:Module]
+// @RELATION: VERIFIES -> ../Component.svelte
+// @PURPOSE: Test UX states and transitions
+
+describe('Component UX States', () => {
+  // @UX_STATE: Idle -> {action: click, expected: Active}
+  it('should transition Idle -> Active on click', async () => { ... });
+  
+  // @UX_FEEDBACK: Toast on success
+  it('should show toast on successful action', async () => { ... });
+  
+  // @UX_RECOVERY: Retry on error
+  it('should allow retry on error', async () => { ... });
+});
+```
+
+### 5. Test Documentation
+
+Create/update documentation in `specs/<feature>/tests/`:
+
+```
+tests/
+├── README.md           # Test strategy and overview
+├── coverage.md         # Coverage matrix and reports
+└── reports/
+    └── YYYY-MM-DD-report.md
+```
+
+### 6. Execute Tests
+
+Run tests and report results:
+
+**Backend:**
+```bash
+cd backend && .venv/bin/python3 -m pytest -v
+```
+
+**Frontend:**
+```bash
+cd frontend && npm run test
+```
+
+### 7. Update Tasks
+
+Mark test tasks as completed in tasks.md with:
+- Test file path
+- Coverage achieved
+- Any issues found
+
+## Output
+
+Generate test execution report:
+
+```markdown
+# Test Report: [FEATURE]
+
+**Date**: [YYYY-MM-DD]
+**Executed by**: Tester Agent
+
+## Coverage Summary
+
+| Module | Tests | Coverage % |
+|--------|-------|------------|
+| ... | ... | ... |
+
+## Test Results
+
+- Total: [X]
+- Passed: [X]
+- Failed: [X]
+- Skipped: [X]
+
+## Issues Found
+
+| Test | Error | Resolution |
+|------|-------|------------|
+| ... | ... | ... |
+
+## Next Steps
+
+- [ ] Fix failed tests
+- [ ] Add more coverage for [module]
+- [ ] Review TEST_DATA fixtures
+```
+
+## Context for Testing
+
+$ARGUMENTS
--- a/.kilocodemodes
+++ b/.kilocodemodes
@@ -1,25 +1,39 @@
 customModes:
  - slug: tester
    name: Tester
-    description: QA and Plan Verification Specialist
+    description: QA and Test Engineer - Full Testing Cycle
    roleDefinition: |-
-      You are Kilo Code, acting as a QA and Verification Specialist. Your primary goal is to validate that the project implementation aligns strictly with the defined specifications and task plans.
-      Your responsibilities include: - Reading and analyzing task plans and specifications (typically in the `specs/` directory). - Verifying that implemented code matches the requirements. - Executing tests and validating system behavior via CLI or Browser. - Updating the status of tasks in the plan files (e.g., marking checkboxes [x]) as they are verified. - Identifying and reporting missing features or bugs.
-    whenToUse: Use this mode when you need to audit the progress of a project, verify completed tasks against the plan, run quality assurance checks, or update the status of task lists in specification documents.
+      You are Kilo Code, acting as a QA and Test Engineer. Your primary goal is to ensure maximum test coverage, maintain test quality, and preserve existing tests.
+      Your responsibilities include:
+      - WRITING TESTS: Create comprehensive unit tests following TDD principles, using co-location strategy (`__tests__` directories).
+      - TEST DATA: For CRITICAL tier modules, you MUST use @TEST_DATA fixtures defined in .ai/standards/semantics.md. Read and apply them in your tests.
+      - DOCUMENTATION: Maintain test documentation in `specs/<feature>/tests/` directory with coverage reports and test case specifications.
+      - VERIFICATION: Run tests, analyze results, and ensure all tests pass.
+      - PROTECTION: NEVER delete existing tests. NEVER duplicate tests - check for existing tests first.
+    whenToUse: Use this mode when you need to write tests, run test coverage analysis, or perform quality assurance with full testing cycle.
    groups:
      - read
      - edit
      - command
      - browser
      - mcp
-    customInstructions: 1. Always begin by loading the relevant plan or task list from the `specs/` directory. 2. Do not assume a task is done just because it is checked; verify the code or functionality first if asked to audit. 3. When updating task lists, ensure you only mark items as complete if you have verified them.
+    customInstructions: |
+      1. KNOWLEDGE GRAPH: ALWAYS read .ai/ROOT.md first to understand the project structure and navigation.
+      2. CO-LOCATION: Write tests in `__tests__` subdirectories relative to the code being tested (Fractal Strategy).
+      2. TEST DATA MANDATORY: For CRITICAL modules, read @TEST_DATA from .ai/standards/semantics.md and use fixtures in tests.
+      3. UX CONTRACT TESTING: For Svelte components with @UX_STATE, @UX_FEEDBACK, @UX_RECOVERY tags, create comprehensive UX tests.
+      4. NO DELETION: Never delete existing tests - only update if they fail due to legitimate bugs.
+      5. NO DUPLICATION: Check existing tests in `__tests__/` before creating new ones. Reuse existing test patterns.
+      6. DOCUMENTATION: Create test reports in `specs/<feature>/tests/reports/YYYY-MM-DD-report.md`.
+      7. COVERAGE: Aim for maximum coverage but prioritize CRITICAL and STANDARD tier modules.
+      8. RUN TESTS: Execute tests using `cd backend && .venv/bin/python3 -m pytest` or `cd frontend && npm run test`.
  - slug: semantic
    name: Semantic Agent
    roleDefinition: |-
-      You are Kilo Code, a Semantic Agent responsible for maintaining the semantic integrity of the codebase. Your primary goal is to ensure that all code entities (Modules, Classes, Functions, Components) are properly annotated with semantic anchors and tags as defined in `semantic_protocol.md`.
-      Your core responsibilities are: 1.  **Semantic Mapping**: You run and maintain the `generate_semantic_map.py` script to generate up-to-date semantic maps (`semantics/semantic_map.json`, `specs/project_map.md`) and compliance reports (`semantics/reports/*.md`). 2.  **Compliance Auditing**: You analyze the generated compliance reports to identify files with low semantic coverage or parsing errors. 3.  **Semantic Enrichment**: You actively edit code files to add missing semantic anchors (`[DEF:...]`, `[/DEF:...]`) and mandatory tags (`@PURPOSE`, `@LAYER`, etc.) to improve the global compliance score. 4.  **Protocol Enforcement**: You strictly adhere to the syntax and rules defined in `semantic_protocol.md` when modifying code.
+      You are Kilo Code, a Semantic Agent responsible for maintaining the semantic integrity of the codebase. Your primary goal is to ensure that all code entities (Modules, Classes, Functions, Components) are properly annotated with semantic anchors and tags as defined in `.ai/standards/semantics.md`.
+      Your core responsibilities are: 1.  **Semantic Mapping**: You run and maintain the `generate_semantic_map.py` script to generate up-to-date semantic maps (`semantics/semantic_map.json`, `.ai/PROJECT_MAP.md`) and compliance reports (`semantics/reports/*.md`). 2.  **Compliance Auditing**: You analyze the generated compliance reports to identify files with low semantic coverage or parsing errors. 3.  **Semantic Enrichment**: You actively edit code files to add missing semantic anchors (`[DEF:...]`, `[/DEF:...]`) and mandatory tags (`@PURPOSE`, `@LAYER`, etc.) to improve the global compliance score. 4.  **Protocol Enforcement**: You strictly adhere to the syntax and rules defined in `.ai/standards/semantics.md` when modifying code.
      You have access to the full codebase and tools to read, write, and execute scripts. You should prioritize fixing "Critical Parsing Errors" (unclosed anchors) before addressing missing metadata.
-    whenToUse: Use this mode when you need to update the project's semantic map, fix semantic compliance issues (missing anchors/tags/DbC ), or analyze the codebase structure. This mode is specialized for maintaining the `semantic_protocol.md` standards.
+    whenToUse: Use this mode when you need to update the project's semantic map, fix semantic compliance issues (missing anchors/tags/DbC ), or analyze the codebase structure. This mode is specialized for maintaining the `.ai/standards/semantics.md` standards.
    description: Codebase semantic mapping and compliance expert
    customInstructions: Always check `semantics/reports/` for the latest compliance status before starting work. When fixing a file, try to fix all semantic issues in that file at once. After making a batch of fixes, run `python3 generate_semantic_map.py` to verify improvements.
    groups:
@@ -33,11 +47,36 @@ customModes:
    name: Product Manager
    roleDefinition: |-
      Your purpose is to rigorously execute the workflows defined in `.kilocode/workflows/`.
-      You act as the orchestrator for: - Specification (`speckit.specify`, `speckit.clarify`) - Planning (`speckit.plan`) - Task Management (`speckit.tasks`, `speckit.taskstoissues`) - Quality Assurance (`speckit.analyze`, `speckit.checklist`) - Governance (`speckit.constitution`) - Implementation Oversight (`speckit.implement`)
+      You act as the orchestrator for: - Specification (`speckit.specify`, `speckit.clarify`) - Planning (`speckit.plan`) - Task Management (`speckit.tasks`, `speckit.taskstoissues`) - Quality Assurance (`speckit.analyze`, `speckit.checklist`, `speckit.test`, `speckit.fix`) - Governance (`speckit.constitution`) - Implementation Oversight (`speckit.implement`)
      For each task, you must read the relevant workflow file from `.kilocode/workflows/` and follow its Execution Steps precisely.
    whenToUse: Use this mode when you need to run any /speckit.* command or when dealing with high-level feature planning, specification writing, or project management tasks.
    description: Executes SpecKit workflows for feature management
-    customInstructions: 1. Always read the specific workflow file in `.kilocode/workflows/` before executing a command. 2. Adhere strictly to the "Operating Constraints" and "Execution Steps" in the workflow files.
+    customInstructions: 1. Always read `.ai/ROOT.md` first to understand the Knowledge Graph structure. 2. Read the specific workflow file in `.kilocode/workflows/` before executing a command. 3. Adhere strictly to the "Operating Constraints" and "Execution Steps" in the workflow files.
+    groups:
+      - read
+      - edit
+      - command
+      - mcp
+    source: project
+  - slug: coder
+    name: Coder
+    roleDefinition: You are Kilo Code, acting as an Implementation Specialist. Your primary goal is to write code that strictly follows the Semantic Protocol defined in `.ai/standards/semantics.md`.
+    whenToUse: Use this mode when you need to implement features, write code, or fix issues based on test reports.
+    description: Implementation Specialist - Semantic Protocol Compliant
+    customInstructions: |
+      1. KNOWLEDGE GRAPH: ALWAYS read .ai/ROOT.md first to understand the project structure and navigation.
+      2. CONSTITUTION: Strictly follow architectural invariants in .ai/standards/constitution.md.
+      3. SEMANTIC PROTOCOL: ALWAYS use .ai/standards/semantics.md as your source of truth for syntax.
+      4. ANCHOR FORMAT: Use #[DEF:filename:Type] at start and #[/DEF:filename] at end.
+      3. TAGS: Add @PURPOSE, @LAYER, @TIER, @RELATION, @PRE, @POST, @UX_STATE, @UX_FEEDBACK, @UX_RECOVERY.
+      4. TIER COMPLIANCE:
+        - CRITICAL: Full contract + all UX tags + strict logging
+        - STANDARD: Basic contract + UX tags where applicable
+        - TRIVIAL: Only anchors + @PURPOSE
+      5. CODE SIZE: Keep modules under 300 lines. Refactor if exceeding.
+      6. ERROR HANDLING: Use if/raise or guards, never assert.
+      7. TEST FIXES: When fixing failing tests, preserve semantic annotations. Only update code logic.
+      8. RUN TESTS: After fixes, run tests to verify: `cd backend && .venv/bin/python3 -m pytest` or `cd frontend && npm run test`.
    groups:
      - read
      - edit
--- a/.specify/memory/constitution.md
+++ b/.specify/memory/constitution.md
@@ -1,55 +0,0 @@
-<!--
-SYNC IMPACT REPORT
-Version: 2.2.0 (ConfigManager Discipline)
-Changes:
- Updated Principle II: Added mandatory requirement for using `ConfigManager` (via dependency injection) for all configuration access to ensure consistent environment handling and avoid hardcoded values.
- Updated Principle III: Refined `requestApi` requirement.
-Templates Status:
- .specify/templates/plan-template.md: ✅ Aligned.
- .specify/templates/spec-template.md: ✅ Aligned.
- .specify/templates/tasks-template.md: ✅ Aligned.
-->
-# Semantic Code Generation Constitution
-
-## Core Principles
-
-### I. Semantic Protocol Compliance
-The file `semantic_protocol.md` is the **sole and authoritative technical standard** for this project.
- **Law**: All code must adhere to the Axioms (Meaning First, Contract First, etc.) defined in the Protocol.
- **Syntax & Structure**: Anchors (`[DEF]`), Tags (`@KEY`), and File Structures must strictly match the Protocol.
- **Compliance**: Any deviation from `semantic_protocol.md` constitutes a build failure.
-
-### II. Everything is a Plugin & Centralized Config
-All functional extensions, tools, or major features must be implemented as modular Plugins inheriting from `PluginBase`.
- **Modularity**: Logic should not reside in standalone services or scripts unless strictly necessary for core infrastructure. This ensures a unified execution model via the `TaskManager`.
- **Configuration Discipline**: All configuration access (environments, settings, paths) MUST use the `ConfigManager`. In the backend, the singleton instance MUST be obtained via dependency injection (`get_config_manager()`). Hardcoding environment IDs (e.g., "1") or paths is STRICTLY FORBIDDEN.
-
-### III. Unified Frontend Experience
-To ensure a consistent and accessible user experience, all frontend implementations must strictly adhere to the unified design and localization standards.
- **Component Reusability**: All UI elements MUST utilize the standardized Svelte component library (`src/lib/ui`) and centralized design tokens.
- **Internationalization (i18n)**: All user-facing text MUST be extracted to the translation system (`src/lib/i18n`).
- **Backend Communication**: All API requests MUST use the `requestApi` wrapper (or its derivatives like `fetchApi`, `postApi`) from `src/lib/api.js`. Direct use of the native `fetch` API for backend communication is FORBIDDEN to ensure consistent authentication (JWT) and error handling.
-
-### IV. Security & Access Control
-To support the Role-Based Access Control (RBAC) system, all functional components must define explicit permissions.
- **Granular Permissions**: Every Plugin MUST define a unique permission string (e.g., `plugin:name:execute`) required for its operation.
- **Registration**: These permissions MUST be registered in the system database (`auth.db`) during initialization.
-
-### V. Independent Testability
-Every feature specification MUST define "Independent Tests" that allow the feature to be verified in isolation.
- **Decoupling**: Features should be designed such that they can be tested without requiring the full application state or external dependencies where possible.
- **Verification**: A feature is not complete until its Independent Test scenarios pass.
-
-### VI. Asynchronous Execution
-All long-running or resource-intensive operations (migrations, analysis, backups, external API calls) MUST be executed as asynchronous tasks via the `TaskManager`.
- **Non-Blocking**: HTTP API endpoints MUST NOT block on these operations; they should spawn a task and return a Task ID.
- **Observability**: Tasks MUST emit real-time status updates via the WebSocket infrastructure.
-
-## Governance
-This Constitution establishes the "Semantic Code Generation Protocol" as the supreme law of this repository.
-
- **Authoritative Source**: `semantic_protocol.md` defines the specific implementation rules for Principle I.
- **Amendments**: Changes to core principles require a Constitution amendment. Changes to technical syntax require a Protocol update.
- **Compliance**: Failure to adhere to the Protocol constitutes a build failure.
-
-**Version**: 2.2.0 | **Ratified**: 2025-12-19 | **Last Amended**: 2026-01-29
--- a/.specify/templates/agent-file-template.md
+++ b/.specify/templates/agent-file-template.md
@@ -2,6 +2,12 @@

 Auto-generated from all feature plans. Last updated: [DATE]

+## Knowledge Graph (GRACE)
+**CRITICAL**: This project uses a GRACE Knowledge Graph for context. Always load the root map first:
+- **Root Map**: `.ai/ROOT.md` -> `[DEF:Project_Knowledge_Map:Root]`
+- **Project Map**: `.ai/PROJECT_MAP.md` -> `[DEF:Project_Map]`
+- **Standards**: Read `.ai/standards/` for architecture and style rules.
+
 ## Active Technologies

 [EXTRACTED FROM ALL PLAN.MD FILES]
--- a/.specify/templates/plan-template.md
+++ b/.specify/templates/plan-template.md
@@ -17,8 +17,8 @@
  the iteration process.
 -->

-**Language/Version**: [e.g., Python 3.11, Swift 5.9, Rust 1.75 or NEEDS CLARIFICATION]  
-**Primary Dependencies**: [e.g., FastAPI, UIKit, LLVM or NEEDS CLARIFICATION]  
+**Language/Version**: [e.g., Python 3.11, Swift 5.9, Rust 1.75 or NEEDS CLARIFICATION]
+**Primary Dependencies**: [e.g., FastAPI, Tailwind CSS, SvelteKit or NEEDS CLARIFICATION]
 **Storage**: [if applicable, e.g., PostgreSQL, CoreData, files or N/A]  
 **Testing**: [e.g., pytest, XCTest, cargo test or NEEDS CLARIFICATION]  
 **Target Platform**: [e.g., Linux server, iOS 15+, WASM or NEEDS CLARIFICATION]
@@ -102,3 +102,14 @@ directories captured above]
 |-----------|------------|-------------------------------------|
 | [e.g., 4th project] | [current need] | [why 3 projects insufficient] |
 | [e.g., Repository pattern] | [specific problem] | [why direct DB access insufficient] |
+
+## Test Data Reference
+
+> **For CRITICAL tier components, reference test fixtures from spec.md**
+
+| Component | TIER | Fixture Name | Location |
+|-----------|------|--------------|----------|
+| [e.g., DashboardAPI] | CRITICAL | valid_dashboard | spec.md#test-data-fixtures |
+| [e.g., TaskDrawer] | CRITICAL | task_states | spec.md#test-data-fixtures |
+
+**Note**: Tester Agent MUST use these fixtures when writing unit tests for CRITICAL modules. See `.ai/standards/semantics.md` for @TEST_DATA syntax.
--- a/.specify/templates/spec-template.md
+++ b/.specify/templates/spec-template.md
@@ -114,3 +114,52 @@
 - **SC-002**: [Measurable metric, e.g., "System handles 1000 concurrent users without degradation"]
 - **SC-003**: [User satisfaction metric, e.g., "90% of users successfully complete primary task on first attempt"]
 - **SC-004**: [Business metric, e.g., "Reduce support tickets related to [X] by 50%"]
+
+---
+
+## Test Data Fixtures *(recommended for CRITICAL components)*
+
+<!--
+  Define reference/fixture data for testing CRITICAL tier components.
+  This data will be used by the Tester Agent when writing unit tests.
+  Format: JSON or YAML that matches the component's data structures.
+-->
+
+### Fixtures
+
+```yaml
+# Example fixture format
+fixture_name:
+  description: "Description of this test data"
+  data:
+    # JSON or YAML data structure
+```
+
+### Example: Dashboard API
+
+```yaml
+valid_dashboard:
+  description: "Valid dashboard object for API responses"
+  data:
+    id: 1
+    title: "Sales Report"
+    slug: "sales"
+    git_status:
+      branch: "main"
+      sync_status: "OK"
+    last_task:
+      task_id: "task-123"
+      status: "SUCCESS"
+
+empty_dashboards:
+  description: "Empty dashboard list response"
+  data:
+    dashboards: []
+    total: 0
+    page: 1
+
+error_not_found:
+  description: "404 error response"
+  data:
+    detail: "Dashboard not found"
+```
--- a/.specify/templates/tasks-template.md
+++ b/.specify/templates/tasks-template.md
@@ -93,7 +93,8 @@ Examples of foundational tasks (adjust based on your project):
 - [ ] T014 [US1] Implement [Service] in src/services/[service].py (depends on T012, T013)
 - [ ] T015 [US1] Implement [endpoint/feature] in src/[location]/[file].py
 - [ ] T016 [US1] Add validation and error handling
- [ ] T017 [US1] Add logging for user story 1 operations
+- [ ] T017 [US1] [P] Implement UI using Tailwind CSS (minimize scoped styles)
+- [ ] T018 [US1] Add logging for user story 1 operations

 **Checkpoint**: At this point, User Story 1 should be fully functional and testable independently

--- a/.specify/templates/test-docs-template.md
+++ b/.specify/templates/test-docs-template.md
@@ -0,0 +1,152 @@
+---
+
+description: "Test documentation template for feature implementation"
+
+---
+
+# Test Documentation: [FEATURE NAME]
+
+**Feature**: [Link to spec.md]
+**Created**: [DATE]
+**Updated**: [DATE]
+**Tester**: [Agent/User Name]
+
+---
+
+## Overview
+
+[Brief description of what this feature does and why testing is important]
+
+**Test Strategy**:
+- [ ] Unit Tests (co-located in `__tests__/` directories)
+- [ ] Integration Tests (if needed)
+- [ ] E2E Tests (if critical user flows)
+- [ ] Contract Tests (for API endpoints)
+
+---
+
+## Test Coverage Matrix
+
+| Module | File | Unit Tests | Coverage % | Status |
+|--------|------|------------|------------|--------|
+| [Module Name] | `path/to/file.py` | [x] | [XX%] | [Pass/Fail] |
+| [Module Name] | `path/to/file.svelte` | [x] | [XX%] | [Pass/Fail] |
+
+---
+
+## Test Cases
+
+### [Module Name]
+
+**Target File**: `path/to/module.py`
+
+| ID | Test Case | Type | Expected Result | Status |
+|----|-----------|------|------------------|--------|
+| TC001 | [Description] | [Unit/Integration] | [Expected] | [Pass/Fail] |
+| TC002 | [Description] | [Unit/Integration] | [Expected] | [Pass/Fail] |
+
+---
+
+## Test Execution Reports
+
+### Report [YYYY-MM-DD]
+
+**Executed by**: [Tester]
+**Duration**: [X] minutes
+**Result**: [Pass/Fail]
+
+**Summary**:
+- Total Tests: [X]
+- Passed: [X]
+- Failed: [X]
+- Skipped: [X]
+
+**Failed Tests**:
+| Test | Error | Resolution |
+|------|-------|-------------|
+| [Test Name] | [Error Message] | [How Fixed] |
+
+---
+
+## Anti-Patterns & Rules
+
+### ✅ DO
+
+1. Write tests BEFORE implementation (TDD approach)
+2. Use co-location: `src/module/__tests__/test_module.py`
+3. Use MagicMock for external dependencies (DB, Auth, APIs)
+4. Include semantic annotations: `# @RELATION: VERIFIES -> module.name`
+5. Test edge cases and error conditions
+6. **Test UX states** for Svelte components (@UX_STATE, @UX_FEEDBACK, @UX_RECOVERY)
+
+### ❌ DON'T
+
+1. Delete existing tests (only update if they fail)
+2. Duplicate tests - check for existing tests first
+3. Test implementation details, not behavior
+4. Use real external services in unit tests
+5. Skip error handling tests
+6. **Skip UX contract tests** for CRITICAL frontend components
+
+---
+
+## UX Contract Testing (Frontend)
+
+### UX States Coverage
+
+| Component | @UX_STATE | @UX_FEEDBACK | @UX_RECOVERY | Tests |
+|-----------|-----------|--------------|--------------|-------|
+| [Component] | [states] | [feedback] | [recovery] | [status] |
+
+### UX Test Cases
+
+| ID | Component | UX Tag | Test Action | Expected Result | Status |
+|----|-----------|--------|-------------|-----------------|--------|
+| UX001 | [Component] | @UX_STATE: Idle | [action] | [expected] | [Pass/Fail] |
+| UX002 | [Component] | @UX_FEEDBACK | [action] | [expected] | [Pass/Fail] |
+| UX003 | [Component] | @UX_RECOVERY | [action] | [expected] | [Pass/Fail] |
+
+### UX Test Examples
+
+```javascript
+// Testing @UX_STATE transition
+it('should transition from Idle to Loading on submit', async () => {
+  render(FormComponent);
+  await fireEvent.click(screen.getByText('Submit'));
+  expect(screen.getByTestId('form')).toHaveClass('loading');
+});
+
+// Testing @UX_FEEDBACK
+it('should show error toast on validation failure', async () => {
+  render(FormComponent);
+  await fireEvent.click(screen.getByText('Submit'));
+  expect(screen.getByRole('alert')).toHaveTextContent('Validation error');
+});
+
+// Testing @UX_RECOVERY
+it('should allow retry after error', async () => {
+  render(FormComponent);
+  // Trigger error state
+  await fireEvent.click(screen.getByText('Submit'));
+  // Click retry
+  await fireEvent.click(screen.getByText('Retry'));
+  expect(screen.getByTestId('form')).not.toHaveClass('error');
+});
+```
+
+---
+
+## Notes
+
+- [Additional notes about testing approach]
+- [Known issues or limitations]
+- [Recommendations for future testing]
+
+---
+
+## Related Documents
+
+- [spec.md](./spec.md)
+- [plan.md](./plan.md)
+- [tasks.md](./tasks.md)
+- [contracts/](./contracts/)
--- a/README.md
+++ b/README.md
@@ -64,7 +64,7 @@

 ## Разработка
 Проект следует строгим правилам разработки:
-1. **Semantic Code Generation**: Использование протокола `semantic_protocol.md` для обеспечения надежности кода.
+1. **Semantic Code Generation**: Использование протокола `.ai/standards/semantics.md` для обеспечения надежности кода.
 2. **Design by Contract (DbC)**: Определение предусловий и постусловий для ключевых функций.
 3. **Constitution**: Соблюдение правил, описанных в конституции проекта в папке `.specify/`.

--- a/backend/logs/app.log.1
+++ b/backend/logs/app.log.1
--- a/backend/mappings.db
+++ b/backend/mappings.db
--- a/backend/src/api/routes/init.py
+++ b/backend/src/api/routes/init.py
@@ -1 +1,10 @@
-from . import plugins, tasks, settings, connections, environments, mappings, migration, git, storage, admin
+# Lazy loading of route modules to avoid import issues in tests
+# This allows tests to import routes without triggering all module imports
+
+__all__ = ['plugins', 'tasks', 'settings', 'connections', 'environments', 'mappings', 'migration', 'git', 'storage', 'admin']
+
+def __getattr__(name):
+    if name in __all__:
+        import importlib
+        return importlib.import_module(f".{name}", __name__)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
--- a/backend/src/api/routes/tests/test_dashboards.py
+++ b/backend/src/api/routes/tests/test_dashboards.py
@@ -0,0 +1,286 @@
+# [DEF:backend.src.api.routes.__tests__.test_dashboards:Module]
+# @TIER: STANDARD
+# @PURPOSE: Unit tests for Dashboards API endpoints
+# @LAYER: API
+# @RELATION: TESTS -> backend.src.api.routes.dashboards
+
+import pytest
+from unittest.mock import MagicMock, patch, AsyncMock
+from fastapi.testclient import TestClient
+from src.app import app
+from src.api.routes.dashboards import DashboardsResponse
+
+client = TestClient(app)
+
+
+# [DEF:test_get_dashboards_success:Function]
+# @TEST: GET /api/dashboards returns 200 and valid schema
+# @PRE: env_id exists
+# @POST: Response matches DashboardsResponse schema
+def test_get_dashboards_success():
+    with patch("src.api.routes.dashboards.get_config_manager") as mock_config, \
+         patch("src.api.routes.dashboards.get_resource_service") as mock_service, \
+         patch("src.api.routes.dashboards.get_task_manager") as mock_task_mgr, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        # Mock environment
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        
+        # Mock task manager
+        mock_task_mgr.return_value.get_all_tasks.return_value = []
+        
+        # Mock resource service response
+        async def mock_get_dashboards(env, tasks):
+            return [
+                {
+                    "id": 1,
+                    "title": "Sales Report",
+                    "slug": "sales",
+                    "git_status": {"branch": "main", "sync_status": "OK"},
+                    "last_task": {"task_id": "task-1", "status": "SUCCESS"}
+                }
+            ]
+        mock_service.return_value.get_dashboards_with_status = AsyncMock(
+            side_effect=mock_get_dashboards
+        )
+        
+        # Mock permission
+        mock_perm.return_value = lambda: True
+
+        response = client.get("/api/dashboards?env_id=prod")
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "dashboards" in data
+        assert "total" in data
+        assert "page" in data
+
+
+# [/DEF:test_get_dashboards_success:Function]
+
+
+# [DEF:test_get_dashboards_with_search:Function]
+# @TEST: GET /api/dashboards filters by search term
+# @PRE: search parameter provided
+# @POST: Only matching dashboards returned
+def test_get_dashboards_with_search():
+    with patch("src.api.routes.dashboards.get_config_manager") as mock_config, \
+         patch("src.api.routes.dashboards.get_resource_service") as mock_service, \
+         patch("src.api.routes.dashboards.get_task_manager") as mock_task_mgr, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        # Mock environment
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        
+        mock_task_mgr.return_value.get_all_tasks.return_value = []
+        
+        async def mock_get_dashboards(env, tasks):
+            return [
+                {"id": 1, "title": "Sales Report", "slug": "sales"},
+                {"id": 2, "title": "Marketing Dashboard", "slug": "marketing"}
+            ]
+        mock_service.return_value.get_dashboards_with_status = AsyncMock(
+            side_effect=mock_get_dashboards
+        )
+        
+        mock_perm.return_value = lambda: True
+
+        response = client.get("/api/dashboards?env_id=prod&search=sales")
+        
+        assert response.status_code == 200
+        data = response.json()
+        # Filtered by search term
+
+
+# [/DEF:test_get_dashboards_with_search:Function]
+
+
+# [DEF:test_get_dashboards_env_not_found:Function]
+# @TEST: GET /api/dashboards returns 404 if env_id missing
+# @PRE: env_id does not exist
+# @POST: Returns 404 error
+def test_get_dashboards_env_not_found():
+    with patch("src.api.routes.dashboards.get_config_manager") as mock_config, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        mock_config.return_value.get_environments.return_value = []
+        mock_perm.return_value = lambda: True
+
+        response = client.get("/api/dashboards?env_id=nonexistent")
+        
+        assert response.status_code == 404
+        assert "Environment not found" in response.json()["detail"]
+
+
+# [/DEF:test_get_dashboards_env_not_found:Function]
+
+
+# [DEF:test_get_dashboards_invalid_pagination:Function]
+# @TEST: GET /api/dashboards returns 400 for invalid page/page_size
+# @PRE: page < 1 or page_size > 100
+# @POST: Returns 400 error
+def test_get_dashboards_invalid_pagination():
+    with patch("src.api.routes.dashboards.get_config_manager") as mock_config, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        mock_perm.return_value = lambda: True
+
+        # Invalid page
+        response = client.get("/api/dashboards?env_id=prod&page=0")
+        assert response.status_code == 400
+        assert "Page must be >= 1" in response.json()["detail"]
+        
+        # Invalid page_size
+        response = client.get("/api/dashboards?env_id=prod&page_size=101")
+        assert response.status_code == 400
+        assert "Page size must be between 1 and 100" in response.json()["detail"]
+
+
+# [/DEF:test_get_dashboards_invalid_pagination:Function]
+
+
+# [DEF:test_migrate_dashboards_success:Function]
+# @TEST: POST /api/dashboards/migrate creates migration task
+# @PRE: Valid source_env_id, target_env_id, dashboard_ids
+# @POST: Returns task_id
+def test_migrate_dashboards_success():
+    with patch("src.api.routes.dashboards.get_config_manager") as mock_config, \
+         patch("src.api.routes.dashboards.get_task_manager") as mock_task_mgr, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        # Mock environments
+        mock_source = MagicMock()
+        mock_source.id = "source"
+        mock_target = MagicMock()
+        mock_target.id = "target"
+        mock_config.return_value.get_environments.return_value = [mock_source, mock_target]
+        
+        # Mock task manager
+        mock_task = MagicMock()
+        mock_task.id = "task-migrate-123"
+        mock_task_mgr.return_value.create_task = AsyncMock(return_value=mock_task)
+        
+        # Mock permission
+        mock_perm.return_value = lambda: True
+
+        response = client.post(
+            "/api/dashboards/migrate",
+            json={
+                "source_env_id": "source",
+                "target_env_id": "target",
+                "dashboard_ids": [1, 2, 3],
+                "db_mappings": {"old_db": "new_db"}
+            }
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "task_id" in data
+
+
+# [/DEF:test_migrate_dashboards_success:Function]
+
+
+# [DEF:test_migrate_dashboards_no_ids:Function]
+# @TEST: POST /api/dashboards/migrate returns 400 for empty dashboard_ids
+# @PRE: dashboard_ids is empty
+# @POST: Returns 400 error
+def test_migrate_dashboards_no_ids():
+    with patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        mock_perm.return_value = lambda: True
+
+        response = client.post(
+            "/api/dashboards/migrate",
+            json={
+                "source_env_id": "source",
+                "target_env_id": "target",
+                "dashboard_ids": []
+            }
+        )
+        
+        assert response.status_code == 400
+        assert "At least one dashboard ID must be provided" in response.json()["detail"]
+
+
+# [/DEF:test_migrate_dashboards_no_ids:Function]
+
+
+# [DEF:test_backup_dashboards_success:Function]
+# @TEST: POST /api/dashboards/backup creates backup task
+# @PRE: Valid env_id, dashboard_ids
+# @POST: Returns task_id
+def test_backup_dashboards_success():
+    with patch("src.api.routes.dashboards.get_config_manager") as mock_config, \
+         patch("src.api.routes.dashboards.get_task_manager") as mock_task_mgr, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        # Mock environment
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        
+        # Mock task manager
+        mock_task = MagicMock()
+        mock_task.id = "task-backup-456"
+        mock_task_mgr.return_value.create_task = AsyncMock(return_value=mock_task)
+        
+        # Mock permission
+        mock_perm.return_value = lambda: True
+
+        response = client.post(
+            "/api/dashboards/backup",
+            json={
+                "env_id": "prod",
+                "dashboard_ids": [1, 2, 3],
+                "schedule": "0 0 * * *"
+            }
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "task_id" in data
+
+
+# [/DEF:test_backup_dashboards_success:Function]
+
+
+# [DEF:test_get_database_mappings_success:Function]
+# @TEST: GET /api/dashboards/db-mappings returns mapping suggestions
+# @PRE: Valid source_env_id, target_env_id
+# @POST: Returns list of database mappings
+def test_get_database_mappings_success():
+    with patch("src.api.routes.dashboards.get_mapping_service") as mock_service, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        # Mock mapping service
+        mock_service.return_value.get_suggestions = AsyncMock(return_value=[
+            {
+                "source_db": "old_sales",
+                "target_db": "new_sales",
+                "source_db_uuid": "uuid-1",
+                "target_db_uuid": "uuid-2",
+                "confidence": 0.95
+            }
+        ])
+        
+        # Mock permission
+        mock_perm.return_value = lambda: True
+
+        response = client.get("/api/dashboards/db-mappings?source_env_id=prod&target_env_id=staging")
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "mappings" in data
+
+
+# [/DEF:test_get_database_mappings_success:Function]
+
+
+# [/DEF:backend.src.api.routes.__tests__.test_dashboards:Module]
--- a/backend/src/api/routes/tests/test_datasets.py
+++ b/backend/src/api/routes/tests/test_datasets.py
@@ -0,0 +1,209 @@
+# [DEF:backend.src.api.routes.__tests__.test_datasets:Module]
+# @TIER: STANDARD
+# @PURPOSE: Unit tests for Datasets API endpoints
+# @LAYER: API
+# @RELATION: TESTS -> backend.src.api.routes.datasets
+
+import pytest
+from unittest.mock import MagicMock, patch, AsyncMock
+from fastapi.testclient import TestClient
+from src.app import app
+from src.api.routes.datasets import DatasetsResponse, DatasetDetailResponse
+
+client = TestClient(app)
+
+
+# [DEF:test_get_datasets_success:Function]
+# @TEST: GET /api/datasets returns 200 and valid schema
+# @PRE: env_id exists
+# @POST: Response matches DatasetsResponse schema
+def test_get_datasets_success():
+    with patch("src.api.routes.datasets.get_config_manager") as mock_config, \
+         patch("src.api.routes.datasets.get_resource_service") as mock_service, \
+         patch("src.api.routes.datasets.has_permission") as mock_perm:
+        
+        # Mock environment
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        
+        # Mock resource service response
+        mock_service.return_value.get_datasets_with_status.return_value = AsyncMock()(
+            return_value=[
+                {
+                    "id": 1,
+                    "table_name": "sales_data",
+                    "schema": "public",
+                    "database": "sales_db",
+                    "mapped_fields": {"total": 10, "mapped": 5},
+                    "last_task": {"task_id": "task-1", "status": "SUCCESS"}
+                }
+            ]
+        )
+        
+        # Mock permission
+        mock_perm.return_value = lambda: True
+
+        response = client.get("/api/datasets?env_id=prod")
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "datasets" in data
+        assert len(data["datasets"]) >= 0
+        # Validate against Pydantic model
+        DatasetsResponse(**data)
+
+
+# [/DEF:test_get_datasets_success:Function]
+
+
+# [DEF:test_get_datasets_env_not_found:Function]
+# @TEST: GET /api/datasets returns 404 if env_id missing
+# @PRE: env_id does not exist
+# @POST: Returns 404 error
+def test_get_datasets_env_not_found():
+    with patch("src.api.routes.datasets.get_config_manager") as mock_config, \
+         patch("src.api.routes.datasets.has_permission") as mock_perm:
+        
+        mock_config.return_value.get_environments.return_value = []
+        mock_perm.return_value = lambda: True
+
+        response = client.get("/api/datasets?env_id=nonexistent")
+        
+        assert response.status_code == 404
+        assert "Environment not found" in response.json()["detail"]
+
+
+# [/DEF:test_get_datasets_env_not_found:Function]
+
+
+# [DEF:test_get_datasets_invalid_pagination:Function]
+# @TEST: GET /api/datasets returns 400 for invalid page/page_size
+# @PRE: page < 1 or page_size > 100
+# @POST: Returns 400 error
+def test_get_datasets_invalid_pagination():
+    with patch("src.api.routes.datasets.get_config_manager") as mock_config, \
+         patch("src.api.routes.datasets.has_permission") as mock_perm:
+        
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        mock_perm.return_value = lambda: True
+
+        # Invalid page
+        response = client.get("/api/datasets?env_id=prod&page=0")
+        assert response.status_code == 400
+        assert "Page must be >= 1" in response.json()["detail"]
+        
+        # Invalid page_size
+        response = client.get("/api/datasets?env_id=prod&page_size=0")
+        assert response.status_code == 400
+        assert "Page size must be between 1 and 100" in response.json()["detail"]
+
+
+# [/DEF:test_get_datasets_invalid_pagination:Function]
+
+
+# [DEF:test_map_columns_success:Function]
+# @TEST: POST /api/datasets/map-columns creates mapping task
+# @PRE: Valid env_id, dataset_ids, source_type
+# @POST: Returns task_id
+def test_map_columns_success():
+    with patch("src.api.routes.datasets.get_config_manager") as mock_config, \
+         patch("src.api.routes.datasets.get_task_manager") as mock_task_mgr, \
+         patch("src.api.routes.datasets.has_permission") as mock_perm:
+        
+        # Mock environment
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        
+        # Mock task manager
+        mock_task = MagicMock()
+        mock_task.id = "task-123"
+        mock_task_mgr.return_value.create_task = AsyncMock(return_value=mock_task)
+        
+        # Mock permission
+        mock_perm.return_value = lambda: True
+
+        response = client.post(
+            "/api/datasets/map-columns",
+            json={
+                "env_id": "prod",
+                "dataset_ids": [1, 2, 3],
+                "source_type": "postgresql"
+            }
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "task_id" in data
+
+
+# [/DEF:test_map_columns_success:Function]
+
+
+# [DEF:test_map_columns_invalid_source_type:Function]
+# @TEST: POST /api/datasets/map-columns returns 400 for invalid source_type
+# @PRE: source_type is not 'postgresql' or 'xlsx'
+# @POST: Returns 400 error
+def test_map_columns_invalid_source_type():
+    with patch("src.api.routes.datasets.has_permission") as mock_perm:
+        mock_perm.return_value = lambda: True
+
+        response = client.post(
+            "/api/datasets/map-columns",
+            json={
+                "env_id": "prod",
+                "dataset_ids": [1],
+                "source_type": "invalid"
+            }
+        )
+        
+        assert response.status_code == 400
+        assert "Source type must be 'postgresql' or 'xlsx'" in response.json()["detail"]
+
+
+# [/DEF:test_map_columns_invalid_source_type:Function]
+
+
+# [DEF:test_generate_docs_success:Function]
+# @TEST: POST /api/datasets/generate-docs creates doc generation task
+# @PRE: Valid env_id, dataset_ids, llm_provider
+# @POST: Returns task_id
+def test_generate_docs_success():
+    with patch("src.api.routes.datasets.get_config_manager") as mock_config, \
+         patch("src.api.routes.datasets.get_task_manager") as mock_task_mgr, \
+         patch("src.api.routes.datasets.has_permission") as mock_perm:
+        
+        # Mock environment
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        
+        # Mock task manager
+        mock_task = MagicMock()
+        mock_task.id = "task-456"
+        mock_task_mgr.return_value.create_task = AsyncMock(return_value=mock_task)
+        
+        # Mock permission
+        mock_perm.return_value = lambda: True
+
+        response = client.post(
+            "/api/datasets/generate-docs",
+            json={
+                "env_id": "prod",
+                "dataset_ids": [1],
+                "llm_provider": "openai"
+            }
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "task_id" in data
+
+
+# [/DEF:test_generate_docs_success:Function]
+
+
+# [/DEF:backend.src.api.routes.__tests__.test_datasets:Module]
--- a/backend/src/api/routes/admin.py
+++ b/backend/src/api/routes/admin.py
@@ -21,8 +21,8 @@ from ...schemas.auth import (
    RoleSchema, RoleCreate, RoleUpdate, PermissionSchema,
    ADGroupMappingSchema, ADGroupMappingCreate
 )
-from ...models.auth import User, Role, Permission, ADGroupMapping
-from ...dependencies import has_permission, get_current_user
+from ...models.auth import User, Role, ADGroupMapping
+from ...dependencies import has_permission
 from ...core.logger import logger, belief_scope
 # [/SECTION]

--- a/backend/src/api/routes/connections.py
+++ b/backend/src/api/routes/connections.py
@@ -11,7 +11,7 @@ from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 from ...core.database import get_db
 from ...models.connection import ConnectionConfig
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from datetime import datetime
 from ...core.logger import logger, belief_scope
 # [/SECTION]
--- a/backend/src/api/routes/dashboards.py
+++ b/backend/src/api/routes/dashboards.py
@@ -0,0 +1,327 @@
+# [DEF:backend.src.api.routes.dashboards:Module]
+#
+# @TIER: STANDARD
+# @SEMANTICS: api, dashboards, resources, hub
+# @PURPOSE:   API endpoints for the Dashboard Hub - listing dashboards with Git and task status
+# @LAYER:     API
+# @RELATION:  DEPENDS_ON -> backend.src.dependencies
+# @RELATION:  DEPENDS_ON -> backend.src.services.resource_service
+# @RELATION:  DEPENDS_ON -> backend.src.core.superset_client
+#
+# @INVARIANT: All dashboard responses include git_status and last_task metadata
+
+# [SECTION: IMPORTS]
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List, Optional, Dict
+from pydantic import BaseModel, Field
+from ...dependencies import get_config_manager, get_task_manager, get_resource_service, get_mapping_service, has_permission
+from ...core.logger import logger, belief_scope
+# [/SECTION]
+
+router = APIRouter(prefix="/api/dashboards", tags=["Dashboards"])
+
+# [DEF:GitStatus:DataClass]
+class GitStatus(BaseModel):
+    branch: Optional[str] = None
+    sync_status: Optional[str] = Field(None, pattern="^OK|DIFF$")
+# [/DEF:GitStatus:DataClass]
+
+# [DEF:LastTask:DataClass]
+class LastTask(BaseModel):
+    task_id: Optional[str] = None
+    status: Optional[str] = Field(None, pattern="^RUNNING|SUCCESS|ERROR|WAITING_INPUT$")
+# [/DEF:LastTask:DataClass]
+
+# [DEF:DashboardItem:DataClass]
+class DashboardItem(BaseModel):
+    id: int
+    title: str
+    slug: Optional[str] = None
+    url: Optional[str] = None
+    last_modified: Optional[str] = None
+    git_status: Optional[GitStatus] = None
+    last_task: Optional[LastTask] = None
+# [/DEF:DashboardItem:DataClass]
+
+# [DEF:DashboardsResponse:DataClass]
+class DashboardsResponse(BaseModel):
+    dashboards: List[DashboardItem]
+    total: int
+    page: int
+    page_size: int
+    total_pages: int
+# [/DEF:DashboardsResponse:DataClass]
+
+# [DEF:get_dashboards:Function]
+# @PURPOSE: Fetch list of dashboards from a specific environment with Git status and last task status
+# @PRE: env_id must be a valid environment ID
+# @PRE: page must be >= 1 if provided
+# @PRE: page_size must be between 1 and 100 if provided
+# @POST: Returns a list of dashboards with enhanced metadata and pagination info
+# @POST: Response includes pagination metadata (page, page_size, total, total_pages)
+# @PARAM: env_id (str) - The environment ID to fetch dashboards from
+# @PARAM: search (Optional[str]) - Filter by title/slug
+# @PARAM: page (Optional[int]) - Page number (default: 1)
+# @PARAM: page_size (Optional[int]) - Items per page (default: 10, max: 100)
+# @RETURN: DashboardsResponse - List of dashboards with status metadata
+# @RELATION: CALLS -> ResourceService.get_dashboards_with_status
+@router.get("", response_model=DashboardsResponse)
+async def get_dashboards(
+    env_id: str,
+    search: Optional[str] = None,
+    page: int = 1,
+    page_size: int = 10,
+    config_manager=Depends(get_config_manager),
+    task_manager=Depends(get_task_manager),
+    resource_service=Depends(get_resource_service),
+    _ = Depends(has_permission("plugin:migration", "READ"))
+):
+    with belief_scope("get_dashboards", f"env_id={env_id}, search={search}, page={page}, page_size={page_size}"):
+        # Validate pagination parameters
+        if page < 1:
+            logger.error(f"[get_dashboards][Coherence:Failed] Invalid page: {page}")
+            raise HTTPException(status_code=400, detail="Page must be >= 1")
+        if page_size < 1 or page_size > 100:
+            logger.error(f"[get_dashboards][Coherence:Failed] Invalid page_size: {page_size}")
+            raise HTTPException(status_code=400, detail="Page size must be between 1 and 100")
+        
+        # Validate environment exists
+        environments = config_manager.get_environments()
+        env = next((e for e in environments if e.id == env_id), None)
+        if not env:
+            logger.error(f"[get_dashboards][Coherence:Failed] Environment not found: {env_id}")
+            raise HTTPException(status_code=404, detail="Environment not found")
+        
+        try:
+            # Get all tasks for status lookup
+            all_tasks = task_manager.get_all_tasks()
+            
+            # Fetch dashboards with status using ResourceService
+            dashboards = await resource_service.get_dashboards_with_status(env, all_tasks)
+            
+            # Apply search filter if provided
+            if search:
+                search_lower = search.lower()
+                dashboards = [
+                    d for d in dashboards 
+                    if search_lower in d.get('title', '').lower() 
+                    or search_lower in d.get('slug', '').lower()
+                ]
+            
+            # Calculate pagination
+            total = len(dashboards)
+            total_pages = (total + page_size - 1) // page_size if total > 0 else 1
+            start_idx = (page - 1) * page_size
+            end_idx = start_idx + page_size
+            
+            # Slice dashboards for current page
+            paginated_dashboards = dashboards[start_idx:end_idx]
+            
+            logger.info(f"[get_dashboards][Coherence:OK] Returning {len(paginated_dashboards)} dashboards (page {page}/{total_pages}, total: {total})")
+            
+            return DashboardsResponse(
+                dashboards=paginated_dashboards,
+                total=total,
+                page=page,
+                page_size=page_size,
+                total_pages=total_pages
+            )
+            
+        except Exception as e:
+            logger.error(f"[get_dashboards][Coherence:Failed] Failed to fetch dashboards: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to fetch dashboards: {str(e)}")
+# [/DEF:get_dashboards:Function]
+
+# [DEF:MigrateRequest:DataClass]
+class MigrateRequest(BaseModel):
+    source_env_id: str = Field(..., description="Source environment ID")
+    target_env_id: str = Field(..., description="Target environment ID")
+    dashboard_ids: List[int] = Field(..., description="List of dashboard IDs to migrate")
+    db_mappings: Optional[Dict[str, str]] = Field(None, description="Database mappings for migration")
+    replace_db_config: bool = Field(False, description="Replace database configuration")
+# [/DEF:MigrateRequest:DataClass]
+
+# [DEF:TaskResponse:DataClass]
+class TaskResponse(BaseModel):
+    task_id: str
+# [/DEF:TaskResponse:DataClass]
+
+# [DEF:migrate_dashboards:Function]
+# @PURPOSE: Trigger bulk migration of dashboards from source to target environment
+# @PRE: User has permission plugin:migration:execute
+# @PRE: source_env_id and target_env_id are valid environment IDs
+# @PRE: dashboard_ids is a non-empty list
+# @POST: Returns task_id for tracking migration progress
+# @POST: Task is created and queued for execution
+# @PARAM: request (MigrateRequest) - Migration request with source, target, and dashboard IDs
+# @RETURN: TaskResponse - Task ID for tracking
+# @RELATION: DISPATCHES -> MigrationPlugin
+# @RELATION: CALLS -> task_manager.create_task
+@router.post("/migrate", response_model=TaskResponse)
+async def migrate_dashboards(
+    request: MigrateRequest,
+    config_manager=Depends(get_config_manager),
+    task_manager=Depends(get_task_manager),
+    _ = Depends(has_permission("plugin:migration", "EXECUTE"))
+):
+    with belief_scope("migrate_dashboards", f"source={request.source_env_id}, target={request.target_env_id}, count={len(request.dashboard_ids)}"):
+        # Validate request
+        if not request.dashboard_ids:
+            logger.error("[migrate_dashboards][Coherence:Failed] No dashboard IDs provided")
+            raise HTTPException(status_code=400, detail="At least one dashboard ID must be provided")
+        
+        # Validate environments exist
+        environments = config_manager.get_environments()
+        source_env = next((e for e in environments if e.id == request.source_env_id), None)
+        target_env = next((e for e in environments if e.id == request.target_env_id), None)
+        
+        if not source_env:
+            logger.error(f"[migrate_dashboards][Coherence:Failed] Source environment not found: {request.source_env_id}")
+            raise HTTPException(status_code=404, detail="Source environment not found")
+        if not target_env:
+            logger.error(f"[migrate_dashboards][Coherence:Failed] Target environment not found: {request.target_env_id}")
+            raise HTTPException(status_code=404, detail="Target environment not found")
+        
+        try:
+            # Create migration task
+            task_params = {
+                'source_env_id': request.source_env_id,
+                'target_env_id': request.target_env_id,
+                'selected_ids': request.dashboard_ids,
+                'replace_db_config': request.replace_db_config,
+                'db_mappings': request.db_mappings or {}
+            }
+            
+            task_obj = await task_manager.create_task(
+                plugin_id='superset-migration',
+                params=task_params
+            )
+            
+            logger.info(f"[migrate_dashboards][Coherence:OK] Migration task created: {task_obj.id} for {len(request.dashboard_ids)} dashboards")
+            
+            return TaskResponse(task_id=str(task_obj.id))
+            
+        except Exception as e:
+            logger.error(f"[migrate_dashboards][Coherence:Failed] Failed to create migration task: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to create migration task: {str(e)}")
+# [/DEF:migrate_dashboards:Function]
+
+# [DEF:BackupRequest:DataClass]
+class BackupRequest(BaseModel):
+    env_id: str = Field(..., description="Environment ID")
+    dashboard_ids: List[int] = Field(..., description="List of dashboard IDs to backup")
+    schedule: Optional[str] = Field(None, description="Cron schedule for recurring backups (e.g., '0 0 * * *')")
+# [/DEF:BackupRequest:DataClass]
+
+# [DEF:backup_dashboards:Function]
+# @PURPOSE: Trigger bulk backup of dashboards with optional cron schedule
+# @PRE: User has permission plugin:backup:execute
+# @PRE: env_id is a valid environment ID
+# @PRE: dashboard_ids is a non-empty list
+# @POST: Returns task_id for tracking backup progress
+# @POST: Task is created and queued for execution
+# @POST: If schedule is provided, a scheduled task is created
+# @PARAM: request (BackupRequest) - Backup request with environment and dashboard IDs
+# @RETURN: TaskResponse - Task ID for tracking
+# @RELATION: DISPATCHES -> BackupPlugin
+# @RELATION: CALLS -> task_manager.create_task
+@router.post("/backup", response_model=TaskResponse)
+async def backup_dashboards(
+    request: BackupRequest,
+    config_manager=Depends(get_config_manager),
+    task_manager=Depends(get_task_manager),
+    _ = Depends(has_permission("plugin:backup", "EXECUTE"))
+):
+    with belief_scope("backup_dashboards", f"env={request.env_id}, count={len(request.dashboard_ids)}, schedule={request.schedule}"):
+        # Validate request
+        if not request.dashboard_ids:
+            logger.error("[backup_dashboards][Coherence:Failed] No dashboard IDs provided")
+            raise HTTPException(status_code=400, detail="At least one dashboard ID must be provided")
+        
+        # Validate environment exists
+        environments = config_manager.get_environments()
+        env = next((e for e in environments if e.id == request.env_id), None)
+        
+        if not env:
+            logger.error(f"[backup_dashboards][Coherence:Failed] Environment not found: {request.env_id}")
+            raise HTTPException(status_code=404, detail="Environment not found")
+        
+        try:
+            # Create backup task
+            task_params = {
+                'env': request.env_id,
+                'dashboards': request.dashboard_ids,
+                'schedule': request.schedule
+            }
+            
+            task_obj = await task_manager.create_task(
+                plugin_id='superset-backup',
+                params=task_params
+            )
+            
+            logger.info(f"[backup_dashboards][Coherence:OK] Backup task created: {task_obj.id} for {len(request.dashboard_ids)} dashboards")
+            
+            return TaskResponse(task_id=str(task_obj.id))
+            
+        except Exception as e:
+            logger.error(f"[backup_dashboards][Coherence:Failed] Failed to create backup task: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to create backup task: {str(e)}")
+# [/DEF:backup_dashboards:Function]
+
+# [DEF:DatabaseMapping:DataClass]
+class DatabaseMapping(BaseModel):
+    source_db: str
+    target_db: str
+    source_db_uuid: Optional[str] = None
+    target_db_uuid: Optional[str] = None
+    confidence: float
+# [/DEF:DatabaseMapping:DataClass]
+
+# [DEF:DatabaseMappingsResponse:DataClass]
+class DatabaseMappingsResponse(BaseModel):
+    mappings: List[DatabaseMapping]
+# [/DEF:DatabaseMappingsResponse:DataClass]
+
+# [DEF:get_database_mappings:Function]
+# @PURPOSE: Get database mapping suggestions between source and target environments
+# @PRE: User has permission plugin:migration:read
+# @PRE: source_env_id and target_env_id are valid environment IDs
+# @POST: Returns list of suggested database mappings with confidence scores
+# @PARAM: source_env_id (str) - Source environment ID
+# @PARAM: target_env_id (str) - Target environment ID
+# @RETURN: DatabaseMappingsResponse - List of suggested mappings
+# @RELATION: CALLS -> MappingService.get_suggestions
+@router.get("/db-mappings", response_model=DatabaseMappingsResponse)
+async def get_database_mappings(
+    source_env_id: str,
+    target_env_id: str,
+    mapping_service=Depends(get_mapping_service),
+    _ = Depends(has_permission("plugin:migration", "READ"))
+):
+    with belief_scope("get_database_mappings", f"source={source_env_id}, target={target_env_id}"):
+        try:
+            # Get mapping suggestions using MappingService
+            suggestions = await mapping_service.get_suggestions(source_env_id, target_env_id)
+            
+            # Format suggestions as DatabaseMapping objects
+            mappings = [
+                DatabaseMapping(
+                    source_db=s.get('source_db', ''),
+                    target_db=s.get('target_db', ''),
+                    source_db_uuid=s.get('source_db_uuid'),
+                    target_db_uuid=s.get('target_db_uuid'),
+                    confidence=s.get('confidence', 0.0)
+                )
+                for s in suggestions
+            ]
+            
+            logger.info(f"[get_database_mappings][Coherence:OK] Returning {len(mappings)} database mapping suggestions")
+            
+            return DatabaseMappingsResponse(mappings=mappings)
+            
+        except Exception as e:
+            logger.error(f"[get_database_mappings][Coherence:Failed] Failed to get database mappings: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to get database mappings: {str(e)}")
+# [/DEF:get_database_mappings:Function]
+
+# [/DEF:backend.src.api.routes.dashboards:Module]
--- a/backend/src/api/routes/datasets.py
+++ b/backend/src/api/routes/datasets.py
@@ -0,0 +1,395 @@
+# [DEF:backend.src.api.routes.datasets:Module]
+#
+# @TIER: STANDARD
+# @SEMANTICS: api, datasets, resources, hub
+# @PURPOSE:   API endpoints for the Dataset Hub - listing datasets with mapping progress
+# @LAYER:     API
+# @RELATION:  DEPENDS_ON -> backend.src.dependencies
+# @RELATION:  DEPENDS_ON -> backend.src.services.resource_service
+# @RELATION:  DEPENDS_ON -> backend.src.core.superset_client
+#
+# @INVARIANT: All dataset responses include last_task metadata
+
+# [SECTION: IMPORTS]
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from ...dependencies import get_config_manager, get_task_manager, get_resource_service, has_permission
+from ...core.logger import logger, belief_scope
+from ...core.superset_client import SupersetClient
+# [/SECTION]
+
+router = APIRouter(prefix="/api/datasets", tags=["Datasets"])
+
+# [DEF:MappedFields:DataClass]
+class MappedFields(BaseModel):
+    total: int
+    mapped: int
+# [/DEF:MappedFields:DataClass]
+
+# [DEF:LastTask:DataClass]
+class LastTask(BaseModel):
+    task_id: Optional[str] = None
+    status: Optional[str] = Field(None, pattern="^RUNNING|SUCCESS|ERROR|WAITING_INPUT$")
+# [/DEF:LastTask:DataClass]
+
+# [DEF:DatasetItem:DataClass]
+class DatasetItem(BaseModel):
+    id: int
+    table_name: str
+    schema: str
+    database: str
+    mapped_fields: Optional[MappedFields] = None
+    last_task: Optional[LastTask] = None
+# [/DEF:DatasetItem:DataClass]
+
+# [DEF:LinkedDashboard:DataClass]
+class LinkedDashboard(BaseModel):
+    id: int
+    title: str
+    slug: Optional[str] = None
+# [/DEF:LinkedDashboard:DataClass]
+
+# [DEF:DatasetColumn:DataClass]
+class DatasetColumn(BaseModel):
+    id: int
+    name: str
+    type: Optional[str] = None
+    is_dttm: bool = False
+    is_active: bool = True
+    description: Optional[str] = None
+# [/DEF:DatasetColumn:DataClass]
+
+# [DEF:DatasetDetailResponse:DataClass]
+class DatasetDetailResponse(BaseModel):
+    id: int
+    table_name: Optional[str] = None
+    schema: Optional[str] = None
+    database: str
+    description: Optional[str] = None
+    columns: List[DatasetColumn]
+    column_count: int
+    sql: Optional[str] = None
+    linked_dashboards: List[LinkedDashboard]
+    linked_dashboard_count: int
+    is_sqllab_view: bool = False
+    created_on: Optional[str] = None
+    changed_on: Optional[str] = None
+# [/DEF:DatasetDetailResponse:DataClass]
+
+# [DEF:DatasetsResponse:DataClass]
+class DatasetsResponse(BaseModel):
+    datasets: List[DatasetItem]
+    total: int
+    page: int
+    page_size: int
+    total_pages: int
+# [/DEF:DatasetsResponse:DataClass]
+
+# [DEF:TaskResponse:DataClass]
+class TaskResponse(BaseModel):
+    task_id: str
+# [/DEF:TaskResponse:DataClass]
+
+# [DEF:get_dataset_ids:Function]
+# @PURPOSE: Fetch list of all dataset IDs from a specific environment (without pagination)
+# @PRE: env_id must be a valid environment ID
+# @POST: Returns a list of all dataset IDs
+# @PARAM: env_id (str) - The environment ID to fetch datasets from
+# @PARAM: search (Optional[str]) - Filter by table name
+# @RETURN: List[int] - List of dataset IDs
+# @RELATION: CALLS -> ResourceService.get_datasets_with_status
+@router.get("/ids")
+async def get_dataset_ids(
+    env_id: str,
+    search: Optional[str] = None,
+    config_manager=Depends(get_config_manager),
+    task_manager=Depends(get_task_manager),
+    resource_service=Depends(get_resource_service),
+    _ = Depends(has_permission("plugin:migration", "READ"))
+):
+    with belief_scope("get_dataset_ids", f"env_id={env_id}, search={search}"):
+        # Validate environment exists
+        environments = config_manager.get_environments()
+        env = next((e for e in environments if e.id == env_id), None)
+        if not env:
+            logger.error(f"[get_dataset_ids][Coherence:Failed] Environment not found: {env_id}")
+            raise HTTPException(status_code=404, detail="Environment not found")
+        
+        try:
+            # Get all tasks for status lookup
+            all_tasks = task_manager.get_all_tasks()
+            
+            # Fetch datasets with status using ResourceService
+            datasets = await resource_service.get_datasets_with_status(env, all_tasks)
+            
+            # Apply search filter if provided
+            if search:
+                search_lower = search.lower()
+                datasets = [
+                    d for d in datasets 
+                    if search_lower in d.get('table_name', '').lower()
+                ]
+            
+            # Extract and return just the IDs
+            dataset_ids = [d['id'] for d in datasets]
+            logger.info(f"[get_dataset_ids][Coherence:OK] Returning {len(dataset_ids)} dataset IDs")
+            
+            return {"dataset_ids": dataset_ids}
+            
+        except Exception as e:
+            logger.error(f"[get_dataset_ids][Coherence:Failed] Failed to fetch dataset IDs: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to fetch dataset IDs: {str(e)}")
+# [/DEF:get_dataset_ids:Function]
+
+# [DEF:get_datasets:Function]
+# @PURPOSE: Fetch list of datasets from a specific environment with mapping progress
+# @PRE: env_id must be a valid environment ID
+# @PRE: page must be >= 1 if provided
+# @PRE: page_size must be between 1 and 100 if provided
+# @POST: Returns a list of datasets with enhanced metadata and pagination info
+# @POST: Response includes pagination metadata (page, page_size, total, total_pages)
+# @PARAM: env_id (str) - The environment ID to fetch datasets from
+# @PARAM: search (Optional[str]) - Filter by table name
+# @PARAM: page (Optional[int]) - Page number (default: 1)
+# @PARAM: page_size (Optional[int]) - Items per page (default: 10, max: 100)
+# @RETURN: DatasetsResponse - List of datasets with status metadata
+# @RELATION: CALLS -> ResourceService.get_datasets_with_status
+@router.get("", response_model=DatasetsResponse)
+async def get_datasets(
+    env_id: str,
+    search: Optional[str] = None,
+    page: int = 1,
+    page_size: int = 10,
+    config_manager=Depends(get_config_manager),
+    task_manager=Depends(get_task_manager),
+    resource_service=Depends(get_resource_service),
+    _ = Depends(has_permission("plugin:migration", "READ"))
+):
+    with belief_scope("get_datasets", f"env_id={env_id}, search={search}, page={page}, page_size={page_size}"):
+        # Validate pagination parameters
+        if page < 1:
+            logger.error(f"[get_datasets][Coherence:Failed] Invalid page: {page}")
+            raise HTTPException(status_code=400, detail="Page must be >= 1")
+        if page_size < 1 or page_size > 100:
+            logger.error(f"[get_datasets][Coherence:Failed] Invalid page_size: {page_size}")
+            raise HTTPException(status_code=400, detail="Page size must be between 1 and 100")
+        
+        # Validate environment exists
+        environments = config_manager.get_environments()
+        env = next((e for e in environments if e.id == env_id), None)
+        if not env:
+            logger.error(f"[get_datasets][Coherence:Failed] Environment not found: {env_id}")
+            raise HTTPException(status_code=404, detail="Environment not found")
+        
+        try:
+            # Get all tasks for status lookup
+            all_tasks = task_manager.get_all_tasks()
+            
+            # Fetch datasets with status using ResourceService
+            datasets = await resource_service.get_datasets_with_status(env, all_tasks)
+            
+            # Apply search filter if provided
+            if search:
+                search_lower = search.lower()
+                datasets = [
+                    d for d in datasets 
+                    if search_lower in d.get('table_name', '').lower()
+                ]
+            
+            # Calculate pagination
+            total = len(datasets)
+            total_pages = (total + page_size - 1) // page_size if total > 0 else 1
+            start_idx = (page - 1) * page_size
+            end_idx = start_idx + page_size
+            
+            # Slice datasets for current page
+            paginated_datasets = datasets[start_idx:end_idx]
+            
+            logger.info(f"[get_datasets][Coherence:OK] Returning {len(paginated_datasets)} datasets (page {page}/{total_pages}, total: {total})")
+            
+            return DatasetsResponse(
+                datasets=paginated_datasets,
+                total=total,
+                page=page,
+                page_size=page_size,
+                total_pages=total_pages
+            )
+            
+        except Exception as e:
+            logger.error(f"[get_datasets][Coherence:Failed] Failed to fetch datasets: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to fetch datasets: {str(e)}")
+# [/DEF:get_datasets:Function]
+
+# [DEF:MapColumnsRequest:DataClass]
+class MapColumnsRequest(BaseModel):
+    env_id: str = Field(..., description="Environment ID")
+    dataset_ids: List[int] = Field(..., description="List of dataset IDs to map")
+    source_type: str = Field(..., description="Source type: 'postgresql' or 'xlsx'")
+    connection_id: Optional[str] = Field(None, description="Connection ID for PostgreSQL source")
+    file_data: Optional[str] = Field(None, description="File path or data for XLSX source")
+# [/DEF:MapColumnsRequest:DataClass]
+
+# [DEF:map_columns:Function]
+# @PURPOSE: Trigger bulk column mapping for datasets
+# @PRE: User has permission plugin:mapper:execute
+# @PRE: env_id is a valid environment ID
+# @PRE: dataset_ids is a non-empty list
+# @POST: Returns task_id for tracking mapping progress
+# @POST: Task is created and queued for execution
+# @PARAM: request (MapColumnsRequest) - Mapping request with environment and dataset IDs
+# @RETURN: TaskResponse - Task ID for tracking
+# @RELATION: DISPATCHES -> MapperPlugin
+# @RELATION: CALLS -> task_manager.create_task
+@router.post("/map-columns", response_model=TaskResponse)
+async def map_columns(
+    request: MapColumnsRequest,
+    config_manager=Depends(get_config_manager),
+    task_manager=Depends(get_task_manager),
+    _ = Depends(has_permission("plugin:mapper", "EXECUTE"))
+):
+    with belief_scope("map_columns", f"env={request.env_id}, count={len(request.dataset_ids)}, source={request.source_type}"):
+        # Validate request
+        if not request.dataset_ids:
+            logger.error("[map_columns][Coherence:Failed] No dataset IDs provided")
+            raise HTTPException(status_code=400, detail="At least one dataset ID must be provided")
+        
+        # Validate source type
+        if request.source_type not in ['postgresql', 'xlsx']:
+            logger.error(f"[map_columns][Coherence:Failed] Invalid source type: {request.source_type}")
+            raise HTTPException(status_code=400, detail="Source type must be 'postgresql' or 'xlsx'")
+        
+        # Validate environment exists
+        environments = config_manager.get_environments()
+        env = next((e for e in environments if e.id == request.env_id), None)
+        
+        if not env:
+            logger.error(f"[map_columns][Coherence:Failed] Environment not found: {request.env_id}")
+            raise HTTPException(status_code=404, detail="Environment not found")
+        
+        try:
+            # Create mapping task
+            task_params = {
+                'env': request.env_id,
+                'dataset_id': request.dataset_ids[0] if request.dataset_ids else None,
+                'source': request.source_type,
+                'connection_id': request.connection_id,
+                'file_data': request.file_data
+            }
+            
+            task_obj = await task_manager.create_task(
+                plugin_id='dataset-mapper',
+                params=task_params
+            )
+            
+            logger.info(f"[map_columns][Coherence:OK] Mapping task created: {task_obj.id} for {len(request.dataset_ids)} datasets")
+            
+            return TaskResponse(task_id=str(task_obj.id))
+            
+        except Exception as e:
+            logger.error(f"[map_columns][Coherence:Failed] Failed to create mapping task: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to create mapping task: {str(e)}")
+# [/DEF:map_columns:Function]
+
+# [DEF:GenerateDocsRequest:DataClass]
+class GenerateDocsRequest(BaseModel):
+    env_id: str = Field(..., description="Environment ID")
+    dataset_ids: List[int] = Field(..., description="List of dataset IDs to generate docs for")
+    llm_provider: str = Field(..., description="LLM provider to use")
+    options: Optional[dict] = Field(None, description="Additional options for documentation generation")
+# [/DEF:GenerateDocsRequest:DataClass]
+
+# [DEF:generate_docs:Function]
+# @PURPOSE: Trigger bulk documentation generation for datasets
+# @PRE: User has permission plugin:llm_analysis:execute
+# @PRE: env_id is a valid environment ID
+# @PRE: dataset_ids is a non-empty list
+# @POST: Returns task_id for tracking documentation generation progress
+# @POST: Task is created and queued for execution
+# @PARAM: request (GenerateDocsRequest) - Documentation generation request
+# @RETURN: TaskResponse - Task ID for tracking
+# @RELATION: DISPATCHES -> LLMAnalysisPlugin
+# @RELATION: CALLS -> task_manager.create_task
+@router.post("/generate-docs", response_model=TaskResponse)
+async def generate_docs(
+    request: GenerateDocsRequest,
+    config_manager=Depends(get_config_manager),
+    task_manager=Depends(get_task_manager),
+    _ = Depends(has_permission("plugin:llm_analysis", "EXECUTE"))
+):
+    with belief_scope("generate_docs", f"env={request.env_id}, count={len(request.dataset_ids)}, provider={request.llm_provider}"):
+        # Validate request
+        if not request.dataset_ids:
+            logger.error("[generate_docs][Coherence:Failed] No dataset IDs provided")
+            raise HTTPException(status_code=400, detail="At least one dataset ID must be provided")
+        
+        # Validate environment exists
+        environments = config_manager.get_environments()
+        env = next((e for e in environments if e.id == request.env_id), None)
+        
+        if not env:
+            logger.error(f"[generate_docs][Coherence:Failed] Environment not found: {request.env_id}")
+            raise HTTPException(status_code=404, detail="Environment not found")
+        
+        try:
+            # Create documentation generation task
+            task_params = {
+                'environment_id': request.env_id,
+                'dataset_id': str(request.dataset_ids[0]) if request.dataset_ids else None,
+                'provider_id': request.llm_provider,
+                'options': request.options or {}
+            }
+            
+            task_obj = await task_manager.create_task(
+                plugin_id='llm_documentation',
+                params=task_params
+            )
+            
+            logger.info(f"[generate_docs][Coherence:OK] Documentation generation task created: {task_obj.id} for {len(request.dataset_ids)} datasets")
+            
+            return TaskResponse(task_id=str(task_obj.id))
+            
+        except Exception as e:
+            logger.error(f"[generate_docs][Coherence:Failed] Failed to create documentation generation task: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to create documentation generation task: {str(e)}")
+# [/DEF:generate_docs:Function]
+
+# [DEF:get_dataset_detail:Function]
+# @PURPOSE: Get detailed dataset information including columns and linked dashboards
+# @PRE: env_id is a valid environment ID
+# @PRE: dataset_id is a valid dataset ID
+# @POST: Returns detailed dataset info with columns and linked dashboards
+# @PARAM: env_id (str) - The environment ID
+# @PARAM: dataset_id (int) - The dataset ID
+# @RETURN: DatasetDetailResponse - Detailed dataset information
+# @RELATION: CALLS -> SupersetClient.get_dataset_detail
+@router.get("/{dataset_id}", response_model=DatasetDetailResponse)
+async def get_dataset_detail(
+    env_id: str,
+    dataset_id: int,
+    config_manager=Depends(get_config_manager),
+    _ = Depends(has_permission("plugin:migration", "READ"))
+):
+    with belief_scope("get_dataset_detail", f"env_id={env_id}, dataset_id={dataset_id}"):
+        # Validate environment exists
+        environments = config_manager.get_environments()
+        env = next((e for e in environments if e.id == env_id), None)
+        if not env:
+            logger.error(f"[get_dataset_detail][Coherence:Failed] Environment not found: {env_id}")
+            raise HTTPException(status_code=404, detail="Environment not found")
+        
+        try:
+            # Fetch detailed dataset info using SupersetClient
+            client = SupersetClient(env)
+            dataset_detail = client.get_dataset_detail(dataset_id)
+            
+            logger.info(f"[get_dataset_detail][Coherence:OK] Retrieved dataset {dataset_id} with {dataset_detail['column_count']} columns and {dataset_detail['linked_dashboard_count']} linked dashboards")
+            
+            return DatasetDetailResponse(**dataset_detail)
+            
+        except Exception as e:
+            logger.error(f"[get_dataset_detail][Coherence:Failed] Failed to fetch dataset detail: {e}")
+            raise HTTPException(status_code=503, detail=f"Failed to fetch dataset detail: {str(e)}")
+# [/DEF:get_dataset_detail:Function]
+
+# [/DEF:backend.src.api.routes.datasets:Module]
--- a/backend/src/api/routes/environments.py
+++ b/backend/src/api/routes/environments.py
@@ -11,15 +11,14 @@

 # [SECTION: IMPORTS]
 from fastapi import APIRouter, Depends, HTTPException
-from typing import List, Dict, Optional
+from typing import List, Optional
 from ...dependencies import get_config_manager, get_scheduler_service, has_permission
 from ...core.superset_client import SupersetClient
 from pydantic import BaseModel, Field
-from ...core.config_models import Environment as EnvModel
 from ...core.logger import belief_scope
 # [/SECTION]

-router = APIRouter()
+router = APIRouter(prefix="/api/environments", tags=["Environments"])

 # [DEF:ScheduleSchema:DataClass]
 class ScheduleSchema(BaseModel):
@@ -44,6 +43,8 @@ class DatabaseResponse(BaseModel):

 # [DEF:get_environments:Function]
 # @PURPOSE: List all configured environments.
+# @LAYER: API
+# @SEMANTICS: list, environments, config
 # @PRE:     config_manager is injected via Depends.
 # @POST:    Returns a list of EnvironmentResponse objects.
 # @RETURN:  List[EnvironmentResponse]
@@ -72,6 +73,8 @@ async def get_environments(

 # [DEF:update_environment_schedule:Function]
 # @PURPOSE: Update backup schedule for an environment.
+# @LAYER: API
+# @SEMANTICS: update, schedule, backup, environment
 # @PRE:     Environment id exists, schedule is valid ScheduleSchema.
 # @POST:    Backup schedule updated and scheduler reloaded.
 # @PARAM:   id (str) - The environment ID.
@@ -104,6 +107,8 @@ async def update_environment_schedule(

 # [DEF:get_environment_databases:Function]
 # @PURPOSE: Fetch the list of databases from a specific environment.
+# @LAYER: API
+# @SEMANTICS: fetch, databases, superset, environment
 # @PRE:     Environment id exists.
 # @POST:    Returns a list of database summaries from the environment.
 # @PARAM:   id (str) - The environment ID.
--- a/backend/src/api/routes/git.py
+++ b/backend/src/api/routes/git.py
@@ -16,17 +16,17 @@ from typing import List, Optional
 import typing
 from src.dependencies import get_config_manager, has_permission
 from src.core.database import get_db
-from src.models.git import GitServerConfig, GitStatus, DeploymentEnvironment, GitRepository
+from src.models.git import GitServerConfig, GitRepository
 from src.api.routes.git_schemas import (
    GitServerConfigSchema, GitServerConfigCreate,
-    GitRepositorySchema, BranchSchema, BranchCreate,
+    BranchSchema, BranchCreate,
    BranchCheckout, CommitSchema, CommitCreate,
    DeploymentEnvironmentSchema, DeployRequest, RepoInitRequest
 )
 from src.services.git_service import GitService
 from src.core.logger import logger, belief_scope

-router = APIRouter(prefix="/api/git", tags=["git"])
+router = APIRouter(tags=["git"])
 git_service = GitService()

 # [DEF:get_git_configs:Function]
--- a/backend/src/api/routes/git_schemas.py
+++ b/backend/src/api/routes/git_schemas.py
@@ -11,7 +11,6 @@
 from pydantic import BaseModel, Field
 from typing import List, Optional
 from datetime import datetime
-from uuid import UUID
 from src.models.git import GitProvider, GitStatus, SyncStatus

 # [DEF:GitServerConfigBase:Class]
--- a/backend/src/api/routes/llm.py
+++ b/backend/src/api/routes/llm.py
@@ -16,7 +16,7 @@ from sqlalchemy.orm import Session

 # [DEF:router:Global]
 # @PURPOSE: APIRouter instance for LLM routes.
-router = APIRouter(prefix="/api/llm", tags=["LLM"])
+router = APIRouter(tags=["LLM"])
 # [/DEF:router:Global]

 # [DEF:get_providers:Function]
--- a/backend/src/api/routes/mappings.py
+++ b/backend/src/api/routes/mappings.py
@@ -21,7 +21,7 @@ from ...models.mapping import DatabaseMapping
 from pydantic import BaseModel
 # [/SECTION]

-router = APIRouter(prefix="/api/mappings", tags=["mappings"])
+router = APIRouter(tags=["mappings"])

 # [DEF:MappingCreate:DataClass]
 class MappingCreate(BaseModel):
@@ -31,6 +31,7 @@ class MappingCreate(BaseModel):
    target_db_uuid: str
    source_db_name: str
    target_db_name: str
+    engine: Optional[str] = None
 # [/DEF:MappingCreate:DataClass]

 # [DEF:MappingResponse:DataClass]
@@ -42,6 +43,7 @@ class MappingResponse(BaseModel):
    target_db_uuid: str
    source_db_name: str
    target_db_name: str
+    engine: Optional[str] = None

    class Config:
        from_attributes = True
@@ -94,6 +96,7 @@ async def create_mapping(
        if existing:
            existing.target_db_uuid = mapping.target_db_uuid
            existing.target_db_name = mapping.target_db_name
+            existing.engine = mapping.engine
            db.commit()
            db.refresh(existing)
            return existing
--- a/backend/src/api/routes/migration.py
+++ b/backend/src/api/routes/migration.py
@@ -7,7 +7,7 @@
 # @RELATION:  DEPENDS_ON -> backend.src.models.dashboard

 from fastapi import APIRouter, Depends, HTTPException
-from typing import List, Dict
+from typing import List
 from ...dependencies import get_config_manager, get_task_manager, has_permission
 from ...models.dashboard import DashboardMetadata, DashboardSelection
 from ...core.superset_client import SupersetClient
@@ -44,7 +44,7 @@ async def get_dashboards(
 # @POST:    Starts the migration task and returns the task ID.
 # @PARAM:   selection (DashboardSelection) - The dashboards to migrate.
 # @RETURN:  Dict - {"task_id": str, "message": str}
-@router.post("/migration/execute")
+@router.post("/execute")
 async def execute_migration(
    selection: DashboardSelection,
    config_manager=Depends(get_config_manager),
--- a/backend/src/api/routes/settings.py
+++ b/backend/src/api/routes/settings.py
@@ -17,9 +17,8 @@ from ...core.config_models import AppConfig, Environment, GlobalSettings, Loggin
 from ...models.storage import StorageConfig
 from ...dependencies import get_config_manager, has_permission
 from ...core.config_manager import ConfigManager
-from ...core.logger import logger, belief_scope, get_task_log_level
+from ...core.logger import logger, belief_scope
 from ...core.superset_client import SupersetClient
-import os
 # [/SECTION]

 # [DEF:LoggingConfigResponse:Class]
@@ -279,4 +278,99 @@ async def update_logging_config(
        )
 # [/DEF:update_logging_config:Function]

+# [DEF:ConsolidatedSettingsResponse:Class]
+class ConsolidatedSettingsResponse(BaseModel):
+    environments: List[dict]
+    connections: List[dict]
+    llm: dict
+    llm_providers: List[dict]
+    logging: dict
+    storage: dict
+# [/DEF:ConsolidatedSettingsResponse:Class]
+
+# [DEF:get_consolidated_settings:Function]
+# @PURPOSE: Retrieves all settings categories in a single call
+# @PRE:     Config manager is available.
+# @POST:    Returns all consolidated settings.
+# @RETURN: ConsolidatedSettingsResponse - All settings categories.
+@router.get("/consolidated", response_model=ConsolidatedSettingsResponse)
+async def get_consolidated_settings(
+    config_manager: ConfigManager = Depends(get_config_manager),
+    _ = Depends(has_permission("admin:settings", "READ"))
+):
+    with belief_scope("get_consolidated_settings"):
+        logger.info("[get_consolidated_settings][Entry] Fetching all consolidated settings")
+        
+        config = config_manager.get_config()
+        
+        from ...services.llm_provider import LLMProviderService
+        from ...core.database import SessionLocal
+        db = SessionLocal()
+        try:
+            llm_service = LLMProviderService(db)
+            providers = llm_service.get_all_providers()
+            llm_providers_list = [
+                {
+                    "id": p.id,
+                    "provider_type": p.provider_type,
+                    "name": p.name,
+                    "base_url": p.base_url,
+                    "api_key": "********",
+                    "default_model": p.default_model,
+                    "is_active": p.is_active
+                } for p in providers
+            ]
+        finally:
+            db.close()
+
+        return ConsolidatedSettingsResponse(
+            environments=[env.dict() for env in config.environments],
+            connections=config.settings.connections,
+            llm=config.settings.llm,
+            llm_providers=llm_providers_list,
+            logging=config.settings.logging.dict(),
+            storage=config.settings.storage.dict()
+        )
+# [/DEF:get_consolidated_settings:Function]
+
+# [DEF:update_consolidated_settings:Function]
+# @PURPOSE: Bulk update application settings from the consolidated view.
+# @PRE:     User has admin permissions, config is valid.
+# @POST:    Settings are updated and saved via ConfigManager.
+@router.patch("/consolidated")
+async def update_consolidated_settings(
+    settings_patch: dict,
+    config_manager: ConfigManager = Depends(get_config_manager),
+    _ = Depends(has_permission("admin:settings", "WRITE"))
+):
+    with belief_scope("update_consolidated_settings"):
+        logger.info("[update_consolidated_settings][Entry] Applying consolidated settings patch")
+        
+        current_config = config_manager.get_config()
+        current_settings = current_config.settings
+        
+        # Update connections if provided
+        if "connections" in settings_patch:
+            current_settings.connections = settings_patch["connections"]
+            
+        # Update LLM if provided
+        if "llm" in settings_patch:
+            current_settings.llm = settings_patch["llm"]
+            
+        # Update Logging if provided
+        if "logging" in settings_patch:
+            current_settings.logging = LoggingConfig(**settings_patch["logging"])
+            
+        # Update Storage if provided
+        if "storage" in settings_patch:
+            new_storage = StorageConfig(**settings_patch["storage"])
+            is_valid, message = config_manager.validate_path(new_storage.root_path)
+            if not is_valid:
+                 raise HTTPException(status_code=400, detail=message)
+            current_settings.storage = new_storage
+
+        config_manager.update_global_settings(current_settings)
+        return {"status": "success", "message": "Settings updated"}
+# [/DEF:update_consolidated_settings:Function]
+
 # [/DEF:SettingsRouter:Module]
--- a/backend/src/api/routes/tasks.py
+++ b/backend/src/api/routes/tasks.py
@@ -6,7 +6,7 @@
 # @RELATION: Depends on the TaskManager. It is included by the main app.
 from typing import List, Dict, Any, Optional
 from fastapi import APIRouter, Depends, HTTPException, status, Query
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from ...core.logger import belief_scope

 from ...core.task_manager import TaskManager, Task, TaskStatus, LogEntry
--- a/backend/src/app.py
+++ b/backend/src/app.py
@@ -6,26 +6,23 @@
 # @RELATION: Depends on the dependency module and API route modules.
 # @INVARIANT: Only one FastAPI app instance exists per process.
 # @INVARIANT: All WebSocket connections must be properly cleaned up on disconnect.
-import sys
 from pathlib import Path

 # project_root is used for static files mounting
 project_root = Path(__file__).resolve().parent.parent.parent

-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Depends, Request, HTTPException
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request, HTTPException
 from starlette.middleware.sessions import SessionMiddleware
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
 import asyncio
-import os

 from .dependencies import get_task_manager, get_scheduler_service
 from .core.utils.network import NetworkError
 from .core.logger import logger, belief_scope
-from .api.routes import plugins, tasks, settings, environments, mappings, migration, connections, git, storage, admin, llm
+from .api.routes import plugins, tasks, settings, environments, mappings, migration, connections, git, storage, admin, llm, dashboards, datasets
 from .api import auth
-from .core.database import init_db

 # [DEF:App:Global]
 # @SEMANTICS: app, fastapi, instance
@@ -118,12 +115,21 @@ app.include_router(plugins.router, prefix="/api/plugins", tags=["Plugins"])
 app.include_router(tasks.router, prefix="/api/tasks", tags=["Tasks"])
 app.include_router(settings.router, prefix="/api/settings", tags=["Settings"])
 app.include_router(connections.router, prefix="/api/settings/connections", tags=["Connections"])
-app.include_router(environments.router, prefix="/api/environments", tags=["Environments"])
-app.include_router(mappings.router)
+app.include_router(environments.router, tags=["Environments"])
+app.include_router(mappings.router, prefix="/api/mappings", tags=["Mappings"])
 app.include_router(migration.router)
-app.include_router(git.router)
-app.include_router(llm.router)
+app.include_router(git.router, prefix="/api/git", tags=["Git"])
+app.include_router(llm.router, prefix="/api/llm", tags=["LLM"])
 app.include_router(storage.router, prefix="/api/storage", tags=["Storage"])
+app.include_router(dashboards.router)
+app.include_router(datasets.router)
+
+
+# [DEF:api.include_routers:Action]
+# @PURPOSE: Registers all API routers with the FastAPI application.
+# @LAYER: API
+# @SEMANTICS: routes, registration, api
+# [/DEF:api.include_routers:Action]

 # [DEF:websocket_endpoint:Function]
 # @PURPOSE: Provides a WebSocket endpoint for real-time log streaming of a task with server-side filtering.
@@ -234,25 +240,20 @@ async def websocket_endpoint(
 frontend_path = project_root / "frontend" / "build"
 if frontend_path.exists():
    app.mount("/_app", StaticFiles(directory=str(frontend_path / "_app")), name="static")
-    
-    # Serve other static files from the root of build directory
-    # [DEF:serve_spa:Function]
-    # @PURPOSE: Serves frontend static files or index.html for SPA routing.
-    # @PRE: file_path is requested by the client.
-    # @POST: Returns the requested file or index.html as a fallback.
-    @app.get("/{file_path:path}")
+
+    @app.get("/{file_path:path}", include_in_schema=False)
    async def serve_spa(file_path: str):
-        with belief_scope("serve_spa", f"path={file_path}"):
-            # Don't serve SPA for API routes that fell through
-            if file_path.startswith("api/"):
-                logger.info(f"[DEBUG] API route fell through to serve_spa: {file_path}")
-                raise HTTPException(status_code=404, detail=f"API endpoint not found: {file_path}")
-                
-            full_path = frontend_path / file_path
-            if full_path.is_file():
-                return FileResponse(str(full_path))
-            # Fallback to index.html for SPA routing
-            return FileResponse(str(frontend_path / "index.html"))
+        # Only serve SPA for non-API paths
+        # API routes are registered separately and should be matched by FastAPI first
+        if file_path and (file_path.startswith("api/") or file_path.startswith("/api/") or file_path == "api"):
+            # This should not happen if API routers are properly registered
+            # Return 404 instead of serving HTML
+            raise HTTPException(status_code=404, detail=f"API endpoint not found: {file_path}")
+        
+        full_path = frontend_path / file_path
+        if file_path and full_path.is_file():
+            return FileResponse(str(full_path))
+        return FileResponse(str(frontend_path / "index.html"))
    # [/DEF:serve_spa:Function]
 else:
    # [DEF:read_root:Function]
--- a/backend/src/core/auth/tests/test_auth.py
+++ b/backend/src/core/auth/tests/test_auth.py
@@ -0,0 +1,179 @@
+# [DEF:test_auth:Module]
+# @TIER: STANDARD
+# @PURPOSE: Unit tests for authentication module
+# @LAYER: Domain
+# @RELATION: VERIFIES -> src.core.auth
+
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.append(str(Path(__file__).parent.parent.parent.parent / "src"))
+
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from src.core.database import Base
+from src.models.auth import User, Role, Permission, ADGroupMapping
+from src.services.auth_service import AuthService
+from src.core.auth.repository import AuthRepository
+from src.core.auth.security import verify_password, get_password_hash
+
+# Create in-memory SQLite database for testing
+SQLALCHEMY_DATABASE_URL = "sqlite:///:memory:"
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
+TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Create all tables
+Base.metadata.create_all(bind=engine)
+
+
+@pytest.fixture
+def db_session():
+    """Create a new database session with a transaction, rollback after test"""
+    connection = engine.connect()
+    transaction = connection.begin()
+    session = TestingSessionLocal(bind=connection)
+    
+    yield session
+    
+    session.close()
+    transaction.rollback()
+    connection.close()
+
+
+@pytest.fixture
+def auth_service(db_session):
+    return AuthService(db_session)
+
+
+@pytest.fixture
+def auth_repo(db_session):
+    return AuthRepository(db_session)
+
+
+def test_create_user(auth_repo):
+    """Test user creation"""
+    user = User(
+        username="testuser",
+        email="test@example.com",
+        password_hash=get_password_hash("testpassword123"),
+        auth_source="LOCAL"
+    )
+    
+    auth_repo.db.add(user)
+    auth_repo.db.commit()
+    
+    retrieved_user = auth_repo.get_user_by_username("testuser")
+    assert retrieved_user is not None
+    assert retrieved_user.username == "testuser"
+    assert retrieved_user.email == "test@example.com"
+    assert verify_password("testpassword123", retrieved_user.password_hash)
+
+
+def test_authenticate_user(auth_service, auth_repo):
+    """Test user authentication with valid and invalid credentials"""
+    user = User(
+        username="testuser",
+        email="test@example.com",
+        password_hash=get_password_hash("testpassword123"),
+        auth_source="LOCAL"
+    )
+    
+    auth_repo.db.add(user)
+    auth_repo.db.commit()
+    
+    # Test valid credentials
+    authenticated_user = auth_service.authenticate_user("testuser", "testpassword123")
+    assert authenticated_user is not None
+    assert authenticated_user.username == "testuser"
+    
+    # Test invalid password
+    invalid_user = auth_service.authenticate_user("testuser", "wrongpassword")
+    assert invalid_user is None
+    
+    # Test invalid username
+    invalid_user = auth_service.authenticate_user("nonexistent", "testpassword123")
+    assert invalid_user is None
+
+
+def test_create_session(auth_service, auth_repo):
+    """Test session token creation"""
+    user = User(
+        username="testuser",
+        email="test@example.com",
+        password_hash=get_password_hash("testpassword123"),
+        auth_source="LOCAL"
+    )
+    
+    auth_repo.db.add(user)
+    auth_repo.db.commit()
+    
+    session = auth_service.create_session(user)
+    assert "access_token" in session
+    assert "token_type" in session
+    assert session["token_type"] == "bearer"
+    assert len(session["access_token"]) > 0
+
+
+def test_role_permission_association(auth_repo):
+    """Test role and permission association"""
+    role = Role(name="Admin", description="System administrator")
+    perm1 = Permission(resource="admin:users", action="READ")
+    perm2 = Permission(resource="admin:users", action="WRITE")
+    
+    role.permissions.extend([perm1, perm2])
+    
+    auth_repo.db.add(role)
+    auth_repo.db.commit()
+    
+    retrieved_role = auth_repo.get_role_by_name("Admin")
+    assert retrieved_role is not None
+    assert len(retrieved_role.permissions) == 2
+    
+    permissions = [f"{p.resource}:{p.action}" for p in retrieved_role.permissions]
+    assert "admin:users:READ" in permissions
+    assert "admin:users:WRITE" in permissions
+
+
+def test_user_role_association(auth_repo):
+    """Test user and role association"""
+    role = Role(name="Admin", description="System administrator")
+    user = User(
+        username="adminuser",
+        email="admin@example.com",
+        password_hash=get_password_hash("adminpass123"),
+        auth_source="LOCAL"
+    )
+    
+    user.roles.append(role)
+    
+    auth_repo.db.add(role)
+    auth_repo.db.add(user)
+    auth_repo.db.commit()
+    
+    retrieved_user = auth_repo.get_user_by_username("adminuser")
+    assert retrieved_user is not None
+    assert len(retrieved_user.roles) == 1
+    assert retrieved_user.roles[0].name == "Admin"
+
+
+def test_ad_group_mapping(auth_repo):
+    """Test AD group mapping"""
+    role = Role(name="ADFS_Admin", description="ADFS administrators")
+    
+    auth_repo.db.add(role)
+    auth_repo.db.commit()
+    
+    mapping = ADGroupMapping(ad_group="DOMAIN\\ADFS_Admins", role_id=role.id)
+    
+    auth_repo.db.add(mapping)
+    auth_repo.db.commit()
+    
+    retrieved_mapping = auth_repo.db.query(ADGroupMapping).filter_by(ad_group="DOMAIN\\ADFS_Admins").first()
+    assert retrieved_mapping is not None
+    assert retrieved_mapping.role_id == role.id
+
+
+# [/DEF:test_auth:Module]
--- a/backend/src/core/auth/config.py
+++ b/backend/src/core/auth/config.py
@@ -10,7 +10,6 @@
 # [SECTION: IMPORTS]
 from pydantic import Field
 from pydantic_settings import BaseSettings
-import os
 # [/SECTION]

 # [DEF:AuthConfig:Class]
--- a/backend/src/core/auth/jwt.py
+++ b/backend/src/core/auth/jwt.py
@@ -11,8 +11,8 @@

 # [SECTION: IMPORTS]
 from datetime import datetime, timedelta
-from typing import Optional, List
-from jose import JWTError, jwt
+from typing import Optional
+from jose import jwt
 from .config import auth_config
 from ..logger import belief_scope
 # [/SECTION]
--- a/backend/src/core/auth/repository.py
+++ b/backend/src/core/auth/repository.py
@@ -11,7 +11,7 @@
 # [SECTION: IMPORTS]
 from typing import Optional, List
 from sqlalchemy.orm import Session
-from ...models.auth import User, Role, Permission, ADGroupMapping
+from ...models.auth import User, Role, Permission
 from ..logger import belief_scope
 # [/SECTION]

--- a/backend/src/core/config_manager.py
+++ b/backend/src/core/config_manager.py
@@ -15,7 +15,7 @@ import json
 import os
 from pathlib import Path
 from typing import Optional, List
-from .config_models import AppConfig, Environment, GlobalSettings
+from .config_models import AppConfig, Environment, GlobalSettings, StorageConfig
 from .logger import logger, configure_logger, belief_scope
 # [/SECTION]

@@ -46,7 +46,7 @@ class ConfigManager:
            # 3. Runtime check of @POST
            assert isinstance(self.config, AppConfig), "self.config must be an instance of AppConfig"

-            logger.info(f"[ConfigManager][Exit] Initialized")
+            logger.info("[ConfigManager][Exit] Initialized")
    # [/DEF:__init__:Function]

    # [DEF:_load_config:Function]
@@ -59,7 +59,7 @@ class ConfigManager:
            logger.debug(f"[_load_config][Entry] Loading from {self.config_path}")
        
        if not self.config_path.exists():
-            logger.info(f"[_load_config][Action] Config file not found. Creating default.")
+            logger.info("[_load_config][Action] Config file not found. Creating default.")
            default_config = AppConfig(
                environments=[],
                settings=GlobalSettings()
@@ -75,7 +75,7 @@ class ConfigManager:
                    del data["settings"]["backup_path"]

                config = AppConfig(**data)
-                logger.info(f"[_load_config][Coherence:OK] Configuration loaded")
+                logger.info("[_load_config][Coherence:OK] Configuration loaded")
                return config
        except Exception as e:
            logger.error(f"[_load_config][Coherence:Failed] Error loading config: {e}")
@@ -103,7 +103,7 @@ class ConfigManager:
        try:
            with open(self.config_path, "w") as f:
                json.dump(config.dict(), f, indent=4)
-            logger.info(f"[_save_config_to_disk][Action] Configuration saved")
+            logger.info("[_save_config_to_disk][Action] Configuration saved")
        except Exception as e:
            logger.error(f"[_save_config_to_disk][Coherence:Failed] Failed to save: {e}")
    # [/DEF:_save_config_to_disk:Function]
@@ -134,7 +134,7 @@ class ConfigManager:
    # @PARAM: settings (GlobalSettings) - The new global settings.
    def update_global_settings(self, settings: GlobalSettings):
        with belief_scope("update_global_settings"):
-            logger.info(f"[update_global_settings][Entry] Updating settings")
+            logger.info("[update_global_settings][Entry] Updating settings")
        
        # 1. Runtime check of @PRE
        assert isinstance(settings, GlobalSettings), "settings must be an instance of GlobalSettings"
@@ -146,7 +146,7 @@ class ConfigManager:
        # Reconfigure logger with new settings
        configure_logger(settings.logging)

-        logger.info(f"[update_global_settings][Exit] Settings updated")
+        logger.info("[update_global_settings][Exit] Settings updated")
    # [/DEF:update_global_settings:Function]

    # [DEF:validate_path:Function]
@@ -222,7 +222,7 @@ class ConfigManager:
        self.config.environments.append(env)
        self.save()
        
-        logger.info(f"[add_environment][Exit] Environment added")
+        logger.info("[add_environment][Exit] Environment added")
    # [/DEF:add_environment:Function]

    # [DEF:update_environment:Function]
--- a/backend/src/core/config_models.py
+++ b/backend/src/core/config_models.py
@@ -48,6 +48,8 @@ class GlobalSettings(BaseModel):
    storage: StorageConfig = Field(default_factory=StorageConfig)
    default_environment_id: Optional[str] = None
    logging: LoggingConfig = Field(default_factory=LoggingConfig)
+    connections: List[dict] = []
+    llm: dict = Field(default_factory=lambda: {"providers": [], "default_provider": ""})
    
    # Task retention settings
    task_retention_days: int = 30
--- a/backend/src/core/database.py
+++ b/backend/src/core/database.py
@@ -11,14 +11,9 @@

 # [SECTION: IMPORTS]
 from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.orm import sessionmaker
 from ..models.mapping import Base
 # Import models to ensure they're registered with Base
-from ..models.task import TaskRecord
-from ..models.connection import ConnectionConfig
-from ..models.git import GitServerConfig, GitRepository, DeploymentEnvironment
-from ..models.auth import User, Role, Permission, ADGroupMapping
-from ..models.llm import LLMProvider, ValidationRecord
 from .logger import belief_scope
 from .auth.config import auth_config
 import os
--- a/backend/src/core/logger.py
+++ b/backend/src/core/logger.py
@@ -111,7 +111,6 @@ def configure_logger(config):

    # Add file handler if file_path is set
    if config.file_path:
-        import os
        from pathlib import Path
        log_file = Path(config.file_path)
        log_file.parent.mkdir(parents=True, exist_ok=True)
--- a/backend/src/core/logger/tests/test_logger.py
+++ b/backend/src/core/logger/tests/test_logger.py
@@ -0,0 +1,228 @@
+# [DEF:test_logger:Module]
+# @TIER: STANDARD
+# @PURPOSE: Unit tests for logger module
+# @LAYER: Infra
+# @RELATION: VERIFIES -> src.core.logger
+
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.append(str(Path(__file__).parent.parent.parent.parent / "src"))
+
+import pytest
+from src.core.logger import (
+    belief_scope,
+    logger,
+    configure_logger,
+    get_task_log_level,
+    should_log_task_level
+)
+from src.core.config_models import LoggingConfig
+
+
+# [DEF:test_belief_scope_logs_entry_action_exit_at_debug:Function]
+# @PURPOSE: Test that belief_scope generates [ID][Entry], [ID][Action], and [ID][Exit] logs at DEBUG level.
+# @PRE: belief_scope is available. caplog fixture is used. Logger configured to DEBUG.
+# @POST: Logs are verified to contain Entry, Action, and Exit tags at DEBUG level.
+def test_belief_scope_logs_entry_action_exit_at_debug(caplog):
+    """Test that belief_scope generates [ID][Entry], [ID][Action], and [ID][Exit] logs at DEBUG level."""
+    # Configure logger to DEBUG level
+    config = LoggingConfig(
+        level="DEBUG",
+        task_log_level="DEBUG",
+        enable_belief_state=True
+    )
+    configure_logger(config)
+    
+    caplog.set_level("DEBUG")
+
+    with belief_scope("TestFunction"):
+        logger.info("Doing something important")
+
+    # Check that the logs contain the expected patterns
+    log_messages = [record.message for record in caplog.records]
+
+    assert any("[TestFunction][Entry]" in msg for msg in log_messages), "Entry log not found"
+    assert any("[TestFunction][Action] Doing something important" in msg for msg in log_messages), "Action log not found"
+    assert any("[TestFunction][Exit]" in msg for msg in log_messages), "Exit log not found"
+    
+    # Reset to INFO
+    config = LoggingConfig(level="INFO", task_log_level="INFO", enable_belief_state=True)
+    configure_logger(config)
+# [/DEF:test_belief_scope_logs_entry_action_exit_at_debug:Function]
+
+
+# [DEF:test_belief_scope_error_handling:Function]
+# @PURPOSE: Test that belief_scope logs Coherence:Failed on exception.
+# @PRE: belief_scope is available. caplog fixture is used. Logger configured to DEBUG.
+# @POST: Logs are verified to contain Coherence:Failed tag.
+def test_belief_scope_error_handling(caplog):
+    """Test that belief_scope logs Coherence:Failed on exception."""
+    # Configure logger to DEBUG level
+    config = LoggingConfig(
+        level="DEBUG",
+        task_log_level="DEBUG",
+        enable_belief_state=True
+    )
+    configure_logger(config)
+    
+    caplog.set_level("DEBUG")
+
+    with pytest.raises(ValueError):
+        with belief_scope("FailingFunction"):
+            raise ValueError("Something went wrong")
+
+    log_messages = [record.message for record in caplog.records]
+
+    assert any("[FailingFunction][Entry]" in msg for msg in log_messages), "Entry log not found"
+    assert any("[FailingFunction][Coherence:Failed]" in msg for msg in log_messages), "Failed coherence log not found"
+    # Exit should not be logged on failure
+    
+    # Reset to INFO
+    config = LoggingConfig(level="INFO", task_log_level="INFO", enable_belief_state=True)
+    configure_logger(config)
+# [/DEF:test_belief_scope_error_handling:Function]
+
+
+# [DEF:test_belief_scope_success_coherence:Function]
+# @PURPOSE: Test that belief_scope logs Coherence:OK on success.
+# @PRE: belief_scope is available. caplog fixture is used. Logger configured to DEBUG.
+# @POST: Logs are verified to contain Coherence:OK tag.
+def test_belief_scope_success_coherence(caplog):
+    """Test that belief_scope logs Coherence:OK on success."""
+    # Configure logger to DEBUG level
+    config = LoggingConfig(
+        level="DEBUG",
+        task_log_level="DEBUG",
+        enable_belief_state=True
+    )
+    configure_logger(config)
+    
+    caplog.set_level("DEBUG")
+
+    with belief_scope("SuccessFunction"):
+        pass
+
+    log_messages = [record.message for record in caplog.records]
+
+    assert any("[SuccessFunction][Coherence:OK]" in msg for msg in log_messages), "Success coherence log not found"
+    
+    # Reset to INFO
+    config = LoggingConfig(level="INFO", task_log_level="INFO", enable_belief_state=True)
+    configure_logger(config)
+# [/DEF:test_belief_scope_success_coherence:Function]
+
+
+# [DEF:test_belief_scope_not_visible_at_info:Function]
+# @PURPOSE: Test that belief_scope Entry/Exit/Coherence logs are NOT visible at INFO level.
+# @PRE: belief_scope is available. caplog fixture is used.
+# @POST: Entry/Exit/Coherence logs are not captured at INFO level.
+def test_belief_scope_not_visible_at_info(caplog):
+    """Test that belief_scope Entry/Exit/Coherence logs are NOT visible at INFO level."""
+    caplog.set_level("INFO")
+
+    with belief_scope("InfoLevelFunction"):
+        logger.info("Doing something important")
+
+    log_messages = [record.message for record in caplog.records]
+
+    # Action log should be visible
+    assert any("[InfoLevelFunction][Action] Doing something important" in msg for msg in log_messages), "Action log not found"
+    # Entry/Exit/Coherence should NOT be visible at INFO level
+    assert not any("[InfoLevelFunction][Entry]" in msg for msg in log_messages), "Entry log should not be visible at INFO"
+    assert not any("[InfoLevelFunction][Exit]" in msg for msg in log_messages), "Exit log should not be visible at INFO"
+    assert not any("[InfoLevelFunction][Coherence:OK]" in msg for msg in log_messages), "Coherence log should not be visible at INFO"
+# [/DEF:test_belief_scope_not_visible_at_info:Function]
+
+
+# [DEF:test_task_log_level_default:Function]
+# @PURPOSE: Test that default task log level is INFO.
+# @PRE: None.
+# @POST: Default level is INFO.
+def test_task_log_level_default():
+    """Test that default task log level is INFO."""
+    level = get_task_log_level()
+    assert level == "INFO"
+# [/DEF:test_task_log_level_default:Function]
+
+
+# [DEF:test_should_log_task_level:Function]
+# @PURPOSE: Test that should_log_task_level correctly filters log levels.
+# @PRE: None.
+# @POST: Filtering works correctly for all level combinations.
+def test_should_log_task_level():
+    """Test that should_log_task_level correctly filters log levels."""
+    # Default level is INFO
+    assert should_log_task_level("ERROR") is True, "ERROR should be logged at INFO threshold"
+    assert should_log_task_level("WARNING") is True, "WARNING should be logged at INFO threshold"
+    assert should_log_task_level("INFO") is True, "INFO should be logged at INFO threshold"
+    assert should_log_task_level("DEBUG") is False, "DEBUG should NOT be logged at INFO threshold"
+# [/DEF:test_should_log_task_level:Function]
+
+
+# [DEF:test_configure_logger_task_log_level:Function]
+# @PURPOSE: Test that configure_logger updates task_log_level.
+# @PRE: LoggingConfig is available.
+# @POST: task_log_level is updated correctly.
+def test_configure_logger_task_log_level():
+    """Test that configure_logger updates task_log_level."""
+    config = LoggingConfig(
+        level="DEBUG",
+        task_log_level="DEBUG",
+        enable_belief_state=True
+    )
+    configure_logger(config)
+    
+    assert get_task_log_level() == "DEBUG", "task_log_level should be DEBUG"
+    assert should_log_task_level("DEBUG") is True, "DEBUG should be logged at DEBUG threshold"
+    
+    # Reset to INFO
+    config = LoggingConfig(
+        level="INFO",
+        task_log_level="INFO",
+        enable_belief_state=True
+    )
+    configure_logger(config)
+    assert get_task_log_level() == "INFO", "task_log_level should be reset to INFO"
+# [/DEF:test_configure_logger_task_log_level:Function]
+
+
+# [DEF:test_enable_belief_state_flag:Function]
+# @PURPOSE: Test that enable_belief_state flag controls belief_scope logging.
+# @PRE: LoggingConfig is available. caplog fixture is used.
+# @POST: belief_scope logs are controlled by the flag.
+def test_enable_belief_state_flag(caplog):
+    """Test that enable_belief_state flag controls belief_scope logging."""
+    # Disable belief state
+    config = LoggingConfig(
+        level="DEBUG",
+        task_log_level="DEBUG",
+        enable_belief_state=False
+    )
+    configure_logger(config)
+    
+    caplog.set_level("DEBUG")
+    
+    with belief_scope("DisabledFunction"):
+        logger.info("Doing something")
+    
+    log_messages = [record.message for record in caplog.records]
+    
+    # Entry and Exit should NOT be logged when disabled
+    assert not any("[DisabledFunction][Entry]" in msg for msg in log_messages), "Entry should not be logged when disabled"
+    assert not any("[DisabledFunction][Exit]" in msg for msg in log_messages), "Exit should not be logged when disabled"
+    # Coherence:OK should still be logged (internal tracking)
+    assert any("[DisabledFunction][Coherence:OK]" in msg for msg in log_messages), "Coherence should still be logged"
+    
+    # Re-enable for other tests
+    config = LoggingConfig(
+        level="DEBUG",
+        task_log_level="DEBUG",
+        enable_belief_state=True
+    )
+    configure_logger(config)
+# [/DEF:test_enable_belief_state_flag:Function]
+
+
+# [/DEF:test_logger:Module]
--- a/backend/src/core/migration_engine.py
+++ b/backend/src/core/migration_engine.py
@@ -11,12 +11,10 @@
 import zipfile
 import yaml
 import os
-import shutil
 import tempfile
 from pathlib import Path
 from typing import Dict
 from .logger import logger, belief_scope
-import yaml
 # [/SECTION]

 # [DEF:MigrationEngine:Class]
--- a/backend/src/core/plugin_loader.py
+++ b/backend/src/core/plugin_loader.py
@@ -1,9 +1,8 @@
 import importlib.util
 import os
 import sys # Added this line
-from typing import Dict, Type, List, Optional
+from typing import Dict, List, Optional
 from .plugin_base import PluginBase, PluginConfig
-from jsonschema import validate
 from .logger import belief_scope

 # [DEF:PluginLoader:Class]
--- a/backend/src/core/scheduler.py
+++ b/backend/src/core/scheduler.py
@@ -10,7 +10,6 @@ from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 from .logger import logger, belief_scope
 from .config_manager import ConfigManager
-from typing import Optional
 import asyncio
 # [/SECTION]

--- a/backend/src/core/superset_client.py
+++ b/backend/src/core/superset_client.py
@@ -13,10 +13,10 @@
 import json
 import zipfile
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Dict, List, Optional, Tuple, Union, cast
 from requests import Response
 from .logger import logger as app_logger, belief_scope
-from .utils.network import APIClient, SupersetAPIError, AuthenticationError, DashboardNotFoundError, NetworkError
+from .utils.network import APIClient, SupersetAPIError
 from .utils.fileio import get_filename_from_headers
 from .config_models import Environment
 # [/SECTION]
@@ -87,11 +87,11 @@ class SupersetClient:
            if 'columns' not in validated_query:
                validated_query['columns'] = ["slug", "id", "changed_on_utc", "dashboard_title", "published"]
            
-            total_count = self._fetch_total_object_count(endpoint="/dashboard/")
            paginated_data = self._fetch_all_pages(
                endpoint="/dashboard/",
-                pagination_options={"base_query": validated_query, "total_count": total_count, "results_field": "result"},
+                pagination_options={"base_query": validated_query, "results_field": "result"},
            )
+            total_count = len(paginated_data)
            app_logger.info("[get_dashboards][Exit] Found %d dashboards.", total_count)
            return total_count, paginated_data
    # [/DEF:get_dashboards:Function]
@@ -203,15 +203,121 @@ class SupersetClient:
            app_logger.info("[get_datasets][Enter] Fetching datasets.")
            validated_query = self._validate_query_params(query)

-            total_count = self._fetch_total_object_count(endpoint="/dataset/")
            paginated_data = self._fetch_all_pages(
                endpoint="/dataset/",
-                pagination_options={"base_query": validated_query, "total_count": total_count, "results_field": "result"},
+                pagination_options={"base_query": validated_query, "results_field": "result"},
            )
+            total_count = len(paginated_data)
            app_logger.info("[get_datasets][Exit] Found %d datasets.", total_count)
            return total_count, paginated_data
    # [/DEF:get_datasets:Function]

+    # [DEF:get_datasets_summary:Function]
+    # @PURPOSE: Fetches dataset metadata optimized for the Dataset Hub grid.
+    # @PRE: Client is authenticated.
+    # @POST: Returns a list of dataset metadata summaries.
+    # @RETURN: List[Dict]
+    def get_datasets_summary(self) -> List[Dict]:
+        with belief_scope("SupersetClient.get_datasets_summary"):
+            query = {
+                "columns": ["id", "table_name", "schema", "database"]
+            }
+            _, datasets = self.get_datasets(query=query)
+
+            # Map fields to match the contracts
+            result = []
+            for ds in datasets:
+                result.append({
+                    "id": ds.get("id"),
+                    "table_name": ds.get("table_name"),
+                    "schema": ds.get("schema"),
+                    "database": ds.get("database", {}).get("database_name", "Unknown")
+                })
+            return result
+    # [/DEF:get_datasets_summary:Function]
+
+    # [DEF:get_dataset_detail:Function]
+    # @PURPOSE: Fetches detailed dataset information including columns and linked dashboards
+    # @PRE: Client is authenticated and dataset_id exists.
+    # @POST: Returns detailed dataset info with columns and linked dashboards.
+    # @PARAM: dataset_id (int) - The dataset ID to fetch details for.
+    # @RETURN: Dict - Dataset details with columns and linked_dashboards.
+    # @RELATION: CALLS -> self.get_dataset
+    # @RELATION: CALLS -> self.network.request (for related_objects)
+    def get_dataset_detail(self, dataset_id: int) -> Dict:
+        with belief_scope("SupersetClient.get_dataset_detail", f"id={dataset_id}"):
+            # Get base dataset info
+            response = self.get_dataset(dataset_id)
+            
+            # If the response is a dict and has a 'result' key, use that (standard Superset API)
+            if isinstance(response, dict) and 'result' in response:
+                dataset = response['result']
+            else:
+                dataset = response
+
+            # Extract columns information
+            columns = dataset.get("columns", [])
+            column_info = []
+            for col in columns:
+                column_info.append({
+                    "id": col.get("id"),
+                    "name": col.get("column_name"),
+                    "type": col.get("type"),
+                    "is_dttm": col.get("is_dttm", False),
+                    "is_active": col.get("is_active", True),
+                    "description": col.get("description", "")
+                })
+            
+            # Get linked dashboards using related_objects endpoint
+            linked_dashboards = []
+            try:
+                related_objects = self.network.request(
+                    method="GET",
+                    endpoint=f"/dataset/{dataset_id}/related_objects"
+                )
+                
+                # Handle different response formats
+                if isinstance(related_objects, dict):
+                    if "dashboards" in related_objects:
+                        dashboards_data = related_objects["dashboards"]
+                    elif "result" in related_objects and isinstance(related_objects["result"], dict):
+                        dashboards_data = related_objects["result"].get("dashboards", [])
+                    else:
+                        dashboards_data = []
+                    
+                    for dash in dashboards_data:
+                        linked_dashboards.append({
+                            "id": dash.get("id"),
+                            "title": dash.get("dashboard_title") or dash.get("title", "Unknown"),
+                            "slug": dash.get("slug")
+                        })
+            except Exception as e:
+                app_logger.warning(f"[get_dataset_detail][Warning] Failed to fetch related dashboards: {e}")
+                linked_dashboards = []
+            
+            # Extract SQL table information
+            sql = dataset.get("sql", "")
+            
+            result = {
+                "id": dataset.get("id"),
+                "table_name": dataset.get("table_name"),
+                "schema": dataset.get("schema"),
+                "database": dataset.get("database", {}).get("database_name", "Unknown"),
+                "description": dataset.get("description", ""),
+                "columns": column_info,
+                "column_count": len(column_info),
+                "sql": sql,
+                "linked_dashboards": linked_dashboards,
+                "linked_dashboard_count": len(linked_dashboards),
+                "is_sqllab_view": dataset.get("is_sqllab_view", False),
+                "created_on": dataset.get("created_on"),
+                "changed_on": dataset.get("changed_on")
+            }
+            
+            app_logger.info(f"[get_dataset_detail][Exit] Got dataset {dataset_id} with {len(column_info)} columns and {len(linked_dashboards)} linked dashboards")
+            return result
+    # [/DEF:get_dataset_detail:Function]
+
    # [DEF:get_dataset:Function]
    # @PURPOSE: Получает информацию о конкретном датасете по его ID.
    # @PARAM: dataset_id (int) - ID датасета.
@@ -264,11 +370,12 @@ class SupersetClient:
            validated_query = self._validate_query_params(query or {})
            if 'columns' not in validated_query:
                validated_query['columns'] = []
-            total_count = self._fetch_total_object_count(endpoint="/database/")
+            
            paginated_data = self._fetch_all_pages(
                endpoint="/database/",
-                pagination_options={"base_query": validated_query, "total_count": total_count, "results_field": "result"},
+                pagination_options={"base_query": validated_query, "results_field": "result"},
            )
+            total_count = len(paginated_data)
            app_logger.info("[get_databases][Exit] Found %d databases.", total_count)
            return total_count, paginated_data
    # [/DEF:get_databases:Function]
--- a/backend/src/core/task_manager/cleanup.py
+++ b/backend/src/core/task_manager/cleanup.py
@@ -5,7 +5,6 @@
 # @LAYER: Core
 # @RELATION: Uses TaskPersistenceService and TaskLogPersistenceService to delete old tasks and logs.

-from datetime import datetime, timedelta
 from typing import List
 from .persistence import TaskPersistenceService, TaskLogPersistenceService
 from ..logger import logger, belief_scope
--- a/backend/src/core/task_manager/context.py
+++ b/backend/src/core/task_manager/context.py
@@ -7,7 +7,7 @@
 # @INVARIANT: Each TaskContext is bound to a single task execution.

 # [SECTION: IMPORTS]
-from typing import Dict, Any, Optional, Callable
+from typing import Dict, Any, Callable
 from .task_logger import TaskLogger
 # [/SECTION]

--- a/backend/src/core/task_manager/manager.py
+++ b/backend/src/core/task_manager/manager.py
@@ -14,7 +14,7 @@ from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from typing import Dict, Any, List, Optional

-from .models import Task, TaskStatus, LogEntry, LogFilter, LogStats, TaskLog
+from .models import Task, TaskStatus, LogEntry, LogFilter, LogStats
 from .persistence import TaskPersistenceService, TaskLogPersistenceService
 from .context import TaskContext
 from ..logger import logger, belief_scope, should_log_task_level
@@ -136,7 +136,7 @@ class TaskManager:
                logger.error(f"Plugin with ID '{plugin_id}' not found.")
                raise ValueError(f"Plugin with ID '{plugin_id}' not found.")

-            plugin = self.plugin_loader.get_plugin(plugin_id)
+            self.plugin_loader.get_plugin(plugin_id)
            
            if not isinstance(params, dict):
                 logger.error("Task parameters must be a dictionary.")
@@ -248,7 +248,8 @@ class TaskManager:
    async def wait_for_resolution(self, task_id: str):
        with belief_scope("TaskManager.wait_for_resolution", f"task_id={task_id}"):
            task = self.tasks.get(task_id)
-            if not task: return
+            if not task:
+                return
            
            task.status = TaskStatus.AWAITING_MAPPING
            self.persistence_service.persist_task(task)
@@ -269,7 +270,8 @@ class TaskManager:
    async def wait_for_input(self, task_id: str):
        with belief_scope("TaskManager.wait_for_input", f"task_id={task_id}"):
            task = self.tasks.get(task_id)
-            if not task: return
+            if not task:
+                return
            
            # Status is already set to AWAITING_INPUT by await_input()
            self.task_futures[task_id] = self.loop.create_future()
--- a/backend/src/core/task_manager/persistence.py
+++ b/backend/src/core/task_manager/persistence.py
@@ -7,11 +7,10 @@

 # [SECTION: IMPORTS]
 from datetime import datetime
-from typing import List, Optional, Dict, Any
+from typing import List, Optional
 import json

 from sqlalchemy.orm import Session
-from sqlalchemy import and_, or_
 from ...models.task import TaskRecord, TaskLogRecord
 from ..database import TasksSessionLocal
 from .models import Task, TaskStatus, LogEntry, TaskLog, LogFilter, LogStats
--- a/backend/src/core/task_manager/task_logger.py
+++ b/backend/src/core/task_manager/task_logger.py
@@ -8,7 +8,6 @@

 # [SECTION: IMPORTS]
 from typing import Dict, Any, Optional, Callable
-from datetime import datetime
 # [/SECTION]

 # [DEF:TaskLogger:Class]
--- a/backend/src/core/utils/dataset_mapper.py
+++ b/backend/src/core/utils/dataset_mapper.py
@@ -11,7 +11,7 @@
 # [SECTION: IMPORTS]
 import pandas as pd  # type: ignore
 import psycopg2  # type: ignore
-from typing import Dict, List, Optional, Any
+from typing import Dict, Optional, Any
 from ..logger import logger as app_logger, belief_scope
 # [/SECTION]

--- a/backend/src/core/utils/fileio.py
+++ b/backend/src/core/utils/fileio.py
@@ -19,7 +19,6 @@ from datetime import date, datetime
 import shutil
 import zlib
 from dataclasses import dataclass
-import yaml
 from ..logger import logger as app_logger, belief_scope
 # [/SECTION]

--- a/backend/src/core/utils/matching.py
+++ b/backend/src/core/utils/matching.py
@@ -42,6 +42,8 @@ def suggest_mappings(source_databases: List[Dict], target_databases: List[Dict],
            name, score, index = match
            if score >= threshold:
                suggestions.append({
+                    "source_db": s_db['database_name'],
+                    "target_db": target_databases[index]['database_name'],
                    "source_db_uuid": s_db['uuid'],
                    "target_db_uuid": target_databases[index]['uuid'],
                    "confidence": score / 100.0
--- a/backend/src/core/utils/network.py
+++ b/backend/src/core/utils/network.py
@@ -118,14 +118,41 @@ class APIClient:
    def _init_session(self) -> requests.Session:
        with belief_scope("_init_session"):
            session = requests.Session()
+        
+        # Create a custom adapter that handles TLS issues
+        class TLSAdapter(HTTPAdapter):
+            def init_poolmanager(self, connections, maxsize, block=False):
+                from urllib3.poolmanager import PoolManager
+                import ssl
+                
+                # Create an SSL context that ignores TLSv1 unrecognized name errors
+                ctx = ssl.create_default_context()
+                ctx.set_ciphers('HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA')
+                
+                # Ignore TLSV1_UNRECOGNIZED_NAME errors by disabling hostname verification
+                # This is safe when verify_ssl is false (we're already not verifying the certificate)
+                ctx.check_hostname = False
+                
+                self.poolmanager = PoolManager(
+                    num_pools=connections,
+                    maxsize=maxsize,
+                    block=block,
+                    ssl_context=ctx
+                )
+        
        retries = Retry(total=3, backoff_factor=0.5, status_forcelist=[500, 502, 503, 504])
-        adapter = HTTPAdapter(max_retries=retries)
+        adapter = TLSAdapter(max_retries=retries)
        session.mount('http://', adapter)
        session.mount('https://', adapter)
+        
        if not self.request_settings["verify_ssl"]:
            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
            app_logger.warning("[_init_session][State] SSL verification disabled.")
-        session.verify = self.request_settings["verify_ssl"]
+            # When verify_ssl is false, we should also disable hostname verification
+            session.verify = False
+        else:
+            session.verify = True
+        
        return session
    # [/DEF:_init_session:Function]

@@ -177,7 +204,8 @@ class APIClient:
    # @POST: Returns headers including auth tokens.
    def headers(self) -> Dict[str, str]:
        with belief_scope("headers"):
-            if not self._authenticated: self.authenticate()
+            if not self._authenticated:
+                self.authenticate()
            return {
            "Authorization": f"Bearer {self._tokens['access_token']}",
            "X-CSRFToken": self._tokens.get("csrf_token", ""),
@@ -200,7 +228,8 @@ class APIClient:
        with belief_scope("request"):
            full_url = f"{self.base_url}{endpoint}"
        _headers = self.headers.copy()
-        if headers: _headers.update(headers)
+        if headers:
+            _headers.update(headers)
        
        try:
            response = self.session.request(method, full_url, headers=_headers, **kwargs)
@@ -223,9 +252,12 @@ class APIClient:
            status_code = e.response.status_code
        if status_code == 502 or status_code == 503 or status_code == 504:
            raise NetworkError(f"Environment unavailable (Status {status_code})", status_code=status_code) from e
-        if status_code == 404: raise DashboardNotFoundError(endpoint) from e
-        if status_code == 403: raise PermissionDeniedError() from e
-        if status_code == 401: raise AuthenticationError() from e
+        if status_code == 404:
+            raise DashboardNotFoundError(endpoint) from e
+        if status_code == 403:
+            raise PermissionDeniedError() from e
+        if status_code == 401:
+            raise AuthenticationError() from e
        raise SupersetAPIError(f"API Error {status_code}: {e.response.text}") from e
    # [/DEF:_handle_http_error:Function]

@@ -237,9 +269,12 @@ class APIClient:
    # @POST: Raises a NetworkError.
    def _handle_network_error(self, e: requests.exceptions.RequestException, url: str):
        with belief_scope("_handle_network_error"):
-            if isinstance(e, requests.exceptions.Timeout): msg = "Request timeout"
-            elif isinstance(e, requests.exceptions.ConnectionError): msg = "Connection error"
-            else: msg = f"Unknown network error: {e}"
+            if isinstance(e, requests.exceptions.Timeout):
+                msg = "Request timeout"
+            elif isinstance(e, requests.exceptions.ConnectionError):
+                msg = "Connection error"
+            else:
+                msg = f"Unknown network error: {e}"
            raise NetworkError(msg, url=url) from e
    # [/DEF:_handle_network_error:Function]

@@ -256,7 +291,9 @@ class APIClient:
    def upload_file(self, endpoint: str, file_info: Dict[str, Any], extra_data: Optional[Dict] = None, timeout: Optional[int] = None) -> Dict:
        with belief_scope("upload_file"):
            full_url = f"{self.base_url}{endpoint}"
-        _headers = self.headers.copy(); _headers.pop('Content-Type', None)
+            _headers = self.headers.copy()
+            _headers.pop('Content-Type', None)
+        
        
        file_obj, file_name, form_field = file_info.get("file_obj"), file_info.get("file_name"), file_info.get("form_field", "file")
        
@@ -318,20 +355,40 @@ class APIClient:
    # @PURPOSE: Автоматически собирает данные со всех страниц пагинированного эндпоинта.
    # @PARAM: endpoint (str) - Эндпоинт.
    # @PARAM: pagination_options (Dict[str, Any]) - Опции пагинации.
-    # @PRE: pagination_options must contain 'base_query', 'total_count', 'results_field'.
+    # @PRE: pagination_options must contain 'base_query', 'results_field'. 'total_count' is optional.
    # @POST: Returns all items across all pages.
    # @RETURN: List[Any] - Список данных.
    def fetch_paginated_data(self, endpoint: str, pagination_options: Dict[str, Any]) -> List[Any]:
        with belief_scope("fetch_paginated_data"):
-            base_query, total_count = pagination_options["base_query"], pagination_options["total_count"]
-        results_field, page_size = pagination_options["results_field"], base_query.get('page_size')
-        assert page_size and page_size > 0, "'page_size' must be a positive number."
+            base_query = pagination_options["base_query"]
+            total_count = pagination_options.get("total_count")
+        
+        results_field = pagination_options["results_field"]
+        count_field = pagination_options.get("count_field", "count")
+        page_size = base_query.get('page_size', 1000)
+        assert page_size > 0, "'page_size' must be a positive number."
        
        results = []
-        for page in range((total_count + page_size - 1) // page_size):
+        page = 0
+        
+        # Fetch first page to get data and total count if not provided
+        query = {**base_query, 'page': page}
+        response_json = cast(Dict[str, Any], self.request("GET", endpoint, params={"q": json.dumps(query)}))
+        
+        first_page_results = response_json.get(results_field, [])
+        results.extend(first_page_results)
+        
+        if total_count is None:
+            total_count = response_json.get(count_field, len(first_page_results))
+            app_logger.debug(f"[fetch_paginated_data][State] Total count resolved from first page: {total_count}")
+
+        # Fetch remaining pages
+        total_pages = (total_count + page_size - 1) // page_size
+        for page in range(1, total_pages):
            query = {**base_query, 'page': page}
            response_json = cast(Dict[str, Any], self.request("GET", endpoint, params={"q": json.dumps(query)}))
            results.extend(response_json.get(results_field, []))
+            
        return results
    # [/DEF:fetch_paginated_data:Function]

--- a/backend/src/dependencies.py
+++ b/backend/src/dependencies.py
@@ -1,11 +1,10 @@
 # [DEF:Dependencies:Module]
 # @SEMANTICS: dependency, injection, singleton, factory, auth, jwt
-# @PURPOSE: Manages the creation and provision of shared application dependencies, such as the PluginLoader and TaskManager, to avoid circular imports.
+# @PURPOSE: Manages creation and provision of shared application dependencies, such as PluginLoader and TaskManager, to avoid circular imports.
 # @LAYER: Core
-# @RELATION: Used by the main app and API routers to get access to shared instances.
+# @RELATION: Used by main app and API routers to get access to shared instances.

 from pathlib import Path
-from typing import Optional
 from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
 from jose import JWTError
@@ -13,8 +12,10 @@ from .core.plugin_loader import PluginLoader
 from .core.task_manager import TaskManager
 from .core.config_manager import ConfigManager
 from .core.scheduler import SchedulerService
+from .services.resource_service import ResourceService
+from .services.mapping_service import MappingService
 from .core.database import init_db, get_auth_db
-from .core.logger import logger, belief_scope
+from .core.logger import logger
 from .core.auth.jwt import decode_token
 from .core.auth.repository import AuthRepository
 from .models.auth import User
@@ -29,12 +30,12 @@ config_manager = ConfigManager(config_path=str(config_path))
 init_db()

 # [DEF:get_config_manager:Function]
-# @PURPOSE: Dependency injector for the ConfigManager.
+# @PURPOSE: Dependency injector for ConfigManager.
 # @PRE: Global config_manager must be initialized.
 # @POST: Returns shared ConfigManager instance.
 # @RETURN: ConfigManager - The shared config manager instance.
 def get_config_manager() -> ConfigManager:
-    """Dependency injector for the ConfigManager."""
+    """Dependency injector for ConfigManager."""
    return config_manager
 # [/DEF:get_config_manager:Function]

@@ -50,45 +51,68 @@ logger.info("TaskManager initialized")
 scheduler_service = SchedulerService(task_manager, config_manager)
 logger.info("SchedulerService initialized")

+resource_service = ResourceService()
+logger.info("ResourceService initialized")
+
 # [DEF:get_plugin_loader:Function]
-# @PURPOSE: Dependency injector for the PluginLoader.
+# @PURPOSE: Dependency injector for PluginLoader.
 # @PRE: Global plugin_loader must be initialized.
 # @POST: Returns shared PluginLoader instance.
 # @RETURN: PluginLoader - The shared plugin loader instance.
 def get_plugin_loader() -> PluginLoader:
-    """Dependency injector for the PluginLoader."""
+    """Dependency injector for PluginLoader."""
    return plugin_loader
 # [/DEF:get_plugin_loader:Function]

 # [DEF:get_task_manager:Function]
-# @PURPOSE: Dependency injector for the TaskManager.
+# @PURPOSE: Dependency injector for TaskManager.
 # @PRE: Global task_manager must be initialized.
 # @POST: Returns shared TaskManager instance.
 # @RETURN: TaskManager - The shared task manager instance.
 def get_task_manager() -> TaskManager:
-    """Dependency injector for the TaskManager."""
+    """Dependency injector for TaskManager."""
    return task_manager
 # [/DEF:get_task_manager:Function]

 # [DEF:get_scheduler_service:Function]
-# @PURPOSE: Dependency injector for the SchedulerService.
+# @PURPOSE: Dependency injector for SchedulerService.
 # @PRE: Global scheduler_service must be initialized.
 # @POST: Returns shared SchedulerService instance.
 # @RETURN: SchedulerService - The shared scheduler service instance.
 def get_scheduler_service() -> SchedulerService:
-    """Dependency injector for the SchedulerService."""
+    """Dependency injector for SchedulerService."""
    return scheduler_service
 # [/DEF:get_scheduler_service:Function]

+# [DEF:get_resource_service:Function]
+# @PURPOSE: Dependency injector for ResourceService.
+# @PRE: Global resource_service must be initialized.
+# @POST: Returns shared ResourceService instance.
+# @RETURN: ResourceService - The shared resource service instance.
+def get_resource_service() -> ResourceService:
+    """Dependency injector for ResourceService."""
+    return resource_service
+# [/DEF:get_resource_service:Function]
+
+# [DEF:get_mapping_service:Function]
+# @PURPOSE: Dependency injector for MappingService.
+# @PRE: Global config_manager must be initialized.
+# @POST: Returns new MappingService instance.
+# @RETURN: MappingService - A new mapping service instance.
+def get_mapping_service() -> MappingService:
+    """Dependency injector for MappingService."""
+    return MappingService(config_manager)
+# [/DEF:get_mapping_service:Function]
+
 # [DEF:oauth2_scheme:Variable]
 # @PURPOSE: OAuth2 password bearer scheme for token extraction.
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
 # [/DEF:oauth2_scheme:Variable]

 # [DEF:get_current_user:Function]
-# @PURPOSE: Dependency for retrieving the currently authenticated user from a JWT.
+# @PURPOSE: Dependency for retrieving currently authenticated user from a JWT.
 # @PRE:     JWT token provided in Authorization header.
-# @POST:    Returns the User object if token is valid.
+# @POST:    Returns User object if token is valid.
 # @THROW:   HTTPException 401 if token is invalid or user not found.
 # @PARAM:   token (str) - Extracted JWT token.
 # @PARAM:   db (Session) - Auth database session.
@@ -144,4 +168,4 @@ def has_permission(resource: str, action: str):
    return permission_checker
 # [/DEF:has_permission:Function]

-# [/DEF:Dependencies:Module]
+# [/DEF:Dependencies:Module]
--- a/backend/src/models/tests/test_models.py
+++ b/backend/src/models/tests/test_models.py
@@ -0,0 +1,36 @@
+# [DEF:test_models:Module]
+# @TIER: TRIVIAL
+# @PURPOSE: Unit tests for data models
+# @LAYER: Domain
+# @RELATION: VERIFIES -> src.models
+
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.append(str(Path(__file__).parent.parent.parent.parent / "src"))
+
+from src.core.config_models import Environment
+from src.core.logger import belief_scope
+
+
+# [DEF:test_environment_model:Function]
+# @PURPOSE: Tests that Environment model correctly stores values.
+# @PRE: Environment class is available.
+# @POST: Values are verified.
+def test_environment_model():
+    with belief_scope("test_environment_model"):
+        env = Environment(
+            id="test-id",
+            name="test-env",
+            url="http://localhost:8088/api/v1",
+            username="admin",
+            password="password"
+        )
+        assert env.id == "test-id"
+        assert env.name == "test-env"
+        assert env.url == "http://localhost:8088/api/v1"
+# [/DEF:test_environment_model:Function]
+
+
+# [/DEF:test_models:Module]
--- a/backend/src/models/auth.py
+++ b/backend/src/models/auth.py
@@ -11,7 +11,7 @@
 # [SECTION: IMPORTS]
 import uuid
 from datetime import datetime
-from sqlalchemy import Column, String, Boolean, DateTime, ForeignKey, Table, Enum
+from sqlalchemy import Column, String, Boolean, DateTime, ForeignKey, Table
 from sqlalchemy.orm import relationship
 from .mapping import Base
 # [/SECTION]
--- a/backend/src/models/git.py
+++ b/backend/src/models/git.py
@@ -8,7 +8,6 @@
 import enum
 from datetime import datetime
 from sqlalchemy import Column, String, Integer, DateTime, Enum, ForeignKey, Boolean
-from sqlalchemy.dialects.postgresql import UUID
 import uuid
 from src.core.database import Base

--- a/backend/src/models/llm.py
+++ b/backend/src/models/llm.py
@@ -5,7 +5,7 @@
 # @LAYER: Domain
 # @RELATION: INHERITS_FROM -> backend.src.models.mapping.Base

-from sqlalchemy import Column, String, Boolean, DateTime, JSON, Enum, Text
+from sqlalchemy import Column, String, Boolean, DateTime, JSON, Text
 from datetime import datetime
 import uuid
 from .mapping import Base
--- a/backend/src/plugins/backup.py
+++ b/backend/src/plugins/backup.py
@@ -95,7 +95,7 @@ class BackupPlugin(PluginBase):
        with belief_scope("get_schema"):
            config_manager = get_config_manager()
            envs = [e.name for e in config_manager.get_environments()]
-        default_path = config_manager.get_config().settings.storage.root_path
+        config_manager.get_config().settings.storage.root_path
        
        return {
            "type": "object",
@@ -113,14 +113,21 @@ class BackupPlugin(PluginBase):

    # [DEF:execute:Function]
    # @PURPOSE: Executes the dashboard backup logic with TaskContext support.
-    # @PARAM: params (Dict[str, Any]) - Backup parameters (env, backup_path).
+    # @PARAM: params (Dict[str, Any]) - Backup parameters (env, backup_path, dashboard_ids).
    # @PARAM: context (Optional[TaskContext]) - Task context for logging with source attribution.
    # @PRE: Target environment must be configured. params must be a dictionary.
    # @POST: All dashboards are exported and archived.
    async def execute(self, params: Dict[str, Any], context: Optional[TaskContext] = None):
        with belief_scope("execute"):
            config_manager = get_config_manager()
-            env_id = params.get("environment_id")
+            
+            # Support both parameter names: environment_id (for task creation) and env (for direct calls)
+            env_id = params.get("environment_id") or params.get("env")
+            dashboard_ids = params.get("dashboard_ids") or params.get("dashboards")
+            
+            # Log the incoming parameters for debugging
+            log = context.logger if context else app_logger
+            log.info(f"Backup parameters received: env_id={env_id}, dashboard_ids={dashboard_ids}")
            
            # Resolve environment name if environment_id is provided
            if env_id:
@@ -131,6 +138,8 @@ class BackupPlugin(PluginBase):
            env = params.get("env")
            if not env:
                raise KeyError("env")
+            
+            log.info(f"Backup started for environment: {env}, selected dashboards: {dashboard_ids}")

            storage_settings = config_manager.get_config().settings.storage
            # Use 'backups' subfolder within the storage root
@@ -156,8 +165,20 @@ class BackupPlugin(PluginBase):
                
                client = SupersetClient(env_config)
                
-                dashboard_count, dashboard_meta = client.get_dashboards()
-                superset_log.info(f"Found {dashboard_count} dashboards to export")
+                # Get all dashboards
+                all_dashboard_count, all_dashboard_meta = client.get_dashboards()
+                superset_log.info(f"Found {all_dashboard_count} total dashboards in environment")
+                
+                # Filter dashboards if specific IDs are provided
+                if dashboard_ids:
+                    dashboard_ids_int = [int(did) for did in dashboard_ids]
+                    dashboard_meta = [db for db in all_dashboard_meta if db.get('id') in dashboard_ids_int]
+                    dashboard_count = len(dashboard_meta)
+                    superset_log.info(f"Filtered to {dashboard_count} selected dashboards: {dashboard_ids_int}")
+                else:
+                    dashboard_count = all_dashboard_count
+                    superset_log.info("No dashboard filter applied - backing up all dashboards")
+                    dashboard_meta = all_dashboard_meta

                if dashboard_count == 0:
                    log.info("No dashboards to back up")
--- a/backend/src/plugins/git/llm_extension.py
+++ b/backend/src/plugins/git/llm_extension.py
@@ -5,10 +5,9 @@
 # @LAYER: Domain
 # @RELATION: DEPENDS_ON -> backend.src.plugins.llm_analysis.service.LLMClient

-from typing import List, Optional
+from typing import List
 from tenacity import retry, stop_after_attempt, wait_exponential
 from ..llm_analysis.service import LLMClient
-from ..llm_analysis.models import LLMProviderType
 from ...core.logger import belief_scope, logger

 # [DEF:GitLLMExtension:Class]
--- a/backend/src/plugins/git_plugin.py
+++ b/backend/src/plugins/git_plugin.py
@@ -54,7 +54,7 @@ class GitPlugin(PluginBase):
                    self.config_manager = config_manager
                    app_logger.info("GitPlugin initialized using shared config_manager.")
                    return
-                except:
+                except Exception:
                    config_path = "config.json"

            self.config_manager = ConfigManager(config_path)
@@ -135,7 +135,7 @@ class GitPlugin(PluginBase):
    # @POST: Плагин готов к выполнению задач.
    async def initialize(self):
        with belief_scope("GitPlugin.initialize"):
-            logger.info("[GitPlugin.initialize][Action] Initializing Git Integration Plugin logic.")
+            app_logger.info("[GitPlugin.initialize][Action] Initializing Git Integration Plugin logic.")

    # [DEF:execute:Function]
    # @PURPOSE: Основной метод выполнения задач плагина с поддержкой TaskContext.
@@ -246,15 +246,15 @@ class GitPlugin(PluginBase):
                # 5. Автоматический staging изменений (не коммит, чтобы юзер мог проверить diff)
                try:
                    repo.git.add(A=True)
-                    logger.info(f"[_handle_sync][Action] Changes staged in git")
+                    app_logger.info("[_handle_sync][Action] Changes staged in git")
                except Exception as ge:
-                    logger.warning(f"[_handle_sync][Action] Failed to stage changes: {ge}")
+                    app_logger.warning(f"[_handle_sync][Action] Failed to stage changes: {ge}")

-                logger.info(f"[_handle_sync][Coherence:OK] Dashboard {dashboard_id} synced successfully.")
+                app_logger.info(f"[_handle_sync][Coherence:OK] Dashboard {dashboard_id} synced successfully.")
                return {"status": "success", "message": "Dashboard synced and flattened in local repository"}

            except Exception as e:
-                logger.error(f"[_handle_sync][Coherence:Failed] Sync failed: {e}")
+                app_logger.error(f"[_handle_sync][Coherence:Failed] Sync failed: {e}")
                raise
    # [/DEF:_handle_sync:Function]

@@ -292,7 +292,8 @@ class GitPlugin(PluginBase):
                        if ".git" in dirs:
                            dirs.remove(".git")
                        for file in files:
-                            if file == ".git" or file.endswith(".zip"): continue
+                            if file == ".git" or file.endswith(".zip"):
+                                continue
                            file_path = Path(root) / file
                            # Prepend the root directory name to the archive path
                            arcname = Path(root_dir_name) / file_path.relative_to(repo_path)
@@ -315,16 +316,16 @@ class GitPlugin(PluginBase):
                    f.write(zip_buffer.getvalue())
                
                try:
-                    logger.info(f"[_handle_deploy][Action] Importing dashboard to {env.name}")
+                    app_logger.info(f"[_handle_deploy][Action] Importing dashboard to {env.name}")
                    result = client.import_dashboard(temp_zip_path)
-                    logger.info(f"[_handle_deploy][Coherence:OK] Deployment successful for dashboard {dashboard_id}.")
+                    app_logger.info(f"[_handle_deploy][Coherence:OK] Deployment successful for dashboard {dashboard_id}.")
                    return {"status": "success", "message": f"Dashboard deployed to {env.name}", "details": result}
                finally:
                    if temp_zip_path.exists():
                        os.remove(temp_zip_path)

            except Exception as e:
-                logger.error(f"[_handle_deploy][Coherence:Failed] Deployment failed: {e}")
+                app_logger.error(f"[_handle_deploy][Coherence:Failed] Deployment failed: {e}")
                raise
    # [/DEF:_handle_deploy:Function]

@@ -336,13 +337,13 @@ class GitPlugin(PluginBase):
    # @RETURN: Environment - Объект конфигурации окружения.
    def _get_env(self, env_id: Optional[str] = None):
        with belief_scope("GitPlugin._get_env"):
-            logger.info(f"[_get_env][Entry] Fetching environment for ID: {env_id}")
+            app_logger.info(f"[_get_env][Entry] Fetching environment for ID: {env_id}")
            
            # Priority 1: ConfigManager (config.json)
            if env_id:
                env = self.config_manager.get_environment(env_id)
                if env:
-                    logger.info(f"[_get_env][Exit] Found environment by ID in ConfigManager: {env.name}")
+                    app_logger.info(f"[_get_env][Exit] Found environment by ID in ConfigManager: {env.name}")
                    return env
            
            # Priority 2: Database (DeploymentEnvironment)
@@ -355,12 +356,12 @@ class GitPlugin(PluginBase):
                    db_env = db.query(DeploymentEnvironment).filter(DeploymentEnvironment.id == env_id).first()
                else:
                    # If no ID, try to find active or any environment in DB
-                    db_env = db.query(DeploymentEnvironment).filter(DeploymentEnvironment.is_active == True).first()
+                    db_env = db.query(DeploymentEnvironment).filter(DeploymentEnvironment.is_active).first()
                    if not db_env:
                        db_env = db.query(DeploymentEnvironment).first()

                if db_env:
-                    logger.info(f"[_get_env][Exit] Found environment in DB: {db_env.name}")
+                    app_logger.info(f"[_get_env][Exit] Found environment in DB: {db_env.name}")
                    from src.core.config_models import Environment
                    # Use token as password for SupersetClient
                    return Environment(
@@ -382,14 +383,14 @@ class GitPlugin(PluginBase):
                    # but we have other envs, maybe it's one of them?
                    env = next((e for e in envs if e.id == env_id), None)
                    if env:
-                        logger.info(f"[_get_env][Exit] Found environment {env_id} in ConfigManager list")
+                        app_logger.info(f"[_get_env][Exit] Found environment {env_id} in ConfigManager list")
                        return env
                
                if not env_id:
-                    logger.info(f"[_get_env][Exit] Using first environment from ConfigManager: {envs[0].name}")
+                    app_logger.info(f"[_get_env][Exit] Using first environment from ConfigManager: {envs[0].name}")
                    return envs[0]
                
-            logger.error(f"[_get_env][Coherence:Failed] No environments configured (searched config.json and DB). env_id={env_id}")
+            app_logger.error(f"[_get_env][Coherence:Failed] No environments configured (searched config.json and DB). env_id={env_id}")
            raise ValueError("No environments configured. Please add a Superset Environment in Settings.")
    # [/DEF:_get_env:Function]

--- a/backend/src/plugins/llm_analysis/init.py
+++ b/backend/src/plugins/llm_analysis/init.py
@@ -9,4 +9,6 @@ LLM Analysis Plugin for automated dashboard validation and dataset documentation

 from .plugin import DashboardValidationPlugin, DocumentationPlugin

+__all__ = ['DashboardValidationPlugin', 'DocumentationPlugin']
+
 # [/DEF:backend/src/plugins/llm_analysis/__init__.py:Module]
--- a/backend/src/plugins/llm_analysis/plugin.py
+++ b/backend/src/plugins/llm_analysis/plugin.py
@@ -10,15 +10,13 @@
 # @RELATION: USES -> TaskContext
 # @INVARIANT: All LLM interactions must be executed as asynchronous tasks.

-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional
 import os
 import json
-import logging
 from datetime import datetime, timedelta
 from ...core.plugin_base import PluginBase
 from ...core.logger import belief_scope, logger
 from ...core.database import SessionLocal
-from ...core.config_manager import ConfigManager
 from ...services.llm_provider import LLMProviderService
 from ...core.superset_client import SupersetClient
 from .service import ScreenshotService, LLMClient
@@ -97,7 +95,7 @@ class DashboardValidationPlugin(PluginBase):
                    log.error(f"LLM Provider {provider_id} not found")
                    raise ValueError(f"LLM Provider {provider_id} not found")
                
-                llm_log.debug(f"Retrieved provider config:")
+                llm_log.debug("Retrieved provider config:")
                llm_log.debug(f"  Provider ID: {db_provider.id}")
                llm_log.debug(f"  Provider Name: {db_provider.name}")
                llm_log.debug(f"  Provider Type: {db_provider.provider_type}")
@@ -299,7 +297,7 @@ class DocumentationPlugin(PluginBase):
                    log.error(f"LLM Provider {provider_id} not found")
                    raise ValueError(f"LLM Provider {provider_id} not found")
                
-                llm_log.debug(f"Retrieved provider config:")
+                llm_log.debug("Retrieved provider config:")
                llm_log.debug(f"  Provider ID: {db_provider.id}")
                llm_log.debug(f"  Provider Name: {db_provider.name}")
                llm_log.debug(f"  Provider Type: {db_provider.provider_type}")
--- a/backend/src/plugins/llm_analysis/service.py
+++ b/backend/src/plugins/llm_analysis/service.py
@@ -12,12 +12,12 @@ import asyncio
 import base64
 import json
 import io
-from typing import List, Optional, Dict, Any
+from typing import List, Dict, Any
 from PIL import Image
 from playwright.async_api import async_playwright
 from openai import AsyncOpenAI, RateLimitError, AuthenticationError as OpenAIAuthenticationError
 from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception
-from .models import LLMProviderType, ValidationResult, ValidationStatus, DetectedIssue
+from .models import LLMProviderType
 from ...core.logger import belief_scope, logger
 from ...core.config_models import Environment

@@ -96,7 +96,7 @@ class ScreenshotService:
                    "password": ['input[name="password"]', 'input#password', 'input[placeholder*="Password"]', 'input[type="password"]'],
                    "submit": ['button[type="submit"]', 'button#submit', '.btn-primary', 'input[type="submit"]']
                }
-                logger.info(f"[DEBUG] Attempting to find login form elements...")
+                logger.info("[DEBUG] Attempting to find login form elements...")
                
                try:
                    # Find and fill username
@@ -190,27 +190,27 @@ class ScreenshotService:
                try:
                    # Wait for the dashboard grid to be present
                    await page.wait_for_selector('.dashboard-component, .dashboard-header, [data-test="dashboard-grid"]', timeout=30000)
-                    logger.info(f"[DEBUG] Dashboard container loaded")
+                    logger.info("[DEBUG] Dashboard container loaded")
                    
                    # Wait for charts to finish loading (Superset uses loading spinners/skeletons)
                    # We wait until loading indicators disappear or a timeout occurs
                    try:
                        # Wait for loading indicators to disappear
                        await page.wait_for_selector('.loading, .ant-skeleton, .spinner', state="hidden", timeout=60000)
-                        logger.info(f"[DEBUG] Loading indicators hidden")
-                    except:
-                        logger.warning(f"[DEBUG] Timeout waiting for loading indicators to hide")
+                        logger.info("[DEBUG] Loading indicators hidden")
+                    except Exception:
+                        logger.warning("[DEBUG] Timeout waiting for loading indicators to hide")

                    # Wait for charts to actually render their content (e.g., ECharts, NVD3)
                    # We look for common chart containers that should have content
                    try:
                        await page.wait_for_selector('.chart-container canvas, .slice_container svg, .superset-chart-canvas, .grid-content .chart-container', timeout=60000)
-                        logger.info(f"[DEBUG] Chart content detected")
-                    except:
-                        logger.warning(f"[DEBUG] Timeout waiting for chart content")
+                        logger.info("[DEBUG] Chart content detected")
+                    except Exception:
+                        logger.warning("[DEBUG] Timeout waiting for chart content")

                    # Additional check: wait for all chart containers to have non-empty content
-                    logger.info(f"[DEBUG] Waiting for all charts to have rendered content...")
+                    logger.info("[DEBUG] Waiting for all charts to have rendered content...")
                    await page.wait_for_function("""() => {
                        const charts = document.querySelectorAll('.chart-container, .slice_container');
                        if (charts.length === 0) return true; // No charts to wait for
@@ -223,10 +223,10 @@ class ScreenshotService:
                            return hasCanvas || hasSvg || hasContent;
                        });
                    }""", timeout=60000)
-                    logger.info(f"[DEBUG] All charts have rendered content")
+                    logger.info("[DEBUG] All charts have rendered content")

                    # Scroll to bottom and back to top to trigger lazy loading of all charts
-                    logger.info(f"[DEBUG] Scrolling to trigger lazy loading...")
+                    logger.info("[DEBUG] Scrolling to trigger lazy loading...")
                    await page.evaluate("""async () => {
                        const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
                        for (let i = 0; i < document.body.scrollHeight; i += 500) {
@@ -241,7 +241,7 @@ class ScreenshotService:
                    logger.warning(f"[DEBUG] Dashboard content wait failed: {e}, proceeding anyway after delay")
                
                # Final stabilization delay - increased for complex dashboards
-                logger.info(f"[DEBUG] Final stabilization delay...")
+                logger.info("[DEBUG] Final stabilization delay...")
                await asyncio.sleep(15)

                # Logic to handle tabs and full-page capture
@@ -251,7 +251,8 @@ class ScreenshotService:
                    processed_tabs = set()

                    async def switch_tabs(depth=0):
-                        if depth > 3: return # Limit recursion depth
+                        if depth > 3:
+                            return # Limit recursion depth
                        
                        tab_selectors = [
                            '.ant-tabs-nav-list .ant-tabs-tab',
@@ -262,7 +263,8 @@ class ScreenshotService:
                        found_tabs = []
                        for selector in tab_selectors:
                            found_tabs = await page.locator(selector).all()
-                            if found_tabs: break
+                            if found_tabs:
+                                break
                            
                        if found_tabs:
                            logger.info(f"[DEBUG][TabSwitching] Found {len(found_tabs)} tabs at depth {depth}")
@@ -292,7 +294,8 @@ class ScreenshotService:
                                if "ant-tabs-tab-active" not in (await first_tab.get_attribute("class") or ""):
                                    await first_tab.click()
                                    await asyncio.sleep(1)
-                            except: pass
+                            except Exception:
+                                pass

                    await switch_tabs()

@@ -423,7 +426,7 @@ class LLMClient:
        self.default_model = default_model
        
        # DEBUG: Log initialization parameters (without exposing full API key)
-        logger.info(f"[LLMClient.__init__] Initializing LLM client:")
+        logger.info("[LLMClient.__init__] Initializing LLM client:")
        logger.info(f"[LLMClient.__init__]   Provider Type: {provider_type}")
        logger.info(f"[LLMClient.__init__]   Base URL: {base_url}")
        logger.info(f"[LLMClient.__init__]   Default Model: {default_model}")
--- a/backend/src/plugins/migration.py
+++ b/backend/src/plugins/migration.py
@@ -7,15 +7,13 @@
 # @RELATION: DEPENDS_ON -> superset_tool.utils
 # @RELATION: USES -> TaskContext

-from typing import Dict, Any, List, Optional
-from pathlib import Path
-import zipfile
+from typing import Dict, Any, Optional
 import re

 from ..core.plugin_base import PluginBase
 from ..core.logger import belief_scope, logger as app_logger
 from ..core.superset_client import SupersetClient
-from ..core.utils.fileio import create_temp_file, update_yamls, create_dashboard_export
+from ..core.utils.fileio import create_temp_file
 from ..dependencies import get_config_manager
 from ..core.migration_engine import MigrationEngine
 from ..core.database import SessionLocal
@@ -151,8 +149,8 @@ class MigrationPlugin(PluginBase):
        dashboard_regex = params.get("dashboard_regex")
        
        replace_db_config = params.get("replace_db_config", False)
-        from_db_id = params.get("from_db_id")
-        to_db_id = params.get("to_db_id")
+        params.get("from_db_id")
+        params.get("to_db_id")
        
        # [DEF:MigrationPlugin.execute:Action]
        # @PURPOSE: Execute the migration logic with proper task logging.
@@ -221,22 +219,29 @@ class MigrationPlugin(PluginBase):
                log.warning("No dashboards found matching criteria.")
                return

-            # Fetch mappings from database
-            db_mapping = {}
+            # Get mappings from params
+            db_mapping = params.get("db_mappings", {})
+            if not isinstance(db_mapping, dict):
+                db_mapping = {}
+            
+            # Fetch additional mappings from database if requested
            if replace_db_config:
                db = SessionLocal()
                try:
                    # Find environment IDs by name
-                    src_env = db.query(Environment).filter(Environment.name == from_env_name).first()
-                    tgt_env = db.query(Environment).filter(Environment.name == to_env_name).first()
+                    src_env_db = db.query(Environment).filter(Environment.name == from_env_name).first()
+                    tgt_env_db = db.query(Environment).filter(Environment.name == to_env_name).first()
                    
-                    if src_env and tgt_env:
-                        mappings = db.query(DatabaseMapping).filter(
-                            DatabaseMapping.source_env_id == src_env.id,
-                            DatabaseMapping.target_env_id == tgt_env.id
+                    if src_env_db and tgt_env_db:
+                        stored_mappings = db.query(DatabaseMapping).filter(
+                            DatabaseMapping.source_env_id == src_env_db.id,
+                            DatabaseMapping.target_env_id == tgt_env_db.id
                        ).all()
-                        db_mapping = {m.source_db_uuid: m.target_db_uuid for m in mappings}
-                        log.info(f"Loaded {len(db_mapping)} database mappings.")
+                        # Provided mappings override stored ones
+                        stored_map_dict = {m.source_db_uuid: m.target_db_uuid for m in stored_mappings}
+                        stored_map_dict.update(db_mapping)
+                        db_mapping = stored_map_dict
+                        log.info(f"Loaded {len(stored_mappings)} database mappings from database.")
                finally:
                    db.close()

@@ -301,7 +306,7 @@ class MigrationPlugin(PluginBase):
                             if match_alt:
                                 db_name = match_alt.group(1)

-                        logger.warning(f"[MigrationPlugin][Action] Detected missing password for database: {db_name}")
+                        app_logger.warning(f"[MigrationPlugin][Action] Detected missing password for database: {db_name}")
                        
                        if task_id:
                            input_request = {
@@ -320,19 +325,19 @@ class MigrationPlugin(PluginBase):
                            
                            # Retry import with password
                            if passwords:
-                                logger.info(f"[MigrationPlugin][Action] Retrying import for {title} with provided passwords.")
+                                app_logger.info(f"[MigrationPlugin][Action] Retrying import for {title} with provided passwords.")
                                to_c.import_dashboard(file_name=tmp_new_zip, dash_id=dash_id, dash_slug=dash_slug, passwords=passwords)
-                                logger.info(f"[MigrationPlugin][Success] Dashboard {title} imported after password injection.")
+                                app_logger.info(f"[MigrationPlugin][Success] Dashboard {title} imported after password injection.")
                                # Clear passwords from params after use for security
                                if "passwords" in task.params:
                                    del task.params["passwords"]
                                continue

-                    logger.error(f"[MigrationPlugin][Failure] Failed to migrate dashboard {title}: {exc}", exc_info=True)
+                    app_logger.error(f"[MigrationPlugin][Failure] Failed to migrate dashboard {title}: {exc}", exc_info=True)

-                logger.info("[MigrationPlugin][Exit] Migration finished.")
+                app_logger.info("[MigrationPlugin][Exit] Migration finished.")
        except Exception as e:
-            logger.critical(f"[MigrationPlugin][Failure] Fatal error during migration: {e}", exc_info=True)
+            app_logger.critical(f"[MigrationPlugin][Failure] Fatal error during migration: {e}", exc_info=True)
            raise e
        # [/DEF:MigrationPlugin.execute:Action]
    # [/DEF:execute:Function]
--- a/backend/src/plugins/search.py
+++ b/backend/src/plugins/search.py
@@ -8,7 +8,7 @@

 # [SECTION: IMPORTS]
 import re
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, Optional
 from ..core.plugin_base import PluginBase
 from ..core.superset_client import SupersetClient
 from ..core.logger import logger, belief_scope
@@ -116,7 +116,7 @@ class SearchPlugin(PluginBase):
            log = context.logger if context else logger
            
            # Create sub-loggers for different components
-            superset_log = log.with_source("superset_api") if context else log
+            log.with_source("superset_api") if context else log
            search_log = log.with_source("search") if context else log
            
            if not env_name or not search_query:
--- a/backend/src/plugins/storage/plugin.py
+++ b/backend/src/plugins/storage/plugin.py
@@ -19,7 +19,7 @@ from fastapi import UploadFile

 from ...core.plugin_base import PluginBase
 from ...core.logger import belief_scope, logger
-from ...models.storage import StoredFile, FileCategory, StorageConfig
+from ...models.storage import StoredFile, FileCategory
 from ...dependencies import get_config_manager
 from ...core.task_manager.context import TaskContext
 # [/SECTION]
@@ -126,7 +126,7 @@ class StoragePlugin(PluginBase):
            
            # Create sub-loggers for different components
            storage_log = log.with_source("storage") if context else log
-            filesystem_log = log.with_source("filesystem") if context else log
+            log.with_source("filesystem") if context else log
            
            storage_log.info(f"Executing with params: {params}")
    # [/DEF:execute:Function]
--- a/backend/src/schemas/auth.py
+++ b/backend/src/schemas/auth.py
@@ -10,7 +10,7 @@

 # [SECTION: IMPORTS]
 from typing import List, Optional
-from pydantic import BaseModel, EmailStr, Field
+from pydantic import BaseModel, EmailStr
 from datetime import datetime
 # [/SECTION]

--- a/backend/src/scripts/create_admin.py
+++ b/backend/src/scripts/create_admin.py
@@ -20,7 +20,7 @@ sys.path.append(str(Path(__file__).parent.parent.parent))

 from src.core.database import AuthSessionLocal, init_db
 from src.core.auth.security import get_password_hash
-from src.models.auth import User, Role, Permission
+from src.models.auth import User, Role
 from src.core.logger import logger, belief_scope
 # [/SECTION]

--- a/backend/src/scripts/init_auth_db.py
+++ b/backend/src/scripts/init_auth_db.py
@@ -9,13 +9,12 @@

 # [SECTION: IMPORTS]
 import sys
-import os
 from pathlib import Path

 # Add src to path
 sys.path.append(str(Path(__file__).parent.parent.parent))

-from src.core.database import init_db, auth_engine
+from src.core.database import init_db
 from src.core.logger import logger, belief_scope
 from src.scripts.seed_permissions import seed_permissions
 # [/SECTION]
--- a/backend/src/scripts/test_dataset_dashboard_relations.py
+++ b/backend/src/scripts/test_dataset_dashboard_relations.py
@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Script to test dataset-to-dashboard relationships from Superset API.
+
+Usage:
+    cd backend && .venv/bin/python3 src/scripts/test_dataset_dashboard_relations.py
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Add src to path (parent of scripts directory)
+sys.path.append(str(Path(__file__).parent.parent.parent))
+
+from src.core.superset_client import SupersetClient
+from src.core.config_manager import ConfigManager
+from src.core.logger import logger
+
+
+def test_dashboard_dataset_relations():
+    """Test fetching dataset-to-dashboard relationships."""
+    
+    # Load environment from existing config
+    config_manager = ConfigManager()
+    environments = config_manager.get_environments()
+    
+    if not environments:
+        logger.error("No environments configured!")
+        return
+    
+    # Use first available environment
+    env = environments[0]
+    logger.info(f"Using environment: {env.name} ({env.url})")
+    
+    client = SupersetClient(env)
+    
+    try:
+        # Authenticate
+        logger.info("Authenticating to Superset...")
+        client.authenticate()
+        logger.info("Authentication successful!")
+        
+        # Test dashboard ID 13
+        dashboard_id = 13
+        logger.info(f"\n=== Fetching Dashboard {dashboard_id} ===")
+        dashboard = client.network.request(method="GET", endpoint=f"/dashboard/{dashboard_id}")
+        
+        print("\nDashboard structure:")
+        print(f"  ID: {dashboard.get('id')}")
+        print(f"  Title: {dashboard.get('dashboard_title')}")
+        print(f"  Published: {dashboard.get('published')}")
+        
+        # Check for slices/charts
+        if 'slices' in dashboard:
+            logger.info(f"\n  Found {len(dashboard['slices'])} slices/charts in dashboard")
+            for i, slice_data in enumerate(dashboard['slices'][:5]):  # Show first 5
+                print(f"    Slice {i+1}:")
+                print(f"      ID: {slice_data.get('slice_id')}")
+                print(f"      Name: {slice_data.get('slice_name')}")
+                # Check for datasource_id
+                if 'datasource_id' in slice_data:
+                    print(f"      Datasource ID: {slice_data['datasource_id']}")
+                if 'datasource_name' in slice_data:
+                    print(f"      Datasource Name: {slice_data['datasource_name']}")
+                if 'datasource_type' in slice_data:
+                    print(f"      Datasource Type: {slice_data['datasource_type']}")
+        else:
+            logger.warning("  No 'slices' field found in dashboard response")
+            logger.info(f"  Available fields: {list(dashboard.keys())}")
+        
+        # Test dataset ID 26
+        dataset_id = 26
+        logger.info(f"\n=== Fetching Dataset {dataset_id} ===")
+        dataset = client.get_dataset(dataset_id)
+        
+        print("\nDataset structure:")
+        print(f"  ID: {dataset.get('id')}")
+        print(f"  Table Name: {dataset.get('table_name')}")
+        print(f"  Schema: {dataset.get('schema')}")
+        print(f"  Database: {dataset.get('database', {}).get('database_name', 'Unknown')}")
+        
+        # Check for dashboards that use this dataset
+        logger.info(f"\n=== Finding Dashboards using Dataset {dataset_id} ===")
+        
+        # Method: Use Superset's related_objects API
+        try:
+            logger.info(f"  Using /api/v1/dataset/{dataset_id}/related_objects endpoint...")
+            related_objects = client.network.request(
+                method="GET",
+                endpoint=f"/dataset/{dataset_id}/related_objects"
+            )
+            
+            logger.info(f"  Related objects response type: {type(related_objects)}")
+            logger.info(f"  Related objects keys: {list(related_objects.keys()) if isinstance(related_objects, dict) else 'N/A'}")
+            
+            # Check for dashboards in related objects
+            if 'dashboards' in related_objects:
+                dashboards = related_objects['dashboards']
+                logger.info(f"  Found {len(dashboards)} dashboards using this dataset:")
+                
+                for dash in dashboards:
+                    logger.info(f"    - Dashboard ID {dash.get('id')}: {dash.get('dashboard_title', dash.get('title', 'Unknown'))}")
+            elif 'result' in related_objects:
+                # Some Superset versions use 'result' wrapper
+                result = related_objects['result']
+                if 'dashboards' in result:
+                    dashboards = result['dashboards']
+                    logger.info(f"  Found {len(dashboards)} dashboards using this dataset:")
+                    
+                    for dash in dashboards:
+                        logger.info(f"    - Dashboard ID {dash.get('id')}: {dash.get('dashboard_title', dash.get('title', 'Unknown'))}")
+                else:
+                    logger.warning(f"  No 'dashboards' key in result. Keys: {list(result.keys())}")
+            else:
+                logger.warning(f"  No 'dashboards' key in response. Available keys: {list(related_objects.keys())}")
+                logger.info(f"  Full related_objects response:")
+                print(json.dumps(related_objects, indent=2, default=str)[:1000])
+                
+        except Exception as e:
+            logger.error(f"  Error fetching related objects: {e}")
+            import traceback
+            traceback.print_exc()
+        
+        # Method 2: Try to use the position_json from dashboard
+        logger.info(f"\n=== Analyzing Dashboard Position JSON ===")
+        if 'position_json' in dashboard:
+            position_data = json.loads(dashboard['position_json'])
+            logger.info(f"  Position data type: {type(position_data)}")
+            
+            # Look for datasource references
+            datasource_ids = set()
+            if isinstance(position_data, dict):
+                for key, value in position_data.items():
+                    if 'datasource' in key.lower() or key == 'DASHBOARD_VERSION_KEY':
+                        logger.debug(f"    Key: {key}, Value type: {type(value)}")
+            elif isinstance(position_data, list):
+                logger.info(f"  Position data has {len(position_data)} items")
+                for item in position_data[:3]:  # Show first 3
+                    logger.debug(f"    Item: {type(item)}, keys: {list(item.keys()) if isinstance(item, dict) else 'N/A'}")
+                    if isinstance(item, dict):
+                        if 'datasource_id' in item:
+                            datasource_ids.add(item['datasource_id'])
+            
+            if datasource_ids:
+                logger.info(f"  Found datasource IDs: {datasource_ids}")
+        
+        # Save full response for analysis
+        output_file = Path(__file__).parent / "dataset_dashboard_analysis.json"
+        with open(output_file, 'w') as f:
+            json.dump({
+                'dashboard': dashboard,
+                'dataset': dataset
+            }, f, indent=2, default=str)
+        logger.info(f"\nFull response saved to: {output_file}")
+        
+    except Exception as e:
+        logger.error(f"Error: {e}", exc_info=True)
+        raise
+
+
+if __name__ == "__main__":
+    test_dashboard_dataset_relations()
--- a/backend/src/services/init.py
+++ b/backend/src/services/init.py
@@ -0,0 +1,20 @@
+# [DEF:backend.src.services:Module]
+# @TIER: STANDARD
+# @SEMANTICS: services, package, init
+# @PURPOSE: Package initialization for services module
+# @LAYER: Core
+# @RELATION: EXPORTS -> resource_service, mapping_service
+# @NOTE: Only export services that don't cause circular imports
+# @NOTE: GitService, AuthService, LLMProviderService have circular import issues - import directly when needed
+
+# Lazy loading to avoid import issues in tests
+__all__ = ['MappingService', 'ResourceService']
+
+def __getattr__(name):
+    if name == 'MappingService':
+        from .mapping_service import MappingService
+        return MappingService
+    if name == 'ResourceService':
+        from .resource_service import ResourceService
+        return ResourceService
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
--- a/backend/src/services/tests/test_resource_service.py
+++ b/backend/src/services/tests/test_resource_service.py
@@ -0,0 +1,212 @@
+# [DEF:backend.src.services.__tests__.test_resource_service:Module]
+# @TIER: STANDARD
+# @PURPOSE: Unit tests for ResourceService
+# @LAYER: Service
+# @RELATION: TESTS -> backend.src.services.resource_service
+# @RELATION: VERIFIES -> ResourceService
+
+import pytest
+from unittest.mock import MagicMock, patch, AsyncMock
+from datetime import datetime
+
+
+# [DEF:test_get_dashboards_with_status:Function]
+# @TEST: get_dashboards_with_status returns dashboards with git and task status
+# @PRE: SupersetClient returns dashboard list
+# @POST: Each dashboard has git_status and last_task fields
+@pytest.mark.asyncio
+async def test_get_dashboards_with_status():
+    with patch("src.services.resource_service.SupersetClient") as mock_client, \
+         patch("src.services.resource_service.GitService"):
+        
+        from src.services.resource_service import ResourceService
+        
+        service = ResourceService()
+        
+        # Mock Superset response
+        mock_client.return_value.get_dashboards_summary.return_value = [
+            {"id": 1, "title": "Dashboard 1", "slug": "dash-1"},
+            {"id": 2, "title": "Dashboard 2", "slug": "dash-2"}
+        ]
+        
+        # Mock tasks
+        mock_task = MagicMock()
+        mock_task.id = "task-123"
+        mock_task.status = "SUCCESS"
+        mock_task.params = {"resource_id": "dashboard-1"}
+        mock_task.created_at = datetime.now()
+        
+        env = MagicMock()
+        env.id = "prod"
+        
+        result = await service.get_dashboards_with_status(env, [mock_task])
+        
+        assert len(result) == 2
+        assert result[0]["id"] == 1
+        assert "git_status" in result[0]
+        assert "last_task" in result[0]
+        assert result[0]["last_task"]["task_id"] == "task-123"
+
+
+# [/DEF:test_get_dashboards_with_status:Function]
+
+
+# [DEF:test_get_datasets_with_status:Function]
+# @TEST: get_datasets_with_status returns datasets with task status
+# @PRE: SupersetClient returns dataset list
+# @POST: Each dataset has last_task field
+@pytest.mark.asyncio
+async def test_get_datasets_with_status():
+    with patch("src.services.resource_service.SupersetClient") as mock_client:
+        
+        from src.services.resource_service import ResourceService
+        
+        service = ResourceService()
+        
+        # Mock Superset response
+        mock_client.return_value.get_datasets_summary.return_value = [
+            {"id": 1, "table_name": "users", "schema": "public", "database": "app"},
+            {"id": 2, "table_name": "orders", "schema": "public", "database": "app"}
+        ]
+        
+        # Mock tasks
+        mock_task = MagicMock()
+        mock_task.id = "task-456"
+        mock_task.status = "RUNNING"
+        mock_task.params = {"resource_id": "dataset-1"}
+        mock_task.created_at = datetime.now()
+        
+        env = MagicMock()
+        env.id = "prod"
+        
+        result = await service.get_datasets_with_status(env, [mock_task])
+        
+        assert len(result) == 2
+        assert result[0]["table_name"] == "users"
+        assert "last_task" in result[0]
+        assert result[0]["last_task"]["task_id"] == "task-456"
+        assert result[0]["last_task"]["status"] == "RUNNING"
+
+
+# [/DEF:test_get_datasets_with_status:Function]
+
+
+# [DEF:test_get_activity_summary:Function]
+# @TEST: get_activity_summary returns active count and recent tasks
+# @PRE: tasks list provided
+# @POST: Returns dict with active_count and recent_tasks
+def test_get_activity_summary():
+    from src.services.resource_service import ResourceService
+    
+    service = ResourceService()
+    
+    # Create mock tasks
+    task1 = MagicMock()
+    task1.id = "task-1"
+    task1.status = "RUNNING"
+    task1.params = {"resource_name": "Dashboard 1", "resource_type": "dashboard"}
+    task1.created_at = datetime(2024, 1, 1, 10, 0, 0)
+    
+    task2 = MagicMock()
+    task2.id = "task-2"
+    task2.status = "SUCCESS"
+    task2.params = {"resource_name": "Dataset 1", "resource_type": "dataset"}
+    task2.created_at = datetime(2024, 1, 1, 9, 0, 0)
+    
+    task3 = MagicMock()
+    task3.id = "task-3"
+    task3.status = "WAITING_INPUT"
+    task3.params = {"resource_name": "Dashboard 2", "resource_type": "dashboard"}
+    task3.created_at = datetime(2024, 1, 1, 8, 0, 0)
+    
+    result = service.get_activity_summary([task1, task2, task3])
+    
+    assert result["active_count"] == 2  # RUNNING + WAITING_INPUT
+    assert len(result["recent_tasks"]) == 3
+
+
+# [/DEF:test_get_activity_summary:Function]
+
+
+# [DEF:test_get_git_status_for_dashboard_no_repo:Function]
+# @TEST: _get_git_status_for_dashboard returns None when no repo exists
+# @PRE: GitService returns None for repo
+# @POST: Returns None
+def test_get_git_status_for_dashboard_no_repo():
+    with patch("src.services.resource_service.GitService") as mock_git:
+        
+        from src.services.resource_service import ResourceService
+        
+        service = ResourceService()
+        mock_git.return_value.get_repo.return_value = None
+        
+        result = service._get_git_status_for_dashboard(123)
+        
+        assert result is None
+
+
+# [/DEF:test_get_git_status_for_dashboard_no_repo:Function]
+
+
+# [DEF:test_get_last_task_for_resource:Function]
+# @TEST: _get_last_task_for_resource returns most recent task for resource
+# @PRE: tasks list with matching resource_id
+# @POST: Returns task summary with task_id and status
+def test_get_last_task_for_resource():
+    from src.services.resource_service import ResourceService
+    
+    service = ResourceService()
+    
+    # Create mock tasks
+    task1 = MagicMock()
+    task1.id = "task-old"
+    task1.status = "SUCCESS"
+    task1.params = {"resource_id": "dashboard-1"}
+    task1.created_at = datetime(2024, 1, 1, 10, 0, 0)
+    
+    task2 = MagicMock()
+    task2.id = "task-new"
+    task2.status = "RUNNING"
+    task2.params = {"resource_id": "dashboard-1"}
+    task2.created_at = datetime(2024, 1, 1, 12, 0, 0)
+    
+    result = service._get_last_task_for_resource("dashboard-1", [task1, task2])
+    
+    assert result is not None
+    assert result["task_id"] == "task-new"  # Most recent
+    assert result["status"] == "RUNNING"
+
+
+# [/DEF:test_get_last_task_for_resource:Function]
+
+
+# [DEF:test_extract_resource_name_from_task:Function]
+# @TEST: _extract_resource_name_from_task extracts name from params
+# @PRE: task has resource_name in params
+# @POST: Returns resource name or fallback
+def test_extract_resource_name_from_task():
+    from src.services.resource_service import ResourceService
+    
+    service = ResourceService()
+    
+    # Task with resource_name
+    task = MagicMock()
+    task.id = "task-123"
+    task.params = {"resource_name": "My Dashboard"}
+    
+    result = service._extract_resource_name_from_task(task)
+    assert result == "My Dashboard"
+    
+    # Task without resource_name
+    task2 = MagicMock()
+    task2.id = "task-456"
+    task2.params = {}
+    
+    result2 = service._extract_resource_name_from_task(task2)
+    assert "task-456" in result2
+
+
+# [/DEF:test_extract_resource_name_from_task:Function]
+
+
+# [/DEF:backend.src.services.__tests__.test_resource_service:Module]
--- a/backend/src/services/auth_service.py
+++ b/backend/src/services/auth_service.py
@@ -10,11 +10,11 @@
 # @INVARIANT: Authentication must verify both credentials and account status.

 # [SECTION: IMPORTS]
-from typing import Optional, Dict, Any, List
+from typing import Dict, Any
 from sqlalchemy.orm import Session
 from ..models.auth import User, Role
 from ..core.auth.repository import AuthRepository
-from ..core.auth.security import verify_password, get_password_hash
+from ..core.auth.security import verify_password
 from ..core.auth.jwt import create_access_token
 from ..core.logger import belief_scope
 # [/SECTION]
--- a/backend/src/services/git_service.py
+++ b/backend/src/services/git_service.py
@@ -10,11 +10,10 @@
 # @INVARIANT: All Git operations must be performed on a valid local directory.

 import os
-import shutil
 import httpx
-from git import Repo, RemoteProgress
+from git import Repo
 from fastapi import HTTPException
-from typing import List, Optional
+from typing import List
 from datetime import datetime
 from src.core.logger import logger, belief_scope
 from src.models.git import GitProvider
@@ -167,7 +166,7 @@ class GitService:
            
            # Handle empty repository case (no commits)
            if not repo.heads and not repo.remotes:
-                logger.warning(f"[create_branch][Action] Repository is empty. Creating initial commit to enable branching.")
+                logger.warning("[create_branch][Action] Repository is empty. Creating initial commit to enable branching.")
                readme_path = os.path.join(repo.working_dir, "README.md")
                if not os.path.exists(readme_path):
                    with open(readme_path, "w") as f:
@@ -178,7 +177,7 @@ class GitService:
            # Verify source branch exists
            try:
                repo.commit(from_branch)
-            except:
+            except Exception:
                logger.warning(f"[create_branch][Action] Source branch {from_branch} not found, using HEAD")
                from_branch = repo.head

--- a/backend/src/services/llm_provider.py
+++ b/backend/src/services/llm_provider.py
@@ -9,7 +9,7 @@
 from typing import List, Optional
 from sqlalchemy.orm import Session
 from ..models.llm import LLMProvider
-from ..plugins.llm_analysis.models import LLMProviderConfig, LLMProviderType
+from ..plugins.llm_analysis.models import LLMProviderConfig
 from ..core.logger import belief_scope, logger
 from cryptography.fernet import Fernet
 import os
--- a/backend/src/services/resource_service.py
+++ b/backend/src/services/resource_service.py
@@ -0,0 +1,251 @@
+# [DEF:backend.src.services.resource_service:Module]
+# @TIER: STANDARD
+# @SEMANTICS: service, resources, dashboards, datasets, tasks, git
+# @PURPOSE:   Shared service for fetching resource data with Git status and task status
+# @LAYER:     Service
+# @RELATION:  DEPENDS_ON -> backend.src.core.superset_client
+# @RELATION:  DEPENDS_ON -> backend.src.core.task_manager
+# @RELATION:  DEPENDS_ON -> backend.src.services.git_service
+# @INVARIANT: All resources include metadata about their current state
+
+# [SECTION: IMPORTS]
+from typing import List, Dict, Optional, Any
+from ..core.superset_client import SupersetClient
+from ..core.task_manager.models import Task
+from ..services.git_service import GitService
+from ..core.logger import logger, belief_scope
+# [/SECTION]
+
+# [DEF:ResourceService:Class]
+# @PURPOSE: Provides centralized access to resource data with enhanced metadata
+class ResourceService:
+    
+    # [DEF:__init__:Function]
+    # @PURPOSE: Initialize the resource service with dependencies
+    # @PRE: None
+    # @POST: ResourceService is ready to fetch resources
+    def __init__(self):
+        with belief_scope("ResourceService.__init__"):
+            self.git_service = GitService()
+            logger.info("[ResourceService][Action] Initialized ResourceService")
+    # [/DEF:__init__:Function]
+    
+    # [DEF:get_dashboards_with_status:Function]
+    # @PURPOSE: Fetch dashboards from environment with Git status and last task status
+    # @PRE: env is a valid Environment object
+    # @POST: Returns list of dashboards with enhanced metadata
+    # @PARAM: env (Environment) - The environment to fetch from
+    # @PARAM: tasks (List[Task]) - List of tasks to check for status
+    # @RETURN: List[Dict] - Dashboards with git_status and last_task fields
+    # @RELATION: CALLS -> SupersetClient.get_dashboards_summary
+    # @RELATION: CALLS -> self._get_git_status_for_dashboard
+    # @RELATION: CALLS -> self._get_last_task_for_resource
+    async def get_dashboards_with_status(
+        self, 
+        env: Any, 
+        tasks: Optional[List[Task]] = None
+    ) -> List[Dict[str, Any]]:
+        with belief_scope("get_dashboards_with_status", f"env={env.id}"):
+            client = SupersetClient(env)
+            dashboards = client.get_dashboards_summary()
+            
+            # Enhance each dashboard with Git status and task status
+            result = []
+            for dashboard in dashboards:
+                # dashboard is already a dict, no need to call .dict()
+                dashboard_dict = dashboard
+                dashboard_id = dashboard_dict.get('id')
+                
+                # Get Git status if repo exists
+                git_status = self._get_git_status_for_dashboard(dashboard_id)
+                dashboard_dict['git_status'] = git_status
+                
+                # Get last task status
+                last_task = self._get_last_task_for_resource(
+                    f"dashboard-{dashboard_id}", 
+                    tasks
+                )
+                dashboard_dict['last_task'] = last_task
+                
+                result.append(dashboard_dict)
+            
+            logger.info(f"[ResourceService][Coherence:OK] Fetched {len(result)} dashboards with status")
+            return result
+    # [/DEF:get_dashboards_with_status:Function]
+    
+    # [DEF:get_datasets_with_status:Function]
+    # @PURPOSE: Fetch datasets from environment with mapping progress and last task status
+    # @PRE: env is a valid Environment object
+    # @POST: Returns list of datasets with enhanced metadata
+    # @PARAM: env (Environment) - The environment to fetch from
+    # @PARAM: tasks (List[Task]) - List of tasks to check for status
+    # @RETURN: List[Dict] - Datasets with mapped_fields and last_task fields
+    # @RELATION: CALLS -> SupersetClient.get_datasets_summary
+    # @RELATION: CALLS -> self._get_last_task_for_resource
+    async def get_datasets_with_status(
+        self, 
+        env: Any, 
+        tasks: Optional[List[Task]] = None
+    ) -> List[Dict[str, Any]]:
+        with belief_scope("get_datasets_with_status", f"env={env.id}"):
+            client = SupersetClient(env)
+            datasets = client.get_datasets_summary()
+            
+            # Enhance each dataset with task status
+            result = []
+            for dataset in datasets:
+                # dataset is already a dict, no need to call .dict()
+                dataset_dict = dataset
+                dataset_id = dataset_dict.get('id')
+                
+                # Get last task status
+                last_task = self._get_last_task_for_resource(
+                    f"dataset-{dataset_id}", 
+                    tasks
+                )
+                dataset_dict['last_task'] = last_task
+                
+                result.append(dataset_dict)
+            
+            logger.info(f"[ResourceService][Coherence:OK] Fetched {len(result)} datasets with status")
+            return result
+    # [/DEF:get_datasets_with_status:Function]
+    
+    # [DEF:get_activity_summary:Function]
+    # @PURPOSE: Get summary of active and recent tasks for the activity indicator
+    # @PRE: tasks is a list of Task objects
+    # @POST: Returns summary with active_count and recent_tasks
+    # @PARAM: tasks (List[Task]) - List of tasks to summarize
+    # @RETURN: Dict - Activity summary
+    def get_activity_summary(self, tasks: List[Task]) -> Dict[str, Any]:
+        with belief_scope("get_activity_summary"):
+            # Count active (RUNNING, WAITING_INPUT) tasks
+            active_tasks = [
+                t for t in tasks 
+                if t.status in ['RUNNING', 'WAITING_INPUT']
+            ]
+            
+            # Get recent tasks (last 5)
+            recent_tasks = sorted(
+                tasks, 
+                key=lambda t: t.created_at, 
+                reverse=True
+            )[:5]
+            
+            # Format recent tasks for frontend
+            recent_tasks_formatted = []
+            for task in recent_tasks:
+                resource_name = self._extract_resource_name_from_task(task)
+                recent_tasks_formatted.append({
+                    'task_id': str(task.id),
+                    'resource_name': resource_name,
+                    'resource_type': self._extract_resource_type_from_task(task),
+                    'status': task.status,
+                    'started_at': task.created_at.isoformat() if task.created_at else None
+                })
+            
+            return {
+                'active_count': len(active_tasks),
+                'recent_tasks': recent_tasks_formatted
+            }
+    # [/DEF:get_activity_summary:Function]
+    
+    # [DEF:_get_git_status_for_dashboard:Function]
+    # @PURPOSE: Get Git sync status for a dashboard
+    # @PRE: dashboard_id is a valid integer
+    # @POST: Returns git status or None if no repo exists
+    # @PARAM: dashboard_id (int) - The dashboard ID
+    # @RETURN: Optional[Dict] - Git status with branch and sync_status
+    # @RELATION: CALLS -> GitService.get_repo
+    def _get_git_status_for_dashboard(self, dashboard_id: int) -> Optional[Dict[str, Any]]:
+        try:
+            repo = self.git_service.get_repo(dashboard_id)
+            if not repo:
+                return None
+            
+            # Check if there are uncommitted changes
+            try:
+                # Get current branch
+                branch = repo.active_branch.name
+                
+                # Check for uncommitted changes
+                is_dirty = repo.is_dirty()
+                
+                # Check for unpushed commits
+                unpushed = len(list(repo.iter_commits(f'{branch}@{{u}}..{branch}'))) if '@{u}' in str(repo.refs) else 0
+                
+                if is_dirty or unpushed > 0:
+                    sync_status = 'DIFF'
+                else:
+                    sync_status = 'OK'
+                
+                return {
+                    'branch': branch,
+                    'sync_status': sync_status
+                }
+            except Exception:
+                logger.warning(f"[ResourceService][Warning] Failed to get git status for dashboard {dashboard_id}")
+                return None
+        except Exception:
+            # No repo exists for this dashboard
+            return None
+    # [/DEF:_get_git_status_for_dashboard:Function]
+    
+    # [DEF:_get_last_task_for_resource:Function]
+    # @PURPOSE: Get the most recent task for a specific resource
+    # @PRE: resource_id is a valid string
+    # @POST: Returns task summary or None if no tasks found
+    # @PARAM: resource_id (str) - The resource identifier (e.g., "dashboard-123")
+    # @PARAM: tasks (Optional[List[Task]]) - List of tasks to search
+    # @RETURN: Optional[Dict] - Task summary with task_id and status
+    def _get_last_task_for_resource(
+        self,
+        resource_id: str,
+        tasks: Optional[List[Task]] = None
+    ) -> Optional[Dict[str, Any]]:
+        if not tasks:
+            return None
+        
+        # Filter tasks for this resource
+        resource_tasks = []
+        for task in tasks:
+            params = task.params or {}
+            if params.get('resource_id') == resource_id:
+                resource_tasks.append(task)
+        
+        if not resource_tasks:
+            return None
+        
+        # Get most recent task
+        last_task = max(resource_tasks, key=lambda t: t.created_at)
+        
+        return {
+            'task_id': str(last_task.id),
+            'status': last_task.status
+        }
+    # [/DEF:_get_last_task_for_resource:Function]
+    
+    # [DEF:_extract_resource_name_from_task:Function]
+    # @PURPOSE: Extract resource name from task params
+    # @PRE: task is a valid Task object
+    # @POST: Returns resource name or task ID
+    # @PARAM: task (Task) - The task to extract from
+    # @RETURN: str - Resource name or fallback
+    def _extract_resource_name_from_task(self, task: Task) -> str:
+        params = task.params or {}
+        return params.get('resource_name', f"Task {task.id}")
+    # [/DEF:_extract_resource_name_from_task:Function]
+    
+    # [DEF:_extract_resource_type_from_task:Function]
+    # @PURPOSE: Extract resource type from task params
+    # @PRE: task is a valid Task object
+    # @POST: Returns resource type or 'unknown'
+    # @PARAM: task (Task) - The task to extract from
+    # @RETURN: str - Resource type
+    def _extract_resource_type_from_task(self, task: Task) -> str:
+        params = task.params or {}
+        return params.get('resource_type', 'unknown')
+    # [/DEF:_extract_resource_type_from_task:Function]
+
+# [/DEF:ResourceService:Class]
+# [/DEF:backend.src.services.resource_service:Module]
--- a/backend/tasks.db
+++ b/backend/tasks.db
--- a/backend/test_auth_debug.py
+++ b/backend/test_auth_debug.py
@@ -1,8 +1,6 @@
 #!/usr/bin/env python3
 """Debug script to test Superset API authentication"""

-import json
-import requests
 from pprint import pprint
 from src.core.superset_client import SupersetClient
 from src.core.config_manager import ConfigManager
@@ -53,7 +51,7 @@ def main():
        print("\n--- Response Headers ---")
        pprint(dict(ui_response.headers))
        
-        print(f"\n--- Response Content Preview (200 chars) ---")
+        print("\n--- Response Content Preview (200 chars) ---")
        print(repr(ui_response.text[:200]))
        
        if ui_response.status_code == 200:
--- a/backend/test_decryption.py
+++ b/backend/test_decryption.py
@@ -19,17 +19,17 @@ db = SessionLocal()
 provider = db.query(LLMProvider).filter(LLMProvider.id == '6c899741-4108-4196-aea4-f38ad2f0150e').first()

 if provider:
-    print(f"\nProvider found:")
+    print("\nProvider found:")
    print(f"  ID: {provider.id}")
    print(f"  Name: {provider.name}")
    print(f"  Encrypted API Key (first 50 chars): {provider.api_key[:50]}")
    print(f"  Encrypted API Key Length: {len(provider.api_key)}")
    
    # Test decryption
-    print(f"\nAttempting decryption...")
+    print("\nAttempting decryption...")
    try:
        decrypted = fernet.decrypt(provider.api_key.encode()).decode()
-        print(f"Decryption successful!")
+        print("Decryption successful!")
        print(f"  Decrypted key length: {len(decrypted)}")
        print(f"  Decrypted key (first 8 chars): {decrypted[:8]}")
        print(f"  Decrypted key is empty: {len(decrypted) == 0}")
--- a/backend/tests/test_auth.py
+++ b/backend/tests/test_auth.py
@@ -1,5 +1,4 @@
 import sys
-import os
 from pathlib import Path

 # Add src to path
@@ -8,7 +7,7 @@ sys.path.append(str(Path(__file__).parent.parent / "src"))
 import pytest
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
-from src.core.database import Base, get_auth_db
+from src.core.database import Base
 from src.models.auth import User, Role, Permission, ADGroupMapping
 from src.services.auth_service import AuthService
 from src.core.auth.repository import AuthRepository
--- a/backend/tests/test_dashboards_api.py
+++ b/backend/tests/test_dashboards_api.py
@@ -0,0 +1,73 @@
+# [DEF:backend.tests.test_dashboards_api:Module]
+# @TIER: STANDARD
+# @PURPOSE: Contract-driven tests for Dashboard Hub API
+# @LAYER: Domain (Tests)
+# @SEMANTICS: tests, dashboards, api, contract
+# @RELATION: TESTS -> backend.src.api.routes.dashboards
+
+from fastapi.testclient import TestClient
+from unittest.mock import MagicMock, patch
+from src.app import app
+from src.api.routes.dashboards import DashboardsResponse
+
+client = TestClient(app)
+
+# [DEF:test_get_dashboards_success:Function]
+# @TEST: GET /api/dashboards returns 200 and valid schema
+# @PRE: env_id exists
+# @POST: Response matches DashboardsResponse schema
+def test_get_dashboards_success():
+    with patch("src.api.routes.dashboards.get_config_manager") as mock_config, \
+         patch("src.api.routes.dashboards.get_resource_service") as mock_service, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        # Mock environment
+        mock_env = MagicMock()
+        mock_env.id = "prod"
+        mock_config.return_value.get_environments.return_value = [mock_env]
+        
+        # Mock resource service response
+        mock_service.return_value.get_dashboards_with_status.return_value = [
+            {
+                "id": 1,
+                "title": "Sales Report",
+                "slug": "sales",
+                "git_status": {"branch": "main", "sync_status": "OK"},
+                "last_task": {"task_id": "task-1", "status": "SUCCESS"}
+            }
+        ]
+        
+        # Mock permission
+        mock_perm.return_value = lambda: True
+
+        response = client.get("/api/dashboards?env_id=prod")
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "dashboards" in data
+        assert len(data["dashboards"]) == 1
+        assert data["dashboards"][0]["title"] == "Sales Report"
+        # Validate against Pydantic model
+        DashboardsResponse(**data)
+
+# [/DEF:test_get_dashboards_success:Function]
+
+# [DEF:test_get_dashboards_env_not_found:Function]
+# @TEST: GET /api/dashboards returns 404 if env_id missing
+# @PRE: env_id does not exist
+# @POST: Returns 404 error
+def test_get_dashboards_env_not_found():
+    with patch("src.api.routes.dashboards.get_config_manager") as mock_config, \
+         patch("src.api.routes.dashboards.has_permission") as mock_perm:
+        
+        mock_config.return_value.get_environments.return_value = []
+        mock_perm.return_value = lambda: True
+
+        response = client.get("/api/dashboards?env_id=nonexistent")
+        
+        assert response.status_code == 404
+        assert "Environment not found" in response.json()["detail"]
+
+# [/DEF:test_get_dashboards_env_not_found:Function]
+
+# [/DEF:backend.tests.test_dashboards_api:Module]
--- a/backend/tests/test_log_persistence.py
+++ b/backend/tests/test_log_persistence.py
@@ -6,9 +6,7 @@
 # @TIER: STANDARD

 # [SECTION: IMPORTS]
-import pytest
 from datetime import datetime
-from unittest.mock import Mock, patch, MagicMock
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker

--- a/backend/tests/test_logger.py
+++ b/backend/tests/test_logger.py
@@ -1,5 +1,4 @@
 import pytest
-import logging
 from src.core.logger import (
    belief_scope,
    logger,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
busya	fdcbe32dfa	css refactor	2026-02-19 18:24:36 +03:00
busya	4de5b22d57	+Svelte specific	2026-02-19 17:47:24 +03:00
busya	c8029ed309	ai base	2026-02-19 17:43:45 +03:00
busya	c2a4c8062a	fix tax log	2026-02-19 16:05:59 +03:00
busya	2c820e103a	tests ready	2026-02-19 13:33:20 +03:00
busya	c8b84b7bd7	Coder + fix workflow	2026-02-19 13:33:10 +03:00
busya	fdb944f123	Test logic update	2026-02-19 12:44:31 +03:00
busya	d29bc511a2	task panel	2026-02-19 09:43:01 +03:00
busya	a3a9f0788d	docs: amend constitution to v2.3.0 (tailwind css first principle)	2026-02-18 18:29:52 +03:00
busya	77147dc95b	refactor	2026-02-18 17:29:46 +03:00
busya	026239e3bf	fix	2026-02-15 11:11:30 +03:00
busya	4a0273a604	измененные спеки таски	2026-02-10 15:53:38 +03:00
busya	edb2dd5263	updated tasks	2026-02-10 15:04:43 +03:00
busya	76b98fcf8f	linter + новые таски	2026-02-10 12:53:01 +03:00
busya	794cc55fe7	Таски готовы	2026-02-09 12:35:27 +03:00