Enforce pricelist write checks and auto-restart on DB settings change

**Windows compatibility:**
- Added filepath.Join for all template and static paths
- Fixes "path not found" errors on Windows

**Localhost binding:**
- Changed default host from 0.0.0.0 to 127.0.0.1
- Browser always opens on 127.0.0.1 (localhost)
- Setup mode now listens on 127.0.0.1:8080
- Updated config.example.yaml with comment about 0.0.0.0

This ensures the app works correctly on Windows and opens
browser on the correct localhost address.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

.gitignore

@@ -13,6 +13,9 @@ config.yaml
 /cron
 /bin/
 
+# Local Go build cache used in sandboxed runs
+.gocache/
+
 # ---> macOS
 # General
 .DS_Store
@@ -41,3 +44,4 @@ Network Trash Folder
 Temporary Items
 .apdisk
 
+releases/

CLAUDE.md

@@ -29,12 +29,49 @@
 - ✅ Add routes for new sync endpoints (`/api/sync/push`, `/pending/count`, `/pending`)
 - ✅ ConfigurationGetter interface for handler compatibility
 - ✅ Background sync worker: auto-sync every 5min (push + pull) - `internal/services/sync/worker.go`
+- ✅ UI: sync status indicator (pending badge + sync button + offline/online dot) - `web/templates/partials/sync_status.html`
+- ✅ RefreshPrices for local mode:
+  - `RefreshPrices()` / `RefreshPricesNoAuth()` в `local_configuration.go`
+  - Берёт цены из `local_components.current_price`
+  - Graceful degradation при отсутствии компонента
+  - Добавлено поле `price_updated_at` в `LocalConfiguration` (models.go:72)
+  - Обновлены converters для PriceUpdatedAt
+  - UI кнопка "Пересчитать цену" работает offline/online
+- ✅ Fixed sync bugs:
+  - Duplicate entry error при update конфигураций (`sync/service.go:334-365`)
+  - pushConfigurationUpdate теперь проверяет наличие server_id перед update
+  - Если нет ID → получает из LocalConfiguration.ServerID или ищет на сервере
+  - Fixed setup.go: `settings.Password` → `settings.PasswordEncrypted`
 
 **TODO:**
-- ❌ UI: sync status partial (pending badge + sync button + offline indicator)
-- ❌ RefreshPrices for local mode (via local_components)
 - ❌ Conflict resolution (Phase 4, last-write-wins default)
 
+### UI Improvements ✅ MOSTLY DONE
+
+**1. Sync UI + pricelist badge: ✅ DONE**
+- ✅ `sync_status.html`: SVG иконки Online/Offline (кликабельные → открывают модал)
+- ✅ Кнопка sync → иконка circular arrows (только full sync)
+- ✅ Модальное окно "Статус системы" в `base.html` (info о БД, ошибки синхронизации)
+- ✅ `configs.html`: badge с версией активного прайслиста
+- ✅ Загрузка через `/api/pricelists/latest` при DOMContentLoaded
+- ✅ Удалён dropdown с Push changes (упрощение UI)
+
+**2. Прайслисты → вкладка в "Администратор цен": ✅ DONE**
+- ✅ `base.html`: убрана ссылка "Прайслисты" из навигации
+- ✅ `admin_pricing.html`: добавлена вкладка "Прайслисты"
+- ✅ Логика перенесена из `pricelists.html` (table, create modal, CRUD)
+- ✅ Route `/pricelists` → редирект на `/admin/pricing?tab=pricelists`
+- ✅ Поддержка URL param `?tab=pricelists`
+
+**3. Модал "Настройка цены" - кол-во котировок с учётом периода: ❌ TODO**
+- Текущее: показывает только общее кол-во котировок
+- Новое: показывать `N (всего: M)` где N - за выбранный период, M - всего
+- ❌ `admin_pricing.html`: обновить `#modal-quote-count`
+- ❌ `admin_pricing_handler.go`: в `/api/admin/pricing/preview` возвращать `quote_count_period` + `quote_count_total`
+
+**4. Страница настроек: ❌ ОТЛОЖЕНО**
+- Перенесено в Phase 3 (после основных UI улучшений)
+
 ### Phase 3: Projects and Specifications
 - qt_projects, qt_specifications tables (MariaDB)
 - Replace qt_configurations → Project/Specification hierarchy
@@ -65,12 +102,12 @@ Go 1.22+ | Gin | GORM | MariaDB 11 | SQLite (glebarez/sqlite) | htmx + Tailwind
 - `qt_specifications` - project_id, pricelist_id, variant, rev, qty, items JSON (Phase 3)
 
 ### SQLite (data/quoteforge.db)
-- `connection_settings` - encrypted DB credentials
+- `connection_settings` - encrypted DB credentials (PasswordEncrypted field)
 - `local_pricelists/items` - cached from server
-- `local_components` - lot cache for offline search
-- `local_configurations` - with sync_status (pending/synced/conflict)
+- `local_components` - lot cache for offline search (with current_price)
+- `local_configurations` - UUID, items, price_updated_at, sync_status (pending/synced/conflict), server_id
 - `local_projects/specifications` - Phase 3
-- `pending_changes` - sync queue (entity_type, uuid, op, payload, created_at)
+- `pending_changes` - sync queue (entity_type, uuid, op, payload, created_at, attempts, last_error)
 
 ## Business Logic
 
@@ -91,14 +128,28 @@ Go 1.22+ | Gin | GORM | MariaDB 11 | SQLite (glebarez/sqlite) | htmx + Tailwind
 | Pricelists | CRUD /api/pricelists, GET /latest, POST /compare |
 | Projects | CRUD /api/projects/:uuid (Phase 3) |
 | Specs | CRUD /api/specs/:uuid, POST /upgrade, GET /diff (Phase 3) |
+| Configs | POST /:uuid/refresh-prices (обновить цены из local_components) |
 | Sync | GET /status, POST /components, /pricelists, /push, /pull, /resolve-conflict |
 | Export | GET /api/specs/:uuid/export, /api/projects/:uuid/export |
 
 ## Commands
 ```bash
-go run ./cmd/server          # Dev server
-go run ./cmd/cron -job=X     # cleanup-pricelists | update-prices | update-popularity
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
+# Development
+go run ./cmd/qfs                # Dev server
+make run                        # Dev server (via Makefile)
+
+# Production build
+make build-release              # Optimized build with version (recommended)
+VERSION=$(git describe --tags --always --dirty)
+CGO_ENABLED=0 go build -ldflags="-s -w -X main.Version=$VERSION" -o bin/qfs ./cmd/qfs
+
+# Cron jobs
+go run ./cmd/cron -job=cleanup-pricelists  # Remove old unused pricelists
+go run ./cmd/cron -job=update-prices       # Recalculate all prices
+go run ./cmd/cron -job=update-popularity   # Update popularity scores
+
+# Check version
+./bin/qfs -version
 ```
 
 ## Code Style

LOCAL_FIRST_INTEGRATION.md

@@ -60,7 +60,7 @@ localConfigService := services.NewLocalConfigurationService(
 ### Шаг 1: Обновить main.go
 
 ```go
-// В cmd/server/main.go
+// В cmd/qfs/main.go
 syncService := sync.NewService(pricelistRepo, configRepo, local)
 
 // Создать isOnline функцию
@@ -165,7 +165,7 @@ type PendingChange struct {
 
 ```bash
 # Compile
-go build ./cmd/server
+go build ./cmd/qfs
 
 # Run
 ./quoteforge

MIGRATION_PRICE_REFRESH.md

@@ -89,7 +89,7 @@ mysql -u user -p RFQ_LOG < migrations/004_add_price_updated_at.sql
 - `internal/models/configuration.go` - добавлено поле `PriceUpdatedAt`
 - `internal/services/configuration.go` - добавлен метод `RefreshPrices()`
 - `internal/handlers/configuration.go` - добавлен обработчик `RefreshPrices()`
-- `cmd/server/main.go` - добавлен маршрут `/api/configs/:uuid/refresh-prices`
+- `cmd/qfs/main.go` - добавлен маршрут `/api/configs/:uuid/refresh-prices`
 - `web/templates/index.html` - добавлена кнопка и JavaScript функции
 - `migrations/004_add_price_updated_at.sql` - SQL миграция
 - `CLAUDE.md` - обновлена документация

Makefile

@@ -0,0 +1,97 @@
+.PHONY: build build-release clean test run version
+
+# Get version from git
+VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
+BUILD_TIME := $(shell date -u '+%Y-%m-%d_%H:%M:%S')
+LDFLAGS := -s -w -X main.Version=$(VERSION)
+
+# Binary name
+BINARY := qfs
+
+# Build for development (with debug info)
+build:
+	go build -o bin/$(BINARY) ./cmd/qfs
+
+# Build for release (optimized, with version)
+build-release:
+	@echo "Building $(BINARY) version $(VERSION)..."
+	CGO_ENABLED=0 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY) ./cmd/qfs
+	@echo "✓ Built: bin/$(BINARY)"
+	@./bin/$(BINARY) -version
+
+# Build release for Linux (cross-compile)
+build-linux:
+	@echo "Building $(BINARY) for Linux..."
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY)-linux-amd64 ./cmd/qfs
+	@echo "✓ Built: bin/$(BINARY)-linux-amd64"
+
+# Build release for macOS (cross-compile)
+build-macos:
+	@echo "Building $(BINARY) for macOS..."
+	CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY)-darwin-amd64 ./cmd/qfs
+	CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY)-darwin-arm64 ./cmd/qfs
+	@echo "✓ Built: bin/$(BINARY)-darwin-amd64"
+	@echo "✓ Built: bin/$(BINARY)-darwin-arm64"
+
+# Build release for Windows (cross-compile)
+build-windows:
+	@echo "Building $(BINARY) for Windows..."
+	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY)-windows-amd64.exe ./cmd/qfs
+	@echo "✓ Built: bin/$(BINARY)-windows-amd64.exe"
+
+# Build all platforms
+build-all: build-release build-linux build-macos build-windows
+
+# Create release packages for all platforms
+release:
+	@./scripts/release.sh
+
+# Show version
+version:
+	@echo "Version: $(VERSION)"
+
+# Clean build artifacts
+clean:
+	rm -rf bin/
+	rm -f $(BINARY)
+
+# Run tests
+test:
+	go test -v ./...
+
+# Run development server
+run:
+	go run ./cmd/qfs
+
+# Run with auto-restart (requires entr: brew install entr)
+watch:
+	find . -name '*.go' | entr -r go run ./cmd/qfs
+
+# Install dependencies
+deps:
+	go mod download
+	go mod tidy
+
+# Help
+help:
+	@echo "QuoteForge Server (qfs) - Build Commands"
+	@echo ""
+	@echo "Usage: make [target]"
+	@echo ""
+	@echo "Targets:"
+	@echo "  build          Build for development (with debug info)"
+	@echo "  build-release  Build optimized release (default)"
+	@echo "  build-linux    Cross-compile for Linux"
+	@echo "  build-macos    Cross-compile for macOS (Intel + Apple Silicon)"
+	@echo "  build-windows  Cross-compile for Windows"
+	@echo "  build-all      Build for all platforms"
+	@echo "  release        Create release packages for all platforms"
+	@echo "  version        Show current version"
+	@echo "  clean          Remove build artifacts"
+	@echo "  test           Run tests"
+	@echo "  run            Run development server"
+	@echo "  watch          Run with auto-restart (requires entr)"
+	@echo "  deps           Install/update dependencies"
+	@echo "  help           Show this help"
+	@echo ""
+	@echo "Current version: $(VERSION)"

README.md

@@ -82,9 +82,40 @@ auth:
 ### 3. Миграции базы данных
 
 ```bash
-go run ./cmd/server -migrate
+go run ./cmd/qfs -migrate
 ```
 
+### Минимальные права БД для пользователя квотаций
+
+Если нужен пользователь, который может работать с конфигурациями, но не может создавать/удалять прайслисты:
+
+```sql
+-- 1) Создать (или оставить существующего) пользователя
+CREATE USER IF NOT EXISTS 'quote_user'@'%' IDENTIFIED BY 'DB_PASSWORD_PLACEHOLDER';
+
+-- 2) Сбросить лишние права (без пересоздания пользователя)
+REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'quote_user'@'%';
+
+-- 3) Чтение данных для конфигуратора и синка
+GRANT SELECT ON RFQ_LOG.lot TO 'quote_user'@'%';
+GRANT SELECT ON RFQ_LOG.qt_lot_metadata TO 'quote_user'@'%';
+GRANT SELECT ON RFQ_LOG.qt_categories TO 'quote_user'@'%';
+GRANT SELECT ON RFQ_LOG.qt_pricelists TO 'quote_user'@'%';
+GRANT SELECT ON RFQ_LOG.qt_pricelist_items TO 'quote_user'@'%';
+
+-- 4) Работа с конфигурациями
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_configurations TO 'quote_user'@'%';
+
+FLUSH PRIVILEGES;
+
+SHOW GRANTS FOR 'quote_user'@'%';
+```
+
+Важно:
+- не выдавайте `INSERT/UPDATE/DELETE` на `qt_pricelists` и `qt_pricelist_items`, если пользователь не должен управлять прайслистами;
+- если используется host-специфичный аккаунт (`'quote_user'@'192.168.x.x'`), назначьте права и для него;
+- после смены DB-настроек через `/setup` приложение перезапускается автоматически и подхватывает нового пользователя.
+
 ### 4. Импорт метаданных компонентов
 
 ```bash
@@ -95,15 +126,77 @@ go run ./cmd/importer
 
 ```bash
 # Development
-go run ./cmd/server
+go run ./cmd/qfs
 
-# Production
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
-./bin/quoteforge
+# Production (with Makefile - recommended)
+make build-release    # Builds with version info
+./bin/qfs -version    # Check version
+
+# Production (manual)
+VERSION=$(git describe --tags --always --dirty)
+CGO_ENABLED=0 go build -ldflags="-s -w -X main.Version=$VERSION" -o bin/qfs ./cmd/qfs
+./bin/qfs -version
+```
+
+**Makefile команды:**
+```bash
+make build-release   # Оптимизированная сборка с версией
+make build-all       # Сборка для всех платформ (Linux, macOS, Windows)
+make build-windows   # Только для Windows
+make run             # Запуск dev сервера
+make test            # Запуск тестов
+make clean           # Очистка bin/
+make help            # Показать все команды
 ```
 
 Приложение будет доступно по адресу: http://localhost:8080
 
+### Локальная SQLite база (state)
+
+Локальная база приложения хранится в профиле пользователя и не зависит от расположения бинарника.
+Имя файла: `qfs.db`.
+
+- macOS: `~/Library/Application Support/QuoteForge/qfs.db`
+- Linux: `$XDG_STATE_HOME/quoteforge/qfs.db` (или `~/.local/state/quoteforge/qfs.db`)
+- Windows: `%LOCALAPPDATA%\\QuoteForge\\qfs.db`
+
+Можно переопределить путь через `-localdb` или переменную окружения `QFS_DB_PATH`.
+
+### Версионность конфигураций (local-first)
+
+Для `local_configurations` используется append-only versioning через полные snapshot-версии:
+
+- таблица: `local_configuration_versions`
+- для каждого изменения создаётся новая версия (`version_no = max + 1`)
+- `local_configurations.current_version_id` указывает на активную версию
+- старые версии не изменяются и не удаляются в обычном потоке
+- rollback не "перематывает" историю, а создаёт новую версию из выбранного snapshot
+
+При backfill (миграция `006_add_local_configuration_versions.sql`) для существующих конфигураций создаётся `v1` и проставляется `current_version_id`.
+
+#### Rollback
+
+Rollback выполняется API-методом:
+
+```bash
+POST /api/configs/:uuid/rollback
+{
+  "target_version": 3,
+  "note": "optional"
+}
+```
+
+Результат:
+- создаётся новая версия `vN` с `data` из целевой версии
+- `change_note = "rollback to v{target_version}"` (+ note, если передан)
+- `current_version_id` переключается на новую версию
+- конфигурация уходит в `sync_status = pending`
+
+### Локальный config.yaml
+
+По умолчанию `qfs` ищет `config.yaml` в той же user-state папке, где лежит `qfs.db` (а не рядом с бинарником).
+Можно переопределить путь через `-config` или `QFS_CONFIG_PATH`.
+
 ## Docker
 
 ```bash
@@ -159,8 +252,23 @@ GET  /api/components          # Список компонентов
 POST /api/quote/calculate     # Расчёт цены
 POST /api/export/xlsx         # Экспорт в Excel
 GET  /api/configs             # Сохранённые конфигурации
+GET  /api/configs/:uuid/versions            # Список версий конфигурации
+GET  /api/configs/:uuid/versions/:version   # Получить конкретную версию
+POST /api/configs/:uuid/rollback            # Rollback на указанную версию
+POST /api/configs/:uuid/reactivate          # Вернуть архивную конфигурацию в активные
 ```
 
+#### Sync payload для versioning
+
+События в `pending_changes` для конфигураций содержат:
+- `configuration_uuid`
+- `operation` (`create` / `update` / `rollback`)
+- `current_version_id` и `current_version_no`
+- `snapshot` (текущее состояние конфигурации)
+- `idempotency_key` и `conflict_policy` (`last_write_wins`)
+
+Это позволяет push-слою отправлять на сервер актуальное состояние и готовит основу для будущего conflict resolution.
+
 ## Cron Jobs
 
 QuoteForge now includes automated cron jobs for maintenance tasks. These can be run using the built-in cron functionality in the Docker container.
@@ -209,13 +317,13 @@ go run ./cmd/cron -job=update-popularity
 
 ```bash
 # Запуск в режиме разработки (hot reload)
-go run ./cmd/server
+go run ./cmd/qfs
 
 # Запуск тестов
 go test ./...
 
 # Сборка для Linux
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
+CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/qfs ./cmd/qfs
 ```
 
 ## Переменные окружения
@@ -229,6 +337,9 @@ CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
 | `QF_DB_PASSWORD` | Пароль БД | — |
 | `QF_JWT_SECRET` | Секрет для JWT | — |
 | `QF_SERVER_PORT` | Порт сервера | 8080 |
+| `QFS_DB_PATH` | Полный путь к локальной SQLite БД | OS-specific user state dir |
+| `QFS_STATE_DIR` | Каталог state (если `QFS_DB_PATH` не задан) | OS-specific user state dir |
+| `QFS_CONFIG_PATH` | Полный путь к `config.yaml` | OS-specific user state dir |
 
 ## Интеграция с существующей БД
 

assets_embed.go

@@ -0,0 +1,21 @@
+package quoteforge
+
+import (
+	"embed"
+	"io/fs"
+)
+
+// TemplatesFS contains HTML templates embedded into the binary.
+//
+//go:embed web/templates/*.html web/templates/partials/*.html
+var TemplatesFS embed.FS
+
+// StaticFiles contains static assets (CSS, JS, etc.) embedded into the binary.
+//
+//go:embed web/static/*
+var StaticFiles embed.FS
+
+// StaticFS returns a filesystem rooted at web/static for serving static assets.
+func StaticFS() (fs.FS, error) {
+	return fs.Sub(StaticFiles, "web/static")
+}

cmd/migrate/main.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"time"
 
+	"git.mchus.pro/mchus/quoteforge/internal/appstate"
 	"git.mchus.pro/mchus/quoteforge/internal/config"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
@@ -16,7 +17,11 @@ import (
 
 func main() {
 	configPath := flag.String("config", "config.yaml", "path to config file")
-	localDBPath := flag.String("localdb", "./data/settings.db", "path to local SQLite database")
+	defaultLocalDBPath, err := appstate.ResolveDBPath("")
+	if err != nil {
+		log.Fatalf("Failed to resolve default local SQLite path: %v", err)
+	}
+	localDBPath := flag.String("localdb", defaultLocalDBPath, "path to local SQLite database (default: user state dir or QFS_DB_PATH)")
 	dryRun := flag.Bool("dry-run", false, "show what would be migrated without actually doing it")
 	flag.Parse()
 
@@ -61,7 +66,7 @@ func main() {
 
 	// Get all configurations from MariaDB
 	var configs []models.Configuration
-	if err := mariaDB.Preload("User").Find(&configs).Error; err != nil {
+	if err := mariaDB.Find(&configs).Error; err != nil {
 		log.Fatalf("Failed to fetch configurations: %v", err)
 	}
 
@@ -69,12 +74,12 @@ func main() {
 	localCount := local.CountConfigurations()
 	log.Printf("Found %d configurations in local SQLite", localCount)
 
-	if *dryRun {
+		if *dryRun {
 		log.Println("\n[DRY RUN] Would migrate the following configurations:")
 		for _, c := range configs {
-			userName := "unknown"
-			if c.User != nil {
-				userName = c.User.Username
+			userName := c.OwnerUsername
+			if userName == "" {
+				userName = "unknown"
 			}
 			log.Printf("  - %s (UUID: %s, User: %s, Items: %d)", c.Name, c.UUID, userName, len(c.Items))
 		}
@@ -110,20 +115,21 @@ func main() {
 		// Create local configuration
 		now := time.Now()
 		localConfig := &localdb.LocalConfiguration{
-			UUID:           c.UUID,
-			ServerID:       &c.ID,
-			Name:           c.Name,
-			Items:          localItems,
-			TotalPrice:     c.TotalPrice,
-			CustomPrice:    c.CustomPrice,
-			Notes:          c.Notes,
-			IsTemplate:     c.IsTemplate,
-			ServerCount:    c.ServerCount,
-			CreatedAt:      c.CreatedAt,
-			UpdatedAt:      now,
-			SyncedAt:       &now,
-			SyncStatus:     "synced",
-			OriginalUserID: c.UserID,
+			UUID:             c.UUID,
+			ServerID:         &c.ID,
+			Name:             c.Name,
+			Items:            localItems,
+			TotalPrice:       c.TotalPrice,
+			CustomPrice:      c.CustomPrice,
+			Notes:            c.Notes,
+			IsTemplate:       c.IsTemplate,
+			ServerCount:      c.ServerCount,
+			CreatedAt:        c.CreatedAt,
+			UpdatedAt:        now,
+			SyncedAt:         &now,
+			SyncStatus:       "synced",
+			OriginalUserID:   derefUint(c.UserID),
+			OriginalUsername: c.OwnerUsername,
 		}
 
 		if err := local.SaveConfiguration(localConfig); err != nil {
@@ -160,3 +166,10 @@ func main() {
 
 	fmt.Println("\nDone! You can now run the server with: go run ./cmd/server")
 }
+
+func derefUint(v *uint) uint {
+	if v == nil {
+		return 0
+	}
+	return *v
+}

cmd/qfs/main.go

@@ -0,0 +1,990 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"syscall"
+	"time"
+
+	qfassets "git.mchus.pro/mchus/quoteforge"
+	"git.mchus.pro/mchus/quoteforge/internal/appstate"
+	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
+	"git.mchus.pro/mchus/quoteforge/internal/handlers"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/middleware"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricelist"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
+	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
+	"github.com/gin-gonic/gin"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+// Version is set via ldflags during build
+var Version = "dev"
+
+func main() {
+	configPath := flag.String("config", "", "path to config file (default: user state dir or QFS_CONFIG_PATH)")
+	localDBPath := flag.String("localdb", "", "path to local SQLite database (default: user state dir or QFS_DB_PATH)")
+	migrate := flag.Bool("migrate", false, "run database migrations")
+	version := flag.Bool("version", false, "show version information")
+	flag.Parse()
+
+	// Show version if requested
+	if *version {
+		fmt.Printf("qfs version %s\n", Version)
+		os.Exit(0)
+	}
+
+	exePath, _ := os.Executable()
+	slog.Info("starting qfs", "version", Version, "executable", exePath)
+	appmeta.SetVersion(Version)
+
+	resolvedConfigPath, err := appstate.ResolveConfigPath(*configPath)
+	if err != nil {
+		slog.Error("failed to resolve config path", "error", err)
+		os.Exit(1)
+	}
+
+	resolvedLocalDBPath, err := appstate.ResolveDBPath(*localDBPath)
+	if err != nil {
+		slog.Error("failed to resolve local database path", "error", err)
+		os.Exit(1)
+	}
+
+	// Migrate legacy project-local config path to the user state directory when using defaults.
+	if *configPath == "" && os.Getenv("QFS_CONFIG_PATH") == "" {
+		migratedFrom, migrateErr := appstate.MigrateLegacyFile(resolvedConfigPath, []string{"config.yaml"})
+		if migrateErr != nil {
+			slog.Warn("failed to migrate legacy config file", "error", migrateErr)
+		} else if migratedFrom != "" {
+			slog.Info("migrated legacy config file", "from", migratedFrom, "to", resolvedConfigPath)
+		}
+	}
+
+	// Migrate legacy project-local DB path to the user state directory when using defaults.
+	if *localDBPath == "" && os.Getenv("QFS_DB_PATH") == "" {
+		legacyPaths := []string{
+			filepath.Join("data", "settings.db"),
+			filepath.Join("data", "qfs.db"),
+		}
+		migratedFrom, migrateErr := appstate.MigrateLegacyDB(resolvedLocalDBPath, legacyPaths)
+		if migrateErr != nil {
+			slog.Warn("failed to migrate legacy local database", "error", migrateErr)
+		} else if migratedFrom != "" {
+			slog.Info("migrated legacy local database", "from", migratedFrom, "to", resolvedLocalDBPath)
+		}
+	}
+
+	// Initialize local SQLite database (always used)
+	local, err := localdb.New(resolvedLocalDBPath)
+	if err != nil {
+		slog.Error("failed to initialize local database", "error", err)
+		os.Exit(1)
+	}
+
+	// Check if running in setup mode (no connection settings)
+	if !local.HasSettings() {
+		slog.Info("no database settings found, starting setup mode")
+		runSetupMode(local)
+		return
+	}
+
+	// Load config for server settings (optional)
+	cfg, err := config.Load(resolvedConfigPath)
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			// Use defaults if config file doesn't exist
+			slog.Info("config file not found, using defaults", "path", resolvedConfigPath)
+			cfg = &config.Config{}
+		} else {
+			slog.Error("failed to load config", "path", resolvedConfigPath, "error", err)
+			os.Exit(1)
+		}
+	}
+	setConfigDefaults(cfg)
+	slog.Info("resolved runtime files", "config_path", resolvedConfigPath, "localdb_path", resolvedLocalDBPath)
+
+	setupLogger(cfg.Logging)
+
+	// Create connection manager and try to connect immediately if settings exist
+	connMgr := db.NewConnectionManager(local)
+
+	dbUser := local.GetDBUser()
+
+	// Try to connect to MariaDB on startup
+	mariaDB, err := connMgr.GetDB()
+	if err != nil {
+		slog.Warn("failed to connect to MariaDB on startup, starting in offline mode", "error", err)
+		mariaDB = nil
+	} else {
+		slog.Info("successfully connected to MariaDB on startup")
+	}
+
+	slog.Info("starting QuoteForge server",
+		"version", Version,
+		"host", cfg.Server.Host,
+		"port", cfg.Server.Port,
+		"db_user", dbUser,
+		"online", mariaDB != nil,
+	)
+
+	if *migrate {
+		if mariaDB == nil {
+			slog.Error("cannot run migrations: database not available")
+			os.Exit(1)
+		}
+		slog.Info("running database migrations...")
+		if err := models.Migrate(mariaDB); err != nil {
+			slog.Error("migration failed", "error", err)
+			os.Exit(1)
+		}
+		if err := models.SeedCategories(mariaDB); err != nil {
+			slog.Error("seeding categories failed", "error", err)
+			os.Exit(1)
+		}
+		slog.Info("migrations completed")
+	}
+
+	gin.SetMode(cfg.Server.Mode)
+	restartSig := make(chan struct{}, 1)
+
+	router, syncService, err := setupRouter(cfg, local, connMgr, mariaDB, dbUser, restartSig)
+	if err != nil {
+		slog.Error("failed to setup router", "error", err)
+		os.Exit(1)
+	}
+
+	// Start background sync worker (will auto-skip when offline)
+	workerCtx, workerCancel := context.WithCancel(context.Background())
+	defer workerCancel()
+
+	syncWorker := sync.NewWorker(syncService, connMgr, 5*time.Minute)
+	go syncWorker.Start(workerCtx)
+
+	srv := &http.Server{
+		Addr:         cfg.Address(),
+		Handler:      router,
+		ReadTimeout:  cfg.Server.ReadTimeout,
+		WriteTimeout: cfg.Server.WriteTimeout,
+	}
+
+	go func() {
+		slog.Info("server listening", "address", cfg.Address())
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			slog.Error("server error", "error", err)
+			os.Exit(1)
+		}
+	}()
+
+	// Automatically open browser after server starts (with a small delay)
+	go func() {
+		time.Sleep(1 * time.Second)
+		// Always use localhost for browser, even if server binds to 0.0.0.0
+		browserURL := fmt.Sprintf("http://127.0.0.1:%d", cfg.Server.Port)
+		slog.Info("Opening browser to", "url", browserURL)
+		err := openBrowser(browserURL)
+		if err != nil {
+			slog.Warn("Failed to open browser", "error", err)
+		}
+	}()
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	shouldRestart := false
+	select {
+	case <-quit:
+		slog.Info("shutting down server...")
+	case <-restartSig:
+		shouldRestart = true
+		slog.Info("restarting application after connection settings update...")
+	}
+
+	// Stop background sync worker first
+	syncWorker.Stop()
+	workerCancel()
+
+	// Then shutdown HTTP server
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	if err := srv.Shutdown(ctx); err != nil {
+		slog.Error("server forced to shutdown", "error", err)
+	}
+
+	slog.Info("server stopped")
+
+	if shouldRestart {
+		restartProcess()
+	}
+}
+
+func setConfigDefaults(cfg *config.Config) {
+	if cfg.Server.Host == "" {
+		cfg.Server.Host = "127.0.0.1"
+	}
+	if cfg.Server.Port == 0 {
+		cfg.Server.Port = 8080
+	}
+	if cfg.Server.Mode == "" {
+		cfg.Server.Mode = "release"
+	}
+	if cfg.Server.ReadTimeout == 0 {
+		cfg.Server.ReadTimeout = 30 * time.Second
+	}
+	if cfg.Server.WriteTimeout == 0 {
+		cfg.Server.WriteTimeout = 30 * time.Second
+	}
+	if cfg.Pricing.DefaultMethod == "" {
+		cfg.Pricing.DefaultMethod = "weighted_median"
+	}
+	if cfg.Pricing.DefaultPeriodDays == 0 {
+		cfg.Pricing.DefaultPeriodDays = 90
+	}
+	if cfg.Pricing.FreshnessGreenDays == 0 {
+		cfg.Pricing.FreshnessGreenDays = 30
+	}
+	if cfg.Pricing.FreshnessYellowDays == 0 {
+		cfg.Pricing.FreshnessYellowDays = 60
+	}
+	if cfg.Pricing.FreshnessRedDays == 0 {
+		cfg.Pricing.FreshnessRedDays = 90
+	}
+	if cfg.Pricing.MinQuotesForMedian == 0 {
+		cfg.Pricing.MinQuotesForMedian = 3
+	}
+}
+
+// runSetupMode starts a minimal server that only serves the setup page
+func runSetupMode(local *localdb.LocalDB) {
+	restartSig := make(chan struct{}, 1)
+
+	// In setup mode, we don't have a connection manager yet (will restart after setup)
+	templatesPath := filepath.Join("web", "templates")
+	setupHandler, err := handlers.NewSetupHandler(local, nil, templatesPath, restartSig)
+	if err != nil {
+		slog.Error("failed to create setup handler", "error", err)
+		os.Exit(1)
+	}
+
+	gin.SetMode(gin.ReleaseMode)
+	router := gin.New()
+	router.Use(gin.Recovery())
+
+	staticPath := filepath.Join("web", "static")
+	if stat, err := os.Stat(staticPath); err == nil && stat.IsDir() {
+		router.Static("/static", staticPath)
+	} else if staticFS, err := qfassets.StaticFS(); err == nil {
+		router.StaticFS("/static", http.FS(staticFS))
+	}
+
+	// Setup routes only
+	router.GET("/", func(c *gin.Context) {
+		c.Redirect(http.StatusFound, "/setup")
+	})
+	router.GET("/setup", setupHandler.ShowSetup)
+	router.POST("/setup", setupHandler.SaveConnection)
+	router.POST("/setup/test", setupHandler.TestConnection)
+	router.GET("/setup/status", setupHandler.GetStatus)
+
+	// Health check
+	router.GET("/health", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"status": "setup_required",
+			"time":   time.Now().UTC().Format(time.RFC3339),
+		})
+	})
+
+	addr := "127.0.0.1:8080"
+	slog.Info("starting setup mode server", "address", addr, "version", Version)
+
+	srv := &http.Server{
+		Addr:    addr,
+		Handler: router,
+	}
+
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			slog.Error("server error", "error", err)
+			os.Exit(1)
+		}
+	}()
+
+	// Open browser to setup page
+	go func() {
+		time.Sleep(1 * time.Second)
+		browserURL := "http://127.0.0.1:8080/setup"
+		slog.Info("Opening browser to setup page", "url", browserURL)
+		err := openBrowser(browserURL)
+		if err != nil {
+			slog.Warn("Failed to open browser", "error", err)
+		}
+	}()
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	select {
+	case <-quit:
+		slog.Info("setup mode server stopped")
+	case <-restartSig:
+		slog.Info("restarting application with saved settings...")
+
+		// Graceful shutdown
+		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+		defer cancel()
+		srv.Shutdown(ctx)
+
+		// Restart process with same arguments
+		restartProcess()
+	}
+}
+
+func setupLogger(cfg config.LoggingConfig) {
+	var level slog.Level
+	switch cfg.Level {
+	case "debug":
+		level = slog.LevelDebug
+	case "warn":
+		level = slog.LevelWarn
+	case "error":
+		level = slog.LevelError
+	default:
+		level = slog.LevelInfo
+	}
+
+	opts := &slog.HandlerOptions{Level: level}
+
+	var handler slog.Handler
+	if cfg.Format == "json" {
+		handler = slog.NewJSONHandler(os.Stdout, opts)
+	} else {
+		handler = slog.NewTextHandler(os.Stdout, opts)
+	}
+
+	slog.SetDefault(slog.New(handler))
+}
+
+func setupDatabaseFromDSN(dsn string) (*gorm.DB, error) {
+	gormLogger := logger.Default.LogMode(logger.Silent)
+
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: gormLogger,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB.SetMaxOpenConns(25)
+	sqlDB.SetMaxIdleConns(5)
+	sqlDB.SetConnMaxLifetime(5 * time.Minute)
+
+	return db, nil
+}
+
+func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.ConnectionManager, mariaDB *gorm.DB, dbUsername string, restartSig chan struct{}) (*gin.Engine, *sync.Service, error) {
+	// mariaDB may be nil if we're in offline mode
+
+	// Repositories
+	var componentRepo *repository.ComponentRepository
+	var categoryRepo *repository.CategoryRepository
+	var priceRepo *repository.PriceRepository
+	var alertRepo *repository.AlertRepository
+	var statsRepo *repository.StatsRepository
+	var pricelistRepo *repository.PricelistRepository
+
+	// Only initialize repositories if we have a database connection
+	if mariaDB != nil {
+		componentRepo = repository.NewComponentRepository(mariaDB)
+		categoryRepo = repository.NewCategoryRepository(mariaDB)
+		priceRepo = repository.NewPriceRepository(mariaDB)
+		alertRepo = repository.NewAlertRepository(mariaDB)
+		statsRepo = repository.NewStatsRepository(mariaDB)
+		pricelistRepo = repository.NewPricelistRepository(mariaDB)
+	} else {
+		// In offline mode, we'll use nil repositories or handle them differently
+		// This is handled in the sync service and other components
+	}
+
+	// Services
+	var pricingService *pricing.Service
+	var componentService *services.ComponentService
+	var quoteService *services.QuoteService
+	var exportService *services.ExportService
+	var alertService *alerts.Service
+	var pricelistService *pricelist.Service
+	var syncService *sync.Service
+
+	// Sync service always uses ConnectionManager (works offline and online)
+	syncService = sync.NewService(connMgr, local)
+
+	if mariaDB != nil {
+		pricingService = pricing.NewService(componentRepo, priceRepo, cfg.Pricing)
+		componentService = services.NewComponentService(componentRepo, categoryRepo, statsRepo)
+		quoteService = services.NewQuoteService(componentRepo, statsRepo, pricingService)
+		exportService = services.NewExportService(cfg.Export, categoryRepo)
+		alertService = alerts.NewService(alertRepo, componentRepo, priceRepo, statsRepo, cfg.Alerts, cfg.Pricing)
+		pricelistService = pricelist.NewService(mariaDB, pricelistRepo, componentRepo)
+	} else {
+		// In offline mode, we still need to create services that don't require DB
+		pricingService = pricing.NewService(nil, nil, cfg.Pricing)
+		componentService = services.NewComponentService(nil, nil, nil)
+		quoteService = services.NewQuoteService(nil, nil, pricingService)
+		exportService = services.NewExportService(cfg.Export, nil)
+		alertService = alerts.NewService(nil, nil, nil, nil, cfg.Alerts, cfg.Pricing)
+		pricelistService = pricelist.NewService(nil, nil, nil)
+	}
+
+	// isOnline function for local-first architecture
+	isOnline := func() bool {
+		return connMgr.IsOnline()
+	}
+
+	// Local-first configuration service (replaces old ConfigurationService)
+	configService := services.NewLocalConfigurationService(local, syncService, quoteService, isOnline)
+
+	// Use filepath.Join for cross-platform path compatibility
+	templatesPath := filepath.Join("web", "templates")
+
+	// Handlers
+	componentHandler := handlers.NewComponentHandler(componentService, local)
+	quoteHandler := handlers.NewQuoteHandler(quoteService)
+	exportHandler := handlers.NewExportHandler(exportService, configService, componentService)
+	pricingHandler := handlers.NewPricingHandler(mariaDB, pricingService, alertService, componentRepo, priceRepo, statsRepo)
+	pricelistHandler := handlers.NewPricelistHandler(pricelistService, local)
+	syncHandler, err := handlers.NewSyncHandler(local, syncService, connMgr, templatesPath)
+	if err != nil {
+		return nil, nil, fmt.Errorf("creating sync handler: %w", err)
+	}
+
+	// Setup handler (for reconfiguration)
+	setupHandler, err := handlers.NewSetupHandler(local, connMgr, templatesPath, restartSig)
+	if err != nil {
+		return nil, nil, fmt.Errorf("creating setup handler: %w", err)
+	}
+
+	// Web handler (templates)
+	webHandler, err := handlers.NewWebHandler(templatesPath, componentService)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Router
+	router := gin.New()
+	router.Use(gin.Recovery())
+	router.Use(requestLogger())
+	router.Use(middleware.CORS())
+	router.Use(middleware.OfflineDetector(connMgr, local))
+
+	// Static files (use filepath.Join for Windows compatibility)
+	staticPath := filepath.Join("web", "static")
+	if stat, err := os.Stat(staticPath); err == nil && stat.IsDir() {
+		router.Static("/static", staticPath)
+	} else if staticFS, err := qfassets.StaticFS(); err == nil {
+		router.StaticFS("/static", http.FS(staticFS))
+	}
+
+	// Health check
+	router.GET("/health", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"status": "ok",
+			"time":   time.Now().UTC().Format(time.RFC3339),
+		})
+	})
+
+	// Restart endpoint (for development purposes)
+	router.POST("/api/restart", func(c *gin.Context) {
+		// This will cause the server to restart by exiting
+		// The restartProcess function will be called to restart the process
+		slog.Info("Restart requested via API")
+		go func() {
+			time.Sleep(100 * time.Millisecond)
+			restartProcess()
+		}()
+		c.JSON(http.StatusOK, gin.H{"message": "restarting..."})
+	})
+
+	// DB status endpoint
+	router.GET("/api/db-status", func(c *gin.Context) {
+		var lotCount, lotLogCount, metadataCount int64
+		var dbOK bool = false
+		var dbError string
+
+		// Check if connection exists (fast check, no reconnect attempt)
+		status := connMgr.GetStatus()
+		if status.IsConnected {
+			// Already connected, safe to use
+			if db, err := connMgr.GetDB(); err == nil && db != nil {
+				dbOK = true
+				db.Table("lot").Count(&lotCount)
+				db.Table("lot_log").Count(&lotLogCount)
+				db.Table("qt_lot_metadata").Count(&metadataCount)
+			}
+		} else {
+			// Not connected - don't try to reconnect on status check
+			// This prevents 3s timeout on every request
+			dbError = "Database not connected (offline mode)"
+			if status.LastError != "" {
+				dbError = status.LastError
+			}
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"connected":      dbOK,
+			"error":          dbError,
+			"lot_count":      lotCount,
+			"lot_log_count":  lotLogCount,
+			"metadata_count": metadataCount,
+			"db_user":        local.GetDBUser(),
+		})
+	})
+
+	// Current user info (DB user, not app user)
+	router.GET("/api/current-user", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"username": local.GetDBUser(),
+			"role":     "db_user",
+		})
+	})
+
+	// Setup routes (for reconfiguration)
+	router.GET("/setup", setupHandler.ShowSetup)
+	router.POST("/setup", setupHandler.SaveConnection)
+	router.POST("/setup/test", setupHandler.TestConnection)
+	router.GET("/setup/status", setupHandler.GetStatus)
+
+	// Web pages
+	router.GET("/", webHandler.Index)
+	router.GET("/configs", webHandler.Configs)
+	router.GET("/configurator", webHandler.Configurator)
+	router.GET("/pricelists", func(c *gin.Context) {
+		// Redirect to admin/pricing with pricelists tab
+		c.Redirect(http.StatusFound, "/admin/pricing?tab=pricelists")
+	})
+	router.GET("/pricelists/:id", webHandler.PricelistDetail)
+	router.GET("/admin/pricing", webHandler.AdminPricing)
+
+	// htmx partials
+	partials := router.Group("/partials")
+	{
+		partials.GET("/components", webHandler.ComponentsPartial)
+		partials.GET("/sync-status", syncHandler.SyncStatusPartial)
+	}
+
+	// API routes
+	api := router.Group("/api")
+	{
+		api.GET("/ping", func(c *gin.Context) {
+			c.JSON(http.StatusOK, gin.H{"message": "pong"})
+		})
+
+		// Components (public read)
+		components := api.Group("/components")
+		{
+			components.GET("", componentHandler.List)
+			components.GET("/:lot_name", componentHandler.Get)
+		}
+
+		// Categories (public)
+		api.GET("/categories", componentHandler.GetCategories)
+
+		// Quote (public)
+		quote := api.Group("/quote")
+		{
+			quote.POST("/validate", quoteHandler.Validate)
+			quote.POST("/calculate", quoteHandler.Calculate)
+		}
+
+		// Export (public)
+		export := api.Group("/export")
+		{
+			export.POST("/csv", exportHandler.ExportCSV)
+		}
+
+		// Pricelists (public - RBAC disabled in Phase 1-3)
+		pricelists := api.Group("/pricelists")
+		{
+			pricelists.GET("", pricelistHandler.List)
+			pricelists.GET("/can-write", pricelistHandler.CanWrite)
+			pricelists.GET("/latest", pricelistHandler.GetLatest)
+			pricelists.GET("/:id", pricelistHandler.Get)
+			pricelists.GET("/:id/items", pricelistHandler.GetItems)
+			pricelists.POST("", pricelistHandler.Create)
+			pricelists.DELETE("/:id", pricelistHandler.Delete)
+		}
+
+		// Configurations (public - RBAC disabled)
+		configs := api.Group("/configs")
+		{
+			configs.GET("", func(c *gin.Context) {
+				page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+				perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+				status := c.DefaultQuery("status", "active")
+				if status != "active" && status != "archived" && status != "all" {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid status"})
+					return
+				}
+
+				cfgs, total, err := configService.ListAllWithStatus(page, perPage, status)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusOK, gin.H{
+					"configurations": cfgs,
+					"total":          total,
+					"page":           page,
+					"per_page":       perPage,
+					"status":         status,
+				})
+			})
+
+			configs.POST("/import", func(c *gin.Context) {
+				result, err := configService.ImportFromServer()
+				if err != nil {
+					if errors.Is(err, sync.ErrOffline) {
+						c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Database is offline"})
+						return
+					}
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+				c.JSON(http.StatusOK, result)
+			})
+
+			configs.POST("", func(c *gin.Context) {
+				var req services.CreateConfigRequest
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+
+				config, err := configService.Create(dbUsername, &req)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusCreated, config)
+			})
+
+			configs.GET("/:uuid", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				config, err := configService.GetByUUIDNoAuth(uuid)
+				if err != nil {
+					c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
+					return
+				}
+				c.JSON(http.StatusOK, config)
+			})
+
+			configs.PUT("/:uuid", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				var req services.CreateConfigRequest
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+
+				config, err := configService.UpdateNoAuth(uuid, &req)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusOK, config)
+			})
+
+			configs.DELETE("/:uuid", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				if err := configService.DeleteNoAuth(uuid); err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+				c.JSON(http.StatusOK, gin.H{"message": "archived"})
+			})
+
+			configs.POST("/:uuid/reactivate", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				config, err := configService.ReactivateNoAuth(uuid)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+				c.JSON(http.StatusOK, gin.H{
+					"message": "reactivated",
+					"config":  config,
+				})
+			})
+
+			configs.PATCH("/:uuid/rename", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				var req struct {
+					Name string `json:"name"`
+				}
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+
+				config, err := configService.RenameNoAuth(uuid, req.Name)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusOK, config)
+			})
+
+			configs.POST("/:uuid/clone", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				var req struct {
+					Name string `json:"name"`
+				}
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+
+				config, err := configService.CloneNoAuth(uuid, req.Name, dbUsername)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusCreated, config)
+			})
+
+			configs.POST("/:uuid/refresh-prices", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				config, err := configService.RefreshPricesNoAuth(uuid)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+				c.JSON(http.StatusOK, config)
+			})
+
+			configs.GET("/:uuid/versions", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+
+				limit, err := strconv.Atoi(c.DefaultQuery("limit", "20"))
+				if err != nil || limit <= 0 {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid limit"})
+					return
+				}
+				offset, err := strconv.Atoi(c.DefaultQuery("offset", "0"))
+				if err != nil || offset < 0 {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid offset"})
+					return
+				}
+
+				versions, err := configService.ListVersions(uuid, limit, offset)
+				if err != nil {
+					switch {
+					case errors.Is(err, services.ErrConfigNotFound):
+						c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
+					case errors.Is(err, services.ErrInvalidVersionNumber):
+						c.JSON(http.StatusBadRequest, gin.H{"error": "invalid paging params"})
+					default:
+						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					}
+					return
+				}
+
+				c.JSON(http.StatusOK, gin.H{
+					"versions": versions,
+					"limit":    limit,
+					"offset":   offset,
+				})
+			})
+
+			configs.GET("/:uuid/versions/:version", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				versionNo, err := strconv.Atoi(c.Param("version"))
+				if err != nil || versionNo <= 0 {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid version number"})
+					return
+				}
+
+				version, err := configService.GetVersion(uuid, versionNo)
+				if err != nil {
+					switch {
+					case errors.Is(err, services.ErrInvalidVersionNumber):
+						c.JSON(http.StatusBadRequest, gin.H{"error": "invalid version number"})
+					case errors.Is(err, services.ErrConfigVersionNotFound):
+						c.JSON(http.StatusNotFound, gin.H{"error": "version not found"})
+					default:
+						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					}
+					return
+				}
+
+				c.JSON(http.StatusOK, version)
+			})
+
+			configs.POST("/:uuid/rollback", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				var req struct {
+					TargetVersion int    `json:"target_version"`
+					Note          string `json:"note"`
+				}
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+				if req.TargetVersion <= 0 {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid target_version"})
+					return
+				}
+
+				config, err := configService.RollbackToVersionWithNote(uuid, req.TargetVersion, dbUsername, req.Note)
+				if err != nil {
+					switch {
+					case errors.Is(err, services.ErrInvalidVersionNumber):
+						c.JSON(http.StatusBadRequest, gin.H{"error": "invalid target_version"})
+					case errors.Is(err, services.ErrConfigNotFound), errors.Is(err, services.ErrConfigVersionNotFound):
+						c.JSON(http.StatusNotFound, gin.H{"error": "version not found"})
+					case errors.Is(err, services.ErrVersionConflict):
+						c.JSON(http.StatusConflict, gin.H{"error": "version conflict"})
+					default:
+						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					}
+					return
+				}
+
+				currentVersion, err := configService.GetCurrentVersion(uuid)
+				if err != nil {
+					c.JSON(http.StatusOK, gin.H{
+						"message": "rollback applied",
+						"config":  config,
+					})
+					return
+				}
+
+				c.JSON(http.StatusOK, gin.H{
+					"message":         "rollback applied",
+					"config":          config,
+					"current_version": currentVersion,
+				})
+			})
+		}
+
+		// Pricing admin (public - RBAC disabled)
+		pricingAdmin := api.Group("/admin/pricing")
+		{
+			pricingAdmin.GET("/stats", pricingHandler.GetStats)
+			pricingAdmin.GET("/components", pricingHandler.ListComponents)
+			pricingAdmin.GET("/components/:lot_name", pricingHandler.GetComponentPricing)
+			pricingAdmin.POST("/update", pricingHandler.UpdatePrice)
+			pricingAdmin.POST("/preview", pricingHandler.PreviewPrice)
+			pricingAdmin.POST("/recalculate-all", pricingHandler.RecalculateAll)
+
+			pricingAdmin.GET("/alerts", pricingHandler.ListAlerts)
+			pricingAdmin.POST("/alerts/:id/acknowledge", pricingHandler.AcknowledgeAlert)
+			pricingAdmin.POST("/alerts/:id/resolve", pricingHandler.ResolveAlert)
+			pricingAdmin.POST("/alerts/:id/ignore", pricingHandler.IgnoreAlert)
+		}
+
+		// Sync API (for offline mode)
+		syncAPI := api.Group("/sync")
+		{
+			syncAPI.GET("/status", syncHandler.GetStatus)
+			syncAPI.GET("/info", syncHandler.GetInfo)
+			syncAPI.POST("/components", syncHandler.SyncComponents)
+			syncAPI.POST("/pricelists", syncHandler.SyncPricelists)
+			syncAPI.POST("/all", syncHandler.SyncAll)
+			syncAPI.POST("/push", syncHandler.PushPendingChanges)
+			syncAPI.GET("/pending/count", syncHandler.GetPendingCount)
+			syncAPI.GET("/pending", syncHandler.GetPendingChanges)
+		}
+	}
+
+	return router, syncService, nil
+}
+
+// restartProcess restarts the current process with the same arguments
+func restartProcess() {
+	executable, err := os.Executable()
+	if err != nil {
+		slog.Error("failed to get executable path", "error", err)
+		os.Exit(1)
+	}
+
+	args := os.Args
+	env := os.Environ()
+
+	slog.Info("executing restart", "executable", executable, "args", args)
+
+	err = syscall.Exec(executable, args, env)
+	if err != nil {
+		slog.Error("failed to restart process", "error", err)
+		os.Exit(1)
+	}
+}
+
+func openBrowser(url string) error {
+	var cmd string
+	var args []string
+
+	switch runtime.GOOS {
+	case "windows":
+		cmd = "cmd"
+		args = []string{"/c", "start", url}
+	case "darwin":
+		cmd = "open"
+		args = []string{url}
+	default: // "linux", "freebsd", "openbsd", "netbsd"
+		cmd = "xdg-open"
+		args = []string{url}
+	}
+
+	return exec.Command(cmd, args...).Start()
+}
+
+func requestLogger() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		path := c.Request.URL.Path
+		query := c.Request.URL.RawQuery
+
+		c.Next()
+
+		latency := time.Since(start)
+		status := c.Writer.Status()
+
+		slog.Info("request",
+			"method", c.Request.Method,
+			"path", path,
+			"query", query,
+			"status", status,
+			"latency", latency,
+			"ip", c.ClientIP(),
+		)
+	}
+}

cmd/qfs/versioning_api_test.go

@@ -0,0 +1,173 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/services"
+	syncsvc "git.mchus.pro/mchus/quoteforge/internal/services/sync"
+)
+
+func TestConfigurationVersioningAPI(t *testing.T) {
+	moveToRepoRoot(t)
+
+	local, connMgr, configService := newAPITestStack(t)
+	_ = local
+
+	created, err := configService.Create("tester", &services.CreateConfigRequest{
+		Name:        "api-v1",
+		Items:       models.ConfigItems{{LotName: "CPU_API", Quantity: 1, UnitPrice: 1000}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+	if _, err := configService.RenameNoAuth(created.UUID, "api-v2"); err != nil {
+		t.Fatalf("rename config: %v", err)
+	}
+
+	cfg := &config.Config{}
+	setConfigDefaults(cfg)
+	router, _, err := setupRouter(cfg, local, connMgr, nil, "tester", nil)
+	if err != nil {
+		t.Fatalf("setup router: %v", err)
+	}
+
+	// list versions happy path
+	listReq := httptest.NewRequest(http.MethodGet, "/api/configs/"+created.UUID+"/versions?limit=10&offset=0", nil)
+	listRec := httptest.NewRecorder()
+	router.ServeHTTP(listRec, listReq)
+	if listRec.Code != http.StatusOK {
+		t.Fatalf("list versions status=%d body=%s", listRec.Code, listRec.Body.String())
+	}
+
+	// get version happy path
+	getReq := httptest.NewRequest(http.MethodGet, "/api/configs/"+created.UUID+"/versions/1", nil)
+	getRec := httptest.NewRecorder()
+	router.ServeHTTP(getRec, getReq)
+	if getRec.Code != http.StatusOK {
+		t.Fatalf("get version status=%d body=%s", getRec.Code, getRec.Body.String())
+	}
+
+	// rollback happy path
+	body := []byte(`{"target_version":1,"note":"api rollback"}`)
+	rbReq := httptest.NewRequest(http.MethodPost, "/api/configs/"+created.UUID+"/rollback", bytes.NewReader(body))
+	rbReq.Header.Set("Content-Type", "application/json")
+	rbRec := httptest.NewRecorder()
+	router.ServeHTTP(rbRec, rbReq)
+	if rbRec.Code != http.StatusOK {
+		t.Fatalf("rollback status=%d body=%s", rbRec.Code, rbRec.Body.String())
+	}
+
+	var rbResp struct {
+		Message        string `json:"message"`
+		CurrentVersion struct {
+			VersionNo int `json:"version_no"`
+		} `json:"current_version"`
+	}
+	if err := json.Unmarshal(rbRec.Body.Bytes(), &rbResp); err != nil {
+		t.Fatalf("unmarshal rollback response: %v", err)
+	}
+	if rbResp.Message == "" || rbResp.CurrentVersion.VersionNo != 3 {
+		t.Fatalf("unexpected rollback response: %+v", rbResp)
+	}
+
+	// 404: version missing
+	notFoundReq := httptest.NewRequest(http.MethodGet, "/api/configs/"+created.UUID+"/versions/999", nil)
+	notFoundRec := httptest.NewRecorder()
+	router.ServeHTTP(notFoundRec, notFoundReq)
+	if notFoundRec.Code != http.StatusNotFound {
+		t.Fatalf("expected 404 for missing version, got %d", notFoundRec.Code)
+	}
+
+	// 400: invalid version number
+	invalidReq := httptest.NewRequest(http.MethodGet, "/api/configs/"+created.UUID+"/versions/abc", nil)
+	invalidRec := httptest.NewRecorder()
+	router.ServeHTTP(invalidRec, invalidReq)
+	if invalidRec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400 for invalid version, got %d", invalidRec.Code)
+	}
+
+	// 400: rollback invalid target_version
+	badRollbackReq := httptest.NewRequest(http.MethodPost, "/api/configs/"+created.UUID+"/rollback", bytes.NewReader([]byte(`{"target_version":0}`)))
+	badRollbackReq.Header.Set("Content-Type", "application/json")
+	badRollbackRec := httptest.NewRecorder()
+	router.ServeHTTP(badRollbackRec, badRollbackReq)
+	if badRollbackRec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400 for invalid rollback target, got %d", badRollbackRec.Code)
+	}
+
+	// archive + reactivate flow
+	delReq := httptest.NewRequest(http.MethodDelete, "/api/configs/"+created.UUID, nil)
+	delRec := httptest.NewRecorder()
+	router.ServeHTTP(delRec, delReq)
+	if delRec.Code != http.StatusOK {
+		t.Fatalf("archive status=%d body=%s", delRec.Code, delRec.Body.String())
+	}
+
+	archivedListReq := httptest.NewRequest(http.MethodGet, "/api/configs?status=archived&page=1&per_page=20", nil)
+	archivedListRec := httptest.NewRecorder()
+	router.ServeHTTP(archivedListRec, archivedListReq)
+	if archivedListRec.Code != http.StatusOK {
+		t.Fatalf("archived list status=%d body=%s", archivedListRec.Code, archivedListRec.Body.String())
+	}
+
+	reactivateReq := httptest.NewRequest(http.MethodPost, "/api/configs/"+created.UUID+"/reactivate", nil)
+	reactivateRec := httptest.NewRecorder()
+	router.ServeHTTP(reactivateRec, reactivateReq)
+	if reactivateRec.Code != http.StatusOK {
+		t.Fatalf("reactivate status=%d body=%s", reactivateRec.Code, reactivateRec.Body.String())
+	}
+
+	activeListReq := httptest.NewRequest(http.MethodGet, "/api/configs?status=active&page=1&per_page=20", nil)
+	activeListRec := httptest.NewRecorder()
+	router.ServeHTTP(activeListRec, activeListReq)
+	if activeListRec.Code != http.StatusOK {
+		t.Fatalf("active list status=%d body=%s", activeListRec.Code, activeListRec.Body.String())
+	}
+}
+
+func newAPITestStack(t *testing.T) (*localdb.LocalDB, *db.ConnectionManager, *services.LocalConfigurationService) {
+	t.Helper()
+
+	localPath := filepath.Join(t.TempDir(), "api.db")
+	local, err := localdb.New(localPath)
+	if err != nil {
+		t.Fatalf("init local db: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	connMgr := db.NewConnectionManager(local)
+	syncService := syncsvc.NewService(connMgr, local)
+	configService := services.NewLocalConfigurationService(
+		local,
+		syncService,
+		&services.QuoteService{},
+		func() bool { return false },
+	)
+	return local, connMgr, configService
+}
+
+func moveToRepoRoot(t *testing.T) {
+	t.Helper()
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("getwd: %v", err)
+	}
+	root := filepath.Clean(filepath.Join(wd, "..", ".."))
+	if err := os.Chdir(root); err != nil {
+		t.Fatalf("chdir repo root: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = os.Chdir(wd)
+	})
+}

cmd/server/main.go

@@ -1,643 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log/slog"
-	"net/http"
-	"os"
-	"os/signal"
-	"strconv"
-	"syscall"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"git.mchus.pro/mchus/quoteforge/internal/config"
-	"git.mchus.pro/mchus/quoteforge/internal/handlers"
-	"git.mchus.pro/mchus/quoteforge/internal/localdb"
-	"git.mchus.pro/mchus/quoteforge/internal/middleware"
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-	"git.mchus.pro/mchus/quoteforge/internal/services"
-	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
-	"git.mchus.pro/mchus/quoteforge/internal/services/pricelist"
-	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
-	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
-	"gorm.io/driver/mysql"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
-)
-
-const (
-	localDBPath = "./data/settings.db"
-)
-
-func main() {
-	configPath := flag.String("config", "config.yaml", "path to config file (optional, for server settings)")
-	migrate := flag.Bool("migrate", false, "run database migrations")
-	flag.Parse()
-
-	// Initialize local SQLite database (always used)
-	local, err := localdb.New(localDBPath)
-	if err != nil {
-		slog.Error("failed to initialize local database", "error", err)
-		os.Exit(1)
-	}
-
-	// Check if running in setup mode (no connection settings)
-	if !local.HasSettings() {
-		slog.Info("no database settings found, starting setup mode")
-		runSetupMode(local)
-		return
-	}
-
-	// Load config for server settings (optional)
-	cfg, err := config.Load(*configPath)
-	if err != nil {
-		// Use defaults if config file doesn't exist
-		slog.Info("config file not found, using defaults", "path", *configPath)
-		cfg = &config.Config{}
-	}
-	setConfigDefaults(cfg)
-
-	setupLogger(cfg.Logging)
-
-	// Get DSN from local SQLite
-	dsn, err := local.GetDSN()
-	if err != nil {
-		slog.Error("failed to get database settings", "error", err)
-		os.Exit(1)
-	}
-
-	// Connect to MariaDB
-	db, err := setupDatabaseFromDSN(dsn)
-	if err != nil {
-		slog.Error("failed to connect to database", "error", err)
-		slog.Info("you may need to reconfigure connection at /setup")
-		os.Exit(1)
-	}
-
-	dbUser := local.GetDBUser()
-
-	// Ensure DB user exists in qt_users table (for foreign key constraint)
-	dbUserID, err := models.EnsureDBUser(db, dbUser)
-	if err != nil {
-		slog.Error("failed to ensure DB user exists", "error", err)
-		os.Exit(1)
-	}
-
-	slog.Info("starting QuoteForge server",
-		"host", cfg.Server.Host,
-		"port", cfg.Server.Port,
-		"db_user", dbUser,
-		"db_user_id", dbUserID,
-	)
-
-	if *migrate {
-		slog.Info("running database migrations...")
-		if err := models.Migrate(db); err != nil {
-			slog.Error("migration failed", "error", err)
-			os.Exit(1)
-		}
-		if err := models.SeedCategories(db); err != nil {
-			slog.Error("seeding categories failed", "error", err)
-			os.Exit(1)
-		}
-		slog.Info("migrations completed")
-	}
-
-	gin.SetMode(cfg.Server.Mode)
-	router, syncService, err := setupRouter(db, cfg, local, dbUserID)
-	if err != nil {
-		slog.Error("failed to setup router", "error", err)
-		os.Exit(1)
-	}
-
-	// Start background sync worker
-	workerCtx, workerCancel := context.WithCancel(context.Background())
-	defer workerCancel()
-
-	syncWorker := sync.NewWorker(syncService, db, 5*time.Minute)
-	go syncWorker.Start(workerCtx)
-
-	srv := &http.Server{
-		Addr:         cfg.Address(),
-		Handler:      router,
-		ReadTimeout:  cfg.Server.ReadTimeout,
-		WriteTimeout: cfg.Server.WriteTimeout,
-	}
-
-	go func() {
-		slog.Info("server listening", "address", cfg.Address())
-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			slog.Error("server error", "error", err)
-			os.Exit(1)
-		}
-	}()
-
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-	<-quit
-
-	slog.Info("shutting down server...")
-
-	// Stop background sync worker first
-	syncWorker.Stop()
-	workerCancel()
-
-	// Then shutdown HTTP server
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
-	if err := srv.Shutdown(ctx); err != nil {
-		slog.Error("server forced to shutdown", "error", err)
-	}
-
-	slog.Info("server stopped")
-}
-
-func setConfigDefaults(cfg *config.Config) {
-	if cfg.Server.Host == "" {
-		cfg.Server.Host = "0.0.0.0"
-	}
-	if cfg.Server.Port == 0 {
-		cfg.Server.Port = 8080
-	}
-	if cfg.Server.Mode == "" {
-		cfg.Server.Mode = "release"
-	}
-	if cfg.Server.ReadTimeout == 0 {
-		cfg.Server.ReadTimeout = 30 * time.Second
-	}
-	if cfg.Server.WriteTimeout == 0 {
-		cfg.Server.WriteTimeout = 30 * time.Second
-	}
-	if cfg.Pricing.DefaultMethod == "" {
-		cfg.Pricing.DefaultMethod = "weighted_median"
-	}
-	if cfg.Pricing.DefaultPeriodDays == 0 {
-		cfg.Pricing.DefaultPeriodDays = 90
-	}
-	if cfg.Pricing.FreshnessGreenDays == 0 {
-		cfg.Pricing.FreshnessGreenDays = 30
-	}
-	if cfg.Pricing.FreshnessYellowDays == 0 {
-		cfg.Pricing.FreshnessYellowDays = 60
-	}
-	if cfg.Pricing.FreshnessRedDays == 0 {
-		cfg.Pricing.FreshnessRedDays = 90
-	}
-	if cfg.Pricing.MinQuotesForMedian == 0 {
-		cfg.Pricing.MinQuotesForMedian = 3
-	}
-}
-
-// runSetupMode starts a minimal server that only serves the setup page
-func runSetupMode(local *localdb.LocalDB) {
-	setupHandler, err := handlers.NewSetupHandler(local, "web/templates")
-	if err != nil {
-		slog.Error("failed to create setup handler", "error", err)
-		os.Exit(1)
-	}
-
-	gin.SetMode(gin.ReleaseMode)
-	router := gin.New()
-	router.Use(gin.Recovery())
-
-	router.Static("/static", "web/static")
-
-	// Setup routes only
-	router.GET("/", func(c *gin.Context) {
-		c.Redirect(http.StatusFound, "/setup")
-	})
-	router.GET("/setup", setupHandler.ShowSetup)
-	router.POST("/setup", setupHandler.SaveConnection)
-	router.POST("/setup/test", setupHandler.TestConnection)
-	router.GET("/setup/status", setupHandler.GetStatus)
-
-	// Health check
-	router.GET("/health", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"status": "setup_required",
-			"time":   time.Now().UTC().Format(time.RFC3339),
-		})
-	})
-
-	addr := ":8080"
-	slog.Info("starting setup mode server", "address", addr)
-	slog.Info("open http://localhost:8080/setup to configure database connection")
-
-	srv := &http.Server{
-		Addr:    addr,
-		Handler: router,
-	}
-
-	go func() {
-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			slog.Error("server error", "error", err)
-			os.Exit(1)
-		}
-	}()
-
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-	<-quit
-
-	slog.Info("setup mode server stopped")
-}
-
-func setupLogger(cfg config.LoggingConfig) {
-	var level slog.Level
-	switch cfg.Level {
-	case "debug":
-		level = slog.LevelDebug
-	case "warn":
-		level = slog.LevelWarn
-	case "error":
-		level = slog.LevelError
-	default:
-		level = slog.LevelInfo
-	}
-
-	opts := &slog.HandlerOptions{Level: level}
-
-	var handler slog.Handler
-	if cfg.Format == "json" {
-		handler = slog.NewJSONHandler(os.Stdout, opts)
-	} else {
-		handler = slog.NewTextHandler(os.Stdout, opts)
-	}
-
-	slog.SetDefault(slog.New(handler))
-}
-
-func setupDatabaseFromDSN(dsn string) (*gorm.DB, error) {
-	gormLogger := logger.Default.LogMode(logger.Silent)
-
-	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
-		Logger: gormLogger,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	sqlDB, err := db.DB()
-	if err != nil {
-		return nil, err
-	}
-
-	sqlDB.SetMaxOpenConns(25)
-	sqlDB.SetMaxIdleConns(5)
-	sqlDB.SetConnMaxLifetime(5 * time.Minute)
-
-	return db, nil
-}
-
-func setupRouter(db *gorm.DB, cfg *config.Config, local *localdb.LocalDB, dbUserID uint) (*gin.Engine, *sync.Service, error) {
-	// Repositories
-	componentRepo := repository.NewComponentRepository(db)
-	categoryRepo := repository.NewCategoryRepository(db)
-	priceRepo := repository.NewPriceRepository(db)
-	alertRepo := repository.NewAlertRepository(db)
-	statsRepo := repository.NewStatsRepository(db)
-	pricelistRepo := repository.NewPricelistRepository(db)
-	configRepo := repository.NewConfigurationRepository(db)
-
-	// Services
-	pricingService := pricing.NewService(componentRepo, priceRepo, cfg.Pricing)
-	componentService := services.NewComponentService(componentRepo, categoryRepo, statsRepo)
-	quoteService := services.NewQuoteService(componentRepo, statsRepo, pricingService)
-	exportService := services.NewExportService(cfg.Export, categoryRepo)
-	alertService := alerts.NewService(alertRepo, componentRepo, priceRepo, statsRepo, cfg.Alerts, cfg.Pricing)
-	pricelistService := pricelist.NewService(db, pricelistRepo, componentRepo)
-	syncService := sync.NewService(pricelistRepo, configRepo, local)
-
-	// isOnline function for local-first architecture
-	isOnline := func() bool {
-		sqlDB, err := db.DB()
-		if err != nil {
-			return false
-		}
-		return sqlDB.Ping() == nil
-	}
-
-	// Local-first configuration service (replaces old ConfigurationService)
-	configService := services.NewLocalConfigurationService(local, syncService, quoteService, isOnline)
-
-	// Handlers
-	componentHandler := handlers.NewComponentHandler(componentService)
-	quoteHandler := handlers.NewQuoteHandler(quoteService)
-	exportHandler := handlers.NewExportHandler(exportService, configService, componentService)
-	pricingHandler := handlers.NewPricingHandler(db, pricingService, alertService, componentRepo, priceRepo, statsRepo)
-	pricelistHandler := handlers.NewPricelistHandler(pricelistService, local)
-	syncHandler, err := handlers.NewSyncHandler(local, syncService, db, "web/templates")
-	if err != nil {
-		return nil, nil, fmt.Errorf("creating sync handler: %w", err)
-	}
-
-	// Setup handler (for reconfiguration)
-	setupHandler, err := handlers.NewSetupHandler(local, "web/templates")
-	if err != nil {
-		return nil, nil, fmt.Errorf("creating setup handler: %w", err)
-	}
-
-	// Web handler (templates)
-	webHandler, err := handlers.NewWebHandler("web/templates", componentService)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// Router
-	router := gin.New()
-	router.Use(gin.Recovery())
-	router.Use(requestLogger())
-	router.Use(middleware.CORS())
-	router.Use(middleware.OfflineDetector(db, local))
-
-	// Static files
-	router.Static("/static", "web/static")
-
-	// Health check
-	router.GET("/health", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"status": "ok",
-			"time":   time.Now().UTC().Format(time.RFC3339),
-		})
-	})
-
-	// DB status endpoint
-	router.GET("/api/db-status", func(c *gin.Context) {
-		var lotCount, lotLogCount, metadataCount int64
-		var dbOK bool = true
-		var dbError string
-
-		sqlDB, err := db.DB()
-		if err != nil {
-			dbOK = false
-			dbError = err.Error()
-		} else if err := sqlDB.Ping(); err != nil {
-			dbOK = false
-			dbError = err.Error()
-		}
-
-		db.Table("lot").Count(&lotCount)
-		db.Table("lot_log").Count(&lotLogCount)
-		db.Table("qt_lot_metadata").Count(&metadataCount)
-
-		c.JSON(http.StatusOK, gin.H{
-			"connected":      dbOK,
-			"error":          dbError,
-			"lot_count":      lotCount,
-			"lot_log_count":  lotLogCount,
-			"metadata_count": metadataCount,
-			"db_user":        local.GetDBUser(),
-		})
-	})
-
-	// Current user info (DB user, not app user)
-	router.GET("/api/current-user", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"username": local.GetDBUser(),
-			"role":     "db_user",
-		})
-	})
-
-	// Setup routes (for reconfiguration)
-	router.GET("/setup", setupHandler.ShowSetup)
-	router.POST("/setup", setupHandler.SaveConnection)
-	router.POST("/setup/test", setupHandler.TestConnection)
-	router.GET("/setup/status", setupHandler.GetStatus)
-
-	// Web pages
-	router.GET("/", webHandler.Index)
-	router.GET("/configs", webHandler.Configs)
-	router.GET("/configurator", webHandler.Configurator)
-	router.GET("/pricelists", webHandler.Pricelists)
-	router.GET("/pricelists/:id", webHandler.PricelistDetail)
-	router.GET("/admin/pricing", webHandler.AdminPricing)
-
-	// htmx partials
-	partials := router.Group("/partials")
-	{
-		partials.GET("/components", webHandler.ComponentsPartial)
-		partials.GET("/sync-status", syncHandler.SyncStatusPartial)
-	}
-
-	// API routes
-	api := router.Group("/api")
-	{
-		api.GET("/ping", func(c *gin.Context) {
-			c.JSON(http.StatusOK, gin.H{"message": "pong"})
-		})
-
-		// Components (public read)
-		components := api.Group("/components")
-		{
-			components.GET("", componentHandler.List)
-			components.GET("/:lot_name", componentHandler.Get)
-		}
-
-		// Categories (public)
-		api.GET("/categories", componentHandler.GetCategories)
-
-		// Quote (public)
-		quote := api.Group("/quote")
-		{
-			quote.POST("/validate", quoteHandler.Validate)
-			quote.POST("/calculate", quoteHandler.Calculate)
-		}
-
-		// Export (public)
-		export := api.Group("/export")
-		{
-			export.POST("/csv", exportHandler.ExportCSV)
-		}
-
-		// Pricelists (public - RBAC disabled in Phase 1-3)
-		pricelists := api.Group("/pricelists")
-		{
-			pricelists.GET("", pricelistHandler.List)
-			pricelists.GET("/can-write", pricelistHandler.CanWrite)
-			pricelists.GET("/latest", pricelistHandler.GetLatest)
-			pricelists.GET("/:id", pricelistHandler.Get)
-			pricelists.GET("/:id/items", pricelistHandler.GetItems)
-			pricelists.POST("", pricelistHandler.Create)
-			pricelists.DELETE("/:id", pricelistHandler.Delete)
-		}
-
-		// Configurations (public - RBAC disabled)
-		configs := api.Group("/configs")
-		{
-			configs.GET("", func(c *gin.Context) {
-				page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
-				perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
-
-				cfgs, total, err := configService.ListAll(page, perPage)
-				if err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-					return
-				}
-
-				c.JSON(http.StatusOK, gin.H{
-					"configurations": cfgs,
-					"total":          total,
-					"page":           page,
-					"per_page":       perPage,
-				})
-			})
-
-			configs.POST("", func(c *gin.Context) {
-				var req services.CreateConfigRequest
-				if err := c.ShouldBindJSON(&req); err != nil {
-					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-					return
-				}
-
-				config, err := configService.Create(dbUserID, &req) // use DB user ID
-				if err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-					return
-				}
-
-				c.JSON(http.StatusCreated, config)
-			})
-
-			configs.GET("/:uuid", func(c *gin.Context) {
-				uuid := c.Param("uuid")
-				config, err := configService.GetByUUIDNoAuth(uuid)
-				if err != nil {
-					c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
-					return
-				}
-				c.JSON(http.StatusOK, config)
-			})
-
-			configs.PUT("/:uuid", func(c *gin.Context) {
-				uuid := c.Param("uuid")
-				var req services.CreateConfigRequest
-				if err := c.ShouldBindJSON(&req); err != nil {
-					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-					return
-				}
-
-				config, err := configService.UpdateNoAuth(uuid, &req)
-				if err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-					return
-				}
-
-				c.JSON(http.StatusOK, config)
-			})
-
-			configs.DELETE("/:uuid", func(c *gin.Context) {
-				uuid := c.Param("uuid")
-				if err := configService.DeleteNoAuth(uuid); err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-					return
-				}
-				c.JSON(http.StatusOK, gin.H{"message": "deleted"})
-			})
-
-			configs.PATCH("/:uuid/rename", func(c *gin.Context) {
-				uuid := c.Param("uuid")
-				var req struct {
-					Name string `json:"name"`
-				}
-				if err := c.ShouldBindJSON(&req); err != nil {
-					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-					return
-				}
-
-				config, err := configService.RenameNoAuth(uuid, req.Name)
-				if err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-					return
-				}
-
-				c.JSON(http.StatusOK, config)
-			})
-
-			configs.POST("/:uuid/clone", func(c *gin.Context) {
-				uuid := c.Param("uuid")
-				var req struct {
-					Name string `json:"name"`
-				}
-				if err := c.ShouldBindJSON(&req); err != nil {
-					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-					return
-				}
-
-				config, err := configService.CloneNoAuth(uuid, req.Name, dbUserID)
-				if err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-					return
-				}
-
-				c.JSON(http.StatusCreated, config)
-			})
-
-			configs.POST("/:uuid/refresh-prices", func(c *gin.Context) {
-				uuid := c.Param("uuid")
-				config, err := configService.RefreshPricesNoAuth(uuid)
-				if err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-					return
-				}
-				c.JSON(http.StatusOK, config)
-			})
-		}
-
-		// Pricing admin (public - RBAC disabled)
-		pricingAdmin := api.Group("/admin/pricing")
-		{
-			pricingAdmin.GET("/stats", pricingHandler.GetStats)
-			pricingAdmin.GET("/components", pricingHandler.ListComponents)
-			pricingAdmin.GET("/components/:lot_name", pricingHandler.GetComponentPricing)
-			pricingAdmin.POST("/update", pricingHandler.UpdatePrice)
-			pricingAdmin.POST("/preview", pricingHandler.PreviewPrice)
-			pricingAdmin.POST("/recalculate-all", pricingHandler.RecalculateAll)
-
-			pricingAdmin.GET("/alerts", pricingHandler.ListAlerts)
-			pricingAdmin.POST("/alerts/:id/acknowledge", pricingHandler.AcknowledgeAlert)
-			pricingAdmin.POST("/alerts/:id/resolve", pricingHandler.ResolveAlert)
-			pricingAdmin.POST("/alerts/:id/ignore", pricingHandler.IgnoreAlert)
-		}
-
-		// Sync API (for offline mode)
-		syncAPI := api.Group("/sync")
-		{
-			syncAPI.GET("/status", syncHandler.GetStatus)
-			syncAPI.POST("/components", syncHandler.SyncComponents)
-			syncAPI.POST("/pricelists", syncHandler.SyncPricelists)
-			syncAPI.POST("/all", syncHandler.SyncAll)
-			syncAPI.POST("/push", syncHandler.PushPendingChanges)
-			syncAPI.GET("/pending/count", syncHandler.GetPendingCount)
-			syncAPI.GET("/pending", syncHandler.GetPendingChanges)
-		}
-	}
-
-	return router, syncService, nil
-}
-
-func requestLogger() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		start := time.Now()
-		path := c.Request.URL.Path
-		query := c.Request.URL.RawQuery
-
-		c.Next()
-
-		latency := time.Since(start)
-		status := c.Writer.Status()
-
-		slog.Info("request",
-			"method", c.Request.Method,
-			"path", path,
-			"query", query,
-			"status", status,
-			"latency", latency,
-			"ip", c.ClientIP(),
-		)
-	}
-}

config.example.yaml

@@ -2,7 +2,7 @@
 # Copy this file to config.yaml and update values
 
 server:
-  host: "0.0.0.0"
+  host: "127.0.0.1"  # Use 0.0.0.0 to listen on all interfaces
   port: 8080
   mode: "release"  # debug | release
   read_timeout: "30s"

internal/appmeta/version.go

@@ -0,0 +1,26 @@
+package appmeta
+
+import "sync/atomic"
+
+var appVersion atomic.Value
+
+func init() {
+	appVersion.Store("dev")
+}
+
+// SetVersion configures the running application version string.
+func SetVersion(v string) {
+	if v == "" {
+		v = "dev"
+	}
+	appVersion.Store(v)
+}
+
+// Version returns the running application version string.
+func Version() string {
+	if v, ok := appVersion.Load().(string); ok && v != "" {
+		return v
+	}
+	return "dev"
+}
+

internal/appstate/path.go

@@ -0,0 +1,197 @@
+package appstate
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+)
+
+const (
+	appDirName  = "QuoteForge"
+	defaultDB   = "qfs.db"
+	defaultCfg  = "config.yaml"
+	envDBPath   = "QFS_DB_PATH"
+	envStateDir = "QFS_STATE_DIR"
+	envCfgPath  = "QFS_CONFIG_PATH"
+)
+
+// ResolveDBPath returns the local SQLite path using priority:
+// explicit CLI path > QFS_DB_PATH > OS-specific user state directory.
+func ResolveDBPath(explicitPath string) (string, error) {
+	if explicitPath != "" {
+		return filepath.Clean(explicitPath), nil
+	}
+
+	if fromEnv := os.Getenv(envDBPath); fromEnv != "" {
+		return filepath.Clean(fromEnv), nil
+	}
+
+	dir, err := defaultStateDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(dir, defaultDB), nil
+}
+
+// ResolveConfigPath returns the config path using priority:
+// explicit CLI path > QFS_CONFIG_PATH > OS-specific user state directory.
+func ResolveConfigPath(explicitPath string) (string, error) {
+	if explicitPath != "" {
+		return filepath.Clean(explicitPath), nil
+	}
+
+	if fromEnv := os.Getenv(envCfgPath); fromEnv != "" {
+		return filepath.Clean(fromEnv), nil
+	}
+
+	dir, err := defaultStateDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(dir, defaultCfg), nil
+}
+
+// MigrateLegacyDB copies an existing legacy DB (and optional SQLite sidecars)
+// to targetPath if targetPath does not already exist.
+// Returns source path if migration happened.
+func MigrateLegacyDB(targetPath string, legacyPaths []string) (string, error) {
+	if targetPath == "" {
+		return "", nil
+	}
+
+	if exists(targetPath) {
+		return "", nil
+	}
+
+	if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+		return "", fmt.Errorf("creating target db directory: %w", err)
+	}
+
+	for _, src := range legacyPaths {
+		if src == "" {
+			continue
+		}
+		src = filepath.Clean(src)
+		if src == targetPath || !exists(src) {
+			continue
+		}
+
+		if err := copyFile(src, targetPath); err != nil {
+			return "", fmt.Errorf("migrating legacy db from %s: %w", src, err)
+		}
+
+		// Optional SQLite sidecar files.
+		_ = copyIfExists(src+"-wal", targetPath+"-wal")
+		_ = copyIfExists(src+"-shm", targetPath+"-shm")
+
+		return src, nil
+	}
+
+	return "", nil
+}
+
+// MigrateLegacyFile copies an existing legacy file to targetPath
+// if targetPath does not already exist.
+func MigrateLegacyFile(targetPath string, legacyPaths []string) (string, error) {
+	if targetPath == "" {
+		return "", nil
+	}
+
+	if exists(targetPath) {
+		return "", nil
+	}
+
+	if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+		return "", fmt.Errorf("creating target directory: %w", err)
+	}
+
+	for _, src := range legacyPaths {
+		if src == "" {
+			continue
+		}
+		src = filepath.Clean(src)
+		if src == targetPath || !exists(src) {
+			continue
+		}
+		if err := copyFile(src, targetPath); err != nil {
+			return "", fmt.Errorf("migrating legacy file from %s: %w", src, err)
+		}
+		return src, nil
+	}
+
+	return "", nil
+}
+
+func defaultStateDir() (string, error) {
+	if override := os.Getenv(envStateDir); override != "" {
+		return filepath.Clean(override), nil
+	}
+
+	switch runtime.GOOS {
+	case "darwin":
+		base, err := os.UserConfigDir() // ~/Library/Application Support
+		if err != nil {
+			return "", fmt.Errorf("resolving user config dir: %w", err)
+		}
+		return filepath.Join(base, appDirName), nil
+	case "windows":
+		if local := os.Getenv("LOCALAPPDATA"); local != "" {
+			return filepath.Join(local, appDirName), nil
+		}
+		base, err := os.UserConfigDir()
+		if err != nil {
+			return "", fmt.Errorf("resolving user config dir: %w", err)
+		}
+		return filepath.Join(base, appDirName), nil
+	default:
+		if xdgState := os.Getenv("XDG_STATE_HOME"); xdgState != "" {
+			return filepath.Join(xdgState, "quoteforge"), nil
+		}
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", fmt.Errorf("resolving user home dir: %w", err)
+		}
+		return filepath.Join(home, ".local", "state", "quoteforge"), nil
+	}
+}
+
+func exists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+func copyIfExists(src, dst string) error {
+	if !exists(src) {
+		return nil
+	}
+	return copyFile(src, dst)
+}
+
+func copyFile(src, dst string) error {
+	in, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer in.Close()
+
+	info, err := in.Stat()
+	if err != nil {
+		return err
+	}
+
+	out, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, info.Mode().Perm())
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	if _, err := io.Copy(out, in); err != nil {
+		return err
+	}
+
+	return out.Sync()
+}

internal/config/config.go

@@ -106,7 +106,7 @@ func Load(path string) (*Config, error) {
 
 func (c *Config) setDefaults() {
 	if c.Server.Host == "" {
-		c.Server.Host = "0.0.0.0"
+		c.Server.Host = "127.0.0.1"
 	}
 	if c.Server.Port == 0 {
 		c.Server.Port = 8080

internal/db/connection.go

@@ -0,0 +1,334 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+const (
+	defaultConnectTimeout    = 5 * time.Second
+	defaultPingInterval      = 30 * time.Second
+	defaultReconnectCooldown = 10 * time.Second
+
+	maxOpenConns    = 10
+	maxIdleConns    = 2
+	connMaxLifetime = 5 * time.Minute
+)
+
+// ConnectionStatus represents the current status of the database connection
+type ConnectionStatus struct {
+	IsConnected bool
+	LastCheck   time.Time
+	LastError   string // empty if no error
+	DSNHost     string // host:port for display (without password!)
+}
+
+// ConnectionManager manages database connections with thread-safety and connection pooling
+type ConnectionManager struct {
+	localDB           *localdb.LocalDB // for getting DSN from settings
+	mu                sync.RWMutex     // protects db and state
+	db                *gorm.DB         // current connection (nil if not connected)
+	lastError         error            // last connection error
+	lastCheck         time.Time        // time of last check/attempt
+	connectTimeout    time.Duration    // timeout for connection (default: 5s)
+	pingInterval      time.Duration    // minimum interval between pings (default: 30s)
+	reconnectCooldown time.Duration    // pause after failed attempt (default: 10s)
+}
+
+// NewConnectionManager creates a new ConnectionManager instance
+func NewConnectionManager(localDB *localdb.LocalDB) *ConnectionManager {
+	return &ConnectionManager{
+		localDB:           localDB,
+		connectTimeout:    defaultConnectTimeout,
+		pingInterval:      defaultPingInterval,
+		reconnectCooldown: defaultReconnectCooldown,
+		db:                nil,
+		lastError:         nil,
+		lastCheck:         time.Time{},
+	}
+}
+
+// GetDB returns the current database connection, establishing it if needed
+// Thread-safe and respects connection cooldowns
+func (cm *ConnectionManager) GetDB() (*gorm.DB, error) {
+	// Handle case where localDB is nil
+	if cm.localDB == nil {
+		return nil, fmt.Errorf("local database not initialized")
+	}
+
+	// First check if we already have a valid connection
+	cm.mu.RLock()
+	if cm.db != nil {
+		// Check if connection is still valid and within ping interval
+		if time.Since(cm.lastCheck) < cm.pingInterval {
+			cm.mu.RUnlock()
+			return cm.db, nil
+		}
+	}
+	cm.mu.RUnlock()
+
+	// Upgrade to write lock
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	// Double-check: someone else might have connected while we were waiting for the write lock
+	if cm.db != nil {
+		// Check if connection is still valid and within ping interval
+		if time.Since(cm.lastCheck) < cm.pingInterval {
+			return cm.db, nil
+		}
+	}
+
+	// Check if we're in cooldown period after a failed attempt
+	if cm.lastError != nil && time.Since(cm.lastCheck) < cm.reconnectCooldown {
+		return nil, cm.lastError
+	}
+
+	// Attempt to connect
+	err := cm.connect()
+	if err != nil {
+		// Drop stale handle so callers don't treat it as an active connection.
+		cm.db = nil
+		cm.lastError = err
+		cm.lastCheck = time.Now()
+		return nil, err
+	}
+
+	// Update last check time and return success
+	cm.lastCheck = time.Now()
+	cm.lastError = nil
+	return cm.db, nil
+}
+
+// connect establishes a new database connection
+func (cm *ConnectionManager) connect() error {
+	// Get DSN from local settings
+	dsn, err := cm.localDB.GetDSN()
+	if err != nil {
+		return fmt.Errorf("getting DSN: %w", err)
+	}
+
+	// Create context with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), cm.connectTimeout)
+	defer cancel()
+
+	// Open database connection
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		return fmt.Errorf("opening database connection: %w", err)
+	}
+
+	// Test the connection
+	sqlDB, err := db.DB()
+	if err != nil {
+		return fmt.Errorf("getting sql.DB: %w", err)
+	}
+
+	// Ping with timeout
+	if err = sqlDB.PingContext(ctx); err != nil {
+		return fmt.Errorf("pinging database: %w", err)
+	}
+
+	// Set connection pool settings
+	sqlDB.SetMaxOpenConns(maxOpenConns)
+	sqlDB.SetMaxIdleConns(maxIdleConns)
+	sqlDB.SetConnMaxLifetime(connMaxLifetime)
+
+	// Store the connection
+	cm.db = db
+
+	return nil
+}
+
+// IsOnline checks if the database is currently connected and responsive.
+// If disconnected, it tries to reconnect (respecting cooldowns in GetDB).
+func (cm *ConnectionManager) IsOnline() bool {
+	cm.mu.RLock()
+	isDisconnected := cm.db == nil
+	lastErr := cm.lastError
+	checkedRecently := time.Since(cm.lastCheck) < cm.pingInterval
+	cm.mu.RUnlock()
+
+	// Try reconnect in disconnected state.
+	if isDisconnected {
+		_, err := cm.GetDB()
+		return err == nil
+	}
+
+	// If we've checked recently, return cached result.
+	if checkedRecently {
+		return lastErr == nil
+	}
+
+	// Need to perform actual ping.
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	// Double-check after acquiring write lock
+	if cm.db == nil {
+		return false
+	}
+
+	// Perform ping with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), cm.connectTimeout)
+	defer cancel()
+
+	sqlDB, err := cm.db.DB()
+	if err != nil {
+		cm.lastError = err
+		cm.lastCheck = time.Now()
+		cm.db = nil
+		return false
+	}
+
+	if err = sqlDB.PingContext(ctx); err != nil {
+		cm.lastError = err
+		cm.lastCheck = time.Now()
+		cm.db = nil
+		return false
+	}
+
+	// Update last check time and return success
+	cm.lastCheck = time.Now()
+	cm.lastError = nil
+	return true
+}
+
+// TryConnect forces a new connection attempt (for UI "Reconnect" button)
+// Ignores cooldown period
+func (cm *ConnectionManager) TryConnect() error {
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	// Attempt to connect
+	err := cm.connect()
+	if err != nil {
+		cm.lastError = err
+		cm.lastCheck = time.Now()
+		return err
+	}
+
+	// Update last check time and clear error
+	cm.lastCheck = time.Now()
+	cm.lastError = nil
+	return nil
+}
+
+// Disconnect closes the current database connection
+func (cm *ConnectionManager) Disconnect() {
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	if cm.db != nil {
+		sqlDB, err := cm.db.DB()
+		if err == nil {
+			sqlDB.Close()
+		}
+	}
+	cm.db = nil
+	cm.lastError = nil
+}
+
+// GetLastError returns the last connection error (thread-safe)
+func (cm *ConnectionManager) GetLastError() error {
+	cm.mu.RLock()
+	defer cm.mu.RUnlock()
+	return cm.lastError
+}
+
+// GetStatus returns the current connection status
+func (cm *ConnectionManager) GetStatus() ConnectionStatus {
+	cm.mu.RLock()
+	defer cm.mu.RUnlock()
+
+	status := ConnectionStatus{
+		IsConnected: cm.db != nil,
+		LastCheck:   cm.lastCheck,
+		LastError:   "",
+		DSNHost:     "",
+	}
+
+	if cm.lastError != nil {
+		status.LastError = cm.lastError.Error()
+	}
+
+	// Extract host from DSN for display
+	if cm.localDB != nil {
+		if dsn, err := cm.localDB.GetDSN(); err == nil {
+			// Parse DSN to extract host:port
+			// Format: user:password@tcp(host:port)/database?...
+			status.DSNHost = extractHostFromDSN(dsn)
+		}
+	}
+
+	return status
+}
+
+// extractHostFromDSN extracts the host:port part from a DSN string
+func extractHostFromDSN(dsn string) string {
+	// Find the tcp( part
+	tcpStart := 0
+	if tcpStart = len("tcp("); tcpStart < len(dsn) && dsn[tcpStart] == '(' {
+		// Look for the closing parenthesis
+		parenEnd := -1
+		for i := tcpStart + 1; i < len(dsn); i++ {
+			if dsn[i] == ')' {
+				parenEnd = i
+				break
+			}
+		}
+		if parenEnd != -1 {
+			// Extract host:port part between tcp( and )
+			hostPort := dsn[tcpStart+1 : parenEnd]
+			return hostPort
+		}
+	}
+
+	// Fallback: try to find host:port by looking for @tcp( pattern
+	atIndex := -1
+	for i := 0; i < len(dsn)-4; i++ {
+		if dsn[i:i+4] == "@tcp" {
+			atIndex = i
+			break
+		}
+	}
+
+	if atIndex != -1 {
+		// Look for the opening parenthesis after @tcp
+		parenStart := -1
+		for i := atIndex + 4; i < len(dsn); i++ {
+			if dsn[i] == '(' {
+				parenStart = i
+				break
+			}
+		}
+
+		if parenStart != -1 {
+			// Look for the closing parenthesis
+			parenEnd := -1
+			for i := parenStart + 1; i < len(dsn); i++ {
+				if dsn[i] == ')' {
+					parenEnd = i
+					break
+				}
+			}
+
+			if parenEnd != -1 {
+				hostPort := dsn[parenStart+1 : parenEnd]
+				return hostPort
+			}
+		}
+	}
+
+	// If we can't parse it, return empty string
+	return ""
+}

internal/handlers/component.go

@@ -4,17 +4,22 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
 )
 
 type ComponentHandler struct {
 	componentService *services.ComponentService
+	localDB          *localdb.LocalDB
 }
 
-func NewComponentHandler(componentService *services.ComponentService) *ComponentHandler {
-	return &ComponentHandler{componentService: componentService}
+func NewComponentHandler(componentService *services.ComponentService, localDB *localdb.LocalDB) *ComponentHandler {
+	return &ComponentHandler{
+		componentService: componentService,
+		localDB:          localDB,
+	}
 }
 
 func (h *ComponentHandler) List(c *gin.Context) {
@@ -34,6 +39,46 @@ func (h *ComponentHandler) List(c *gin.Context) {
 		return
 	}
 
+	// If offline mode (empty result), fallback to local components
+	isOffline := false
+	if v, ok := c.Get("is_offline"); ok {
+		if b, ok := v.(bool); ok {
+			isOffline = b
+		}
+	}
+	if isOffline && result.Total == 0 && h.localDB != nil {
+		localFilter := localdb.ComponentFilter{
+			Category: filter.Category,
+			Search:   filter.Search,
+			HasPrice: filter.HasPrice,
+		}
+
+		offset := (page - 1) * perPage
+		localComps, total, err := h.localDB.ListComponents(localFilter, offset, perPage)
+		if err == nil && len(localComps) > 0 {
+			// Convert local components to ComponentView format
+			components := make([]services.ComponentView, len(localComps))
+			for i, lc := range localComps {
+				components[i] = services.ComponentView{
+					LotName:      lc.LotName,
+					Description:  lc.LotDescription,
+					Category:     lc.Category,
+					CategoryName: lc.Category, // No translation in local mode
+					Model:        lc.Model,
+					CurrentPrice: lc.CurrentPrice,
+				}
+			}
+
+			c.JSON(http.StatusOK, &services.ComponentListResult{
+				Components: components,
+				Total:      total,
+				Page:       page,
+				PerPage:    perPage,
+			})
+			return
+		}
+	}
+
 	c.JSON(http.StatusOK, result)
 }
 

internal/handlers/configuration.go

@@ -1,13 +1,12 @@
 package handlers
 
 import (
-
 	"net/http"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
 	"git.mchus.pro/mchus/quoteforge/internal/middleware"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
 )
 
 type ConfigurationHandler struct {
@@ -26,11 +25,11 @@ func NewConfigurationHandler(
 }
 
 func (h *ConfigurationHandler) List(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
 
-	configs, total, err := h.configService.ListByUser(userID, page, perPage)
+	configs, total, err := h.configService.ListByUser(username, page, perPage)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
@@ -45,7 +44,7 @@ func (h *ConfigurationHandler) List(c *gin.Context) {
 }
 
 func (h *ConfigurationHandler) Create(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 
 	var req services.CreateConfigRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
@@ -53,7 +52,7 @@ func (h *ConfigurationHandler) Create(c *gin.Context) {
 		return
 	}
 
-	config, err := h.configService.Create(userID, &req)
+	config, err := h.configService.Create(username, &req)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
@@ -63,10 +62,10 @@ func (h *ConfigurationHandler) Create(c *gin.Context) {
 }
 
 func (h *ConfigurationHandler) Get(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 	uuid := c.Param("uuid")
 
-	config, err := h.configService.GetByUUID(uuid, userID)
+	config, err := h.configService.GetByUUID(uuid, username)
 	if err != nil {
 		status := http.StatusNotFound
 		if err == services.ErrConfigForbidden {
@@ -80,7 +79,7 @@ func (h *ConfigurationHandler) Get(c *gin.Context) {
 }
 
 func (h *ConfigurationHandler) Update(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 	uuid := c.Param("uuid")
 
 	var req services.CreateConfigRequest
@@ -89,7 +88,7 @@ func (h *ConfigurationHandler) Update(c *gin.Context) {
 		return
 	}
 
-	config, err := h.configService.Update(uuid, userID, &req)
+	config, err := h.configService.Update(uuid, username, &req)
 	if err != nil {
 		status := http.StatusInternalServerError
 		if err == services.ErrConfigNotFound {
@@ -105,10 +104,10 @@ func (h *ConfigurationHandler) Update(c *gin.Context) {
 }
 
 func (h *ConfigurationHandler) Delete(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 	uuid := c.Param("uuid")
 
-	err := h.configService.Delete(uuid, userID)
+	err := h.configService.Delete(uuid, username)
 	if err != nil {
 		status := http.StatusInternalServerError
 		if err == services.ErrConfigNotFound {
@@ -128,7 +127,7 @@ type RenameConfigRequest struct {
 }
 
 func (h *ConfigurationHandler) Rename(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 	uuid := c.Param("uuid")
 
 	var req RenameConfigRequest
@@ -137,7 +136,7 @@ func (h *ConfigurationHandler) Rename(c *gin.Context) {
 		return
 	}
 
-	config, err := h.configService.Rename(uuid, userID, req.Name)
+	config, err := h.configService.Rename(uuid, username, req.Name)
 	if err != nil {
 		status := http.StatusInternalServerError
 		if err == services.ErrConfigNotFound {
@@ -157,7 +156,7 @@ type CloneConfigRequest struct {
 }
 
 func (h *ConfigurationHandler) Clone(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 	uuid := c.Param("uuid")
 
 	var req CloneConfigRequest
@@ -166,7 +165,7 @@ func (h *ConfigurationHandler) Clone(c *gin.Context) {
 		return
 	}
 
-	config, err := h.configService.Clone(uuid, userID, req.Name)
+	config, err := h.configService.Clone(uuid, username, req.Name)
 	if err != nil {
 		status := http.StatusInternalServerError
 		if err == services.ErrConfigNotFound {
@@ -182,10 +181,10 @@ func (h *ConfigurationHandler) Clone(c *gin.Context) {
 }
 
 func (h *ConfigurationHandler) RefreshPrices(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 	uuid := c.Param("uuid")
 
-	config, err := h.configService.RefreshPrices(uuid, userID)
+	config, err := h.configService.RefreshPrices(uuid, username)
 	if err != nil {
 		status := http.StatusInternalServerError
 		if err == services.ErrConfigNotFound {

internal/handlers/export.go

@@ -5,9 +5,9 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/gin-gonic/gin"
 	"git.mchus.pro/mchus/quoteforge/internal/middleware"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
 )
 
 type ExportHandler struct {
@@ -98,10 +98,10 @@ func (h *ExportHandler) buildExportData(req *ExportRequest) *services.ExportData
 }
 
 func (h *ExportHandler) ExportConfigCSV(c *gin.Context) {
-	userID := middleware.GetUserID(c)
+	username := middleware.GetUsername(c)
 	uuid := c.Param("uuid")
 
-	config, err := h.configService.GetByUUID(uuid, userID)
+	config, err := h.configService.GetByUUID(uuid, username)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
 		return

internal/handlers/pricelist.go

@@ -29,6 +29,36 @@ func (h *PricelistHandler) List(c *gin.Context) {
 		return
 	}
 
+	// If offline (empty list), fallback to local pricelists
+	if total == 0 && h.localDB != nil {
+		localPLs, err := h.localDB.GetLocalPricelists()
+		if err == nil && len(localPLs) > 0 {
+			// Convert to PricelistSummary format
+			summaries := make([]map[string]interface{}, len(localPLs))
+			for i, lpl := range localPLs {
+				summaries[i] = map[string]interface{}{
+					"id":          lpl.ServerID,
+					"version":     lpl.Version,
+					"created_by":  "sync",
+					"item_count":  0, // Not tracked
+					"usage_count": 0, // Not tracked in local
+					"is_active":   true,
+					"created_at":  lpl.CreatedAt,
+					"synced_from": "local",
+				}
+			}
+
+			c.JSON(http.StatusOK, gin.H{
+				"pricelists": summaries,
+				"total":      len(summaries),
+				"page":       page,
+				"per_page":   perPage,
+				"offline":    true,
+			})
+			return
+		}
+	}
+
 	c.JSON(http.StatusOK, gin.H{
 		"pricelists": pricelists,
 		"total":      total,
@@ -57,6 +87,15 @@ func (h *PricelistHandler) Get(c *gin.Context) {
 
 // Create creates a new pricelist from current prices
 func (h *PricelistHandler) Create(c *gin.Context) {
+	canWrite, debugInfo := h.service.CanWriteDebug()
+	if !canWrite {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "pricelist write is not allowed",
+			"debug": debugInfo,
+		})
+		return
+	}
+
 	// Get the database username as the creator
 	createdBy := h.localDB.GetDBUser()
 	if createdBy == "" {
@@ -74,6 +113,15 @@ func (h *PricelistHandler) Create(c *gin.Context) {
 
 // Delete deletes a pricelist by ID
 func (h *PricelistHandler) Delete(c *gin.Context) {
+	canWrite, debugInfo := h.service.CanWriteDebug()
+	if !canWrite {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "pricelist write is not allowed",
+			"debug": debugInfo,
+		})
+		return
+	}
+
 	idStr := c.Param("id")
 	id, err := strconv.ParseUint(idStr, 10, 32)
 	if err != nil {
@@ -124,9 +172,33 @@ func (h *PricelistHandler) CanWrite(c *gin.Context) {
 
 // GetLatest returns the most recent active pricelist
 func (h *PricelistHandler) GetLatest(c *gin.Context) {
+	// Try to get from server first
 	pl, err := h.service.GetLatestActive()
 	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "no active pricelists found"})
+		// If offline or no server pricelists, try to get from local cache
+		if h.localDB == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "no database available"})
+			return
+		}
+		localPL, localErr := h.localDB.GetLatestLocalPricelist()
+		if localErr != nil {
+			// No local pricelists either
+			c.JSON(http.StatusNotFound, gin.H{
+				"error":       "no pricelists available",
+				"local_error": localErr.Error(),
+			})
+			return
+		}
+		// Return local pricelist
+		c.JSON(http.StatusOK, gin.H{
+			"id":          localPL.ServerID,
+			"version":     localPL.Version,
+			"created_by":  "sync",
+			"item_count":  0, // Not tracked in local pricelists
+			"is_active":   true,
+			"created_at":  localPL.CreatedAt,
+			"synced_from": "local",
+		})
 		return
 	}
 

internal/handlers/pricing.go

@@ -68,6 +68,17 @@ func NewPricingHandler(
 }
 
 func (h *PricingHandler) GetStats(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.statsRepo == nil || h.alertService == nil {
+		c.JSON(http.StatusOK, gin.H{
+			"new_alerts_count":    0,
+			"top_components":      []interface{}{},
+			"trending_components": []interface{}{},
+			"offline":             true,
+		})
+		return
+	}
+
 	newAlerts, _ := h.alertService.GetNewAlertsCount()
 	topComponents, _ := h.statsRepo.GetTopComponents(10)
 	trendingComponents, _ := h.statsRepo.GetTrendingComponents(10)
@@ -86,6 +97,19 @@ type ComponentWithCount struct {
 }
 
 func (h *PricingHandler) ListComponents(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.componentRepo == nil {
+		c.JSON(http.StatusOK, gin.H{
+			"components": []ComponentWithCount{},
+			"total":      0,
+			"page":       1,
+			"per_page":   20,
+			"offline":    true,
+			"message":    "Управление ценами доступно только в онлайн режиме",
+		})
+		return
+	}
+
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
 
@@ -213,6 +237,15 @@ func (h *PricingHandler) expandMetaPrices(metaPrices, excludeLot string) []strin
 }
 
 func (h *PricingHandler) GetComponentPricing(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.componentRepo == nil || h.pricingService == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Управление ценами доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	lotName := c.Param("lot_name")
 
 	component, err := h.componentRepo.GetByLotName(lotName)
@@ -248,6 +281,15 @@ type UpdatePriceRequest struct {
 }
 
 func (h *PricingHandler) UpdatePrice(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Обновление цен доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	var req UpdatePriceRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
@@ -409,6 +451,15 @@ func (h *PricingHandler) recalculateSinglePrice(lotName string) {
 }
 
 func (h *PricingHandler) RecalculateAll(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Пересчёт цен доступен только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	// Set headers for SSE
 	c.Header("Content-Type", "text/event-stream")
 	c.Header("Cache-Control", "no-cache")
@@ -588,6 +639,18 @@ func (h *PricingHandler) RecalculateAll(c *gin.Context) {
 }
 
 func (h *PricingHandler) ListAlerts(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusOK, gin.H{
+			"alerts":   []interface{}{},
+			"total":    0,
+			"page":     1,
+			"per_page": 20,
+			"offline":  true,
+		})
+		return
+	}
+
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
 
@@ -613,6 +676,15 @@ func (h *PricingHandler) ListAlerts(c *gin.Context) {
 }
 
 func (h *PricingHandler) AcknowledgeAlert(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Управление алертами доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
@@ -628,6 +700,15 @@ func (h *PricingHandler) AcknowledgeAlert(c *gin.Context) {
 }
 
 func (h *PricingHandler) ResolveAlert(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Управление алертами доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
@@ -643,6 +724,15 @@ func (h *PricingHandler) ResolveAlert(c *gin.Context) {
 }
 
 func (h *PricingHandler) IgnoreAlert(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Управление алертами доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
@@ -667,6 +757,15 @@ type PreviewPriceRequest struct {
 }
 
 func (h *PricingHandler) PreviewPrice(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Предпросмотр цены доступен только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	var req PreviewPriceRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
@@ -708,8 +807,8 @@ func (h *PricingHandler) PreviewPrice(c *gin.Context) {
 		medianAllTime = &median
 	}
 
-	// Get quote count (from all relevant lots)
-	var quoteCount int64
+	// Get quote count (from all relevant lots) - total count
+	var quoteCountTotal int64
 	for _, lotName := range lotNames {
 		var count int64
 		if strings.HasSuffix(lotName, "*") {
@@ -718,7 +817,25 @@ func (h *PricingHandler) PreviewPrice(c *gin.Context) {
 		} else {
 			h.db.Model(&models.LotLog{}).Where("lot = ?", lotName).Count(&count)
 		}
-		quoteCount += count
+		quoteCountTotal += count
+	}
+
+	// Get quote count for specified period (if period is > 0)
+	var quoteCountPeriod int64
+	if req.PeriodDays > 0 {
+		for _, lotName := range lotNames {
+			var count int64
+			if strings.HasSuffix(lotName, "*") {
+				pattern := strings.TrimSuffix(lotName, "*") + "%"
+				h.db.Raw(`SELECT COUNT(*) FROM lot_log WHERE lot LIKE ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY)`, pattern, req.PeriodDays).Scan(&count)
+			} else {
+				h.db.Raw(`SELECT COUNT(*) FROM lot_log WHERE lot = ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY)`, lotName, req.PeriodDays).Scan(&count)
+			}
+			quoteCountPeriod += count
+		}
+	} else {
+		// If no period specified, period count equals total count
+		quoteCountPeriod = quoteCountTotal
 	}
 
 	// Get last received price (from the main lot only)
@@ -773,14 +890,15 @@ func (h *PricingHandler) PreviewPrice(c *gin.Context) {
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"lot_name":        req.LotName,
-		"current_price":   comp.CurrentPrice,
-		"median_all_time": medianAllTime,
-		"new_price":       newPrice,
-		"quote_count":     quoteCount,
-		"manual_price":    comp.ManualPrice,
-		"last_price":      lastPrice.Price,
-		"last_price_date": lastPrice.Date,
+		"lot_name":           req.LotName,
+		"current_price":      comp.CurrentPrice,
+		"median_all_time":    medianAllTime,
+		"new_price":          newPrice,
+		"quote_count_total":  quoteCountTotal,
+		"quote_count_period": quoteCountPeriod,
+		"manual_price":       comp.ManualPrice,
+		"last_price":         lastPrice.Price,
+		"last_price_date":    lastPrice.Date,
 	})
 }
 

internal/handlers/setup.go

@@ -3,24 +3,30 @@ package handlers
 import (
 	"fmt"
 	"html/template"
+	"log/slog"
 	"net/http"
+	"os"
 	"path/filepath"
 	"strconv"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	qfassets "git.mchus.pro/mchus/quoteforge"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"github.com/gin-gonic/gin"
 	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 )
 
 type SetupHandler struct {
-	localDB   *localdb.LocalDB
-	templates map[string]*template.Template
+	localDB    *localdb.LocalDB
+	connMgr    *db.ConnectionManager
+	templates  map[string]*template.Template
+	restartSig chan struct{}
 }
 
-func NewSetupHandler(localDB *localdb.LocalDB, templatesPath string) (*SetupHandler, error) {
+func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, templatesPath string, restartSig chan struct{}) (*SetupHandler, error) {
 	funcMap := template.FuncMap{
 		"sub": func(a, b int) int { return a - b },
 		"add": func(a, b int) int { return a + b },
@@ -30,15 +36,23 @@ func NewSetupHandler(localDB *localdb.LocalDB, templatesPath string) (*SetupHand
 
 	// Load setup template (standalone, no base needed)
 	setupPath := filepath.Join(templatesPath, "setup.html")
-	tmpl, err := template.New("").Funcs(funcMap).ParseFiles(setupPath)
+	var tmpl *template.Template
+	var err error
+	if stat, statErr := os.Stat(templatesPath); statErr == nil && stat.IsDir() {
+		tmpl, err = template.New("").Funcs(funcMap).ParseFiles(setupPath)
+	} else {
+		tmpl, err = template.New("").Funcs(funcMap).ParseFS(qfassets.TemplatesFS, "web/templates/setup.html")
+	}
 	if err != nil {
 		return nil, fmt.Errorf("parsing setup template: %w", err)
 	}
 	templates["setup.html"] = tmpl
 
 	return &SetupHandler{
-		localDB:   localDB,
-		templates: templates,
+		localDB:    localDB,
+		connMgr:    connMgr,
+		templates:  templates,
+		restartSig: restartSig,
 	}, nil
 }
 
@@ -72,6 +86,13 @@ func (h *SetupHandler) TestConnection(c *gin.Context) {
 		port = p
 	}
 
+	// If password is empty, try to use saved password
+	if password == "" {
+		if settings, err := h.localDB.GetSettings(); err == nil && settings != nil {
+			password = settings.PasswordEncrypted // GetSettings returns decrypted password in this field
+		}
+	}
+
 	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=5s",
 		user, password, host, port, database)
 
@@ -127,6 +148,8 @@ func (h *SetupHandler) TestConnection(c *gin.Context) {
 
 // SaveConnection saves the connection settings and signals restart
 func (h *SetupHandler) SaveConnection(c *gin.Context) {
+	existingSettings, _ := h.localDB.GetSettings()
+
 	host := c.PostForm("host")
 	portStr := c.PostForm("port")
 	database := c.PostForm("database")
@@ -138,6 +161,13 @@ func (h *SetupHandler) SaveConnection(c *gin.Context) {
 		port = p
 	}
 
+	// If password is empty, use saved password
+	if password == "" {
+		if settings, err := h.localDB.GetSettings(); err == nil && settings != nil {
+			password = settings.PasswordEncrypted // GetSettings returns decrypted password in this field
+		}
+	}
+
 	// Test connection first
 	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=5s",
 		user, password, host, port, database)
@@ -165,10 +195,40 @@ func (h *SetupHandler) SaveConnection(c *gin.Context) {
 		return
 	}
 
+	// Try to connect immediately to verify settings
+	if h.connMgr != nil {
+		if err := h.connMgr.TryConnect(); err != nil {
+			slog.Warn("failed to connect after saving settings", "error", err)
+		} else {
+			slog.Info("successfully connected to database after saving settings")
+		}
+	}
+
+	settingsChanged := existingSettings == nil ||
+		existingSettings.Host != host ||
+		existingSettings.Port != port ||
+		existingSettings.Database != database ||
+		existingSettings.User != user ||
+		existingSettings.PasswordEncrypted != password
+
+	restartQueued := settingsChanged && h.restartSig != nil
 	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "Settings saved. Please restart the application.",
+		"success":          true,
+		"message":          "Settings saved.",
+		"restart_required": settingsChanged,
+		"restart_queued":   restartQueued,
 	})
+
+	// Signal restart after response is sent (if restart signal is configured)
+	if restartQueued {
+		go func() {
+			time.Sleep(500 * time.Millisecond) // Give time for response to be sent
+			select {
+			case h.restartSig <- struct{}{}:
+			default:
+			}
+		}()
+	}
 }
 
 // GetStatus returns the current setup status

internal/handlers/sync.go

@@ -4,28 +4,36 @@ import (
 	"html/template"
 	"log/slog"
 	"net/http"
+	"os"
 	"path/filepath"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	qfassets "git.mchus.pro/mchus/quoteforge"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
-	"gorm.io/gorm"
+	"github.com/gin-gonic/gin"
 )
 
 // SyncHandler handles sync API endpoints
 type SyncHandler struct {
 	localDB     *localdb.LocalDB
 	syncService *sync.Service
-	mariaDB     *gorm.DB
+	connMgr     *db.ConnectionManager
 	tmpl        *template.Template
 }
 
 // NewSyncHandler creates a new sync handler
-func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, mariaDB *gorm.DB, templatesPath string) (*SyncHandler, error) {
+func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, templatesPath string) (*SyncHandler, error) {
 	// Load sync_status partial template
 	partialPath := filepath.Join(templatesPath, "partials", "sync_status.html")
-	tmpl, err := template.ParseFiles(partialPath)
+	var tmpl *template.Template
+	var err error
+	if stat, statErr := os.Stat(templatesPath); statErr == nil && stat.IsDir() {
+		tmpl, err = template.ParseFiles(partialPath)
+	} else {
+		tmpl, err = template.ParseFS(qfassets.TemplatesFS, "web/templates/partials/sync_status.html")
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -33,21 +41,21 @@ func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, mariaDB
 	return &SyncHandler{
 		localDB:     localDB,
 		syncService: syncService,
-		mariaDB:     mariaDB,
+		connMgr:     connMgr,
 		tmpl:        tmpl,
 	}, nil
 }
 
 // SyncStatusResponse represents the sync status
 type SyncStatusResponse struct {
-	LastComponentSync  *time.Time `json:"last_component_sync"`
-	LastPricelistSync  *time.Time `json:"last_pricelist_sync"`
-	IsOnline           bool       `json:"is_online"`
-	ComponentsCount    int64      `json:"components_count"`
-	PricelistsCount    int64      `json:"pricelists_count"`
-	ServerPricelists   int        `json:"server_pricelists"`
-	NeedComponentSync  bool       `json:"need_component_sync"`
-	NeedPricelistSync  bool       `json:"need_pricelist_sync"`
+	LastComponentSync *time.Time `json:"last_component_sync"`
+	LastPricelistSync *time.Time `json:"last_pricelist_sync"`
+	IsOnline          bool       `json:"is_online"`
+	ComponentsCount   int64      `json:"components_count"`
+	PricelistsCount   int64      `json:"pricelists_count"`
+	ServerPricelists  int        `json:"server_pricelists"`
+	NeedComponentSync bool       `json:"need_component_sync"`
+	NeedPricelistSync bool       `json:"need_pricelist_sync"`
 }
 
 // GetStatus returns current sync status
@@ -79,14 +87,14 @@ func (h *SyncHandler) GetStatus(c *gin.Context) {
 	needComponentSync := h.localDB.NeedComponentSync(24)
 
 	c.JSON(http.StatusOK, SyncStatusResponse{
-		LastComponentSync:  lastComponentSync,
-		LastPricelistSync:  lastPricelistSync,
-		IsOnline:           isOnline,
-		ComponentsCount:    componentsCount,
-		PricelistsCount:    pricelistsCount,
-		ServerPricelists:   serverPricelists,
-		NeedComponentSync:  needComponentSync,
-		NeedPricelistSync:  needPricelistSync,
+		LastComponentSync: lastComponentSync,
+		LastPricelistSync: lastPricelistSync,
+		IsOnline:          isOnline,
+		ComponentsCount:   componentsCount,
+		PricelistsCount:   pricelistsCount,
+		ServerPricelists:  serverPricelists,
+		NeedComponentSync: needComponentSync,
+		NeedPricelistSync: needPricelistSync,
 	})
 }
 
@@ -109,7 +117,17 @@ func (h *SyncHandler) SyncComponents(c *gin.Context) {
 		return
 	}
 
-	result, err := h.localDB.SyncComponents(h.mariaDB)
+	// Get database connection from ConnectionManager
+	mariaDB, err := h.connMgr.GetDB()
+	if err != nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database connection failed: " + err.Error(),
+		})
+		return
+	}
+
+	result, err := h.localDB.SyncComponents(mariaDB)
 	if err != nil {
 		slog.Error("component sync failed", "error", err)
 		c.JSON(http.StatusInternalServerError, gin.H{
@@ -159,11 +177,11 @@ func (h *SyncHandler) SyncPricelists(c *gin.Context) {
 
 // SyncAllResponse represents result of full sync
 type SyncAllResponse struct {
-	Success            bool   `json:"success"`
-	Message            string `json:"message"`
-	ComponentsSynced   int    `json:"components_synced"`
-	PricelistsSynced   int    `json:"pricelists_synced"`
-	Duration           string `json:"duration"`
+	Success          bool   `json:"success"`
+	Message          string `json:"message"`
+	ComponentsSynced int    `json:"components_synced"`
+	PricelistsSynced int    `json:"pricelists_synced"`
+	Duration         string `json:"duration"`
 }
 
 // SyncAll syncs both components and pricelists
@@ -181,7 +199,16 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 	var componentsSynced, pricelistsSynced int
 
 	// Sync components
-	compResult, err := h.localDB.SyncComponents(h.mariaDB)
+	mariaDB, err := h.connMgr.GetDB()
+	if err != nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database connection failed: " + err.Error(),
+		})
+		return
+	}
+
+	compResult, err := h.localDB.SyncComponents(mariaDB)
 	if err != nil {
 		slog.Error("component sync failed during full sync", "error", err)
 		c.JSON(http.StatusInternalServerError, gin.H{
@@ -197,8 +224,8 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 	if err != nil {
 		slog.Error("pricelist sync failed during full sync", "error", err)
 		c.JSON(http.StatusInternalServerError, gin.H{
-			"success":          false,
-			"error":            "Pricelist sync failed: " + err.Error(),
+			"success":           false,
+			"error":             "Pricelist sync failed: " + err.Error(),
 			"components_synced": componentsSynced,
 		})
 		return
@@ -215,16 +242,7 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 
 // checkOnline checks if MariaDB is accessible
 func (h *SyncHandler) checkOnline() bool {
-	sqlDB, err := h.mariaDB.DB()
-	if err != nil {
-		return false
-	}
-
-	if err := sqlDB.Ping(); err != nil {
-		return false
-	}
-
-	return true
+	return h.connMgr.IsOnline()
 }
 
 // PushPendingChanges pushes all pending changes to the server
@@ -282,23 +300,97 @@ func (h *SyncHandler) GetPendingChanges(c *gin.Context) {
 	})
 }
 
+// SyncInfoResponse represents sync information
+type SyncInfoResponse struct {
+	LastSyncAt *time.Time  `json:"last_sync_at"`
+	IsOnline   bool        `json:"is_online"`
+	ErrorCount int         `json:"error_count"`
+	Errors     []SyncError `json:"errors,omitempty"`
+}
+
+// SyncError represents a sync error
+type SyncError struct {
+	Timestamp time.Time `json:"timestamp"`
+	Message   string    `json:"message"`
+}
+
+// GetInfo returns sync information for modal
+// GET /api/sync/info
+func (h *SyncHandler) GetInfo(c *gin.Context) {
+	// Check online status by pinging MariaDB
+	isOnline := h.checkOnline()
+
+	// Get sync times
+	lastPricelistSync := h.localDB.GetLastSyncTime()
+
+	// Get error count (only changes with LastError != "")
+	errorCount := int(h.localDB.CountErroredChanges())
+
+	// Get recent errors (last 10)
+	changes, err := h.localDB.GetPendingChanges()
+	if err != nil {
+		slog.Error("failed to get pending changes for sync info", "error", err)
+		// Even if we can't get changes, we can still return the error count
+		c.JSON(http.StatusOK, SyncInfoResponse{
+			LastSyncAt: lastPricelistSync,
+			IsOnline:   isOnline,
+			ErrorCount: errorCount,
+			Errors:     []SyncError{}, // Return empty errors list
+		})
+		return
+	}
+
+	var errors []SyncError
+	for _, change := range changes {
+		// Check if there's a last error and it's not empty
+		if change.LastError != "" {
+			errors = append(errors, SyncError{
+				Timestamp: change.CreatedAt,
+				Message:   change.LastError,
+			})
+		}
+	}
+
+	// Limit to last 10 errors
+	if len(errors) > 10 {
+		errors = errors[:10]
+	}
+
+	c.JSON(http.StatusOK, SyncInfoResponse{
+		LastSyncAt: lastPricelistSync,
+		IsOnline:   isOnline,
+		ErrorCount: errorCount,
+		Errors:     errors,
+	})
+}
+
 // SyncStatusPartial renders the sync status partial for htmx
 // GET /partials/sync-status
 func (h *SyncHandler) SyncStatusPartial(c *gin.Context) {
-	// Check online status
-	isOffline, _ := c.Get("is_offline")
+	// Check online status from middleware
+	isOfflineValue, exists := c.Get("is_offline")
+	isOffline := false
+	if exists {
+		isOffline = isOfflineValue.(bool)
+	} else {
+		// Fallback: check directly if middleware didn't set it
+		isOffline = !h.checkOnline()
+		slog.Warn("is_offline not found in context, checking directly")
+	}
 
 	// Get pending count
 	pendingCount := h.localDB.GetPendingCount()
 
+	slog.Debug("rendering sync status", "is_offline", isOffline, "pending_count", pendingCount)
+
 	data := gin.H{
-		"IsOffline":    isOffline.(bool),
+		"IsOffline":    isOffline,
 		"PendingCount": pendingCount,
 	}
 
 	c.Header("Content-Type", "text/html; charset=utf-8")
 	if err := h.tmpl.ExecuteTemplate(c.Writer, "sync_status", data); err != nil {
 		slog.Error("failed to render sync_status template", "error", err)
-		c.String(http.StatusInternalServerError, "Template error")
+		c.String(http.StatusInternalServerError, "Template error: "+err.Error())
 	}
 }

internal/handlers/web.go

@@ -2,12 +2,14 @@ package handlers
 
 import (
 	"html/template"
+	"os"
 	"path/filepath"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
+	qfassets "git.mchus.pro/mchus/quoteforge"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
 )
 
 type WebHandler struct {
@@ -59,12 +61,26 @@ func NewWebHandler(templatesPath string, componentService *services.ComponentSer
 
 	templates := make(map[string]*template.Template)
 	basePath := filepath.Join(templatesPath, "base.html")
+	useDisk := false
+	if stat, statErr := os.Stat(templatesPath); statErr == nil && stat.IsDir() {
+		useDisk = true
+	}
 
 	// Load each page template with base
 	simplePages := []string{"login.html", "configs.html", "admin_pricing.html", "pricelists.html", "pricelist_detail.html"}
 	for _, page := range simplePages {
 		pagePath := filepath.Join(templatesPath, page)
-		tmpl, err := template.New("").Funcs(funcMap).ParseFiles(basePath, pagePath)
+		var tmpl *template.Template
+		var err error
+		if useDisk {
+			tmpl, err = template.New("").Funcs(funcMap).ParseFiles(basePath, pagePath)
+		} else {
+			tmpl, err = template.New("").Funcs(funcMap).ParseFS(
+				qfassets.TemplatesFS,
+				"web/templates/base.html",
+				"web/templates/"+page,
+			)
+		}
 		if err != nil {
 			return nil, err
 		}
@@ -74,7 +90,18 @@ func NewWebHandler(templatesPath string, componentService *services.ComponentSer
 	// Index page needs components_list.html as well
 	indexPath := filepath.Join(templatesPath, "index.html")
 	componentsListPath := filepath.Join(templatesPath, "components_list.html")
-	indexTmpl, err := template.New("").Funcs(funcMap).ParseFiles(basePath, indexPath, componentsListPath)
+	var indexTmpl *template.Template
+	var err error
+	if useDisk {
+		indexTmpl, err = template.New("").Funcs(funcMap).ParseFiles(basePath, indexPath, componentsListPath)
+	} else {
+		indexTmpl, err = template.New("").Funcs(funcMap).ParseFS(
+			qfassets.TemplatesFS,
+			"web/templates/base.html",
+			"web/templates/index.html",
+			"web/templates/components_list.html",
+		)
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -84,7 +111,16 @@ func NewWebHandler(templatesPath string, componentService *services.ComponentSer
 	partials := []string{"components_list.html"}
 	for _, partial := range partials {
 		partialPath := filepath.Join(templatesPath, partial)
-		tmpl, err := template.New("").Funcs(funcMap).ParseFiles(partialPath)
+		var tmpl *template.Template
+		var err error
+		if useDisk {
+			tmpl, err = template.New("").Funcs(funcMap).ParseFiles(partialPath)
+		} else {
+			tmpl, err = template.New("").Funcs(funcMap).ParseFS(
+				qfassets.TemplatesFS,
+				"web/templates/"+partial,
+			)
+		}
 		if err != nil {
 			return nil, err
 		}

internal/localdb/components.go

@@ -9,6 +9,13 @@ import (
 	"gorm.io/gorm"
 )
 
+// ComponentFilter for searching with filters
+type ComponentFilter struct {
+	Category string
+	Search   string
+	HasPrice bool
+}
+
 // ComponentSyncResult contains statistics from component sync
 type ComponentSyncResult struct {
 	TotalSynced int
@@ -196,6 +203,44 @@ func (l *LocalDB) SearchLocalComponentsByCategory(category string, query string,
 	return components, err
 }
 
+// ListComponents returns components with filtering and pagination
+func (l *LocalDB) ListComponents(filter ComponentFilter, offset, limit int) ([]LocalComponent, int64, error) {
+	db := l.db
+
+	// Apply category filter
+	if filter.Category != "" {
+		db = db.Where("LOWER(category) = ?", strings.ToLower(filter.Category))
+	}
+
+	// Apply search filter
+	if filter.Search != "" {
+		searchPattern := "%" + strings.ToLower(filter.Search) + "%"
+		db = db.Where(
+			"LOWER(lot_name) LIKE ? OR LOWER(lot_description) LIKE ? OR LOWER(category) LIKE ? OR LOWER(model) LIKE ?",
+			searchPattern, searchPattern, searchPattern, searchPattern,
+		)
+	}
+
+	// Apply price filter
+	if filter.HasPrice {
+		db = db.Where("current_price IS NOT NULL")
+	}
+
+	// Get total count
+	var total int64
+	if err := db.Model(&LocalComponent{}).Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Apply pagination and get results
+	var components []LocalComponent
+	if err := db.Order("lot_name").Offset(offset).Limit(limit).Find(&components).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return components, total, nil
+}
+
 // GetLocalComponent returns a single component by lot_name
 func (l *LocalDB) GetLocalComponent(lotName string) (*LocalComponent, error) {
 	var component LocalComponent
@@ -266,3 +311,100 @@ func (l *LocalDB) NeedComponentSync(maxAgeHours int) bool {
 	}
 	return time.Since(*syncTime).Hours() > float64(maxAgeHours)
 }
+
+// UpdateComponentPricesFromPricelist updates current_price in local_components from pricelist items
+// This allows offline price updates using synced pricelists without MariaDB connection
+func (l *LocalDB) UpdateComponentPricesFromPricelist(pricelistID uint) (int, error) {
+	// Get all items from the specified pricelist
+	var items []LocalPricelistItem
+	if err := l.db.Where("pricelist_id = ?", pricelistID).Find(&items).Error; err != nil {
+		return 0, fmt.Errorf("fetching pricelist items: %w", err)
+	}
+
+	if len(items) == 0 {
+		slog.Warn("no items found in pricelist", "pricelist_id", pricelistID)
+		return 0, nil
+	}
+
+	// Update current_price for each component
+	updated := 0
+	err := l.db.Transaction(func(tx *gorm.DB) error {
+		for _, item := range items {
+			result := tx.Model(&LocalComponent{}).
+				Where("lot_name = ?", item.LotName).
+				Update("current_price", item.Price)
+
+			if result.Error != nil {
+				return fmt.Errorf("updating price for %s: %w", item.LotName, result.Error)
+			}
+
+			if result.RowsAffected > 0 {
+				updated++
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return 0, err
+	}
+
+	slog.Info("updated component prices from pricelist",
+		"pricelist_id", pricelistID,
+		"total_items", len(items),
+		"updated_components", updated)
+
+	return updated, nil
+}
+
+// EnsureComponentPricesFromPricelists loads prices from the latest pricelist into local_components
+// if no components exist or all current prices are NULL
+func (l *LocalDB) EnsureComponentPricesFromPricelists() error {
+	// Check if we have any components with prices
+	var count int64
+	if err := l.db.Model(&LocalComponent{}).Where("current_price IS NOT NULL").Count(&count).Error; err != nil {
+		return fmt.Errorf("checking component prices: %w", err)
+	}
+
+	// If we have components with prices, don't load from pricelists
+	if count > 0 {
+		return nil
+	}
+
+	// Check if we have any components at all
+	var totalComponents int64
+	if err := l.db.Model(&LocalComponent{}).Count(&totalComponents).Error; err != nil {
+		return fmt.Errorf("counting components: %w", err)
+	}
+
+	// If we have no components, we need to load them from pricelists
+	if totalComponents == 0 {
+		slog.Info("no components found in local database, loading from latest pricelist")
+		// This would typically be called from the sync service or setup process
+		// For now, we'll just return nil to indicate no action needed
+		return nil
+	}
+
+	// If we have components but no prices, we should load prices from pricelists
+	// Find the latest pricelist
+	var latestPricelist LocalPricelist
+	if err := l.db.Order("created_at DESC").First(&latestPricelist).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			slog.Warn("no pricelists found in local database")
+			return nil
+		}
+		return fmt.Errorf("finding latest pricelist: %w", err)
+	}
+
+	// Update prices from the latest pricelist
+	updated, err := l.UpdateComponentPricesFromPricelist(latestPricelist.ID)
+	if err != nil {
+		return fmt.Errorf("updating component prices from pricelist: %w", err)
+	}
+
+	slog.Info("loaded component prices from latest pricelist",
+		"pricelist_id", latestPricelist.ID,
+		"updated_components", updated)
+
+	return nil
+}

internal/localdb/converters.go

@@ -18,18 +18,25 @@ func ConfigurationToLocal(cfg *models.Configuration) *LocalConfiguration {
 	}
 
 	local := &LocalConfiguration{
-		UUID:           cfg.UUID,
-		Name:           cfg.Name,
-		Items:          items,
-		TotalPrice:     cfg.TotalPrice,
-		CustomPrice:    cfg.CustomPrice,
-		Notes:          cfg.Notes,
-		IsTemplate:     cfg.IsTemplate,
-		ServerCount:    cfg.ServerCount,
-		CreatedAt:      cfg.CreatedAt,
-		UpdatedAt:      time.Now(),
-		SyncStatus:     "pending",
-		OriginalUserID: cfg.UserID,
+		UUID:             cfg.UUID,
+		IsActive:         true,
+		Name:             cfg.Name,
+		Items:            items,
+		TotalPrice:       cfg.TotalPrice,
+		CustomPrice:      cfg.CustomPrice,
+		Notes:            cfg.Notes,
+		IsTemplate:       cfg.IsTemplate,
+		ServerCount:      cfg.ServerCount,
+		PriceUpdatedAt:   cfg.PriceUpdatedAt,
+		CreatedAt:        cfg.CreatedAt,
+		UpdatedAt:        time.Now(),
+		SyncStatus:       "pending",
+		OriginalUserID:   derefUint(cfg.UserID),
+		OriginalUsername: cfg.OwnerUsername,
+	}
+
+	if local.OriginalUsername == "" && cfg.User != nil {
+		local.OriginalUsername = cfg.User.Username
 	}
 
 	if cfg.ID > 0 {
@@ -52,25 +59,37 @@ func LocalToConfiguration(local *LocalConfiguration) *models.Configuration {
 	}
 
 	cfg := &models.Configuration{
-		UUID:        local.UUID,
-		UserID:      local.OriginalUserID,
-		Name:        local.Name,
-		Items:       items,
-		TotalPrice:  local.TotalPrice,
-		CustomPrice: local.CustomPrice,
-		Notes:       local.Notes,
-		IsTemplate:  local.IsTemplate,
-		ServerCount: local.ServerCount,
-		CreatedAt:   local.CreatedAt,
+		UUID:           local.UUID,
+		OwnerUsername:  local.OriginalUsername,
+		Name:           local.Name,
+		Items:          items,
+		TotalPrice:     local.TotalPrice,
+		CustomPrice:    local.CustomPrice,
+		Notes:          local.Notes,
+		IsTemplate:     local.IsTemplate,
+		ServerCount:    local.ServerCount,
+		PriceUpdatedAt: local.PriceUpdatedAt,
+		CreatedAt:      local.CreatedAt,
 	}
 
 	if local.ServerID != nil {
 		cfg.ID = *local.ServerID
 	}
+	if local.OriginalUserID != 0 {
+		userID := local.OriginalUserID
+		cfg.UserID = &userID
+	}
 
 	return cfg
 }
 
+func derefUint(v *uint) uint {
+	if v == nil {
+		return 0
+	}
+	return *v
+}
+
 // PricelistToLocal converts models.Pricelist to LocalPricelist
 func PricelistToLocal(pl *models.Pricelist) *LocalPricelist {
 	name := pl.Notification

internal/localdb/local_migrations_test.go

@@ -0,0 +1,72 @@
+package localdb
+
+import (
+	"path/filepath"
+	"testing"
+)
+
+func TestRunLocalMigrationsBackfillsExistingConfigurations(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "legacy_local.db")
+
+	local, err := New(dbPath)
+	if err != nil {
+		t.Fatalf("open localdb: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	cfg := &LocalConfiguration{
+		UUID:             "legacy-cfg",
+		Name:             "Legacy",
+		Items:            LocalConfigItems{},
+		SyncStatus:       "pending",
+		OriginalUsername: "tester",
+		IsActive:         true,
+	}
+	if err := local.SaveConfiguration(cfg); err != nil {
+		t.Fatalf("save seed config: %v", err)
+	}
+	if err := local.DB().Where("configuration_uuid = ?", "legacy-cfg").Delete(&LocalConfigurationVersion{}).Error; err != nil {
+		t.Fatalf("delete seed versions: %v", err)
+	}
+	if err := local.DB().Model(&LocalConfiguration{}).
+		Where("uuid = ?", "legacy-cfg").
+		Update("current_version_id", nil).Error; err != nil {
+		t.Fatalf("clear current_version_id: %v", err)
+	}
+	if err := local.DB().Where("1=1").Delete(&LocalSchemaMigration{}).Error; err != nil {
+		t.Fatalf("clear migration records: %v", err)
+	}
+
+	if err := runLocalMigrations(local.DB()); err != nil {
+		t.Fatalf("run local migrations manually: %v", err)
+	}
+
+	migratedCfg, err := local.GetConfigurationByUUID("legacy-cfg")
+	if err != nil {
+		t.Fatalf("get migrated config: %v", err)
+	}
+	if migratedCfg.CurrentVersionID == nil || *migratedCfg.CurrentVersionID == "" {
+		t.Fatalf("expected current_version_id after migration")
+	}
+	if !migratedCfg.IsActive {
+		t.Fatalf("expected migrated config to be active")
+	}
+
+	var versionCount int64
+	if err := local.DB().Model(&LocalConfigurationVersion{}).
+		Where("configuration_uuid = ?", "legacy-cfg").
+		Count(&versionCount).Error; err != nil {
+		t.Fatalf("count versions: %v", err)
+	}
+	if versionCount != 1 {
+		t.Fatalf("expected 1 backfilled version, got %d", versionCount)
+	}
+
+	var migrationCount int64
+	if err := local.DB().Model(&LocalSchemaMigration{}).Count(&migrationCount).Error; err != nil {
+		t.Fatalf("count local migrations: %v", err)
+	}
+	if migrationCount == 0 {
+		t.Fatalf("expected local migrations to be recorded")
+	}
+}

internal/localdb/localdb.go

@@ -7,7 +7,9 @@ import (
 	"path/filepath"
 	"time"
 
+	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
 	"github.com/glebarez/sqlite"
+	uuidpkg "github.com/google/uuid"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 )
@@ -52,6 +54,7 @@ func New(dbPath string) (*LocalDB, error) {
 	if err := db.AutoMigrate(
 		&ConnectionSettings{},
 		&LocalConfiguration{},
+		&LocalConfigurationVersion{},
 		&LocalPricelist{},
 		&LocalPricelistItem{},
 		&LocalComponent{},
@@ -60,6 +63,9 @@ func New(dbPath string) (*LocalDB, error) {
 	); err != nil {
 		return nil, fmt.Errorf("migrating sqlite database: %w", err)
 	}
+	if err := runLocalMigrations(db); err != nil {
+		return nil, fmt.Errorf("running local sqlite migrations: %w", err)
+	}
 
 	slog.Info("local SQLite database initialized", "path", dbPath)
 
@@ -132,7 +138,11 @@ func (l *LocalDB) GetDSN() (string, error) {
 		return "", err
 	}
 
-	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local",
+	// Add aggressive timeouts for offline-first architecture
+	// timeout: connection establishment timeout (3s)
+	// readTimeout: I/O read timeout (3s)
+	// writeTimeout: I/O write timeout (3s)
+	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=3s&readTimeout=3s&writeTimeout=3s",
 		settings.User,
 		settings.PasswordEncrypted, // Contains decrypted password after GetSettings
 		settings.Host,
@@ -189,7 +199,60 @@ func (l *LocalDB) GetConfigurationByUUID(uuid string) (*LocalConfiguration, erro
 
 // DeleteConfiguration deletes a configuration by UUID
 func (l *LocalDB) DeleteConfiguration(uuid string) error {
-	return l.db.Where("uuid = ?", uuid).Delete(&LocalConfiguration{}).Error
+	return l.DeactivateConfiguration(uuid)
+}
+
+// DeactivateConfiguration marks configuration as inactive and appends one snapshot version.
+func (l *LocalDB) DeactivateConfiguration(uuid string) error {
+	return l.db.Transaction(func(tx *gorm.DB) error {
+		var cfg LocalConfiguration
+		if err := tx.Where("uuid = ?", uuid).First(&cfg).Error; err != nil {
+			return err
+		}
+		if !cfg.IsActive {
+			return nil
+		}
+
+		cfg.IsActive = false
+		cfg.UpdatedAt = time.Now()
+		cfg.SyncStatus = "pending"
+		if err := tx.Save(&cfg).Error; err != nil {
+			return fmt.Errorf("save inactive configuration: %w", err)
+		}
+
+		var maxVersion int
+		if err := tx.Model(&LocalConfigurationVersion{}).
+			Where("configuration_uuid = ?", cfg.UUID).
+			Select("COALESCE(MAX(version_no), 0)").
+			Scan(&maxVersion).Error; err != nil {
+			return fmt.Errorf("read max version for deactivate: %w", err)
+		}
+
+		snapshot, err := BuildConfigurationSnapshot(&cfg)
+		if err != nil {
+			return fmt.Errorf("build deactivate snapshot: %w", err)
+		}
+		note := "deactivate via local delete"
+		version := &LocalConfigurationVersion{
+			ID:                uuidpkg.NewString(),
+			ConfigurationUUID: cfg.UUID,
+			VersionNo:         maxVersion + 1,
+			Data:              snapshot,
+			ChangeNote:        &note,
+			AppVersion:        appmeta.Version(),
+			CreatedAt:         time.Now(),
+		}
+		if err := tx.Create(version).Error; err != nil {
+			return fmt.Errorf("insert deactivate version: %w", err)
+		}
+		if err := tx.Model(&LocalConfiguration{}).
+			Where("uuid = ?", cfg.UUID).
+			Update("current_version_id", version.ID).Error; err != nil {
+			return fmt.Errorf("set current version after deactivate: %w", err)
+		}
+
+		return nil
+	})
 }
 
 // CountConfigurations returns the number of local configurations
@@ -396,6 +459,13 @@ func (l *LocalDB) CountPendingChangesByType(entityType string) int64 {
 	return count
 }
 
+// CountErroredChanges returns the number of pending changes with errors
+func (l *LocalDB) CountErroredChanges() int64 {
+	var count int64
+	l.db.Model(&PendingChange{}).Where("last_error != ?", "").Count(&count)
+	return count
+}
+
 // MarkChangesSynced marks multiple pending changes as synced by deleting them
 func (l *LocalDB) MarkChangesSynced(ids []int64) error {
 	if len(ids) == 0 {
@@ -404,6 +474,16 @@ func (l *LocalDB) MarkChangesSynced(ids []int64) error {
 	return l.db.Where("id IN ?", ids).Delete(&PendingChange{}).Error
 }
 
+// PurgeOrphanConfigurationPendingChanges removes configuration pending changes
+// whose entity_uuid no longer exists in local_configurations.
+func (l *LocalDB) PurgeOrphanConfigurationPendingChanges() (int64, error) {
+	tx := l.db.Where(
+		"entity_type = ? AND entity_uuid NOT IN (SELECT uuid FROM local_configurations)",
+		"configuration",
+	).Delete(&PendingChange{})
+	return tx.RowsAffected, tx.Error
+}
+
 // GetPendingCount returns the total number of pending changes (alias for CountPendingChanges)
 func (l *LocalDB) GetPendingCount() int64 {
 	return l.CountPendingChanges()

internal/localdb/migration_versioning_test.go

@@ -0,0 +1,131 @@
+package localdb
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+)
+
+func TestMigration006BackfillCreatesV1AndCurrentPointer(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "migration_backfill.db")
+	db, err := gorm.Open(sqlite.Open(dbPath), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+
+	if err := db.Exec(`
+CREATE TABLE local_configurations (
+	id INTEGER PRIMARY KEY AUTOINCREMENT,
+	uuid TEXT NOT NULL UNIQUE,
+	server_id INTEGER NULL,
+	name TEXT NOT NULL,
+	items TEXT,
+	total_price REAL,
+	custom_price REAL,
+	notes TEXT,
+	is_template BOOLEAN DEFAULT FALSE,
+	server_count INTEGER DEFAULT 1,
+	price_updated_at DATETIME NULL,
+	created_at DATETIME,
+	updated_at DATETIME,
+	synced_at DATETIME,
+	sync_status TEXT DEFAULT 'local',
+	original_user_id INTEGER DEFAULT 0,
+	original_username TEXT DEFAULT ''
+);`).Error; err != nil {
+		t.Fatalf("create pre-migration schema: %v", err)
+	}
+
+	items := `[{"lot_name":"CPU_X","quantity":2,"unit_price":1000}]`
+	now := time.Now().UTC().Format(time.RFC3339)
+	if err := db.Exec(`
+INSERT INTO local_configurations
+	(uuid, name, items, total_price, notes, server_count, created_at, updated_at, sync_status, original_username)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		"cfg-1", "Cfg One", items, 2000.0, "note", 1, now, now, "pending", "tester",
+	).Error; err != nil {
+		t.Fatalf("seed pre-migration data: %v", err)
+	}
+
+	migrationPath := filepath.Join("..", "..", "migrations", "006_add_local_configuration_versions.sql")
+	sqlBytes, err := os.ReadFile(migrationPath)
+	if err != nil {
+		t.Fatalf("read migration file: %v", err)
+	}
+	if err := execSQLScript(db, string(sqlBytes)); err != nil {
+		t.Fatalf("apply migration: %v", err)
+	}
+
+	var count int64
+	if err := db.Table("local_configuration_versions").Where("configuration_uuid = ?", "cfg-1").Count(&count).Error; err != nil {
+		t.Fatalf("count versions: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("expected 1 version, got %d", count)
+	}
+
+	var currentVersionID *string
+	if err := db.Table("local_configurations").Select("current_version_id").Where("uuid = ?", "cfg-1").Scan(&currentVersionID).Error; err != nil {
+		t.Fatalf("read current_version_id: %v", err)
+	}
+	if currentVersionID == nil || *currentVersionID == "" {
+		t.Fatalf("expected current_version_id to be set")
+	}
+
+	var row struct {
+		ID        string
+		VersionNo int
+		Data      string
+	}
+	if err := db.Table("local_configuration_versions").
+		Select("id, version_no, data").
+		Where("configuration_uuid = ?", "cfg-1").
+		First(&row).Error; err != nil {
+		t.Fatalf("load v1 row: %v", err)
+	}
+	if row.VersionNo != 1 {
+		t.Fatalf("expected version_no=1, got %d", row.VersionNo)
+	}
+	if row.ID != *currentVersionID {
+		t.Fatalf("expected current_version_id=%s, got %s", row.ID, *currentVersionID)
+	}
+
+	var snapshot map[string]any
+	if err := json.Unmarshal([]byte(row.Data), &snapshot); err != nil {
+		t.Fatalf("parse snapshot json: %v", err)
+	}
+	if snapshot["uuid"] != "cfg-1" {
+		t.Fatalf("expected snapshot uuid cfg-1, got %v", snapshot["uuid"])
+	}
+	if snapshot["name"] != "Cfg One" {
+		t.Fatalf("expected snapshot name Cfg One, got %v", snapshot["name"])
+	}
+}
+
+func execSQLScript(db *gorm.DB, script string) error {
+	var cleaned []string
+	for _, line := range strings.Split(script, "\n") {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "--") {
+			continue
+		}
+		cleaned = append(cleaned, line)
+	}
+
+	for _, stmt := range strings.Split(strings.Join(cleaned, "\n"), ";") {
+		sql := strings.TrimSpace(stmt)
+		if sql == "" {
+			continue
+		}
+		if err := db.Exec(sql).Error; err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/localdb/migrations.go

@@ -0,0 +1,141 @@
+package localdb
+
+import (
+	"fmt"
+	"log/slog"
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type LocalSchemaMigration struct {
+	ID        string    `gorm:"primaryKey;size:128"`
+	Name      string    `gorm:"not null;size:255"`
+	AppliedAt time.Time `gorm:"not null"`
+}
+
+func (LocalSchemaMigration) TableName() string {
+	return "local_schema_migrations"
+}
+
+type localMigration struct {
+	id   string
+	name string
+	run  func(tx *gorm.DB) error
+}
+
+var localMigrations = []localMigration{
+	{
+		id:   "2026_02_04_versioning_backfill",
+		name: "Ensure configuration versioning data and current pointers",
+		run:  backfillConfigurationVersions,
+	},
+	{
+		id:   "2026_02_04_is_active_backfill",
+		name: "Ensure is_active defaults to true for existing configurations",
+		run:  backfillConfigurationIsActive,
+	},
+}
+
+func runLocalMigrations(db *gorm.DB) error {
+	if err := db.AutoMigrate(&LocalSchemaMigration{}); err != nil {
+		return fmt.Errorf("migrate local schema migrations table: %w", err)
+	}
+
+	for _, migration := range localMigrations {
+		var count int64
+		if err := db.Model(&LocalSchemaMigration{}).Where("id = ?", migration.id).Count(&count).Error; err != nil {
+			return fmt.Errorf("check local migration %s: %w", migration.id, err)
+		}
+		if count > 0 {
+			continue
+		}
+
+		if err := db.Transaction(func(tx *gorm.DB) error {
+			if err := migration.run(tx); err != nil {
+				return fmt.Errorf("run migration %s: %w", migration.id, err)
+			}
+
+			record := &LocalSchemaMigration{
+				ID:        migration.id,
+				Name:      migration.name,
+				AppliedAt: time.Now(),
+			}
+			if err := tx.Create(record).Error; err != nil {
+				return fmt.Errorf("insert migration %s record: %w", migration.id, err)
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+
+		slog.Info("local migration applied", "id", migration.id, "name", migration.name)
+	}
+
+	return nil
+}
+
+func backfillConfigurationVersions(tx *gorm.DB) error {
+	var configs []LocalConfiguration
+	if err := tx.Find(&configs).Error; err != nil {
+		return fmt.Errorf("load local configurations for backfill: %w", err)
+	}
+
+	for i := range configs {
+		cfg := configs[i]
+		var versionCount int64
+		if err := tx.Model(&LocalConfigurationVersion{}).
+			Where("configuration_uuid = ?", cfg.UUID).
+			Count(&versionCount).Error; err != nil {
+			return fmt.Errorf("count versions for %s: %w", cfg.UUID, err)
+		}
+
+		if versionCount == 0 {
+			snapshot, err := BuildConfigurationSnapshot(&cfg)
+			if err != nil {
+				return fmt.Errorf("build initial snapshot for %s: %w", cfg.UUID, err)
+			}
+			note := "Initial snapshot backfill (v1)"
+			version := LocalConfigurationVersion{
+				ID:                uuid.NewString(),
+				ConfigurationUUID: cfg.UUID,
+				VersionNo:         1,
+				Data:              snapshot,
+				ChangeNote:        &note,
+				AppVersion:        "backfill",
+				CreatedAt:         chooseNonZeroTime(cfg.CreatedAt, time.Now()),
+			}
+			if err := tx.Create(&version).Error; err != nil {
+				return fmt.Errorf("create v1 backfill for %s: %w", cfg.UUID, err)
+			}
+		}
+
+		if cfg.CurrentVersionID == nil || *cfg.CurrentVersionID == "" {
+			var latest LocalConfigurationVersion
+			if err := tx.Where("configuration_uuid = ?", cfg.UUID).
+				Order("version_no DESC").
+				First(&latest).Error; err != nil {
+				return fmt.Errorf("load latest version for %s: %w", cfg.UUID, err)
+			}
+			if err := tx.Model(&LocalConfiguration{}).
+				Where("uuid = ?", cfg.UUID).
+				Update("current_version_id", latest.ID).Error; err != nil {
+				return fmt.Errorf("set current version for %s: %w", cfg.UUID, err)
+			}
+		}
+	}
+
+	return nil
+}
+
+func backfillConfigurationIsActive(tx *gorm.DB) error {
+	return tx.Exec("UPDATE local_configurations SET is_active = 1 WHERE is_active IS NULL").Error
+}
+
+func chooseNonZeroTime(candidate time.Time, fallback time.Time) time.Time {
+	if candidate.IsZero() {
+		return fallback
+	}
+	return candidate
+}

internal/localdb/models.go

@@ -59,36 +59,59 @@ func (c LocalConfigItems) Total() float64 {
 
 // LocalConfiguration stores configurations in local SQLite
 type LocalConfiguration struct {
-	ID             uint             `gorm:"primaryKey;autoIncrement" json:"id"`
-	UUID           string           `gorm:"uniqueIndex;not null" json:"uuid"`
-	ServerID       *uint            `json:"server_id"`        // ID on MariaDB server, NULL if local only
-	Name           string           `gorm:"not null" json:"name"`
-	Items          LocalConfigItems `gorm:"type:text" json:"items"` // JSON stored as text in SQLite
-	TotalPrice     *float64         `json:"total_price"`
-	CustomPrice    *float64         `json:"custom_price"`
-	Notes          string           `json:"notes"`
-	IsTemplate     bool             `gorm:"default:false" json:"is_template"`
-	ServerCount    int              `gorm:"default:1" json:"server_count"`
-	CreatedAt      time.Time        `json:"created_at"`
-	UpdatedAt      time.Time        `json:"updated_at"`
-	SyncedAt       *time.Time       `json:"synced_at"`
-	SyncStatus     string           `gorm:"default:'local'" json:"sync_status"` // 'local', 'synced', 'modified'
-	OriginalUserID uint             `json:"original_user_id"`                   // UserID from MariaDB for reference
+	ID               uint                        `gorm:"primaryKey;autoIncrement" json:"id"`
+	UUID             string                      `gorm:"uniqueIndex;not null" json:"uuid"`
+	ServerID         *uint                       `json:"server_id"` // ID on MariaDB server, NULL if local only
+	CurrentVersionID *string                     `gorm:"index" json:"current_version_id,omitempty"`
+	IsActive         bool                        `gorm:"default:true;index" json:"is_active"`
+	Name             string                      `gorm:"not null" json:"name"`
+	Items            LocalConfigItems            `gorm:"type:text" json:"items"` // JSON stored as text in SQLite
+	TotalPrice       *float64                    `json:"total_price"`
+	CustomPrice      *float64                    `json:"custom_price"`
+	Notes            string                      `json:"notes"`
+	IsTemplate       bool                        `gorm:"default:false" json:"is_template"`
+	ServerCount      int                         `gorm:"default:1" json:"server_count"`
+	PriceUpdatedAt   *time.Time                  `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
+	CreatedAt        time.Time                   `json:"created_at"`
+	UpdatedAt        time.Time                   `json:"updated_at"`
+	SyncedAt         *time.Time                  `json:"synced_at"`
+	SyncStatus       string                      `gorm:"default:'local'" json:"sync_status"` // 'local', 'synced', 'modified'
+	OriginalUserID   uint                        `json:"original_user_id"`                   // UserID from MariaDB for reference
+	OriginalUsername string                      `gorm:"not null;default:'';index" json:"original_username"`
+	CurrentVersion   *LocalConfigurationVersion  `gorm:"foreignKey:CurrentVersionID;references:ID" json:"current_version,omitempty"`
+	Versions         []LocalConfigurationVersion `gorm:"foreignKey:ConfigurationUUID;references:UUID" json:"versions,omitempty"`
 }
 
 func (LocalConfiguration) TableName() string {
 	return "local_configurations"
 }
 
+// LocalConfigurationVersion stores immutable full snapshots for each configuration version
+type LocalConfigurationVersion struct {
+	ID                string              `gorm:"primaryKey" json:"id"`
+	ConfigurationUUID string              `gorm:"not null;index:idx_lcv_config_created,priority:1;index:idx_lcv_config_version,priority:1;uniqueIndex:idx_lcv_config_version_unique,priority:1" json:"configuration_uuid"`
+	VersionNo         int                 `gorm:"not null;index:idx_lcv_config_version,sort:desc,priority:2;uniqueIndex:idx_lcv_config_version_unique,priority:2" json:"version_no"`
+	Data              string              `gorm:"type:text;not null" json:"data"`
+	ChangeNote        *string             `json:"change_note,omitempty"`
+	CreatedBy         *string             `json:"created_by,omitempty"`
+	AppVersion        string              `gorm:"size:64" json:"app_version,omitempty"`
+	CreatedAt         time.Time           `gorm:"not null;autoCreateTime;index:idx_lcv_config_created,sort:desc,priority:2" json:"created_at"`
+	Configuration     *LocalConfiguration `gorm:"foreignKey:ConfigurationUUID;references:UUID" json:"configuration,omitempty"`
+}
+
+func (LocalConfigurationVersion) TableName() string {
+	return "local_configuration_versions"
+}
+
 // LocalPricelist stores cached pricelists from server
 type LocalPricelist struct {
-	ID        uint       `gorm:"primaryKey;autoIncrement" json:"id"`
-	ServerID  uint       `gorm:"not null" json:"server_id"` // ID on MariaDB server
-	Version   string     `gorm:"uniqueIndex;not null" json:"version"`
-	Name      string     `json:"name"`
-	CreatedAt time.Time  `json:"created_at"`
-	SyncedAt  time.Time  `json:"synced_at"`
-	IsUsed    bool       `gorm:"default:false" json:"is_used"` // Used by any local configuration
+	ID        uint      `gorm:"primaryKey;autoIncrement" json:"id"`
+	ServerID  uint      `gorm:"not null" json:"server_id"` // ID on MariaDB server
+	Version   string    `gorm:"uniqueIndex;not null" json:"version"`
+	Name      string    `json:"name"`
+	CreatedAt time.Time `json:"created_at"`
+	SyncedAt  time.Time `json:"synced_at"`
+	IsUsed    bool      `gorm:"default:false" json:"is_used"` // Used by any local configuration
 }
 
 func (LocalPricelist) TableName() string {
@@ -126,7 +149,7 @@ type PendingChange struct {
 	ID         int64     `gorm:"primaryKey;autoIncrement" json:"id"`
 	EntityType string    `gorm:"not null;index" json:"entity_type"` // "configuration", "project", "specification"
 	EntityUUID string    `gorm:"not null;index" json:"entity_uuid"`
-	Operation  string    `gorm:"not null" json:"operation"` // "create", "update", "delete"
+	Operation  string    `gorm:"not null" json:"operation"` // "create", "update", "rollback", "deactivate", "reactivate", "delete"
 	Payload    string    `gorm:"type:text" json:"payload"`  // JSON snapshot of the entity
 	CreatedAt  time.Time `gorm:"not null" json:"created_at"`
 	Attempts   int       `gorm:"default:0" json:"attempts"` // Retry count for sync

internal/localdb/snapshots.go

@@ -0,0 +1,78 @@
+package localdb
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// BuildConfigurationSnapshot serializes the full local configuration state.
+func BuildConfigurationSnapshot(localCfg *LocalConfiguration) (string, error) {
+	snapshot := map[string]interface{}{
+		"id":                 localCfg.ID,
+		"uuid":               localCfg.UUID,
+		"server_id":          localCfg.ServerID,
+		"current_version_id": localCfg.CurrentVersionID,
+		"is_active":          localCfg.IsActive,
+		"name":               localCfg.Name,
+		"items":              localCfg.Items,
+		"total_price":        localCfg.TotalPrice,
+		"custom_price":       localCfg.CustomPrice,
+		"notes":              localCfg.Notes,
+		"is_template":        localCfg.IsTemplate,
+		"server_count":       localCfg.ServerCount,
+		"price_updated_at":   localCfg.PriceUpdatedAt,
+		"created_at":         localCfg.CreatedAt,
+		"updated_at":         localCfg.UpdatedAt,
+		"synced_at":          localCfg.SyncedAt,
+		"sync_status":        localCfg.SyncStatus,
+		"original_user_id":   localCfg.OriginalUserID,
+		"original_username":  localCfg.OriginalUsername,
+	}
+
+	data, err := json.Marshal(snapshot)
+	if err != nil {
+		return "", fmt.Errorf("marshal configuration snapshot: %w", err)
+	}
+	return string(data), nil
+}
+
+// DecodeConfigurationSnapshot returns editable fields from one saved snapshot.
+func DecodeConfigurationSnapshot(data string) (*LocalConfiguration, error) {
+	var snapshot struct {
+		IsActive         *bool            `json:"is_active"`
+		Name             string           `json:"name"`
+		Items            LocalConfigItems `json:"items"`
+		TotalPrice       *float64         `json:"total_price"`
+		CustomPrice      *float64         `json:"custom_price"`
+		Notes            string           `json:"notes"`
+		IsTemplate       bool             `json:"is_template"`
+		ServerCount      int              `json:"server_count"`
+		PriceUpdatedAt   *time.Time       `json:"price_updated_at"`
+		OriginalUserID   uint             `json:"original_user_id"`
+		OriginalUsername string           `json:"original_username"`
+	}
+
+	if err := json.Unmarshal([]byte(data), &snapshot); err != nil {
+		return nil, fmt.Errorf("unmarshal snapshot JSON: %w", err)
+	}
+
+	isActive := true
+	if snapshot.IsActive != nil {
+		isActive = *snapshot.IsActive
+	}
+
+	return &LocalConfiguration{
+		IsActive:         isActive,
+		Name:             snapshot.Name,
+		Items:            snapshot.Items,
+		TotalPrice:       snapshot.TotalPrice,
+		CustomPrice:      snapshot.CustomPrice,
+		Notes:            snapshot.Notes,
+		IsTemplate:       snapshot.IsTemplate,
+		ServerCount:      snapshot.ServerCount,
+		PriceUpdatedAt:   snapshot.PriceUpdatedAt,
+		OriginalUserID:   snapshot.OriginalUserID,
+		OriginalUsername: snapshot.OriginalUsername,
+	}, nil
+}

internal/middleware/auth.go

@@ -4,9 +4,9 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/gin-gonic/gin"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
 )
 
 const (
@@ -99,3 +99,12 @@ func GetUserID(c *gin.Context) uint {
 	}
 	return claims.UserID
 }
+
+// GetUsername extracts username from context
+func GetUsername(c *gin.Context) string {
+	claims := GetClaims(c)
+	if claims == nil {
+		return ""
+	}
+	return claims.Username
+}

internal/middleware/offline.go

@@ -4,17 +4,17 @@ import (
 	"log/slog"
 
 	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
-	"gorm.io/gorm"
 )
 
 // OfflineDetector creates middleware that detects offline mode
 // Sets context values:
 //   - "is_offline" (bool) - true if MariaDB is unavailable
 //   - "localdb" (*localdb.LocalDB) - local database instance for fallback
-func OfflineDetector(mariaDB *gorm.DB, local *localdb.LocalDB) gin.HandlerFunc {
+func OfflineDetector(connMgr *db.ConnectionManager, local *localdb.LocalDB) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		isOffline := !checkMariaDBOnline(mariaDB)
+		isOffline := !connMgr.IsOnline()
 
 		// Set context values for handlers
 		c.Set("is_offline", isOffline)
@@ -27,17 +27,3 @@ func OfflineDetector(mariaDB *gorm.DB, local *localdb.LocalDB) gin.HandlerFunc {
 		c.Next()
 	}
 }
-
-// checkMariaDBOnline checks if MariaDB is accessible
-func checkMariaDBOnline(mariaDB *gorm.DB) bool {
-	sqlDB, err := mariaDB.DB()
-	if err != nil {
-		return false
-	}
-
-	if err := sqlDB.Ping(); err != nil {
-		return false
-	}
-
-	return true
-}

internal/models/configuration.go

@@ -40,18 +40,20 @@ func (c ConfigItems) Total() float64 {
 }
 
 type Configuration struct {
-	ID               uint       `gorm:"primaryKey;autoIncrement" json:"id"`
-	UUID             string     `gorm:"size:36;uniqueIndex;not null" json:"uuid"`
-	UserID           uint       `gorm:"not null" json:"user_id"`
-	Name             string     `gorm:"size:200;not null" json:"name"`
-	Items            ConfigItems `gorm:"type:json;not null" json:"items"`
-	TotalPrice       *float64   `gorm:"type:decimal(12,2)" json:"total_price"`
-	CustomPrice      *float64   `gorm:"type:decimal(12,2)" json:"custom_price"`
-	Notes            string     `gorm:"type:text" json:"notes"`
-	IsTemplate       bool       `gorm:"default:false" json:"is_template"`
-	ServerCount      int        `gorm:"default:1" json:"server_count"`
-	PriceUpdatedAt   *time.Time `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
-	CreatedAt        time.Time  `gorm:"autoCreateTime" json:"created_at"`
+	ID             uint        `gorm:"primaryKey;autoIncrement" json:"id"`
+	UUID           string      `gorm:"size:36;uniqueIndex;not null" json:"uuid"`
+	UserID         *uint       `json:"user_id,omitempty"` // Legacy field, no longer required for ownership
+	OwnerUsername  string      `gorm:"size:100;not null;default:'';index" json:"owner_username"`
+	AppVersion     string      `gorm:"size:64" json:"app_version,omitempty"`
+	Name           string      `gorm:"size:200;not null" json:"name"`
+	Items          ConfigItems `gorm:"type:json;not null" json:"items"`
+	TotalPrice     *float64    `gorm:"type:decimal(12,2)" json:"total_price"`
+	CustomPrice    *float64    `gorm:"type:decimal(12,2)" json:"custom_price"`
+	Notes          string      `gorm:"type:text" json:"notes"`
+	IsTemplate     bool        `gorm:"default:false" json:"is_template"`
+	ServerCount    int         `gorm:"default:1" json:"server_count"`
+	PriceUpdatedAt *time.Time  `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
+	CreatedAt      time.Time   `gorm:"autoCreateTime" json:"created_at"`
 
 	User *User `gorm:"foreignKey:UserID" json:"user,omitempty"`
 }

internal/repository/configuration.go

@@ -19,7 +19,7 @@ func (r *ConfigurationRepository) Create(config *models.Configuration) error {
 
 func (r *ConfigurationRepository) GetByID(id uint) (*models.Configuration, error) {
 	var config models.Configuration
-	err := r.db.Preload("User").First(&config, id).Error
+	err := r.db.First(&config, id).Error
 	if err != nil {
 		return nil, err
 	}
@@ -28,7 +28,7 @@ func (r *ConfigurationRepository) GetByID(id uint) (*models.Configuration, error
 
 func (r *ConfigurationRepository) GetByUUID(uuid string) (*models.Configuration, error) {
 	var config models.Configuration
-	err := r.db.Preload("User").Where("uuid = ?", uuid).First(&config).Error
+	err := r.db.Where("uuid = ?", uuid).First(&config).Error
 	if err != nil {
 		return nil, err
 	}
@@ -43,13 +43,15 @@ func (r *ConfigurationRepository) Delete(id uint) error {
 	return r.db.Delete(&models.Configuration{}, id).Error
 }
 
-func (r *ConfigurationRepository) ListByUser(userID uint, offset, limit int) ([]models.Configuration, int64, error) {
+func (r *ConfigurationRepository) ListByUser(ownerUsername string, offset, limit int) ([]models.Configuration, int64, error) {
 	var configs []models.Configuration
 	var total int64
 
-	r.db.Model(&models.Configuration{}).Where("user_id = ?", userID).Count(&total)
+	ownerScope := "owner_username = ?"
+
+	r.db.Model(&models.Configuration{}).Where(ownerScope, ownerUsername).Count(&total)
 	err := r.db.
-		Where("user_id = ?", userID).
+		Where(ownerScope, ownerUsername).
 		Order("created_at DESC").
 		Offset(offset).
 		Limit(limit).
@@ -64,7 +66,6 @@ func (r *ConfigurationRepository) ListTemplates(offset, limit int) ([]models.Con
 
 	r.db.Model(&models.Configuration{}).Where("is_template = ?", true).Count(&total)
 	err := r.db.
-		Preload("User").
 		Where("is_template = ?", true).
 		Order("created_at DESC").
 		Offset(offset).

internal/repository/pricelist.go

@@ -29,6 +29,34 @@ func (r *PricelistRepository) List(offset, limit int) ([]models.PricelistSummary
 		return nil, 0, fmt.Errorf("listing pricelists: %w", err)
 	}
 
+	return r.toSummaries(pricelists), total, nil
+}
+
+// ListActive returns active pricelists with pagination.
+func (r *PricelistRepository) ListActive(offset, limit int) ([]models.PricelistSummary, int64, error) {
+	var total int64
+	if err := r.db.Model(&models.Pricelist{}).Where("is_active = ?", true).Count(&total).Error; err != nil {
+		return nil, 0, fmt.Errorf("counting active pricelists: %w", err)
+	}
+
+	var pricelists []models.Pricelist
+	if err := r.db.Where("is_active = ?", true).Order("created_at DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
+		return nil, 0, fmt.Errorf("listing active pricelists: %w", err)
+	}
+
+	return r.toSummaries(pricelists), total, nil
+}
+
+// CountActive returns the number of active pricelists.
+func (r *PricelistRepository) CountActive() (int64, error) {
+	var total int64
+	if err := r.db.Model(&models.Pricelist{}).Where("is_active = ?", true).Count(&total).Error; err != nil {
+		return 0, fmt.Errorf("counting active pricelists: %w", err)
+	}
+	return total, nil
+}
+
+func (r *PricelistRepository) toSummaries(pricelists []models.Pricelist) []models.PricelistSummary {
 	// Get item counts for each pricelist
 	summaries := make([]models.PricelistSummary, len(pricelists))
 	for i, pl := range pricelists {
@@ -48,7 +76,7 @@ func (r *PricelistRepository) List(offset, limit int) ([]models.PricelistSummary
 		}
 	}
 
-	return summaries, total, nil
+	return summaries
 }
 
 // GetByID returns a pricelist by ID

internal/repository/unified.go

@@ -19,7 +19,7 @@ type DataSource interface {
 
 	// Configurations
 	SaveConfiguration(cfg *models.Configuration) error
-	GetConfigurations(userID uint) ([]models.Configuration, error)
+	GetConfigurations(ownerUsername string) ([]models.Configuration, error)
 	GetConfigurationByUUID(uuid string) (*models.Configuration, error)
 	DeleteConfiguration(uuid string) error
 
@@ -159,16 +159,17 @@ func (r *UnifiedRepo) SaveConfiguration(cfg *models.Configuration) error {
 
 	// Offline: save to local SQLite and queue for sync
 	localCfg := &localdb.LocalConfiguration{
-		UUID:        cfg.UUID,
-		Name:        cfg.Name,
-		TotalPrice:  cfg.TotalPrice,
-		CustomPrice: cfg.CustomPrice,
-		Notes:       cfg.Notes,
-		IsTemplate:  cfg.IsTemplate,
-		ServerCount: cfg.ServerCount,
-		CreatedAt:   cfg.CreatedAt,
-		UpdatedAt:   time.Now(),
-		SyncStatus:  "pending",
+		UUID:             cfg.UUID,
+		Name:             cfg.Name,
+		TotalPrice:       cfg.TotalPrice,
+		CustomPrice:      cfg.CustomPrice,
+		Notes:            cfg.Notes,
+		IsTemplate:       cfg.IsTemplate,
+		ServerCount:      cfg.ServerCount,
+		CreatedAt:        cfg.CreatedAt,
+		UpdatedAt:        time.Now(),
+		SyncStatus:       "pending",
+		OriginalUsername: cfg.OwnerUsername,
 	}
 
 	// Convert items
@@ -196,10 +197,10 @@ func (r *UnifiedRepo) SaveConfiguration(cfg *models.Configuration) error {
 }
 
 // GetConfigurations returns all configurations for a user
-func (r *UnifiedRepo) GetConfigurations(userID uint) ([]models.Configuration, error) {
+func (r *UnifiedRepo) GetConfigurations(ownerUsername string) ([]models.Configuration, error) {
 	if r.isOnline {
 		repo := NewConfigurationRepository(r.mariaDB)
-		configs, _, err := repo.ListByUser(userID, 0, 1000)
+		configs, _, err := repo.ListByUser(ownerUsername, 0, 1000)
 		return configs, err
 	}
 
@@ -222,15 +223,16 @@ func (r *UnifiedRepo) GetConfigurations(userID uint) ([]models.Configuration, er
 		}
 
 		result[i] = models.Configuration{
-			UUID:        lc.UUID,
-			Name:        lc.Name,
-			Items:       items,
-			TotalPrice:  lc.TotalPrice,
-			CustomPrice: lc.CustomPrice,
-			Notes:       lc.Notes,
-			IsTemplate:  lc.IsTemplate,
-			ServerCount: lc.ServerCount,
-			CreatedAt:   lc.CreatedAt,
+			UUID:          lc.UUID,
+			OwnerUsername: lc.OriginalUsername,
+			Name:          lc.Name,
+			Items:         items,
+			TotalPrice:    lc.TotalPrice,
+			CustomPrice:   lc.CustomPrice,
+			Notes:         lc.Notes,
+			IsTemplate:    lc.IsTemplate,
+			ServerCount:   lc.ServerCount,
+			CreatedAt:     lc.CreatedAt,
 		}
 	}
 

internal/services/component.go

@@ -1,6 +1,7 @@
 package services
 
 import (
+	"fmt"
 	"strings"
 
 	"git.mchus.pro/mchus/quoteforge/internal/models"
@@ -59,6 +60,17 @@ type ComponentView struct {
 }
 
 func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage int) (*ComponentListResult, error) {
+	// If no database connection (offline mode), return empty list
+	// Components should be loaded via /api/sync/components first
+	if s.componentRepo == nil {
+		return &ComponentListResult{
+			Components: []ComponentView{},
+			Total:      0,
+			Page:       page,
+			PerPage:    perPage,
+		}, nil
+	}
+
 	if page < 1 {
 		page = 1
 	}
@@ -106,6 +118,11 @@ func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage
 }
 
 func (s *ComponentService) GetByLotName(lotName string) (*ComponentView, error) {
+	// If no database connection (offline mode), return error
+	if s.componentRepo == nil {
+		return nil, fmt.Errorf("offline mode: component data not available")
+	}
+
 	c, err := s.componentRepo.GetByLotName(lotName)
 	if err != nil {
 		return nil, err
@@ -135,11 +152,20 @@ func (s *ComponentService) GetByLotName(lotName string) (*ComponentView, error)
 }
 
 func (s *ComponentService) GetCategories() ([]models.Category, error) {
+	// If no database connection (offline mode), return default categories
+	if s.categoryRepo == nil {
+		return models.DefaultCategories, nil
+	}
 	return s.categoryRepo.GetAll()
 }
 
 // ImportFromLot creates metadata entries for lots that don't have them
 func (s *ComponentService) ImportFromLot() (int, error) {
+	// If no database connection (offline mode), return error
+	if s.componentRepo == nil || s.categoryRepo == nil {
+		return 0, fmt.Errorf("offline mode: import not available")
+	}
+
 	lots, err := s.componentRepo.GetLotsWithoutMetadata()
 	if err != nil {
 		return 0, err

internal/services/configuration.go

@@ -4,20 +4,20 @@ import (
 	"errors"
 	"time"
 
-	"github.com/google/uuid"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"github.com/google/uuid"
 )
 
 var (
-	ErrConfigNotFound   = errors.New("configuration not found")
-	ErrConfigForbidden  = errors.New("access to configuration forbidden")
+	ErrConfigNotFound  = errors.New("configuration not found")
+	ErrConfigForbidden = errors.New("access to configuration forbidden")
 )
 
 // ConfigurationGetter is an interface for services that can retrieve configurations
 // Used by handlers to work with both ConfigurationService and LocalConfigurationService
 type ConfigurationGetter interface {
-	GetByUUID(uuid string, userID uint) (*models.Configuration, error)
+	GetByUUID(uuid string, ownerUsername string) (*models.Configuration, error)
 }
 
 type ConfigurationService struct {
@@ -39,15 +39,15 @@ func NewConfigurationService(
 }
 
 type CreateConfigRequest struct {
-	Name        string              `json:"name"`
-	Items       models.ConfigItems  `json:"items"`
-	CustomPrice *float64            `json:"custom_price"`
-	Notes       string              `json:"notes"`
-	IsTemplate  bool                `json:"is_template"`
-	ServerCount int                 `json:"server_count"`
+	Name        string             `json:"name"`
+	Items       models.ConfigItems `json:"items"`
+	CustomPrice *float64           `json:"custom_price"`
+	Notes       string             `json:"notes"`
+	IsTemplate  bool               `json:"is_template"`
+	ServerCount int                `json:"server_count"`
 }
 
-func (s *ConfigurationService) Create(userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+func (s *ConfigurationService) Create(ownerUsername string, req *CreateConfigRequest) (*models.Configuration, error) {
 	total := req.Items.Total()
 
 	// If server count is greater than 1, multiply the total by server count
@@ -56,15 +56,15 @@ func (s *ConfigurationService) Create(userID uint, req *CreateConfigRequest) (*m
 	}
 
 	config := &models.Configuration{
-		UUID:        uuid.New().String(),
-		UserID:      userID,
-		Name:        req.Name,
-		Items:       req.Items,
-		TotalPrice:  &total,
-		CustomPrice: req.CustomPrice,
-		Notes:       req.Notes,
-		IsTemplate:  req.IsTemplate,
-		ServerCount: req.ServerCount,
+		UUID:          uuid.New().String(),
+		OwnerUsername: ownerUsername,
+		Name:          req.Name,
+		Items:         req.Items,
+		TotalPrice:    &total,
+		CustomPrice:   req.CustomPrice,
+		Notes:         req.Notes,
+		IsTemplate:    req.IsTemplate,
+		ServerCount:   req.ServerCount,
 	}
 
 	if err := s.configRepo.Create(config); err != nil {
@@ -77,27 +77,27 @@ func (s *ConfigurationService) Create(userID uint, req *CreateConfigRequest) (*m
 	return config, nil
 }
 
-func (s *ConfigurationService) GetByUUID(uuid string, userID uint) (*models.Configuration, error) {
+func (s *ConfigurationService) GetByUUID(uuid string, ownerUsername string) (*models.Configuration, error) {
 	config, err := s.configRepo.GetByUUID(uuid)
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
 
 	// Allow access if user owns config or it's a template
-	if config.UserID != userID && !config.IsTemplate {
+	if !s.isOwner(config, ownerUsername) && !config.IsTemplate {
 		return nil, ErrConfigForbidden
 	}
 
 	return config, nil
 }
 
-func (s *ConfigurationService) Update(uuid string, userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+func (s *ConfigurationService) Update(uuid string, ownerUsername string, req *CreateConfigRequest) (*models.Configuration, error) {
 	config, err := s.configRepo.GetByUUID(uuid)
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
 
-	if config.UserID != userID {
+	if !s.isOwner(config, ownerUsername) {
 		return nil, ErrConfigForbidden
 	}
 
@@ -123,26 +123,26 @@ func (s *ConfigurationService) Update(uuid string, userID uint, req *CreateConfi
 	return config, nil
 }
 
-func (s *ConfigurationService) Delete(uuid string, userID uint) error {
+func (s *ConfigurationService) Delete(uuid string, ownerUsername string) error {
 	config, err := s.configRepo.GetByUUID(uuid)
 	if err != nil {
 		return ErrConfigNotFound
 	}
 
-	if config.UserID != userID {
+	if !s.isOwner(config, ownerUsername) {
 		return ErrConfigForbidden
 	}
 
 	return s.configRepo.Delete(config.ID)
 }
 
-func (s *ConfigurationService) Rename(uuid string, userID uint, newName string) (*models.Configuration, error) {
+func (s *ConfigurationService) Rename(uuid string, ownerUsername string, newName string) (*models.Configuration, error) {
 	config, err := s.configRepo.GetByUUID(uuid)
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
 
-	if config.UserID != userID {
+	if !s.isOwner(config, ownerUsername) {
 		return nil, ErrConfigForbidden
 	}
 
@@ -155,8 +155,8 @@ func (s *ConfigurationService) Rename(uuid string, userID uint, newName string)
 	return config, nil
 }
 
-func (s *ConfigurationService) Clone(configUUID string, userID uint, newName string) (*models.Configuration, error) {
-	original, err := s.GetByUUID(configUUID, userID)
+func (s *ConfigurationService) Clone(configUUID string, ownerUsername string, newName string) (*models.Configuration, error) {
+	original, err := s.GetByUUID(configUUID, ownerUsername)
 	if err != nil {
 		return nil, err
 	}
@@ -170,15 +170,15 @@ func (s *ConfigurationService) Clone(configUUID string, userID uint, newName str
 	}
 
 	clone := &models.Configuration{
-		UUID:        uuid.New().String(),
-		UserID:      userID,
-		Name:        newName,
-		Items:       original.Items,
-		TotalPrice:  &total,
-		CustomPrice: original.CustomPrice,
-		Notes:       original.Notes,
-		IsTemplate:  false, // Clone is never a template
-		ServerCount: original.ServerCount,
+		UUID:          uuid.New().String(),
+		OwnerUsername: ownerUsername,
+		Name:          newName,
+		Items:         original.Items,
+		TotalPrice:    &total,
+		CustomPrice:   original.CustomPrice,
+		Notes:         original.Notes,
+		IsTemplate:    false, // Clone is never a template
+		ServerCount:   original.ServerCount,
 	}
 
 	if err := s.configRepo.Create(clone); err != nil {
@@ -188,7 +188,7 @@ func (s *ConfigurationService) Clone(configUUID string, userID uint, newName str
 	return clone, nil
 }
 
-func (s *ConfigurationService) ListByUser(userID uint, page, perPage int) ([]models.Configuration, int64, error) {
+func (s *ConfigurationService) ListByUser(ownerUsername string, page, perPage int) ([]models.Configuration, int64, error) {
 	if page < 1 {
 		page = 1
 	}
@@ -197,7 +197,7 @@ func (s *ConfigurationService) ListByUser(userID uint, page, perPage int) ([]mod
 	}
 	offset := (page - 1) * perPage
 
-	return s.configRepo.ListByUser(userID, offset, perPage)
+	return s.configRepo.ListByUser(ownerUsername, offset, perPage)
 }
 
 // ListAll returns all configurations without user filter (for use when auth is disabled)
@@ -274,7 +274,7 @@ func (s *ConfigurationService) RenameNoAuth(uuid string, newName string) (*model
 }
 
 // CloneNoAuth clones configuration without ownership check
-func (s *ConfigurationService) CloneNoAuth(configUUID string, newName string, userID uint) (*models.Configuration, error) {
+func (s *ConfigurationService) CloneNoAuth(configUUID string, newName string, ownerUsername string) (*models.Configuration, error) {
 	original, err := s.configRepo.GetByUUID(configUUID)
 	if err != nil {
 		return nil, ErrConfigNotFound
@@ -286,15 +286,15 @@ func (s *ConfigurationService) CloneNoAuth(configUUID string, newName string, us
 	}
 
 	clone := &models.Configuration{
-		UUID:        uuid.New().String(),
-		UserID:      userID, // Use provided user ID
-		Name:        newName,
-		Items:       original.Items,
-		TotalPrice:  &total,
-		CustomPrice: original.CustomPrice,
-		Notes:       original.Notes,
-		IsTemplate:  false,
-		ServerCount: original.ServerCount,
+		UUID:          uuid.New().String(),
+		OwnerUsername: ownerUsername,
+		Name:          newName,
+		Items:         original.Items,
+		TotalPrice:    &total,
+		CustomPrice:   original.CustomPrice,
+		Notes:         original.Notes,
+		IsTemplate:    false,
+		ServerCount:   original.ServerCount,
 	}
 
 	if err := s.configRepo.Create(clone); err != nil {
@@ -356,13 +356,13 @@ func (s *ConfigurationService) ListTemplates(page, perPage int) ([]models.Config
 }
 
 // RefreshPrices updates all component prices in the configuration with current prices
-func (s *ConfigurationService) RefreshPrices(uuid string, userID uint) (*models.Configuration, error) {
+func (s *ConfigurationService) RefreshPrices(uuid string, ownerUsername string) (*models.Configuration, error) {
 	config, err := s.configRepo.GetByUUID(uuid)
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
 
-	if config.UserID != userID {
+	if !s.isOwner(config, ownerUsername) {
 		return nil, ErrConfigForbidden
 	}
 
@@ -407,6 +407,19 @@ func (s *ConfigurationService) RefreshPrices(uuid string, userID uint) (*models.
 	return config, nil
 }
 
+func (s *ConfigurationService) isOwner(config *models.Configuration, ownerUsername string) bool {
+	if config == nil || ownerUsername == "" {
+		return false
+	}
+	if config.OwnerUsername != "" {
+		return config.OwnerUsername == ownerUsername
+	}
+	if config.User != nil {
+		return config.User.Username == ownerUsername
+	}
+	return false
+}
+
 // // Export configuration as JSON
 // type ConfigExport struct {
 // 	Name  string             `json:"name"`

internal/services/local_configuration.go

@@ -3,12 +3,23 @@ package services
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
+	"strings"
 	"time"
 
-	"github.com/google/uuid"
+	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+var (
+	ErrConfigVersionNotFound = errors.New("configuration version not found")
+	ErrInvalidVersionNumber  = errors.New("invalid version number")
+	ErrVersionConflict       = errors.New("configuration version conflict")
 )
 
 // LocalConfigurationService handles configurations in local-first mode
@@ -36,7 +47,7 @@ func NewLocalConfigurationService(
 }
 
 // Create creates a new configuration in local SQLite and queues it for sync
-func (s *LocalConfigurationService) Create(userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+func (s *LocalConfigurationService) Create(ownerUsername string, req *CreateConfigRequest) (*models.Configuration, error) {
 	// If online, check for new pricelists first
 	if s.isOnline() {
 		if err := s.syncService.SyncPricelistsIfNeeded(); err != nil {
@@ -50,33 +61,23 @@ func (s *LocalConfigurationService) Create(userID uint, req *CreateConfigRequest
 	}
 
 	cfg := &models.Configuration{
-		UUID:        uuid.New().String(),
-		UserID:      userID,
-		Name:        req.Name,
-		Items:       req.Items,
-		TotalPrice:  &total,
-		CustomPrice: req.CustomPrice,
-		Notes:       req.Notes,
-		IsTemplate:  req.IsTemplate,
-		ServerCount: req.ServerCount,
-		CreatedAt:   time.Now(),
+		UUID:          uuid.New().String(),
+		OwnerUsername: ownerUsername,
+		Name:          req.Name,
+		Items:         req.Items,
+		TotalPrice:    &total,
+		CustomPrice:   req.CustomPrice,
+		Notes:         req.Notes,
+		IsTemplate:    req.IsTemplate,
+		ServerCount:   req.ServerCount,
+		CreatedAt:     time.Now(),
 	}
 
 	// Convert to local model
 	localCfg := localdb.ConfigurationToLocal(cfg)
 
-	// Save to local SQLite
-	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
-		return nil, err
-	}
-
-	// Add to pending sync queue
-	payload, err := json.Marshal(cfg)
-	if err != nil {
-		return nil, err
-	}
-	if err := s.localDB.AddPendingChange("configuration", cfg.UUID, "create", string(payload)); err != nil {
-		return nil, err
+	if err := s.createWithVersion(localCfg, ownerUsername); err != nil {
+		return nil, fmt.Errorf("create configuration with version: %w", err)
 	}
 
 	// Record usage stats
@@ -86,17 +87,20 @@ func (s *LocalConfigurationService) Create(userID uint, req *CreateConfigRequest
 }
 
 // GetByUUID returns a configuration from local SQLite
-func (s *LocalConfigurationService) GetByUUID(uuid string, userID uint) (*models.Configuration, error) {
+func (s *LocalConfigurationService) GetByUUID(uuid string, ownerUsername string) (*models.Configuration, error) {
 	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
+	if !localCfg.IsActive {
+		return nil, ErrConfigNotFound
+	}
 
 	// Convert to models.Configuration
 	cfg := localdb.LocalToConfiguration(localCfg)
 
 	// Allow access if user owns config or it's a template
-	if cfg.UserID != userID && !cfg.IsTemplate {
+	if !s.isOwner(localCfg, ownerUsername) && !cfg.IsTemplate {
 		return nil, ErrConfigForbidden
 	}
 
@@ -104,13 +108,13 @@ func (s *LocalConfigurationService) GetByUUID(uuid string, userID uint) (*models
 }
 
 // Update updates a configuration in local SQLite and queues it for sync
-func (s *LocalConfigurationService) Update(uuid string, userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+func (s *LocalConfigurationService) Update(uuid string, ownerUsername string, req *CreateConfigRequest) (*models.Configuration, error) {
 	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
 
-	if localCfg.OriginalUserID != userID {
+	if !s.isOwner(localCfg, ownerUsername) {
 		return nil, ErrConfigForbidden
 	}
 
@@ -137,56 +141,59 @@ func (s *LocalConfigurationService) Update(uuid string, userID uint, req *Create
 	localCfg.UpdatedAt = time.Now()
 	localCfg.SyncStatus = "pending"
 
-	// Save to local SQLite
-	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
-		return nil, err
-	}
-
-	// Add to pending sync queue
-	cfg := localdb.LocalToConfiguration(localCfg)
-	payload, err := json.Marshal(cfg)
+	cfg, err := s.saveWithVersionAndPending(localCfg, "update", ownerUsername)
 	if err != nil {
-		return nil, err
-	}
-	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("update configuration with version: %w", err)
 	}
 
 	return cfg, nil
 }
 
 // Delete deletes a configuration from local SQLite and queues it for sync
-func (s *LocalConfigurationService) Delete(uuid string, userID uint) error {
+func (s *LocalConfigurationService) Delete(uuid string, ownerUsername string) error {
 	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
 	if err != nil {
 		return ErrConfigNotFound
 	}
 
-	if localCfg.OriginalUserID != userID {
+	if !s.isOwner(localCfg, ownerUsername) {
 		return ErrConfigForbidden
 	}
 
-	// Delete from local SQLite
-	if err := s.localDB.DeleteConfiguration(uuid); err != nil {
-		return err
+	localCfg.IsActive = false
+	localCfg.UpdatedAt = time.Now()
+	localCfg.SyncStatus = "pending"
+	_, err = s.saveWithVersionAndPending(localCfg, "deactivate", ownerUsername)
+	return err
+}
+
+// Reactivate restores an archived configuration and creates a new version.
+func (s *LocalConfigurationService) Reactivate(uuid string, ownerUsername string) (*models.Configuration, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+	if !s.isOwner(localCfg, ownerUsername) {
+		return nil, ErrConfigForbidden
+	}
+	if localCfg.IsActive {
+		return localdb.LocalToConfiguration(localCfg), nil
 	}
 
-	// Add to pending sync queue
-	if err := s.localDB.AddPendingChange("configuration", uuid, "delete", ""); err != nil {
-		return err
-	}
-
-	return nil
+	localCfg.IsActive = true
+	localCfg.UpdatedAt = time.Now()
+	localCfg.SyncStatus = "pending"
+	return s.saveWithVersionAndPending(localCfg, "reactivate", ownerUsername)
 }
 
 // Rename renames a configuration
-func (s *LocalConfigurationService) Rename(uuid string, userID uint, newName string) (*models.Configuration, error) {
+func (s *LocalConfigurationService) Rename(uuid string, ownerUsername string, newName string) (*models.Configuration, error) {
 	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
 
-	if localCfg.OriginalUserID != userID {
+	if !s.isOwner(localCfg, ownerUsername) {
 		return nil, ErrConfigForbidden
 	}
 
@@ -194,26 +201,16 @@ func (s *LocalConfigurationService) Rename(uuid string, userID uint, newName str
 	localCfg.UpdatedAt = time.Now()
 	localCfg.SyncStatus = "pending"
 
-	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
-		return nil, err
-	}
-
-	// Add to pending sync queue
-	cfg := localdb.LocalToConfiguration(localCfg)
-	payload, err := json.Marshal(cfg)
+	cfg, err := s.saveWithVersionAndPending(localCfg, "update", ownerUsername)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("rename configuration with version: %w", err)
 	}
-	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
-		return nil, err
-	}
-
 	return cfg, nil
 }
 
 // Clone clones a configuration
-func (s *LocalConfigurationService) Clone(configUUID string, userID uint, newName string) (*models.Configuration, error) {
-	original, err := s.GetByUUID(configUUID, userID)
+func (s *LocalConfigurationService) Clone(configUUID string, ownerUsername string, newName string) (*models.Configuration, error) {
+	original, err := s.GetByUUID(configUUID, ownerUsername)
 	if err != nil {
 		return nil, err
 	}
@@ -224,37 +221,32 @@ func (s *LocalConfigurationService) Clone(configUUID string, userID uint, newNam
 	}
 
 	clone := &models.Configuration{
-		UUID:        uuid.New().String(),
-		UserID:      userID,
-		Name:        newName,
-		Items:       original.Items,
-		TotalPrice:  &total,
-		CustomPrice: original.CustomPrice,
-		Notes:       original.Notes,
-		IsTemplate:  false,
-		ServerCount: original.ServerCount,
-		CreatedAt:   time.Now(),
+		UUID:          uuid.New().String(),
+		OwnerUsername: ownerUsername,
+		Name:          newName,
+		Items:         original.Items,
+		TotalPrice:    &total,
+		CustomPrice:   original.CustomPrice,
+		Notes:         original.Notes,
+		IsTemplate:    false,
+		ServerCount:   original.ServerCount,
+		CreatedAt:     time.Now(),
 	}
 
 	localCfg := localdb.ConfigurationToLocal(clone)
-	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
-		return nil, err
-	}
-
-	// Add to pending sync queue
-	payload, err := json.Marshal(clone)
-	if err != nil {
-		return nil, err
-	}
-	if err := s.localDB.AddPendingChange("configuration", clone.UUID, "create", string(payload)); err != nil {
-		return nil, err
+	if err := s.createWithVersion(localCfg, ownerUsername); err != nil {
+		return nil, fmt.Errorf("clone configuration with version: %w", err)
 	}
 
 	return clone, nil
 }
 
 // ListByUser returns all configurations for a user from local SQLite
-func (s *LocalConfigurationService) ListByUser(userID uint, page, perPage int) ([]models.Configuration, int64, error) {
+func (s *LocalConfigurationService) ListByUser(ownerUsername string, page, perPage int) ([]models.Configuration, int64, error) {
+	return s.listByUserWithStatus(ownerUsername, page, perPage, "active")
+}
+
+func (s *LocalConfigurationService) listByUserWithStatus(ownerUsername string, page, perPage int, status string) ([]models.Configuration, int64, error) {
 	// Get all local configurations
 	localConfigs, err := s.localDB.GetConfigurations()
 	if err != nil {
@@ -264,7 +256,10 @@ func (s *LocalConfigurationService) ListByUser(userID uint, page, perPage int) (
 	// Filter by user
 	var userConfigs []models.Configuration
 	for _, lc := range localConfigs {
-		if lc.OriginalUserID == userID || lc.IsTemplate {
+		if !matchesConfigStatus(lc.IsActive, status) {
+			continue
+		}
+		if (lc.OriginalUsername == ownerUsername) || lc.IsTemplate {
 			userConfigs = append(userConfigs, *localdb.LocalToConfiguration(&lc))
 		}
 	}
@@ -292,11 +287,60 @@ func (s *LocalConfigurationService) ListByUser(userID uint, page, perPage int) (
 	return userConfigs[start:end], total, nil
 }
 
-// RefreshPrices updates all component prices in the configuration
-func (s *LocalConfigurationService) RefreshPrices(uuid string, userID uint) (*models.Configuration, error) {
-	// This requires access to component prices from local cache
-	// For now, return error as we need to implement component price lookup from local cache
-	return nil, errors.New("refresh prices not yet implemented for local-first mode")
+// RefreshPrices updates all component prices in the configuration from local cache
+func (s *LocalConfigurationService) RefreshPrices(uuid string, ownerUsername string) (*models.Configuration, error) {
+	// Get configuration from local SQLite
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	// Check ownership
+	if !s.isOwner(localCfg, ownerUsername) {
+		return nil, ErrConfigForbidden
+	}
+
+	// Update prices for all items
+	updatedItems := make(localdb.LocalConfigItems, len(localCfg.Items))
+	for i, item := range localCfg.Items {
+		// Get current component price from local cache
+		component, err := s.localDB.GetLocalComponent(item.LotName)
+		if err != nil || component.CurrentPrice == nil {
+			// Keep original item if component not found or no price available
+			updatedItems[i] = item
+			continue
+		}
+
+		// Update item with current price from local cache
+		updatedItems[i] = localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: *component.CurrentPrice,
+		}
+	}
+
+	// Update configuration
+	localCfg.Items = updatedItems
+	total := updatedItems.Total()
+
+	// If server count is greater than 1, multiply the total by server count
+	if localCfg.ServerCount > 1 {
+		total *= float64(localCfg.ServerCount)
+	}
+
+	localCfg.TotalPrice = &total
+
+	// Set price update timestamp and mark for sync
+	now := time.Now()
+	localCfg.PriceUpdatedAt = &now
+	localCfg.UpdatedAt = now
+	localCfg.SyncStatus = "pending"
+
+	cfg, err := s.saveWithVersionAndPending(localCfg, "update", ownerUsername)
+	if err != nil {
+		return nil, fmt.Errorf("refresh prices with version: %w", err)
+	}
+	return cfg, nil
 }
 
 // GetByUUIDNoAuth returns configuration without ownership check
@@ -305,6 +349,9 @@ func (s *LocalConfigurationService) GetByUUIDNoAuth(uuid string) (*models.Config
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
+	if !localCfg.IsActive {
+		return nil, ErrConfigNotFound
+	}
 	return localdb.LocalToConfiguration(localCfg), nil
 }
 
@@ -337,28 +384,40 @@ func (s *LocalConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigR
 	localCfg.UpdatedAt = time.Now()
 	localCfg.SyncStatus = "pending"
 
-	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
-		return nil, err
-	}
-
-	cfg := localdb.LocalToConfiguration(localCfg)
-	payload, err := json.Marshal(cfg)
+	cfg, err := s.saveWithVersionAndPending(localCfg, "update", "")
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("update configuration without auth with version: %w", err)
 	}
-	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
-		return nil, err
-	}
-
 	return cfg, nil
 }
 
 // DeleteNoAuth deletes configuration without ownership check
 func (s *LocalConfigurationService) DeleteNoAuth(uuid string) error {
-	if err := s.localDB.DeleteConfiguration(uuid); err != nil {
-		return err
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return ErrConfigNotFound
 	}
-	return s.localDB.AddPendingChange("configuration", uuid, "delete", "")
+	localCfg.IsActive = false
+	localCfg.UpdatedAt = time.Now()
+	localCfg.SyncStatus = "pending"
+	_, err = s.saveWithVersionAndPending(localCfg, "deactivate", "")
+	return err
+}
+
+// ReactivateNoAuth restores an archived configuration without ownership check.
+func (s *LocalConfigurationService) ReactivateNoAuth(uuid string) (*models.Configuration, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+	if localCfg.IsActive {
+		return localdb.LocalToConfiguration(localCfg), nil
+	}
+
+	localCfg.IsActive = true
+	localCfg.UpdatedAt = time.Now()
+	localCfg.SyncStatus = "pending"
+	return s.saveWithVersionAndPending(localCfg, "reactivate", "")
 }
 
 // RenameNoAuth renames configuration without ownership check
@@ -372,24 +431,15 @@ func (s *LocalConfigurationService) RenameNoAuth(uuid string, newName string) (*
 	localCfg.UpdatedAt = time.Now()
 	localCfg.SyncStatus = "pending"
 
-	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
-		return nil, err
-	}
-
-	cfg := localdb.LocalToConfiguration(localCfg)
-	payload, err := json.Marshal(cfg)
+	cfg, err := s.saveWithVersionAndPending(localCfg, "update", "")
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("rename configuration without auth with version: %w", err)
 	}
-	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
-		return nil, err
-	}
-
 	return cfg, nil
 }
 
 // CloneNoAuth clones configuration without ownership check
-func (s *LocalConfigurationService) CloneNoAuth(configUUID string, newName string, userID uint) (*models.Configuration, error) {
+func (s *LocalConfigurationService) CloneNoAuth(configUUID string, newName string, ownerUsername string) (*models.Configuration, error) {
 	original, err := s.GetByUUIDNoAuth(configUUID)
 	if err != nil {
 		return nil, err
@@ -401,29 +451,21 @@ func (s *LocalConfigurationService) CloneNoAuth(configUUID string, newName strin
 	}
 
 	clone := &models.Configuration{
-		UUID:        uuid.New().String(),
-		UserID:      userID,
-		Name:        newName,
-		Items:       original.Items,
-		TotalPrice:  &total,
-		CustomPrice: original.CustomPrice,
-		Notes:       original.Notes,
-		IsTemplate:  false,
-		ServerCount: original.ServerCount,
-		CreatedAt:   time.Now(),
+		UUID:          uuid.New().String(),
+		OwnerUsername: ownerUsername,
+		Name:          newName,
+		Items:         original.Items,
+		TotalPrice:    &total,
+		CustomPrice:   original.CustomPrice,
+		Notes:         original.Notes,
+		IsTemplate:    false,
+		ServerCount:   original.ServerCount,
+		CreatedAt:     time.Now(),
 	}
 
 	localCfg := localdb.ConfigurationToLocal(clone)
-	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
-		return nil, err
-	}
-
-	payload, err := json.Marshal(clone)
-	if err != nil {
-		return nil, err
-	}
-	if err := s.localDB.AddPendingChange("configuration", clone.UUID, "create", string(payload)); err != nil {
-		return nil, err
+	if err := s.createWithVersion(localCfg, ownerUsername); err != nil {
+		return nil, fmt.Errorf("clone configuration without auth with version: %w", err)
 	}
 
 	return clone, nil
@@ -431,14 +473,23 @@ func (s *LocalConfigurationService) CloneNoAuth(configUUID string, newName strin
 
 // ListAll returns all configurations without user filter
 func (s *LocalConfigurationService) ListAll(page, perPage int) ([]models.Configuration, int64, error) {
+	return s.ListAllWithStatus(page, perPage, "active")
+}
+
+// ListAllWithStatus returns configurations filtered by status: active|archived|all.
+func (s *LocalConfigurationService) ListAllWithStatus(page, perPage int, status string) ([]models.Configuration, int64, error) {
 	localConfigs, err := s.localDB.GetConfigurations()
 	if err != nil {
 		return nil, 0, err
 	}
 
 	configs := make([]models.Configuration, len(localConfigs))
-	for i, lc := range localConfigs {
-		configs[i] = *localdb.LocalToConfiguration(&lc)
+	configs = configs[:0]
+	for _, lc := range localConfigs {
+		if !matchesConfigStatus(lc.IsActive, status) {
+			continue
+		}
+		configs = append(configs, *localdb.LocalToConfiguration(&lc))
 	}
 
 	total := int64(len(configs))
@@ -473,6 +524,9 @@ func (s *LocalConfigurationService) ListTemplates(page, perPage int) ([]models.C
 
 	var templates []models.Configuration
 	for _, lc := range localConfigs {
+		if !lc.IsActive {
+			continue
+		}
 		if lc.IsTemplate {
 			templates = append(templates, *localdb.LocalToConfiguration(&lc))
 		}
@@ -503,7 +557,459 @@ func (s *LocalConfigurationService) ListTemplates(page, perPage int) ([]models.C
 
 // RefreshPricesNoAuth updates all component prices in the configuration without ownership check
 func (s *LocalConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Configuration, error) {
-	// This requires access to component prices from local cache
-	// For now, return error as we need to implement component price lookup from local cache
-	return nil, errors.New("refresh prices not yet implemented for local-first mode")
+	// Get configuration from local SQLite
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	// Update prices for all items
+	updatedItems := make(localdb.LocalConfigItems, len(localCfg.Items))
+	for i, item := range localCfg.Items {
+		// Get current component price from local cache
+		component, err := s.localDB.GetLocalComponent(item.LotName)
+		if err != nil || component.CurrentPrice == nil {
+			// Keep original item if component not found or no price available
+			updatedItems[i] = item
+			continue
+		}
+
+		// Update item with current price from local cache
+		updatedItems[i] = localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: *component.CurrentPrice,
+		}
+	}
+
+	// Update configuration
+	localCfg.Items = updatedItems
+	total := updatedItems.Total()
+
+	// If server count is greater than 1, multiply the total by server count
+	if localCfg.ServerCount > 1 {
+		total *= float64(localCfg.ServerCount)
+	}
+
+	localCfg.TotalPrice = &total
+
+	// Set price update timestamp and mark for sync
+	now := time.Now()
+	localCfg.PriceUpdatedAt = &now
+	localCfg.UpdatedAt = now
+	localCfg.SyncStatus = "pending"
+
+	cfg, err := s.saveWithVersionAndPending(localCfg, "update", "")
+	if err != nil {
+		return nil, fmt.Errorf("refresh prices without auth with version: %w", err)
+	}
+	return cfg, nil
+}
+
+// ImportFromServer imports configurations from MariaDB to local SQLite cache.
+func (s *LocalConfigurationService) ImportFromServer() (*sync.ConfigImportResult, error) {
+	return s.syncService.ImportConfigurationsToLocal()
+}
+
+// GetCurrentVersion returns the currently active version row for configuration UUID.
+func (s *LocalConfigurationService) GetCurrentVersion(configurationUUID string) (*localdb.LocalConfigurationVersion, error) {
+	var cfg localdb.LocalConfiguration
+	if err := s.localDB.DB().Where("uuid = ?", configurationUUID).First(&cfg).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, ErrConfigNotFound
+		}
+		return nil, fmt.Errorf("get configuration for current version: %w", err)
+	}
+
+	var version localdb.LocalConfigurationVersion
+	if cfg.CurrentVersionID != nil && *cfg.CurrentVersionID != "" {
+		if err := s.localDB.DB().
+			Where("id = ? AND configuration_uuid = ?", *cfg.CurrentVersionID, configurationUUID).
+			First(&version).Error; err == nil {
+			return &version, nil
+		}
+	}
+
+	if err := s.localDB.DB().
+		Where("configuration_uuid = ?", configurationUUID).
+		Order("version_no DESC").
+		First(&version).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, ErrConfigVersionNotFound
+		}
+		return nil, fmt.Errorf("get latest version for current pointer fallback: %w", err)
+	}
+
+	return &version, nil
+}
+
+// ListVersions returns versions by configuration UUID in descending order by version number.
+func (s *LocalConfigurationService) ListVersions(configurationUUID string, limit, offset int) ([]localdb.LocalConfigurationVersion, error) {
+	if limit <= 0 {
+		limit = 20
+	}
+	if limit > 200 {
+		limit = 200
+	}
+	if offset < 0 {
+		return nil, ErrInvalidVersionNumber
+	}
+
+	var cfgCount int64
+	if err := s.localDB.DB().Model(&localdb.LocalConfiguration{}).
+		Where("uuid = ?", configurationUUID).
+		Count(&cfgCount).Error; err != nil {
+		return nil, fmt.Errorf("check configuration before list versions: %w", err)
+	}
+	if cfgCount == 0 {
+		return nil, ErrConfigNotFound
+	}
+
+	var versions []localdb.LocalConfigurationVersion
+	if err := s.localDB.DB().
+		Where("configuration_uuid = ?", configurationUUID).
+		Order("version_no DESC").
+		Limit(limit).
+		Offset(offset).
+		Find(&versions).Error; err != nil {
+		return nil, fmt.Errorf("list versions: %w", err)
+	}
+
+	return versions, nil
+}
+
+// GetVersion returns one version by configuration UUID and version number.
+func (s *LocalConfigurationService) GetVersion(configurationUUID string, versionNo int) (*localdb.LocalConfigurationVersion, error) {
+	if versionNo <= 0 {
+		return nil, ErrInvalidVersionNumber
+	}
+
+	var version localdb.LocalConfigurationVersion
+	if err := s.localDB.DB().
+		Where("configuration_uuid = ? AND version_no = ?", configurationUUID, versionNo).
+		First(&version).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, ErrConfigVersionNotFound
+		}
+		return nil, fmt.Errorf("get version %d for %s: %w", versionNo, configurationUUID, err)
+	}
+
+	return &version, nil
+}
+
+// RollbackToVersion creates a new version from target snapshot and marks it current.
+func (s *LocalConfigurationService) RollbackToVersion(configurationUUID string, targetVersionNo int, userID string) (*models.Configuration, error) {
+	return s.rollbackToVersion(configurationUUID, targetVersionNo, userID, "")
+}
+
+// RollbackToVersionWithNote same as RollbackToVersion, with optional user note.
+func (s *LocalConfigurationService) RollbackToVersionWithNote(configurationUUID string, targetVersionNo int, userID string, note string) (*models.Configuration, error) {
+	return s.rollbackToVersion(configurationUUID, targetVersionNo, userID, note)
+}
+
+func (s *LocalConfigurationService) isOwner(cfg *localdb.LocalConfiguration, ownerUsername string) bool {
+	if cfg == nil || ownerUsername == "" {
+		return false
+	}
+	if cfg.OriginalUsername != "" {
+		return cfg.OriginalUsername == ownerUsername
+	}
+	return false
+}
+
+func (s *LocalConfigurationService) createWithVersion(localCfg *localdb.LocalConfiguration, createdBy string) error {
+	return s.localDB.DB().Transaction(func(tx *gorm.DB) error {
+		if err := tx.Create(localCfg).Error; err != nil {
+			return fmt.Errorf("create local configuration: %w", err)
+		}
+
+		version, err := s.appendVersionTx(tx, localCfg, "create", createdBy)
+		if err != nil {
+			return fmt.Errorf("append create version: %w", err)
+		}
+
+		if err := tx.Model(&localdb.LocalConfiguration{}).
+			Where("uuid = ?", localCfg.UUID).
+			Update("current_version_id", version.ID).Error; err != nil {
+			return fmt.Errorf("set current version id: %w", err)
+		}
+		localCfg.CurrentVersionID = &version.ID
+
+		if err := s.enqueueConfigurationPendingChangeTx(tx, localCfg, "create", version, createdBy); err != nil {
+			return fmt.Errorf("enqueue create pending change: %w", err)
+		}
+
+		return nil
+	})
+}
+
+func (s *LocalConfigurationService) saveWithVersionAndPending(localCfg *localdb.LocalConfiguration, operation string, createdBy string) (*models.Configuration, error) {
+	var cfg *models.Configuration
+
+	err := s.localDB.DB().Transaction(func(tx *gorm.DB) error {
+		var locked localdb.LocalConfiguration
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
+			Where("uuid = ?", localCfg.UUID).
+			First(&locked).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return ErrConfigNotFound
+			}
+			return fmt.Errorf("lock configuration row: %w", err)
+		}
+
+		if err := tx.Save(localCfg).Error; err != nil {
+			return fmt.Errorf("save local configuration: %w", err)
+		}
+
+		version, err := s.appendVersionTx(tx, localCfg, operation, createdBy)
+		if err != nil {
+			return fmt.Errorf("append %s version: %w", operation, err)
+		}
+
+		if err := tx.Model(&localdb.LocalConfiguration{}).
+			Where("uuid = ?", localCfg.UUID).
+			Update("current_version_id", version.ID).Error; err != nil {
+			return fmt.Errorf("update current version id: %w", err)
+		}
+		localCfg.CurrentVersionID = &version.ID
+
+		cfg = localdb.LocalToConfiguration(localCfg)
+		if err := s.enqueueConfigurationPendingChangeTx(tx, localCfg, operation, version, createdBy); err != nil {
+			return fmt.Errorf("enqueue %s pending change: %w", operation, err)
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}
+
+func (s *LocalConfigurationService) appendVersionTx(
+	tx *gorm.DB,
+	localCfg *localdb.LocalConfiguration,
+	operation string,
+	createdBy string,
+) (*localdb.LocalConfigurationVersion, error) {
+	snapshot, err := s.buildConfigurationSnapshot(localCfg)
+	if err != nil {
+		return nil, fmt.Errorf("build snapshot: %w", err)
+	}
+	changeNote := fmt.Sprintf("%s via local-first flow", operation)
+
+	var createdByPtr *string
+	if createdBy != "" {
+		createdByPtr = &createdBy
+	}
+
+	for attempt := 0; attempt < 3; attempt++ {
+		var maxVersion int
+		if err := tx.Model(&localdb.LocalConfigurationVersion{}).
+			Where("configuration_uuid = ?", localCfg.UUID).
+			Select("COALESCE(MAX(version_no), 0)").
+			Scan(&maxVersion).Error; err != nil {
+			return nil, fmt.Errorf("read max version: %w", err)
+		}
+
+		versionID := uuid.New().String()
+		version := &localdb.LocalConfigurationVersion{
+			ID:                versionID,
+			ConfigurationUUID: localCfg.UUID,
+			VersionNo:         maxVersion + 1,
+			Data:              snapshot,
+			ChangeNote:        &changeNote,
+			CreatedBy:         createdByPtr,
+			AppVersion:        appmeta.Version(),
+		}
+
+		if err := tx.Create(version).Error; err != nil {
+			// SQLite equivalent safety: serialized writer tx + UNIQUE(configuration_uuid, version_no) + retry.
+			if strings.Contains(err.Error(), "UNIQUE constraint failed: local_configuration_versions.configuration_uuid, local_configuration_versions.version_no") {
+				continue
+			}
+			return nil, fmt.Errorf("insert configuration version: %w", err)
+		}
+
+		return version, nil
+	}
+
+	return nil, fmt.Errorf("%w: exceeded retries for %s", ErrVersionConflict, localCfg.UUID)
+}
+
+func (s *LocalConfigurationService) buildConfigurationSnapshot(localCfg *localdb.LocalConfiguration) (string, error) {
+	return localdb.BuildConfigurationSnapshot(localCfg)
+}
+
+func (s *LocalConfigurationService) rollbackToVersion(configurationUUID string, targetVersionNo int, userID string, note string) (*models.Configuration, error) {
+	if targetVersionNo <= 0 {
+		return nil, ErrInvalidVersionNumber
+	}
+
+	var resultCfg *models.Configuration
+	err := s.localDB.DB().Transaction(func(tx *gorm.DB) error {
+		var current localdb.LocalConfiguration
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
+			Where("uuid = ?", configurationUUID).
+			First(&current).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return ErrConfigNotFound
+			}
+			return fmt.Errorf("lock configuration for rollback: %w", err)
+		}
+
+		var target localdb.LocalConfigurationVersion
+		if err := tx.Where("configuration_uuid = ? AND version_no = ?", configurationUUID, targetVersionNo).
+			First(&target).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return ErrConfigVersionNotFound
+			}
+			return fmt.Errorf("load target rollback version: %w", err)
+		}
+
+		rollbackData, err := s.decodeConfigurationSnapshot(target.Data)
+		if err != nil {
+			return fmt.Errorf("decode target rollback snapshot: %w", err)
+		}
+
+		// Keep stable identity/sync linkage; restore editable config content from target snapshot.
+		current.Name = rollbackData.Name
+		current.Items = rollbackData.Items
+		current.TotalPrice = rollbackData.TotalPrice
+		current.CustomPrice = rollbackData.CustomPrice
+		current.Notes = rollbackData.Notes
+		current.IsTemplate = rollbackData.IsTemplate
+		current.ServerCount = rollbackData.ServerCount
+		current.PriceUpdatedAt = rollbackData.PriceUpdatedAt
+		current.UpdatedAt = time.Now()
+		current.SyncStatus = "pending"
+		current.IsActive = rollbackData.IsActive
+
+		if rollbackData.OriginalUsername != "" {
+			current.OriginalUsername = rollbackData.OriginalUsername
+		}
+		if rollbackData.OriginalUserID != 0 {
+			current.OriginalUserID = rollbackData.OriginalUserID
+		}
+
+		if err := tx.Save(&current).Error; err != nil {
+			return fmt.Errorf("save rolled back configuration: %w", err)
+		}
+
+		var maxVersion int
+		if err := tx.Model(&localdb.LocalConfigurationVersion{}).
+			Where("configuration_uuid = ?", configurationUUID).
+			Select("COALESCE(MAX(version_no), 0)").
+			Scan(&maxVersion).Error; err != nil {
+			return fmt.Errorf("read max version before rollback append: %w", err)
+		}
+
+		changeNote := fmt.Sprintf("rollback to v%d", targetVersionNo)
+		if trimmed := strings.TrimSpace(note); trimmed != "" {
+			changeNote = fmt.Sprintf("%s (%s)", changeNote, trimmed)
+		}
+
+		version := &localdb.LocalConfigurationVersion{
+			ID:                uuid.New().String(),
+			ConfigurationUUID: configurationUUID,
+			VersionNo:         maxVersion + 1,
+			Data:              target.Data,
+			ChangeNote:        &changeNote,
+			CreatedBy:         stringPtrOrNil(userID),
+			AppVersion:        appmeta.Version(),
+		}
+
+		if err := tx.Create(version).Error; err != nil {
+			if strings.Contains(err.Error(), "UNIQUE constraint failed: local_configuration_versions.configuration_uuid, local_configuration_versions.version_no") {
+				return ErrVersionConflict
+			}
+			return fmt.Errorf("create rollback version: %w", err)
+		}
+
+		if err := tx.Model(&localdb.LocalConfiguration{}).
+			Where("uuid = ?", configurationUUID).
+			Update("current_version_id", version.ID).Error; err != nil {
+			return fmt.Errorf("update current version after rollback: %w", err)
+		}
+		current.CurrentVersionID = &version.ID
+
+		resultCfg = localdb.LocalToConfiguration(&current)
+		if err := s.enqueueConfigurationPendingChangeTx(tx, &current, "rollback", version, userID); err != nil {
+			return fmt.Errorf("enqueue rollback pending change: %w", err)
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return resultCfg, nil
+}
+
+func (s *LocalConfigurationService) enqueueConfigurationPendingChangeTx(
+	tx *gorm.DB,
+	localCfg *localdb.LocalConfiguration,
+	operation string,
+	version *localdb.LocalConfigurationVersion,
+	createdBy string,
+) error {
+	cfg := localdb.LocalToConfiguration(localCfg)
+	payload := sync.ConfigurationChangePayload{
+		EventID:           uuid.New().String(),
+		IdempotencyKey:    fmt.Sprintf("%s:v%d:%s", localCfg.UUID, version.VersionNo, operation),
+		ConfigurationUUID: localCfg.UUID,
+		Operation:         operation,
+		CurrentVersionID:  version.ID,
+		CurrentVersionNo:  version.VersionNo,
+		ConflictPolicy:    "last_write_wins",
+		Snapshot:          *cfg,
+		CreatedAt:         time.Now().UTC(),
+		CreatedBy:         stringPtrOrNil(createdBy),
+	}
+
+	rawPayload, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("marshal pending payload: %w", err)
+	}
+
+	change := &localdb.PendingChange{
+		EntityType: "configuration",
+		EntityUUID: localCfg.UUID,
+		Operation:  operation,
+		Payload:    string(rawPayload),
+		CreatedAt:  time.Now(),
+		Attempts:   0,
+	}
+	if err := tx.Create(change).Error; err != nil {
+		return fmt.Errorf("insert pending change: %w", err)
+	}
+
+	return nil
+}
+
+func (s *LocalConfigurationService) decodeConfigurationSnapshot(data string) (*localdb.LocalConfiguration, error) {
+	return localdb.DecodeConfigurationSnapshot(data)
+}
+
+func stringPtrOrNil(value string) *string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return nil
+	}
+	return &trimmed
+}
+
+func matchesConfigStatus(isActive bool, status string) bool {
+	switch status {
+	case "active", "":
+		return isActive
+	case "archived":
+		return !isActive
+	case "all":
+		return true
+	default:
+		return isActive
+	}
 }

internal/services/local_configuration_versioning_test.go

@@ -0,0 +1,357 @@
+package services
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	syncsvc "git.mchus.pro/mchus/quoteforge/internal/services/sync"
+)
+
+func TestSaveCreatesNewVersionAndUpdatesCurrentPointer(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "v1",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 1000}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+
+	if _, err := service.RenameNoAuth(created.UUID, "v2"); err != nil {
+		t.Fatalf("rename config: %v", err)
+	}
+
+	versions := loadVersions(t, local, created.UUID)
+	if len(versions) != 2 {
+		t.Fatalf("expected 2 versions, got %d", len(versions))
+	}
+	if versions[0].VersionNo != 1 || versions[1].VersionNo != 2 {
+		t.Fatalf("expected version_no [1,2], got [%d,%d]", versions[0].VersionNo, versions[1].VersionNo)
+	}
+
+	cfg, err := local.GetConfigurationByUUID(created.UUID)
+	if err != nil {
+		t.Fatalf("load local config: %v", err)
+	}
+	if cfg.CurrentVersionID == nil || *cfg.CurrentVersionID != versions[1].ID {
+		t.Fatalf("current_version_id should point to v2")
+	}
+}
+
+func TestRollbackCreatesNewVersionWithTargetData(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "base",
+		Items:       models.ConfigItems{{LotName: "RAM_A", Quantity: 2, UnitPrice: 100}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+
+	if _, err := service.RenameNoAuth(created.UUID, "changed"); err != nil {
+		t.Fatalf("rename config: %v", err)
+	}
+	if _, err := service.RollbackToVersionWithNote(created.UUID, 1, "tester", "test rollback"); err != nil {
+		t.Fatalf("rollback to v1: %v", err)
+	}
+
+	versions := loadVersions(t, local, created.UUID)
+	if len(versions) != 3 {
+		t.Fatalf("expected 3 versions, got %d", len(versions))
+	}
+	if versions[2].VersionNo != 3 {
+		t.Fatalf("expected v3 as rollback version, got v%d", versions[2].VersionNo)
+	}
+	if versions[2].Data != versions[0].Data {
+		t.Fatalf("expected rollback snapshot data equal to v1 data")
+	}
+}
+
+func TestAppendOnlyInvariantOldRowsUnchanged(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "initial",
+		Items:       models.ConfigItems{{LotName: "SSD_A", Quantity: 1, UnitPrice: 300}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+
+	versionsBefore := loadVersions(t, local, created.UUID)
+	if len(versionsBefore) != 1 {
+		t.Fatalf("expected exactly one version after create")
+	}
+	v1Before := versionsBefore[0]
+
+	if _, err := service.RenameNoAuth(created.UUID, "after-rename"); err != nil {
+		t.Fatalf("rename config: %v", err)
+	}
+	if _, err := service.RollbackToVersion(created.UUID, 1, "tester"); err != nil {
+		t.Fatalf("rollback: %v", err)
+	}
+
+	versionsAfter := loadVersions(t, local, created.UUID)
+	if len(versionsAfter) != 3 {
+		t.Fatalf("expected 3 versions, got %d", len(versionsAfter))
+	}
+	v1After := versionsAfter[0]
+
+	if v1After.ID != v1Before.ID {
+		t.Fatalf("v1 id changed: before=%s after=%s", v1Before.ID, v1After.ID)
+	}
+	if v1After.Data != v1Before.Data {
+		t.Fatalf("v1 data changed")
+	}
+	if !v1After.CreatedAt.Equal(v1Before.CreatedAt) {
+		t.Fatalf("v1 created_at changed")
+	}
+}
+
+func TestConcurrentSaveNoDuplicateVersionNumbers(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "base",
+		Items:       models.ConfigItems{{LotName: "NIC_A", Quantity: 1, UnitPrice: 150}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+
+	const workers = 8
+	start := make(chan struct{})
+	errCh := make(chan error, workers)
+	var wg sync.WaitGroup
+
+	for i := 0; i < workers; i++ {
+		i := i
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			<-start
+			if err := renameWithRetry(service, created.UUID, fmt.Sprintf("name-%d", i)); err != nil {
+				errCh <- err
+			}
+		}()
+	}
+
+	close(start)
+	wg.Wait()
+	close(errCh)
+
+	for err := range errCh {
+		if err != nil {
+			t.Fatalf("concurrent save failed: %v", err)
+		}
+	}
+
+	type counts struct {
+		Total         int64
+		DistinctCount int64
+		Max           int
+	}
+	var c counts
+	if err := local.DB().Raw(`
+SELECT
+	COUNT(*) as total,
+	COUNT(DISTINCT version_no) as distinct_count,
+	COALESCE(MAX(version_no), 0) as max
+FROM local_configuration_versions
+WHERE configuration_uuid = ?`, created.UUID).Scan(&c).Error; err != nil {
+		t.Fatalf("query version counts: %v", err)
+	}
+
+	if c.Total != c.DistinctCount {
+		t.Fatalf("duplicate version numbers detected: total=%d distinct=%d", c.Total, c.DistinctCount)
+	}
+	expected := int64(workers + 1) // initial create version + each successful save
+	if c.Total != expected || c.Max != int(expected) {
+		t.Fatalf("expected total=max=%d, got total=%d max=%d", expected, c.Total, c.Max)
+	}
+}
+
+func newLocalConfigServiceForTest(t *testing.T) (*LocalConfigurationService, *localdb.LocalDB) {
+	t.Helper()
+
+	dbPath := filepath.Join(t.TempDir(), "local.db")
+	local, err := localdb.New(dbPath)
+	if err != nil {
+		t.Fatalf("init local db: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = local.Close()
+	})
+
+	return NewLocalConfigurationService(
+		local,
+		syncsvc.NewService(nil, local),
+		&QuoteService{},
+		func() bool { return false },
+	), local
+}
+
+func loadVersions(t *testing.T, local *localdb.LocalDB, configurationUUID string) []localdb.LocalConfigurationVersion {
+	t.Helper()
+	var versions []localdb.LocalConfigurationVersion
+	if err := local.DB().
+		Where("configuration_uuid = ?", configurationUUID).
+		Order("version_no ASC").
+		Find(&versions).Error; err != nil {
+		t.Fatalf("load versions: %v", err)
+	}
+	return versions
+}
+
+func renameWithRetry(service *LocalConfigurationService, uuid string, name string) error {
+	var lastErr error
+	for i := 0; i < 6; i++ {
+		_, err := service.RenameNoAuth(uuid, name)
+		if err == nil {
+			return nil
+		}
+		lastErr = err
+		if errors.Is(err, ErrVersionConflict) || strings.Contains(err.Error(), "database is locked") {
+			time.Sleep(10 * time.Millisecond)
+			continue
+		}
+		return err
+	}
+	return fmt.Errorf("rename retries exhausted: %w", lastErr)
+}
+
+func TestRollbackVersionSnapshotJSONMatchesV1(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "initial",
+		Items:       models.ConfigItems{{LotName: "GPU_A", Quantity: 1, UnitPrice: 2000}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+	if _, err := service.RenameNoAuth(created.UUID, "second"); err != nil {
+		t.Fatalf("rename: %v", err)
+	}
+	if _, err := service.RollbackToVersion(created.UUID, 1, "tester"); err != nil {
+		t.Fatalf("rollback: %v", err)
+	}
+
+	versions := loadVersions(t, local, created.UUID)
+	if len(versions) != 3 {
+		t.Fatalf("expected 3 versions")
+	}
+
+	var v1 map[string]any
+	var v3 map[string]any
+	if err := json.Unmarshal([]byte(versions[0].Data), &v1); err != nil {
+		t.Fatalf("unmarshal v1: %v", err)
+	}
+	if err := json.Unmarshal([]byte(versions[2].Data), &v3); err != nil {
+		t.Fatalf("unmarshal v3: %v", err)
+	}
+	if fmt.Sprintf("%v", v1["name"]) != fmt.Sprintf("%v", v3["name"]) {
+		t.Fatalf("rollback snapshot differs from v1 snapshot by name")
+	}
+}
+
+func TestDeleteMarksInactiveAndCreatesVersion(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "to-archive",
+		Items:       models.ConfigItems{{LotName: "CPU_Z", Quantity: 1, UnitPrice: 500}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+	if err := service.DeleteNoAuth(created.UUID); err != nil {
+		t.Fatalf("delete no auth: %v", err)
+	}
+
+	cfg, err := local.GetConfigurationByUUID(created.UUID)
+	if err != nil {
+		t.Fatalf("load archived config: %v", err)
+	}
+	if cfg.IsActive {
+		t.Fatalf("expected config to be inactive after delete")
+	}
+
+	versions := loadVersions(t, local, created.UUID)
+	if len(versions) != 2 {
+		t.Fatalf("expected 2 versions after archive, got %d", len(versions))
+	}
+	if versions[1].VersionNo != 2 {
+		t.Fatalf("expected archive to create version 2, got %d", versions[1].VersionNo)
+	}
+
+	list, total, err := service.ListAll(1, 20)
+	if err != nil {
+		t.Fatalf("list all: %v", err)
+	}
+	if total != int64(len(list)) {
+		t.Fatalf("unexpected total/list mismatch")
+	}
+	if len(list) != 0 {
+		t.Fatalf("expected archived config to be hidden from list")
+	}
+}
+
+func TestReactivateRestoresArchivedConfigurationAndCreatesVersion(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "to-reactivate",
+		Items:       models.ConfigItems{{LotName: "CPU_R", Quantity: 1, UnitPrice: 700}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+	if err := service.DeleteNoAuth(created.UUID); err != nil {
+		t.Fatalf("archive config: %v", err)
+	}
+	if _, err := service.ReactivateNoAuth(created.UUID); err != nil {
+		t.Fatalf("reactivate config: %v", err)
+	}
+
+	cfg, err := local.GetConfigurationByUUID(created.UUID)
+	if err != nil {
+		t.Fatalf("load reactivated config: %v", err)
+	}
+	if !cfg.IsActive {
+		t.Fatalf("expected config to be active after reactivation")
+	}
+
+	versions := loadVersions(t, local, created.UUID)
+	if len(versions) != 3 {
+		t.Fatalf("expected 3 versions after reactivation, got %d", len(versions))
+	}
+	if versions[2].VersionNo != 3 {
+		t.Fatalf("expected reactivation version 3, got %d", versions[2].VersionNo)
+	}
+
+	list, _, err := service.ListAll(1, 20)
+	if err != nil {
+		t.Fatalf("list all after reactivation: %v", err)
+	}
+	if len(list) != 1 {
+		t.Fatalf("expected reactivated config to be visible in list")
+	}
+}

internal/services/pricelist/service.go

@@ -26,6 +26,10 @@ func NewService(db *gorm.DB, repo *repository.PricelistRepository, componentRepo
 
 // CreateFromCurrentPrices creates a new pricelist by taking a snapshot of current prices
 func (s *Service) CreateFromCurrentPrices(createdBy string) (*models.Pricelist, error) {
+	if s.repo == nil || s.db == nil {
+		return nil, fmt.Errorf("offline mode: cannot create pricelists")
+	}
+
 	version, err := s.repo.GenerateVersion()
 	if err != nil {
 		return nil, fmt.Errorf("generating version: %w", err)
@@ -88,6 +92,11 @@ func (s *Service) CreateFromCurrentPrices(createdBy string) (*models.Pricelist,
 
 // List returns pricelists with pagination
 func (s *Service) List(page, perPage int) ([]models.PricelistSummary, int64, error) {
+	// If no database connection (offline mode), return empty list
+	if s.repo == nil {
+		return []models.PricelistSummary{}, 0, nil
+	}
+
 	if page < 1 {
 		page = 1
 	}
@@ -100,11 +109,17 @@ func (s *Service) List(page, perPage int) ([]models.PricelistSummary, int64, err
 
 // GetByID returns a pricelist by ID
 func (s *Service) GetByID(id uint) (*models.Pricelist, error) {
+	if s.repo == nil {
+		return nil, fmt.Errorf("offline mode: pricelist service not available")
+	}
 	return s.repo.GetByID(id)
 }
 
 // GetItems returns pricelist items with pagination
 func (s *Service) GetItems(pricelistID uint, page, perPage int, search string) ([]models.PricelistItem, int64, error) {
+	if s.repo == nil {
+		return []models.PricelistItem{}, 0, nil
+	}
 	if page < 1 {
 		page = 1
 	}
@@ -117,26 +132,42 @@ func (s *Service) GetItems(pricelistID uint, page, perPage int, search string) (
 
 // Delete deletes a pricelist by ID
 func (s *Service) Delete(id uint) error {
+	if s.repo == nil {
+		return fmt.Errorf("offline mode: cannot delete pricelists")
+	}
 	return s.repo.Delete(id)
 }
 
 // CanWrite returns true if the user can create pricelists
 func (s *Service) CanWrite() bool {
+	if s.repo == nil {
+		return false
+	}
 	return s.repo.CanWrite()
 }
 
 // CanWriteDebug returns write permission status with debug info
 func (s *Service) CanWriteDebug() (bool, string) {
+	if s.repo == nil {
+		return false, "offline mode"
+	}
 	return s.repo.CanWriteDebug()
 }
 
 // GetLatestActive returns the most recent active pricelist
 func (s *Service) GetLatestActive() (*models.Pricelist, error) {
+	if s.repo == nil {
+		return nil, fmt.Errorf("offline mode: pricelist service not available")
+	}
 	return s.repo.GetLatestActive()
 }
 
 // CleanupExpired deletes expired and unused pricelists
 func (s *Service) CleanupExpired() (int, error) {
+	if s.repo == nil {
+		return 0, fmt.Errorf("offline mode: cleanup not available")
+	}
+
 	expired, err := s.repo.GetExpiredUnused()
 	if err != nil {
 		return 0, err

internal/services/pricing/service.go

@@ -68,7 +68,7 @@ func (s *Service) CalculatePrice(lotName string, method models.PriceMethod, peri
 	case models.PriceMethodAverage:
 		return CalculateAverage(prices), nil
 	case models.PriceMethodWeightedMedian:
-		return CalculateWeightedMedian(points, s.config.DefaultPeriodDays), nil
+		return CalculateWeightedMedian(points, periodDays), nil
 	case models.PriceMethodMedian:
 		fallthrough
 	default:
@@ -149,17 +149,17 @@ func (s *Service) GetPriceStats(lotName string, periodDays int) (*PriceStats, er
 	}
 
 	return &PriceStats{
-		QuoteCount:    len(points),
-		MinPrice:      CalculatePercentile(prices, 0),
-		MaxPrice:      CalculatePercentile(prices, 100),
-		MedianPrice:   CalculateMedian(prices),
-		AveragePrice:  CalculateAverage(prices),
-		StdDeviation:  CalculateStdDev(prices),
-		LatestPrice:   points[0].Price,
-		LatestDate:    points[0].Date,
-		OldestDate:    points[len(points)-1].Date,
-		Percentile25:  CalculatePercentile(prices, 25),
-		Percentile75:  CalculatePercentile(prices, 75),
+		QuoteCount:   len(points),
+		MinPrice:     CalculatePercentile(prices, 0),
+		MaxPrice:     CalculatePercentile(prices, 100),
+		MedianPrice:  CalculateMedian(prices),
+		AveragePrice: CalculateAverage(prices),
+		StdDeviation: CalculateStdDev(prices),
+		LatestPrice:  points[0].Price,
+		LatestDate:   points[0].Date,
+		OldestDate:   points[len(points)-1].Date,
+		Percentile25: CalculatePercentile(prices, 25),
+		Percentile75: CalculatePercentile(prices, 75),
 	}, nil
 }
 

internal/services/quote.go

@@ -9,14 +9,14 @@ import (
 )
 
 var (
-	ErrEmptyQuote       = errors.New("quote cannot be empty")
+	ErrEmptyQuote        = errors.New("quote cannot be empty")
 	ErrComponentNotFound = errors.New("component not found")
 	ErrNoPriceAvailable  = errors.New("no price available for component")
 )
 
 type QuoteService struct {
-	componentRepo *repository.ComponentRepository
-	statsRepo     *repository.StatsRepository
+	componentRepo  *repository.ComponentRepository
+	statsRepo      *repository.StatsRepository
 	pricingService *pricing.Service
 }
 
@@ -43,11 +43,11 @@ type QuoteItem struct {
 }
 
 type QuoteValidationResult struct {
-	Valid    bool          `json:"valid"`
-	Items    []QuoteItem   `json:"items"`
-	Errors   []string      `json:"errors"`
-	Warnings []string      `json:"warnings"`
-	Total    float64       `json:"total"`
+	Valid    bool        `json:"valid"`
+	Items    []QuoteItem `json:"items"`
+	Errors   []string    `json:"errors"`
+	Warnings []string    `json:"warnings"`
+	Total    float64     `json:"total"`
 }
 
 type QuoteRequest struct {
@@ -61,6 +61,9 @@ func (s *QuoteService) ValidateAndCalculate(req *QuoteRequest) (*QuoteValidation
 	if len(req.Items) == 0 {
 		return nil, ErrEmptyQuote
 	}
+	if s.componentRepo == nil || s.pricingService == nil {
+		return nil, errors.New("offline mode: quote calculation not available")
+	}
 
 	result := &QuoteValidationResult{
 		Valid:    true,
@@ -129,6 +132,11 @@ func (s *QuoteService) ValidateAndCalculate(req *QuoteRequest) (*QuoteValidation
 
 // RecordUsage records that components were used in a quote
 func (s *QuoteService) RecordUsage(items []models.ConfigItem) error {
+	if s.statsRepo == nil {
+		// Offline mode: usage stats are unavailable and should not block config saves.
+		return nil
+	}
+
 	for _, item := range items {
 		revenue := item.UnitPrice * float64(item.Quantity)
 		if err := s.statsRepo.IncrementUsage(item.LotName, item.Quantity, revenue); err != nil {

internal/services/sync/service.go

@@ -2,28 +2,32 @@ package sync
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log/slog"
 	"time"
 
+	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"gorm.io/gorm"
 )
 
+var ErrOffline = errors.New("database is offline")
+
 // Service handles synchronization between MariaDB and local SQLite
 type Service struct {
-	pricelistRepo *repository.PricelistRepository
-	configRepo    *repository.ConfigurationRepository
-	localDB       *localdb.LocalDB
+	connMgr *db.ConnectionManager
+	localDB *localdb.LocalDB
 }
 
 // NewService creates a new sync service
-func NewService(pricelistRepo *repository.PricelistRepository, configRepo *repository.ConfigurationRepository, localDB *localdb.LocalDB) *Service {
+func NewService(connMgr *db.ConnectionManager, localDB *localdb.LocalDB) *Service {
 	return &Service{
-		pricelistRepo: pricelistRepo,
-		configRepo:    configRepo,
-		localDB:       localDB,
+		connMgr: connMgr,
+		localDB: localDB,
 	}
 }
 
@@ -35,14 +39,106 @@ type SyncStatus struct {
 	NeedsSync        bool       `json:"needs_sync"`
 }
 
+// ConfigImportResult represents server->local configuration import stats.
+type ConfigImportResult struct {
+	Imported int `json:"imported"`
+	Updated  int `json:"updated"`
+	Skipped  int `json:"skipped"`
+}
+
+// ConfigurationChangePayload is stored in pending_changes.payload for configuration events.
+// It carries version metadata so sync can push the latest snapshot and prepare for conflict resolution.
+type ConfigurationChangePayload struct {
+	EventID           string               `json:"event_id"`
+	IdempotencyKey    string               `json:"idempotency_key"`
+	ConfigurationUUID string               `json:"configuration_uuid"`
+	Operation         string               `json:"operation"` // create/update/rollback/deactivate/reactivate/delete
+	CurrentVersionID  string               `json:"current_version_id,omitempty"`
+	CurrentVersionNo  int                  `json:"current_version_no,omitempty"`
+	ConflictPolicy    string               `json:"conflict_policy,omitempty"` // currently: last_write_wins
+	Snapshot          models.Configuration `json:"snapshot"`
+	CreatedAt         time.Time            `json:"created_at"`
+	CreatedBy         *string              `json:"created_by,omitempty"`
+}
+
+// ImportConfigurationsToLocal imports configurations from MariaDB into local SQLite.
+// Existing local configs with pending local changes are skipped to avoid data loss.
+func (s *Service) ImportConfigurationsToLocal() (*ConfigImportResult, error) {
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return nil, ErrOffline
+	}
+
+	configRepo := repository.NewConfigurationRepository(mariaDB)
+	result := &ConfigImportResult{}
+
+	offset := 0
+	const limit = 200
+	for {
+		serverConfigs, _, err := configRepo.ListAll(offset, limit)
+		if err != nil {
+			return nil, fmt.Errorf("listing server configurations: %w", err)
+		}
+		if len(serverConfigs) == 0 {
+			break
+		}
+
+		for i := range serverConfigs {
+			cfg := serverConfigs[i]
+			existing, err := s.localDB.GetConfigurationByUUID(cfg.UUID)
+			if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+				return nil, fmt.Errorf("getting local configuration %s: %w", cfg.UUID, err)
+			}
+
+			if existing != nil && err == nil && existing.SyncStatus == "pending" {
+				result.Skipped++
+				continue
+			}
+			if existing != nil && err == nil && !existing.IsActive {
+				// Keep local deactivation sticky: do not resurrect hidden entries from server pull.
+				result.Skipped++
+				continue
+			}
+
+			localCfg := localdb.ConfigurationToLocal(&cfg)
+			now := time.Now()
+			localCfg.SyncedAt = &now
+			localCfg.SyncStatus = "synced"
+			localCfg.UpdatedAt = now
+
+			if existing != nil && err == nil {
+				localCfg.ID = existing.ID
+				result.Updated++
+			} else {
+				result.Imported++
+			}
+
+			if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+				return nil, fmt.Errorf("saving local configuration %s: %w", cfg.UUID, err)
+			}
+		}
+
+		offset += len(serverConfigs)
+	}
+
+	return result, nil
+}
+
 // GetStatus returns the current sync status
 func (s *Service) GetStatus() (*SyncStatus, error) {
 	lastSync := s.localDB.GetLastSyncTime()
 
-	// Count server pricelists
-	serverPricelists, _, err := s.pricelistRepo.List(0, 1)
-	if err != nil {
-		return nil, fmt.Errorf("counting server pricelists: %w", err)
+	// Count server pricelists (only if already connected, don't reconnect)
+	serverCount := 0
+	connStatus := s.connMgr.GetStatus()
+	if connStatus.IsConnected {
+		if mariaDB, err := s.connMgr.GetDB(); err == nil && mariaDB != nil {
+			pricelistRepo := repository.NewPricelistRepository(mariaDB)
+			activeCount, err := pricelistRepo.CountActive()
+			if err == nil {
+				serverCount = int(activeCount)
+			}
+		}
 	}
 
 	// Count local pricelists
@@ -52,7 +148,7 @@ func (s *Service) GetStatus() (*SyncStatus, error) {
 
 	return &SyncStatus{
 		LastSyncAt:       lastSync,
-		ServerPricelists: len(serverPricelists),
+		ServerPricelists: serverCount,
 		LocalPricelists:  int(localCount),
 		NeedsSync:        needsSync,
 	}, nil
@@ -73,8 +169,21 @@ func (s *Service) NeedSync() (bool, error) {
 		return true, nil
 	}
 
-	// Check if there are new pricelists on server
-	latestServer, err := s.pricelistRepo.GetLatestActive()
+	// Check if there are new pricelists on server (only if already connected)
+	connStatus := s.connMgr.GetStatus()
+	if !connStatus.IsConnected {
+		// If offline, can't check server, no need to sync
+		return false, nil
+	}
+
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		// If offline, can't check server, no need to sync
+		return false, nil
+	}
+
+	pricelistRepo := repository.NewPricelistRepository(mariaDB)
+	latestServer, err := pricelistRepo.GetLatestActive()
 	if err != nil {
 		// If no pricelists on server, no need to sync
 		return false, nil
@@ -98,18 +207,33 @@ func (s *Service) NeedSync() (bool, error) {
 func (s *Service) SyncPricelists() (int, error) {
 	slog.Info("starting pricelist sync")
 
-	// Get all active pricelists from server (up to 100)
-	serverPricelists, _, err := s.pricelistRepo.List(0, 100)
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
 	if err != nil {
-		return 0, fmt.Errorf("getting server pricelists: %w", err)
+		return 0, fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	pricelistRepo := repository.NewPricelistRepository(mariaDB)
+
+	// Get active pricelists from server (up to 100)
+	serverPricelists, _, err := pricelistRepo.ListActive(0, 100)
+	if err != nil {
+		return 0, fmt.Errorf("getting active server pricelists: %w", err)
 	}
 
 	synced := 0
+	var latestLocalID uint
+	var latestServerID uint
 	for _, pl := range serverPricelists {
 		// Check if pricelist already exists locally
 		existing, _ := s.localDB.GetLocalPricelistByServerID(pl.ID)
 		if existing != nil {
-			// Already synced, skip
+			// Already synced, track latest by server ID
+			if pl.ID > latestServerID {
+				latestServerID = pl.ID
+				latestLocalID = existing.ID
+			}
 			continue
 		}
 
@@ -128,8 +252,30 @@ func (s *Service) SyncPricelists() (int, error) {
 			continue
 		}
 
+		// Sync items for the newly created pricelist
+		itemCount, err := s.SyncPricelistItems(localPL.ID)
+		if err != nil {
+			slog.Warn("failed to sync pricelist items", "version", pl.Version, "error", err)
+			// Continue even if items sync fails - we have the pricelist metadata
+		} else {
+			slog.Debug("synced pricelist with items", "version", pl.Version, "items", itemCount)
+		}
+
+		if pl.ID > latestServerID {
+			latestServerID = pl.ID
+			latestLocalID = localPL.ID
+		}
 		synced++
-		slog.Debug("synced pricelist", "version", pl.Version, "server_id", pl.ID)
+	}
+
+	// Update component prices from latest pricelist
+	if latestLocalID > 0 {
+		updated, err := s.localDB.UpdateComponentPricesFromPricelist(latestLocalID)
+		if err != nil {
+			slog.Warn("failed to update component prices from pricelist", "error", err)
+		} else {
+			slog.Info("updated component prices from latest pricelist", "updated", updated)
+		}
 	}
 
 	// Update last sync time
@@ -154,8 +300,17 @@ func (s *Service) SyncPricelistItems(localPricelistID uint) (int, error) {
 		return int(existingCount), nil
 	}
 
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return 0, fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	pricelistRepo := repository.NewPricelistRepository(mariaDB)
+
 	// Get items from server
-	serverItems, _, err := s.pricelistRepo.GetItems(localPL.ServerID, 0, 10000, "")
+	serverItems, _, err := pricelistRepo.GetItems(localPL.ServerID, 0, 10000, "")
 	if err != nil {
 		return 0, fmt.Errorf("getting server pricelist items: %w", err)
 	}
@@ -243,6 +398,13 @@ func (s *Service) SyncPricelistsIfNeeded() error {
 
 // PushPendingChanges pushes all pending changes to the server
 func (s *Service) PushPendingChanges() (int, error) {
+	removed, err := s.localDB.PurgeOrphanConfigurationPendingChanges()
+	if err != nil {
+		slog.Warn("failed to purge orphan configuration pending changes", "error", err)
+	} else if removed > 0 {
+		slog.Info("purged orphan configuration pending changes", "removed", removed)
+	}
+
 	changes, err := s.localDB.GetPendingChanges()
 	if err != nil {
 		return 0, fmt.Errorf("getting pending changes: %w", err)
@@ -298,6 +460,12 @@ func (s *Service) pushConfigurationChange(change *localdb.PendingChange) error {
 		return s.pushConfigurationCreate(change)
 	case "update":
 		return s.pushConfigurationUpdate(change)
+	case "rollback":
+		return s.pushConfigurationRollback(change)
+	case "deactivate":
+		return s.pushConfigurationDeactivate(change)
+	case "reactivate":
+		return s.pushConfigurationReactivate(change)
 	case "delete":
 		return s.pushConfigurationDelete(change)
 	default:
@@ -307,14 +475,38 @@ func (s *Service) pushConfigurationChange(change *localdb.PendingChange) error {
 
 // pushConfigurationCreate creates a configuration on the server
 func (s *Service) pushConfigurationCreate(change *localdb.PendingChange) error {
-	var cfg models.Configuration
-	if err := json.Unmarshal([]byte(change.Payload), &cfg); err != nil {
-		return fmt.Errorf("unmarshaling configuration: %w", err)
+	payload, cfg, isStale, err := s.resolveConfigurationPayloadForPush(change)
+	if err != nil {
+		return err
+	}
+	if isStale {
+		slog.Debug("skipping stale create event, newer version exists", "uuid", payload.ConfigurationUUID, "idempotency_key", payload.IdempotencyKey)
+		return nil
+	}
+
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	configRepo := repository.NewConfigurationRepository(mariaDB)
+	if err := s.ensureConfigurationOwner(mariaDB, &cfg); err != nil {
+		return fmt.Errorf("resolve configuration owner: %w", err)
 	}
 
 	// Create on server
-	if err := s.configRepo.Create(&cfg); err != nil {
-		return fmt.Errorf("creating configuration on server: %w", err)
+	if err := configRepo.Create(&cfg); err != nil {
+		// Idempotency fallback: configuration may already be created remotely.
+		serverCfg, getErr := configRepo.GetByUUID(cfg.UUID)
+		if getErr != nil {
+			return fmt.Errorf("creating configuration on server: %w", err)
+		}
+		cfg.ID = serverCfg.ID
+		if updateErr := configRepo.Update(&cfg); updateErr != nil {
+			return fmt.Errorf("create fallback update on server: %w", updateErr)
+		}
 	}
 
 	// Update local configuration with server ID
@@ -326,19 +518,66 @@ func (s *Service) pushConfigurationCreate(change *localdb.PendingChange) error {
 		s.localDB.SaveConfiguration(localCfg)
 	}
 
-	slog.Info("configuration created on server", "uuid", cfg.UUID, "server_id", cfg.ID)
+	slog.Info("configuration created on server",
+		"uuid", cfg.UUID,
+		"server_id", cfg.ID,
+		"version_no", payload.CurrentVersionNo,
+		"version_id", payload.CurrentVersionID,
+		"idempotency_key", payload.IdempotencyKey,
+	)
 	return nil
 }
 
 // pushConfigurationUpdate updates a configuration on the server
 func (s *Service) pushConfigurationUpdate(change *localdb.PendingChange) error {
-	var cfg models.Configuration
-	if err := json.Unmarshal([]byte(change.Payload), &cfg); err != nil {
-		return fmt.Errorf("unmarshaling configuration: %w", err)
+	payload, cfg, isStale, err := s.resolveConfigurationPayloadForPush(change)
+	if err != nil {
+		return err
+	}
+	if isStale {
+		slog.Debug("skipping stale update event, newer version exists", "uuid", payload.ConfigurationUUID, "idempotency_key", payload.IdempotencyKey)
+		return nil
+	}
+
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	configRepo := repository.NewConfigurationRepository(mariaDB)
+	if err := s.ensureConfigurationOwner(mariaDB, &cfg); err != nil {
+		return fmt.Errorf("resolve configuration owner: %w", err)
+	}
+
+	// Ensure we have a server ID before updating
+	// If the payload doesn't have ID, get it from local configuration
+	if cfg.ID == 0 {
+		localCfg, err := s.localDB.GetConfigurationByUUID(cfg.UUID)
+		if err != nil {
+			return fmt.Errorf("getting local configuration: %w", err)
+		}
+
+		if localCfg.ServerID == nil {
+			// Configuration hasn't been synced yet, try to find it on server by UUID
+			serverCfg, err := configRepo.GetByUUID(cfg.UUID)
+			if err != nil {
+				return fmt.Errorf("configuration not yet synced to server: %w", err)
+			}
+			cfg.ID = serverCfg.ID
+
+			// Update local with server ID
+			serverID := serverCfg.ID
+			localCfg.ServerID = &serverID
+			s.localDB.SaveConfiguration(localCfg)
+		} else {
+			cfg.ID = *localCfg.ServerID
+		}
 	}
 
 	// Update on server
-	if err := s.configRepo.Update(&cfg); err != nil {
+	if err := configRepo.Update(&cfg); err != nil {
 		return fmt.Errorf("updating configuration on server: %w", err)
 	}
 
@@ -349,14 +588,187 @@ func (s *Service) pushConfigurationUpdate(change *localdb.PendingChange) error {
 		s.localDB.SaveConfiguration(localCfg)
 	}
 
-	slog.Info("configuration updated on server", "uuid", cfg.UUID)
+	slog.Info("configuration updated on server",
+		"uuid", cfg.UUID,
+		"version_no", payload.CurrentVersionNo,
+		"version_id", payload.CurrentVersionID,
+		"idempotency_key", payload.IdempotencyKey,
+		"operation", payload.Operation,
+		"conflict_policy", payload.ConflictPolicy,
+	)
 	return nil
 }
 
+func (s *Service) ensureConfigurationOwner(mariaDB *gorm.DB, cfg *models.Configuration) error {
+	if cfg == nil {
+		return fmt.Errorf("configuration is nil")
+	}
+
+	ownerUsername := cfg.OwnerUsername
+	if ownerUsername == "" {
+		ownerUsername = s.localDB.GetDBUser()
+		cfg.OwnerUsername = ownerUsername
+	}
+	if ownerUsername == "" {
+		return fmt.Errorf("owner username is empty")
+	}
+
+	// user_id is legacy and no longer used for ownership in local-first mode.
+	// Keep it NULL on writes; ownership is represented by owner_username.
+	cfg.UserID = nil
+	cfg.AppVersion = appmeta.Version()
+	return nil
+}
+
+func (s *Service) pushConfigurationRollback(change *localdb.PendingChange) error {
+	// Last-write-wins for now: rollback is pushed as an update with rollback metadata.
+	return s.pushConfigurationUpdate(change)
+}
+
+func (s *Service) pushConfigurationDeactivate(change *localdb.PendingChange) error {
+	// Local deactivate is represented as the latest snapshot push.
+	return s.pushConfigurationUpdate(change)
+}
+
+func (s *Service) pushConfigurationReactivate(change *localdb.PendingChange) error {
+	// Local reactivate is represented as the latest snapshot push.
+	return s.pushConfigurationUpdate(change)
+}
+
+func (s *Service) resolveConfigurationPayloadForPush(change *localdb.PendingChange) (ConfigurationChangePayload, models.Configuration, bool, error) {
+	payload, err := decodeConfigurationChangePayload(change)
+	if err != nil {
+		return ConfigurationChangePayload{}, models.Configuration{}, false, fmt.Errorf("decode configuration payload: %w", err)
+	}
+	eventVersionNo := payload.CurrentVersionNo
+
+	currentCfg, currentVersionID, currentVersionNo, err := s.loadCurrentConfigurationState(payload.ConfigurationUUID)
+	if err != nil {
+		// Local config may be gone (e.g. stale queue item after delete/cleanup). Treat as no-op.
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return payload, payload.Snapshot, true, nil
+		}
+		// create->deactivate race: config may no longer be active/visible locally, skip stale create.
+		if change.Operation == "create" {
+			return payload, payload.Snapshot, true, nil
+		}
+		return ConfigurationChangePayload{}, models.Configuration{}, false, fmt.Errorf("load current local configuration state: %w", err)
+	}
+
+	if payload.ConflictPolicy == "" {
+		payload.ConflictPolicy = "last_write_wins"
+	}
+
+	if currentCfg.UUID != "" {
+		payload.Snapshot = currentCfg
+		if currentVersionID != "" {
+			payload.CurrentVersionID = currentVersionID
+		}
+		if currentVersionNo > 0 {
+			payload.CurrentVersionNo = currentVersionNo
+		}
+	}
+
+	isStale := false
+	if eventVersionNo > 0 && currentVersionNo > eventVersionNo {
+		// Keep only latest intent in queue; older versions become no-op.
+		isStale = true
+	}
+	if !isStale && change.Operation == "create" {
+		localCfg, getErr := s.localDB.GetConfigurationByUUID(payload.ConfigurationUUID)
+		if getErr == nil && !localCfg.IsActive {
+			isStale = true
+		}
+	}
+
+	return payload, payload.Snapshot, isStale, nil
+}
+
+func decodeConfigurationChangePayload(change *localdb.PendingChange) (ConfigurationChangePayload, error) {
+	var payload ConfigurationChangePayload
+	if err := json.Unmarshal([]byte(change.Payload), &payload); err == nil && payload.ConfigurationUUID != "" && payload.Snapshot.UUID != "" {
+		if payload.Operation == "" {
+			payload.Operation = change.Operation
+		}
+		return payload, nil
+	}
+
+	// Backward compatibility: legacy queue stored raw models.Configuration JSON.
+	var cfg models.Configuration
+	if err := json.Unmarshal([]byte(change.Payload), &cfg); err != nil {
+		return ConfigurationChangePayload{}, fmt.Errorf("unmarshal legacy configuration payload: %w", err)
+	}
+
+	return ConfigurationChangePayload{
+		EventID:           "",
+		IdempotencyKey:    fmt.Sprintf("%s:%s:legacy", cfg.UUID, change.Operation),
+		ConfigurationUUID: cfg.UUID,
+		Operation:         change.Operation,
+		ConflictPolicy:    "last_write_wins",
+		Snapshot:          cfg,
+	}, nil
+}
+
+func (s *Service) loadCurrentConfigurationState(configurationUUID string) (models.Configuration, string, int, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(configurationUUID)
+	if err != nil {
+		return models.Configuration{}, "", 0, fmt.Errorf("get local configuration by uuid: %w", err)
+	}
+
+	cfg := *localdb.LocalToConfiguration(localCfg)
+
+	currentVersionID := ""
+	if localCfg.CurrentVersionID != nil {
+		currentVersionID = *localCfg.CurrentVersionID
+	}
+
+	currentVersionNo := 0
+	if currentVersionID != "" {
+		var version localdb.LocalConfigurationVersion
+		err = s.localDB.DB().
+			Where("id = ? AND configuration_uuid = ?", currentVersionID, configurationUUID).
+			First(&version).Error
+		if err == nil {
+			currentVersionNo = version.VersionNo
+		}
+	}
+
+	if currentVersionNo == 0 {
+		var latest localdb.LocalConfigurationVersion
+		err = s.localDB.DB().
+			Where("configuration_uuid = ?", configurationUUID).
+			Order("version_no DESC").
+			First(&latest).Error
+		if err == nil {
+			currentVersionNo = latest.VersionNo
+			currentVersionID = latest.ID
+		}
+	}
+
+	if currentVersionNo == 0 {
+		return models.Configuration{}, "", 0, fmt.Errorf("no local configuration version found for %s", configurationUUID)
+	}
+
+	return cfg, currentVersionID, currentVersionNo, nil
+}
+
+// NOTE: prepared for future conflict resolution:
+// when server starts storing version metadata, we can compare payload.CurrentVersionNo
+// against remote version and branch into custom strategies. For now use last-write-wins.
+
 // pushConfigurationDelete deletes a configuration from the server
 func (s *Service) pushConfigurationDelete(change *localdb.PendingChange) error {
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	configRepo := repository.NewConfigurationRepository(mariaDB)
+
 	// Get the configuration from server by UUID to get the ID
-	cfg, err := s.configRepo.GetByUUID(change.EntityUUID)
+	cfg, err := configRepo.GetByUUID(change.EntityUUID)
 	if err != nil {
 		// Already deleted or not found, consider it successful
 		slog.Warn("configuration not found on server, considering delete successful", "uuid", change.EntityUUID)
@@ -364,10 +776,10 @@ func (s *Service) pushConfigurationDelete(change *localdb.PendingChange) error {
 	}
 
 	// Delete from server
-	if err := s.configRepo.Delete(cfg.ID); err != nil {
+	if err := configRepo.Delete(cfg.ID); err != nil {
 		return fmt.Errorf("deleting configuration from server: %w", err)
 	}
 
-	slog.Info("configuration deleted from server", "uuid", change.EntityUUID)
+	slog.Info("configuration deleted on server", "uuid", change.EntityUUID)
 	return nil
 }

internal/services/sync/worker.go

@@ -5,23 +5,23 @@ import (
 	"log/slog"
 	"time"
 
-	"gorm.io/gorm"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
 )
 
 // Worker performs background synchronization at regular intervals
 type Worker struct {
 	service  *Service
-	db       *gorm.DB
+	connMgr  *db.ConnectionManager
 	interval time.Duration
 	logger   *slog.Logger
 	stopCh   chan struct{}
 }
 
 // NewWorker creates a new background sync worker
-func NewWorker(service *Service, db *gorm.DB, interval time.Duration) *Worker {
+func NewWorker(service *Service, connMgr *db.ConnectionManager, interval time.Duration) *Worker {
 	return &Worker{
 		service:  service,
-		db:       db,
+		connMgr:  connMgr,
 		interval: interval,
 		logger:   slog.Default(),
 		stopCh:   make(chan struct{}),
@@ -30,11 +30,7 @@ func NewWorker(service *Service, db *gorm.DB, interval time.Duration) *Worker {
 
 // isOnline checks if the database connection is available
 func (w *Worker) isOnline() bool {
-	sqlDB, err := w.db.DB()
-	if err != nil {
-		return false
-	}
-	return sqlDB.Ping() == nil
+	return w.connMgr.IsOnline()
 }
 
 // Start begins the background sync loop in a goroutine
@@ -75,21 +71,19 @@ func (w *Worker) runSync() {
 		return
 	}
 
-	w.logger.Debug("running background sync")
-
 	// Push pending changes first
 	pushed, err := w.service.PushPendingChanges()
 	if err != nil {
-		w.logger.Warn("failed to push pending changes", "error", err)
+		w.logger.Warn("background sync: failed to push pending changes", "error", err)
 	} else if pushed > 0 {
-		w.logger.Info("pushed pending changes", "count", pushed)
+		w.logger.Info("background sync: pushed pending changes", "count", pushed)
 	}
 
 	// Then check for new pricelists
 	err = w.service.SyncPricelistsIfNeeded()
 	if err != nil {
-		w.logger.Warn("failed to sync pricelists", "error", err)
+		w.logger.Warn("background sync: failed to sync pricelists", "error", err)
 	}
 
-	w.logger.Debug("background sync completed")
+	w.logger.Info("background sync cycle completed")
 }

migrations/005_add_owner_username.sql

@@ -0,0 +1,10 @@
+-- Store configuration owner as username (instead of relying on numeric user_id)
+ALTER TABLE qt_configurations
+    ADD COLUMN owner_username VARCHAR(100) NOT NULL DEFAULT '' AFTER user_id,
+    ADD INDEX idx_qt_configurations_owner_username (owner_username);
+
+-- Backfill owner_username from qt_users for existing rows
+UPDATE qt_configurations c
+LEFT JOIN qt_users u ON u.id = c.user_id
+SET c.owner_username = COALESCE(u.username, c.owner_username)
+WHERE c.owner_username = '';

migrations/006_add_local_configuration_versions.sql

@@ -0,0 +1,80 @@
+-- Add full-snapshot versioning for local configurations (SQLite)
+-- 1) Create local_configuration_versions
+-- 2) Add current_version_id to local_configurations
+-- 3) Backfill v1 snapshots from existing local_configurations
+
+PRAGMA foreign_keys = ON;
+
+BEGIN TRANSACTION;
+
+CREATE TABLE local_configuration_versions (
+    id TEXT PRIMARY KEY,
+    configuration_uuid TEXT NOT NULL,
+    version_no INTEGER NOT NULL,
+    data TEXT NOT NULL,
+    change_note TEXT NULL,
+    created_by TEXT NULL,
+    app_version TEXT NULL,
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (configuration_uuid) REFERENCES local_configurations(uuid),
+    UNIQUE(configuration_uuid, version_no)
+);
+
+ALTER TABLE local_configurations
+    ADD COLUMN current_version_id TEXT NULL;
+
+CREATE INDEX idx_lcv_config_created
+    ON local_configuration_versions(configuration_uuid, created_at DESC);
+
+CREATE INDEX idx_lcv_config_version
+    ON local_configuration_versions(configuration_uuid, version_no DESC);
+
+-- Backfill v1 snapshot for every existing configuration.
+INSERT INTO local_configuration_versions (
+    id,
+    configuration_uuid,
+    version_no,
+    data,
+    change_note,
+    created_by,
+    app_version,
+    created_at
+)
+SELECT
+    uuid || '-v1' AS id,
+    uuid AS configuration_uuid,
+    1 AS version_no,
+    json_object(
+        'uuid', uuid,
+        'server_id', server_id,
+        'name', name,
+        'items', CASE WHEN json_valid(items) THEN json(items) ELSE items END,
+        'total_price', total_price,
+        'custom_price', custom_price,
+        'notes', notes,
+        'is_template', is_template,
+        'server_count', server_count,
+        'price_updated_at', price_updated_at,
+        'created_at', created_at,
+        'updated_at', updated_at,
+        'synced_at', synced_at,
+        'sync_status', sync_status,
+        'original_user_id', original_user_id,
+        'original_username', original_username,
+        'app_version', NULL
+    ) AS data,
+    'Initial snapshot backfill (v1)' AS change_note,
+    NULL AS created_by,
+    NULL AS app_version,
+    COALESCE(created_at, CURRENT_TIMESTAMP) AS created_at
+FROM local_configurations;
+
+UPDATE local_configurations
+SET current_version_id = (
+    SELECT lcv.id
+    FROM local_configuration_versions lcv
+    WHERE lcv.configuration_uuid = local_configurations.uuid
+      AND lcv.version_no = 1
+);
+
+COMMIT;

migrations/007_detach_configurations_from_qt_users.sql

@@ -0,0 +1,25 @@
+-- Detach qt_configurations from qt_users (ownership is owner_username text)
+-- Safe for MySQL 8+/MariaDB 10.2+ via INFORMATION_SCHEMA checks.
+
+SET @fk_exists := (
+    SELECT COUNT(*)
+    FROM information_schema.TABLE_CONSTRAINTS
+    WHERE CONSTRAINT_SCHEMA = DATABASE()
+      AND TABLE_NAME = 'qt_configurations'
+      AND CONSTRAINT_NAME = 'fk_qt_configurations_user'
+      AND CONSTRAINT_TYPE = 'FOREIGN KEY'
+);
+
+SET @drop_fk_sql := IF(
+    @fk_exists > 0,
+    'ALTER TABLE qt_configurations DROP FOREIGN KEY fk_qt_configurations_user',
+    'SELECT ''fk_qt_configurations_user not found, skip'' '
+);
+PREPARE stmt_drop_fk FROM @drop_fk_sql;
+EXECUTE stmt_drop_fk;
+DEALLOCATE PREPARE stmt_drop_fk;
+
+-- user_id becomes optional legacy column (can stay NULL)
+ALTER TABLE qt_configurations
+    MODIFY COLUMN user_id BIGINT UNSIGNED NULL;
+

migrations/008_add_app_version_to_configurations.sql

@@ -0,0 +1,4 @@
+-- Track application version used for configuration writes (create/update via sync)
+ALTER TABLE qt_configurations
+    ADD COLUMN app_version VARCHAR(64) NULL DEFAULT NULL AFTER owner_username;
+

scripts/release.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+set -e
+
+# QuoteForge Release Build Script
+# Creates binaries for all platforms and packages them for release
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Get version from git
+VERSION=$(git describe --tags --always --dirty 2>/dev/null || echo "dev")
+if [[ $VERSION == *"dirty"* ]]; then
+    echo -e "${RED}✗ Error: Working directory has uncommitted changes${NC}"
+    echo "  Commit your changes first"
+    exit 1
+fi
+
+echo -e "${GREEN}Building QuoteForge version: ${VERSION}${NC}"
+echo ""
+
+# Create release directory
+RELEASE_DIR="releases/${VERSION}"
+mkdir -p "${RELEASE_DIR}"
+
+# Build for all platforms
+echo -e "${YELLOW}→ Building binaries...${NC}"
+make build-all
+
+# Package binaries with checksums
+echo ""
+echo -e "${YELLOW}→ Creating release packages...${NC}"
+
+# Linux AMD64
+if [ -f "bin/qfs-linux-amd64" ]; then
+    cd bin
+    tar -czf "../${RELEASE_DIR}/qfs-${VERSION}-linux-amd64.tar.gz" qfs-linux-amd64
+    cd ..
+    echo -e "${GREEN}  ✓ qfs-${VERSION}-linux-amd64.tar.gz${NC}"
+fi
+
+# macOS Intel
+if [ -f "bin/qfs-darwin-amd64" ]; then
+    cd bin
+    tar -czf "../${RELEASE_DIR}/qfs-${VERSION}-darwin-amd64.tar.gz" qfs-darwin-amd64
+    cd ..
+    echo -e "${GREEN}  ✓ qfs-${VERSION}-darwin-amd64.tar.gz${NC}"
+fi
+
+# macOS Apple Silicon
+if [ -f "bin/qfs-darwin-arm64" ]; then
+    cd bin
+    tar -czf "../${RELEASE_DIR}/qfs-${VERSION}-darwin-arm64.tar.gz" qfs-darwin-arm64
+    cd ..
+    echo -e "${GREEN}  ✓ qfs-${VERSION}-darwin-arm64.tar.gz${NC}"
+fi
+
+# Windows AMD64
+if [ -f "bin/qfs-windows-amd64.exe" ]; then
+    cd bin
+    zip -q "../${RELEASE_DIR}/qfs-${VERSION}-windows-amd64.zip" qfs-windows-amd64.exe
+    cd ..
+    echo -e "${GREEN}  ✓ qfs-${VERSION}-windows-amd64.zip${NC}"
+fi
+
+# Generate checksums
+echo ""
+echo -e "${YELLOW}→ Generating checksums...${NC}"
+cd "${RELEASE_DIR}"
+shasum -a 256 *.tar.gz *.zip > SHA256SUMS.txt 2>/dev/null || shasum -a 256 * | grep -v SHA256SUMS > SHA256SUMS.txt
+cd ../..
+echo -e "${GREEN}  ✓ SHA256SUMS.txt${NC}"
+
+# List release files
+echo ""
+echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${GREEN}Release ${VERSION} built successfully!${NC}"
+echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+echo "Files in ${RELEASE_DIR}:"
+ls -lh "${RELEASE_DIR}"
+echo ""
+
+# Show next steps
+echo -e "${YELLOW}Next steps:${NC}"
+echo "  1. Create git tag:"
+echo "     git tag -a ${VERSION} -m \"Release ${VERSION}\""
+echo ""
+echo "  2. Push tag to remote:"
+echo "     git push origin ${VERSION}"
+echo ""
+echo "  3. Create release on git.mchus.pro:"
+echo "     - Go to: https://git.mchus.pro/mchus/QuoteForge/releases"
+echo "     - Click 'New Release'"
+echo "     - Select tag: ${VERSION}"
+echo "     - Upload files from: ${RELEASE_DIR}/"
+echo ""
+echo -e "${GREEN}Done!${NC}"

web/templates/admin_pricing.html

@@ -9,6 +9,7 @@
             <div class="flex gap-4">
                 <button onclick="loadTab('alerts')" id="btn-alerts" class="text-blue-600 font-medium">Алерты</button>
                 <button onclick="loadTab('components')" id="btn-components" class="text-gray-600">Компоненты</button>
+                <button onclick="loadTab('pricelists')" id="btn-pricelists" class="text-gray-600">Прайслисты</button>
                 <button onclick="loadTab('all-configs')" id="btn-all-configs" class="text-gray-600 hidden">Все конфигурации</button>
             </div>
             <button onclick="recalculateAll()" id="btn-recalc" class="px-3 py-1 bg-green-600 text-white text-sm rounded hover:bg-green-700">
@@ -53,6 +54,60 @@
             <div class="text-center py-8 text-gray-500">Загрузка...</div>
         </div>
 
+        <!-- Pricelists Tab Content (hidden by default) -->
+        <div id="pricelists-tab-content" class="hidden">
+            <div class="flex justify-between items-center mb-4">
+                <h2 class="text-xl font-semibold">Прайслисты</h2>
+                <div id="pricelists-create-btn-container"></div>
+            </div>
+
+            <div class="bg-white rounded-lg shadow overflow-hidden">
+                <table class="min-w-full divide-y divide-gray-200">
+                    <thead class="bg-gray-50">
+                        <tr>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Версия</th>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Дата</th>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Автор</th>
+                            <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Позиций</th>
+                            <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Исп.</th>
+                            <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Статус</th>
+                            <th class="px-6 py-3 text-right text-xs font-medium text-gray-500 uppercase">Действия</th>
+                        </tr>
+                    </thead>
+                    <tbody id="pricelists-body" class="bg-white divide-y divide-gray-200">
+                        <tr>
+                            <td colspan="7" class="px-6 py-4 text-center text-gray-500">Загрузка...</td>
+                        </tr>
+                    </tbody>
+                </table>
+            </div>
+
+            <div id="pricelists-pagination" class="flex justify-center space-x-2 mt-4"></div>
+        </div>
+
+        <!-- Create Modal -->
+        <div id="pricelists-create-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
+            <div class="bg-white rounded-lg p-6 max-w-md w-full mx-4">
+                <h2 class="text-xl font-bold mb-4">Создать прайслист</h2>
+                <p class="text-sm text-gray-600 mb-4">
+                    Будет создан снимок текущих цен из базы данных.<br>
+                    Автор прайслиста: <span id="pricelists-db-username" class="font-medium">загрузка...</span>
+                </p>
+                <form id="pricelists-create-form" class="space-y-4">
+                    <div class="flex justify-end space-x-3">
+                        <button type="button" onclick="closePricelistsCreateModal()"
+                                class="px-4 py-2 text-gray-700 border border-gray-300 rounded-md hover:bg-gray-50">
+                            Отмена
+                        </button>
+                        <button type="submit"
+                                class="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700">
+                            Создать
+                        </button>
+                    </div>
+                </form>
+            </div>
+        </div>
+
         <!-- Pagination -->
         <div id="pagination" class="flex justify-between items-center mt-4 pt-4 border-t hidden">
             <span id="page-info" class="text-sm text-gray-600"></span>
@@ -157,6 +212,10 @@ let currentSearch = '';
 let componentsCache = [];
 let sortField = 'popularity_score';
 let sortDir = 'desc';
+let pricelistsPage = 1;
+let pricelistsCanWrite = false;
+let isCreatingPricelist = false;
+let cachedDbUsername = null;
 
 async function loadTab(tab) {
     currentTab = tab;
@@ -166,6 +225,7 @@ async function loadTab(tab) {
 
     document.getElementById('btn-alerts').className = tab === 'alerts' ? 'text-blue-600 font-medium' : 'text-gray-600';
     document.getElementById('btn-components').className = tab === 'components' ? 'text-blue-600 font-medium' : 'text-gray-600';
+    document.getElementById('btn-pricelists').className = tab === 'pricelists' ? 'text-blue-600 font-medium' : 'text-gray-600';
     document.getElementById('btn-all-configs').className = tab === 'all-configs' ? 'text-blue-600 font-medium' : 'text-gray-600 hidden';
 
     // Show/hide elements based on tab
@@ -173,17 +233,34 @@ async function loadTab(tab) {
         document.getElementById('search-bar').className = 'mb-4';
         document.getElementById('pagination').className = 'flex justify-between items-center mt-4 pt-4 border-t';
         document.getElementById('btn-all-configs').className = 'text-gray-600 hidden'; // Hide this tab for components
+        document.getElementById('pricelists-tab-content').className = 'hidden';
+        document.getElementById('tab-content').className = '';
     } else if (tab === 'all-configs') {
         document.getElementById('search-bar').className = 'mb-4 hidden'; // Hide search for all configs
         document.getElementById('pagination').className = 'flex justify-between items-center mt-4 pt-4 border-t'; // Show pagination
         document.getElementById('btn-all-configs').className = 'text-blue-600 font-medium'; // Show this tab for all configs
+        document.getElementById('pricelists-tab-content').className = 'hidden';
+        document.getElementById('tab-content').className = '';
+    } else if (tab === 'pricelists') {
+        document.getElementById('search-bar').className = 'mb-4 hidden';
+        document.getElementById('pagination').className = 'hidden';
+        document.getElementById('btn-all-configs').className = 'text-gray-600 hidden';
+        document.getElementById('pricelists-tab-content').className = '';
+        document.getElementById('tab-content').className = 'hidden';
+        // Load pricelists when pricelists tab is selected
+        checkPricelistWritePermission();
+        loadPricelists(1);
     } else {
         document.getElementById('search-bar').className = 'mb-4 hidden';
         document.getElementById('pagination').className = 'hidden';
         document.getElementById('btn-all-configs').className = 'text-gray-600 hidden';
+        document.getElementById('pricelists-tab-content').className = 'hidden';
+        document.getElementById('tab-content').className = '';
     }
 
-    await loadData();
+    if (tab !== 'pricelists') {
+        await loadData();
+    }
 }
 
 async function loadData() {
@@ -514,8 +591,21 @@ async function fetchPreview() {
             document.getElementById('modal-new-price').textContent =
                 data.new_price ? '$' + parseFloat(data.new_price).toFixed(2) : '—';
 
-            // Update quote count
-            document.getElementById('modal-quote-count').textContent = data.quote_count || 0;
+            // Update quote count with new format "N (всего: M)"
+            let quoteCountText = '';
+            if (data.quote_count_period !== undefined && data.quote_count_total !== undefined) {
+                if (data.quote_count_period === data.quote_count_total) {
+                    // If period count equals total count, just show the total
+                    quoteCountText = data.quote_count_total;
+                } else {
+                    // Show both counts in format "N (всего: M)"
+                    quoteCountText = data.quote_count_period + ' (всего: ' + data.quote_count_total + ')';
+                }
+            } else {
+                // Fallback for older API responses
+                quoteCountText = data.quote_count || 0;
+            }
+            document.getElementById('modal-quote-count').textContent = quoteCountText;
         }
     } catch(e) {
         console.error('Preview fetch error:', e);
@@ -771,7 +861,7 @@ function renderAllConfigs(configs) {
         const date = new Date(c.created_at).toLocaleDateString('ru-RU');
         const total = c.total_price ? '$' + c.total_price.toLocaleString('en-US', {minimumFractionDigits: 2}) : '—';
         const serverCount = c.server_count ? c.server_count : 1;
-        const username = c.user ? c.user.username : '—';
+        const username = c.owner_username || (c.user ? c.user.username : '—');
 
         html += '<tr class="hover:bg-gray-50">';
         html += '<td class="px-3 py-2 text-sm text-gray-500">' + date + '</td>';
@@ -803,7 +893,10 @@ function renderAllConfigs(configs) {
 }
 
 document.addEventListener('DOMContentLoaded', () => {
-    loadTab('alerts');
+    // Check URL params for initial tab
+    const urlParams = new URLSearchParams(window.location.search);
+    const initialTab = urlParams.get('tab') || 'alerts';
+    loadTab(initialTab);
 
     // Add event listeners for preview updates
     document.getElementById('modal-period').addEventListener('change', fetchPreview);
@@ -811,6 +904,217 @@ document.addEventListener('DOMContentLoaded', () => {
     document.getElementById('modal-manual-price').addEventListener('input', debounceFetchPreview);
     document.getElementById('modal-meta-prices').addEventListener('input', debounceFetchPreview);
 });
+
+// Pricelists functions
+let canWrite = false;
+
+async function checkPricelistWritePermission() {
+    try {
+        const resp = await fetch('/api/pricelists/can-write');
+        const data = await resp.json();
+        pricelistsCanWrite = data.can_write;
+
+        if (pricelistsCanWrite) {
+            document.getElementById('pricelists-create-btn-container').innerHTML = `
+                <button onclick="openPricelistsCreateModal()" class="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700">
+                    Создать прайслист
+                </button>
+            `;
+        }
+    } catch (e) {
+        console.error('Failed to check pricelist write permission:', e);
+    }
+}
+
+async function loadPricelists(page = 1) {
+    pricelistsPage = page;
+    try {
+        const resp = await fetch(`/api/pricelists?page=${page}&per_page=20`);
+        const data = await resp.json();
+
+        renderPricelists(data.pricelists || []);
+        renderPricelistsPagination(data.total, data.page, data.per_page);
+    } catch (e) {
+        document.getElementById('pricelists-body').innerHTML = `
+            <tr>
+                <td colspan="7" class="px-6 py-4 text-center text-red-500">
+                    Ошибка загрузки: ${e.message}
+                </td>
+            </tr>
+        `;
+        // Hide pagination when there's an error
+        document.getElementById('pricelists-pagination').innerHTML = '';
+    }
+}
+
+function renderPricelists(pricelists) {
+    if (pricelists.length === 0) {
+        document.getElementById('pricelists-body').innerHTML = `
+            <tr>
+                <td colspan="7" class="px-6 py-4 text-center text-gray-500">
+                    Прайслисты не найдены. ${pricelistsCanWrite ? 'Создайте первый прайслист.' : ''}
+                </td>
+            </tr>
+        `;
+        return;
+    }
+
+    const html = pricelists.map(pl => {
+        const date = new Date(pl.created_at).toLocaleDateString('ru-RU');
+        const statusClass = pl.is_active ? 'bg-green-100 text-green-800' : 'bg-gray-100 text-gray-800';
+        const statusText = pl.is_active ? 'Активен' : 'Неактивен';
+
+        let actions = `<a href="/pricelists/${pl.id}" class="text-blue-600 hover:text-blue-800 text-sm">Просмотр</a>`;
+        if (pricelistsCanWrite && pl.usage_count === 0) {
+            actions += ` <button onclick="deletePricelist(${pl.id})" class="text-red-600 hover:text-red-800 text-sm ml-2">Удалить</button>`;
+        }
+
+        return `
+            <tr class="hover:bg-gray-50">
+                <td class="px-6 py-4 whitespace-nowrap">
+                    <span class="font-mono text-sm">${pl.version}</span>
+                </td>
+                <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${date}</td>
+                <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${pl.created_by || '-'}</td>
+                <td class="px-6 py-4 whitespace-nowrap text-center text-sm">${pl.item_count}</td>
+                <td class="px-6 py-4 whitespace-nowrap text-center text-sm">${pl.usage_count}</td>
+                <td class="px-6 py-4 whitespace-nowrap text-center">
+                    <span class="px-2 py-1 text-xs rounded-full ${statusClass}">${statusText}</span>
+                </td>
+                <td class="px-6 py-4 whitespace-nowrap text-right">${actions}</td>
+            </tr>
+        `;
+    }).join('');
+
+    document.getElementById('pricelists-body').innerHTML = html;
+}
+
+function renderPricelistsPagination(total, page, perPage) {
+    const totalPages = Math.ceil(total / perPage);
+    if (totalPages <= 1) {
+        document.getElementById('pricelists-pagination').innerHTML = '';
+        return;
+    }
+
+    let html = '';
+    for (let i = 1; i <= totalPages; i++) {
+        const activeClass = i === page ? 'bg-blue-600 text-white' : 'bg-white text-gray-700 hover:bg-gray-50';
+        html += `<button onclick="loadPricelists(${i})" class="px-3 py-1 rounded border ${activeClass}">${i}</button>`;
+    }
+
+    document.getElementById('pricelists-pagination').innerHTML = html;
+}
+
+async function loadPricelistsDbUsername() {
+    if (cachedDbUsername) {
+        document.getElementById('pricelists-db-username').textContent = cachedDbUsername;
+        return;
+    }
+
+    try {
+        const resp = await fetch('/api/current-user');
+        const data = await resp.json();
+        cachedDbUsername = data.username || 'неизвестно';
+        document.getElementById('pricelists-db-username').textContent = cachedDbUsername;
+    } catch (e) {
+        document.getElementById('pricelists-db-username').textContent = 'неизвестно';
+    }
+}
+
+function openPricelistsCreateModal() {
+    document.getElementById('pricelists-create-modal').classList.remove('hidden');
+    document.getElementById('pricelists-create-modal').classList.add('flex');
+    loadPricelistsDbUsername();
+}
+
+function closePricelistsCreateModal() {
+    document.getElementById('pricelists-create-modal').classList.add('hidden');
+    document.getElementById('pricelists-create-modal').classList.remove('flex');
+}
+
+async function checkOnlineStatus() {
+    try {
+        const resp = await fetch('/api/db-status');
+        const data = await resp.json();
+        return data.connected === true;
+    } catch(e) {
+        return false;
+    }
+}
+
+async function createPricelist() {
+    // Check if online before creating
+    const isOnline = await checkOnlineStatus();
+    if (!isOnline) {
+        throw new Error('Создание прайслистов доступно только в онлайн режиме');
+    }
+
+    const resp = await fetch('/api/pricelists', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({})
+    });
+
+    if (!resp.ok) {
+        const data = await resp.json();
+        throw new Error(data.error || 'Failed to create pricelist');
+    }
+
+    return await resp.json();
+}
+
+async function deletePricelist(id) {
+    // Check if online before deleting
+    const isOnline = await checkOnlineStatus();
+    if (!isOnline) {
+        showToast('Удаление прайслистов доступно только в онлайн режиме', 'error');
+        return;
+    }
+
+    if (!confirm('Удалить этот прайслист?')) return;
+
+    try {
+        const resp = await fetch(`/api/pricelists/${id}`, {
+            method: 'DELETE'
+        });
+
+        if (!resp.ok) {
+            const data = await resp.json();
+            throw new Error(data.error || 'Failed to delete');
+        }
+
+        showToast('Прайслист удален', 'success');
+        loadPricelists(pricelistsPage);
+    } catch (e) {
+        showToast('Ошибка: ' + e.message, 'error');
+    }
+}
+
+document.getElementById('pricelists-create-form').addEventListener('submit', async function(e) {
+    e.preventDefault();
+
+    if (isCreatingPricelist) return; // protection from double-submit
+    isCreatingPricelist = true;
+
+    const submitBtn = this.querySelector('button[type="submit"]');
+    submitBtn.disabled = true;
+    submitBtn.textContent = 'Создание...';
+
+    try {
+        const pl = await createPricelist();
+        closePricelistsCreateModal();
+        showToast(`Прайслист ${pl.version} создан (${pl.item_count} позиций)`, 'success');
+        loadPricelists(1);
+    } catch (e) {
+        showToast('Ошибка: ' + e.message, 'error');
+    } finally {
+        isCreatingPricelist = false;
+        submitBtn.disabled = false;
+        submitBtn.textContent = 'Создать';
+    }
+});
 </script>
 {{end}}
 

web/templates/base.html

@@ -19,19 +19,18 @@
                 <div class="flex items-center space-x-8">
                     <a href="/" class="text-xl font-bold text-blue-600">QuoteForge</a>
                     <div class="hidden md:flex space-x-4">
-                        <a href="/pricelists" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Прайслисты</a>
                         <a href="/configurator" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Конфигуратор</a>
-                        <a id="admin-pricing-link" href="/admin/pricing" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm hidden">Администратор цен</a>
+                        <a id="admin-pricing-link" href="/admin/pricing" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Администратор цен</a>
                         <a href="/setup" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Настройки</a>
                     </div>
                 </div>
                 <div class="flex items-center space-x-4">
                     <!-- Sync Status Indicator (htmx-powered) -->
                     <div id="sync-status"
+                         class="flex items-center gap-3 text-sm"
                          hx-get="/partials/sync-status"
                          hx-trigger="load, refresh from:body, every 30s"
                          hx-swap="innerHTML">
-                        <span class="animate-pulse text-gray-400 text-xs">Загрузка...</span>
                     </div>
                     <span id="db-user" class="text-sm text-gray-600"></span>
                 </div>
@@ -45,6 +44,52 @@
 
     <div id="toast" class="fixed bottom-4 right-4 z-50"></div>
 
+    <!-- Sync Info Modal -->
+    <div id="sync-modal" class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 hidden">
+        <div class="bg-white rounded-lg shadow-xl max-w-md w-full mx-4">
+            <div class="p-6">
+                <div class="flex justify-between items-center mb-4">
+                    <h3 class="text-lg font-medium text-gray-900">Информация о синхронизации</h3>
+                    <button onclick="closeSyncModal()" class="text-gray-400 hover:text-gray-500">
+                        <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
+                        </svg>
+                    </button>
+                </div>
+
+                <div class="space-y-4">
+                    <div>
+                        <h4 class="font-medium text-gray-900">Статус БД</h4>
+                        <p id="modal-db-status" class="text-sm text-gray-600">Проверка...</p>
+                    </div>
+
+                    <div>
+                        <h4 class="font-medium text-gray-900">Количество ошибок</h4>
+                        <p id="modal-error-count" class="text-sm text-gray-600">0</p>
+                    </div>
+
+                    <div>
+                        <h4 class="font-medium text-gray-900">Последняя синхронизация</h4>
+                        <p id="modal-last-sync" class="text-sm text-gray-600">-</p>
+                    </div>
+
+                    <div>
+                        <h4 class="font-medium text-gray-900">Список ошибок</h4>
+                        <div id="modal-errors-list" class="mt-2 text-sm text-gray-600 max-h-40 overflow-y-auto">
+                            <p>Нет ошибок</p>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-6 flex justify-end">
+                    <button onclick="closeSyncModal()" class="px-4 py-2 bg-gray-600 text-white rounded-md hover:bg-gray-700">
+                        Закрыть
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+
     <footer class="fixed bottom-0 left-0 right-0 bg-gray-800 text-gray-300 text-xs py-1 px-4">
         <div class="max-w-7xl mx-auto flex justify-between">
             <span id="db-status">БД: проверка...</span>
@@ -60,6 +105,115 @@
             setTimeout(() => el.innerHTML = '', 3000);
         }
 
+        // Open sync modal
+        function openSyncModal() {
+            const modal = document.getElementById('sync-modal');
+            if (modal) {
+                modal.classList.remove('hidden');
+                // Load sync info when modal opens
+                loadSyncInfo();
+            }
+        }
+
+        // Close sync modal
+        function closeSyncModal() {
+            const modal = document.getElementById('sync-modal');
+            if (modal) {
+                modal.classList.add('hidden');
+            }
+        }
+
+        // Load sync info for modal
+        async function loadSyncInfo() {
+            try {
+                const resp = await fetch('/api/sync/info');
+                const data = await resp.json();
+
+                document.getElementById('modal-db-status').textContent = data.is_online ? 'Подключено' : 'Отключено';
+                document.getElementById('modal-error-count').textContent = data.error_count;
+
+                if (data.last_sync_at) {
+                    const date = new Date(data.last_sync_at);
+                    document.getElementById('modal-last-sync').textContent = date.toLocaleString('ru-RU');
+                } else {
+                    document.getElementById('modal-last-sync').textContent = 'Нет данных';
+                }
+
+                // Load error list
+                const errorsList = document.getElementById('modal-errors-list');
+                if (data.errors && data.errors.length > 0) {
+                    errorsList.innerHTML = data.errors.map(error =>
+                        `<div class="mb-1"><span class="font-medium">${error.timestamp}</span>: ${error.message}</div>`
+                    ).join('');
+                } else {
+                    errorsList.innerHTML = '<p>Нет ошибок</p>';
+                }
+            } catch(e) {
+                console.error('Failed to load sync info:', e);
+                document.getElementById('modal-db-status').textContent = 'Ошибка загрузки';
+                document.getElementById('modal-error-count').textContent = '0';
+                document.getElementById('modal-last-sync').textContent = '-';
+                document.getElementById('modal-errors-list').innerHTML = '<p>Ошибка загрузки данных</p>';
+            }
+        }
+
+        // Event delegation for sync dropdown and actions
+        document.addEventListener('DOMContentLoaded', function() {
+            checkDbStatus();
+            checkWritePermission();
+        });
+
+        // Event delegation for sync actions
+        document.body.addEventListener('click', function(e) {
+            // Handle sync button click (full sync only)
+            const syncButton = e.target.closest('#sync-button');
+            if (syncButton) {
+                e.stopPropagation();
+                const button = syncButton;
+
+                // Add loading state
+                const originalHTML = button.innerHTML;
+                button.disabled = true;
+                button.innerHTML = '<svg class="animate-spin w-4 h-4 inline mr-2" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';
+
+                fullSync(button, originalHTML);
+            }
+        });
+
+        // Refactored sync action function to reduce duplication
+        async function syncAction(endpoint, successMessage, button, originalHTML) {
+            try {
+                const resp = await fetch(endpoint, { method: 'POST' });
+                const data = await resp.json();
+
+                if (data.success) {
+                    showToast(successMessage, 'success');
+                    // Update last sync time - removed since dropdown is gone
+                    // loadLastSyncTime();
+                } else {
+                    showToast('Ошибка: ' + (data.error || 'неизвестная ошибка'), 'error');
+                }
+
+                htmx.trigger('#sync-status', 'refresh');
+            } catch (error) {
+                showToast('Ошибка: ' + error.message, 'error');
+            } finally {
+                // Reset button state
+                if (button) {
+                    button.disabled = false;
+                    button.innerHTML = originalHTML;
+                }
+            }
+        }
+
+        function pushPendingChanges(button, originalHTML) {
+            syncAction('/api/sync/push', 'Изменения синхронизированы', button, originalHTML);
+        }
+
+        function fullSync(button, originalHTML) {
+            syncAction('/api/sync/all', 'Полная синхронизация завершена', button, originalHTML);
+        }
+
         async function checkDbStatus() {
             try {
                 const resp = await fetch('/api/db-status');
@@ -83,23 +237,36 @@
             }
         }
 
+        // Admin pricing link is now always visible
+        // Write permission is checked at operation time (create/delete)
         async function checkWritePermission() {
-            try {
-                const resp = await fetch('/api/pricelists/can-write');
-                const data = await resp.json();
-                if (data.can_write) {
-                    const link = document.getElementById('admin-pricing-link');
-                    if (link) link.classList.remove('hidden');
-                }
-            } catch(e) {
-                console.error('Failed to check write permission:', e);
-            }
+            // No longer needed - link always visible in offline-first mode
+            // Operations will check online status when executed
         }
 
-        document.addEventListener('DOMContentLoaded', function() {
-            checkDbStatus();
-            checkWritePermission();
-        });
+        // Load last sync time for dropdown (removed since dropdown is gone)
+        // async function loadLastSyncTime() {
+        //     try {
+        //         const resp = await fetch('/api/sync/status');
+        //         const data = await resp.json();
+        //         if (data.last_pricelist_sync) {
+        //             const date = new Date(data.last_pricelist_sync);
+        //             document.getElementById('last-sync-time').textContent = date.toLocaleString('ru-RU');
+        //         } else {
+        //             document.getElementById('last-sync-time').textContent = 'Нет данных';
+        //         }
+        //     } catch(e) {
+        //         console.error('Failed to load last sync time:', e);
+        //     }
+        // }
+
+        // Call functions immediately to ensure they run even before DOMContentLoaded
+        // This ensures username and admin link are visible ASAP
+        checkDbStatus();
+        checkWritePermission();
+
+        // Load last sync time - removed since dropdown is gone
+        // document.addEventListener('DOMContentLoaded', loadLastSyncTime);
     </script>
 </body>
 </html>

web/templates/configs.html

@@ -4,10 +4,31 @@
 <div class="space-y-4">
     <h1 class="text-2xl font-bold">Мои конфигурации</h1>
 
-    <div class="mt-4">
-        <button onclick="openCreateModal()" class="w-full py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 font-medium">
+    <div id="action-buttons" class="mt-4 grid grid-cols-1 sm:grid-cols-2 gap-3">
+        <button onclick="openCreateModal()" class="py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 font-medium">
             + Создать новую конфигурацию
         </button>
+        <button id="import-configs-btn" onclick="importConfigsFromServer()" class="py-3 bg-emerald-600 text-white rounded-lg hover:bg-emerald-700 font-medium">
+            Импорт с сервера
+        </button>
+    </div>
+
+    <div class="mt-4 inline-flex rounded-lg border border-gray-200 overflow-hidden">
+        <button id="status-active-btn" onclick="setConfigStatusMode('active')" class="px-4 py-2 text-sm font-medium bg-blue-600 text-white">
+            Активные
+        </button>
+        <button id="status-archived-btn" onclick="setConfigStatusMode('archived')" class="px-4 py-2 text-sm font-medium bg-white text-gray-700 hover:bg-gray-50 border-l border-gray-200">
+            Архив
+        </button>
+    </div>
+
+    <div id="pricelist-badge" class="mt-4 text-sm text-gray-600 hidden">
+        <span class="bg-blue-100 text-blue-800 px-2 py-1 rounded-full">
+            <svg class="w-4 h-4 inline mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"></path>
+            </svg>
+            Активный прайслист: <span id="pricelist-version">-</span>
+        </span>
     </div>
 
     <div id="configs-list">
@@ -103,11 +124,15 @@
 let currentPage = 1;
 let totalPages = 1;
 let perPage = 20;
+let configStatusMode = 'active';
 
 function renderConfigs(configs) {
+    const emptyText = configStatusMode === 'archived'
+        ? 'Архив пуст'
+        : 'Нет сохраненных конфигураций';
     if (configs.length === 0) {
         document.getElementById('configs-list').innerHTML =
-            '<div class="bg-white rounded-lg shadow p-8 text-center text-gray-500">Нет сохраненных конфигураций</div>';
+            '<div class="bg-white rounded-lg shadow p-8 text-center text-gray-500">' + emptyText + '</div>';
         return;
     }
 
@@ -115,6 +140,7 @@ function renderConfigs(configs) {
     html += '<thead class="bg-gray-50"><tr>';
     html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Дата</th>';
     html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Название</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Автор</th>';
     html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Цена (за 1 шт)</th>';
     html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Кол-во</th>';
     html += '<th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Сумма</th>';
@@ -125,6 +151,7 @@ function renderConfigs(configs) {
         const date = new Date(c.created_at).toLocaleDateString('ru-RU');
         const total = c.total_price ? '$' + c.total_price.toLocaleString('en-US', {minimumFractionDigits: 2}) : '—';
         const serverCount = c.server_count ? c.server_count : 1;
+        const author = c.owner_username || (c.user && c.user.username) || '—';
 
         // Calculate price per unit (total / server count)
         let pricePerUnit = '—';
@@ -135,26 +162,39 @@ function renderConfigs(configs) {
 
         html += '<tr class="hover:bg-gray-50">';
         html += '<td class="px-4 py-3 text-sm text-gray-500">' + date + '</td>';
-        html += '<td class="px-4 py-3 text-sm font-medium"><a href="/configurator?uuid=' + c.uuid + '" class="text-blue-600 hover:text-blue-800 hover:underline">' + escapeHtml(c.name) + '</a></td>';
+        if (configStatusMode === 'archived') {
+            html += '<td class="px-4 py-3 text-sm font-medium text-gray-700">' + escapeHtml(c.name) + '</td>';
+        } else {
+            html += '<td class="px-4 py-3 text-sm font-medium"><a href="/configurator?uuid=' + c.uuid + '" class="text-blue-600 hover:text-blue-800 hover:underline">' + escapeHtml(c.name) + '</a></td>';
+        }
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + escapeHtml(author) + '</td>';
         html += '<td class="px-4 py-3 text-sm text-gray-500">' + pricePerUnit + '</td>';
         html += '<td class="px-4 py-3 text-sm text-gray-500">' + serverCount + '</td>';
         html += '<td class="px-4 py-3 text-sm text-right">' + total + '</td>';
         html += '<td class="px-4 py-3 text-sm text-right space-x-2">';
-        html += '<button onclick="openCloneModal(\'' + c.uuid + '\', \'' + escapeHtml(c.name).replace(/'/g, "\\'") + '\')" class="text-green-600 hover:text-green-800" title="Копировать">';
-        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
-        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"></path>';
-        html += '</svg>';
-        html += '</button>';
-        html += '<button onclick="openRenameModal(\'' + c.uuid + '\', \'' + escapeHtml(c.name).replace(/'/g, "\\'") + '\')" class="text-blue-600 hover:text-blue-800" title="Переименовать">';
-        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
-        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"></path>';
-        html += '</svg>';
-        html += '</button>';
-        html += '<button onclick="deleteConfig(\'' + c.uuid + '\')" class="text-red-600 hover:text-red-800" title="Удалить">';
-        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
-        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"></path>';
-        html += '</svg>';
-        html += '</button>';
+        if (configStatusMode === 'archived') {
+            html += '<button onclick="reactivateConfig(\'' + c.uuid + '\')" class="text-emerald-600 hover:text-emerald-800" title="Восстановить">';
+            html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+            html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"></path>';
+            html += '</svg>';
+            html += '</button>';
+        } else {
+            html += '<button onclick="openCloneModal(\'' + c.uuid + '\', \'' + escapeHtml(c.name).replace(/'/g, "\\'") + '\')" class="text-green-600 hover:text-green-800" title="Копировать">';
+            html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+            html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"></path>';
+            html += '</svg>';
+            html += '</button>';
+            html += '<button onclick="openRenameModal(\'' + c.uuid + '\', \'' + escapeHtml(c.name).replace(/'/g, "\\'") + '\')" class="text-blue-600 hover:text-blue-800" title="Переименовать">';
+            html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+            html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"></path>';
+            html += '</svg>';
+            html += '</button>';
+            html += '<button onclick="deleteConfig(\'' + c.uuid + '\')" class="text-red-600 hover:text-red-800" title="В архив">';
+            html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+            html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"></path>';
+            html += '</svg>';
+            html += '</button>';
+        }
         html += '</td></tr>';
     });
 
@@ -169,13 +209,25 @@ function escapeHtml(text) {
 }
 
 async function deleteConfig(uuid) {
-    if (!confirm('Удалить?')) return;
+    if (!confirm('Переместить конфигурацию в архив?')) return;
     await fetch('/api/configs/' + uuid, {
         method: 'DELETE'
     });
     loadConfigs();
 }
 
+async function reactivateConfig(uuid) {
+    if (!confirm('Восстановить конфигурацию из архива?')) return;
+    const resp = await fetch('/api/configs/' + uuid + '/reactivate', {
+        method: 'POST'
+    });
+    if (!resp.ok) {
+        alert('Не удалось восстановить конфигурацию');
+        return;
+    }
+    loadConfigs();
+}
+
 function openRenameModal(uuid, currentName) {
     document.getElementById('rename-uuid').value = uuid;
     document.getElementById('rename-input').value = currentName;
@@ -370,18 +422,46 @@ function nextPage() {
 }
 
 function updatePagination(total) {
-    totalPages = Math.ceil(total / perPage);
+    totalPages = Math.max(1, Math.ceil(total / perPage));
     document.getElementById('page-info').textContent =
         'Страница ' + currentPage + ' из ' + totalPages + ' (всего: ' + total + ')';
     document.getElementById('btn-prev').disabled = currentPage <= 1;
     document.getElementById('btn-next').disabled = currentPage >= totalPages;
-    document.getElementById('pagination').classList.remove('hidden');
+    if (total <= perPage) {
+        document.getElementById('pagination').classList.add('hidden');
+    } else {
+        document.getElementById('pagination').classList.remove('hidden');
+    }
+}
+
+function setConfigStatusMode(mode) {
+    if (mode !== 'active' && mode !== 'archived') return;
+    configStatusMode = mode;
+    currentPage = 1;
+    applyStatusModeUI();
+    loadConfigs();
+}
+
+function applyStatusModeUI() {
+    const activeBtn = document.getElementById('status-active-btn');
+    const archivedBtn = document.getElementById('status-archived-btn');
+    const actionButtons = document.getElementById('action-buttons');
+
+    if (configStatusMode === 'archived') {
+        activeBtn.className = 'px-4 py-2 text-sm font-medium bg-white text-gray-700 hover:bg-gray-50';
+        archivedBtn.className = 'px-4 py-2 text-sm font-medium bg-blue-600 text-white border-l border-gray-200';
+        actionButtons.classList.add('hidden');
+    } else {
+        activeBtn.className = 'px-4 py-2 text-sm font-medium bg-blue-600 text-white';
+        archivedBtn.className = 'px-4 py-2 text-sm font-medium bg-white text-gray-700 hover:bg-gray-50 border-l border-gray-200';
+        actionButtons.classList.remove('hidden');
+    }
 }
 
 // Load configs with pagination
 async function loadConfigs() {
     try {
-        const resp = await fetch('/api/configs?page=' + currentPage + '&per_page=' + perPage);
+        const resp = await fetch('/api/configs?page=' + currentPage + '&per_page=' + perPage + '&status=' + configStatusMode);
 
         if (!resp.ok) {
             document.getElementById('configs-list').innerHTML =
@@ -398,7 +478,72 @@ async function loadConfigs() {
     }
 }
 
-document.addEventListener('DOMContentLoaded', loadConfigs);
+async function importConfigsFromServer() {
+    const button = document.getElementById('import-configs-btn');
+    const originalText = button.textContent;
+    button.disabled = true;
+    button.textContent = 'Импорт...';
+
+    try {
+        const resp = await fetch('/api/configs/import', { method: 'POST' });
+        const data = await resp.json();
+
+        if (!resp.ok) {
+            alert('Ошибка импорта: ' + (data.error || 'неизвестная ошибка'));
+            return;
+        }
+
+        alert(
+            'Импорт завершен:\n' +
+            '- Новых: ' + (data.imported || 0) + '\n' +
+            '- Обновлено: ' + (data.updated || 0) + '\n' +
+            '- Пропущено (локальные изменения): ' + (data.skipped || 0)
+        );
+
+        currentPage = 1;
+        await loadConfigs();
+    } catch (e) {
+        alert('Ошибка импорта с сервера');
+    } finally {
+        button.disabled = false;
+        button.textContent = originalText;
+    }
+}
+
+document.addEventListener('DOMContentLoaded', function() {
+    applyStatusModeUI();
+    loadConfigs();
+
+    // Load latest pricelist version for badge
+    loadLatestPricelistVersion();
+});
+
+async function loadLatestPricelistVersion() {
+    try {
+        const resp = await fetch('/api/pricelists/latest');
+        if (resp.ok) {
+            const pricelist = await resp.json();
+            document.getElementById('pricelist-version').textContent = pricelist.version;
+            document.getElementById('pricelist-badge').classList.remove('hidden');
+        } else if (resp.status === 404) {
+            // No active pricelist (normal in offline mode or when not synced)
+            document.getElementById('pricelist-version').textContent = 'Не загружен';
+            document.getElementById('pricelist-badge').classList.remove('hidden');
+            document.getElementById('pricelist-badge').classList.add('bg-gray-100', 'text-gray-600');
+        } else {
+            // Real error
+            document.getElementById('pricelist-version').textContent = 'Ошибка загрузки';
+            document.getElementById('pricelist-badge').classList.remove('hidden');
+            document.getElementById('pricelist-badge').classList.add('bg-red-100', 'text-red-800');
+        }
+    } catch(e) {
+        // Network error or other exception
+        console.error('Failed to load pricelist version:', e);
+        document.getElementById('pricelist-version').textContent = 'Не доступен';
+        document.getElementById('pricelist-badge').classList.remove('hidden');
+        document.getElementById('pricelist-badge').classList.add('bg-gray-100', 'text-gray-600');
+    }
+}
 </script>
 {{end}}
 

web/templates/partials/sync_status.html

@@ -1,37 +1,37 @@
 {{define "sync_status"}}
-<div class="flex items-center gap-2">
+<div class="flex items-center gap-2 relative">
     {{if .IsOffline}}
-    <span class="flex items-center gap-1 text-red-600" title="Offline">
-        <span class="w-2 h-2 bg-red-500 rounded-full"></span>
-        <span class="text-xs">Offline</span>
+    <span class="flex items-center gap-1 text-red-600 cursor-pointer" title="Offline" onclick="openSyncModal()">
+        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
+        </svg>
     </span>
     {{else}}
-    <span class="flex items-center gap-1 text-green-600" title="Online">
-        <span class="w-2 h-2 bg-green-500 rounded-full"></span>
-        <span class="text-xs">Online</span>
+    <span class="flex items-center gap-1 text-green-600 cursor-pointer" title="Online" onclick="openSyncModal()">
+        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+        </svg>
     </span>
     {{end}}
 
     {{if gt .PendingCount 0}}
-    <span class="bg-yellow-100 text-yellow-800 px-2 py-0.5 rounded-full text-xs font-medium">
-        {{.PendingCount}} pending
+    <span class="bg-yellow-100 text-yellow-800 px-2 py-0.5 rounded-full text-xs font-medium flex items-center gap-1 cursor-pointer" onclick="openSyncModal()">
+        <svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
+        </svg>
+        {{.PendingCount}}
     </span>
-    <button hx-post="/api/sync/push"
-            hx-swap="none"
-            hx-on::after-request="
-                if(event.detail.successful) {
-                    const resp = JSON.parse(event.detail.xhr.response);
-                    if(resp.success) {
-                        showToast('Синхронизировано: ' + resp.synced + ' изменений', 'success');
-                    } else {
-                        showToast('Ошибка: ' + (resp.error || 'неизвестная ошибка'), 'error');
-                    }
-                    htmx.trigger('#sync-status', 'refresh');
-                }
-            "
-            class="text-blue-600 hover:text-blue-800 text-xs underline cursor-pointer">
-        Sync
-    </button>
     {{end}}
+
+    <!-- Sync button (full sync only) -->
+    <div class="relative">
+        <button id="sync-button"
+                aria-label="Синхронизация"
+                class="text-gray-600 hover:text-gray-800 text-xs flex items-center gap-1">
+            <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"></path>
+            </svg>
+        </button>
+    </div>
 </div>
 {{end}}

web/templates/setup.html

@@ -61,6 +61,12 @@
                 <div id="status" class="hidden p-3 rounded-md text-sm"></div>
 
                 <div class="flex space-x-3 pt-4">
+                    {{if .Settings}}
+                    <a href="/"
+                       class="flex-1 px-4 py-2 bg-gray-100 text-gray-700 rounded-md hover:bg-gray-200 transition text-center">
+                        Назад
+                    </a>
+                    {{end}}
                     <button type="button" onclick="testConnection()"
                             class="flex-1 px-4 py-2 bg-gray-100 text-gray-700 rounded-md hover:bg-gray-200 transition">
                         Проверить
@@ -81,12 +87,14 @@
     <script>
         function showStatus(message, type) {
             const status = document.getElementById('status');
-            status.classList.remove('hidden', 'bg-green-100', 'text-green-800', 'bg-red-100', 'text-red-800', 'bg-blue-100', 'text-blue-800');
+            status.classList.remove('hidden', 'bg-green-100', 'text-green-800', 'bg-red-100', 'text-red-800', 'bg-blue-100', 'text-blue-800', 'bg-yellow-100', 'text-yellow-800');
 
             if (type === 'success') {
                 status.classList.add('bg-green-100', 'text-green-800');
             } else if (type === 'error') {
                 status.classList.add('bg-red-100', 'text-red-800');
+            } else if (type === 'warning') {
+                status.classList.add('bg-yellow-100', 'text-yellow-800');
             } else {
                 status.classList.add('bg-blue-100', 'text-blue-800');
             }
@@ -122,6 +130,44 @@
             }
         }
 
+        async function checkServerReady() {
+            let attempts = 0;
+            const maxAttempts = 30; // 30 seconds max
+
+            const checkInterval = setInterval(async () => {
+                attempts++;
+                try {
+                    const resp = await fetch('/health', { method: 'GET' });
+                    const data = await resp.json();
+
+                    // Check if we're out of setup mode
+                    if (data.status === 'ok') {
+                        clearInterval(checkInterval);
+                        showStatus('✓ Приложение запущено! Перенаправление...', 'success');
+                        setTimeout(() => {
+                            window.location.href = '/';
+                        }, 1000);
+                    }
+                } catch (e) {
+                    // Server still restarting, continue polling
+                    if (attempts >= maxAttempts) {
+                        clearInterval(checkInterval);
+                        showStatus('Сервер не отвечает. Обновите страницу вручную.', 'error');
+                    }
+                }
+            }, 1000); // Check every second
+        }
+
+        async function requestRestartAndWait() {
+            showStatus('Перезапуск приложения...', 'info');
+            try {
+                await fetch('/api/restart', { method: 'POST' });
+            } catch (e) {
+                // Ignore network errors here: restart may break connection immediately.
+            }
+            checkServerReady();
+        }
+
         document.getElementById('setup-form').addEventListener('submit', async function(e) {
             e.preventDefault();
             showStatus('Сохранение настроек...', 'info');
@@ -136,10 +182,21 @@
                 const data = await resp.json();
 
                 if (data.success) {
-                    showStatus(data.message + ' Перенаправление...', 'success');
-                    setTimeout(() => {
-                        window.location.href = '/';
-                    }, 2000);
+                    showStatus('✓ ' + data.message, 'success');
+
+                    // Check if restart is required
+                    if (data.restart_required) {
+                        setTimeout(() => {
+                            requestRestartAndWait();
+                        }, 2000);
+                    } else {
+                        // In setup mode, auto-restart is happening
+                        setTimeout(() => {
+                            showStatus('✓ Настройки сохранены. Проверка подключения...', 'success');
+                            // Poll until server is back
+                            checkServerReady();
+                        }, 2000);
+                    }
                 } else {
                     showStatus(data.error, 'error');
                 }