Fix article generator producing 1xINTEL in GPU segment

MB_ lots (e.g. MB_INTEL_..._GPU8) are incorrectly categorized as GPU
in the pricelist. Two fixes:
- Skip MB_ lots in buildGPUSegment regardless of pricelist category
- Add INTEL to vendor token skip list in parseGPUModel (was missing,
  unlike AMD/NV/NVIDIA which were already skipped)

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

.githooks/pre-commit

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+repo_root="$(git rev-parse --show-toplevel)"
+"$repo_root/scripts/check-secrets.sh"

.gitignore

@@ -1,5 +1,16 @@
 # QuoteForge
 config.yaml
+.env
+.env.*
+*.pem
+*.key
+*.p12
+*.pfx
+*.crt
+id_rsa
+id_rsa.*
+secrets.yaml
+secrets.yml
 
 # Local SQLite database (contains encrypted credentials)
 /data/*.db
@@ -12,6 +23,29 @@ config.yaml
 /importer
 /cron
 /bin/
+qfs
+
+# Local Go build cache used in sandboxed runs
+.gocache/
+
+# Local tooling state
+.claude/
+
+# Editor settings
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Temp and logs
+*.tmp
+*.temp
+*.log
+
+# Go test/build artifacts
+*.out
+*.test
+coverage/
 
 # ---> macOS
 # General
@@ -41,4 +75,7 @@ Network Trash Folder
 Temporary Items
 .apdisk
 
-releases/
+# Release artifacts (binaries, archives, checksums), but DO track releases/memory/ for changelog
+releases/*
+!releases/memory/
+!releases/memory/**

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "bible"]
+	path = bible
+	url = https://git.mchus.pro/mchus/bible.git

AGENTS.md

@@ -0,0 +1,11 @@
+# QuoteForge — Instructions for Codex
+
+## Shared Engineering Rules
+Read `bible/` — shared rules for all projects (CSV, logging, DB, tables, background tasks, code style).
+Start with `bible/rules/patterns/` for specific contracts.
+
+## Project Architecture
+Read `bible-local/` — QuoteForge specific architecture.
+Read order: `bible-local/README.md` → relevant files for the task.
+
+Every architectural decision specific to this project must be recorded in `bible-local/`.

CLAUDE.md

@@ -1,163 +1,17 @@
-# QuoteForge - Claude Code Instructions
+# QuoteForge — Instructions for Claude
 
-## Overview
-Корпоративный конфигуратор серверов и формирование КП. MariaDB (RFQ_LOG) + SQLite для оффлайн.
+## Shared Engineering Rules
+Read `bible/` — shared rules for all projects (CSV, logging, DB, tables, background tasks, code style).
+Start with `bible/rules/patterns/` for specific contracts.
 
-## Development Phases
+## Project Architecture
+Read `bible-local/` — QuoteForge specific architecture.
+Read order: `bible-local/README.md` → relevant files for the task.
 
-### Phase 1: Pricelists in MariaDB ✅ DONE
-### Phase 2: Local SQLite Database ✅ DONE
+Every architectural decision specific to this project must be recorded in `bible-local/`.
 
-### Phase 2.5: Full Offline Mode 🔶 IN PROGRESS
-**Local-first architecture:** приложение ВСЕГДА работает с SQLite, MariaDB только для синхронизации.
-
-**Принцип работы:**
-- ВСЕ операции (CRUD) выполняются в SQLite
-- При создании конфигурации:
-  1. Если online → проверить новые прайслисты на сервере → скачать если есть
-  2. Далее работаем с local_pricelists (и online, и offline одинаково)
-- Background sync: push pending_changes → pull updates
-
-**DONE:**
-- ✅ Sync queue table (pending_changes) - `internal/localdb/models.go`
-- ✅ Model converters: MariaDB ↔ SQLite - `internal/localdb/converters.go`
-- ✅ LocalConfigurationService: все CRUD через SQLite - `internal/services/local_configuration.go`
-- ✅ Pre-create pricelist check: `SyncPricelistsIfNeeded()` - `internal/services/sync/service.go`
-- ✅ Push pending changes: `PushPendingChanges()` - sync service + handlers
-- ✅ Sync API endpoints: `/api/sync/push`, `/pending/count`, `/pending`
-- ✅ Integrate LocalConfigurationService in main.go (replace ConfigurationService)
-- ✅ 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:**
-- ❌ 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
-- Fields: opty, customer_requirement, variant, qty, rev
-- Local projects/specs with server sync
-
-### Phase 4: Price Versioning
-- Bind specifications to pricelist versions
-- Price diff comparison
-- Auto-cleanup expired pricelists (>1 year, usage_count=0)
-
-## Tech Stack
-Go 1.22+ | Gin | GORM | MariaDB 11 | SQLite (glebarez/sqlite) | htmx + Tailwind CDN | excelize
-
-## Key Tables
-
-### READ-ONLY (external systems)
-- `lot` (lot_name PK, lot_description)
-- `lot_log` (lot, supplier, date, price, quality, comments)
-- `supplier` (supplier_name PK)
-
-### MariaDB (qt_* prefix)
-- `qt_lot_metadata` - component prices, methods, popularity
-- `qt_categories` - category codes and names
-- `qt_pricelists` - version snapshots (YYYY-MM-DD-NNN format)
-- `qt_pricelist_items` - prices per pricelist
-- `qt_projects` - uuid, opty, customer_requirement, name (Phase 3)
-- `qt_specifications` - project_id, pricelist_id, variant, rev, qty, items JSON (Phase 3)
-
-### SQLite (data/quoteforge.db)
-- `connection_settings` - encrypted DB credentials (PasswordEncrypted field)
-- `local_pricelists/items` - cached from server
-- `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, attempts, last_error)
-
-## Business Logic
-
-**Part number parsing:** `CPU_AMD_9654` → category=`CPU`, model=`AMD_9654`
-
-**Price methods:** manual | median | average | weighted_median
-
-**Price freshness:** fresh (<30d, ≥3 quotes) | normal (<60d) | stale (<90d) | critical
-
-**Pricelist version:** `YYYY-MM-DD-NNN` (e.g., `2024-01-31-001`)
-
-## API Endpoints
-
-| Group | Endpoints |
-|-------|-----------|
-| Setup | GET/POST /setup, POST /setup/test |
-| Components | GET /api/components, /api/categories |
-| 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
-# 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
+go build ./cmd/qfs && go vet ./...   # verify
+go run ./cmd/qfs                      # run
+make build-release                    # release build
 ```
-
-## Code Style
-- gofmt, structured logging (slog), wrap errors with context
-- snake_case files, PascalCase types
-- RBAC disabled: DB username = user_id via `models.EnsureDBUser()`
-
-## UI Guidelines
-- htmx (hx-get/post/target/swap), Tailwind CDN
-- Freshness colors: green (fresh) → yellow → orange → red (critical)
-- Sync status + offline indicator in header

LOCAL_FIRST_INTEGRATION.md

@@ -1,178 +0,0 @@
-# Local-First Architecture Integration Guide
-
-## Overview
-
-QuoteForge теперь поддерживает local-first архитектуру: приложение ВСЕГДА работает с SQLite (localdb), MariaDB используется только для синхронизации.
-
-## Реализованные компоненты
-
-### 1. Конвертеры моделей (`internal/localdb/converters.go`)
-
-Конвертеры между MariaDB и SQLite моделями:
-- `ConfigurationToLocal()` / `LocalToConfiguration()`
-- `PricelistToLocal()` / `LocalToPricelist()`
-- `ComponentToLocal()` / `LocalToComponent()`
-
-### 2. LocalDB методы (`internal/localdb/localdb.go`)
-
-Добавлены методы для работы с pending changes:
-- `MarkChangesSynced(ids []int64)` - помечает изменения как синхронизированные
-- `GetPendingCount()` - возвращает количество несинхронизированных изменений
-
-### 3. Sync Service расширения (`internal/services/sync/service.go`)
-
-Новые методы:
-- `SyncPricelistsIfNeeded()` - проверяет и скачивает новые прайслисты при необходимости
-- `PushPendingChanges()` - отправляет все pending changes на сервер
-- `pushSingleChange()` - обрабатывает один pending change
-- `pushConfigurationCreate/Update/Delete()` - специфичные методы для конфигураций
-
-**ВАЖНО**: Конструктор изменен - теперь требует `ConfigurationRepository`:
-```go
-syncService := sync.NewService(pricelistRepo, configRepo, local)
-```
-
-### 4. LocalConfigurationService (`internal/services/local_configuration.go`)
-
-Новый сервис для работы с конфигурациями в local-first режиме:
-- Все операции CRUD работают через SQLite
-- Автоматически добавляет изменения в pending_changes
-- При создании конфигурации (если online) проверяет новые прайслисты
-
-```go
-localConfigService := services.NewLocalConfigurationService(
-    localDB,
-    syncService,
-    quoteService,
-    isOnlineFunc,
-)
-```
-
-### 5. Sync Handler расширения (`internal/handlers/sync.go`)
-
-Новые endpoints:
-- `POST /api/sync/push` - отправить pending changes на сервер
-- `GET /api/sync/pending/count` - получить количество pending changes
-- `GET /api/sync/pending` - получить список pending changes
-
-## Интеграция
-
-### Шаг 1: Обновить main.go
-
-```go
-// В cmd/qfs/main.go
-syncService := sync.NewService(pricelistRepo, configRepo, local)
-
-// Создать isOnline функцию
-isOnlineFunc := func() bool {
-    sqlDB, err := db.DB()
-    if err != nil {
-        return false
-    }
-    return sqlDB.Ping() == nil
-}
-
-// Создать LocalConfigurationService
-localConfigService := services.NewLocalConfigurationService(
-    local,
-    syncService,
-    quoteService,
-    isOnlineFunc,
-)
-```
-
-### Шаг 2: Обновить ConfigurationHandler
-
-Заменить `ConfigurationService` на `LocalConfigurationService` в handlers:
-
-```go
-// Было:
-configHandler := handlers.NewConfigurationHandler(configService, exportService)
-
-// Стало:
-configHandler := handlers.NewConfigurationHandler(localConfigService, exportService)
-```
-
-### Шаг 3: Добавить endpoints для sync
-
-В роутере добавить:
-```go
-syncGroup := router.Group("/api/sync")
-{
-    syncGroup.POST("/push", syncHandler.PushPendingChanges)
-    syncGroup.GET("/pending/count", syncHandler.GetPendingCount)
-    syncGroup.GET("/pending", syncHandler.GetPendingChanges)
-}
-```
-
-## Как это работает
-
-### Создание конфигурации
-
-1. Пользователь создает конфигурацию
-2. `LocalConfigurationService.Create()`:
-   - Если online → `SyncPricelistsIfNeeded()` проверяет новые прайслисты
-   - Сохраняет конфигурацию в SQLite
-   - Добавляет в `pending_changes` с operation="create"
-3. Конфигурация доступна локально сразу
-
-### Синхронизация с сервером
-
-**Manual sync:**
-```bash
-POST /api/sync/push
-```
-
-**Background sync (TODO):**
-- Периодический worker вызывает `syncService.PushPendingChanges()`
-- Проверяет online статус
-- Отправляет все pending changes на сервер
-- Удаляет успешно синхронизированные записи
-
-### Offline режим
-
-1. Все операции работают нормально через SQLite
-2. Изменения копятся в `pending_changes`
-3. При восстановлении соединения автоматически синхронизируются
-
-## Pending Changes Queue
-
-Таблица `pending_changes`:
-```go
-type PendingChange struct {
-    ID         int64     // Auto-increment
-    EntityType string    // "configuration", "project", "specification"
-    EntityUUID string    // UUID сущности
-    Operation  string    // "create", "update", "delete"
-    Payload    string    // JSON snapshot сущности
-    CreatedAt  time.Time
-    Attempts   int       // Счетчик попыток синхронизации
-    LastError  string    // Последняя ошибка синхронизации
-}
-```
-
-## TODO для Phase 2.5
-
-- [ ] Background sync worker (автоматическая синхронизация каждые N минут)
-- [ ] Conflict resolution (при конфликтах обновления)
-- [ ] UI: pending counter в header
-- [ ] UI: manual sync button
-- [ ] UI: conflict alerts
-- [ ] Retry logic для failed pending changes
-- [ ] RefreshPrices для local mode (через local_components)
-
-## Testing
-
-```bash
-# Compile
-go build ./cmd/qfs
-
-# Run
-./quoteforge
-
-# Check pending changes
-curl http://localhost:8080/api/sync/pending/count
-
-# Manual sync
-curl -X POST http://localhost:8080/api/sync/push
-```

MIGRATION_PRICE_REFRESH.md

@@ -1,121 +0,0 @@
-# Миграция: Функционал пересчета цен в конфигураторе
-
-## Описание изменений
-
-Добавлен функционал автоматического обновления цен компонентов в сохраненных конфигурациях.
-
-### Новые возможности
-
-1. **Кнопка "Пересчитать цену"** на странице конфигуратора
-   - Обновляет цены всех компонентов в конфигурации до актуальных значений из базы данных
-   - Сохраняет количество компонентов, обновляя только цены
-   - Отображает время последнего обновления цен
-
-2. **Поле `price_updated_at`** в таблице конфигураций
-   - Хранит дату и время последнего обновления цен
-   - Отображается на странице конфигуратора в удобном формате ("5 мин. назад", "2 ч. назад" и т.д.)
-
-### Изменения в базе данных
-
-Добавлено новое поле в таблицу `qt_configurations`:
-```sql
-ALTER TABLE qt_configurations
-ADD COLUMN price_updated_at TIMESTAMP NULL DEFAULT NULL
-AFTER server_count;
-```
-
-### Новый API endpoint
-
-```
-POST /api/configs/:uuid/refresh-prices
-```
-
-**Требования:**
-- Авторизация: Bearer Token
-- Роль: editor или выше
-
-**Ответ:**
-```json
-{
-  "id": 1,
-  "uuid": "...",
-  "name": "Конфигурация 1",
-  "items": [
-    {
-      "lot_name": "CPU_AMD_9654",
-      "quantity": 2,
-      "unit_price": 11500.00
-    }
-  ],
-  "total_price": 23000.00,
-  "price_updated_at": "2026-01-31T12:34:56Z",
-  ...
-}
-```
-
-## Применение изменений
-
-### 1. Обновление базы данных
-
-Запустите сервер с флагом миграции:
-```bash
-./quoteforge -migrate -config config.yaml
-```
-
-Или выполните SQL миграцию вручную:
-```bash
-mysql -u user -p RFQ_LOG < migrations/004_add_price_updated_at.sql
-```
-
-### 2. Перезапуск сервера
-
-После применения миграции перезапустите сервер:
-```bash
-./quoteforge -config config.yaml
-```
-
-## Использование
-
-1. Откройте любую сохраненную конфигурацию в конфигураторе
-2. Нажмите кнопку **"Пересчитать цену"** рядом с кнопкой "Сохранить"
-3. Все цены компонентов будут обновлены до актуальных значений
-4. Конфигурация автоматически сохраняется с обновленными ценами
-5. Под кнопками отображается время последнего обновления цен
-
-## Технические детали
-
-### Измененные файлы
-
-- `internal/models/configuration.go` - добавлено поле `PriceUpdatedAt`
-- `internal/services/configuration.go` - добавлен метод `RefreshPrices()`
-- `internal/handlers/configuration.go` - добавлен обработчик `RefreshPrices()`
-- `cmd/qfs/main.go` - добавлен маршрут `/api/configs/:uuid/refresh-prices`
-- `web/templates/index.html` - добавлена кнопка и JavaScript функции
-- `migrations/004_add_price_updated_at.sql` - SQL миграция
-- `CLAUDE.md` - обновлена документация
-
-### Логика обновления цен
-
-1. Получение конфигурации по UUID
-2. Проверка прав доступа (пользователь должен быть владельцем)
-3. Для каждого компонента в конфигурации:
-   - Получение актуальной цены из `qt_lot_metadata.current_price`
-   - Обновление `unit_price` в items
-4. Пересчет `total_price` с учетом `server_count`
-5. Установка `price_updated_at` на текущее время
-6. Сохранение конфигурации
-
-### Обработка ошибок
-
-- Если компонент не найден или у него нет цены - сохраняется старая цена
-- При ошибках доступа возвращается 403 Forbidden
-- При отсутствии конфигурации возвращается 404 Not Found
-
-## Отмена изменений (Rollback)
-
-Для отмены миграции выполните:
-```sql
-ALTER TABLE qt_configurations DROP COLUMN price_updated_at;
-```
-
-**Внимание:** После отмены миграции функционал пересчета цен перестанет работать корректно.

Makefile

@@ -1,4 +1,4 @@
-.PHONY: build build-release clean test run version
+.PHONY: build build-release clean test run version install-hooks
 
 # Get version from git
 VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
@@ -72,6 +72,12 @@ deps:
 	go mod download
 	go mod tidy
 
+# Install local git hooks
+install-hooks:
+	git config core.hooksPath .githooks
+	chmod +x .githooks/pre-commit scripts/check-secrets.sh
+	@echo "Installed git hooks from .githooks/"
+
 # Help
 help:
 	@echo "QuoteForge Server (qfs) - Build Commands"
@@ -92,6 +98,7 @@ help:
 	@echo "  run            Run development server"
 	@echo "  watch          Run with auto-restart (requires entr)"
 	@echo "  deps           Install/update dependencies"
+	@echo "  install-hooks  Install local git hooks (secret scan on commit)"
 	@echo "  help           Show this help"
 	@echo ""
 	@echo "Current version: $(VERSION)"

README.md

@@ -1,274 +1,66 @@
 # QuoteForge
 
-**Server Configuration & Quotation Tool**
+**Корпоративный конфигуратор серверов и расчёт КП**
 
-QuoteForge — корпоративный инструмент для конфигурирования серверов и формирования коммерческих предложений (КП). Приложение интегрируется с существующей базой данных RFQ_LOG.
+Offline-first архитектура: пользовательские операции через локальную SQLite, MariaDB только для синхронизации.
 
 ![Go Version](https://img.shields.io/badge/Go-1.22+-00ADD8?style=flat&logo=go)
 ![License](https://img.shields.io/badge/License-Proprietary-red)
 ![Status](https://img.shields.io/badge/Status-In%20Development-yellow)
 
-## Возможности
+---
 
-### Для пользователей
-- 📱 **Mobile-first интерфейс** — удобная работа с телефона и планшета
-- 🖥️ **Конфигуратор серверов** — пошаговый выбор компонентов с проверкой совместимости
-- 💰 **Автоматический расчёт цен** — актуальные цены на основе истории закупок
-- 📊 **Экспорт в CSV/XLSX** — готовые спецификации для клиентов
-- 💾 **Сохранение конфигураций** — история и шаблоны для повторного использования
+## Документация
 
-### Для ценовых администраторов
-- 📈 **Умный расчёт цен** — медиана, взвешенная медиана, среднее
-- 🎯 **Система алертов** — уведомления о популярных компонентах с устаревшими ценами
-- 📉 **Аналитика использования** — какие компоненты востребованы в КП
-- ⚙️ **Гибкие настройки** — периоды расчёта, методы, ручные переопределения
+Полная архитектурная документация хранится в **[bible/](bible/README.md)**:
 
-### Индикация актуальности цен
-| Цвет | Статус | Условие |
-|------|--------|---------|
-| 🟢 Зелёный | Свежая | < 30 дней, ≥ 3 источника |
-| 🟡 Жёлтый | Нормальная | 30-60 дней |
-| 🟠 Оранжевый | Устаревающая | 60-90 дней |
-| 🔴 Красный | Устаревшая | > 90 дней или нет данных |
+| Файл | Тема |
+|------|------|
+| [bible/01-overview.md](bible/01-overview.md) | Продукт, возможности, технологии, структура репо |
+| [bible/02-architecture.md](bible/02-architecture.md) | Local-first, sync, ценообразование, версионность |
+| [bible/03-database.md](bible/03-database.md) | SQLite и MariaDB схемы, права, миграции |
+| [bible/04-api.md](bible/04-api.md) | Все API endpoints и web-маршруты |
+| [bible/05-config.md](bible/05-config.md) | Конфигурация, env vars, установка |
+| [bible/06-backup.md](bible/06-backup.md) | Резервное копирование |
+| [bible/07-dev.md](bible/07-dev.md) | Команды разработки, стиль кода, guardrails |
 
-## Технологии
+---
 
-- **Backend:** Go 1.22+, Gin, GORM
-- **Frontend:** HTML, Tailwind CSS, htmx
-- **Database:** MariaDB 11+
-- **Export:** excelize (XLSX), encoding/csv
-
-## Требования
-
-- Go 1.22 или выше
-- MariaDB 11.x (или MySQL 8.x)
-- ~50 MB дискового пространства
-
-## Установка
-
-### 1. Клонирование репозитория
-
-```bash
-git clone https://github.com/your-company/quoteforge.git
-cd quoteforge
-```
-
-### 2. Настройка конфигурации
-
-```bash
-cp config.example.yaml config.yaml
-```
-
-Отредактируйте `config.yaml`:
-
-```yaml
-server:
-  host: "0.0.0.0"
-  port: 8080
-  mode: "release"
-
-database:
-  host: "localhost"
-  port: 3306
-  name: "RFQ_LOG"
-  user: "quoteforge"
-  password: "your-secure-password"
-
-auth:
-  jwt_secret: "your-jwt-secret-min-32-chars"
-  token_expiry: "24h"
-```
-
-### 3. Миграции базы данных
+## Быстрый старт
 
 ```bash
+# Применить миграции
 go run ./cmd/qfs -migrate
-```
 
-### 4. Импорт метаданных компонентов
-
-```bash
-go run ./cmd/importer
-```
-
-### 5. Запуск
-
-```bash
-# Development
+# Запустить
 go run ./cmd/qfs
-
-# 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
+# или
+make run
 ```
 
-**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
-
-## Docker
+Приложение: http://localhost:8080 → откроется `/setup` для настройки подключения к MariaDB.
 
 ```bash
-# Сборка образа
-docker build -t quoteforge .
+# Сборка
+make build-release
 
-# Запуск с docker-compose
-docker-compose up -d
+# Проверка
+go build ./cmd/qfs && go vet ./...
 ```
 
-## Структура проекта
+---
 
-```
-quoteforge/
-├── cmd/
-│   ├── server/main.go           # Main HTTP server
-│   └── importer/main.go         # Import metadata from lot table
-├── internal/
-│   ├── config/          # Конфигурация
-│   ├── models/          # GORM модели
-│   ├── handlers/        # HTTP handlers
-│   ├── services/        # Бизнес-логика
-│   ├── middleware/      # Auth, CORS, etc.
-│   └── repository/      # Работа с БД
-├── web/
-│   ├── templates/       # HTML шаблоны
-│   └── static/          # CSS, JS, изображения
-├── migrations/          # SQL миграции
-├── config.yaml          # Конфигурация
-├── Dockerfile
-├── docker-compose.yml
-└── go.mod
-```
+## Releases & Changelog
 
-## Роли пользователей
+Changelog между версиями: `releases/memory/v{major}.{minor}.{patch}.md`
 
-| Роль | Описание |
-|------|----------|
-| `viewer` | Просмотр, создание квот, экспорт |
-| `editor` | + сохранение конфигураций |
-| `pricing_admin` | + управление ценами и алертами |
-| `admin` | Полный доступ, управление пользователями |
-
-## API
-
-Документация API доступна по адресу `/api/docs` (в разработке).
-
-Основные endpoints:
-
-```
-POST /api/auth/login          # Авторизация
-GET  /api/components          # Список компонентов
-POST /api/quote/calculate     # Расчёт цены
-POST /api/export/xlsx         # Экспорт в Excel
-GET  /api/configs             # Сохранённые конфигурации
-```
-
-## 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.
-
-### Docker Compose Setup
-
-The Docker setup includes a dedicated cron service that runs the following jobs:
-
-- **Alerts check**: Every hour (0 * * * *)
-- **Price updates**: Daily at 2 AM (0 2 * * *)
-- **Usage counter reset**: Weekly on Sunday at 1 AM (0 1 * * 0)
-- **Popularity score updates**: Daily at 3 AM (0 3 * * *)
-
-To enable cron jobs in Docker, run:
-
-```bash
-docker-compose up -d
-```
-
-### Manual Cron Job Execution
-
-You can also run cron jobs manually using the quoteforge-cron binary:
-
-```bash
-# Check and generate alerts
-go run ./cmd/cron -job=alerts
-
-# Recalculate all prices
-go run ./cmd/cron -job=update-prices
-
-# Reset usage counters
-go run ./cmd/cron -job=reset-counters
-
-# Update popularity scores
-go run ./cmd/cron -job=update-popularity
-```
-
-### Cron Job Details
-
-- **Alerts check**: Generates alerts for components with high demand and stale prices, trending components without prices, and components with no recent quotes
-- **Price updates**: Recalculates prices for all components using configured methods (median, weighted median, average)
-- **Usage counter reset**: Resets weekly and monthly usage counters for components
-- **Popularity score updates**: Recalculates popularity scores based on supplier quote activity
-
-## Разработка
-
-```bash
-# Запуск в режиме разработки (hot reload)
-go run ./cmd/qfs
-
-# Запуск тестов
-go test ./...
-
-# Сборка для Linux
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/qfs ./cmd/qfs
-```
-
-## Переменные окружения
-
-| Переменная | Описание | По умолчанию |
-|------------|----------|--------------|
-| `QF_DB_HOST` | Хост базы данных | localhost |
-| `QF_DB_PORT` | Порт базы данных | 3306 |
-| `QF_DB_NAME` | Имя базы данных | RFQ_LOG |
-| `QF_DB_USER` | Пользователь БД | — |
-| `QF_DB_PASSWORD` | Пароль БД | — |
-| `QF_JWT_SECRET` | Секрет для JWT | — |
-| `QF_SERVER_PORT` | Порт сервера | 8080 |
-
-## Интеграция с существующей БД
-
-QuoteForge интегрируется с существующей базой RFQ_LOG:
-
-- `lot` — справочник компонентов (только чтение)
-- `lot_log` — история цен от поставщиков (только чтение)
-- `supplier` — справочник поставщиков (только чтение)
-
-Новые таблицы QuoteForge имеют префикс `qt_`:
-
-- `qt_users` — пользователи приложения
-- `qt_lot_metadata` — расширенные данные компонентов
-- `qt_configurations` — сохранённые конфигурации
-- `qt_pricing_alerts` — алерты для администраторов
+---
 
 ## Поддержка
 
-По вопросам работы приложения обращайтесь:
 - Email: mike@mchus.pro
 - Internal: @mchus
 
 ## Лицензия
 
-Данное программное обеспечение является собственностью компании и предназначено исключительно для внутреннего использования. Распространение, копирование или модификация без письменного разрешения запрещены.
-
-См. файл [LICENSE](LICENSE) для подробностей.
+Собственность компании, только для внутреннего использования. См. [LICENSE](LICENSE).

RELEASE_v0.2.6.md

@@ -1,60 +0,0 @@
-## Release v0.2.6 - Build & Release Improvements
-
-Minor release focused on developer experience and release automation.
-
-### Changes
-
-**Build System**
-- 🎯 Renamed binary from `quoteforge` to `qfs` (shorter, easier to type)
-- 🏷️ Added `-version` flag to display build version
-- 📦 Added Makefile with build targets for all platforms
-- 🚀 Added automated release script for multi-platform binaries
-
-**New Commands**
-```bash
-make build-release   # Optimized build with version info
-make build-all       # Build for Linux + macOS (Intel/ARM)
-make release         # Create release packages with checksums
-./bin/qfs -version   # Show version
-```
-
-**Release Artifacts**
-- Linux AMD64
-- macOS Intel (AMD64)
-- macOS Apple Silicon (ARM64)
-- Windows AMD64
-- SHA256 checksums
-
-### Installation
-
-Download the appropriate binary for your platform:
-```bash
-# Linux
-wget https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.6/qfs-v0.2.6-linux-amd64.tar.gz
-tar -xzf qfs-v0.2.6-linux-amd64.tar.gz
-chmod +x qfs-linux-amd64
-./qfs-linux-amd64
-
-# macOS Intel
-curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.6/qfs-v0.2.6-darwin-amd64.tar.gz
-tar -xzf qfs-v0.2.6-darwin-amd64.tar.gz
-chmod +x qfs-darwin-amd64
-./qfs-darwin-amd64
-
-# macOS Apple Silicon
-curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.6/qfs-v0.2.6-darwin-arm64.tar.gz
-tar -xzf qfs-v0.2.6-darwin-arm64.tar.gz
-chmod +x qfs-darwin-arm64
-./qfs-darwin-arm64
-
-# Windows
-curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.6/qfs-v0.2.6-windows-amd64.zip
-unzip qfs-v0.2.6-windows-amd64.zip
-qfs-windows-amd64.exe
-```
-
-### Breaking Changes
-None - fully backward compatible with v0.2.5
-
-### Full Changelog
-https://git.mchus.pro/mchus/QuoteForge/compare/v0.2.5...v0.2.6

RELEASE_v0.2.7.md

@@ -1,57 +0,0 @@
-## Release v0.2.7 - Windows Support & Localhost Binding
-
-Bug fix release improving Windows compatibility and default network binding.
-
-### Changes
-
-**Windows Support**
-- ✅ Fixed template loading errors on Windows
-- ✅ All file paths now use `filepath.Join` for cross-platform compatibility
-- ✅ Binary now works correctly on Windows without path errors
-
-**Localhost Binding**
-- ✅ Server now binds to `127.0.0.1` by default (instead of `0.0.0.0`)
-- ✅ Browser always opens to `http://127.0.0.1:8080`
-- ✅ Setup mode properly opens browser automatically
-- ✅ More secure default - only accessible from local machine
-
-> **Note:** To bind to all network interfaces (for network access), set `host: "0.0.0.0"` in config.yaml
-
-### Installation
-
-Download the appropriate binary for your platform:
-
-```bash
-# Linux
-wget https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.7/qfs-v0.2.7-linux-amd64.tar.gz
-tar -xzf qfs-v0.2.7-linux-amd64.tar.gz
-chmod +x qfs-linux-amd64
-./qfs-linux-amd64
-
-# macOS Intel
-curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.7/qfs-v0.2.7-darwin-amd64.tar.gz
-tar -xzf qfs-v0.2.7-darwin-amd64.tar.gz
-chmod +x qfs-darwin-amd64
-./qfs-darwin-amd64
-
-# macOS Apple Silicon
-curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.7/qfs-v0.2.7-darwin-arm64.tar.gz
-tar -xzf qfs-v0.2.7-darwin-arm64.tar.gz
-chmod +x qfs-darwin-arm64
-./qfs-darwin-arm64
-
-# Windows
-# Download and extract: https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.7/qfs-v0.2.7-windows-amd64.zip
-# Run: qfs-windows-amd64.exe
-```
-
-### Breaking Changes
-None - fully backward compatible with v0.2.6
-
-### Upgrade Notes
-- If you use config.yaml with `host: "0.0.0.0"`, the app will respect that setting
-- Default behavior now binds only to localhost for security
-- Windows users no longer need workarounds for path errors
-
-### Full Changelog
-https://git.mchus.pro/mchus/QuoteForge/compare/v0.2.6...v0.2.7

bible-local/01-overview.md

@@ -0,0 +1,119 @@
+# 01 — Product Overview
+
+## What is QuoteForge
+
+A corporate server configuration and quotation tool.
+Operates in **strict local-first** mode: all user operations go through local SQLite; MariaDB is used only for synchronization.
+
+---
+
+## Features
+
+### For Users
+- Mobile-first interface — works comfortably on phones and tablets
+- Server configurator — step-by-step component selection
+- Automatic price calculation — based on pricelists from local cache
+- CSV export — ready-to-use specifications for clients
+- Configuration history — versioned snapshots with rollback support
+- Full offline operation — continue working without network, sync later
+- Guarded synchronization — sync is blocked by preflight check if local schema is not ready
+
+### User Roles
+
+| Role | Permissions |
+|------|-------------|
+| `viewer` | View, create quotes, export |
+| `editor` | + save configurations |
+| `pricing_admin` | + manage prices and alerts |
+| `admin` | Full access, user management |
+
+### Price Freshness Indicators
+
+| Color | Status | Condition |
+|-------|--------|-----------|
+| Green | Fresh | < 30 days, ≥ 3 sources |
+| Yellow | Normal | 30–60 days |
+| Orange | Aging | 60–90 days |
+| Red | Stale | > 90 days or no data |
+
+---
+
+## Tech Stack
+
+| Layer | Stack |
+|-------|-------|
+| Backend | Go 1.22+, Gin, GORM |
+| Frontend | HTML, Tailwind CSS, htmx |
+| Local DB | SQLite (`qfs.db`) |
+| Server DB | MariaDB 11+ (sync + server admin) |
+| Export | encoding/csv, excelize (XLSX) |
+
+---
+
+## Product Scope
+
+**In scope:**
+- Component configurator and quotation calculation
+- Projects and configurations
+- Read-only pricelist viewing from local cache
+- Sync (pull components/pricelists, push local changes)
+
+**Out of scope (removed intentionally — do not restore):**
+- Admin pricing UI/API
+- Stock import
+- Alerts
+- Cron/importer utilities
+
+---
+
+## Repository Structure
+
+```
+quoteforge/
+├── cmd/
+│   ├── qfs/main.go               # HTTP server entry point
+│   ├── migrate/                  # Migration tool
+│   └── migrate_ops_projects/     # OPS project migrator
+├── internal/
+│   ├── appmeta/                  # App version metadata
+│   ├── appstate/                 # State management, backup
+│   ├── article/                  # Article generation
+│   ├── config/                   # Config parsing
+│   ├── db/                       # DB initialization
+│   ├── handlers/                 # HTTP handlers
+│   ├── localdb/                  # SQLite layer
+│   ├── lotmatch/                 # Lot matching logic
+│   ├── middleware/               # Auth, CORS, etc.
+│   ├── models/                   # GORM models
+│   ├── repository/               # Repository layer
+│   └── services/                 # Business logic
+├── web/
+│   ├── templates/                # HTML templates + partials
+│   └── static/                   # CSS, JS, assets
+├── migrations/                   # SQL migration files (30+)
+├── bible/                        # Architectural documentation (this section)
+├── releases/memory/              # Per-version changelogs
+├── config.example.yaml           # Config template (the only one in repo)
+└── go.mod
+```
+
+---
+
+## Integration with Existing DB
+
+QuoteForge integrates with the existing `RFQ_LOG` database:
+
+**Read-only:**
+- `lot` — component catalog
+- `qt_lot_metadata` — extended component data
+- `qt_categories` — categories
+- `qt_pricelists`, `qt_pricelist_items` — pricelists
+
+**Read + Write:**
+- `qt_configurations` — configurations
+- `qt_projects` — projects
+
+**Sync service tables:**
+- `qt_client_local_migrations` — migration catalog (SELECT only)
+- `qt_client_schema_state` — applied migrations state
+- `qt_pricelist_sync_status` — pricelist sync status

bible-local/02-architecture.md

@@ -0,0 +1,220 @@
+# 02 — Architecture
+
+## Local-First Principle
+
+**SQLite** is the single source of truth for the user.
+**MariaDB** is a sync server only — it never blocks local operations.
+
+```
+User
+  │
+  ▼
+SQLite (qfs.db)          ← all CRUD operations go here
+  │
+  │ background sync (every 5 min)
+  ▼
+MariaDB (RFQ_LOG)        ← pull/push only
+```
+
+**Rules:**
+- All CRUD operations go through SQLite only
+- If MariaDB is unavailable → local work continues without restrictions
+- Changes are queued in `pending_changes` and pushed on next sync
+
+---
+
+## Synchronization
+
+### Data Flow Diagram
+
+```
+                      [ SERVER / MariaDB ]
+                 ┌───────────────────────────┐
+                 │ qt_projects               │
+                 │ qt_configurations         │
+                 │ qt_pricelists             │
+                 │ qt_pricelist_items        │
+                 │ qt_pricelist_sync_status  │
+                 └─────────────┬─────────────┘
+                               │
+              pull (projects/configs/pricelists)
+                               │
+          ┌────────────────────┴────────────────────┐
+          │                                         │
+[ CLIENT A / SQLite ]                   [ CLIENT B / SQLite ]
+local_projects                          local_projects
+local_configurations                    local_configurations
+local_pricelists                        local_pricelists
+local_pricelist_items                   local_pricelist_items
+pending_changes                         pending_changes
+          │                                         │
+          └────── push (projects/configs only) ─────┘
+                               │
+                      [ SERVER / MariaDB ]
+```
+
+### Sync Direction by Entity
+
+| Entity | Direction |
+|--------|-----------|
+| Configurations | Client ↔ Server ↔ Other Clients |
+| Projects | Client ↔ Server ↔ Other Clients |
+| Pricelists | Server → Clients only (no push) |
+| Components | Server → Clients only |
+
+Local pricelists not present on the server and not referenced by active configurations are deleted automatically on sync.
+
+### Soft Deletes (Archive Pattern)
+
+Configurations and projects are **never hard-deleted**. Deletion is archive via `is_active = false`.
+
+- `DELETE /api/configs/:uuid` → sets `is_active = false` (archived); can be restored via `reactivate`
+- `DELETE /api/projects/:uuid` → archives a project **variant** only (`variant` field must be non-empty); main projects cannot be deleted via this endpoint
+
+## Sync Readiness Guard
+
+Before every push/pull, a preflight check runs:
+1. Is the server (MariaDB) reachable?
+2. Can centralized local DB migrations be applied?
+3. Does the application version satisfy `min_app_version` of pending migrations?
+
+**If the check fails:**
+- Local CRUD continues without restriction
+- Sync API returns `423 Locked` with `reason_code` and `reason_text`
+- UI shows a red indicator with the block reason
+
+---
+
+## Pricing
+
+### Principle
+
+**Prices come only from `local_pricelist_items`.**
+Components (`local_components`) are metadata-only — they contain no pricing information.
+
+### Lookup Pattern
+
+```go
+// Look up a price for a line item
+price, found := s.lookupPriceByPricelistID(pricelistID, lotName)
+if found && price > 0 {
+    // use price
+}
+
+// Inside lookupPriceByPricelistID:
+localPL, err := s.localDB.GetLocalPricelistByServerID(pricelistID)
+price, err := s.localDB.GetLocalPriceForLot(localPL.ID, lotName)
+```
+
+### Multi-Level Pricelists
+
+A configuration can reference up to three pricelists simultaneously:
+
+| Field | Purpose |
+|-------|---------|
+| `pricelist_id` | Primary (estimate) |
+| `warehouse_pricelist_id` | Warehouse pricing |
+| `competitor_pricelist_id` | Competitor pricing |
+
+Pricelist sources: `estimate` | `warehouse` | `competitor`
+
+### "Auto" Pricelist Selection
+
+Configurator supports explicit and automatic selection per source (`estimate`, `warehouse`, `competitor`):
+
+- **Explicit mode:** concrete `pricelist_id` is set by user in settings.
+- **Auto mode:** client sends no explicit ID for that source; backend resolves the current latest active pricelist.
+
+`auto` must stay `auto` after price-level refresh and after manual "refresh prices":
+- resolved IDs are runtime-only and must not overwrite user's mode;
+- switching to explicit selection must clear runtime auto resolution for that source.
+
+### Latest Pricelist Resolution Rules
+
+For both server (`qt_pricelists`) and local cache (`local_pricelists`), "latest by source" is resolved with:
+
+1. only pricelists that have at least one item (`EXISTS ...pricelist_items`);
+2. deterministic sort: `created_at DESC, id DESC`.
+
+This prevents selecting empty/incomplete snapshots and removes nondeterministic ties.
+
+---
+
+## Configuration Versioning
+
+### Principle
+
+Append-only for **spec+price** changes: immutable snapshots are stored in `local_configuration_versions`.
+
+```
+local_configurations
+  └── current_version_id ──► local_configuration_versions (v3)  ← active
+                              local_configuration_versions (v2)
+                              local_configuration_versions (v1)
+```
+
+- `version_no = max + 1` when configuration **spec+price** changes
+- Old versions are never modified or deleted in normal flow
+- Rollback does **not** rewind history — it creates a **new** version from the snapshot
+- Operational updates (`line_no` reorder, server count, project move, rename)
+  are synced via `pending_changes` but do **not** create a new revision snapshot
+
+### Rollback
+
+```bash
+POST /api/configs/:uuid/rollback
+{
+  "target_version": 3,
+  "note": "optional comment"
+}
+```
+
+Result:
+- A new version `vN` is created with `data` from the target version
+- `change_note = "rollback to v{target_version}"` (+ note if provided)
+- `current_version_id` is switched to the new version
+- Configuration moves to `sync_status = pending`
+
+### Sync Status Flow
+
+```
+local → pending → synced
+```
+
+---
+
+## Project Specification Ordering (`Line`)
+
+- Each project configuration has persistent `line_no` (`10,20,30...`) in both SQLite and MariaDB.
+- Project list ordering is deterministic:
+  `line_no ASC`, then `created_at DESC`, then `id DESC`.
+- Drag-and-drop reorder in project UI updates `line_no` for active project configurations.
+- Reorder writes are queued as configuration `update` events in `pending_changes`
+  without creating new configuration versions.
+- Backward compatibility: if remote MariaDB schema does not yet include `line_no`,
+  sync falls back to create/update without `line_no` instead of failing.
+
+---
+
+## Sync Payload for Versioning
+
+Events in `pending_changes` for configurations contain:
+
+| Field | Description |
+|-------|-------------|
+| `configuration_uuid` | Identifier |
+| `operation` | `create` / `update` / `rollback` |
+| `current_version_id` | Active version ID |
+| `current_version_no` | Version number |
+| `snapshot` | Current configuration state |
+| `idempotency_key` | For idempotent push |
+| `conflict_policy` | `last_write_wins` |
+
+---
+
+## Background Processes
+
+| Process | Interval | What it does |
+|---------|----------|--------------|
+| Sync worker | 5 min | push pending + pull all |
+| Backup scheduler | configurable (`backup.time`) | creates ZIP archives |

bible-local/03-database.md

@@ -0,0 +1,206 @@
+# 03 — Database
+
+## SQLite (local, client-side)
+
+File: `qfs.db` in the user-state directory (see [05-config.md](05-config.md)).
+
+### Tables
+
+#### Components and Reference Data
+
+| Table | Purpose | Key Fields |
+|-------|---------|------------|
+| `local_components` | Component metadata (NO prices) | `lot_name` (PK), `lot_description`, `category`, `model` |
+| `connection_settings` | MariaDB connection settings | key-value store |
+| `app_settings` | Application settings | `key` (PK), `value`, `updated_at` |
+
+#### Pricelists
+
+| Table | Purpose | Key Fields |
+|-------|---------|------------|
+| `local_pricelists` | Pricelist headers | `id`, `server_id` (unique), `source`, `version`, `created_at` |
+| `local_pricelist_items` | Pricelist line items ← **sole source of prices** | `id`, `pricelist_id` (FK), `lot_name`, `price`, `lot_category` |
+
+#### Partnumber Books (PN → LOT mapping, pull-only from PriceForge)
+
+| Table | Purpose | Key Fields |
+|-------|---------|------------|
+| `local_partnumber_books` | Version snapshots of PN→LOT mappings | `id`, `server_id` (unique), `version`, `created_at`, `is_active` |
+| `local_partnumber_book_items` | PN→LOT mapping rows | `id`, `book_id` (FK), `partnumber`, `lot_name`, `is_primary_pn` |
+
+Active book: `WHERE is_active=1 ORDER BY created_at DESC, id DESC LIMIT 1`
+
+`is_primary_pn=1` means this PN's quantity in the vendor BOM determines qty(LOT). If only non-primary PNs are present for a LOT, qty defaults to 1.
+
+#### Configurations and Projects
+
+| Table | Purpose | Key Fields |
+|-------|---------|------------|
+| `local_configurations` | Saved configurations | `id`, `uuid` (unique), `items` (JSON), `vendor_spec` (JSON: PN/qty/description + canonical `lot_mappings[]`), `line_no`, `pricelist_id`, `warehouse_pricelist_id`, `competitor_pricelist_id`, `current_version_id`, `sync_status` |
+| `local_configuration_versions` | Immutable snapshots (revisions) | `id`, `configuration_id` (FK), `version_no`, `data` (JSON), `change_note`, `created_at` |
+| `local_projects` | Projects | `id`, `uuid` (unique), `name`, `code`, `sync_status` |
+
+#### Sync
+
+| Table | Purpose |
+|-------|---------|
+| `pending_changes` | Queue of changes to push to MariaDB |
+| `local_schema_migrations` | Applied migrations (idempotency guard) |
+
+---
+
+### Key SQLite Indexes
+
+```sql
+-- Pricelists
+INDEX local_pricelist_items(pricelist_id)
+UNIQUE INDEX local_pricelists(server_id)
+INDEX local_pricelists(source, created_at)   -- used for "latest by source" queries
+-- latest-by-source runtime query also applies deterministic tie-break by id DESC
+
+-- Configurations
+INDEX local_configurations(pricelist_id)
+INDEX local_configurations(warehouse_pricelist_id)
+INDEX local_configurations(competitor_pricelist_id)
+INDEX local_configurations(project_uuid, line_no)  -- project ordering (Line column)
+UNIQUE INDEX local_configurations(uuid)
+```
+
+---
+
+### `items` JSON Structure in Configurations
+
+```json
+{
+  "items": [
+    {
+      "lot_name": "CPU_AMD_9654",
+      "quantity": 2,
+      "unit_price": 123456.78,
+      "section": "Processors"
+    }
+  ]
+}
+```
+
+Prices are stored inside the `items` JSON field and refreshed from the pricelist on configuration refresh.
+
+---
+
+## MariaDB (server-side, sync-only)
+
+Database: `RFQ_LOG`
+
+### Tables and Permissions
+
+| Table | Purpose | Permissions |
+|-------|---------|-------------|
+| `lot` | Component catalog | SELECT |
+| `qt_lot_metadata` | Extended component data | SELECT |
+| `qt_categories` | Component categories | SELECT |
+| `qt_pricelists` | Pricelists | SELECT |
+| `qt_pricelist_items` | Pricelist line items | SELECT |
+| `lot_partnumbers` | Partnumber → lot mapping (pricelist enrichment) | SELECT |
+| `stock_log` | Latest stock qty by partnumber (pricelist enrichment) | SELECT |
+| `qt_configurations` | Saved configurations (includes `line_no`) | SELECT, INSERT, UPDATE |
+| `lot_partnumbers` | Partnumber → lot mapping (pricelist enrichment) | SELECT |
+| `stock_log` | Latest stock qty by partnumber (pricelist enrichment) | SELECT |
+| `qt_projects` | Projects | SELECT, INSERT, UPDATE |
+| `qt_client_local_migrations` | Migration catalog | SELECT only |
+| `qt_client_schema_state` | Applied migrations state | SELECT, INSERT, UPDATE |
+| `qt_pricelist_sync_status` | Pricelist sync status | SELECT, INSERT, UPDATE |
+| `qt_partnumber_books` | Partnumber book snapshots (written by PriceForge) | SELECT |
+| `qt_partnumber_book_items` | PN→LOT mapping rows (written by PriceForge) | SELECT |
+| `qt_vendor_partnumber_seen` | Vendor PN tracking for unresolved/ignored BOM rows (`is_ignored`) | INSERT, UPDATE |
+
+### Grant Permissions to Existing User
+
+```sql
+GRANT SELECT ON RFQ_LOG.lot TO '<DB_USER>'@'%';
+GRANT SELECT ON RFQ_LOG.qt_lot_metadata TO '<DB_USER>'@'%';
+GRANT SELECT ON RFQ_LOG.qt_categories TO '<DB_USER>'@'%';
+GRANT SELECT ON RFQ_LOG.qt_pricelists TO '<DB_USER>'@'%';
+GRANT SELECT ON RFQ_LOG.qt_pricelist_items TO '<DB_USER>'@'%';
+GRANT SELECT ON RFQ_LOG.lot_partnumbers TO '<DB_USER>'@'%';
+GRANT SELECT ON RFQ_LOG.stock_log TO '<DB_USER>'@'%';
+
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_configurations TO '<DB_USER>'@'%';
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_projects TO '<DB_USER>'@'%';
+
+GRANT SELECT ON RFQ_LOG.qt_client_local_migrations TO '<DB_USER>'@'%';
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_client_schema_state TO '<DB_USER>'@'%';
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_pricelist_sync_status TO '<DB_USER>'@'%';
+
+GRANT SELECT ON RFQ_LOG.qt_partnumber_books TO '<DB_USER>'@'%';
+GRANT SELECT ON RFQ_LOG.qt_partnumber_book_items TO '<DB_USER>'@'%';
+GRANT INSERT, UPDATE ON RFQ_LOG.qt_vendor_partnumber_seen TO '<DB_USER>'@'%';
+
+FLUSH PRIVILEGES;
+```
+
+### Create a New User
+
+```sql
+CREATE USER IF NOT EXISTS 'quote_user'@'%' IDENTIFIED BY '<DB_PASSWORD>';
+
+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'@'%';
+GRANT SELECT ON RFQ_LOG.lot_partnumbers TO 'quote_user'@'%';
+GRANT SELECT ON RFQ_LOG.stock_log TO 'quote_user'@'%';
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_configurations TO 'quote_user'@'%';
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_projects TO 'quote_user'@'%';
+GRANT SELECT ON RFQ_LOG.qt_client_local_migrations TO 'quote_user'@'%';
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_client_schema_state TO 'quote_user'@'%';
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_pricelist_sync_status TO 'quote_user'@'%';
+GRANT SELECT ON RFQ_LOG.qt_partnumber_books TO 'quote_user'@'%';
+GRANT SELECT ON RFQ_LOG.qt_partnumber_book_items TO 'quote_user'@'%';
+GRANT INSERT, UPDATE ON RFQ_LOG.qt_vendor_partnumber_seen TO 'quote_user'@'%';
+
+FLUSH PRIVILEGES;
+SHOW GRANTS FOR 'quote_user'@'%';
+```
+
+**Note:** If pricelists sync but show `0` positions (or logs contain `enriching pricelist items with stock` + `SELECT denied`), verify `SELECT` on `lot_partnumbers` and `stock_log` in addition to `qt_pricelist_items`.
+
+**Note:** If you see `Access denied for user ...@'<ip>'`, check for conflicting user entries (user@localhost vs user@'%').
+
+---
+
+## Migrations
+
+### SQLite Migrations (local) — три уровня, выполняются при каждом старте
+
+**1. GORM AutoMigrate** (`internal/localdb/localdb.go`) — первый и основной уровень.
+Список Go-моделей передаётся в `db.AutoMigrate(...)`. GORM создаёт отсутствующие таблицы и добавляет новые колонки. Колонки и таблицы **не удаляет**.
+→ Для добавления новой таблицы или колонки достаточно добавить модель/поле и включить модель в AutoMigrate.
+
+**2. `runLocalMigrations`** (`internal/localdb/migrations.go`) — второй уровень, для операций которые AutoMigrate не умеет: backfill данных, пересоздание таблиц, создание индексов.
+Каждая функция выполняется один раз — идемпотентность через запись `id` в `local_schema_migrations`.
+
+**3. Централизованные (server-side)** — третий уровень, при проверке готовности к синку.
+SQL-тексты хранятся в `qt_client_local_migrations` (MariaDB, пишет только PriceForge). Клиент читает, применяет к локальной SQLite, записывает в `local_remote_migrations_applied` + `qt_client_schema_state`.
+
+### MariaDB Migrations (server-side)
+
+- Stored in `migrations/` (SQL files)
+- Applied via `-migrate` flag
+- `min_app_version` — minimum app version required for the migration
+
+---
+
+## DB Debugging
+
+```bash
+# Inspect schema
+sqlite3 ~/.local/state/quoteforge/qfs.db ".schema local_components"
+sqlite3 ~/.local/state/quoteforge/qfs.db ".schema local_configurations"
+
+# Check pricelist item count
+sqlite3 ~/.local/state/quoteforge/qfs.db "SELECT COUNT(*) FROM local_pricelist_items"
+
+# Check pending sync queue
+sqlite3 ~/.local/state/quoteforge/qfs.db "SELECT COUNT(*) FROM pending_changes"
+```

bible-local/04-api.md

@@ -0,0 +1,163 @@
+# 04 — API and Web Routes
+
+## API Endpoints
+
+### Setup
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| GET | `/setup` | Initial setup page |
+| POST | `/setup` | Save connection settings |
+| POST | `/setup/test` | Test MariaDB connection |
+| GET | `/setup/status` | Setup status |
+
+### Components
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| GET | `/api/components` | List components (metadata only) |
+| GET | `/api/components/:lot_name` | Component by lot_name |
+| GET | `/api/categories` | List categories |
+
+### Quote
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| POST | `/api/quote/validate` | Validate line items |
+| POST | `/api/quote/calculate` | Calculate quote (prices from pricelist) |
+| POST | `/api/quote/price-levels` | Prices by level (estimate/warehouse/competitor) |
+
+### Pricelists (read-only)
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| GET | `/api/pricelists` | List pricelists (`source`, `active_only`, pagination) |
+| GET | `/api/pricelists/latest` | Latest pricelist by source |
+| GET | `/api/pricelists/:id` | Pricelist by ID |
+| GET | `/api/pricelists/:id/items` | Pricelist line items |
+| GET | `/api/pricelists/:id/lots` | Lot names in pricelist |
+
+`GET /api/pricelists?active_only=true` returns only pricelists that have synced items (`item_count > 0`).
+
+### Configurations
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| GET | `/api/configs` | List configurations |
+| POST | `/api/configs` | Create configuration |
+| GET | `/api/configs/:uuid` | Get configuration |
+| PUT | `/api/configs/:uuid` | Update configuration |
+| DELETE | `/api/configs/:uuid` | Archive configuration |
+| POST | `/api/configs/:uuid/refresh-prices` | Refresh prices from pricelist |
+| POST | `/api/configs/:uuid/clone` | Clone configuration |
+| POST | `/api/configs/:uuid/reactivate` | Restore archived configuration |
+| POST | `/api/configs/:uuid/rename` | Rename configuration |
+| POST | `/api/configs/preview-article` | Preview generated article for a configuration |
+| POST | `/api/configs/:uuid/rollback` | Roll back to a version |
+| GET | `/api/configs/:uuid/versions` | List versions |
+| GET | `/api/configs/:uuid/versions/:version` | Get specific version |
+
+`line` field in configuration payloads is backed by persistent `line_no` in DB.
+
+### Projects
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| GET | `/api/projects` | List projects |
+| POST | `/api/projects` | Create project |
+| GET | `/api/projects/:uuid` | Get project |
+| PUT | `/api/projects/:uuid` | Update project |
+| DELETE | `/api/projects/:uuid` | Archive project variant (soft-delete via `is_active=false`; fails if project has no `variant` set — main projects cannot be deleted this way) |
+| GET | `/api/projects/:uuid/configs` | Project configurations |
+| PATCH | `/api/projects/:uuid/configs/reorder` | Reorder active project configurations (`ordered_uuids`) and persist `line_no` |
+
+`GET /api/projects/:uuid/configs` ordering:
+`line ASC`, then `created_at DESC`, then `id DESC`.
+
+### Sync
+
+| Method | Endpoint | Purpose | Flow |
+|--------|----------|---------|------|
+| GET | `/api/sync/status` | Overall sync status | read-only |
+| GET | `/api/sync/readiness` | Preflight status (ready/blocked/unknown) | read-only |
+| GET | `/api/sync/info` | Data for sync modal | read-only |
+| GET | `/api/sync/users-status` | Users status | read-only |
+| GET | `/api/sync/pending` | List pending changes | read-only |
+| GET | `/api/sync/pending/count` | Count of pending changes | read-only |
+| POST | `/api/sync/push` | Push pending → MariaDB | SQLite → MariaDB |
+| POST | `/api/sync/components` | Pull components | MariaDB → SQLite |
+| POST | `/api/sync/pricelists` | Pull pricelists | MariaDB → SQLite |
+| POST | `/api/sync/all` | Full sync: push + pull + import | bidirectional |
+| POST | `/api/sync/repair` | Repair broken entries in pending_changes | SQLite |
+| POST | `/api/sync/partnumber-seen` | Report unresolved/ignored vendor PNs for server-side tracking | QuoteForge → MariaDB |
+
+**If sync is blocked by the readiness guard:** all POST sync methods return `423 Locked` with `reason_code` and `reason_text`.
+
+### Vendor Spec (BOM)
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| GET | `/api/configs/:uuid/vendor-spec` | Fetch stored vendor BOM |
+| PUT | `/api/configs/:uuid/vendor-spec` | Replace vendor BOM (full update) |
+| POST | `/api/configs/:uuid/vendor-spec/resolve` | Resolve PNs → LOTs (read-only) |
+| POST | `/api/configs/:uuid/vendor-spec/apply` | Apply resolved LOTs to cart |
+
+Notes:
+- `GET` / `PUT /api/configs/:uuid/vendor-spec` exchange normalized BOM rows (`vendor_spec`), not raw pasted Excel layout.
+- BOM row contract stores canonical LOT mapping list as seen in BOM UI:
+  - `lot_mappings[]`
+  - each mapping contains `lot_name` + `quantity_per_pn`
+- `POST /api/configs/:uuid/vendor-spec/apply` rebuilds cart items from explicit BOM mappings:
+  - all LOTs from `lot_mappings[]`
+
+### Partnumber Books (read-only)
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| GET | `/api/partnumber-books` | List local book snapshots |
+| GET | `/api/partnumber-books/:id` | Items for a book by `server_id` |
+| POST | `/api/sync/partnumber-books` | Pull book snapshots from MariaDB |
+
+See [09-vendor-spec.md](09-vendor-spec.md) for schema and pull logic.
+See [09-vendor-spec.md](09-vendor-spec.md) for `vendor_spec` JSON schema and BOM UI mapping contract.
+
+### Export
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| POST | `/api/export/csv` | Export configuration to CSV |
+
+**Export filename format:** `YYYY-MM-DD (ProjectCode) ConfigName Article.csv`
+(uses `project.Code`, not `project.Name`)
+
+---
+
+## Web Routes
+
+| Route | Page |
+|-------|------|
+| `/configs` | Configuration list |
+| `/configurator` | Configurator |
+| `/configs/:uuid/revisions` | Configuration revision history |
+| `/projects` | Project list |
+| `/projects/:uuid` | Project details |
+| `/pricelists` | Pricelist list |
+| `/pricelists/:id` | Pricelist details |
+| `/partnumber-books` | Partnumber books (active book summary + snapshot history) |
+| `/setup` | Connection settings |
+
+---
+
+## Rollback API (details)
+
+```bash
+POST /api/configs/:uuid/rollback
+Content-Type: application/json
+
+{
+  "target_version": 3,
+  "note": "optional comment"
+}
+```
+
+Response: updated configuration with the new version.

bible-local/05-config.md

@@ -0,0 +1,129 @@
+# 05 — Configuration and Environment
+
+## File Paths
+
+### SQLite database (`qfs.db`)
+
+| OS | Default path |
+|----|-------------|
+| macOS | `~/Library/Application Support/QuoteForge/qfs.db` |
+| Linux | `$XDG_STATE_HOME/quoteforge/qfs.db` or `~/.local/state/quoteforge/qfs.db` |
+| Windows | `%LOCALAPPDATA%\QuoteForge\qfs.db` |
+
+Override: `-localdb <path>` or `QFS_DB_PATH`.
+
+### config.yaml
+
+Searched in the same user-state directory as `qfs.db` by default.
+If the file does not exist, it is created automatically.
+If the format is outdated, it is automatically migrated to the runtime format (`server` + `logging` sections only).
+
+Override: `-config <path>` or `QFS_CONFIG_PATH`.
+
+**Important:** `config.yaml` is a runtime user file — it is **not stored in the repository**.
+`config.example.yaml` is the only config template in the repo.
+
+---
+
+## config.yaml Structure
+
+```yaml
+server:
+  host: "0.0.0.0"
+  port: 8080
+  mode: "release"   # release | debug
+
+logging:
+  level: "info"     # debug | info | warn | error
+  format: "json"    # json | text
+  output: "stdout"  # stdout | stderr | /path/to/file
+
+backup:
+  time: "00:00"     # HH:MM in local time
+```
+
+---
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `QFS_DB_PATH` | Full path to SQLite DB | OS-specific user state dir |
+| `QFS_STATE_DIR` | State directory (if `QFS_DB_PATH` is not set) | OS-specific user state dir |
+| `QFS_CONFIG_PATH` | Full path to `config.yaml` | OS-specific user state dir |
+| `QFS_BACKUP_DIR` | Root directory for rotating backups | `<db dir>/backups` |
+| `QFS_BACKUP_DISABLE` | Disable automatic backups | — |
+| `QF_DB_HOST` | MariaDB host | localhost |
+| `QF_DB_PORT` | MariaDB port | 3306 |
+| `QF_DB_NAME` | Database name | RFQ_LOG |
+| `QF_DB_USER` | DB user | — |
+| `QF_DB_PASSWORD` | DB password | — |
+| `QF_JWT_SECRET` | JWT secret | — |
+| `QF_SERVER_PORT` | HTTP server port | 8080 |
+
+`QFS_BACKUP_DISABLE` accepts: `1`, `true`, `yes`.
+
+---
+
+## CLI Flags
+
+| Flag | Description |
+|------|-------------|
+| `-config <path>` | Path to config.yaml |
+| `-localdb <path>` | Path to SQLite DB |
+| `-reset-localdb` | Reset local DB (destructive!) |
+| `-migrate` | Apply pending migrations and exit |
+| `-version` | Print version and exit |
+
+---
+
+## Installation and First Run
+
+### Requirements
+- Go 1.22 or higher
+- MariaDB 11.x (or MySQL 8.x)
+- ~50 MB disk space
+
+### Steps
+
+```bash
+# 1. Clone the repository
+git clone <repo-url>
+cd quoteforge
+
+# 2. Apply migrations
+go run ./cmd/qfs -migrate
+
+# 3. Start
+go run ./cmd/qfs
+# or
+make run
+```
+
+Application is available at: http://localhost:8080
+
+On first run, `/setup` opens for configuring the MariaDB connection.
+
+### OPS Project Migrator
+
+Migrates quotes whose names start with `OPS-xxxx` (where `x` is a digit) into a project named `OPS-xxxx`.
+
+```bash
+# Preview first (always)
+go run ./cmd/migrate_ops_projects
+
+# Apply
+go run ./cmd/migrate_ops_projects -apply
+
+# Apply without interactive confirmation
+go run ./cmd/migrate_ops_projects -apply -yes
+```
+
+---
+
+## Docker
+
+```bash
+docker build -t quoteforge .
+docker-compose up -d
+```

bible-local/06-backup.md

@@ -0,0 +1,221 @@
+# 06 — Backup
+
+## Overview
+
+Automatic rotating ZIP backup system for local data.
+
+**What is included in each archive:**
+- SQLite DB (`qfs.db`)
+- SQLite sidecars (`qfs.db-wal`, `qfs.db-shm`) if present
+- `config.yaml` if present
+
+**Archive name format:** `qfs-backp-YYYY-MM-DD.zip`
+
+**Retention policy:**
+| Period | Keep |
+|--------|------|
+| Daily | 7 archives |
+| Weekly | 4 archives |
+| Monthly | 12 archives |
+| Yearly | 10 archives |
+
+**Directories:** `<backup root>/daily`, `/weekly`, `/monthly`, `/yearly`
+
+---
+
+## Configuration
+
+```yaml
+backup:
+  time: "00:00"   # Trigger time in local time (HH:MM format)
+```
+
+**Environment variables:**
+- `QFS_BACKUP_DIR` — backup root directory (default: `<db dir>/backups`)
+- `QFS_BACKUP_DISABLE` — disable backups (`1/true/yes`)
+
+---
+
+## Behavior
+
+- **At startup:** if no backup exists for the current period, one is created immediately
+- **Daily:** at the configured time, a new backup is created
+- **Deduplication:** prevented via a `.period.json` marker file in each period directory
+- **Rotation:** excess old archives are deleted automatically
+
+---
+
+## Implementation
+
+Module: `internal/appstate/backup.go`
+
+Main function:
+```go
+func EnsureRotatingLocalBackup(dbPath, configPath string) ([]string, error)
+```
+
+Scheduler (in `main.go`):
+```go
+func startBackupScheduler(ctx context.Context, cfg *config.Config, dbPath, configPath string)
+```
+
+### Config struct
+
+```go
+type BackupConfig struct {
+    Time string `yaml:"time"`
+}
+// Default: "00:00"
+```
+
+---
+
+## Implementation Notes
+
+- `backup.time` is in **local time** without timezone offset parsing
+- `.period.json` is the marker that prevents duplicate backups within the same period
+- Archive filenames contain only the date; uniqueness is ensured by per-period directories + the period marker
+- When changing naming or retention: update both the filename logic and the prune logic together
+
+---
+
+## Full Listing: `internal/appstate/backup.go`
+
+```go
+package appstate
+
+import (
+    "archive/zip"
+    "encoding/json"
+    "fmt"
+    "io"
+    "os"
+    "path/filepath"
+    "sort"
+    "strings"
+    "time"
+)
+
+type backupPeriod struct {
+    name      string
+    retention int
+    key       func(time.Time) string
+    date      func(time.Time) string
+}
+
+var backupPeriods = []backupPeriod{
+    {
+        name:      "daily",
+        retention: 7,
+        key:  func(t time.Time) string { return t.Format("2006-01-02") },
+        date: func(t time.Time) string { return t.Format("2006-01-02") },
+    },
+    {
+        name:      "weekly",
+        retention: 4,
+        key: func(t time.Time) string {
+            y, w := t.ISOWeek()
+            return fmt.Sprintf("%04d-W%02d", y, w)
+        },
+        date: func(t time.Time) string { return t.Format("2006-01-02") },
+    },
+    {
+        name:      "monthly",
+        retention: 12,
+        key:  func(t time.Time) string { return t.Format("2006-01") },
+        date: func(t time.Time) string { return t.Format("2006-01-02") },
+    },
+    {
+        name:      "yearly",
+        retention: 10,
+        key:  func(t time.Time) string { return t.Format("2006") },
+        date: func(t time.Time) string { return t.Format("2006-01-02") },
+    },
+}
+
+func EnsureRotatingLocalBackup(dbPath, configPath string) ([]string, error) {
+    if isBackupDisabled() || dbPath == "" {
+        return nil, nil
+    }
+    if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+        return nil, nil
+    }
+    root := resolveBackupRoot(dbPath)
+    now := time.Now()
+    created := make([]string, 0)
+    for _, period := range backupPeriods {
+        newFiles, err := ensurePeriodBackup(root, period, now, dbPath, configPath)
+        if err != nil {
+            return created, err
+        }
+        created = append(created, newFiles...)
+    }
+    return created, nil
+}
+```
+
+---
+
+## Full Listing: Scheduler Hook (`main.go`)
+
+```go
+func startBackupScheduler(ctx context.Context, cfg *config.Config, dbPath, configPath string) {
+    if cfg == nil {
+        return
+    }
+    hour, minute, err := parseBackupTime(cfg.Backup.Time)
+    if err != nil {
+        slog.Warn("invalid backup time; using 00:00", "value", cfg.Backup.Time, "error", err)
+        hour, minute = 0, 0
+    }
+
+    // Startup check: create backup immediately if none exists for current periods
+    if created, backupErr := appstate.EnsureRotatingLocalBackup(dbPath, configPath); backupErr != nil {
+        slog.Error("local backup failed", "error", backupErr)
+    } else {
+        for _, path := range created {
+            slog.Info("local backup completed", "archive", path)
+        }
+    }
+
+    for {
+        next := nextBackupTime(time.Now(), hour, minute)
+        timer := time.NewTimer(time.Until(next))
+        select {
+        case <-ctx.Done():
+            timer.Stop()
+            return
+        case <-timer.C:
+            start := time.Now()
+            created, backupErr := appstate.EnsureRotatingLocalBackup(dbPath, configPath)
+            duration := time.Since(start)
+            if backupErr != nil {
+                slog.Error("local backup failed", "error", backupErr, "duration", duration)
+            } else {
+                for _, path := range created {
+                    slog.Info("local backup completed", "archive", path, "duration", duration)
+                }
+            }
+        }
+    }
+}
+
+func parseBackupTime(value string) (int, int, error) {
+    if strings.TrimSpace(value) == "" {
+        return 0, 0, fmt.Errorf("empty backup time")
+    }
+    parsed, err := time.Parse("15:04", value)
+    if err != nil {
+        return 0, 0, err
+    }
+    return parsed.Hour(), parsed.Minute(), nil
+}
+
+func nextBackupTime(now time.Time, hour, minute int) time.Time {
+    target := time.Date(now.Year(), now.Month(), now.Day(), hour, minute, 0, 0, now.Location())
+    if !now.Before(target) {
+        target = target.Add(24 * time.Hour)
+    }
+    return target
+}
+```

bible-local/07-dev.md

@@ -0,0 +1,136 @@
+# 07 — Development
+
+## Commands
+
+```bash
+# Run (dev)
+go run ./cmd/qfs
+make run
+
+# Build
+make build-release        # Optimized build with version info
+CGO_ENABLED=0 go build -o bin/qfs ./cmd/qfs
+
+# Cross-platform build
+make build-all            # Linux, macOS, Windows
+make build-windows        # Windows only
+
+# Verification
+go build ./cmd/qfs        # Must compile without errors
+go vet ./...              # Linter
+
+# Tests
+go test ./...
+make test
+
+# Utilities
+make install-hooks        # Git hooks (block committing secrets)
+make clean                # Clean bin/
+make help                 # All available commands
+```
+
+---
+
+## Code Style
+
+- **Formatting:** `gofmt` (mandatory)
+- **Logging:** `slog` only (structured logging to the binary's stdout/stderr). No `console.log` or any other logging in browser-side JS — the browser console is never used for diagnostics.
+- **Errors:** explicit wrapping with context (`fmt.Errorf("context: %w", err)`)
+- **Style:** no unnecessary abstractions; minimum code for the task
+
+---
+
+## Guardrails
+
+### What Must Never Be Restored
+
+The following components were **intentionally removed** and must not be brought back:
+- cron jobs
+- importer utility
+- admin pricing UI/API
+- alerts
+- stock import
+
+### Configuration Files
+
+- `config.yaml` — runtime user file, **not stored in the repository**
+- `config.example.yaml` — the only config template in the repo
+
+### Sync and Local-First
+
+- Any sync changes must preserve local-first behavior
+- Local CRUD must not be blocked when MariaDB is unavailable
+
+### Formats and UI
+
+- **CSV export:** filename must use **project code** (`project.Code`), not project name
+  Format: `YYYY-MM-DD (ProjectCode) ConfigName Article.csv`
+- **Breadcrumbs UI:** names longer than 16 characters must be truncated with an ellipsis
+
+### Architecture Documentation
+
+- **Every architectural decision must be recorded in `bible/`**
+- The corresponding Bible file must be updated **in the same commit** as the code change
+- On every user-requested commit, review and update the Bible in that same commit
+
+---
+
+## Common Tasks
+
+### Add a Field to Configuration
+
+1. Add the field to `LocalConfiguration` struct (`internal/models/`)
+2. Add GORM tags for the DB column
+3. Write a SQL migration (`migrations/`)
+4. Update `ConfigurationToLocal` / `LocalToConfiguration` converters
+5. Update API handlers and services
+
+### Add a Field to Component
+
+1. Add the field to `LocalComponent` struct (`internal/models/`)
+2. Update the SQL query in `SyncComponents()`
+3. Update the `componentRow` struct to match
+4. Update converter functions
+
+### Add a Pricelist Price Lookup
+
+```go
+// Modern pattern
+price, found := s.lookupPriceByPricelistID(pricelistID, lotName)
+if found && price > 0 {
+    // use price
+}
+```
+
+---
+
+## Known Gotchas
+
+1. **`CurrentPrice` removed from components** — any code using it will fail to compile
+2. **`HasPrice` filter removed** — `component.go ListComponents` no longer supports this filter
+3. **Quote calculation:** always offline-first (SQLite); online path is separate
+4. **Items JSON:** prices are stored in the `items` field of the configuration, not fetched from components
+5. **Migrations are additive:** already-applied migrations are skipped (checked by `id` in `local_schema_migrations`)
+6. **`SyncedAt` removed:** last component sync time is now in `app_settings` (key=`last_component_sync`)
+
+---
+
+## Debugging Price Issues
+
+**Problem: quote returns no prices**
+1. Check that `pricelist_id` is set on the configuration
+2. Check that pricelist items exist: `SELECT COUNT(*) FROM local_pricelist_items`
+3. Check `lookupPriceByPricelistID()` in `quote.go`
+4. Verify the correct source is used (estimate/warehouse/competitor)
+
+**Problem: component sync not working**
+1. Components sync as metadata only — no prices
+2. Prices come via a separate pricelist sync
+3. Check `SyncComponents()` and the MariaDB query
+
+**Problem: configuration refresh does not update prices**
+1. Refresh uses the latest estimate pricelist by default
+2. Latest resolution ignores pricelists without items (`EXISTS local_pricelist_items`)
+3. Old prices in `config.items` are preserved if a line item is not found in the pricelist
+4. To force a pricelist update: set `configuration.pricelist_id`
+5. In configurator, `Авто` must remain auto-mode (runtime resolved ID must not be persisted as explicit selection)

bible-local/09-vendor-spec.md

@@ -0,0 +1,364 @@
+# 09 — Vendor Spec (BOM Import)
+
+## Overview
+
+The vendor spec feature allows importing a vendor BOM (Bill of Materials) into a configuration. It maps vendor part numbers (PN) to internal LOT names using an active partnumber book (snapshot pulled from PriceForge), then aggregates quantities to populate the Estimate (cart).
+
+---
+
+## Architecture
+
+### Storage
+
+| Data | Storage | Sync direction |
+|------|---------|---------------|
+| `vendor_spec` JSON | `local_configurations.vendor_spec` (TEXT, JSON-encoded) | Two-way via `pending_changes` |
+| Partnumber book snapshots | `local_partnumber_books` + `local_partnumber_book_items` | Pull-only from PriceForge |
+
+`vendor_spec` is a JSON array of `VendorSpecItem` objects stored inside the configuration row. It syncs to MariaDB `qt_configurations.vendor_spec` via the existing pending_changes mechanism.
+
+### `vendor_spec` JSON Schema
+
+```json
+[
+  {
+    "sort_order": 10,
+    "vendor_partnumber": "ABC-123",
+    "quantity": 2,
+    "description": "...",
+    "unit_price": 4500.00,
+    "total_price": 9000.00,
+    "lot_mappings": [
+      { "lot_name": "LOT_A", "quantity_per_pn": 1 },
+      { "lot_name": "LOT_B", "quantity_per_pn": 2 }
+    ]
+  }
+]
+```
+
+`lot_mappings[]` is the canonical persisted LOT mapping list for a BOM row.
+Each mapping entry stores:
+
+- `lot_name`
+- `quantity_per_pn` (how many units of this LOT are included in **one vendor PN**)
+
+### PN → LOT Mapping Contract (single LOT, multiplier, bundle)
+
+QuoteForge expects the server to return/store BOM rows (`vendor_spec`) using a single canonical mapping list:
+
+- `lot_mappings[]` contains **all** LOT mappings for the PN row (single LOT and bundle cases alike)
+- the list stores exactly what the user sees in BOM (LOT + "LOT в 1 PN")
+- the DB contract does **not** split mappings into "base LOT" vs "bundle LOTs"
+
+#### Final quantity contribution to Estimate
+
+For one BOM row with vendor PN quantity `pn_qty`:
+
+- each mapping contribution:
+  - `lot_qty = pn_qty * lot_mappings[i].quantity_per_pn`
+
+#### Example: one PN maps to multiple LOTs
+
+```json
+{
+  "vendor_partnumber": "SYS-821GE-TNHR",
+  "quantity": 3,
+  "lot_mappings": [
+    { "lot_name": "CHASSIS_X13_8GPU", "quantity_per_pn": 1 },
+    { "lot_name": "PS_3000W_Titanium", "quantity_per_pn": 2 },
+    { "lot_name": "RAILKIT_X13", "quantity_per_pn": 1 }
+  ]
+}
+```
+
+This row contributes to Estimate:
+
+- `CHASSIS_X13_8GPU` → `3 * 1 = 3`
+- `PS_3000W_Titanium` → `3 * 2 = 6`
+- `RAILKIT_X13` → `3 * 1 = 3`
+
+---
+
+## Partnumber Books (Snapshots)
+
+Partnumber books are immutable versioned snapshots of the global PN→LOT mapping table, analogous to pricelists. PriceForge creates new snapshots; QuoteForge only pulls and reads them.
+
+### SQLite (local mirror)
+
+```sql
+CREATE TABLE local_partnumber_books (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    server_id  INTEGER UNIQUE NOT NULL,   -- id from qt_partnumber_books
+    version    TEXT    NOT NULL,          -- format YYYY-MM-DD-NNN
+    created_at DATETIME NOT NULL,
+    is_active  INTEGER NOT NULL DEFAULT 1
+);
+
+CREATE TABLE local_partnumber_book_items (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    book_id       INTEGER NOT NULL,      -- FK → local_partnumber_books.id
+    partnumber    TEXT    NOT NULL,
+    lot_name      TEXT    NOT NULL,
+    is_primary_pn INTEGER NOT NULL DEFAULT 0,
+    description   TEXT
+);
+CREATE INDEX idx_local_book_pn ON local_partnumber_book_items(book_id, partnumber);
+```
+
+**Active book query:** `WHERE is_active=1 ORDER BY created_at DESC, id DESC LIMIT 1`
+
+**Schema creation:** GORM AutoMigrate (not `runLocalMigrations`).
+
+### MariaDB (managed exclusively by PriceForge)
+
+```sql
+CREATE TABLE qt_partnumber_books (
+    id         INT AUTO_INCREMENT PRIMARY KEY,
+    version    VARCHAR(50)  NOT NULL,
+    created_at DATETIME     NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    is_active  TINYINT(1)   NOT NULL DEFAULT 1
+);
+
+CREATE TABLE qt_partnumber_book_items (
+    id            INT AUTO_INCREMENT PRIMARY KEY,
+    book_id       INT          NOT NULL,
+    partnumber    VARCHAR(255) NOT NULL,
+    lot_name      VARCHAR(255) NOT NULL,
+    is_primary_pn TINYINT(1)   NOT NULL DEFAULT 0,
+    description   VARCHAR(10000) NULL,
+    INDEX idx_book_pn (book_id, partnumber),
+    FOREIGN KEY (book_id) REFERENCES qt_partnumber_books(id)
+);
+
+ALTER TABLE qt_configurations ADD COLUMN vendor_spec JSON NULL;
+```
+
+QuoteForge has `SELECT` permission only on `qt_partnumber_books` and `qt_partnumber_book_items`. All writes are managed by PriceForge.
+
+**Grant (add to existing user setup):**
+```sql
+GRANT SELECT ON RFQ_LOG.qt_partnumber_books TO '<DB_USER>'@'%';
+GRANT SELECT ON RFQ_LOG.qt_partnumber_book_items TO '<DB_USER>'@'%';
+```
+
+### `is_primary_pn` semantics
+
+- `1` = primary PN for this `lot_name`. Its quantity in the vendor BOM determines `qty(LOT)`.
+- `0` = non-primary (trigger) PN. If no primary PN for the LOT is found in BOM, contributes `qty=1`.
+
+---
+
+## Resolution Algorithm (3-step)
+
+For each `vendor_partnumber` in the BOM, QuoteForge builds/updates UI-visible LOT mappings:
+
+1. **Active book lookup** — query `local_partnumber_book_items WHERE book_id = activeBook.id AND partnumber = ?`.
+2. **Populate BOM UI** — if a match exists, BOM row shows a LOT value (user can still edit it).
+3. **Unresolved** — red row + inline LOT input with strict autocomplete.
+
+Persistence note: the application stores the final user-visible mappings in `lot_mappings[]` (not separate "resolved/manual" persisted fields).
+
+---
+
+## Qty Aggregation Logic
+
+After resolution, qty per LOT is computed as:
+
+```
+qty(lot) = SUM(quantity of rows where is_primary_pn=1 AND resolved_lot=lot)
+           if at least one primary PN for this lot was found in BOM
+         = 1
+           if only non-primary PNs for this lot were found
+```
+
+Examples (book: LOT_A → x1[primary], x2, x3):
+- BOM: x2×1, x3×2 → 1×LOT_A (no primary PN)
+- BOM: x1×2, x2×1 → 2×LOT_A (primary qty=2)
+- BOM: x1×1, x2×3 → 1×LOT_A (primary qty=1)
+
+---
+
+## UI: Three Top-Level Tabs
+
+The configurator (`/configurator`) has three tabs:
+
+1. **Estimate** — existing cart/component configurator (unchanged).
+2. **BOM** — paste/import vendor BOM, manual column mapping, LOT matching, bundle decomposition (`1 PN -> multiple LOTs`), "Пересчитать эстимейт", "Очистить".
+3. **Ценообразование** — pricing summary table + custom price input.
+
+BOM data is shared between tabs 2 and 3.
+
+### BOM Import UI (raw table, manual column mapping)
+
+After paste (`Ctrl+V`) QuoteForge renders an editable raw table (not auto-detected parsing).
+
+- The pasted rows are shown **as-is** (including header rows, if present).
+- The user selects a type for each column manually:
+  - `P/N`
+  - `Кол-во`
+  - `Цена`
+  - `Описание`
+  - `Не использовать`
+- Required mapping:
+  - exactly one `P/N`
+  - exactly one `Кол-во`
+- Optional mapping:
+  - `Цена` (0..1)
+  - `Описание` (0..1)
+- Rows can be:
+  - ignored (UI-only, excluded from `vendor_spec`)
+  - deleted
+- Raw cells are editable inline after paste.
+
+Notes:
+- There is **no auto column detection**.
+- There is **no auto header-row skip**.
+- Raw import layout itself is not stored on server; only normalized `vendor_spec` is stored.
+
+### LOT matching in BOM table
+
+The BOM table adds service columns on the right:
+
+- `LOT`
+- `LOT в 1 PN`
+- actions (`+`, ignore, delete)
+
+`LOT` behavior:
+- The first LOT row shown in the BOM UI is the primary LOT mapping for the PN row.
+- Additional LOT rows are added via the `+` action.
+- inline LOT input is strict:
+  - autocomplete source = full local components list (`/api/components?per_page=5000`)
+  - free text that does not match an existing LOT is rejected
+
+`LOT в 1 PN` behavior:
+- quantity multiplier for each visible LOT row in BOM (`quantity_per_pn` in persisted `lot_mappings[]`)
+- default = `1`
+- editable inline
+
+### Bundle mode (`1 PN -> multiple LOTs`)
+
+The `+` action in BOM rows adds an extra LOT mapping row for the same vendor PN row.
+
+- All visible LOT rows (first + added rows) are persisted uniformly in `lot_mappings[]`
+- Each mapping row has:
+  - LOT
+  - qty (`LOT in 1 PN` = `quantity_per_pn`)
+
+### BOM restore on config open
+
+On config open, QuoteForge loads `vendor_spec` from server and reconstructs the editable BOM table in normalized form:
+
+- columns restored as: `Qty | P/N | Description | Price`
+- column mapping restored as:
+  - `qty`, `pn`, `description`, `price`
+- LOT / `LOT в 1 PN` rows are restored from `vendor_spec.lot_mappings[]`
+
+This restores the BOM editing state, but not the original raw Excel layout (extra columns, ignored rows, original headers).
+
+### Pricing Tab: column order
+
+```
+LOT | PN вендора | Описание | Кол-во | Estimate | Цена вендора | Склад | Конк.
+```
+
+**If BOM is empty** — the pricing tab still renders, using cart items as rows (PN вендора = "—", Цена вендора = "—").
+
+**Description source priority:** BOM row description → LOT description from `local_components`.
+
+### Pricing Tab: BOM + Estimate merge behavior
+
+When BOM exists, the pricing tab renders:
+
+- BOM-based rows (including rows resolved via manual LOT and bundle mappings)
+- plus **Estimate-only LOTs** (rows currently in cart but not covered by BOM mappings)
+
+Estimate-only rows are shown as separate rows with:
+- `PN вендора = "—"`
+- vendor price = `—`
+- description from local components
+
+### Pricing Tab: "Своя цена" input
+
+- Manual entry → proportionally redistributes custom price into "Цена вендора" cells (proportional to each row's Estimate share). Last row absorbs rounding remainder.
+- "Проставить цены BOM" button → restores per-row original BOM prices directly (no proportional redistribution). Sets "Своя цена" to their sum.
+- Both paths show "Скидка от Estimate: X%" info.
+- "Экспорт CSV" button → downloads `pricing_<uuid>.csv` with UTF-8 BOM, same column order as table, plus Итого row.
+
+---
+
+## API Endpoints
+
+| Method | URL | Description |
+|--------|-----|-------------|
+| GET | `/api/configs/:uuid/vendor-spec` | Fetch stored BOM |
+| PUT | `/api/configs/:uuid/vendor-spec` | Replace BOM (full update) |
+| POST | `/api/configs/:uuid/vendor-spec/resolve` | Resolve PNs → LOTs (no cart mutation) |
+| POST | `/api/configs/:uuid/vendor-spec/apply` | Apply resolved LOTs to cart |
+| GET | `/api/partnumber-books` | List local book snapshots |
+| GET | `/api/partnumber-books/:id` | Items for a book by server_id |
+| POST | `/api/sync/partnumber-books` | Pull book snapshots from MariaDB |
+| POST | `/api/sync/partnumber-seen` | Push unresolved PNs to `qt_vendor_partnumber_seen` on MariaDB |
+
+## Unresolved PN Tracking (`qt_vendor_partnumber_seen`)
+
+After each `resolveBOM()` call, QuoteForge pushes PN rows to `POST /api/sync/partnumber-seen` (fire-and-forget from JS — errors silently ignored):
+
+- unresolved BOM rows (`ignored = false`)
+- raw BOM rows explicitly marked as ignored in UI (`ignored = true`) — these rows are **not** saved to `vendor_spec`, but are reported for server-side tracking
+
+The handler calls `sync.PushPartnumberSeen()` which upserts into `qt_vendor_partnumber_seen`:
+
+```sql
+INSERT INTO qt_vendor_partnumber_seen (source_type, vendor, partnumber, description, is_ignored, last_seen_at)
+VALUES ('manual', '', ?, ?, ?, NOW())
+ON DUPLICATE KEY UPDATE
+    last_seen_at = VALUES(last_seen_at),
+    is_ignored   = VALUES(is_ignored),
+    description  = COALESCE(NULLIF(VALUES(description), ''), description)
+```
+
+Uniqueness key: `partnumber` only (after PriceForge migration 025). PriceForge uses this table for populating the partnumber book.
+
+## BOM Persistence
+
+- `vendor_spec` is saved to server via `PUT /api/configs/:uuid/vendor-spec`.
+- `GET` / `PUT` `vendor_spec` must preserve row-level mapping fields used by the UI:
+  - `lot_mappings[]`
+  - each item: `lot_name`, `quantity_per_pn`
+- `description` is persisted in each BOM row and is used by the Pricing tab when available.
+- Ignored raw rows are **not** persisted into `vendor_spec`.
+- The PUT handler explicitly marshals `VendorSpec` to JSON string before passing to GORM `Update` (GORM does not reliably call `driver.Valuer` for custom types in `Update(column, value)`).
+- BOM is autosaved (debounced) after BOM-changing actions, including:
+  - `resolveBOM()`
+  - LOT row qty (`LOT в 1 PN`) changes
+  - LOT row add/remove (`+` / delete in bundle context)
+- "Сохранить BOM" button triggers explicit save.
+
+## Pricing Tab: Estimate Price Source
+
+`renderPricingTab()` is async. It calls `POST /api/quote/price-levels` with LOTs collected from:
+
+- `lot_mappings[]` from BOM rows
+- current Estimate/cart LOTs not covered by BOM mappings (to show estimate-only rows)
+
+This ensures Estimate prices appear for:
+
+- manually matched LOTs in the BOM tab
+- bundle LOTs
+- LOTs already present in Estimate but not mapped from BOM
+
+### Apply to Estimate (`Пересчитать эстимейт`)
+
+When applying BOM to Estimate, QuoteForge builds cart rows from explicit UI mappings stored in `lot_mappings[]`.
+
+For a BOM row with PN qty = `Q`:
+
+- each mapped LOT contributes `Q * quantity_per_pn`
+
+Rows without any valid LOT mapping are skipped.
+
+## Web Route
+
+| Route | Page |
+|-------|------|
+| `/partnumber-books` | Partnumber books — active book summary (unique LOTs, total PN, primary PN count), searchable items table, collapsible snapshot history |

bible-local/README.md

@@ -0,0 +1,55 @@
+# QuoteForge Bible — Architectural Documentation
+
+The single source of truth for architecture, schemas, and patterns.
+
+---
+
+## Table of Contents
+
+| File | Topic |
+|------|-------|
+| [01-overview.md](01-overview.md) | Product: purpose, features, tech stack, repository structure |
+| [02-architecture.md](02-architecture.md) | Architecture: local-first, sync, pricing, versioning |
+| [03-database.md](03-database.md) | DB schemas: SQLite + MariaDB, permissions, indexes |
+| [04-api.md](04-api.md) | API endpoints and web routes |
+| [05-config.md](05-config.md) | Configuration, environment variables, paths, installation |
+| [06-backup.md](06-backup.md) | Backup: implementation, rotation policy |
+| [07-dev.md](07-dev.md) | Development: commands, code style, guardrails |
+
+---
+
+## Bible Rules
+
+> **Every architectural decision must be recorded in the Bible.**
+>
+> Any change to DB schema, data access patterns, sync behavior, API contracts,
+> configuration format, or any other system-level aspect — the corresponding `bible/` file
+> **must be updated in the same commit** as the code.
+>
+> On every user-requested commit, the Bible must be reviewed and updated in that commit.
+>
+> The Bible is the single source of truth for architecture. Outdated documentation is worse than none.
+
+> **Documentation language: English.**
+>
+> All files in `bible/` are written and updated **in English only**.
+> Mixing languages is not allowed.
+
+---
+
+## Quick Reference
+
+**Where is user data stored?**
+SQLite → `~/Library/Application Support/QuoteForge/qfs.db` (macOS). MariaDB is sync-only.
+
+**How to look up a price for a line item?**
+`local_pricelist_items` → by `pricelist_id` from config + `lot_name`. Prices are **never** taken from `local_components`.
+
+**Pre-commit check?**
+`go build ./cmd/qfs && go vet ./...`
+
+**What must never be restored?**
+cron jobs, admin pricing, alerts, stock import, importer utility — all removed intentionally.
+
+**Where is the release changelog?**
+`releases/memory/v{major}.{minor}.{patch}.md`

cmd/cron/main.go

@@ -1,84 +0,0 @@
-package main
-
-import (
-	"flag"
-	"log"
-
-	"git.mchus.pro/mchus/quoteforge/internal/config"
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
-	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
-	"gorm.io/driver/mysql"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
-)
-
-func main() {
-	configPath := flag.String("config", "config.yaml", "path to config file")
-	cronJob := flag.String("job", "", "type of cron job to run (alerts, update-prices)")
-	flag.Parse()
-
-	cfg, err := config.Load(*configPath)
-	if err != nil {
-		log.Fatalf("Failed to load config: %v", err)
-	}
-
-	db, err := gorm.Open(mysql.Open(cfg.Database.DSN()), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
-	})
-	if err != nil {
-		log.Fatalf("Failed to connect to database: %v", err)
-	}
-
-	// Ensure tables exist
-	if err := models.Migrate(db); err != nil {
-		log.Fatalf("Migration failed: %v", err)
-	}
-
-	// Initialize repositories
-	statsRepo := repository.NewStatsRepository(db)
-	alertRepo := repository.NewAlertRepository(db)
-	componentRepo := repository.NewComponentRepository(db)
-	priceRepo := repository.NewPriceRepository(db)
-
-	// Initialize services
-	alertService := alerts.NewService(alertRepo, componentRepo, priceRepo, statsRepo, cfg.Alerts, cfg.Pricing)
-	pricingService := pricing.NewService(componentRepo, priceRepo, cfg.Pricing)
-
-	switch *cronJob {
-	case "alerts":
-		log.Println("Running alerts check...")
-		if err := alertService.CheckAndGenerateAlerts(); err != nil {
-			log.Printf("Error running alerts check: %v", err)
-		} else {
-			log.Println("Alerts check completed successfully")
-		}
-	case "update-prices":
-		log.Println("Recalculating all prices...")
-		updated, errors := pricingService.RecalculateAllPrices()
-		log.Printf("Prices recalculated: %d updated, %d errors", updated, errors)
-	case "reset-counters":
-		log.Println("Resetting usage counters...")
-		if err := statsRepo.ResetWeeklyCounters(); err != nil {
-			log.Printf("Error resetting weekly counters: %v", err)
-		}
-		if err := statsRepo.ResetMonthlyCounters(); err != nil {
-			log.Printf("Error resetting monthly counters: %v", err)
-		}
-		log.Println("Usage counters reset completed")
-	case "update-popularity":
-		log.Println("Updating popularity scores...")
-		if err := statsRepo.UpdatePopularityScores(); err != nil {
-			log.Printf("Error updating popularity scores: %v", err)
-		} else {
-			log.Println("Popularity scores updated successfully")
-		}
-	default:
-		log.Println("No valid cron job specified. Available jobs:")
-		log.Println("  - alerts: Check and generate alerts")
-		log.Println("  - update-prices: Recalculate all prices")
-		log.Println("  - reset-counters: Reset usage counters")
-		log.Println("  - update-popularity: Update popularity scores")
-	}
-}

cmd/importer/main.go

@@ -1,160 +0,0 @@
-package main
-
-import (
-	"flag"
-	"log"
-	"strings"
-
-	"git.mchus.pro/mchus/quoteforge/internal/config"
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"gorm.io/driver/mysql"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
-)
-
-func main() {
-	configPath := flag.String("config", "config.yaml", "path to config file")
-	flag.Parse()
-
-	cfg, err := config.Load(*configPath)
-	if err != nil {
-		log.Fatalf("Failed to load config: %v", err)
-	}
-
-	db, err := gorm.Open(mysql.Open(cfg.Database.DSN()), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
-	})
-	if err != nil {
-		log.Fatalf("Failed to connect to database: %v", err)
-	}
-
-	log.Println("Connected to database")
-
-	// Ensure tables exist
-	if err := models.Migrate(db); err != nil {
-		log.Fatalf("Migration failed: %v", err)
-	}
-	if err := models.SeedCategories(db); err != nil {
-		log.Fatalf("Seeding categories failed: %v", err)
-	}
-
-	// Load categories for lookup
-	var categories []models.Category
-	db.Find(&categories)
-	categoryMap := make(map[string]uint)
-	for _, c := range categories {
-		categoryMap[c.Code] = c.ID
-	}
-	log.Printf("Loaded %d categories", len(categories))
-
-	// Get all lots
-	var lots []models.Lot
-	if err := db.Find(&lots).Error; err != nil {
-		log.Fatalf("Failed to load lots: %v", err)
-	}
-	log.Printf("Found %d lots to import", len(lots))
-
-	// Import each lot
-	var imported, skipped, updated int
-	for _, lot := range lots {
-		category, model := ParsePartNumber(lot.LotName)
-
-		var categoryID *uint
-		if id, ok := categoryMap[category]; ok && id > 0 {
-			categoryID = &id
-		} else {
-			// Try to find by prefix match
-			for code, id := range categoryMap {
-				if strings.HasPrefix(category, code) {
-					categoryID = &id
-					break
-				}
-			}
-		}
-
-		// Check if already exists
-		var existing models.LotMetadata
-		result := db.Where("lot_name = ?", lot.LotName).First(&existing)
-
-		if result.Error == gorm.ErrRecordNotFound {
-			// Check if there are prices in the last 90 days
-			var recentPriceCount int64
-			db.Model(&models.LotLog{}).
-				Where("lot = ? AND date >= DATE_SUB(NOW(), INTERVAL 90 DAY)", lot.LotName).
-				Count(&recentPriceCount)
-
-			// Default to 90 days, but use "all time" (0) if no recent prices
-			periodDays := 90
-			if recentPriceCount == 0 {
-				periodDays = 0
-			}
-
-			// Create new
-			metadata := models.LotMetadata{
-				LotName:         lot.LotName,
-				CategoryID:      categoryID,
-				Model:           model,
-				PricePeriodDays: periodDays,
-			}
-			if err := db.Create(&metadata).Error; err != nil {
-				log.Printf("Failed to create metadata for %s: %v", lot.LotName, err)
-				continue
-			}
-			imported++
-		} else if result.Error == nil {
-			// Update if needed
-			needsUpdate := false
-
-			if existing.Model == "" {
-				existing.Model = model
-				needsUpdate = true
-			}
-			if existing.CategoryID == nil {
-				existing.CategoryID = categoryID
-				needsUpdate = true
-			}
-
-			// Check if using default period (90 days) but no recent prices
-			if existing.PricePeriodDays == 90 {
-				var recentPriceCount int64
-				db.Model(&models.LotLog{}).
-					Where("lot = ? AND date >= DATE_SUB(NOW(), INTERVAL 90 DAY)", lot.LotName).
-					Count(&recentPriceCount)
-
-				if recentPriceCount == 0 {
-					existing.PricePeriodDays = 0
-					needsUpdate = true
-				}
-			}
-
-			if needsUpdate {
-				db.Save(&existing)
-				updated++
-			} else {
-				skipped++
-			}
-		}
-	}
-
-	log.Printf("Import complete: %d imported, %d updated, %d skipped", imported, updated, skipped)
-
-	// Show final counts
-	var metadataCount int64
-	db.Model(&models.LotMetadata{}).Count(&metadataCount)
-	log.Printf("Total metadata records: %d", metadataCount)
-}
-
-// ParsePartNumber extracts category and model from lot_name
-// Examples:
-// "CPU_AMD_9654" → category="CPU", model="AMD_9654"
-// "MB_INTEL_4.Sapphire_2S" → category="MB", model="INTEL_4.Sapphire_2S"
-func ParsePartNumber(lotName string) (category, model string) {
-	parts := strings.SplitN(lotName, "_", 2)
-	if len(parts) >= 1 {
-		category = parts[0]
-	}
-	if len(parts) >= 2 {
-		model = parts[1]
-	}
-	return
-}

cmd/migrate/main.go

@@ -6,7 +6,7 @@ import (
 	"log"
 	"time"
 
-	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/appstate"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"gorm.io/driver/mysql"
@@ -15,30 +15,17 @@ 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()
 
 	log.Println("QuoteForge Configuration Migration Tool")
 	log.Println("========================================")
 
-	// Load config for MariaDB connection
-	cfg, err := config.Load(*configPath)
-	if err != nil {
-		log.Fatalf("Failed to load config: %v", err)
-	}
-
-	// Connect to MariaDB
-	log.Printf("Connecting to MariaDB at %s:%d...", cfg.Database.Host, cfg.Database.Port)
-	mariaDB, err := gorm.Open(mysql.Open(cfg.Database.DSN()), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
-	})
-	if err != nil {
-		log.Fatalf("Failed to connect to MariaDB: %v", err)
-	}
-	log.Println("Connected to MariaDB")
-
 	// Initialize local SQLite
 	log.Printf("Opening local SQLite at %s...", *localDBPath)
 	local, err := localdb.New(*localDBPath)
@@ -46,6 +33,28 @@ func main() {
 		log.Fatalf("Failed to initialize local database: %v", err)
 	}
 	log.Println("Local SQLite initialized")
+	if !local.HasSettings() {
+		log.Fatalf("SQLite connection settings are not configured. Run qfs setup first.")
+	}
+
+	settings, err := local.GetSettings()
+	if err != nil {
+		log.Fatalf("Failed to load SQLite connection settings: %v", err)
+	}
+	dsn, err := local.GetDSN()
+	if err != nil {
+		log.Fatalf("Failed to build DSN from SQLite settings: %v", err)
+	}
+
+	// Connect to MariaDB
+	log.Printf("Connecting to MariaDB at %s:%d...", settings.Host, settings.Port)
+	mariaDB, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		log.Fatalf("Failed to connect to MariaDB: %v", err)
+	}
+	log.Println("Connected to MariaDB")
 
 	// Count configurations in MariaDB
 	var serverCount int64
@@ -61,7 +70,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)
 	}
 
@@ -72,9 +81,9 @@ func main() {
 	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 +119,22 @@ 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,
+			ProjectUUID:      c.ProjectUUID,
+			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 {
@@ -142,21 +153,12 @@ func main() {
 	log.Printf("  Skipped:  %d", skipped)
 	log.Printf("  Errors:   %d", errors)
 
-	// Save connection settings to local SQLite if not exists
-	if !local.HasSettings() {
-		log.Println("\nSaving connection settings to local SQLite...")
-		if err := local.SaveSettings(
-			cfg.Database.Host,
-			cfg.Database.Port,
-			cfg.Database.Name,
-			cfg.Database.User,
-			cfg.Database.Password,
-		); err != nil {
-			log.Printf("Warning: Failed to save settings: %v", err)
-		} else {
-			log.Println("Connection settings saved")
-		}
-	}
-
-	fmt.Println("\nDone! You can now run the server with: go run ./cmd/server")
+	fmt.Println("\nDone! You can now run the server with: go run ./cmd/qfs")
+}
+
+func derefUint(v *uint) uint {
+	if v == nil {
+		return 0
+	}
+	return *v
 }

cmd/migrate_ops_projects/main.go

@@ -0,0 +1,308 @@
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"regexp"
+	"sort"
+	"strings"
+
+	"git.mchus.pro/mchus/quoteforge/internal/appstate"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"github.com/google/uuid"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+type configRow struct {
+	ID            uint
+	UUID          string
+	OwnerUsername string
+	Name          string
+	ProjectUUID   *string
+}
+
+type migrationAction struct {
+	ConfigID          uint
+	ConfigUUID        string
+	ConfigName        string
+	OwnerUsername     string
+	TargetProjectName string
+	CurrentProject    string
+	NeedCreateProject bool
+	NeedReactivate    bool
+}
+
+func main() {
+	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)")
+	apply := flag.Bool("apply", false, "apply migration (default is preview only)")
+	yes := flag.Bool("yes", false, "skip interactive confirmation (works only with -apply)")
+	flag.Parse()
+
+	local, err := localdb.New(*localDBPath)
+	if err != nil {
+		log.Fatalf("failed to initialize local database: %v", err)
+	}
+	if !local.HasSettings() {
+		log.Fatalf("SQLite connection settings are not configured. Run qfs setup first.")
+	}
+	dsn, err := local.GetDSN()
+	if err != nil {
+		log.Fatalf("failed to build DSN from SQLite settings: %v", err)
+	}
+	dbUser := strings.TrimSpace(local.GetDBUser())
+
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		log.Fatalf("failed to connect database: %v", err)
+	}
+
+	if err := ensureProjectsTable(db); err != nil {
+		log.Fatalf("precheck failed: %v", err)
+	}
+
+	actions, existingProjects, err := buildPlan(db, dbUser)
+	if err != nil {
+		log.Fatalf("failed to build migration plan: %v", err)
+	}
+
+	printPlan(actions)
+	if len(actions) == 0 {
+		fmt.Println("Nothing to migrate.")
+		return
+	}
+
+	if !*apply {
+		fmt.Println("\nPreview complete. Re-run with -apply to execute.")
+		return
+	}
+
+	if !*yes {
+		ok, confirmErr := askForConfirmation()
+		if confirmErr != nil {
+			log.Fatalf("confirmation failed: %v", confirmErr)
+		}
+		if !ok {
+			fmt.Println("Aborted.")
+			return
+		}
+	}
+
+	if err := executePlan(db, actions, existingProjects); err != nil {
+		log.Fatalf("migration failed: %v", err)
+	}
+
+	fmt.Println("Migration completed successfully.")
+}
+
+func ensureProjectsTable(db *gorm.DB) error {
+	var count int64
+	if err := db.Raw("SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = 'qt_projects'").Scan(&count).Error; err != nil {
+		return fmt.Errorf("checking qt_projects table: %w", err)
+	}
+	if count == 0 {
+		return fmt.Errorf("table qt_projects does not exist; run migration 009_add_projects.sql first")
+	}
+	return nil
+}
+
+func buildPlan(db *gorm.DB, fallbackOwner string) ([]migrationAction, map[string]*models.Project, error) {
+	var configs []configRow
+	if err := db.Table("qt_configurations").
+		Select("id, uuid, owner_username, name, project_uuid").
+		Find(&configs).Error; err != nil {
+		return nil, nil, fmt.Errorf("load configurations: %w", err)
+	}
+
+	codeRegex := regexp.MustCompile(`^(OPS-[0-9]{4})`)
+	owners := make(map[string]struct{})
+	projectNames := make(map[string]struct{})
+	type candidate struct {
+		config configRow
+		code   string
+		owner  string
+	}
+	candidates := make([]candidate, 0)
+
+	for _, cfg := range configs {
+		match := codeRegex.FindStringSubmatch(strings.TrimSpace(cfg.Name))
+		if len(match) < 2 {
+			continue
+		}
+		owner := strings.TrimSpace(cfg.OwnerUsername)
+		if owner == "" {
+			owner = strings.TrimSpace(fallbackOwner)
+		}
+		if owner == "" {
+			continue
+		}
+		code := match[1]
+		owners[owner] = struct{}{}
+		projectNames[code] = struct{}{}
+		candidates = append(candidates, candidate{config: cfg, code: code, owner: owner})
+	}
+
+	ownerList := setKeys(owners)
+	nameList := setKeys(projectNames)
+	existingProjects := make(map[string]*models.Project)
+	if len(ownerList) > 0 && len(nameList) > 0 {
+		var projects []models.Project
+		if err := db.Where("owner_username IN ? AND name IN ?", ownerList, nameList).Find(&projects).Error; err != nil {
+			return nil, nil, fmt.Errorf("load existing projects: %w", err)
+		}
+		for i := range projects {
+			p := projects[i]
+			existingProjects[projectKey(p.OwnerUsername, derefString(p.Name))] = &p
+		}
+	}
+
+	actions := make([]migrationAction, 0)
+	for _, c := range candidates {
+		key := projectKey(c.owner, c.code)
+		existing := existingProjects[key]
+
+		currentProject := ""
+		if c.config.ProjectUUID != nil {
+			currentProject = *c.config.ProjectUUID
+		}
+
+		if existing != nil && currentProject == existing.UUID {
+			continue
+		}
+
+		action := migrationAction{
+			ConfigID:          c.config.ID,
+			ConfigUUID:        c.config.UUID,
+			ConfigName:        c.config.Name,
+			OwnerUsername:     c.owner,
+			TargetProjectName: c.code,
+			CurrentProject:    currentProject,
+		}
+		if existing == nil {
+			action.NeedCreateProject = true
+		} else if !existing.IsActive {
+			action.NeedReactivate = true
+		}
+		actions = append(actions, action)
+	}
+
+	return actions, existingProjects, nil
+}
+
+func printPlan(actions []migrationAction) {
+	createCount := 0
+	reactivateCount := 0
+	for _, a := range actions {
+		if a.NeedCreateProject {
+			createCount++
+		}
+		if a.NeedReactivate {
+			reactivateCount++
+		}
+	}
+
+	fmt.Printf("Planned actions: %d\n", len(actions))
+	fmt.Printf("Projects to create: %d\n", createCount)
+	fmt.Printf("Projects to reactivate: %d\n", reactivateCount)
+	fmt.Println("\nDetails:")
+
+	for _, a := range actions {
+		extra := ""
+		if a.NeedCreateProject {
+			extra = " [create project]"
+		} else if a.NeedReactivate {
+			extra = " [reactivate project]"
+		}
+		current := a.CurrentProject
+		if current == "" {
+			current = "NULL"
+		}
+		fmt.Printf("- %s | owner=%s | \"%s\" | project: %s -> %s%s\n",
+			a.ConfigUUID, a.OwnerUsername, a.ConfigName, current, a.TargetProjectName, extra)
+	}
+}
+
+func askForConfirmation() (bool, error) {
+	fmt.Print("\nApply these changes? type 'yes' to continue: ")
+	reader := bufio.NewReader(os.Stdin)
+	line, err := reader.ReadString('\n')
+	if err != nil {
+		return false, err
+	}
+	return strings.EqualFold(strings.TrimSpace(line), "yes"), nil
+}
+
+func executePlan(db *gorm.DB, actions []migrationAction, existingProjects map[string]*models.Project) error {
+	return db.Transaction(func(tx *gorm.DB) error {
+		projectCache := make(map[string]*models.Project, len(existingProjects))
+		for k, v := range existingProjects {
+			cp := *v
+			projectCache[k] = &cp
+		}
+
+		for _, action := range actions {
+			key := projectKey(action.OwnerUsername, action.TargetProjectName)
+		project := projectCache[key]
+			if project == nil {
+				project = &models.Project{
+					UUID:          uuid.NewString(),
+					OwnerUsername: action.OwnerUsername,
+					Code:          action.TargetProjectName,
+					Name:          ptrString(action.TargetProjectName),
+					IsActive:      true,
+					IsSystem:      false,
+				}
+				if err := tx.Create(project).Error; err != nil {
+					return fmt.Errorf("create project %s for owner %s: %w", action.TargetProjectName, action.OwnerUsername, err)
+				}
+				projectCache[key] = project
+			} else if !project.IsActive {
+				if err := tx.Model(&models.Project{}).Where("uuid = ?", project.UUID).Update("is_active", true).Error; err != nil {
+					return fmt.Errorf("reactivate project %s (%s): %w", derefString(project.Name), project.UUID, err)
+				}
+				project.IsActive = true
+			}
+
+			if err := tx.Table("qt_configurations").Where("id = ?", action.ConfigID).Update("project_uuid", project.UUID).Error; err != nil {
+				return fmt.Errorf("move configuration %s to project %s: %w", action.ConfigUUID, project.UUID, err)
+			}
+		}
+
+		return nil
+	})
+}
+
+func setKeys(set map[string]struct{}) []string {
+	keys := make([]string, 0, len(set))
+	for k := range set {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+func projectKey(owner, name string) string {
+	return owner + "||" + name
+}
+
+func derefString(value *string) string {
+	if value == nil {
+		return ""
+	}
+	return *value
+}
+
+func ptrString(value string) *string {
+	return &value
+}

cmd/qfs/config_migration_test.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+)
+
+func TestMigrateConfigFileToRuntimeShapeDropsDeprecatedSections(t *testing.T) {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.yaml")
+
+	legacy := `server:
+  host: "0.0.0.0"
+  port: 9191
+database:
+  host: "legacy-db"
+  port: 3306
+  name: "RFQ_LOG"
+  user: "old"
+  password: "REDACTED_TEST_PASSWORD"
+pricing:
+  default_method: "median"
+logging:
+  level: "debug"
+  format: "text"
+  output: "stdout"
+`
+	if err := os.WriteFile(path, []byte(legacy), 0644); err != nil {
+		t.Fatalf("write legacy config: %v", err)
+	}
+
+	cfg, err := config.Load(path)
+	if err != nil {
+		t.Fatalf("load legacy config: %v", err)
+	}
+	setConfigDefaults(cfg)
+	if err := migrateConfigFileToRuntimeShape(path, cfg); err != nil {
+		t.Fatalf("migrate config: %v", err)
+	}
+
+	got, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read migrated config: %v", err)
+	}
+	text := string(got)
+	if strings.Contains(text, "database:") {
+		t.Fatalf("migrated config still contains deprecated database section:\n%s", text)
+	}
+	if strings.Contains(text, "pricing:") {
+		t.Fatalf("migrated config still contains deprecated pricing section:\n%s", text)
+	}
+	if !strings.Contains(text, "server:") || !strings.Contains(text, "logging:") {
+		t.Fatalf("migrated config missing required sections:\n%s", text)
+	}
+	if !strings.Contains(text, "port: 9191") {
+		t.Fatalf("migrated config did not preserve server port:\n%s", text)
+	}
+	if !strings.Contains(text, "level: debug") {
+		t.Fatalf("migrated config did not preserve logging level:\n%s", text)
+	}
+}

cmd/qfs/versioning_api_test.go

@@ -0,0 +1,327 @@
+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 != 2 {
+		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 TestProjectArchiveHidesConfigsAndCloneIntoProject(t *testing.T) {
+	moveToRepoRoot(t)
+
+	local, connMgr, configService := newAPITestStack(t)
+	_ = configService
+
+	cfg := &config.Config{}
+	setConfigDefaults(cfg)
+	router, _, err := setupRouter(cfg, local, connMgr, nil, "tester", nil)
+	if err != nil {
+		t.Fatalf("setup router: %v", err)
+	}
+
+	createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"P1","code":"P1"}`)))
+	createProjectReq.Header.Set("Content-Type", "application/json")
+	createProjectRec := httptest.NewRecorder()
+	router.ServeHTTP(createProjectRec, createProjectReq)
+	if createProjectRec.Code != http.StatusCreated {
+		t.Fatalf("create project status=%d body=%s", createProjectRec.Code, createProjectRec.Body.String())
+	}
+	var project models.Project
+	if err := json.Unmarshal(createProjectRec.Body.Bytes(), &project); err != nil {
+		t.Fatalf("unmarshal project: %v", err)
+	}
+
+	createCfgBody := []byte(`{"name":"Cfg A","items":[{"lot_name":"CPU","quantity":1,"unit_price":100}],"server_count":1}`)
+	createCfgReq := httptest.NewRequest(http.MethodPost, "/api/projects/"+project.UUID+"/configs", bytes.NewReader(createCfgBody))
+	createCfgReq.Header.Set("Content-Type", "application/json")
+	createCfgRec := httptest.NewRecorder()
+	router.ServeHTTP(createCfgRec, createCfgReq)
+	if createCfgRec.Code != http.StatusCreated {
+		t.Fatalf("create project config status=%d body=%s", createCfgRec.Code, createCfgRec.Body.String())
+	}
+	var createdCfg models.Configuration
+	if err := json.Unmarshal(createCfgRec.Body.Bytes(), &createdCfg); err != nil {
+		t.Fatalf("unmarshal project config: %v", err)
+	}
+	if createdCfg.ProjectUUID == nil || *createdCfg.ProjectUUID != project.UUID {
+		t.Fatalf("expected config project_uuid=%s got=%v", project.UUID, createdCfg.ProjectUUID)
+	}
+
+	cloneReq := httptest.NewRequest(http.MethodPost, "/api/projects/"+project.UUID+"/configs/"+createdCfg.UUID+"/clone", bytes.NewReader([]byte(`{"name":"Cfg A Clone"}`)))
+	cloneReq.Header.Set("Content-Type", "application/json")
+	cloneRec := httptest.NewRecorder()
+	router.ServeHTTP(cloneRec, cloneReq)
+	if cloneRec.Code != http.StatusCreated {
+		t.Fatalf("clone in project status=%d body=%s", cloneRec.Code, cloneRec.Body.String())
+	}
+	var cloneCfg models.Configuration
+	if err := json.Unmarshal(cloneRec.Body.Bytes(), &cloneCfg); err != nil {
+		t.Fatalf("unmarshal clone config: %v", err)
+	}
+	if cloneCfg.ProjectUUID == nil || *cloneCfg.ProjectUUID != project.UUID {
+		t.Fatalf("expected clone project_uuid=%s got=%v", project.UUID, cloneCfg.ProjectUUID)
+	}
+
+	projectConfigsReq := httptest.NewRequest(http.MethodGet, "/api/projects/"+project.UUID+"/configs", nil)
+	projectConfigsRec := httptest.NewRecorder()
+	router.ServeHTTP(projectConfigsRec, projectConfigsReq)
+	if projectConfigsRec.Code != http.StatusOK {
+		t.Fatalf("project configs status=%d body=%s", projectConfigsRec.Code, projectConfigsRec.Body.String())
+	}
+	var projectConfigsResp struct {
+		Configurations []models.Configuration `json:"configurations"`
+	}
+	if err := json.Unmarshal(projectConfigsRec.Body.Bytes(), &projectConfigsResp); err != nil {
+		t.Fatalf("unmarshal project configs response: %v", err)
+	}
+	if len(projectConfigsResp.Configurations) != 2 {
+		t.Fatalf("expected 2 project configs after clone, got %d", len(projectConfigsResp.Configurations))
+	}
+
+	archiveReq := httptest.NewRequest(http.MethodPost, "/api/projects/"+project.UUID+"/archive", nil)
+	archiveRec := httptest.NewRecorder()
+	router.ServeHTTP(archiveRec, archiveReq)
+	if archiveRec.Code != http.StatusOK {
+		t.Fatalf("archive project status=%d body=%s", archiveRec.Code, archiveRec.Body.String())
+	}
+
+	activeReq := httptest.NewRequest(http.MethodGet, "/api/configs?status=active&page=1&per_page=20", nil)
+	activeRec := httptest.NewRecorder()
+	router.ServeHTTP(activeRec, activeReq)
+	if activeRec.Code != http.StatusOK {
+		t.Fatalf("active configs status=%d body=%s", activeRec.Code, activeRec.Body.String())
+	}
+	var activeResp struct {
+		Configurations []models.Configuration `json:"configurations"`
+	}
+	if err := json.Unmarshal(activeRec.Body.Bytes(), &activeResp); err != nil {
+		t.Fatalf("unmarshal active configs response: %v", err)
+	}
+	if len(activeResp.Configurations) != 0 {
+		t.Fatalf("expected no active configs after project archive, got %d", len(activeResp.Configurations))
+	}
+}
+
+func TestConfigMoveToProjectEndpoint(t *testing.T) {
+	moveToRepoRoot(t)
+
+	local, connMgr, _ := newAPITestStack(t)
+	cfg := &config.Config{}
+	setConfigDefaults(cfg)
+	router, _, err := setupRouter(cfg, local, connMgr, nil, "tester", nil)
+	if err != nil {
+		t.Fatalf("setup router: %v", err)
+	}
+
+	createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"Move Project","code":"MOVE"}`)))
+	createProjectReq.Header.Set("Content-Type", "application/json")
+	createProjectRec := httptest.NewRecorder()
+	router.ServeHTTP(createProjectRec, createProjectReq)
+	if createProjectRec.Code != http.StatusCreated {
+		t.Fatalf("create project status=%d body=%s", createProjectRec.Code, createProjectRec.Body.String())
+	}
+	var project models.Project
+	if err := json.Unmarshal(createProjectRec.Body.Bytes(), &project); err != nil {
+		t.Fatalf("unmarshal project: %v", err)
+	}
+
+	createConfigReq := httptest.NewRequest(http.MethodPost, "/api/configs", bytes.NewReader([]byte(`{"name":"Move Me","items":[],"notes":"","server_count":1}`)))
+	createConfigReq.Header.Set("Content-Type", "application/json")
+	createConfigRec := httptest.NewRecorder()
+	router.ServeHTTP(createConfigRec, createConfigReq)
+	if createConfigRec.Code != http.StatusCreated {
+		t.Fatalf("create config status=%d body=%s", createConfigRec.Code, createConfigRec.Body.String())
+	}
+	var created models.Configuration
+	if err := json.Unmarshal(createConfigRec.Body.Bytes(), &created); err != nil {
+		t.Fatalf("unmarshal config: %v", err)
+	}
+
+	moveReq := httptest.NewRequest(http.MethodPatch, "/api/configs/"+created.UUID+"/project", bytes.NewReader([]byte(`{"project_uuid":"`+project.UUID+`"}`)))
+	moveReq.Header.Set("Content-Type", "application/json")
+	moveRec := httptest.NewRecorder()
+	router.ServeHTTP(moveRec, moveReq)
+	if moveRec.Code != http.StatusOK {
+		t.Fatalf("move config status=%d body=%s", moveRec.Code, moveRec.Body.String())
+	}
+
+	getReq := httptest.NewRequest(http.MethodGet, "/api/configs/"+created.UUID, nil)
+	getRec := httptest.NewRecorder()
+	router.ServeHTTP(getRec, getReq)
+	if getRec.Code != http.StatusOK {
+		t.Fatalf("get config status=%d body=%s", getRec.Code, getRec.Body.String())
+	}
+	var updated models.Configuration
+	if err := json.Unmarshal(getRec.Body.Bytes(), &updated); err != nil {
+		t.Fatalf("unmarshal updated config: %v", err)
+	}
+	if updated.ProjectUUID == nil || *updated.ProjectUUID != project.UUID {
+		t.Fatalf("expected moved project_uuid=%s, got %v", project.UUID, updated.ProjectUUID)
+	}
+}
+
+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)
+	})
+}

config.example.yaml

@@ -37,6 +37,9 @@ export:
   max_file_age: "1h"
   company_name: "Your Company Name"
 
+backup:
+  time: "00:00"
+
 alerts:
   enabled: true
   check_interval: "1h"

crontab

@@ -1,15 +0,0 @@
-# Cron jobs for QuoteForge
-# Run alerts check every hour
-0 * * * * /app/quoteforge-cron -job=alerts
-
-# Run price updates daily at 2 AM
-0 2 * * * /app/quoteforge-cron -job=update-prices
-
-# Reset weekly counters every Sunday at 1 AM
-0 1 * * 0 /app/quoteforge-cron -job=reset-counters
-
-# Update popularity scores daily at 3 AM
-0 3 * * * /app/quoteforge-cron -job=update-popularity
-
-# Log rotation (optional)
-# 0 0 * * * /usr/bin/logrotate /etc/logrotate.conf

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/backup.go

@@ -0,0 +1,273 @@
+package appstate
+
+import (
+	"archive/zip"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+)
+
+type backupPeriod struct {
+	name      string
+	retention int
+	key       func(time.Time) string
+	date      func(time.Time) string
+}
+
+var backupPeriods = []backupPeriod{
+	{
+		name:      "daily",
+		retention: 7,
+		key: func(t time.Time) string {
+			return t.Format("2006-01-02")
+		},
+		date: func(t time.Time) string {
+			return t.Format("2006-01-02")
+		},
+	},
+	{
+		name:      "weekly",
+		retention: 4,
+		key: func(t time.Time) string {
+			y, w := t.ISOWeek()
+			return fmt.Sprintf("%04d-W%02d", y, w)
+		},
+		date: func(t time.Time) string {
+			return t.Format("2006-01-02")
+		},
+	},
+	{
+		name:      "monthly",
+		retention: 12,
+		key: func(t time.Time) string {
+			return t.Format("2006-01")
+		},
+		date: func(t time.Time) string {
+			return t.Format("2006-01-02")
+		},
+	},
+	{
+		name:      "yearly",
+		retention: 10,
+		key: func(t time.Time) string {
+			return t.Format("2006")
+		},
+		date: func(t time.Time) string {
+			return t.Format("2006-01-02")
+		},
+	},
+}
+
+const (
+	envBackupDisable = "QFS_BACKUP_DISABLE"
+	envBackupDir     = "QFS_BACKUP_DIR"
+)
+
+var backupNow = time.Now
+
+// EnsureRotatingLocalBackup creates or refreshes daily/weekly/monthly/yearly backups
+// for the local database and config. It keeps a limited number per period.
+func EnsureRotatingLocalBackup(dbPath, configPath string) ([]string, error) {
+	if isBackupDisabled() {
+		return nil, nil
+	}
+	if dbPath == "" {
+		return nil, nil
+	}
+
+	if _, err := os.Stat(dbPath); err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("stat db: %w", err)
+	}
+
+	root := resolveBackupRoot(dbPath)
+	now := backupNow()
+
+	created := make([]string, 0)
+	for _, period := range backupPeriods {
+		newFiles, err := ensurePeriodBackup(root, period, now, dbPath, configPath)
+		if err != nil {
+			return created, err
+		}
+		if len(newFiles) > 0 {
+			created = append(created, newFiles...)
+		}
+	}
+
+	return created, nil
+}
+
+func resolveBackupRoot(dbPath string) string {
+	if fromEnv := strings.TrimSpace(os.Getenv(envBackupDir)); fromEnv != "" {
+		return filepath.Clean(fromEnv)
+	}
+	return filepath.Join(filepath.Dir(dbPath), "backups")
+}
+
+func isBackupDisabled() bool {
+	val := strings.ToLower(strings.TrimSpace(os.Getenv(envBackupDisable)))
+	return val == "1" || val == "true" || val == "yes"
+}
+
+func ensurePeriodBackup(root string, period backupPeriod, now time.Time, dbPath, configPath string) ([]string, error) {
+	key := period.key(now)
+	periodDir := filepath.Join(root, period.name)
+	if err := os.MkdirAll(periodDir, 0755); err != nil {
+		return nil, fmt.Errorf("create %s backup dir: %w", period.name, err)
+	}
+
+	if hasBackupForKey(periodDir, key) {
+		return nil, nil
+	}
+
+	archiveName := fmt.Sprintf("qfs-backp-%s.zip", period.date(now))
+	archivePath := filepath.Join(periodDir, archiveName)
+
+	if err := createBackupArchive(archivePath, dbPath, configPath); err != nil {
+		return nil, fmt.Errorf("create %s backup archive: %w", period.name, err)
+	}
+
+	if err := writePeriodMarker(periodDir, key); err != nil {
+		return []string{archivePath}, err
+	}
+
+	if err := pruneOldBackups(periodDir, period.retention); err != nil {
+		return []string{archivePath}, err
+	}
+
+	return []string{archivePath}, nil
+}
+
+func hasBackupForKey(periodDir, key string) bool {
+	marker := periodMarker{Key: ""}
+	data, err := os.ReadFile(periodMarkerPath(periodDir))
+	if err != nil {
+		return false
+	}
+	if err := json.Unmarshal(data, &marker); err != nil {
+		return false
+	}
+	return marker.Key == key
+}
+
+type periodMarker struct {
+	Key string `json:"key"`
+}
+
+func periodMarkerPath(periodDir string) string {
+	return filepath.Join(periodDir, ".period.json")
+}
+
+func writePeriodMarker(periodDir, key string) error {
+	data, err := json.MarshalIndent(periodMarker{Key: key}, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(periodMarkerPath(periodDir), data, 0644)
+}
+
+func pruneOldBackups(periodDir string, keep int) error {
+	entries, err := os.ReadDir(periodDir)
+	if err != nil {
+		return fmt.Errorf("read backups dir: %w", err)
+	}
+
+	files := make([]os.DirEntry, 0, len(entries))
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+		if strings.HasSuffix(entry.Name(), ".zip") {
+			files = append(files, entry)
+		}
+	}
+
+	if len(files) <= keep {
+		return nil
+	}
+
+	sort.Slice(files, func(i, j int) bool {
+		infoI, errI := files[i].Info()
+		infoJ, errJ := files[j].Info()
+		if errI != nil || errJ != nil {
+			return files[i].Name() < files[j].Name()
+		}
+		return infoI.ModTime().Before(infoJ.ModTime())
+	})
+
+	for i := 0; i < len(files)-keep; i++ {
+		path := filepath.Join(periodDir, files[i].Name())
+		if err := os.Remove(path); err != nil {
+			return fmt.Errorf("remove old backup %s: %w", path, err)
+		}
+	}
+
+	return nil
+}
+
+func createBackupArchive(destPath, dbPath, configPath string) error {
+	file, err := os.Create(destPath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	zipWriter := zip.NewWriter(file)
+	if err := addZipFile(zipWriter, dbPath); err != nil {
+		_ = zipWriter.Close()
+		return err
+	}
+	_ = addZipOptionalFile(zipWriter, dbPath+"-wal")
+	_ = addZipOptionalFile(zipWriter, dbPath+"-shm")
+
+	if strings.TrimSpace(configPath) != "" {
+		_ = addZipOptionalFile(zipWriter, configPath)
+	}
+
+	if err := zipWriter.Close(); err != nil {
+		return err
+	}
+	return file.Sync()
+}
+
+func addZipOptionalFile(writer *zip.Writer, path string) error {
+	if _, err := os.Stat(path); err != nil {
+		return nil
+	}
+	return addZipFile(writer, path)
+}
+
+func addZipFile(writer *zip.Writer, path string) error {
+	in, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer in.Close()
+
+	info, err := in.Stat()
+	if err != nil {
+		return err
+	}
+
+	header, err := zip.FileInfoHeader(info)
+	if err != nil {
+		return err
+	}
+	header.Name = filepath.Base(path)
+	header.Method = zip.Deflate
+
+	out, err := writer.CreateHeader(header)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(out, in)
+	return err
+}

internal/appstate/backup_test.go

@@ -0,0 +1,83 @@
+package appstate
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestEnsureRotatingLocalBackupCreatesAndRotates(t *testing.T) {
+	temp := t.TempDir()
+	dbPath := filepath.Join(temp, "qfs.db")
+	cfgPath := filepath.Join(temp, "config.yaml")
+
+	if err := os.WriteFile(dbPath, []byte("db"), 0644); err != nil {
+		t.Fatalf("write db: %v", err)
+	}
+	if err := os.WriteFile(cfgPath, []byte("cfg"), 0644); err != nil {
+		t.Fatalf("write config: %v", err)
+	}
+
+	prevNow := backupNow
+	defer func() { backupNow = prevNow }()
+	backupNow = func() time.Time { return time.Date(2026, 2, 11, 10, 0, 0, 0, time.UTC) }
+
+	created, err := EnsureRotatingLocalBackup(dbPath, cfgPath)
+	if err != nil {
+		t.Fatalf("backup: %v", err)
+	}
+	if len(created) == 0 {
+		t.Fatalf("expected backup to be created")
+	}
+
+	dailyArchive := filepath.Join(temp, "backups", "daily", "qfs-backp-2026-02-11.zip")
+	if _, err := os.Stat(dailyArchive); err != nil {
+		t.Fatalf("daily archive missing: %v", err)
+	}
+
+	backupNow = func() time.Time { return time.Date(2026, 2, 12, 10, 0, 0, 0, time.UTC) }
+	created, err = EnsureRotatingLocalBackup(dbPath, cfgPath)
+	if err != nil {
+		t.Fatalf("backup rotate: %v", err)
+	}
+	if len(created) == 0 {
+		t.Fatalf("expected backup to be created for new day")
+	}
+
+	dailyArchive = filepath.Join(temp, "backups", "daily", "qfs-backp-2026-02-12.zip")
+	if _, err := os.Stat(dailyArchive); err != nil {
+		t.Fatalf("daily archive missing after rotate: %v", err)
+	}
+}
+
+func TestEnsureRotatingLocalBackupEnvControls(t *testing.T) {
+	temp := t.TempDir()
+	dbPath := filepath.Join(temp, "qfs.db")
+	cfgPath := filepath.Join(temp, "config.yaml")
+
+	if err := os.WriteFile(dbPath, []byte("db"), 0644); err != nil {
+		t.Fatalf("write db: %v", err)
+	}
+	if err := os.WriteFile(cfgPath, []byte("cfg"), 0644); err != nil {
+		t.Fatalf("write config: %v", err)
+	}
+
+	backupRoot := filepath.Join(temp, "custom_backups")
+	t.Setenv(envBackupDir, backupRoot)
+
+	if _, err := EnsureRotatingLocalBackup(dbPath, cfgPath); err != nil {
+		t.Fatalf("backup with env: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(backupRoot, "daily", "meta.json")); err != nil {
+		t.Fatalf("expected backup in custom dir: %v", err)
+	}
+
+	t.Setenv(envBackupDisable, "1")
+	if _, err := EnsureRotatingLocalBackup(dbPath, cfgPath); err != nil {
+		t.Fatalf("backup disabled: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(backupRoot, "daily", "meta.json")); err != nil {
+		t.Fatalf("backup should remain from previous run: %v", err)
+	}
+}

internal/appstate/path.go

@@ -0,0 +1,217 @@
+package appstate
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+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
+}
+
+// ResolveConfigPathNearDB returns config path using priority:
+// explicit CLI path > QFS_CONFIG_PATH > directory of resolved local DB path.
+// Falls back to ResolveConfigPath when dbPath is empty.
+func ResolveConfigPathNearDB(explicitPath, dbPath string) (string, error) {
+	if explicitPath != "" {
+		return filepath.Clean(explicitPath), nil
+	}
+
+	if fromEnv := os.Getenv(envCfgPath); fromEnv != "" {
+		return filepath.Clean(fromEnv), nil
+	}
+
+	if strings.TrimSpace(dbPath) != "" {
+		return filepath.Join(filepath.Dir(filepath.Clean(dbPath)), defaultCfg), nil
+	}
+
+	return ResolveConfigPath("")
+}
+
+// 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/article/categories.go

@@ -0,0 +1,124 @@
+package article
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+)
+
+// ErrMissingCategoryForLot is returned when a lot has no category in local_pricelist_items.lot_category.
+var ErrMissingCategoryForLot = errors.New("missing_category_for_lot")
+
+type MissingCategoryForLotError struct {
+	LotName string
+}
+
+func (e *MissingCategoryForLotError) Error() string {
+	if e == nil || strings.TrimSpace(e.LotName) == "" {
+		return ErrMissingCategoryForLot.Error()
+	}
+	return fmt.Sprintf("%s: %s", ErrMissingCategoryForLot.Error(), e.LotName)
+}
+
+func (e *MissingCategoryForLotError) Unwrap() error {
+	return ErrMissingCategoryForLot
+}
+
+type Group string
+
+const (
+	GroupCPU  Group = "CPU"
+	GroupMEM  Group = "MEM"
+	GroupGPU  Group = "GPU"
+	GroupDISK Group = "DISK"
+	GroupNET  Group = "NET"
+	GroupPSU  Group = "PSU"
+)
+
+// GroupForLotCategory maps pricelist lot_category codes into article groups.
+// Unknown/unrelated categories return ok=false.
+func GroupForLotCategory(cat string) (group Group, ok bool) {
+	c := strings.ToUpper(strings.TrimSpace(cat))
+	switch c {
+	case "CPU":
+		return GroupCPU, true
+	case "MEM":
+		return GroupMEM, true
+	case "GPU":
+		return GroupGPU, true
+	case "M2", "SSD", "HDD", "EDSFF", "HHHL":
+		return GroupDISK, true
+	case "NIC", "HCA", "DPU":
+		return GroupNET, true
+	case "HBA":
+		return GroupNET, true
+	case "PSU", "PS":
+		return GroupPSU, true
+	default:
+		return "", false
+	}
+}
+
+// ResolveLotCategoriesStrict resolves categories for lotNames using local_pricelist_items.lot_category
+// for a given server pricelist id. If any lot is missing or has empty category, returns an error.
+func ResolveLotCategoriesStrict(local *localdb.LocalDB, serverPricelistID uint, lotNames []string) (map[string]string, error) {
+	if local == nil {
+		return nil, fmt.Errorf("local db is nil")
+	}
+	cats, err := local.GetLocalLotCategoriesByServerPricelistID(serverPricelistID, lotNames)
+	if err != nil {
+		return nil, err
+	}
+	missing := make([]string, 0)
+	for _, lot := range lotNames {
+		cat := strings.TrimSpace(cats[lot])
+		if cat == "" {
+			missing = append(missing, lot)
+			continue
+		}
+		cats[lot] = cat
+	}
+	if len(missing) > 0 {
+		fallback, err := local.GetLocalComponentCategoriesByLotNames(missing)
+		if err != nil {
+			return nil, err
+		}
+		for _, lot := range missing {
+			if cat := strings.TrimSpace(fallback[lot]); cat != "" {
+				cats[lot] = cat
+			}
+		}
+		for _, lot := range missing {
+			if strings.TrimSpace(cats[lot]) == "" {
+				return nil, &MissingCategoryForLotError{LotName: lot}
+			}
+		}
+	}
+	return cats, nil
+}
+
+// NormalizeServerModel produces a stable article segment for the server model.
+func NormalizeServerModel(model string) string {
+	trimmed := strings.TrimSpace(model)
+	if trimmed == "" {
+		return ""
+	}
+	upper := strings.ToUpper(trimmed)
+	var b strings.Builder
+	for _, r := range upper {
+		if r >= 'A' && r <= 'Z' {
+			b.WriteRune(r)
+			continue
+		}
+		if r >= '0' && r <= '9' {
+			b.WriteRune(r)
+			continue
+		}
+		if r == '.' {
+			b.WriteRune(r)
+		}
+	}
+	return b.String()
+}

internal/article/categories_test.go

@@ -0,0 +1,98 @@
+package article
+
+import (
+	"errors"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+)
+
+func TestResolveLotCategoriesStrict_MissingCategoryReturnsError(t *testing.T) {
+	local, err := localdb.New(filepath.Join(t.TempDir(), "local.db"))
+	if err != nil {
+		t.Fatalf("init local db: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
+		ServerID:  1,
+		Source:    "estimate",
+		Version:   "S-2026-02-11-001",
+		Name:      "test",
+		CreatedAt: time.Now(),
+		SyncedAt:  time.Now(),
+	}); err != nil {
+		t.Fatalf("save local pricelist: %v", err)
+	}
+	localPL, err := local.GetLocalPricelistByServerID(1)
+	if err != nil {
+		t.Fatalf("get local pricelist: %v", err)
+	}
+	if err := local.SaveLocalPricelistItems([]localdb.LocalPricelistItem{
+		{PricelistID: localPL.ID, LotName: "CPU_A", LotCategory: "", Price: 10},
+	}); err != nil {
+		t.Fatalf("save local items: %v", err)
+	}
+
+	_, err = ResolveLotCategoriesStrict(local, 1, []string{"CPU_A"})
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+	if !errors.Is(err, ErrMissingCategoryForLot) {
+		t.Fatalf("expected ErrMissingCategoryForLot, got %v", err)
+	}
+}
+
+func TestResolveLotCategoriesStrict_FallbackToLocalComponents(t *testing.T) {
+	local, err := localdb.New(filepath.Join(t.TempDir(), "local.db"))
+	if err != nil {
+		t.Fatalf("init local db: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
+		ServerID:  2,
+		Source:    "estimate",
+		Version:   "S-2026-02-11-002",
+		Name:      "test",
+		CreatedAt: time.Now(),
+		SyncedAt:  time.Now(),
+	}); err != nil {
+		t.Fatalf("save local pricelist: %v", err)
+	}
+	localPL, err := local.GetLocalPricelistByServerID(2)
+	if err != nil {
+		t.Fatalf("get local pricelist: %v", err)
+	}
+	if err := local.SaveLocalPricelistItems([]localdb.LocalPricelistItem{
+		{PricelistID: localPL.ID, LotName: "CPU_B", LotCategory: "", Price: 10},
+	}); err != nil {
+		t.Fatalf("save local items: %v", err)
+	}
+	if err := local.DB().Create(&localdb.LocalComponent{
+		LotName:        "CPU_B",
+		Category:       "CPU",
+		LotDescription: "cpu",
+	}).Error; err != nil {
+		t.Fatalf("save local components: %v", err)
+	}
+
+	cats, err := ResolveLotCategoriesStrict(local, 2, []string{"CPU_B"})
+	if err != nil {
+		t.Fatalf("expected fallback, got error: %v", err)
+	}
+	if cats["CPU_B"] != "CPU" {
+		t.Fatalf("expected CPU, got %q", cats["CPU_B"])
+	}
+}
+
+func TestGroupForLotCategory(t *testing.T) {
+	if g, ok := GroupForLotCategory("cpu"); !ok || g != GroupCPU {
+		t.Fatalf("expected cpu -> GroupCPU")
+	}
+	if g, ok := GroupForLotCategory("SFP"); ok || g != "" {
+		t.Fatalf("expected SFP to be excluded")
+	}
+}

internal/article/generator.go

@@ -0,0 +1,605 @@
+package article
+
+import (
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+)
+
+type BuildOptions struct {
+	ServerModel     string
+	SupportCode     string
+	ServerPricelist *uint
+}
+
+type BuildResult struct {
+	Article  string
+	Warnings []string
+}
+
+var (
+	reMemGiB = regexp.MustCompile(`(?i)(\d+)\s*(GB|G)`)
+	reMemTiB = regexp.MustCompile(`(?i)(\d+)\s*(TB|T)`)
+	reCapacityT = regexp.MustCompile(`(?i)(\d+(?:[.,]\d+)?)T`)
+	reCapacityG = regexp.MustCompile(`(?i)(\d+(?:[.,]\d+)?)G`)
+	rePortSpeed = regexp.MustCompile(`(?i)(\d+)p(\d+)(GbE|G)`)
+	rePortFC = regexp.MustCompile(`(?i)(\d+)pFC(\d+)`)
+	reWatts = regexp.MustCompile(`(?i)(\d{3,5})\s*W`)
+)
+
+func Build(local *localdb.LocalDB, items []models.ConfigItem, opts BuildOptions) (BuildResult, error) {
+	segments := make([]string, 0, 8)
+	warnings := make([]string, 0)
+
+	model := NormalizeServerModel(opts.ServerModel)
+	if model == "" {
+		return BuildResult{}, fmt.Errorf("server_model required")
+	}
+	segments = append(segments, model)
+
+	lotNames := make([]string, 0, len(items))
+	for _, it := range items {
+		lotNames = append(lotNames, it.LotName)
+	}
+
+	if opts.ServerPricelist == nil || *opts.ServerPricelist == 0 {
+		return BuildResult{}, fmt.Errorf("pricelist_id required for article")
+	}
+
+	cats, err := ResolveLotCategoriesStrict(local, *opts.ServerPricelist, lotNames)
+	if err != nil {
+		return BuildResult{}, err
+	}
+
+	cpuSeg := buildCPUSegment(items, cats)
+	if cpuSeg != "" {
+		segments = append(segments, cpuSeg)
+	}
+	memSeg, memWarn := buildMemSegment(items, cats)
+	if memWarn != "" {
+		warnings = append(warnings, memWarn)
+	}
+	if memSeg != "" {
+		segments = append(segments, memSeg)
+	}
+	gpuSeg := buildGPUSegment(items, cats)
+	if gpuSeg != "" {
+		segments = append(segments, gpuSeg)
+	}
+	diskSeg, diskWarn := buildDiskSegment(items, cats)
+	if diskWarn != "" {
+		warnings = append(warnings, diskWarn)
+	}
+	if diskSeg != "" {
+		segments = append(segments, diskSeg)
+	}
+	netSeg, netWarn := buildNetSegment(items, cats)
+	if netWarn != "" {
+		warnings = append(warnings, netWarn)
+	}
+	if netSeg != "" {
+		segments = append(segments, netSeg)
+	}
+	psuSeg, psuWarn := buildPSUSegment(items, cats)
+	if psuWarn != "" {
+		warnings = append(warnings, psuWarn)
+	}
+	if psuSeg != "" {
+		segments = append(segments, psuSeg)
+	}
+
+	if strings.TrimSpace(opts.SupportCode) != "" {
+		code := strings.TrimSpace(opts.SupportCode)
+		if !isSupportCodeValid(code) {
+			return BuildResult{}, fmt.Errorf("invalid_support_code")
+		}
+		segments = append(segments, code)
+	}
+
+	article := strings.Join(segments, "-")
+	if len([]rune(article)) > 80 {
+		article = compressArticle(segments)
+		warnings = append(warnings, "compressed")
+	}
+	if len([]rune(article)) > 80 {
+		return BuildResult{}, fmt.Errorf("article_overflow")
+	}
+
+	return BuildResult{Article: article, Warnings: warnings}, nil
+}
+
+func isSupportCodeValid(code string) bool {
+	if len(code) < 3 {
+		return false
+	}
+	if !strings.Contains(code, "y") {
+		return false
+	}
+	parts := strings.Split(code, "y")
+	if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
+		return false
+	}
+	for _, r := range parts[0] {
+		if r < '0' || r > '9' {
+			return false
+		}
+	}
+	switch parts[1] {
+	case "W", "B", "S", "P":
+		return true
+	default:
+		return false
+	}
+}
+
+func buildCPUSegment(items []models.ConfigItem, cats map[string]string) string {
+	type agg struct {
+		qty int
+	}
+	models := map[string]*agg{}
+	for _, it := range items {
+		group, ok := GroupForLotCategory(cats[it.LotName])
+		if !ok || group != GroupCPU {
+			continue
+		}
+		model := parseCPUModel(it.LotName)
+		if model == "" {
+			model = "UNK"
+		}
+		if _, ok := models[model]; !ok {
+			models[model] = &agg{}
+		}
+		models[model].qty += it.Quantity
+	}
+	if len(models) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(models))
+	for model, a := range models {
+		parts = append(parts, fmt.Sprintf("%dx%s", a.qty, model))
+	}
+	sort.Strings(parts)
+	return strings.Join(parts, "+")
+}
+
+func buildMemSegment(items []models.ConfigItem, cats map[string]string) (string, string) {
+	totalGiB := 0
+	for _, it := range items {
+		group, ok := GroupForLotCategory(cats[it.LotName])
+		if !ok || group != GroupMEM {
+			continue
+		}
+		per := parseMemGiB(it.LotName)
+		if per <= 0 {
+			return "", "mem_unknown"
+		}
+		totalGiB += per * it.Quantity
+	}
+	if totalGiB == 0 {
+		return "", ""
+	}
+	if totalGiB%1024 == 0 {
+		return fmt.Sprintf("%dT", totalGiB/1024), ""
+	}
+	return fmt.Sprintf("%dG", totalGiB), ""
+}
+
+func buildGPUSegment(items []models.ConfigItem, cats map[string]string) string {
+	models := map[string]int{}
+	for _, it := range items {
+		group, ok := GroupForLotCategory(cats[it.LotName])
+		if !ok || group != GroupGPU {
+			continue
+		}
+		if strings.HasPrefix(strings.ToUpper(it.LotName), "MB_") {
+			continue
+		}
+		model := parseGPUModel(it.LotName)
+		if model == "" {
+			model = "UNK"
+		}
+		models[model] += it.Quantity
+	}
+	if len(models) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(models))
+	for model, qty := range models {
+		parts = append(parts, fmt.Sprintf("%dx%s", qty, model))
+	}
+	sort.Strings(parts)
+	return strings.Join(parts, "+")
+}
+
+func buildDiskSegment(items []models.ConfigItem, cats map[string]string) (string, string) {
+	type key struct {
+		t string
+		c string
+	}
+	groupQty := map[key]int{}
+	warn := ""
+	for _, it := range items {
+		group, ok := GroupForLotCategory(cats[it.LotName])
+		if !ok || group != GroupDISK {
+			continue
+		}
+		capToken := parseCapacity(it.LotName)
+		if capToken == "" {
+			warn = "disk_unknown"
+		}
+		typeCode := diskTypeCode(cats[it.LotName], it.LotName)
+		k := key{t: typeCode, c: capToken}
+		groupQty[k] += it.Quantity
+	}
+	if len(groupQty) == 0 {
+		return "", ""
+	}
+	parts := make([]string, 0, len(groupQty))
+	for k, qty := range groupQty {
+		if k.c == "" {
+			parts = append(parts, fmt.Sprintf("%dx%s", qty, k.t))
+		} else {
+			parts = append(parts, fmt.Sprintf("%dx%s%s", qty, k.c, k.t))
+		}
+	}
+	sort.Strings(parts)
+	return strings.Join(parts, "+"), warn
+}
+
+func buildNetSegment(items []models.ConfigItem, cats map[string]string) (string, string) {
+	groupQty := map[string]int{}
+	warn := ""
+	for _, it := range items {
+		group, ok := GroupForLotCategory(cats[it.LotName])
+		if !ok || group != GroupNET {
+			continue
+		}
+		profile := parsePortSpeed(it.LotName)
+		if profile == "" {
+			profile = "UNKNET"
+			warn = "net_unknown"
+		}
+		groupQty[profile] += it.Quantity
+	}
+	if len(groupQty) == 0 {
+		return "", ""
+	}
+	parts := make([]string, 0, len(groupQty))
+	for profile, qty := range groupQty {
+		parts = append(parts, fmt.Sprintf("%dx%s", qty, profile))
+	}
+	sort.Strings(parts)
+	return strings.Join(parts, "+"), warn
+}
+
+func buildPSUSegment(items []models.ConfigItem, cats map[string]string) (string, string) {
+	groupQty := map[string]int{}
+	warn := ""
+	for _, it := range items {
+		group, ok := GroupForLotCategory(cats[it.LotName])
+		if !ok || group != GroupPSU {
+			continue
+		}
+		rating := parseWatts(it.LotName)
+		if rating == "" {
+			rating = "UNKPSU"
+			warn = "psu_unknown"
+		}
+		groupQty[rating] += it.Quantity
+	}
+	if len(groupQty) == 0 {
+		return "", ""
+	}
+	parts := make([]string, 0, len(groupQty))
+	for rating, qty := range groupQty {
+		parts = append(parts, fmt.Sprintf("%dx%s", qty, rating))
+	}
+	sort.Strings(parts)
+	return strings.Join(parts, "+"), warn
+}
+
+func normalizeModelToken(lotName string) string {
+	if idx := strings.Index(lotName, "_"); idx >= 0 && idx+1 < len(lotName) {
+		lotName = lotName[idx+1:]
+	}
+	parts := strings.Split(lotName, "_")
+	token := parts[len(parts)-1]
+	return strings.ToUpper(strings.TrimSpace(token))
+}
+
+func parseCPUModel(lotName string) string {
+	parts := strings.Split(lotName, "_")
+	if len(parts) >= 2 {
+		last := strings.ToUpper(strings.TrimSpace(parts[len(parts)-1]))
+		if last != "" {
+			return last
+		}
+	}
+	return normalizeModelToken(lotName)
+}
+
+func parseGPUModel(lotName string) string {
+	upper := strings.ToUpper(lotName)
+	if idx := strings.Index(upper, "GPU_"); idx >= 0 {
+		upper = upper[idx+4:]
+	}
+	parts := strings.Split(upper, "_")
+	model := ""
+	mem := ""
+	for i, p := range parts {
+		if p == "" {
+			continue
+		}
+		switch p {
+		case "NV", "NVIDIA", "INTEL", "AMD", "RADEON", "PCIE", "PCI", "SXM", "SXMX":
+			continue
+		default:
+			if strings.Contains(p, "GB") {
+				mem = p
+				continue
+			}
+			if model == "" && (i > 0) {
+				model = p
+			}
+		}
+	}
+	if model != "" && mem != "" {
+		return model + "_" + mem
+	}
+	if model != "" {
+		return model
+	}
+	return normalizeModelToken(lotName)
+}
+
+func parseMemGiB(lotName string) int {
+	if m := reMemTiB.FindStringSubmatch(lotName); len(m) == 3 {
+		return atoi(m[1]) * 1024
+	}
+	if m := reMemGiB.FindStringSubmatch(lotName); len(m) == 3 {
+		return atoi(m[1])
+	}
+	return 0
+}
+
+func parseCapacity(lotName string) string {
+	if m := reCapacityT.FindStringSubmatch(lotName); len(m) == 2 {
+		return normalizeTToken(strings.ReplaceAll(m[1], ",", ".")) + "T"
+	}
+	if m := reCapacityG.FindStringSubmatch(lotName); len(m) == 2 {
+		return normalizeNumberToken(strings.ReplaceAll(m[1], ",", ".")) + "G"
+	}
+	return ""
+}
+
+func diskTypeCode(cat string, lotName string) string {
+	c := strings.ToUpper(strings.TrimSpace(cat))
+	if c == "M2" {
+		return "M2"
+	}
+	upper := strings.ToUpper(lotName)
+	if strings.Contains(upper, "NVME") {
+		return "NV"
+	}
+	if strings.Contains(upper, "SAS") {
+		return "SAS"
+	}
+	if strings.Contains(upper, "SATA") {
+		return "SAT"
+	}
+	return c
+}
+
+func parsePortSpeed(lotName string) string {
+	if m := rePortSpeed.FindStringSubmatch(lotName); len(m) == 4 {
+		return fmt.Sprintf("%sp%sG", m[1], m[2])
+	}
+	if m := rePortFC.FindStringSubmatch(lotName); len(m) == 3 {
+		return fmt.Sprintf("%spFC%s", m[1], m[2])
+	}
+	return ""
+}
+
+func parseWatts(lotName string) string {
+	if m := reWatts.FindStringSubmatch(lotName); len(m) == 2 {
+		w := atoi(m[1])
+		if w >= 1000 {
+			kw := fmt.Sprintf("%.1f", float64(w)/1000.0)
+			kw = strings.TrimSuffix(kw, ".0")
+			return fmt.Sprintf("%skW", kw)
+		}
+		return fmt.Sprintf("%dW", w)
+	}
+	return ""
+}
+
+func normalizeNumberToken(raw string) string {
+	raw = strings.TrimSpace(raw)
+	raw = strings.TrimLeft(raw, "0")
+	if raw == "" || raw[0] == '.' {
+		raw = "0" + raw
+	}
+	return raw
+}
+
+func normalizeTToken(raw string) string {
+	raw = normalizeNumberToken(raw)
+	parts := strings.SplitN(raw, ".", 2)
+	intPart := parts[0]
+	frac := ""
+	if len(parts) == 2 {
+		frac = parts[1]
+	}
+	if frac == "" {
+		frac = "0"
+	}
+	if len(intPart) >= 2 {
+		return intPart + "." + frac
+	}
+	if len(frac) > 1 {
+		frac = frac[:1]
+	}
+	return intPart + "." + frac
+}
+
+func atoi(v string) int {
+	n := 0
+	for _, r := range v {
+		if r < '0' || r > '9' {
+			continue
+		}
+		n = n*10 + int(r-'0')
+	}
+	return n
+}
+
+func compressArticle(segments []string) string {
+	if len(segments) == 0 {
+		return ""
+	}
+	normalized := make([]string, 0, len(segments))
+	for _, s := range segments {
+		normalized = append(normalized, strings.ReplaceAll(s, "GbE", "G"))
+	}
+	segments = normalized
+	article := strings.Join(segments, "-")
+	if len([]rune(article)) <= 80 {
+		return article
+	}
+
+	// segment order: model, cpu, mem, gpu, disk, net, psu, support
+	index := func(i int) (int, bool) {
+		if i >= 0 && i < len(segments) {
+			return i, true
+		}
+		return -1, false
+	}
+
+	// 1) remove PSU
+	if i, ok := index(6); ok {
+		segments = append(segments[:i], segments[i+1:]...)
+		article = strings.Join(segments, "-")
+		if len([]rune(article)) <= 80 {
+			return article
+		}
+	}
+
+	// 2) compress NET/HBA/HCA
+	if i, ok := index(5); ok {
+		segments[i] = compressNetSegment(segments[i])
+		article = strings.Join(segments, "-")
+		if len([]rune(article)) <= 80 {
+			return article
+		}
+	}
+
+	// 3) compress DISK
+	if i, ok := index(4); ok {
+		segments[i] = compressDiskSegment(segments[i])
+		article = strings.Join(segments, "-")
+		if len([]rune(article)) <= 80 {
+			return article
+		}
+	}
+
+	// 4) compress GPU to vendor only (GPU_NV)
+	if i, ok := index(3); ok {
+		segments[i] = compressGPUSegment(segments[i])
+	}
+	return strings.Join(segments, "-")
+}
+
+func compressNetSegment(seg string) string {
+	if seg == "" {
+		return seg
+	}
+	parts := strings.Split(seg, "+")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		qty := "1"
+		profile := p
+		if x := strings.SplitN(p, "x", 2); len(x) == 2 {
+			qty = x[0]
+			profile = x[1]
+		}
+		upper := strings.ToUpper(profile)
+		label := "NIC"
+		if strings.Contains(upper, "FC") {
+			label = "HBA"
+		} else if strings.Contains(upper, "HCA") || strings.Contains(upper, "IB") {
+			label = "HCA"
+		}
+		out = append(out, fmt.Sprintf("%sx%s", qty, label))
+	}
+	if len(out) == 0 {
+		return seg
+	}
+	sort.Strings(out)
+	return strings.Join(out, "+")
+}
+
+func compressDiskSegment(seg string) string {
+	if seg == "" {
+		return seg
+	}
+	parts := strings.Split(seg, "+")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		qty := "1"
+		spec := p
+		if x := strings.SplitN(p, "x", 2); len(x) == 2 {
+			qty = x[0]
+			spec = x[1]
+		}
+		upper := strings.ToUpper(spec)
+		label := "DSK"
+		for _, t := range []string{"M2", "NV", "SAS", "SAT", "SSD", "HDD", "EDS", "HHH"} {
+			if strings.Contains(upper, t) {
+				label = t
+				break
+			}
+		}
+		out = append(out, fmt.Sprintf("%sx%s", qty, label))
+	}
+	if len(out) == 0 {
+		return seg
+	}
+	sort.Strings(out)
+	return strings.Join(out, "+")
+}
+
+func compressGPUSegment(seg string) string {
+	if seg == "" {
+		return seg
+	}
+	parts := strings.Split(seg, "+")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		qty := "1"
+		if x := strings.SplitN(p, "x", 2); len(x) == 2 {
+			qty = x[0]
+		}
+		out = append(out, fmt.Sprintf("%sxGPU_NV", qty))
+	}
+	if len(out) == 0 {
+		return seg
+	}
+	sort.Strings(out)
+	return strings.Join(out, "+")
+}

internal/article/generator_test.go

@@ -0,0 +1,66 @@
+package article
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+)
+
+func TestBuild_ParsesNetAndPSU(t *testing.T) {
+	local, err := localdb.New(filepath.Join(t.TempDir(), "local.db"))
+	if err != nil {
+		t.Fatalf("init local db: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
+		ServerID:  1,
+		Source:    "estimate",
+		Version:   "S-2026-02-11-001",
+		Name:      "test",
+		CreatedAt: time.Now(),
+		SyncedAt:  time.Now(),
+	}); err != nil {
+		t.Fatalf("save local pricelist: %v", err)
+	}
+	localPL, err := local.GetLocalPricelistByServerID(1)
+	if err != nil {
+		t.Fatalf("get local pricelist: %v", err)
+	}
+
+	if err := local.SaveLocalPricelistItems([]localdb.LocalPricelistItem{
+		{PricelistID: localPL.ID, LotName: "NIC_2p25G_MCX512A-AC", LotCategory: "NIC", Price: 1},
+		{PricelistID: localPL.ID, LotName: "HBA_2pFC32_Gen6", LotCategory: "HBA", Price: 1},
+		{PricelistID: localPL.ID, LotName: "PS_1000W_Platinum", LotCategory: "PS", Price: 1},
+	}); err != nil {
+		t.Fatalf("save local items: %v", err)
+	}
+
+	items := models.ConfigItems{
+		{LotName: "NIC_2p25G_MCX512A-AC", Quantity: 1},
+		{LotName: "HBA_2pFC32_Gen6", Quantity: 1},
+		{LotName: "PS_1000W_Platinum", Quantity: 2},
+	}
+	result, err := Build(local, items, BuildOptions{
+		ServerModel:     "DL380GEN11",
+		SupportCode:     "1yW",
+		ServerPricelist: &localPL.ServerID,
+	})
+	if err != nil {
+		t.Fatalf("build article: %v", err)
+	}
+	if result.Article == "" {
+		t.Fatalf("expected article to be non-empty")
+	}
+	if contains(result.Article, "UNKNET") || contains(result.Article, "UNKPSU") {
+		t.Fatalf("unexpected UNK in article: %s", result.Article)
+	}
+}
+
+func contains(s, sub string) bool {
+	return strings.Contains(s, sub)
+}

internal/config/config.go

@@ -2,9 +2,12 @@ package config
 
 import (
 	"fmt"
+	"net"
 	"os"
+	"strconv"
 	"time"
 
+	mysqlDriver "github.com/go-sql-driver/mysql"
 	"gopkg.in/yaml.v3"
 )
 
@@ -17,6 +20,7 @@ type Config struct {
 	Alerts        AlertsConfig        `yaml:"alerts"`
 	Notifications NotificationsConfig `yaml:"notifications"`
 	Logging       LoggingConfig       `yaml:"logging"`
+	Backup        BackupConfig        `yaml:"backup"`
 }
 
 type ServerConfig struct {
@@ -39,8 +43,18 @@ type DatabaseConfig struct {
 }
 
 func (d *DatabaseConfig) DSN() string {
-	return fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local",
-		d.User, d.Password, d.Host, d.Port, d.Name)
+	cfg := mysqlDriver.NewConfig()
+	cfg.User = d.User
+	cfg.Passwd = d.Password
+	cfg.Net = "tcp"
+	cfg.Addr = net.JoinHostPort(d.Host, strconv.Itoa(d.Port))
+	cfg.DBName = d.Name
+	cfg.ParseTime = true
+	cfg.Loc = time.Local
+	cfg.Params = map[string]string{
+		"charset": "utf8mb4",
+	}
+	return cfg.FormatDSN()
 }
 
 type AuthConfig struct {
@@ -88,6 +102,10 @@ type LoggingConfig struct {
 	FilePath string `yaml:"file_path"`
 }
 
+type BackupConfig struct {
+	Time string `yaml:"time"`
+}
+
 func Load(path string) (*Config, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
@@ -169,6 +187,10 @@ func (c *Config) setDefaults() {
 	if c.Logging.Output == "" {
 		c.Logging.Output = "stdout"
 	}
+
+	if c.Backup.Time == "" {
+		c.Backup.Time = "00:00"
+	}
 }
 
 func (c *Config) Address() string {

internal/db/connection.go

@@ -32,14 +32,14 @@ type ConnectionStatus struct {
 
 // 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)
+	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
@@ -94,6 +94,8 @@ func (cm *ConnectionManager) GetDB() (*gorm.DB, error) {
 	// 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
@@ -147,23 +149,27 @@ func (cm *ConnectionManager) connect() error {
 	return nil
 }
 
-// IsOnline checks if the database is currently connected and responsive
-// Does not attempt to reconnect, only checks current state with caching
+// 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()
-	if cm.db == nil {
-		cm.mu.RUnlock()
-		return false
-	}
-
-	// If we've checked recently, return cached result
-	if time.Since(cm.lastCheck) < cm.pingInterval {
-		cm.mu.RUnlock()
-		return true
-	}
+	isDisconnected := cm.db == nil
+	lastErr := cm.lastError
+	checkedRecently := time.Since(cm.lastCheck) < cm.pingInterval
 	cm.mu.RUnlock()
 
-	// Need to perform actual ping
+	// 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()
 
@@ -282,7 +288,7 @@ func extractHostFromDSN(dsn string) string {
 		}
 		if parenEnd != -1 {
 			// Extract host:port part between tcp( and )
-			hostPort := dsn[tcpStart+1:parenEnd]
+			hostPort := dsn[tcpStart+1 : parenEnd]
 			return hostPort
 		}
 	}
@@ -317,7 +323,7 @@ func extractHostFromDSN(dsn string) string {
 			}
 
 			if parenEnd != -1 {
-				hostPort := dsn[parenStart+1:parenEnd]
+				hostPort := dsn[parenStart+1 : parenEnd]
 				return hostPort
 			}
 		}
@@ -325,4 +331,4 @@ func extractHostFromDSN(dsn string) string {
 
 	// If we can't parse it, return empty string
 	return ""
-}
+}

internal/handlers/component.go

@@ -3,8 +3,10 @@ package handlers
 import (
 	"net/http"
 	"strconv"
+	"strings"
 
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
 	"github.com/gin-gonic/gin"
@@ -25,6 +27,12 @@ func NewComponentHandler(componentService *services.ComponentService, localDB *l
 func (h *ComponentHandler) List(c *gin.Context) {
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 {
+		perPage = 20
+	}
 
 	filter := repository.ComponentFilter{
 		Category:      c.Query("category"),
@@ -33,73 +41,68 @@ func (h *ComponentHandler) List(c *gin.Context) {
 		ExcludeHidden: c.Query("include_hidden") != "true", // По умолчанию скрытые не показываются
 	}
 
-	result, err := h.componentService.List(filter, page, perPage)
+	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 {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		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
+	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,
+			Model:        lc.Model,
 		}
 	}
 
-	c.JSON(http.StatusOK, result)
+	c.JSON(http.StatusOK, &services.ComponentListResult{
+		Components: components,
+		Total:      total,
+		Page:       page,
+		PerPage:    perPage,
+	})
 }
 
 func (h *ComponentHandler) Get(c *gin.Context) {
 	lotName := c.Param("lot_name")
-
-	component, err := h.componentService.GetByLotName(lotName)
+	component, err := h.localDB.GetLocalComponent(lotName)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "component not found"})
 		return
 	}
 
-	c.JSON(http.StatusOK, component)
+	c.JSON(http.StatusOK, services.ComponentView{
+		LotName:      component.LotName,
+		Description:  component.LotDescription,
+		Category:     component.Category,
+		CategoryName: component.Category,
+		Model:        component.Model,
+	})
 }
 
 func (h *ComponentHandler) GetCategories(c *gin.Context) {
-	categories, err := h.componentService.GetCategories()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+	codes, err := h.localDB.GetLocalComponentCategories()
+	if err == nil && len(codes) > 0 {
+		categories := make([]models.Category, 0, len(codes))
+		for _, code := range codes {
+			trimmed := strings.TrimSpace(code)
+			if trimmed == "" {
+				continue
+			}
+			categories = append(categories, models.Category{Code: trimmed, Name: trimmed})
+		}
+		c.JSON(http.StatusOK, categories)
 		return
 	}
 
-	c.JSON(http.StatusOK, categories)
+	c.JSON(http.StatusOK, models.DefaultCategories)
 }

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

@@ -3,34 +3,41 @@ package handlers
 import (
 	"fmt"
 	"net/http"
+	"strings"
 	"time"
 
-	"github.com/gin-gonic/gin"
 	"git.mchus.pro/mchus/quoteforge/internal/middleware"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
 )
 
 type ExportHandler struct {
-	exportService    *services.ExportService
-	configService    services.ConfigurationGetter
-	componentService *services.ComponentService
+	exportService  *services.ExportService
+	configService  services.ConfigurationGetter
+	projectService *services.ProjectService
 }
 
 func NewExportHandler(
 	exportService *services.ExportService,
 	configService services.ConfigurationGetter,
-	componentService *services.ComponentService,
+	projectService *services.ProjectService,
 ) *ExportHandler {
 	return &ExportHandler{
-		exportService:    exportService,
-		configService:    configService,
-		componentService: componentService,
+		exportService:  exportService,
+		configService:  configService,
+		projectService: projectService,
 	}
 }
 
 type ExportRequest struct {
-	Name  string `json:"name" binding:"required"`
-	Items []struct {
+	Name        string `json:"name" binding:"required"`
+	ProjectName string `json:"project_name"`
+	ProjectUUID string `json:"project_uuid"`
+	Article     string `json:"article"`
+	ServerCount int    `json:"server_count"`
+	PricelistID *uint  `json:"pricelist_id"`
+	Items       []struct {
 		LotName   string  `json:"lot_name" binding:"required"`
 		Quantity  int     `json:"quantity" binding:"required,min=1"`
 		UnitPrice float64 `json:"unit_price"`
@@ -47,75 +54,162 @@ func (h *ExportHandler) ExportCSV(c *gin.Context) {
 
 	data := h.buildExportData(&req)
 
-	csvData, err := h.exportService.ToCSV(data)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+	// Validate before streaming (can return JSON error)
+	if len(data.Configs) == 0 || len(data.Configs[0].Items) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "no items to export"})
 		return
 	}
 
-	filename := fmt.Sprintf("%s %s SPEC.csv", time.Now().Format("2006-01-02"), req.Name)
+	// Get project code for filename
+	projectCode := req.ProjectName // legacy field: may contain code from frontend
+	if projectCode == "" && req.ProjectUUID != "" {
+		username := middleware.GetUsername(c)
+		if project, err := h.projectService.GetByUUID(req.ProjectUUID, username); err == nil && project != nil {
+			projectCode = project.Code
+		}
+	}
+	if projectCode == "" {
+		projectCode = req.Name
+	}
+
+	// Set headers before streaming
+	exportDate := data.CreatedAt
+	articleSegment := sanitizeFilenameSegment(req.Article)
+	if articleSegment == "" {
+		articleSegment = "BOM"
+	}
+	filename := fmt.Sprintf("%s (%s) %s %s.csv", exportDate.Format("2006-01-02"), projectCode, req.Name, articleSegment)
+	c.Header("Content-Type", "text/csv; charset=utf-8")
 	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
-	c.Data(http.StatusOK, "text/csv; charset=utf-8", csvData)
+
+	// Stream CSV (cannot return JSON after this point)
+	if err := h.exportService.ToCSV(c.Writer, data); err != nil {
+		c.Error(err) // Log only
+		return
+	}
 }
 
-func (h *ExportHandler) buildExportData(req *ExportRequest) *services.ExportData {
-	items := make([]services.ExportItem, len(req.Items))
-	var total float64
-
+// buildExportData converts an ExportRequest into a ProjectExportData using a temporary Configuration model
+// so that ExportService.ConfigToExportData can resolve categories via localDB.
+func (h *ExportHandler) buildExportData(req *ExportRequest) *services.ProjectExportData {
+	configItems := make(models.ConfigItems, len(req.Items))
 	for i, item := range req.Items {
-		itemTotal := item.UnitPrice * float64(item.Quantity)
-
-		// Получаем информацию о компоненте для заполнения категории и описания
-		componentView, err := h.componentService.GetByLotName(item.LotName)
-		if err != nil {
-			// Если не удалось получить информацию о компоненте, используем только основные данные
-			items[i] = services.ExportItem{
-				LotName:    item.LotName,
-				Quantity:   item.Quantity,
-				UnitPrice:  item.UnitPrice,
-				TotalPrice: itemTotal,
-			}
-		} else {
-			items[i] = services.ExportItem{
-				LotName:     item.LotName,
-				Description: componentView.Description,
-				Category:    componentView.Category,
-				Quantity:    item.Quantity,
-				UnitPrice:   item.UnitPrice,
-				TotalPrice:  itemTotal,
-			}
+		configItems[i] = models.ConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
 		}
-		total += itemTotal
 	}
 
-	return &services.ExportData{
-		Name:      req.Name,
-		Items:     items,
-		Total:     total,
-		Notes:     req.Notes,
-		CreatedAt: time.Now(),
+	serverCount := req.ServerCount
+	if serverCount < 1 {
+		serverCount = 1
 	}
+
+	cfg := &models.Configuration{
+		Article:     req.Article,
+		ServerCount: serverCount,
+		PricelistID: req.PricelistID,
+		Items:       configItems,
+		CreatedAt:   time.Now(),
+	}
+
+	return h.exportService.ConfigToExportData(cfg)
+}
+
+func sanitizeFilenameSegment(value string) string {
+	if strings.TrimSpace(value) == "" {
+		return ""
+	}
+	replacer := strings.NewReplacer(
+		"/", "_",
+		"\\", "_",
+		":", "_",
+		"*", "_",
+		"?", "_",
+		"\"", "_",
+		"<", "_",
+		">", "_",
+		"|", "_",
+	)
+	return strings.TrimSpace(replacer.Replace(value))
 }
 
 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)
+	// Get config before streaming (can return JSON error)
+	config, err := h.configService.GetByUUID(uuid, username)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
 		return
 	}
 
-	data := h.exportService.ConfigToExportData(config, h.componentService)
+	data := h.exportService.ConfigToExportData(config)
 
-	csvData, err := h.exportService.ToCSV(data)
+	// Validate before streaming (can return JSON error)
+	if len(data.Configs) == 0 || len(data.Configs[0].Items) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "no items to export"})
+		return
+	}
+
+	// Get project code for filename
+	projectCode := config.Name // fallback: use config name if no project
+	if config.ProjectUUID != nil && *config.ProjectUUID != "" {
+		if project, err := h.projectService.GetByUUID(*config.ProjectUUID, username); err == nil && project != nil {
+			projectCode = project.Code
+		}
+	}
+
+	// Set headers before streaming
+	// Use price update time if available, otherwise creation time
+	exportDate := config.CreatedAt
+	if config.PriceUpdatedAt != nil {
+		exportDate = *config.PriceUpdatedAt
+	}
+	filename := fmt.Sprintf("%s (%s) %s BOM.csv", exportDate.Format("2006-01-02"), projectCode, config.Name)
+	c.Header("Content-Type", "text/csv; charset=utf-8")
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
+
+	// Stream CSV (cannot return JSON after this point)
+	if err := h.exportService.ToCSV(c.Writer, data); err != nil {
+		c.Error(err) // Log only
+		return
+	}
+}
+
+// ExportProjectCSV exports all active configurations of a project as a single CSV file.
+func (h *ExportHandler) ExportProjectCSV(c *gin.Context) {
+	username := middleware.GetUsername(c)
+	projectUUID := c.Param("uuid")
+
+	project, err := h.projectService.GetByUUID(projectUUID, username)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+
+	result, err := h.projectService.ListConfigurations(projectUUID, username, "active")
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 
-	filename := fmt.Sprintf("%s %s SPEC.csv", config.CreatedAt.Format("2006-01-02"), config.Name)
+	if len(result.Configs) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "no configurations to export"})
+		return
+	}
+
+	data := h.exportService.ProjectToExportData(result.Configs)
+
+	// Filename: YYYY-MM-DD (ProjectCode) BOM.csv
+	filename := fmt.Sprintf("%s (%s) BOM.csv", time.Now().Format("2006-01-02"), project.Code)
+	c.Header("Content-Type", "text/csv; charset=utf-8")
 	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
-	c.Data(http.StatusOK, "text/csv; charset=utf-8", csvData)
+
+	if err := h.exportService.ToCSV(c.Writer, data); err != nil {
+		c.Error(err)
+		return
+	}
 }

internal/handlers/export_test.go

@@ -0,0 +1,305 @@
+package handlers
+
+import (
+	"bytes"
+	"encoding/csv"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
+)
+
+// Mock services for testing
+type mockConfigService struct {
+	config *models.Configuration
+	err    error
+}
+
+func (m *mockConfigService) GetByUUID(uuid string, ownerUsername string) (*models.Configuration, error) {
+	return m.config, m.err
+}
+
+
+func TestExportCSV_Success(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	// Create handler with mocks
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
+	handler := NewExportHandler(
+		exportSvc,
+		&mockConfigService{},
+		nil,
+	)
+
+	// Create JSON request body
+	jsonBody := `{
+		"name": "Test Export",
+		"items": [
+			{
+				"lot_name": "LOT-001",
+				"quantity": 2,
+				"unit_price": 100.50
+			}
+		],
+		"notes": "Test notes"
+	}`
+
+	// Create HTTP request
+	req, _ := http.NewRequest("POST", "/api/export/csv", bytes.NewBufferString(jsonBody))
+	req.Header.Set("Content-Type", "application/json")
+
+	// Create response recorder
+	w := httptest.NewRecorder()
+
+	// Create Gin context
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+
+	// Call handler
+	handler.ExportCSV(c)
+
+	// Check status code
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+
+	// Check Content-Type header
+	contentType := w.Header().Get("Content-Type")
+	if contentType != "text/csv; charset=utf-8" {
+		t.Errorf("Expected Content-Type 'text/csv; charset=utf-8', got %q", contentType)
+	}
+
+	// Check for BOM
+	responseBody := w.Body.Bytes()
+	if len(responseBody) < 3 {
+		t.Fatalf("Response too short to contain BOM")
+	}
+
+	expectedBOM := []byte{0xEF, 0xBB, 0xBF}
+	actualBOM := responseBody[:3]
+	if !bytes.Equal(actualBOM, expectedBOM) {
+		t.Errorf("UTF-8 BOM mismatch. Expected %v, got %v", expectedBOM, actualBOM)
+	}
+
+	// Check semicolon delimiter in CSV
+	reader := csv.NewReader(bytes.NewReader(responseBody[3:]))
+	reader.Comma = ';'
+
+	header, err := reader.Read()
+	if err != nil {
+		t.Errorf("Failed to parse CSV header: %v", err)
+	}
+
+	if len(header) != 8 {
+		t.Errorf("Expected 8 columns, got %d", len(header))
+	}
+}
+
+func TestExportCSV_InvalidRequest(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
+	handler := NewExportHandler(
+		exportSvc,
+		&mockConfigService{},
+		nil,
+	)
+
+	// Create invalid request (missing required field)
+	req, _ := http.NewRequest("POST", "/api/export/csv", bytes.NewBufferString(`{"name": "Test"}`))
+	req.Header.Set("Content-Type", "application/json")
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+
+	handler.ExportCSV(c)
+
+	// Should return 400 Bad Request
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status 400, got %d", w.Code)
+	}
+
+	// Should return JSON error
+	var errResp map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &errResp)
+	if _, hasError := errResp["error"]; !hasError {
+		t.Errorf("Expected error in JSON response")
+	}
+}
+
+func TestExportCSV_EmptyItems(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
+	handler := NewExportHandler(
+		exportSvc,
+		&mockConfigService{},
+		nil,
+	)
+
+	// Create request with empty items array - should fail binding validation
+	req, _ := http.NewRequest("POST", "/api/export/csv", bytes.NewBufferString(`{"name":"Empty Export","items":[],"notes":""}`))
+	req.Header.Set("Content-Type", "application/json")
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+
+	handler.ExportCSV(c)
+
+	// Should return 400 Bad Request (validation error from gin binding)
+	if w.Code != http.StatusBadRequest {
+		t.Logf("Status code: %d (expected 400 for empty items)", w.Code)
+	}
+}
+
+func TestExportConfigCSV_Success(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	// Mock configuration
+	mockConfig := &models.Configuration{
+		UUID:          "test-uuid",
+		Name:          "Test Config",
+		OwnerUsername: "testuser",
+		Items: models.ConfigItems{
+			{
+				LotName:   "LOT-001",
+				Quantity:  1,
+				UnitPrice: 100.0,
+			},
+		},
+		CreatedAt: time.Now(),
+	}
+
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
+	handler := NewExportHandler(
+		exportSvc,
+		&mockConfigService{config: mockConfig},
+		nil,
+	)
+
+	// Create HTTP request
+	req, _ := http.NewRequest("GET", "/api/configs/test-uuid/export", nil)
+	w := httptest.NewRecorder()
+
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+	c.Params = gin.Params{
+		{Key: "uuid", Value: "test-uuid"},
+	}
+
+	// Mock middleware.GetUsername
+	c.Set("username", "testuser")
+
+	handler.ExportConfigCSV(c)
+
+	// Check status code
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+
+	// Check Content-Type header
+	contentType := w.Header().Get("Content-Type")
+	if contentType != "text/csv; charset=utf-8" {
+		t.Errorf("Expected Content-Type 'text/csv; charset=utf-8', got %q", contentType)
+	}
+
+	// Check for BOM
+	responseBody := w.Body.Bytes()
+	if len(responseBody) < 3 {
+		t.Fatalf("Response too short to contain BOM")
+	}
+
+	expectedBOM := []byte{0xEF, 0xBB, 0xBF}
+	actualBOM := responseBody[:3]
+	if !bytes.Equal(actualBOM, expectedBOM) {
+		t.Errorf("UTF-8 BOM mismatch")
+	}
+}
+
+func TestExportConfigCSV_NotFound(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
+	handler := NewExportHandler(
+		exportSvc,
+		&mockConfigService{err: errors.New("config not found")},
+		nil,
+	)
+
+	req, _ := http.NewRequest("GET", "/api/configs/nonexistent-uuid/export", nil)
+	w := httptest.NewRecorder()
+
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+	c.Params = gin.Params{
+		{Key: "uuid", Value: "nonexistent-uuid"},
+	}
+	c.Set("username", "testuser")
+
+	handler.ExportConfigCSV(c)
+
+	// Should return 404 Not Found
+	if w.Code != http.StatusNotFound {
+		t.Errorf("Expected status 404, got %d", w.Code)
+	}
+
+	// Should return JSON error
+	var errResp map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &errResp)
+	if _, hasError := errResp["error"]; !hasError {
+		t.Errorf("Expected error in JSON response")
+	}
+}
+
+func TestExportConfigCSV_EmptyItems(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	// Mock configuration with empty items
+	mockConfig := &models.Configuration{
+		UUID:          "test-uuid",
+		Name:          "Empty Config",
+		OwnerUsername: "testuser",
+		Items:         models.ConfigItems{},
+		CreatedAt:     time.Now(),
+	}
+
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
+	handler := NewExportHandler(
+		exportSvc,
+		&mockConfigService{config: mockConfig},
+		nil,
+	)
+
+	req, _ := http.NewRequest("GET", "/api/configs/test-uuid/export", nil)
+	w := httptest.NewRecorder()
+
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+	c.Params = gin.Params{
+		{Key: "uuid", Value: "test-uuid"},
+	}
+	c.Set("username", "testuser")
+
+	handler.ExportConfigCSV(c)
+
+	// Should return 400 Bad Request
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status 400, got %d", w.Code)
+	}
+
+	// Should return JSON error
+	var errResp map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &errResp)
+	if _, hasError := errResp["error"]; !hasError {
+		t.Errorf("Expected error in JSON response")
+	}
+}

internal/handlers/partnumber_books.go

@@ -0,0 +1,90 @@
+package handlers
+
+import (
+	"net/http"
+	"strconv"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"github.com/gin-gonic/gin"
+)
+
+// PartnumberBooksHandler provides read-only access to local partnumber book snapshots.
+type PartnumberBooksHandler struct {
+	localDB *localdb.LocalDB
+}
+
+func NewPartnumberBooksHandler(localDB *localdb.LocalDB) *PartnumberBooksHandler {
+	return &PartnumberBooksHandler{localDB: localDB}
+}
+
+// List returns all local partnumber book snapshots.
+// GET /api/partnumber-books
+func (h *PartnumberBooksHandler) List(c *gin.Context) {
+	bookRepo := repository.NewPartnumberBookRepository(h.localDB.DB())
+	books, err := bookRepo.ListBooks()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	type bookSummary struct {
+		ID        uint   `json:"id"`
+		ServerID  int    `json:"server_id"`
+		Version   string `json:"version"`
+		CreatedAt string `json:"created_at"`
+		IsActive  bool   `json:"is_active"`
+		ItemCount int64  `json:"item_count"`
+	}
+
+	summaries := make([]bookSummary, 0, len(books))
+	for _, b := range books {
+		summaries = append(summaries, bookSummary{
+			ID:        b.ID,
+			ServerID:  b.ServerID,
+			Version:   b.Version,
+			CreatedAt: b.CreatedAt.Format("2006-01-02"),
+			IsActive:  b.IsActive,
+			ItemCount: bookRepo.CountBookItems(b.ID),
+		})
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"books": summaries,
+		"total": len(summaries),
+	})
+}
+
+// GetItems returns items for a partnumber book by server ID.
+// GET /api/partnumber-books/:id
+func (h *PartnumberBooksHandler) GetItems(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.ParseUint(idStr, 10, 64)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid book ID"})
+		return
+	}
+
+	bookRepo := repository.NewPartnumberBookRepository(h.localDB.DB())
+
+	// Find local book by server_id
+	var book localdb.LocalPartnumberBook
+	if err := h.localDB.DB().Where("server_id = ?", id).First(&book).Error; err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "partnumber book not found"})
+		return
+	}
+
+	items, err := bookRepo.GetBookItems(book.ID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"book_id":   book.ServerID,
+		"version":   book.Version,
+		"is_active": book.IsActive,
+		"items":     items,
+		"total":     len(items),
+	})
+}

internal/handlers/pricelist.go

@@ -2,72 +2,119 @@ package handlers
 
 import (
 	"net/http"
+	"sort"
 	"strconv"
+	"strings"
 
-	"github.com/gin-gonic/gin"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
-	"git.mchus.pro/mchus/quoteforge/internal/services/pricelist"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"github.com/gin-gonic/gin"
 )
 
 type PricelistHandler struct {
-	service *pricelist.Service
 	localDB *localdb.LocalDB
 }
 
-func NewPricelistHandler(service *pricelist.Service, localDB *localdb.LocalDB) *PricelistHandler {
-	return &PricelistHandler{service: service, localDB: localDB}
+func NewPricelistHandler(localDB *localdb.LocalDB) *PricelistHandler {
+	return &PricelistHandler{localDB: localDB}
 }
 
-// List returns all pricelists with pagination
+// List returns all pricelists with pagination.
 func (h *PricelistHandler) List(c *gin.Context) {
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 {
+		perPage = 20
+	}
+	source := c.Query("source")
+	activeOnly := c.DefaultQuery("active_only", "false") == "true"
 
-	pricelists, total, err := h.service.List(page, perPage)
+	localPLs, err := h.localDB.GetLocalPricelists()
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		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",
-				}
+	if source != "" {
+		filtered := localPLs[:0]
+		for _, lpl := range localPLs {
+			if strings.EqualFold(lpl.Source, source) {
+				filtered = append(filtered, lpl)
 			}
-
-			c.JSON(http.StatusOK, gin.H{
-				"pricelists": summaries,
-				"total":      len(summaries),
-				"page":       page,
-				"per_page":   perPage,
-				"offline":    true,
-			})
-			return
 		}
+		localPLs = filtered
+	}
+	type pricelistWithCount struct {
+		pricelist  localdb.LocalPricelist
+		itemCount  int64
+		usageCount int
+	}
+	withCounts := make([]pricelistWithCount, 0, len(localPLs))
+	for _, lpl := range localPLs {
+		itemCount := h.localDB.CountLocalPricelistItems(lpl.ID)
+		if activeOnly && itemCount == 0 {
+			continue
+		}
+		usageCount := 0
+		if lpl.IsUsed {
+			usageCount = 1
+		}
+		withCounts = append(withCounts, pricelistWithCount{
+			pricelist:  lpl,
+			itemCount:  itemCount,
+			usageCount: usageCount,
+		})
+	}
+	localPLs = localPLs[:0]
+	for _, row := range withCounts {
+		localPLs = append(localPLs, row.pricelist)
+	}
+	sort.SliceStable(localPLs, func(i, j int) bool { return localPLs[i].CreatedAt.After(localPLs[j].CreatedAt) })
+	total := len(localPLs)
+	start := (page - 1) * perPage
+	if start > total {
+		start = total
+	}
+	end := start + perPage
+	if end > total {
+		end = total
+	}
+	pageSlice := localPLs[start:end]
+	summaries := make([]map[string]interface{}, 0, len(pageSlice))
+	for _, lpl := range pageSlice {
+		itemCount := int64(0)
+		usageCount := 0
+		for _, row := range withCounts {
+			if row.pricelist.ID == lpl.ID {
+				itemCount = row.itemCount
+				usageCount = row.usageCount
+				break
+			}
+		}
+		summaries = append(summaries, map[string]interface{}{
+			"id":          lpl.ServerID,
+			"source":      lpl.Source,
+			"version":     lpl.Version,
+			"created_by":  "sync",
+			"item_count":  itemCount,
+			"usage_count": usageCount,
+			"is_active":   true,
+			"created_at":  lpl.CreatedAt,
+			"synced_from": "local",
+		})
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"pricelists": pricelists,
+		"pricelists": summaries,
 		"total":      total,
 		"page":       page,
 		"per_page":   perPage,
 	})
 }
 
-// Get returns a single pricelist by ID
+// Get returns a single pricelist by ID.
 func (h *PricelistHandler) Get(c *gin.Context) {
 	idStr := c.Param("id")
 	id, err := strconv.ParseUint(idStr, 10, 32)
@@ -76,50 +123,25 @@ func (h *PricelistHandler) Get(c *gin.Context) {
 		return
 	}
 
-	pl, err := h.service.GetByID(uint(id))
+	localPL, err := h.localDB.GetLocalPricelistByServerID(uint(id))
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "pricelist not found"})
 		return
 	}
 
-	c.JSON(http.StatusOK, pl)
+	c.JSON(http.StatusOK, gin.H{
+		"id":          localPL.ServerID,
+		"source":      localPL.Source,
+		"version":     localPL.Version,
+		"created_by":  "sync",
+		"item_count":  h.localDB.CountLocalPricelistItems(localPL.ID),
+		"is_active":   true,
+		"created_at":  localPL.CreatedAt,
+		"synced_from": "local",
+	})
 }
 
-// Create creates a new pricelist from current prices
-func (h *PricelistHandler) Create(c *gin.Context) {
-	// Get the database username as the creator
-	createdBy := h.localDB.GetDBUser()
-	if createdBy == "" {
-		createdBy = "unknown"
-	}
-
-	pl, err := h.service.CreateFromCurrentPrices(createdBy)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusCreated, pl)
-}
-
-// Delete deletes a pricelist by ID
-func (h *PricelistHandler) Delete(c *gin.Context) {
-	idStr := c.Param("id")
-	id, err := strconv.ParseUint(idStr, 10, 32)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
-		return
-	}
-
-	if err := h.service.Delete(uint(id)); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"message": "pricelist deleted"})
-}
-
-// GetItems returns items for a pricelist with pagination
+// GetItems returns items for a pricelist with pagination.
 func (h *PricelistHandler) GetItems(c *gin.Context) {
 	idStr := c.Param("id")
 	id, err := strconv.ParseUint(idStr, 10, 32)
@@ -132,57 +154,102 @@ func (h *PricelistHandler) GetItems(c *gin.Context) {
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "50"))
 	search := c.Query("search")
 
-	items, total, err := h.service.GetItems(uint(id), page, perPage, search)
+	localPL, err := h.localDB.GetLocalPricelistByServerID(uint(id))
 	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "pricelist not found"})
+		return
+	}
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 {
+		perPage = 50
+	}
+	var items []localdb.LocalPricelistItem
+	dbq := h.localDB.DB().Model(&localdb.LocalPricelistItem{}).Where("pricelist_id = ?", localPL.ID)
+	if strings.TrimSpace(search) != "" {
+		dbq = dbq.Where("lot_name LIKE ?", "%"+strings.TrimSpace(search)+"%")
+	}
+	var total int64
+	if err := dbq.Count(&total).Error; err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
+	offset := (page - 1) * perPage
+
+	if err := dbq.Order("lot_name").Offset(offset).Limit(perPage).Find(&items).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	resultItems := make([]gin.H, 0, len(items))
+	for _, item := range items {
+		resultItems = append(resultItems, gin.H{
+			"id":            item.ID,
+			"lot_name":      item.LotName,
+			"price":         item.Price,
+			"category":      item.LotCategory,
+			"available_qty": item.AvailableQty,
+			"partnumbers":   []string(item.Partnumbers),
+		})
+	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"items":    items,
+		"source":   localPL.Source,
+		"items":    resultItems,
 		"total":    total,
 		"page":     page,
 		"per_page": perPage,
 	})
 }
 
-// CanWrite returns whether the current user can create pricelists
-func (h *PricelistHandler) CanWrite(c *gin.Context) {
-	canWrite, debugInfo := h.service.CanWriteDebug()
-	c.JSON(http.StatusOK, gin.H{"can_write": canWrite, "debug": debugInfo})
-}
-
-// 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()
+func (h *PricelistHandler) GetLotNames(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
 	if err != nil {
-		// 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",
-		})
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
 		return
 	}
 
-	c.JSON(http.StatusOK, pl)
+	localPL, err := h.localDB.GetLocalPricelistByServerID(uint(id))
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "pricelist not found"})
+		return
+	}
+	items, err := h.localDB.GetLocalPricelistItems(localPL.ID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	lotNames := make([]string, 0, len(items))
+	for _, item := range items {
+		lotNames = append(lotNames, item.LotName)
+	}
+	sort.Strings(lotNames)
+
+	c.JSON(http.StatusOK, gin.H{
+		"lot_names": lotNames,
+		"total":     len(lotNames),
+	})
+}
+
+// GetLatest returns the most recent active pricelist.
+func (h *PricelistHandler) GetLatest(c *gin.Context) {
+	source := c.DefaultQuery("source", string(models.PricelistSourceEstimate))
+	source = string(models.NormalizePricelistSource(source))
+
+	localPL, err := h.localDB.GetLatestLocalPricelistBySource(source)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "no pricelists available"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{
+		"id":          localPL.ServerID,
+		"source":      localPL.Source,
+		"version":     localPL.Version,
+		"created_by":  "sync",
+		"item_count":  h.localDB.CountLocalPricelistItems(localPL.ID),
+		"is_active":   true,
+		"created_at":  localPL.CreatedAt,
+		"synced_from": "local",
+	})
 }

internal/handlers/pricelist_test.go

@@ -0,0 +1,161 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"github.com/gin-gonic/gin"
+)
+
+func TestPricelistGetItems_ReturnsLotCategoryFromLocalPricelistItems(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	local, err := localdb.New(filepath.Join(t.TempDir(), "local.db"))
+	if err != nil {
+		t.Fatalf("init local db: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
+		ServerID:  1,
+		Source:    "estimate",
+		Version:   "S-2026-02-11-001",
+		Name:      "test",
+		CreatedAt: time.Now(),
+		SyncedAt:  time.Now(),
+		IsUsed:    false,
+	}); err != nil {
+		t.Fatalf("save local pricelist: %v", err)
+	}
+	localPL, err := local.GetLocalPricelistByServerID(1)
+	if err != nil {
+		t.Fatalf("get local pricelist: %v", err)
+	}
+	if err := local.SaveLocalPricelistItems([]localdb.LocalPricelistItem{
+		{
+			PricelistID: localPL.ID,
+			LotName:     "NO_UNDERSCORE_NAME",
+			LotCategory: "CPU",
+			Price:       10,
+		},
+	}); err != nil {
+		t.Fatalf("save local pricelist items: %v", err)
+	}
+
+	h := NewPricelistHandler(local)
+
+	req, _ := http.NewRequest("GET", "/api/pricelists/1/items?page=1&per_page=50", nil)
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+	c.Params = gin.Params{{Key: "id", Value: "1"}}
+
+	h.GetItems(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected status 200, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var resp struct {
+		Items []struct {
+			LotName   string `json:"lot_name"`
+			Category  string `json:"category"`
+			UnitPrice any    `json:"price"`
+		} `json:"items"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("unmarshal response: %v", err)
+	}
+	if len(resp.Items) != 1 {
+		t.Fatalf("expected 1 item, got %d", len(resp.Items))
+	}
+	if resp.Items[0].LotName != "NO_UNDERSCORE_NAME" {
+		t.Fatalf("expected lot_name NO_UNDERSCORE_NAME, got %q", resp.Items[0].LotName)
+	}
+	if resp.Items[0].Category != "CPU" {
+		t.Fatalf("expected category CPU, got %q", resp.Items[0].Category)
+	}
+}
+
+func TestPricelistList_ActiveOnlyExcludesPricelistsWithoutItems(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	local, err := localdb.New(filepath.Join(t.TempDir(), "local_active_only.db"))
+	if err != nil {
+		t.Fatalf("init local db: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
+		ServerID:  10,
+		Source:    "estimate",
+		Version:   "E-1",
+		Name:      "with-items",
+		CreatedAt: time.Now().Add(-time.Minute),
+		SyncedAt:  time.Now().Add(-time.Minute),
+	}); err != nil {
+		t.Fatalf("save with-items pricelist: %v", err)
+	}
+	withItems, err := local.GetLocalPricelistByServerID(10)
+	if err != nil {
+		t.Fatalf("load with-items pricelist: %v", err)
+	}
+	if err := local.SaveLocalPricelistItems([]localdb.LocalPricelistItem{
+		{
+			PricelistID: withItems.ID,
+			LotName:     "CPU_X",
+			LotCategory: "CPU",
+			Price:       100,
+		},
+	}); err != nil {
+		t.Fatalf("save with-items pricelist items: %v", err)
+	}
+
+	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
+		ServerID:  11,
+		Source:    "estimate",
+		Version:   "E-2",
+		Name:      "without-items",
+		CreatedAt: time.Now(),
+		SyncedAt:  time.Now(),
+	}); err != nil {
+		t.Fatalf("save without-items pricelist: %v", err)
+	}
+
+	h := NewPricelistHandler(local)
+
+	req, _ := http.NewRequest("GET", "/api/pricelists?source=estimate&active_only=true", nil)
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+
+	h.List(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected status 200, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var resp struct {
+		Pricelists []struct {
+			ID uint `json:"id"`
+		} `json:"pricelists"`
+		Total int `json:"total"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("unmarshal response: %v", err)
+	}
+	if resp.Total != 1 {
+		t.Fatalf("expected total=1, got %d", resp.Total)
+	}
+	if len(resp.Pricelists) != 1 {
+		t.Fatalf("expected 1 pricelist, got %d", len(resp.Pricelists))
+	}
+	if resp.Pricelists[0].ID != 10 {
+		t.Fatalf("expected pricelist id=10, got %d", resp.Pricelists[0].ID)
+	}
+}

internal/handlers/pricing.go

@@ -1,938 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
-	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
-	"gorm.io/gorm"
-)
-
-// calculateMedian returns the median of a sorted slice of prices
-func calculateMedian(prices []float64) float64 {
-	if len(prices) == 0 {
-		return 0
-	}
-	sort.Float64s(prices)
-	n := len(prices)
-	if n%2 == 0 {
-		return (prices[n/2-1] + prices[n/2]) / 2
-	}
-	return prices[n/2]
-}
-
-// calculateAverage returns the arithmetic mean of prices
-func calculateAverage(prices []float64) float64 {
-	if len(prices) == 0 {
-		return 0
-	}
-	var sum float64
-	for _, p := range prices {
-		sum += p
-	}
-	return sum / float64(len(prices))
-}
-
-type PricingHandler struct {
-	db             *gorm.DB
-	pricingService *pricing.Service
-	alertService   *alerts.Service
-	componentRepo  *repository.ComponentRepository
-	priceRepo      *repository.PriceRepository
-	statsRepo      *repository.StatsRepository
-}
-
-func NewPricingHandler(
-	db *gorm.DB,
-	pricingService *pricing.Service,
-	alertService *alerts.Service,
-	componentRepo *repository.ComponentRepository,
-	priceRepo *repository.PriceRepository,
-	statsRepo *repository.StatsRepository,
-) *PricingHandler {
-	return &PricingHandler{
-		db:             db,
-		pricingService: pricingService,
-		alertService:   alertService,
-		componentRepo:  componentRepo,
-		priceRepo:      priceRepo,
-		statsRepo:      statsRepo,
-	}
-}
-
-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)
-
-	c.JSON(http.StatusOK, gin.H{
-		"new_alerts_count":    newAlerts,
-		"top_components":      topComponents,
-		"trending_components": trendingComponents,
-	})
-}
-
-type ComponentWithCount struct {
-	models.LotMetadata
-	QuoteCount int64    `json:"quote_count"`
-	UsedInMeta []string `json:"used_in_meta,omitempty"` // List of meta-articles that use this component
-}
-
-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"))
-
-	filter := repository.ComponentFilter{
-		Category:  c.Query("category"),
-		Search:    c.Query("search"),
-		SortField: c.Query("sort"),
-		SortDir:   c.Query("dir"),
-	}
-
-	if page < 1 {
-		page = 1
-	}
-	if perPage < 1 || perPage > 100 {
-		perPage = 20
-	}
-	offset := (page - 1) * perPage
-
-	components, total, err := h.componentRepo.List(filter, offset, perPage)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	// Get quote counts
-	lotNames := make([]string, len(components))
-	for i, comp := range components {
-		lotNames[i] = comp.LotName
-	}
-
-	counts, _ := h.priceRepo.GetQuoteCounts(lotNames)
-
-	// Get meta usage information
-	metaUsage := h.getMetaUsageMap(lotNames)
-
-	// Combine components with counts
-	result := make([]ComponentWithCount, len(components))
-	for i, comp := range components {
-		result[i] = ComponentWithCount{
-			LotMetadata: comp,
-			QuoteCount:  counts[comp.LotName],
-			UsedInMeta:  metaUsage[comp.LotName],
-		}
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"components": result,
-		"total":      total,
-		"page":       page,
-		"per_page":   perPage,
-	})
-}
-
-// getMetaUsageMap returns a map of lot_name -> list of meta-articles that use this component
-func (h *PricingHandler) getMetaUsageMap(lotNames []string) map[string][]string {
-	result := make(map[string][]string)
-
-	// Get all components with meta_prices
-	var metaComponents []models.LotMetadata
-	h.db.Where("meta_prices IS NOT NULL AND meta_prices != ''").Find(&metaComponents)
-
-	// Build reverse lookup: which components are used in which meta-articles
-	for _, meta := range metaComponents {
-		sources := strings.Split(meta.MetaPrices, ",")
-		for _, source := range sources {
-			source = strings.TrimSpace(source)
-			if source == "" {
-				continue
-			}
-
-			// Handle wildcard patterns
-			if strings.HasSuffix(source, "*") {
-				prefix := strings.TrimSuffix(source, "*")
-				for _, lotName := range lotNames {
-					if strings.HasPrefix(lotName, prefix) && lotName != meta.LotName {
-						result[lotName] = append(result[lotName], meta.LotName)
-					}
-				}
-			} else {
-				// Direct match
-				for _, lotName := range lotNames {
-					if lotName == source && lotName != meta.LotName {
-						result[lotName] = append(result[lotName], meta.LotName)
-					}
-				}
-			}
-		}
-	}
-
-	return result
-}
-
-// expandMetaPrices expands meta_prices string to list of actual lot names
-func (h *PricingHandler) expandMetaPrices(metaPrices, excludeLot string) []string {
-	sources := strings.Split(metaPrices, ",")
-	var result []string
-	seen := make(map[string]bool)
-
-	for _, source := range sources {
-		source = strings.TrimSpace(source)
-		if source == "" {
-			continue
-		}
-
-		if strings.HasSuffix(source, "*") {
-			// Wildcard pattern - find matching lots
-			prefix := strings.TrimSuffix(source, "*")
-			var matchingLots []string
-			h.db.Model(&models.LotMetadata{}).
-				Where("lot_name LIKE ? AND lot_name != ?", prefix+"%", excludeLot).
-				Pluck("lot_name", &matchingLots)
-			for _, lot := range matchingLots {
-				if !seen[lot] {
-					result = append(result, lot)
-					seen[lot] = true
-				}
-			}
-		} else if source != excludeLot && !seen[source] {
-			result = append(result, source)
-			seen[source] = true
-		}
-	}
-
-	return result
-}
-
-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)
-	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "component not found"})
-		return
-	}
-
-	stats, err := h.pricingService.GetPriceStats(lotName, 0)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"component":   component,
-		"price_stats": stats,
-	})
-}
-
-type UpdatePriceRequest struct {
-	LotName     string             `json:"lot_name" binding:"required"`
-	Method      models.PriceMethod `json:"method"`
-	PeriodDays  int                `json:"period_days"`
-	Coefficient float64            `json:"coefficient"`
-	ManualPrice *float64           `json:"manual_price"`
-	ClearManual bool               `json:"clear_manual"`
-	MetaEnabled bool               `json:"meta_enabled"`
-	MetaPrices  string             `json:"meta_prices"`
-	MetaMethod  string             `json:"meta_method"`
-	MetaPeriod  int                `json:"meta_period"`
-	IsHidden    bool               `json:"is_hidden"`
-}
-
-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()})
-		return
-	}
-
-	updates := map[string]interface{}{}
-
-	// Update method if specified
-	if req.Method != "" {
-		updates["price_method"] = req.Method
-	}
-
-	// Update period days
-	if req.PeriodDays >= 0 {
-		updates["price_period_days"] = req.PeriodDays
-	}
-
-	// Update coefficient
-	updates["price_coefficient"] = req.Coefficient
-
-	// Handle meta prices
-	if req.MetaEnabled && req.MetaPrices != "" {
-		updates["meta_prices"] = req.MetaPrices
-	} else {
-		updates["meta_prices"] = ""
-	}
-
-	// Handle hidden flag
-	updates["is_hidden"] = req.IsHidden
-
-	// Handle manual price
-	if req.ClearManual {
-		updates["manual_price"] = nil
-	} else if req.ManualPrice != nil {
-		updates["manual_price"] = *req.ManualPrice
-		// Also update current price immediately when setting manual
-		updates["current_price"] = *req.ManualPrice
-		updates["price_updated_at"] = time.Now()
-	}
-
-	err := h.db.Model(&models.LotMetadata{}).
-		Where("lot_name = ?", req.LotName).
-		Updates(updates).Error
-
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	// Recalculate price if not using manual price
-	if req.ManualPrice == nil {
-		h.recalculateSinglePrice(req.LotName)
-	}
-
-	// Get updated component to return new price
-	var comp models.LotMetadata
-	h.db.Where("lot_name = ?", req.LotName).First(&comp)
-
-	c.JSON(http.StatusOK, gin.H{
-		"message":       "price updated",
-		"current_price": comp.CurrentPrice,
-	})
-}
-
-func (h *PricingHandler) recalculateSinglePrice(lotName string) {
-	var comp models.LotMetadata
-	if err := h.db.Where("lot_name = ?", lotName).First(&comp).Error; err != nil {
-		return
-	}
-
-	// Skip if manual price is set
-	if comp.ManualPrice != nil && *comp.ManualPrice > 0 {
-		return
-	}
-
-	periodDays := comp.PricePeriodDays
-	method := comp.PriceMethod
-	if method == "" {
-		method = models.PriceMethodMedian
-	}
-
-	// Determine which lot names to use for price calculation
-	lotNames := []string{lotName}
-	if comp.MetaPrices != "" {
-		lotNames = h.expandMetaPrices(comp.MetaPrices, lotName)
-	}
-
-	// Get prices based on period from all relevant lots
-	var prices []float64
-	for _, ln := range lotNames {
-		var lotPrices []float64
-		if strings.HasSuffix(ln, "*") {
-			pattern := strings.TrimSuffix(ln, "*") + "%"
-			if periodDays > 0 {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
-					pattern, periodDays).Pluck("price", &lotPrices)
-			} else {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? ORDER BY price`, pattern).Pluck("price", &lotPrices)
-			}
-		} else {
-			if periodDays > 0 {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
-					ln, periodDays).Pluck("price", &lotPrices)
-			} else {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? ORDER BY price`, ln).Pluck("price", &lotPrices)
-			}
-		}
-		prices = append(prices, lotPrices...)
-	}
-
-	// If no prices in period, try all time
-	if len(prices) == 0 && periodDays > 0 {
-		for _, ln := range lotNames {
-			var lotPrices []float64
-			if strings.HasSuffix(ln, "*") {
-				pattern := strings.TrimSuffix(ln, "*") + "%"
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? ORDER BY price`, pattern).Pluck("price", &lotPrices)
-			} else {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? ORDER BY price`, ln).Pluck("price", &lotPrices)
-			}
-			prices = append(prices, lotPrices...)
-		}
-	}
-
-	if len(prices) == 0 {
-		return
-	}
-
-	// Calculate price based on method
-	sortFloat64s(prices)
-	var finalPrice float64
-	switch method {
-	case models.PriceMethodMedian:
-		finalPrice = calculateMedian(prices)
-	case models.PriceMethodAverage:
-		finalPrice = calculateAverage(prices)
-	default:
-		finalPrice = calculateMedian(prices)
-	}
-
-	if finalPrice <= 0 {
-		return
-	}
-
-	// Apply coefficient
-	if comp.PriceCoefficient != 0 {
-		finalPrice = finalPrice * (1 + comp.PriceCoefficient/100)
-	}
-
-	now := time.Now()
-	// Only update price, preserve all user settings
-	h.db.Model(&models.LotMetadata{}).
-		Where("lot_name = ?", lotName).
-		Updates(map[string]interface{}{
-			"current_price":    finalPrice,
-			"price_updated_at": now,
-		})
-}
-
-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")
-	c.Header("Connection", "keep-alive")
-
-	// Get all components with their settings
-	var components []models.LotMetadata
-	h.db.Find(&components)
-	total := int64(len(components))
-
-	// Pre-load all lot names for efficient wildcard matching
-	var allLotNames []string
-	h.db.Model(&models.LotMetadata{}).Pluck("lot_name", &allLotNames)
-	lotNameSet := make(map[string]bool, len(allLotNames))
-	for _, ln := range allLotNames {
-		lotNameSet[ln] = true
-	}
-
-	// Pre-load latest quote dates for all lots (for checking updates)
-	type LotDate struct {
-		Lot  string
-		Date time.Time
-	}
-	var latestDates []LotDate
-	h.db.Raw(`SELECT lot, MAX(date) as date FROM lot_log GROUP BY lot`).Scan(&latestDates)
-	lotLatestDate := make(map[string]time.Time, len(latestDates))
-	for _, ld := range latestDates {
-		lotLatestDate[ld.Lot] = ld.Date
-	}
-
-	// Send initial progress
-	c.SSEvent("progress", gin.H{"current": 0, "total": total, "status": "starting"})
-	c.Writer.Flush()
-
-	// Process components individually to respect their settings
-	var updated, skipped, manual, unchanged, errors int
-	now := time.Now()
-	progressCounter := 0
-
-	for _, comp := range components {
-		progressCounter++
-
-		// If manual price is set, skip recalculation
-		if comp.ManualPrice != nil && *comp.ManualPrice > 0 {
-			manual++
-			goto sendProgress
-		}
-
-		// Calculate price based on component's individual settings
-		{
-			periodDays := comp.PricePeriodDays
-			method := comp.PriceMethod
-			if method == "" {
-				method = models.PriceMethodMedian
-			}
-
-			// Determine source lots for price calculation (using cached lot names)
-			var sourceLots []string
-			if comp.MetaPrices != "" {
-				sourceLots = expandMetaPricesWithCache(comp.MetaPrices, comp.LotName, allLotNames)
-			} else {
-				sourceLots = []string{comp.LotName}
-			}
-
-			if len(sourceLots) == 0 {
-				skipped++
-				goto sendProgress
-			}
-
-			// Check if there are new quotes since last update (using cached dates)
-			if comp.PriceUpdatedAt != nil {
-				hasNewData := false
-				for _, lot := range sourceLots {
-					if latestDate, ok := lotLatestDate[lot]; ok {
-						if latestDate.After(*comp.PriceUpdatedAt) {
-							hasNewData = true
-							break
-						}
-					}
-				}
-				if !hasNewData {
-					unchanged++
-					goto sendProgress
-				}
-			}
-
-			// Get prices from source lots
-			var prices []float64
-			if periodDays > 0 {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot IN ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
-					sourceLots, periodDays).Pluck("price", &prices)
-			} else {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot IN ? ORDER BY price`,
-					sourceLots).Pluck("price", &prices)
-			}
-
-			// If no prices in period, try all time
-			if len(prices) == 0 && periodDays > 0 {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot IN ? ORDER BY price`, sourceLots).Pluck("price", &prices)
-			}
-
-			if len(prices) == 0 {
-				skipped++
-				goto sendProgress
-			}
-
-			// Calculate price based on method
-			var basePrice float64
-			switch method {
-			case models.PriceMethodMedian:
-				basePrice = calculateMedian(prices)
-			case models.PriceMethodAverage:
-				basePrice = calculateAverage(prices)
-			default:
-				basePrice = calculateMedian(prices)
-			}
-
-			if basePrice <= 0 {
-				skipped++
-				goto sendProgress
-			}
-
-			finalPrice := basePrice
-
-			// Apply coefficient
-			if comp.PriceCoefficient != 0 {
-				finalPrice = finalPrice * (1 + comp.PriceCoefficient/100)
-			}
-
-			// Update only price fields
-			err := h.db.Model(&models.LotMetadata{}).
-				Where("lot_name = ?", comp.LotName).
-				Updates(map[string]interface{}{
-					"current_price":    finalPrice,
-					"price_updated_at": now,
-				}).Error
-			if err != nil {
-				errors++
-			} else {
-				updated++
-			}
-		}
-
-	sendProgress:
-		// Send progress update every 10 components to reduce overhead
-		if progressCounter%10 == 0 || progressCounter == int(total) {
-			c.SSEvent("progress", gin.H{
-				"current":   updated + skipped + manual + unchanged + errors,
-				"total":     total,
-				"updated":   updated,
-				"skipped":   skipped,
-				"manual":    manual,
-				"unchanged": unchanged,
-				"errors":    errors,
-				"status":    "processing",
-				"lot_name":  comp.LotName,
-			})
-			c.Writer.Flush()
-		}
-	}
-
-	// Update popularity scores
-	h.statsRepo.UpdatePopularityScores()
-
-	// Send completion
-	c.SSEvent("progress", gin.H{
-		"current":   updated + skipped + manual + unchanged + errors,
-		"total":     total,
-		"updated":   updated,
-		"skipped":   skipped,
-		"manual":    manual,
-		"unchanged": unchanged,
-		"errors":    errors,
-		"status":    "completed",
-	})
-	c.Writer.Flush()
-}
-
-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"))
-
-	filter := repository.AlertFilter{
-		Status:   models.AlertStatus(c.Query("status")),
-		Severity: models.AlertSeverity(c.Query("severity")),
-		Type:     models.AlertType(c.Query("type")),
-		LotName:  c.Query("lot_name"),
-	}
-
-	alertsList, total, err := h.alertService.List(filter, page, perPage)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"alerts":   alertsList,
-		"total":    total,
-		"page":     page,
-		"per_page": perPage,
-	})
-}
-
-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"})
-		return
-	}
-
-	if err := h.alertService.Acknowledge(uint(id)); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"message": "acknowledged"})
-}
-
-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"})
-		return
-	}
-
-	if err := h.alertService.Resolve(uint(id)); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"message": "resolved"})
-}
-
-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"})
-		return
-	}
-
-	if err := h.alertService.Ignore(uint(id)); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"message": "ignored"})
-}
-
-type PreviewPriceRequest struct {
-	LotName     string  `json:"lot_name" binding:"required"`
-	Method      string  `json:"method"`
-	PeriodDays  int     `json:"period_days"`
-	Coefficient float64 `json:"coefficient"`
-	MetaEnabled bool    `json:"meta_enabled"`
-	MetaPrices  string  `json:"meta_prices"`
-}
-
-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()})
-		return
-	}
-
-	// Get component
-	var comp models.LotMetadata
-	if err := h.db.Where("lot_name = ?", req.LotName).First(&comp).Error; err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "component not found"})
-		return
-	}
-
-	// Determine which lot names to use for price calculation
-	lotNames := []string{req.LotName}
-	if req.MetaEnabled && req.MetaPrices != "" {
-		lotNames = h.expandMetaPrices(req.MetaPrices, req.LotName)
-	}
-
-	// Get all prices for calculations (from all relevant lots)
-	var allPrices []float64
-	for _, lotName := range lotNames {
-		var lotPrices []float64
-		if strings.HasSuffix(lotName, "*") {
-			// Wildcard pattern
-			pattern := strings.TrimSuffix(lotName, "*") + "%"
-			h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? ORDER BY price`, pattern).Pluck("price", &lotPrices)
-		} else {
-			h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? ORDER BY price`, lotName).Pluck("price", &lotPrices)
-		}
-		allPrices = append(allPrices, lotPrices...)
-	}
-
-	// Calculate median for all time
-	var medianAllTime *float64
-	if len(allPrices) > 0 {
-		sortFloat64s(allPrices)
-		median := calculateMedian(allPrices)
-		medianAllTime = &median
-	}
-
-	// Get quote count (from all relevant lots) - total count
-	var quoteCountTotal int64
-	for _, lotName := range lotNames {
-		var count int64
-		if strings.HasSuffix(lotName, "*") {
-			pattern := strings.TrimSuffix(lotName, "*") + "%"
-			h.db.Model(&models.LotLog{}).Where("lot LIKE ?", pattern).Count(&count)
-		} else {
-			h.db.Model(&models.LotLog{}).Where("lot = ?", lotName).Count(&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)
-	var lastPrice struct {
-		Price *float64
-		Date  *time.Time
-	}
-	h.db.Raw(`SELECT price, date FROM lot_log WHERE lot = ? ORDER BY date DESC, lot_log_id DESC LIMIT 1`, req.LotName).Scan(&lastPrice)
-
-	// Calculate new price based on parameters (method, period, coefficient)
-	method := req.Method
-	if method == "" {
-		method = "median"
-	}
-
-	var prices []float64
-	if req.PeriodDays > 0 {
-		for _, lotName := range lotNames {
-			var lotPrices []float64
-			if strings.HasSuffix(lotName, "*") {
-				pattern := strings.TrimSuffix(lotName, "*") + "%"
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
-					pattern, req.PeriodDays).Pluck("price", &lotPrices)
-			} else {
-				h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
-					lotName, req.PeriodDays).Pluck("price", &lotPrices)
-			}
-			prices = append(prices, lotPrices...)
-		}
-		// Fall back to all time if no prices in period
-		if len(prices) == 0 {
-			prices = allPrices
-		}
-	} else {
-		prices = allPrices
-	}
-
-	var newPrice *float64
-	if len(prices) > 0 {
-		sortFloat64s(prices)
-		var basePrice float64
-		if method == "average" {
-			basePrice = calculateAverage(prices)
-		} else {
-			basePrice = calculateMedian(prices)
-		}
-
-		if req.Coefficient != 0 {
-			basePrice = basePrice * (1 + req.Coefficient/100)
-		}
-		newPrice = &basePrice
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"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,
-	})
-}
-
-// sortFloat64s sorts a slice of float64 in ascending order
-func sortFloat64s(data []float64) {
-	sort.Float64s(data)
-}
-
-// expandMetaPricesWithCache expands meta_prices using pre-loaded lot names (no DB queries)
-func expandMetaPricesWithCache(metaPrices, excludeLot string, allLotNames []string) []string {
-	sources := strings.Split(metaPrices, ",")
-	var result []string
-	seen := make(map[string]bool)
-
-	for _, source := range sources {
-		source = strings.TrimSpace(source)
-		if source == "" || source == excludeLot {
-			continue
-		}
-
-		if strings.HasSuffix(source, "*") {
-			// Wildcard pattern - find matching lots from cache
-			prefix := strings.TrimSuffix(source, "*")
-			for _, lot := range allLotNames {
-				if strings.HasPrefix(lot, prefix) && lot != excludeLot && !seen[lot] {
-					result = append(result, lot)
-					seen[lot] = true
-				}
-			}
-		} else if !seen[source] {
-			result = append(result, source)
-			seen[source] = true
-		}
-	}
-
-	return result
-}

internal/handlers/quote.go

@@ -3,8 +3,8 @@ package handlers
 import (
 	"net/http"
 
-	"github.com/gin-gonic/gin"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
 )
 
 type QuoteHandler struct {
@@ -49,3 +49,19 @@ func (h *QuoteHandler) Calculate(c *gin.Context) {
 		"total": result.Total,
 	})
 }
+
+func (h *QuoteHandler) PriceLevels(c *gin.Context) {
+	var req services.PriceLevelsRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	result, err := h.quoteService.CalculatePriceLevels(&req)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, result)
+}

internal/handlers/setup.go

@@ -4,17 +4,17 @@ import (
 	"fmt"
 	"html/template"
 	"log/slog"
+	"net"
 	"net/http"
-	"os"
-	"path/filepath"
 	"strconv"
 	"time"
 
 	qfassets "git.mchus.pro/mchus/quoteforge"
 	"git.mchus.pro/mchus/quoteforge/internal/db"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	mysqlDriver "github.com/go-sql-driver/mysql"
 	"github.com/gin-gonic/gin"
-	"gorm.io/driver/mysql"
+	gormmysql "gorm.io/driver/mysql"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 )
@@ -26,7 +26,7 @@ type SetupHandler struct {
 	restartSig chan struct{}
 }
 
-func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, templatesPath string, restartSig chan struct{}) (*SetupHandler, error) {
+func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, _ 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 },
@@ -35,14 +35,9 @@ func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, te
 	templates := make(map[string]*template.Template)
 
 	// Load setup template (standalone, no base needed)
-	setupPath := filepath.Join(templatesPath, "setup.html")
 	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")
-	}
+	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)
 	}
@@ -93,10 +88,9 @@ func (h *SetupHandler) TestConnection(c *gin.Context) {
 		}
 	}
 
-	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=5s",
-		user, password, host, port, database)
+	dsn := buildMySQLDSN(host, port, database, user, password, 5*time.Second)
 
-	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+	db, err := gorm.Open(gormmysql.Open(dsn), &gorm.Config{
 		Logger: logger.Default.LogMode(logger.Silent),
 	})
 	if err != nil {
@@ -148,6 +142,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")
@@ -167,10 +163,9 @@ func (h *SetupHandler) SaveConnection(c *gin.Context) {
 	}
 
 	// 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)
+	dsn := buildMySQLDSN(host, port, database, user, password, 5*time.Second)
 
-	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+	db, err := gorm.Open(gormmysql.Open(dsn), &gorm.Config{
 		Logger: logger.Default.LogMode(logger.Silent),
 	})
 	if err != nil {
@@ -202,18 +197,29 @@ func (h *SetupHandler) SaveConnection(c *gin.Context) {
 		}
 	}
 
-	// Always restart to properly initialize all services with the new connection
+	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 to apply changes.",
-		"restart_required": true,
+		"message":          "Settings saved.",
+		"restart_required": settingsChanged,
+		"restart_queued":   restartQueued,
 	})
 
 	// Signal restart after response is sent (if restart signal is configured)
-	if h.restartSig != nil {
+	if restartQueued {
 		go func() {
 			time.Sleep(500 * time.Millisecond) // Give time for response to be sent
-			h.restartSig <- struct{}{}
+			select {
+			case h.restartSig <- struct{}{}:
+			default:
+			}
 		}()
 	}
 }
@@ -241,3 +247,19 @@ func testWritePermission(db *gorm.DB) bool {
 
 	return true
 }
+
+func buildMySQLDSN(host string, port int, database, user, password string, timeout time.Duration) string {
+	cfg := mysqlDriver.NewConfig()
+	cfg.User = user
+	cfg.Passwd = password
+	cfg.Net = "tcp"
+	cfg.Addr = net.JoinHostPort(host, strconv.Itoa(port))
+	cfg.DBName = database
+	cfg.ParseTime = true
+	cfg.Loc = time.Local
+	cfg.Timeout = timeout
+	cfg.Params = map[string]string{
+		"charset": "utf8mb4",
+	}
+	return cfg.FormatDSN()
+}

internal/handlers/sync.go

@@ -1,11 +1,12 @@
 package handlers
 
 import (
+	"errors"
+	"fmt"
 	"html/template"
 	"log/slog"
 	"net/http"
-	"os"
-	"path/filepath"
+	stdsync "sync"
 	"time"
 
 	qfassets "git.mchus.pro/mchus/quoteforge"
@@ -17,45 +18,55 @@ import (
 
 // SyncHandler handles sync API endpoints
 type SyncHandler struct {
-	localDB     *localdb.LocalDB
-	syncService *sync.Service
-	connMgr     *db.ConnectionManager
-	tmpl        *template.Template
+	localDB           *localdb.LocalDB
+	syncService       *sync.Service
+	connMgr           *db.ConnectionManager
+	autoSyncInterval  time.Duration
+	onlineGraceFactor float64
+	tmpl              *template.Template
+	readinessMu       stdsync.Mutex
+	readinessCached   *sync.SyncReadiness
+	readinessCachedAt time.Time
 }
 
 // NewSyncHandler creates a new sync handler
-func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, templatesPath string) (*SyncHandler, error) {
+func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, _ string, autoSyncInterval time.Duration) (*SyncHandler, error) {
 	// Load sync_status partial template
-	partialPath := filepath.Join(templatesPath, "partials", "sync_status.html")
-	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")
-	}
+	tmpl, err := template.ParseFS(qfassets.TemplatesFS, "web/templates/partials/sync_status.html")
 	if err != nil {
 		return nil, err
 	}
 
 	return &SyncHandler{
-		localDB:     localDB,
-		syncService: syncService,
-		connMgr:     connMgr,
-		tmpl:        tmpl,
+		localDB:           localDB,
+		syncService:       syncService,
+		connMgr:           connMgr,
+		autoSyncInterval:  autoSyncInterval,
+		onlineGraceFactor: 1.10,
+		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"`
+	Readiness         *sync.SyncReadiness `json:"readiness,omitempty"`
+}
+
+type SyncReadinessResponse struct {
+	Status                string     `json:"status"`
+	Blocked               bool       `json:"blocked"`
+	ReasonCode            string     `json:"reason_code,omitempty"`
+	ReasonText            string     `json:"reason_text,omitempty"`
+	RequiredMinAppVersion *string    `json:"required_min_app_version,omitempty"`
+	LastCheckedAt         *time.Time `json:"last_checked_at,omitempty"`
 }
 
 // GetStatus returns current sync status
@@ -85,6 +96,7 @@ func (h *SyncHandler) GetStatus(c *gin.Context) {
 
 	// Check if component sync is needed (older than 24 hours)
 	needComponentSync := h.localDB.NeedComponentSync(24)
+	readiness := h.getReadinessCached(10 * time.Second)
 
 	c.JSON(http.StatusOK, SyncStatusResponse{
 		LastComponentSync: lastComponentSync,
@@ -95,9 +107,63 @@ func (h *SyncHandler) GetStatus(c *gin.Context) {
 		ServerPricelists:  serverPricelists,
 		NeedComponentSync: needComponentSync,
 		NeedPricelistSync: needPricelistSync,
+		Readiness:         readiness,
 	})
 }
 
+// GetReadiness returns sync readiness guard status.
+// GET /api/sync/readiness
+func (h *SyncHandler) GetReadiness(c *gin.Context) {
+	readiness, err := h.syncService.GetReadiness()
+	if err != nil && readiness == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": err.Error(),
+		})
+		return
+	}
+	if readiness == nil {
+		c.JSON(http.StatusOK, SyncReadinessResponse{Status: sync.ReadinessUnknown, Blocked: false})
+		return
+	}
+	c.JSON(http.StatusOK, SyncReadinessResponse{
+		Status:                readiness.Status,
+		Blocked:               readiness.Blocked,
+		ReasonCode:            readiness.ReasonCode,
+		ReasonText:            readiness.ReasonText,
+		RequiredMinAppVersion: readiness.RequiredMinAppVersion,
+		LastCheckedAt:         readiness.LastCheckedAt,
+	})
+}
+
+func (h *SyncHandler) ensureSyncReadiness(c *gin.Context) bool {
+	readiness, err := h.syncService.EnsureReadinessForSync()
+	if err == nil {
+		return true
+	}
+
+	blocked := &sync.SyncBlockedError{}
+	if errors.As(err, &blocked) {
+		c.JSON(http.StatusLocked, gin.H{
+			"success":                  false,
+			"error":                    blocked.Error(),
+			"reason_code":              blocked.Readiness.ReasonCode,
+			"reason_text":              blocked.Readiness.ReasonText,
+			"required_min_app_version": blocked.Readiness.RequiredMinAppVersion,
+			"status":                   blocked.Readiness.Status,
+			"blocked":                  true,
+			"last_checked_at":          blocked.Readiness.LastCheckedAt,
+		})
+		return false
+	}
+
+	c.JSON(http.StatusInternalServerError, gin.H{
+		"success": false,
+		"error":   err.Error(),
+	})
+	_ = readiness
+	return false
+}
+
 // SyncResultResponse represents sync operation result
 type SyncResultResponse struct {
 	Success  bool   `json:"success"`
@@ -109,11 +175,7 @@ type SyncResultResponse struct {
 // SyncComponents syncs components from MariaDB to local SQLite
 // POST /api/sync/components
 func (h *SyncHandler) SyncComponents(c *gin.Context) {
-	if !h.checkOnline() {
-		c.JSON(http.StatusServiceUnavailable, gin.H{
-			"success": false,
-			"error":   "Database is offline",
-		})
+	if !h.ensureSyncReadiness(c) {
 		return
 	}
 
@@ -148,11 +210,7 @@ func (h *SyncHandler) SyncComponents(c *gin.Context) {
 // SyncPricelists syncs pricelists from MariaDB to local SQLite
 // POST /api/sync/pricelists
 func (h *SyncHandler) SyncPricelists(c *gin.Context) {
-	if !h.checkOnline() {
-		c.JSON(http.StatusServiceUnavailable, gin.H{
-			"success": false,
-			"error":   "Database is offline",
-		})
+	if !h.ensureSyncReadiness(c) {
 		return
 	}
 
@@ -173,30 +231,74 @@ func (h *SyncHandler) SyncPricelists(c *gin.Context) {
 		Synced:   synced,
 		Duration: time.Since(startTime).String(),
 	})
+	h.syncService.RecordSyncHeartbeat()
 }
 
-// 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"`
-}
-
-// SyncAll syncs both components and pricelists
-// POST /api/sync/all
-func (h *SyncHandler) SyncAll(c *gin.Context) {
-	if !h.checkOnline() {
-		c.JSON(http.StatusServiceUnavailable, gin.H{
-			"success": false,
-			"error":   "Database is offline",
-		})
+// SyncPartnumberBooks syncs partnumber book snapshots from MariaDB to local SQLite.
+// POST /api/sync/partnumber-books
+func (h *SyncHandler) SyncPartnumberBooks(c *gin.Context) {
+	if !h.ensureSyncReadiness(c) {
 		return
 	}
 
 	startTime := time.Now()
-	var componentsSynced, pricelistsSynced int
+	pulled, err := h.syncService.PullPartnumberBooks()
+	if err != nil {
+		slog.Error("partnumber books pull failed", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, SyncResultResponse{
+		Success:  true,
+		Message:  "Partnumber books synced successfully",
+		Synced:   pulled,
+		Duration: time.Since(startTime).String(),
+	})
+	h.syncService.RecordSyncHeartbeat()
+}
+
+// SyncAllResponse represents result of full sync
+type SyncAllResponse struct {
+	Success                bool   `json:"success"`
+	Message                string `json:"message"`
+	PendingPushed          int    `json:"pending_pushed"`
+	ComponentsSynced       int    `json:"components_synced"`
+	PricelistsSynced       int    `json:"pricelists_synced"`
+	ProjectsImported       int    `json:"projects_imported"`
+	ProjectsUpdated        int    `json:"projects_updated"`
+	ProjectsSkipped        int    `json:"projects_skipped"`
+	ConfigurationsImported int    `json:"configurations_imported"`
+	ConfigurationsUpdated  int    `json:"configurations_updated"`
+	ConfigurationsSkipped  int    `json:"configurations_skipped"`
+	Duration               string `json:"duration"`
+}
+
+// SyncAll performs full bidirectional sync:
+// - push pending local changes (projects/configurations) to server
+// - pull components, pricelists, projects, and configurations from server
+// POST /api/sync/all
+func (h *SyncHandler) SyncAll(c *gin.Context) {
+	if !h.ensureSyncReadiness(c) {
+		return
+	}
+
+	startTime := time.Now()
+	var pendingPushed, componentsSynced, pricelistsSynced int
+
+	// Push local pending changes first (projects/configurations)
+	pendingPushed, err := h.syncService.PushPendingChanges()
+	if err != nil {
+		slog.Error("pending push failed during full sync", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   "Pending changes push failed: " + err.Error(),
+		})
+		return
+	}
 
 	// Sync components
 	mariaDB, err := h.connMgr.GetDB()
@@ -226,18 +328,56 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{
 			"success":           false,
 			"error":             "Pricelist sync failed: " + err.Error(),
+			"pending_pushed":    pendingPushed,
 			"components_synced": componentsSynced,
 		})
 		return
 	}
 
+	projectsResult, err := h.syncService.ImportProjectsToLocal()
+	if err != nil {
+		slog.Error("project import failed during full sync", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success":           false,
+			"error":             "Project import failed: " + err.Error(),
+			"pending_pushed":    pendingPushed,
+			"components_synced": componentsSynced,
+			"pricelists_synced": pricelistsSynced,
+		})
+		return
+	}
+
+	configsResult, err := h.syncService.ImportConfigurationsToLocal()
+	if err != nil {
+		slog.Error("configuration import failed during full sync", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success":           false,
+			"error":             "Configuration import failed: " + err.Error(),
+			"pending_pushed":    pendingPushed,
+			"components_synced": componentsSynced,
+			"pricelists_synced": pricelistsSynced,
+			"projects_imported": projectsResult.Imported,
+			"projects_updated":  projectsResult.Updated,
+			"projects_skipped":  projectsResult.Skipped,
+		})
+		return
+	}
+
 	c.JSON(http.StatusOK, SyncAllResponse{
-		Success:          true,
-		Message:          "Full sync completed successfully",
-		ComponentsSynced: componentsSynced,
-		PricelistsSynced: pricelistsSynced,
-		Duration:         time.Since(startTime).String(),
+		Success:                true,
+		Message:                "Full sync completed successfully",
+		PendingPushed:          pendingPushed,
+		ComponentsSynced:       componentsSynced,
+		PricelistsSynced:       pricelistsSynced,
+		ProjectsImported:       projectsResult.Imported,
+		ProjectsUpdated:        projectsResult.Updated,
+		ProjectsSkipped:        projectsResult.Skipped,
+		ConfigurationsImported: configsResult.Imported,
+		ConfigurationsUpdated:  configsResult.Updated,
+		ConfigurationsSkipped:  configsResult.Skipped,
+		Duration:               time.Since(startTime).String(),
 	})
+	h.syncService.RecordSyncHeartbeat()
 }
 
 // checkOnline checks if MariaDB is accessible
@@ -248,11 +388,7 @@ func (h *SyncHandler) checkOnline() bool {
 // PushPendingChanges pushes all pending changes to the server
 // POST /api/sync/push
 func (h *SyncHandler) PushPendingChanges(c *gin.Context) {
-	if !h.checkOnline() {
-		c.JSON(http.StatusServiceUnavailable, gin.H{
-			"success": false,
-			"error":   "Database is offline",
-		})
+	if !h.ensureSyncReadiness(c) {
 		return
 	}
 
@@ -273,6 +409,7 @@ func (h *SyncHandler) PushPendingChanges(c *gin.Context) {
 		Synced:   pushed,
 		Duration: time.Since(startTime).String(),
 	})
+	h.syncService.RecordSyncHeartbeat()
 }
 
 // GetPendingCount returns the number of pending changes
@@ -300,12 +437,60 @@ func (h *SyncHandler) GetPendingChanges(c *gin.Context) {
 	})
 }
 
-// SyncInfoResponse represents sync information
+// RepairPendingChanges attempts to repair errored pending changes
+// POST /api/sync/repair
+func (h *SyncHandler) RepairPendingChanges(c *gin.Context) {
+	repaired, remainingErrors, err := h.localDB.RepairPendingChanges()
+	if err != nil {
+		slog.Error("repair pending changes failed", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"success":          true,
+		"repaired":         repaired,
+		"remaining_errors": remainingErrors,
+	})
+}
+
+// SyncInfoResponse represents sync information for the modal
 type SyncInfoResponse struct {
-	LastSyncAt *time.Time  `json:"last_sync_at"`
-	IsOnline   bool        `json:"is_online"`
+	// Connection
+	DBHost string `json:"db_host"`
+	DBUser string `json:"db_user"`
+	DBName string `json:"db_name"`
+
+	// Status
+	IsOnline   bool       `json:"is_online"`
+	LastSyncAt *time.Time `json:"last_sync_at"`
+
+	// Statistics
+	LotCount     int64 `json:"lot_count"`
+	LotLogCount  int64 `json:"lot_log_count"`
+	ConfigCount  int64 `json:"config_count"`
+	ProjectCount int64 `json:"project_count"`
+
+	// Pending changes
+	PendingChanges []localdb.PendingChange `json:"pending_changes"`
+
+	// Errors
 	ErrorCount int         `json:"error_count"`
 	Errors     []SyncError `json:"errors,omitempty"`
+
+	// Readiness guard
+	Readiness *sync.SyncReadiness `json:"readiness,omitempty"`
+}
+
+type SyncUsersStatusResponse struct {
+	IsOnline                bool                  `json:"is_online"`
+	AutoSyncIntervalSeconds int64                 `json:"auto_sync_interval_seconds"`
+	OnlineThresholdSeconds  int64                 `json:"online_threshold_seconds"`
+	GeneratedAt             time.Time             `json:"generated_at"`
+	Users                   []sync.UserSyncStatus `json:"users"`
 }
 
 // SyncError represents a sync error
@@ -320,31 +505,44 @@ func (h *SyncHandler) GetInfo(c *gin.Context) {
 	// Check online status by pinging MariaDB
 	isOnline := h.checkOnline()
 
+	// Get DB connection info
+	var dbHost, dbUser, dbName string
+	if settings, err := h.localDB.GetSettings(); err == nil {
+		dbHost = settings.Host + ":" + fmt.Sprintf("%d", settings.Port)
+		dbUser = settings.User
+		dbName = settings.Database
+	}
+
 	// Get sync times
 	lastPricelistSync := h.localDB.GetLastSyncTime()
 
+	// Get MariaDB counts (if online)
+	var lotCount, lotLogCount int64
+	if isOnline {
+		if mariaDB, err := h.connMgr.GetDB(); err == nil {
+			mariaDB.Table("lot").Count(&lotCount)
+			mariaDB.Table("lot_log").Count(&lotLogCount)
+		}
+	}
+
+	// Get local counts
+	configCount := h.localDB.CountConfigurations()
+	projectCount := h.localDB.CountProjects()
+
 	// Get error count (only changes with LastError != "")
 	errorCount := int(h.localDB.CountErroredChanges())
 
-	// Get recent errors (last 10)
+	// Get pending changes
 	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
+		changes = []localdb.PendingChange{}
 	}
 
-	var errors []SyncError
+	var syncErrors []SyncError
 	for _, change := range changes {
-		// Check if there's a last error and it's not empty
 		if change.LastError != "" {
-			errors = append(errors, SyncError{
+			syncErrors = append(syncErrors, SyncError{
 				Timestamp: change.CreatedAt,
 				Message:   change.LastError,
 			})
@@ -352,15 +550,63 @@ func (h *SyncHandler) GetInfo(c *gin.Context) {
 	}
 
 	// Limit to last 10 errors
-	if len(errors) > 10 {
-		errors = errors[:10]
+	if len(syncErrors) > 10 {
+		syncErrors = syncErrors[:10]
 	}
 
+	readiness := h.getReadinessCached(10 * time.Second)
+
 	c.JSON(http.StatusOK, SyncInfoResponse{
-		LastSyncAt: lastPricelistSync,
-		IsOnline:   isOnline,
-		ErrorCount: errorCount,
-		Errors:     errors,
+		DBHost:         dbHost,
+		DBUser:         dbUser,
+		DBName:         dbName,
+		IsOnline:       isOnline,
+		LastSyncAt:     lastPricelistSync,
+		LotCount:       lotCount,
+		LotLogCount:    lotLogCount,
+		ConfigCount:    configCount,
+		ProjectCount:   projectCount,
+		PendingChanges: changes,
+		ErrorCount:     errorCount,
+		Errors:         syncErrors,
+		Readiness:      readiness,
+	})
+}
+
+// GetUsersStatus returns last sync timestamps for users with sync heartbeats.
+// GET /api/sync/users-status
+func (h *SyncHandler) GetUsersStatus(c *gin.Context) {
+	threshold := time.Duration(float64(h.autoSyncInterval) * h.onlineGraceFactor)
+	isOnline := h.checkOnline()
+
+	if !isOnline {
+		c.JSON(http.StatusOK, SyncUsersStatusResponse{
+			IsOnline:                false,
+			AutoSyncIntervalSeconds: int64(h.autoSyncInterval.Seconds()),
+			OnlineThresholdSeconds:  int64(threshold.Seconds()),
+			GeneratedAt:             time.Now().UTC(),
+			Users:                   []sync.UserSyncStatus{},
+		})
+		return
+	}
+
+	// Keep current client heartbeat fresh so app version is available in the table.
+	h.syncService.RecordSyncHeartbeat()
+
+	users, err := h.syncService.ListUserSyncStatuses(threshold)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, SyncUsersStatusResponse{
+		IsOnline:                true,
+		AutoSyncIntervalSeconds: int64(h.autoSyncInterval.Seconds()),
+		OnlineThresholdSeconds:  int64(threshold.Seconds()),
+		GeneratedAt:             time.Now().UTC(),
+		Users:                   users,
 	})
 }
 
@@ -380,12 +626,21 @@ func (h *SyncHandler) SyncStatusPartial(c *gin.Context) {
 
 	// Get pending count
 	pendingCount := h.localDB.GetPendingCount()
+	readiness := h.getReadinessCached(10 * time.Second)
+	isBlocked := readiness != nil && readiness.Blocked
 
-	slog.Debug("rendering sync status", "is_offline", isOffline, "pending_count", pendingCount)
+	slog.Debug("rendering sync status", "is_offline", isOffline, "pending_count", pendingCount, "sync_blocked", isBlocked)
 
 	data := gin.H{
 		"IsOffline":    isOffline,
 		"PendingCount": pendingCount,
+		"IsBlocked":    isBlocked,
+		"BlockedReason": func() string {
+			if readiness == nil {
+				return ""
+			}
+			return readiness.ReasonText
+		}(),
 	}
 
 	c.Header("Content-Type", "text/html; charset=utf-8")
@@ -394,3 +649,58 @@ func (h *SyncHandler) SyncStatusPartial(c *gin.Context) {
 		c.String(http.StatusInternalServerError, "Template error: "+err.Error())
 	}
 }
+
+func (h *SyncHandler) getReadinessCached(maxAge time.Duration) *sync.SyncReadiness {
+	h.readinessMu.Lock()
+	if h.readinessCached != nil && time.Since(h.readinessCachedAt) < maxAge {
+		cached := *h.readinessCached
+		h.readinessMu.Unlock()
+		return &cached
+	}
+	h.readinessMu.Unlock()
+
+	readiness, err := h.syncService.GetReadiness()
+	if err != nil && readiness == nil {
+		return nil
+	}
+
+	h.readinessMu.Lock()
+	h.readinessCached = readiness
+	h.readinessCachedAt = time.Now()
+	h.readinessMu.Unlock()
+	return readiness
+}
+
+// ReportPartnumberSeen pushes unresolved vendor partnumbers to qt_vendor_partnumber_seen on MariaDB.
+// POST /api/sync/partnumber-seen
+func (h *SyncHandler) ReportPartnumberSeen(c *gin.Context) {
+	var body struct {
+		Items []struct {
+			Partnumber  string `json:"partnumber"`
+			Description string `json:"description"`
+			Ignored     bool   `json:"ignored"`
+		} `json:"items"`
+	}
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	items := make([]sync.SeenPartnumber, 0, len(body.Items))
+	for _, it := range body.Items {
+		if it.Partnumber != "" {
+			items = append(items, sync.SeenPartnumber{
+				Partnumber:  it.Partnumber,
+				Description: it.Description,
+				Ignored:     it.Ignored,
+			})
+		}
+	}
+
+	if err := h.syncService.PushPartnumberSeen(items); err != nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"reported": len(items)})
+}

internal/handlers/sync_readiness_test.go

@@ -0,0 +1,64 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	syncsvc "git.mchus.pro/mchus/quoteforge/internal/services/sync"
+	"github.com/gin-gonic/gin"
+)
+
+func TestSyncReadinessOfflineBlocked(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	dir := t.TempDir()
+	local, err := localdb.New(filepath.Join(dir, "qfs.db"))
+	if err != nil {
+		t.Fatalf("init local db: %v", err)
+	}
+
+	service := syncsvc.NewService(nil, local)
+	h, err := NewSyncHandler(local, service, nil, filepath.Join("web", "templates"), 5*time.Minute)
+	if err != nil {
+		t.Fatalf("new sync handler: %v", err)
+	}
+
+	router := gin.New()
+	router.GET("/api/sync/readiness", h.GetReadiness)
+	router.POST("/api/sync/push", h.PushPendingChanges)
+
+	readinessResp := httptest.NewRecorder()
+	readinessReq, _ := http.NewRequest(http.MethodGet, "/api/sync/readiness", nil)
+	router.ServeHTTP(readinessResp, readinessReq)
+	if readinessResp.Code != http.StatusOK {
+		t.Fatalf("unexpected readiness status: %d", readinessResp.Code)
+	}
+
+	var readinessBody map[string]any
+	if err := json.Unmarshal(readinessResp.Body.Bytes(), &readinessBody); err != nil {
+		t.Fatalf("decode readiness body: %v", err)
+	}
+	if blocked, _ := readinessBody["blocked"].(bool); !blocked {
+		t.Fatalf("expected blocked readiness, got %v", readinessBody["blocked"])
+	}
+
+	pushResp := httptest.NewRecorder()
+	pushReq, _ := http.NewRequest(http.MethodPost, "/api/sync/push", nil)
+	router.ServeHTTP(pushResp, pushReq)
+	if pushResp.Code != http.StatusLocked {
+		t.Fatalf("expected 423 for blocked sync push, got %d body=%s", pushResp.Code, pushResp.Body.String())
+	}
+
+	var pushBody map[string]any
+	if err := json.Unmarshal(pushResp.Body.Bytes(), &pushBody); err != nil {
+		t.Fatalf("decode push body: %v", err)
+	}
+	if pushBody["reason_text"] == nil || pushBody["reason_text"] == "" {
+		t.Fatalf("expected reason_text in blocked response, got %v", pushBody)
+	}
+}

internal/handlers/vendor_spec.go

@@ -0,0 +1,209 @@
+package handlers
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strings"
+
+	"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"
+)
+
+// VendorSpecHandler handles vendor BOM spec operations for a configuration.
+type VendorSpecHandler struct {
+	localDB *localdb.LocalDB
+}
+
+func NewVendorSpecHandler(localDB *localdb.LocalDB) *VendorSpecHandler {
+	return &VendorSpecHandler{localDB: localDB}
+}
+
+// lookupConfig finds an active configuration by UUID using the standard localDB method.
+func (h *VendorSpecHandler) lookupConfig(uuid string) (*localdb.LocalConfiguration, error) {
+	cfg, err := h.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, err
+	}
+	if !cfg.IsActive {
+		return nil, errors.New("not active")
+	}
+	return cfg, nil
+}
+
+// GetVendorSpec returns the vendor spec (BOM) for a configuration.
+// GET /api/configs/:uuid/vendor-spec
+func (h *VendorSpecHandler) GetVendorSpec(c *gin.Context) {
+	cfg, err := h.lookupConfig(c.Param("uuid"))
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
+		return
+	}
+
+	spec := cfg.VendorSpec
+	if spec == nil {
+		spec = localdb.VendorSpec{}
+	}
+	c.JSON(http.StatusOK, gin.H{"vendor_spec": spec})
+}
+
+// PutVendorSpec saves (replaces) the vendor spec for a configuration.
+// PUT /api/configs/:uuid/vendor-spec
+func (h *VendorSpecHandler) PutVendorSpec(c *gin.Context) {
+	cfg, err := h.lookupConfig(c.Param("uuid"))
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
+		return
+	}
+
+	var body struct {
+		VendorSpec []localdb.VendorSpecItem `json:"vendor_spec"`
+	}
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	for i := range body.VendorSpec {
+		if body.VendorSpec[i].SortOrder == 0 {
+			body.VendorSpec[i].SortOrder = (i + 1) * 10
+		}
+		// Persist canonical LOT mapping only.
+		body.VendorSpec[i].LotMappings = normalizeLotMappings(body.VendorSpec[i].LotMappings)
+		body.VendorSpec[i].ResolvedLotName = ""
+		body.VendorSpec[i].ResolutionSource = ""
+		body.VendorSpec[i].ManualLotSuggestion = ""
+		body.VendorSpec[i].LotQtyPerPN = 0
+		body.VendorSpec[i].LotAllocations = nil
+	}
+
+	spec := localdb.VendorSpec(body.VendorSpec)
+	specJSON, err := json.Marshal(spec)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	if err := h.localDB.DB().Model(cfg).Update("vendor_spec", string(specJSON)).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"vendor_spec": spec})
+}
+
+func normalizeLotMappings(in []localdb.VendorSpecLotMapping) []localdb.VendorSpecLotMapping {
+	if len(in) == 0 {
+		return nil
+	}
+	merged := make(map[string]int, len(in))
+	order := make([]string, 0, len(in))
+	for _, m := range in {
+		lot := strings.TrimSpace(m.LotName)
+		if lot == "" {
+			continue
+		}
+		qty := m.QuantityPerPN
+		if qty < 1 {
+			qty = 1
+		}
+		if _, exists := merged[lot]; !exists {
+			order = append(order, lot)
+		}
+		merged[lot] += qty
+	}
+	out := make([]localdb.VendorSpecLotMapping, 0, len(order))
+	for _, lot := range order {
+		out = append(out, localdb.VendorSpecLotMapping{
+			LotName:       lot,
+			QuantityPerPN: merged[lot],
+		})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+// ResolveVendorSpec resolves vendor PN → LOT without modifying the cart.
+// POST /api/configs/:uuid/vendor-spec/resolve
+func (h *VendorSpecHandler) ResolveVendorSpec(c *gin.Context) {
+	if _, err := h.lookupConfig(c.Param("uuid")); err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
+		return
+	}
+
+	var body struct {
+		VendorSpec []localdb.VendorSpecItem `json:"vendor_spec"`
+	}
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	bookRepo := repository.NewPartnumberBookRepository(h.localDB.DB())
+	resolver := services.NewVendorSpecResolver(bookRepo)
+
+	resolved, err := resolver.Resolve(body.VendorSpec)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	book, _ := bookRepo.GetActiveBook()
+	aggregated, err := services.AggregateLOTs(resolved, book, bookRepo)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"resolved":   resolved,
+		"aggregated": aggregated,
+	})
+}
+
+// ApplyVendorSpec applies the resolved BOM to the cart (Estimate items).
+// POST /api/configs/:uuid/vendor-spec/apply
+func (h *VendorSpecHandler) ApplyVendorSpec(c *gin.Context) {
+	cfg, err := h.lookupConfig(c.Param("uuid"))
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
+		return
+	}
+
+	var body struct {
+		Items []struct {
+			LotName   string  `json:"lot_name"`
+			Quantity  int     `json:"quantity"`
+			UnitPrice float64 `json:"unit_price"`
+		} `json:"items"`
+	}
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	newItems := make(localdb.LocalConfigItems, 0, len(body.Items))
+	for _, it := range body.Items {
+		newItems = append(newItems, localdb.LocalConfigItem{
+			LotName:   it.LotName,
+			Quantity:  it.Quantity,
+			UnitPrice: it.UnitPrice,
+		})
+	}
+
+	itemsJSON, err := json.Marshal(newItems)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	if err := h.localDB.DB().Model(cfg).Update("items", string(itemsJSON)).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"items": newItems})
+}

internal/handlers/web.go

@@ -2,8 +2,6 @@ package handlers
 
 import (
 	"html/template"
-	"os"
-	"path/filepath"
 	"strconv"
 
 	qfassets "git.mchus.pro/mchus/quoteforge"
@@ -17,7 +15,7 @@ type WebHandler struct {
 	componentService *services.ComponentService
 }
 
-func NewWebHandler(templatesPath string, componentService *services.ComponentService) (*WebHandler, error) {
+func NewWebHandler(_ string, componentService *services.ComponentService) (*WebHandler, error) {
 	funcMap := template.FuncMap{
 		"sub": func(a, b int) int { return a - b },
 		"add": func(a, b int) int { return a + b },
@@ -60,27 +58,16 @@ 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"}
+	simplePages := []string{"login.html", "configs.html", "projects.html", "project_detail.html", "pricelists.html", "pricelist_detail.html", "config_revisions.html", "partnumber_books.html"}
 	for _, page := range simplePages {
-		pagePath := filepath.Join(templatesPath, page)
 		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,
-			)
-		}
+		tmpl, err = template.New("").Funcs(funcMap).ParseFS(
+			qfassets.TemplatesFS,
+			"web/templates/base.html",
+			"web/templates/"+page,
+		)
 		if err != nil {
 			return nil, err
 		}
@@ -88,20 +75,14 @@ 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")
 	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",
-		)
-	}
+	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
 	}
@@ -110,17 +91,12 @@ func NewWebHandler(templatesPath string, componentService *services.ComponentSer
 	// Load partial templates (no base needed)
 	partials := []string{"components_list.html"}
 	for _, partial := range partials {
-		partialPath := filepath.Join(templatesPath, partial)
 		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,
-			)
-		}
+		tmpl, err = template.New("").Funcs(funcMap).ParseFS(
+			qfassets.TemplatesFS,
+			"web/templates/"+partial,
+		)
 		if err != nil {
 			return nil, err
 		}
@@ -147,8 +123,8 @@ func (h *WebHandler) render(c *gin.Context, name string, data gin.H) {
 }
 
 func (h *WebHandler) Index(c *gin.Context) {
-	// Redirect to configs page - configurator is accessed via /configurator?uuid=...
-	c.Redirect(302, "/configs")
+	// Redirect to projects page - configurator is accessed via /configurator?uuid=...
+	c.Redirect(302, "/projects")
 }
 
 func (h *WebHandler) Configurator(c *gin.Context) {
@@ -186,8 +162,22 @@ func (h *WebHandler) Configs(c *gin.Context) {
 	h.render(c, "configs.html", gin.H{"ActivePage": "configs"})
 }
 
-func (h *WebHandler) AdminPricing(c *gin.Context) {
-	h.render(c, "admin_pricing.html", gin.H{"ActivePage": "admin"})
+func (h *WebHandler) Projects(c *gin.Context) {
+	h.render(c, "projects.html", gin.H{"ActivePage": "projects"})
+}
+
+func (h *WebHandler) ProjectDetail(c *gin.Context) {
+	h.render(c, "project_detail.html", gin.H{
+		"ActivePage":  "projects",
+		"ProjectUUID": c.Param("uuid"),
+	})
+}
+
+func (h *WebHandler) ConfigRevisions(c *gin.Context) {
+	h.render(c, "config_revisions.html", gin.H{
+		"ActivePage": "configs",
+		"ConfigUUID": c.Param("uuid"),
+	})
 }
 
 func (h *WebHandler) Pricelists(c *gin.Context) {
@@ -198,6 +188,10 @@ func (h *WebHandler) PricelistDetail(c *gin.Context) {
 	h.render(c, "pricelist_detail.html", gin.H{"ActivePage": "pricelists"})
 }
 
+func (h *WebHandler) PartnumberBooks(c *gin.Context) {
+	h.render(c, "partnumber_books.html", gin.H{"ActivePage": "partnumber-books"})
+}
+
 // Partials for htmx
 
 func (h *WebHandler) ComponentsPartial(c *gin.Context) {

internal/localdb/components.go

@@ -28,14 +28,13 @@ type ComponentSyncResult struct {
 func (l *LocalDB) SyncComponents(mariaDB *gorm.DB) (*ComponentSyncResult, error) {
 	startTime := time.Now()
 
-	// Query to join lot with qt_lot_metadata
+	// Query to join lot with qt_lot_metadata (metadata only, no pricing)
 	// Use LEFT JOIN to include lots without metadata
 	type componentRow struct {
 		LotName        string
 		LotDescription string
 		Category       *string
 		Model          *string
-		CurrentPrice   *float64
 	}
 
 	var rows []componentRow
@@ -44,8 +43,7 @@ func (l *LocalDB) SyncComponents(mariaDB *gorm.DB) (*ComponentSyncResult, error)
 			l.lot_name,
 			l.lot_description,
 			COALESCE(c.code, SUBSTRING_INDEX(l.lot_name, '_', 1)) as category,
-			m.model,
-			m.current_price
+			m.model
 		FROM lot l
 		LEFT JOIN qt_lot_metadata m ON l.lot_name = m.lot_name
 		LEFT JOIN qt_categories c ON m.category_id = c.id
@@ -100,8 +98,6 @@ func (l *LocalDB) SyncComponents(mariaDB *gorm.DB) (*ComponentSyncResult, error)
 			LotDescription: row.LotDescription,
 			Category:       category,
 			Model:          model,
-			CurrentPrice:   row.CurrentPrice,
-			SyncedAt:       syncTime,
 		}
 		components = append(components, comp)
 
@@ -221,11 +217,6 @@ func (l *LocalDB) ListComponents(filter ComponentFilter, offset, limit int) ([]L
 		)
 	}
 
-	// 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 {
@@ -251,6 +242,31 @@ func (l *LocalDB) GetLocalComponent(lotName string) (*LocalComponent, error) {
 	return &component, nil
 }
 
+// GetLocalComponentCategoriesByLotNames returns category for each lot_name in the local component cache.
+// Missing lots are not included in the map; caller is responsible for strict validation.
+func (l *LocalDB) GetLocalComponentCategoriesByLotNames(lotNames []string) (map[string]string, error) {
+	result := make(map[string]string, len(lotNames))
+	if len(lotNames) == 0 {
+		return result, nil
+	}
+
+	type row struct {
+		LotName  string `gorm:"column:lot_name"`
+		Category string `gorm:"column:category"`
+	}
+	var rows []row
+	if err := l.db.Model(&LocalComponent{}).
+		Select("lot_name, category").
+		Where("lot_name IN ?", lotNames).
+		Find(&rows).Error; err != nil {
+		return nil, err
+	}
+	for _, r := range rows {
+		result[r.LotName] = r.Category
+	}
+	return result, nil
+}
+
 // GetLocalComponentCategories returns distinct categories from local components
 func (l *LocalDB) GetLocalComponentCategories() ([]string, error) {
 	var categories []string
@@ -311,100 +327,3 @@ 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,19 +18,32 @@ 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,
-		PriceUpdatedAt: cfg.PriceUpdatedAt,
-		CreatedAt:      cfg.CreatedAt,
-		UpdatedAt:      time.Now(),
-		SyncStatus:     "pending",
-		OriginalUserID: cfg.UserID,
+		UUID:             cfg.UUID,
+		ProjectUUID:      cfg.ProjectUUID,
+		IsActive:         true,
+		Name:             cfg.Name,
+		Items:            items,
+		TotalPrice:       cfg.TotalPrice,
+		CustomPrice:      cfg.CustomPrice,
+		Notes:            cfg.Notes,
+		IsTemplate:       cfg.IsTemplate,
+		ServerCount:      cfg.ServerCount,
+		ServerModel:      cfg.ServerModel,
+		SupportCode:      cfg.SupportCode,
+		Article:          cfg.Article,
+		PricelistID:      cfg.PricelistID,
+		OnlyInStock:      cfg.OnlyInStock,
+		Line:             cfg.Line,
+		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 {
@@ -54,7 +67,8 @@ func LocalToConfiguration(local *LocalConfiguration) *models.Configuration {
 
 	cfg := &models.Configuration{
 		UUID:           local.UUID,
-		UserID:         local.OriginalUserID,
+		OwnerUsername:  local.OriginalUsername,
+		ProjectUUID:    local.ProjectUUID,
 		Name:           local.Name,
 		Items:          items,
 		TotalPrice:     local.TotalPrice,
@@ -62,6 +76,12 @@ func LocalToConfiguration(local *LocalConfiguration) *models.Configuration {
 		Notes:          local.Notes,
 		IsTemplate:     local.IsTemplate,
 		ServerCount:    local.ServerCount,
+		ServerModel:    local.ServerModel,
+		SupportCode:    local.SupportCode,
+		Article:        local.Article,
+		PricelistID:    local.PricelistID,
+		OnlyInStock:    local.OnlyInStock,
+		Line:           local.Line,
 		PriceUpdatedAt: local.PriceUpdatedAt,
 		CreatedAt:      local.CreatedAt,
 	}
@@ -69,10 +89,64 @@ func LocalToConfiguration(local *LocalConfiguration) *models.Configuration {
 	if local.ServerID != nil {
 		cfg.ID = *local.ServerID
 	}
+	if local.OriginalUserID != 0 {
+		userID := local.OriginalUserID
+		cfg.UserID = &userID
+	}
+	if local.CurrentVersion != nil {
+		cfg.CurrentVersionNo = local.CurrentVersion.VersionNo
+	}
 
 	return cfg
 }
 
+func derefUint(v *uint) uint {
+	if v == nil {
+		return 0
+	}
+	return *v
+}
+
+func ProjectToLocal(project *models.Project) *LocalProject {
+	local := &LocalProject{
+		UUID:          project.UUID,
+		OwnerUsername: project.OwnerUsername,
+		Code:          project.Code,
+		Variant:       project.Variant,
+		Name:          project.Name,
+		TrackerURL:    project.TrackerURL,
+		IsActive:      project.IsActive,
+		IsSystem:      project.IsSystem,
+		CreatedAt:     project.CreatedAt,
+		UpdatedAt:     project.UpdatedAt,
+		SyncStatus:    "pending",
+	}
+	if project.ID > 0 {
+		serverID := project.ID
+		local.ServerID = &serverID
+	}
+	return local
+}
+
+func LocalToProject(local *LocalProject) *models.Project {
+	project := &models.Project{
+		UUID:          local.UUID,
+		OwnerUsername: local.OwnerUsername,
+		Code:          local.Code,
+		Variant:       local.Variant,
+		Name:          local.Name,
+		TrackerURL:    local.TrackerURL,
+		IsActive:      local.IsActive,
+		IsSystem:      local.IsSystem,
+		CreatedAt:     local.CreatedAt,
+		UpdatedAt:     local.UpdatedAt,
+	}
+	if local.ServerID != nil {
+		project.ID = *local.ServerID
+	}
+	return project
+}
+
 // PricelistToLocal converts models.Pricelist to LocalPricelist
 func PricelistToLocal(pl *models.Pricelist) *LocalPricelist {
 	name := pl.Notification
@@ -82,6 +156,7 @@ func PricelistToLocal(pl *models.Pricelist) *LocalPricelist {
 
 	return &LocalPricelist{
 		ServerID:  pl.ID,
+		Source:    pl.Source,
 		Version:   pl.Version,
 		Name:      name,
 		CreatedAt: pl.CreatedAt,
@@ -94,6 +169,7 @@ func PricelistToLocal(pl *models.Pricelist) *LocalPricelist {
 func LocalToPricelist(local *LocalPricelist) *models.Pricelist {
 	return &models.Pricelist{
 		ID:           local.ServerID,
+		Source:       local.Source,
 		Version:      local.Version,
 		Notification: local.Name,
 		CreatedAt:    local.CreatedAt,
@@ -103,20 +179,30 @@ func LocalToPricelist(local *LocalPricelist) *models.Pricelist {
 
 // PricelistItemToLocal converts models.PricelistItem to LocalPricelistItem
 func PricelistItemToLocal(item *models.PricelistItem, localPricelistID uint) *LocalPricelistItem {
+	partnumbers := make(LocalStringList, 0, len(item.Partnumbers))
+	partnumbers = append(partnumbers, item.Partnumbers...)
 	return &LocalPricelistItem{
-		PricelistID: localPricelistID,
-		LotName:     item.LotName,
-		Price:       item.Price,
+		PricelistID:  localPricelistID,
+		LotName:      item.LotName,
+		LotCategory:  item.LotCategory,
+		Price:        item.Price,
+		AvailableQty: item.AvailableQty,
+		Partnumbers:  partnumbers,
 	}
 }
 
 // LocalToPricelistItem converts LocalPricelistItem to models.PricelistItem
 func LocalToPricelistItem(local *LocalPricelistItem, serverPricelistID uint) *models.PricelistItem {
+	partnumbers := make([]string, 0, len(local.Partnumbers))
+	partnumbers = append(partnumbers, local.Partnumbers...)
 	return &models.PricelistItem{
-		ID:          local.ID,
-		PricelistID: serverPricelistID,
-		LotName:     local.LotName,
-		Price:       local.Price,
+		ID:           local.ID,
+		PricelistID:  serverPricelistID,
+		LotName:      local.LotName,
+		LotCategory:  local.LotCategory,
+		Price:        local.Price,
+		AvailableQty: local.AvailableQty,
+		Partnumbers:  partnumbers,
 	}
 }
 
@@ -144,17 +230,14 @@ func ComponentToLocal(meta *models.LotMetadata) *LocalComponent {
 		LotDescription: lotDesc,
 		Category:       category,
 		Model:          meta.Model,
-		CurrentPrice:   meta.CurrentPrice,
-		SyncedAt:       time.Now(),
 	}
 }
 
 // LocalToComponent converts LocalComponent to models.LotMetadata
 func LocalToComponent(local *LocalComponent) *models.LotMetadata {
 	return &models.LotMetadata{
-		LotName:      local.LotName,
-		Model:        local.Model,
-		CurrentPrice: local.CurrentPrice,
+		LotName: local.LotName,
+		Model:   local.Model,
 		Lot: &models.Lot{
 			LotName:        local.LotName,
 			LotDescription: local.LotDescription,

internal/localdb/converters_test.go

@@ -0,0 +1,34 @@
+package localdb
+
+import (
+	"testing"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+)
+
+func TestPricelistItemToLocal_PreservesLotCategory(t *testing.T) {
+	item := &models.PricelistItem{
+		LotName:     "CPU_A",
+		LotCategory: "CPU",
+		Price:       10,
+	}
+
+	local := PricelistItemToLocal(item, 123)
+	if local.LotCategory != "CPU" {
+		t.Fatalf("expected LotCategory=CPU, got %q", local.LotCategory)
+	}
+}
+
+func TestLocalToPricelistItem_PreservesLotCategory(t *testing.T) {
+	local := &LocalPricelistItem{
+		LotName:     "CPU_A",
+		LotCategory: "CPU",
+		Price:       10,
+	}
+
+	item := LocalToPricelistItem(local, 456)
+	if item.LotCategory != "CPU" {
+		t.Fatalf("expected LotCategory=CPU, got %q", item.LotCategory)
+	}
+}
+

internal/localdb/local_migrations_test.go

@@ -0,0 +1,315 @@
+package localdb
+
+import (
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+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")
+	}
+}
+
+func TestRunLocalMigrationsFixesPricelistVersionUniqueIndex(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "pricelist_index_fix.db")
+
+	local, err := New(dbPath)
+	if err != nil {
+		t.Fatalf("open localdb: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	if err := local.SaveLocalPricelist(&LocalPricelist{
+		ServerID:  10,
+		Version:   "2026-02-06-001",
+		Name:      "v1",
+		CreatedAt: time.Now().Add(-time.Hour),
+		SyncedAt:  time.Now().Add(-time.Hour),
+	}); err != nil {
+		t.Fatalf("save first pricelist: %v", err)
+	}
+
+	if err := local.DB().Exec(`
+		CREATE UNIQUE INDEX IF NOT EXISTS idx_local_pricelists_version_legacy
+		ON local_pricelists(version)
+	`).Error; err != nil {
+		t.Fatalf("create legacy unique version index: %v", err)
+	}
+
+	if err := local.DB().Where("id = ?", "2026_02_06_pricelist_index_fix").
+		Delete(&LocalSchemaMigration{}).Error; err != nil {
+		t.Fatalf("delete migration record: %v", err)
+	}
+
+	if err := runLocalMigrations(local.DB()); err != nil {
+		t.Fatalf("rerun local migrations: %v", err)
+	}
+
+	if err := local.SaveLocalPricelist(&LocalPricelist{
+		ServerID:  11,
+		Version:   "2026-02-06-001",
+		Name:      "v1-duplicate-version",
+		CreatedAt: time.Now(),
+		SyncedAt:  time.Now(),
+	}); err != nil {
+		t.Fatalf("save second pricelist with duplicate version: %v", err)
+	}
+
+	var count int64
+	if err := local.DB().Model(&LocalPricelist{}).Count(&count).Error; err != nil {
+		t.Fatalf("count pricelists: %v", err)
+	}
+	if count != 2 {
+		t.Fatalf("expected 2 pricelists, got %d", count)
+	}
+}
+
+func TestRunLocalMigrationsDeduplicatesConfigurationVersionsBySpecAndPrice(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "versions_dedup.db")
+
+	local, err := New(dbPath)
+	if err != nil {
+		t.Fatalf("open localdb: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	cfg := &LocalConfiguration{
+		UUID:             "dedup-cfg",
+		Name:             "Dedup",
+		Items:            LocalConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 100}},
+		ServerCount:      1,
+		SyncStatus:       "pending",
+		OriginalUsername: "tester",
+		IsActive:         true,
+	}
+	if err := local.SaveConfiguration(cfg); err != nil {
+		t.Fatalf("save seed config: %v", err)
+	}
+
+	baseV1Data, err := BuildConfigurationSnapshot(cfg)
+	if err != nil {
+		t.Fatalf("build v1 snapshot: %v", err)
+	}
+	baseV1 := LocalConfigurationVersion{
+		ID:                uuid.NewString(),
+		ConfigurationUUID: cfg.UUID,
+		VersionNo:         1,
+		Data:              baseV1Data,
+		AppVersion:        "test",
+		CreatedAt:         time.Now(),
+	}
+	if err := local.DB().Create(&baseV1).Error; err != nil {
+		t.Fatalf("insert base v1: %v", err)
+	}
+	if err := local.DB().Model(&LocalConfiguration{}).
+		Where("uuid = ?", cfg.UUID).
+		Update("current_version_id", baseV1.ID).Error; err != nil {
+		t.Fatalf("set current_version_id to v1: %v", err)
+	}
+
+	v2 := LocalConfigurationVersion{
+		ID:                uuid.NewString(),
+		ConfigurationUUID: cfg.UUID,
+		VersionNo:         2,
+		Data:              baseV1.Data,
+		AppVersion:        "test",
+		CreatedAt:         time.Now().Add(1 * time.Second),
+	}
+	if err := local.DB().Create(&v2).Error; err != nil {
+		t.Fatalf("insert duplicate v2: %v", err)
+	}
+
+	modified := *cfg
+	modified.Items = LocalConfigItems{{LotName: "CPU_A", Quantity: 2, UnitPrice: 100}}
+	total := modified.Items.Total()
+	modified.TotalPrice = &total
+	modified.UpdatedAt = time.Now()
+	v3Data, err := BuildConfigurationSnapshot(&modified)
+	if err != nil {
+		t.Fatalf("build v3 snapshot: %v", err)
+	}
+
+	v3 := LocalConfigurationVersion{
+		ID:                uuid.NewString(),
+		ConfigurationUUID: cfg.UUID,
+		VersionNo:         3,
+		Data:              v3Data,
+		AppVersion:        "test",
+		CreatedAt:         time.Now().Add(2 * time.Second),
+	}
+	if err := local.DB().Create(&v3).Error; err != nil {
+		t.Fatalf("insert v3: %v", err)
+	}
+
+	v4 := LocalConfigurationVersion{
+		ID:                uuid.NewString(),
+		ConfigurationUUID: cfg.UUID,
+		VersionNo:         4,
+		Data:              v3Data,
+		AppVersion:        "test",
+		CreatedAt:         time.Now().Add(3 * time.Second),
+	}
+	if err := local.DB().Create(&v4).Error; err != nil {
+		t.Fatalf("insert duplicate v4: %v", err)
+	}
+
+	if err := local.DB().Model(&LocalConfiguration{}).
+		Where("uuid = ?", cfg.UUID).
+		Update("current_version_id", v4.ID).Error; err != nil {
+		t.Fatalf("point current_version_id to duplicate v4: %v", err)
+	}
+
+	if err := local.DB().Where("id = ?", "2026_02_19_configuration_versions_dedup_spec_price").
+		Delete(&LocalSchemaMigration{}).Error; err != nil {
+		t.Fatalf("delete dedup migration record: %v", err)
+	}
+
+	if err := runLocalMigrations(local.DB()); err != nil {
+		t.Fatalf("rerun local migrations: %v", err)
+	}
+
+	var versions []LocalConfigurationVersion
+	if err := local.DB().Where("configuration_uuid = ?", cfg.UUID).
+		Order("version_no ASC").
+		Find(&versions).Error; err != nil {
+		t.Fatalf("load versions after dedup: %v", err)
+	}
+	if len(versions) != 2 {
+		t.Fatalf("expected 2 versions after dedup, got %d", len(versions))
+	}
+	if versions[0].VersionNo != 1 || versions[1].VersionNo != 3 {
+		t.Fatalf("expected kept version numbers [1,3], got [%d,%d]", versions[0].VersionNo, versions[1].VersionNo)
+	}
+
+	var after LocalConfiguration
+	if err := local.DB().Where("uuid = ?", cfg.UUID).First(&after).Error; err != nil {
+		t.Fatalf("load config after dedup: %v", err)
+	}
+	if after.CurrentVersionID == nil || *after.CurrentVersionID != v3.ID {
+		t.Fatalf("expected current_version_id to point to kept latest version v3")
+	}
+}
+
+func TestRunLocalMigrationsBackfillsConfigurationLineNo(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "line_no_backfill.db")
+
+	local, err := New(dbPath)
+	if err != nil {
+		t.Fatalf("open localdb: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	projectUUID := "project-line"
+	cfg1 := &LocalConfiguration{
+		UUID:             "line-cfg-1",
+		ProjectUUID:      &projectUUID,
+		Name:             "Cfg 1",
+		Items:            LocalConfigItems{},
+		SyncStatus:       "pending",
+		OriginalUsername: "tester",
+		IsActive:         true,
+		CreatedAt:        time.Now().Add(-2 * time.Hour),
+	}
+	cfg2 := &LocalConfiguration{
+		UUID:             "line-cfg-2",
+		ProjectUUID:      &projectUUID,
+		Name:             "Cfg 2",
+		Items:            LocalConfigItems{},
+		SyncStatus:       "pending",
+		OriginalUsername: "tester",
+		IsActive:         true,
+		CreatedAt:        time.Now().Add(-1 * time.Hour),
+	}
+	if err := local.SaveConfiguration(cfg1); err != nil {
+		t.Fatalf("save cfg1: %v", err)
+	}
+	if err := local.SaveConfiguration(cfg2); err != nil {
+		t.Fatalf("save cfg2: %v", err)
+	}
+
+	if err := local.DB().Model(&LocalConfiguration{}).Where("uuid IN ?", []string{cfg1.UUID, cfg2.UUID}).Update("line_no", 0).Error; err != nil {
+		t.Fatalf("reset line_no: %v", err)
+	}
+	if err := local.DB().Where("id = ?", "2026_02_19_local_config_line_no").Delete(&LocalSchemaMigration{}).Error; err != nil {
+		t.Fatalf("delete migration record: %v", err)
+	}
+
+	if err := runLocalMigrations(local.DB()); err != nil {
+		t.Fatalf("rerun local migrations: %v", err)
+	}
+
+	var rows []LocalConfiguration
+	if err := local.DB().Where("uuid IN ?", []string{cfg1.UUID, cfg2.UUID}).Order("created_at ASC").Find(&rows).Error; err != nil {
+		t.Fatalf("load configurations: %v", err)
+	}
+	if len(rows) != 2 {
+		t.Fatalf("expected 2 configurations, got %d", len(rows))
+	}
+	if rows[0].Line != 10 || rows[1].Line != 20 {
+		t.Fatalf("expected line_no [10,20], got [%d,%d]", rows[0].Line, rows[1].Line)
+	}
+}

internal/localdb/migration_projects_test.go

@@ -0,0 +1,60 @@
+package localdb
+
+import (
+	"path/filepath"
+	"testing"
+)
+
+func TestRunLocalMigrationsBackfillsDefaultProject(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "projects_backfill.db")
+
+	local, err := New(dbPath)
+	if err != nil {
+		t.Fatalf("open localdb: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	cfg := &LocalConfiguration{
+		UUID:             "cfg-without-project",
+		Name:             "Cfg no project",
+		Items:            LocalConfigItems{},
+		SyncStatus:       "pending",
+		OriginalUsername: "tester",
+		IsActive:         true,
+	}
+	if err := local.SaveConfiguration(cfg); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+	if err := local.DB().
+		Model(&LocalConfiguration{}).
+		Where("uuid = ?", cfg.UUID).
+		Update("project_uuid", nil).Error; err != nil {
+		t.Fatalf("clear project_uuid: %v", err)
+	}
+	if err := local.DB().Where("id = ?", "2026_02_06_projects_backfill").Delete(&LocalSchemaMigration{}).Error; err != nil {
+		t.Fatalf("delete local migration record: %v", err)
+	}
+
+	if err := runLocalMigrations(local.DB()); err != nil {
+		t.Fatalf("run local migrations: %v", err)
+	}
+
+	updated, err := local.GetConfigurationByUUID(cfg.UUID)
+	if err != nil {
+		t.Fatalf("get updated config: %v", err)
+	}
+	if updated.ProjectUUID == nil || *updated.ProjectUUID == "" {
+		t.Fatalf("expected project_uuid to be backfilled")
+	}
+
+	project, err := local.GetProjectByUUID(*updated.ProjectUUID)
+	if err != nil {
+		t.Fatalf("get system project: %v", err)
+	}
+	if project.Name == nil || *project.Name != "Без проекта" {
+		t.Fatalf("expected system project name, got %v", project.Name)
+	}
+	if !project.IsSystem {
+		t.Fatalf("expected system project flag")
+	}
+}

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,867 @@
+package localdb
+
+import (
+	"errors"
+	"fmt"
+	"log/slog"
+	"strings"
+	"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,
+	},
+	{
+		id:   "2026_02_06_projects_backfill",
+		name: "Create default projects and attach existing configurations",
+		run:  backfillProjectsForConfigurations,
+	},
+	{
+		id:   "2026_02_06_pricelist_backfill",
+		name: "Attach existing configurations to latest local pricelist and recalc usage",
+		run:  backfillConfigurationPricelists,
+	},
+	{
+		id:   "2026_02_06_pricelist_index_fix",
+		name: "Use unique server_id for local pricelists and allow duplicate versions",
+		run:  fixLocalPricelistIndexes,
+	},
+	{
+		id:   "2026_02_06_pricelist_source",
+		name: "Backfill source for local pricelists and create source indexes",
+		run:  backfillLocalPricelistSource,
+	},
+	{
+		id:   "2026_02_09_drop_component_unused_fields",
+		name: "Remove current_price and synced_at from local_components (unused fields)",
+		run:  dropComponentUnusedFields,
+	},
+	{
+		id:   "2026_02_09_add_warehouse_competitor_pricelists",
+		name: "Add warehouse_pricelist_id and competitor_pricelist_id to local_configurations",
+		run:  addWarehouseCompetitorPriceLists,
+	},
+	{
+		id:   "2026_02_11_local_pricelist_item_category",
+		name: "Add lot_category to local_pricelist_items and create indexes",
+		run:  addLocalPricelistItemCategoryAndIndexes,
+	},
+	{
+		id:   "2026_02_11_local_config_article",
+		name: "Add article to local_configurations",
+		run:  addLocalConfigurationArticle,
+	},
+	{
+		id:   "2026_02_11_local_config_server_model",
+		name: "Add server_model to local_configurations",
+		run:  addLocalConfigurationServerModel,
+	},
+	{
+		id:   "2026_02_11_local_config_support_code",
+		name: "Add support_code to local_configurations",
+		run:  addLocalConfigurationSupportCode,
+	},
+	{
+		id:   "2026_02_13_local_project_code",
+		name: "Add project code to local_projects and backfill",
+		run:  addLocalProjectCode,
+	},
+	{
+		id:   "2026_02_13_local_project_variant",
+		name: "Add project variant to local_projects and backfill",
+		run:  addLocalProjectVariant,
+	},
+	{
+		id:   "2026_02_13_local_project_name_nullable",
+		name: "Allow NULL project names in local_projects",
+		run:  allowLocalProjectNameNull,
+	},
+	{
+		id:   "2026_02_19_configuration_versions_dedup_spec_price",
+		name: "Deduplicate configuration revisions by spec+price",
+		run:  deduplicateConfigurationVersionsBySpecAndPrice,
+	},
+	{
+		id:   "2026_02_19_local_config_line_no",
+		name: "Add line_no to local_configurations and backfill ordering",
+		run:  addLocalConfigurationLineNo,
+	},
+}
+
+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 backfillProjectsForConfigurations(tx *gorm.DB) error {
+	var owners []string
+	if err := tx.Model(&LocalConfiguration{}).
+		Distinct("original_username").
+		Pluck("original_username", &owners).Error; err != nil {
+		return fmt.Errorf("load owners for projects backfill: %w", err)
+	}
+
+	for _, owner := range owners {
+		project, err := ensureDefaultProjectTx(tx, owner)
+		if err != nil {
+			return err
+		}
+
+		if err := tx.Model(&LocalConfiguration{}).
+			Where("original_username = ? AND (project_uuid IS NULL OR project_uuid = '')", owner).
+			Update("project_uuid", project.UUID).Error; err != nil {
+			return fmt.Errorf("assign default project for owner %s: %w", owner, err)
+		}
+	}
+
+	return nil
+}
+
+func ensureDefaultProjectTx(tx *gorm.DB, ownerUsername string) (*LocalProject, error) {
+	var project LocalProject
+	err := tx.Where("owner_username = ? AND is_system = ? AND name = ?", ownerUsername, true, "Без проекта").
+		First(&project).Error
+	if err == nil {
+		return &project, nil
+	}
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, fmt.Errorf("load system project for %s: %w", ownerUsername, err)
+	}
+
+	now := time.Now()
+	project = LocalProject{
+		UUID:          uuid.NewString(),
+		OwnerUsername: ownerUsername,
+		Code:          "Без проекта",
+		Name:          ptrString("Без проекта"),
+		IsActive:      true,
+		IsSystem:      true,
+		CreatedAt:     now,
+		UpdatedAt:     now,
+		SyncStatus:    "pending",
+	}
+	if err := tx.Create(&project).Error; err != nil {
+		return nil, fmt.Errorf("create system project for %s: %w", ownerUsername, err)
+	}
+
+	return &project, nil
+}
+
+func addLocalProjectCode(tx *gorm.DB) error {
+	if err := tx.Exec(`ALTER TABLE local_projects ADD COLUMN code TEXT`).Error; err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "duplicate") &&
+			!strings.Contains(strings.ToLower(err.Error()), "exists") {
+			return err
+		}
+	}
+
+	// Drop unique index if it already exists to allow de-duplication updates.
+	if err := tx.Exec(`DROP INDEX IF EXISTS idx_local_projects_code`).Error; err != nil {
+		return err
+	}
+
+	// Copy code from current project name.
+	if err := tx.Exec(`
+UPDATE local_projects
+SET code = TRIM(COALESCE(name, ''))`).Error; err != nil {
+		return err
+	}
+
+	// Ensure any remaining blanks have a unique fallback.
+	if err := tx.Exec(`
+UPDATE local_projects
+SET code = 'P-' || uuid
+WHERE code IS NULL OR TRIM(code) = ''`).Error; err != nil {
+		return err
+	}
+
+	// De-duplicate codes: OPS-1948-2, OPS-1948-3...
+	if err := tx.Exec(`
+WITH ranked AS (
+	SELECT id, code,
+	       ROW_NUMBER() OVER (PARTITION BY code ORDER BY id) AS rn
+	FROM local_projects
+)
+UPDATE local_projects
+SET code = code || '-' || (SELECT rn FROM ranked WHERE ranked.id = local_projects.id)
+WHERE id IN (SELECT id FROM ranked WHERE rn > 1)`).Error; err != nil {
+		return err
+	}
+
+	// Create unique index for project codes (ignore if exists).
+	if err := tx.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_local_projects_code ON local_projects(code)`).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func addLocalProjectVariant(tx *gorm.DB) error {
+	if err := tx.Exec(`ALTER TABLE local_projects ADD COLUMN variant TEXT NOT NULL DEFAULT ''`).Error; err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "duplicate") &&
+			!strings.Contains(strings.ToLower(err.Error()), "exists") {
+			return err
+		}
+	}
+
+	// Drop legacy code index if present.
+	if err := tx.Exec(`DROP INDEX IF EXISTS idx_local_projects_code`).Error; err != nil {
+		return err
+	}
+
+	// Reset code from name and clear variant.
+	if err := tx.Exec(`
+UPDATE local_projects
+SET code = TRIM(COALESCE(name, '')),
+    variant = ''`).Error; err != nil {
+		return err
+	}
+
+	// De-duplicate by assigning variant numbers: 2,3...
+	if err := tx.Exec(`
+WITH ranked AS (
+	SELECT id, code,
+	       ROW_NUMBER() OVER (PARTITION BY code ORDER BY id) AS rn
+	FROM local_projects
+)
+UPDATE local_projects
+SET variant = CASE
+	WHEN (SELECT rn FROM ranked WHERE ranked.id = local_projects.id) = 1 THEN ''
+	ELSE '-' || CAST((SELECT rn FROM ranked WHERE ranked.id = local_projects.id) AS TEXT)
+END`).Error; err != nil {
+		return err
+	}
+
+	if err := tx.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_local_projects_code_variant ON local_projects(code, variant)`).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func allowLocalProjectNameNull(tx *gorm.DB) error {
+	if err := tx.Exec(`ALTER TABLE local_projects RENAME TO local_projects_old`).Error; err != nil {
+		return err
+	}
+
+	if err := tx.Exec(`
+CREATE TABLE local_projects (
+	id INTEGER PRIMARY KEY AUTOINCREMENT,
+	uuid TEXT NOT NULL UNIQUE,
+	server_id INTEGER NULL,
+	owner_username TEXT NOT NULL,
+	code TEXT NOT NULL,
+	variant TEXT NOT NULL DEFAULT '',
+	name TEXT NULL,
+	tracker_url TEXT NULL,
+	is_active INTEGER NOT NULL DEFAULT 1,
+	is_system INTEGER NOT NULL DEFAULT 0,
+	created_at DATETIME,
+	updated_at DATETIME,
+	synced_at DATETIME NULL,
+	sync_status TEXT DEFAULT 'local'
+)`).Error; err != nil {
+		return err
+	}
+
+	_ = tx.Exec(`CREATE INDEX IF NOT EXISTS idx_local_projects_owner_username ON local_projects(owner_username)`).Error
+	_ = tx.Exec(`CREATE INDEX IF NOT EXISTS idx_local_projects_is_active ON local_projects(is_active)`).Error
+	_ = tx.Exec(`CREATE INDEX IF NOT EXISTS idx_local_projects_is_system ON local_projects(is_system)`).Error
+	_ = tx.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_local_projects_code_variant ON local_projects(code, variant)`).Error
+
+	if err := tx.Exec(`
+INSERT INTO local_projects (id, uuid, server_id, owner_username, code, variant, name, tracker_url, is_active, is_system, created_at, updated_at, synced_at, sync_status)
+SELECT id, uuid, server_id, owner_username, code, variant, name, tracker_url, is_active, is_system, created_at, updated_at, synced_at, sync_status
+FROM local_projects_old`).Error; err != nil {
+		return err
+	}
+
+	_ = tx.Exec(`DROP TABLE local_projects_old`).Error
+	return nil
+}
+
+func backfillConfigurationPricelists(tx *gorm.DB) error {
+	var latest LocalPricelist
+	if err := tx.Where("source = ?", "estimate").Order("created_at DESC").First(&latest).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil
+		}
+		return fmt.Errorf("load latest local pricelist: %w", err)
+	}
+
+	if err := tx.Model(&LocalConfiguration{}).
+		Where("pricelist_id IS NULL").
+		Update("pricelist_id", latest.ServerID).Error; err != nil {
+		return fmt.Errorf("backfill configuration pricelist_id: %w", err)
+	}
+
+	if err := tx.Model(&LocalPricelist{}).Where("1 = 1").Update("is_used", false).Error; err != nil {
+		return fmt.Errorf("reset local pricelist usage flags: %w", err)
+	}
+
+	if err := tx.Exec(`
+		UPDATE local_pricelists
+		SET is_used = 1
+		WHERE server_id IN (
+			SELECT DISTINCT pricelist_id
+			FROM local_configurations
+			WHERE pricelist_id IS NOT NULL AND is_active = 1
+		)
+	`).Error; err != nil {
+		return fmt.Errorf("recalculate local pricelist usage flags: %w", err)
+	}
+
+	return nil
+}
+
+func chooseNonZeroTime(candidate time.Time, fallback time.Time) time.Time {
+	if candidate.IsZero() {
+		return fallback
+	}
+	return candidate
+}
+
+func deduplicateConfigurationVersionsBySpecAndPrice(tx *gorm.DB) error {
+	var configs []LocalConfiguration
+	if err := tx.Select("uuid", "current_version_id").Find(&configs).Error; err != nil {
+		return fmt.Errorf("load configurations for revision deduplication: %w", err)
+	}
+
+	var removedTotal int
+	for i := range configs {
+		cfg := configs[i]
+
+		var versions []LocalConfigurationVersion
+		if err := tx.Where("configuration_uuid = ?", cfg.UUID).
+			Order("version_no ASC, created_at ASC").
+			Find(&versions).Error; err != nil {
+			return fmt.Errorf("load versions for %s: %w", cfg.UUID, err)
+		}
+		if len(versions) < 2 {
+			continue
+		}
+
+		deleteIDs := make([]string, 0)
+		deleteSet := make(map[string]struct{})
+		kept := make([]LocalConfigurationVersion, 0, len(versions))
+		var prevKey string
+		hasPrev := false
+
+		for _, version := range versions {
+			snapshotCfg, err := DecodeConfigurationSnapshot(version.Data)
+			if err != nil {
+				// Keep malformed snapshots untouched and reset chain to avoid accidental removals.
+				kept = append(kept, version)
+				hasPrev = false
+				continue
+			}
+
+			key, err := BuildConfigurationSpecPriceFingerprint(snapshotCfg)
+			if err != nil {
+				kept = append(kept, version)
+				hasPrev = false
+				continue
+			}
+
+			if !hasPrev || key != prevKey {
+				kept = append(kept, version)
+				prevKey = key
+				hasPrev = true
+				continue
+			}
+
+			deleteIDs = append(deleteIDs, version.ID)
+			deleteSet[version.ID] = struct{}{}
+		}
+
+		if len(deleteIDs) == 0 {
+			continue
+		}
+
+		if err := tx.Where("id IN ?", deleteIDs).Delete(&LocalConfigurationVersion{}).Error; err != nil {
+			return fmt.Errorf("delete duplicate versions for %s: %w", cfg.UUID, err)
+		}
+		removedTotal += len(deleteIDs)
+
+		latestKeptID := kept[len(kept)-1].ID
+		if cfg.CurrentVersionID == nil || *cfg.CurrentVersionID == "" {
+			if err := tx.Model(&LocalConfiguration{}).
+				Where("uuid = ?", cfg.UUID).
+				Update("current_version_id", latestKeptID).Error; err != nil {
+				return fmt.Errorf("set missing current_version_id for %s: %w", cfg.UUID, err)
+			}
+			continue
+		}
+
+		if _, deleted := deleteSet[*cfg.CurrentVersionID]; deleted {
+			if err := tx.Model(&LocalConfiguration{}).
+				Where("uuid = ?", cfg.UUID).
+				Update("current_version_id", latestKeptID).Error; err != nil {
+				return fmt.Errorf("repair current_version_id for %s: %w", cfg.UUID, err)
+			}
+		}
+	}
+
+	if removedTotal > 0 {
+		slog.Info("deduplicated configuration revisions", "removed_versions", removedTotal)
+	}
+	return nil
+}
+
+func fixLocalPricelistIndexes(tx *gorm.DB) error {
+	type indexRow struct {
+		Name   string `gorm:"column:name"`
+		Unique int    `gorm:"column:unique"`
+	}
+	var indexes []indexRow
+	if err := tx.Raw("PRAGMA index_list('local_pricelists')").Scan(&indexes).Error; err != nil {
+		return fmt.Errorf("list local_pricelists indexes: %w", err)
+	}
+
+	for _, idx := range indexes {
+		if idx.Unique == 0 {
+			continue
+		}
+
+		type indexInfoRow struct {
+			Name string `gorm:"column:name"`
+		}
+		var info []indexInfoRow
+		if err := tx.Raw(fmt.Sprintf("PRAGMA index_info('%s')", strings.ReplaceAll(idx.Name, "'", "''"))).Scan(&info).Error; err != nil {
+			return fmt.Errorf("load index info for %s: %w", idx.Name, err)
+		}
+		if len(info) != 1 || info[0].Name != "version" {
+			continue
+		}
+
+		quoted := strings.ReplaceAll(idx.Name, `"`, `""`)
+		if err := tx.Exec(fmt.Sprintf(`DROP INDEX IF EXISTS "%s"`, quoted)).Error; err != nil {
+			return fmt.Errorf("drop unique version index %s: %w", idx.Name, err)
+		}
+	}
+
+	if err := tx.Exec(`
+		CREATE UNIQUE INDEX IF NOT EXISTS idx_local_pricelists_server_id
+		ON local_pricelists(server_id)
+	`).Error; err != nil {
+		return fmt.Errorf("ensure unique index local_pricelists(server_id): %w", err)
+	}
+
+	if err := tx.Exec(`
+		CREATE INDEX IF NOT EXISTS idx_local_pricelists_version
+		ON local_pricelists(version)
+	`).Error; err != nil {
+		return fmt.Errorf("ensure index local_pricelists(version): %w", err)
+	}
+
+	return nil
+}
+
+func backfillLocalPricelistSource(tx *gorm.DB) error {
+	if err := tx.Exec(`
+		UPDATE local_pricelists
+		SET source = 'estimate'
+		WHERE source IS NULL OR source = ''
+	`).Error; err != nil {
+		return fmt.Errorf("backfill local_pricelists.source: %w", err)
+	}
+
+	if err := tx.Exec(`
+		CREATE INDEX IF NOT EXISTS idx_local_pricelists_source_created_at
+		ON local_pricelists(source, created_at DESC)
+	`).Error; err != nil {
+		return fmt.Errorf("ensure idx_local_pricelists_source_created_at: %w", err)
+	}
+
+	return nil
+}
+
+func dropComponentUnusedFields(tx *gorm.DB) error {
+	// Check if columns exist
+	type columnInfo struct {
+		Name string `gorm:"column:name"`
+	}
+
+	var columns []columnInfo
+	if err := tx.Raw(`
+		SELECT name FROM pragma_table_info('local_components')
+		WHERE name IN ('current_price', 'synced_at')
+	`).Scan(&columns).Error; err != nil {
+		return fmt.Errorf("check columns existence: %w", err)
+	}
+
+	if len(columns) == 0 {
+		slog.Info("unused fields already removed from local_components")
+		return nil
+	}
+
+	// SQLite: recreate table without current_price and synced_at
+	if err := tx.Exec(`
+		CREATE TABLE local_components_new (
+			lot_name TEXT PRIMARY KEY,
+			lot_description TEXT,
+			category TEXT,
+			model TEXT
+		)
+	`).Error; err != nil {
+		return fmt.Errorf("create new local_components table: %w", err)
+	}
+
+	if err := tx.Exec(`
+		INSERT INTO local_components_new (lot_name, lot_description, category, model)
+		SELECT lot_name, lot_description, category, model
+		FROM local_components
+	`).Error; err != nil {
+		return fmt.Errorf("copy data to new table: %w", err)
+	}
+
+	if err := tx.Exec(`DROP TABLE local_components`).Error; err != nil {
+		return fmt.Errorf("drop old table: %w", err)
+	}
+
+	if err := tx.Exec(`ALTER TABLE local_components_new RENAME TO local_components`).Error; err != nil {
+		return fmt.Errorf("rename new table: %w", err)
+	}
+
+	slog.Info("dropped current_price and synced_at columns from local_components")
+	return nil
+}
+
+func addWarehouseCompetitorPriceLists(tx *gorm.DB) error {
+	// Check if columns exist
+	type columnInfo struct {
+		Name string `gorm:"column:name"`
+	}
+
+	var columns []columnInfo
+	if err := tx.Raw(`
+		SELECT name FROM pragma_table_info('local_configurations')
+		WHERE name IN ('warehouse_pricelist_id', 'competitor_pricelist_id')
+	`).Scan(&columns).Error; err != nil {
+		return fmt.Errorf("check columns existence: %w", err)
+	}
+
+	if len(columns) == 2 {
+		slog.Info("warehouse and competitor pricelist columns already exist")
+		return nil
+	}
+
+	// Add columns if they don't exist
+	if err := tx.Exec(`
+		ALTER TABLE local_configurations
+		ADD COLUMN warehouse_pricelist_id INTEGER
+	`).Error; err != nil {
+		// Column might already exist, ignore
+		if !strings.Contains(err.Error(), "duplicate column") {
+			return fmt.Errorf("add warehouse_pricelist_id column: %w", err)
+		}
+	}
+
+	if err := tx.Exec(`
+		ALTER TABLE local_configurations
+		ADD COLUMN competitor_pricelist_id INTEGER
+	`).Error; err != nil {
+		// Column might already exist, ignore
+		if !strings.Contains(err.Error(), "duplicate column") {
+			return fmt.Errorf("add competitor_pricelist_id column: %w", err)
+		}
+	}
+
+	// Create indexes
+	if err := tx.Exec(`
+		CREATE INDEX IF NOT EXISTS idx_local_configurations_warehouse_pricelist
+		ON local_configurations(warehouse_pricelist_id)
+	`).Error; err != nil {
+		return fmt.Errorf("create warehouse pricelist index: %w", err)
+	}
+
+	if err := tx.Exec(`
+		CREATE INDEX IF NOT EXISTS idx_local_configurations_competitor_pricelist
+		ON local_configurations(competitor_pricelist_id)
+	`).Error; err != nil {
+		return fmt.Errorf("create competitor pricelist index: %w", err)
+	}
+
+	slog.Info("added warehouse and competitor pricelist fields to local_configurations")
+	return nil
+}
+
+func addLocalPricelistItemCategoryAndIndexes(tx *gorm.DB) error {
+	type columnInfo struct {
+		Name string `gorm:"column:name"`
+	}
+
+	var columns []columnInfo
+	if err := tx.Raw(`
+		SELECT name FROM pragma_table_info('local_pricelist_items')
+		WHERE name IN ('lot_category')
+	`).Scan(&columns).Error; err != nil {
+		return fmt.Errorf("check local_pricelist_items(lot_category) existence: %w", err)
+	}
+
+	if len(columns) == 0 {
+		if err := tx.Exec(`
+			ALTER TABLE local_pricelist_items
+			ADD COLUMN lot_category TEXT
+		`).Error; err != nil {
+			return fmt.Errorf("add local_pricelist_items.lot_category: %w", err)
+		}
+		slog.Info("added lot_category to local_pricelist_items")
+	}
+
+	if err := tx.Exec(`
+		CREATE INDEX IF NOT EXISTS idx_local_pricelist_items_pricelist_lot
+		ON local_pricelist_items(pricelist_id, lot_name)
+	`).Error; err != nil {
+		return fmt.Errorf("ensure idx_local_pricelist_items_pricelist_lot: %w", err)
+	}
+
+	if err := tx.Exec(`
+		CREATE INDEX IF NOT EXISTS idx_local_pricelist_items_lot_category
+		ON local_pricelist_items(lot_category)
+	`).Error; err != nil {
+		return fmt.Errorf("ensure idx_local_pricelist_items_lot_category: %w", err)
+	}
+
+	return nil
+}
+
+func addLocalConfigurationArticle(tx *gorm.DB) error {
+	type columnInfo struct {
+		Name string `gorm:"column:name"`
+	}
+	var columns []columnInfo
+	if err := tx.Raw(`
+		SELECT name FROM pragma_table_info('local_configurations')
+		WHERE name IN ('article')
+	`).Scan(&columns).Error; err != nil {
+		return fmt.Errorf("check local_configurations(article) existence: %w", err)
+	}
+	if len(columns) == 0 {
+		if err := tx.Exec(`
+			ALTER TABLE local_configurations
+			ADD COLUMN article TEXT
+		`).Error; err != nil {
+			return fmt.Errorf("add local_configurations.article: %w", err)
+		}
+		slog.Info("added article to local_configurations")
+	}
+	return nil
+}
+
+func addLocalConfigurationServerModel(tx *gorm.DB) error {
+	type columnInfo struct {
+		Name string `gorm:"column:name"`
+	}
+	var columns []columnInfo
+	if err := tx.Raw(`
+		SELECT name FROM pragma_table_info('local_configurations')
+		WHERE name IN ('server_model')
+	`).Scan(&columns).Error; err != nil {
+		return fmt.Errorf("check local_configurations(server_model) existence: %w", err)
+	}
+	if len(columns) == 0 {
+		if err := tx.Exec(`
+			ALTER TABLE local_configurations
+			ADD COLUMN server_model TEXT
+		`).Error; err != nil {
+			return fmt.Errorf("add local_configurations.server_model: %w", err)
+		}
+		slog.Info("added server_model to local_configurations")
+	}
+	return nil
+}
+
+func addLocalConfigurationSupportCode(tx *gorm.DB) error {
+	type columnInfo struct {
+		Name string `gorm:"column:name"`
+	}
+	var columns []columnInfo
+	if err := tx.Raw(`
+		SELECT name FROM pragma_table_info('local_configurations')
+		WHERE name IN ('support_code')
+	`).Scan(&columns).Error; err != nil {
+		return fmt.Errorf("check local_configurations(support_code) existence: %w", err)
+	}
+	if len(columns) == 0 {
+		if err := tx.Exec(`
+			ALTER TABLE local_configurations
+			ADD COLUMN support_code TEXT
+		`).Error; err != nil {
+			return fmt.Errorf("add local_configurations.support_code: %w", err)
+		}
+		slog.Info("added support_code to local_configurations")
+	}
+	return nil
+}
+
+func addLocalConfigurationLineNo(tx *gorm.DB) error {
+	type columnInfo struct {
+		Name string `gorm:"column:name"`
+	}
+	var columns []columnInfo
+	if err := tx.Raw(`
+		SELECT name FROM pragma_table_info('local_configurations')
+		WHERE name IN ('line_no')
+	`).Scan(&columns).Error; err != nil {
+		return fmt.Errorf("check local_configurations(line_no) existence: %w", err)
+	}
+	if len(columns) == 0 {
+		if err := tx.Exec(`
+			ALTER TABLE local_configurations
+			ADD COLUMN line_no INTEGER
+		`).Error; err != nil {
+			return fmt.Errorf("add local_configurations.line_no: %w", err)
+		}
+		slog.Info("added line_no to local_configurations")
+	}
+
+	if err := tx.Exec(`
+WITH ranked AS (
+	SELECT
+		id,
+		ROW_NUMBER() OVER (
+			PARTITION BY COALESCE(NULLIF(TRIM(project_uuid), ''), '__NO_PROJECT__')
+			ORDER BY created_at ASC, id ASC
+		) AS rn
+	FROM local_configurations
+	WHERE line_no IS NULL OR line_no <= 0
+)
+UPDATE local_configurations
+SET line_no = (
+	SELECT rn * 10
+	FROM ranked
+	WHERE ranked.id = local_configurations.id
+)
+WHERE id IN (SELECT id FROM ranked)
+`).Error; err != nil {
+		return fmt.Errorf("backfill local_configurations.line_no: %w", err)
+	}
+
+	if err := tx.Exec(`
+		CREATE INDEX IF NOT EXISTS idx_local_configurations_project_line_no
+		ON local_configurations(project_uuid, line_no)
+	`).Error; err != nil {
+		return fmt.Errorf("ensure idx_local_configurations_project_line_no: %w", err)
+	}
+
+	return nil
+}
+

internal/localdb/models.go

@@ -57,39 +57,117 @@ func (c LocalConfigItems) Total() float64 {
 	return total
 }
 
+// LocalStringList is a JSON-encoded list of strings stored as TEXT in SQLite.
+type LocalStringList []string
+
+func (s LocalStringList) Value() (driver.Value, error) {
+	return json.Marshal(s)
+}
+
+func (s *LocalStringList) Scan(value interface{}) error {
+	if value == nil {
+		*s = make(LocalStringList, 0)
+		return nil
+	}
+	var bytes []byte
+	switch v := value.(type) {
+	case []byte:
+		bytes = v
+	case string:
+		bytes = []byte(v)
+	default:
+		return errors.New("type assertion failed for LocalStringList")
+	}
+	return json.Unmarshal(bytes, s)
+}
+
 // 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"`
-	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
+	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
+	ProjectUUID           *string                     `gorm:"index" json:"project_uuid,omitempty"`
+	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"`
+	ServerModel           string                      `gorm:"size:100" json:"server_model,omitempty"`
+	SupportCode           string                      `gorm:"size:20" json:"support_code,omitempty"`
+	Article               string                      `gorm:"size:80" json:"article,omitempty"`
+	PricelistID           *uint                       `gorm:"index" json:"pricelist_id,omitempty"`
+	WarehousePricelistID  *uint                       `gorm:"index" json:"warehouse_pricelist_id,omitempty"`
+	CompetitorPricelistID *uint                       `gorm:"index" json:"competitor_pricelist_id,omitempty"`
+	OnlyInStock           bool                        `gorm:"default:false" json:"only_in_stock"`
+	VendorSpec             VendorSpec                  `gorm:"type:text" json:"vendor_spec,omitempty"`
+	Line                  int                         `gorm:"column:line_no;index" json:"line"`
+	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"
 }
 
+type LocalProject struct {
+	ID            uint       `gorm:"primaryKey;autoIncrement" json:"id"`
+	UUID          string     `gorm:"uniqueIndex;not null" json:"uuid"`
+	ServerID      *uint      `json:"server_id,omitempty"`
+	OwnerUsername string     `gorm:"not null;index" json:"owner_username"`
+	Code          string     `gorm:"not null;index:idx_local_projects_code_variant,priority:1" json:"code"`
+	Variant       string     `gorm:"default:'';index:idx_local_projects_code_variant,priority:2" json:"variant"`
+	Name          *string    `json:"name,omitempty"`
+	TrackerURL    string     `json:"tracker_url"`
+	IsActive      bool       `gorm:"default:true;index" json:"is_active"`
+	IsSystem      bool       `gorm:"default:false;index" json:"is_system"`
+	CreatedAt     time.Time  `json:"created_at"`
+	UpdatedAt     time.Time  `json:"updated_at"`
+	SyncedAt      *time.Time `json:"synced_at,omitempty"`
+	SyncStatus    string     `gorm:"default:'local'" json:"sync_status"` // local/synced/pending
+}
+
+func (LocalProject) TableName() string {
+	return "local_projects"
+}
+
+// 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;uniqueIndex" json:"server_id"` // ID on MariaDB server
+	Source    string    `gorm:"not null;default:'estimate';index:idx_local_pricelists_source_created_at,priority:1" json:"source"`
+	Version   string    `gorm:"not null;index" json:"version"`
+	Name      string    `json:"name"`
+	CreatedAt time.Time `gorm:"index:idx_local_pricelists_source_created_at,priority:2,sort:desc" 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 {
@@ -98,36 +176,65 @@ func (LocalPricelist) TableName() string {
 
 // LocalPricelistItem stores pricelist items
 type LocalPricelistItem struct {
-	ID          uint    `gorm:"primaryKey;autoIncrement" json:"id"`
-	PricelistID uint    `gorm:"not null;index" json:"pricelist_id"`
-	LotName     string  `gorm:"not null" json:"lot_name"`
-	Price       float64 `gorm:"not null" json:"price"`
+	ID           uint            `gorm:"primaryKey;autoIncrement" json:"id"`
+	PricelistID  uint            `gorm:"not null;index" json:"pricelist_id"`
+	LotName      string          `gorm:"not null" json:"lot_name"`
+	LotCategory  string          `gorm:"column:lot_category" json:"lot_category,omitempty"`
+	Price        float64         `gorm:"not null" json:"price"`
+	AvailableQty *float64        `json:"available_qty,omitempty"`
+	Partnumbers  LocalStringList `gorm:"type:text" json:"partnumbers,omitempty"`
 }
 
 func (LocalPricelistItem) TableName() string {
 	return "local_pricelist_items"
 }
 
-// LocalComponent stores cached components for offline search
+// LocalComponent stores cached components for offline search (metadata only)
+// All pricing is now sourced from local_pricelist_items based on configuration pricelist selection
 type LocalComponent struct {
-	LotName        string    `gorm:"primaryKey" json:"lot_name"`
-	LotDescription string    `json:"lot_description"`
-	Category       string    `json:"category"`
-	Model          string    `json:"model"`
-	CurrentPrice   *float64  `json:"current_price"`
-	SyncedAt       time.Time `json:"synced_at"`
+	LotName        string `gorm:"primaryKey" json:"lot_name"`
+	LotDescription string `json:"lot_description"`
+	Category       string `json:"category"`
+	Model          string `json:"model"`
 }
 
 func (LocalComponent) TableName() string {
 	return "local_components"
 }
 
+// LocalRemoteMigrationApplied tracks remote SQLite migrations received from server and applied locally.
+type LocalRemoteMigrationApplied struct {
+	ID         string    `gorm:"primaryKey;size:128" json:"id"`
+	Checksum   string    `gorm:"size:128;not null" json:"checksum"`
+	AppVersion string    `gorm:"size:64" json:"app_version,omitempty"`
+	AppliedAt  time.Time `gorm:"not null" json:"applied_at"`
+}
+
+func (LocalRemoteMigrationApplied) TableName() string {
+	return "local_remote_migrations_applied"
+}
+
+// LocalSyncGuardState stores latest sync readiness decision for UI and preflight checks.
+type LocalSyncGuardState struct {
+	ID                    uint       `gorm:"primaryKey;autoIncrement" json:"id"`
+	Status                string     `gorm:"size:32;not null;index" json:"status"` // ready|blocked|unknown
+	ReasonCode            string     `gorm:"size:128" json:"reason_code,omitempty"`
+	ReasonText            string     `gorm:"type:text" json:"reason_text,omitempty"`
+	RequiredMinAppVersion *string    `gorm:"size:64" json:"required_min_app_version,omitempty"`
+	LastCheckedAt         *time.Time `json:"last_checked_at,omitempty"`
+	UpdatedAt             time.Time  `json:"updated_at"`
+}
+
+func (LocalSyncGuardState) TableName() string {
+	return "local_sync_guard_state"
+}
+
 // PendingChange stores changes that need to be synced to the server
 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
@@ -137,3 +244,85 @@ type PendingChange struct {
 func (PendingChange) TableName() string {
 	return "pending_changes"
 }
+
+// LocalPartnumberBook stores a version snapshot of the PN→LOT mapping book (pull-only from PriceForge)
+type LocalPartnumberBook struct {
+	ID        uint      `gorm:"primaryKey;autoIncrement" json:"id"`
+	ServerID  int       `gorm:"uniqueIndex;not null" json:"server_id"`
+	Version   string    `gorm:"not null" json:"version"`
+	CreatedAt time.Time `gorm:"not null" json:"created_at"`
+	IsActive  bool      `gorm:"not null;default:true" json:"is_active"`
+}
+
+func (LocalPartnumberBook) TableName() string {
+	return "local_partnumber_books"
+}
+
+// LocalPartnumberBookItem stores a single PN→LOT mapping within a book snapshot
+type LocalPartnumberBookItem struct {
+	ID          uint   `gorm:"primaryKey;autoIncrement" json:"id"`
+	BookID      uint   `gorm:"not null;index:idx_local_book_pn,priority:1" json:"book_id"`
+	Partnumber  string `gorm:"not null;index:idx_local_book_pn,priority:2" json:"partnumber"`
+	LotName     string `gorm:"not null" json:"lot_name"`
+	IsPrimaryPN bool   `gorm:"not null;default:false" json:"is_primary_pn"`
+	Description string `json:"description,omitempty"`
+}
+
+func (LocalPartnumberBookItem) TableName() string {
+	return "local_partnumber_book_items"
+}
+
+// VendorSpecItem represents a single row in a vendor BOM specification
+type VendorSpecItem struct {
+	SortOrder           int      `json:"sort_order"`
+	VendorPartnumber    string   `json:"vendor_partnumber"`
+	Quantity            int      `json:"quantity"`
+	Description         string   `json:"description,omitempty"`
+	UnitPrice           *float64 `json:"unit_price,omitempty"`
+	TotalPrice          *float64 `json:"total_price,omitempty"`
+	ResolvedLotName     string   `json:"resolved_lot_name,omitempty"`
+	ResolutionSource    string   `json:"resolution_source,omitempty"` // "book", "manual", "unresolved"
+	ManualLotSuggestion string   `json:"manual_lot_suggestion,omitempty"`
+	LotQtyPerPN         int      `json:"lot_qty_per_pn,omitempty"`
+	LotAllocations      []VendorSpecLotAllocation `json:"lot_allocations,omitempty"`
+	LotMappings         []VendorSpecLotMapping `json:"lot_mappings,omitempty"`
+}
+
+type VendorSpecLotAllocation struct {
+	LotName  string `json:"lot_name"`
+	Quantity int    `json:"quantity"` // quantity of LOT per 1 vendor PN
+}
+
+// VendorSpecLotMapping is the canonical persisted LOT mapping for a vendor PN row.
+// It stores all mapped LOTs (base + bundle) uniformly.
+type VendorSpecLotMapping struct {
+	LotName       string `json:"lot_name"`
+	QuantityPerPN int    `json:"quantity_per_pn"`
+}
+
+// VendorSpec is a JSON-encodable slice of VendorSpecItem
+type VendorSpec []VendorSpecItem
+
+func (v VendorSpec) Value() (driver.Value, error) {
+	if v == nil {
+		return nil, nil
+	}
+	return json.Marshal(v)
+}
+
+func (v *VendorSpec) Scan(value interface{}) error {
+	if value == nil {
+		*v = nil
+		return nil
+	}
+	var bytes []byte
+	switch val := value.(type) {
+	case []byte:
+		bytes = val
+	case string:
+		bytes = []byte(val)
+	default:
+		return errors.New("type assertion failed for VendorSpec")
+	}
+	return json.Unmarshal(bytes, v)
+}

internal/localdb/pricelist_latest_test.go

@@ -0,0 +1,128 @@
+package localdb
+
+import (
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestGetLatestLocalPricelistBySource_SkipsPricelistWithoutItems(t *testing.T) {
+	local, err := New(filepath.Join(t.TempDir(), "latest_without_items.db"))
+	if err != nil {
+		t.Fatalf("open localdb: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	base := time.Now().Add(-time.Minute)
+	withItems := &LocalPricelist{
+		ServerID:  1001,
+		Source:    "estimate",
+		Version:   "E-1",
+		Name:      "with-items",
+		CreatedAt: base,
+		SyncedAt:  base,
+	}
+	if err := local.SaveLocalPricelist(withItems); err != nil {
+		t.Fatalf("save pricelist with items: %v", err)
+	}
+	storedWithItems, err := local.GetLocalPricelistByServerID(withItems.ServerID)
+	if err != nil {
+		t.Fatalf("load pricelist with items: %v", err)
+	}
+	if err := local.SaveLocalPricelistItems([]LocalPricelistItem{
+		{
+			PricelistID: storedWithItems.ID,
+			LotName:     "CPU_A",
+			Price:       100,
+		},
+	}); err != nil {
+		t.Fatalf("save pricelist items: %v", err)
+	}
+
+	withoutItems := &LocalPricelist{
+		ServerID:  1002,
+		Source:    "estimate",
+		Version:   "E-2",
+		Name:      "without-items",
+		CreatedAt: base.Add(2 * time.Second),
+		SyncedAt:  base.Add(2 * time.Second),
+	}
+	if err := local.SaveLocalPricelist(withoutItems); err != nil {
+		t.Fatalf("save pricelist without items: %v", err)
+	}
+
+	got, err := local.GetLatestLocalPricelistBySource("estimate")
+	if err != nil {
+		t.Fatalf("GetLatestLocalPricelistBySource: %v", err)
+	}
+	if got.ServerID != withItems.ServerID {
+		t.Fatalf("expected server_id=%d, got %d", withItems.ServerID, got.ServerID)
+	}
+}
+
+func TestGetLatestLocalPricelistBySource_TieBreaksByID(t *testing.T) {
+	local, err := New(filepath.Join(t.TempDir(), "latest_tie_break.db"))
+	if err != nil {
+		t.Fatalf("open localdb: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	base := time.Now().Add(-time.Minute)
+	first := &LocalPricelist{
+		ServerID:  2001,
+		Source:    "warehouse",
+		Version:   "S-1",
+		Name:      "first",
+		CreatedAt: base,
+		SyncedAt:  base,
+	}
+	if err := local.SaveLocalPricelist(first); err != nil {
+		t.Fatalf("save first pricelist: %v", err)
+	}
+	storedFirst, err := local.GetLocalPricelistByServerID(first.ServerID)
+	if err != nil {
+		t.Fatalf("load first pricelist: %v", err)
+	}
+	if err := local.SaveLocalPricelistItems([]LocalPricelistItem{
+		{
+			PricelistID: storedFirst.ID,
+			LotName:     "CPU_A",
+			Price:       101,
+		},
+	}); err != nil {
+		t.Fatalf("save first items: %v", err)
+	}
+
+	second := &LocalPricelist{
+		ServerID:  2002,
+		Source:    "warehouse",
+		Version:   "S-2",
+		Name:      "second",
+		CreatedAt: base,
+		SyncedAt:  base,
+	}
+	if err := local.SaveLocalPricelist(second); err != nil {
+		t.Fatalf("save second pricelist: %v", err)
+	}
+	storedSecond, err := local.GetLocalPricelistByServerID(second.ServerID)
+	if err != nil {
+		t.Fatalf("load second pricelist: %v", err)
+	}
+	if err := local.SaveLocalPricelistItems([]LocalPricelistItem{
+		{
+			PricelistID: storedSecond.ID,
+			LotName:     "CPU_A",
+			Price:       102,
+		},
+	}); err != nil {
+		t.Fatalf("save second items: %v", err)
+	}
+
+	got, err := local.GetLatestLocalPricelistBySource("warehouse")
+	if err != nil {
+		t.Fatalf("GetLatestLocalPricelistBySource: %v", err)
+	}
+	if got.ServerID != second.ServerID {
+		t.Fatalf("expected server_id=%d, got %d", second.ServerID, got.ServerID)
+	}
+}

internal/localdb/snapshots.go

@@ -0,0 +1,148 @@
+package localdb
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"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,
+		"project_uuid":       localCfg.ProjectUUID,
+		"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,
+		"server_model":       localCfg.ServerModel,
+		"support_code":       localCfg.SupportCode,
+		"article":            localCfg.Article,
+		"pricelist_id":       localCfg.PricelistID,
+		"only_in_stock":      localCfg.OnlyInStock,
+		"line":               localCfg.Line,
+		"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 {
+		ProjectUUID      *string          `json:"project_uuid"`
+		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"`
+		ServerModel      string           `json:"server_model"`
+		SupportCode      string           `json:"support_code"`
+		Article          string           `json:"article"`
+		PricelistID      *uint            `json:"pricelist_id"`
+		OnlyInStock      bool             `json:"only_in_stock"`
+		Line             int              `json:"line"`
+		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,
+		ProjectUUID:      snapshot.ProjectUUID,
+		Name:             snapshot.Name,
+		Items:            snapshot.Items,
+		TotalPrice:       snapshot.TotalPrice,
+		CustomPrice:      snapshot.CustomPrice,
+		Notes:            snapshot.Notes,
+		IsTemplate:       snapshot.IsTemplate,
+		ServerCount:      snapshot.ServerCount,
+		ServerModel:      snapshot.ServerModel,
+		SupportCode:      snapshot.SupportCode,
+		Article:          snapshot.Article,
+		PricelistID:      snapshot.PricelistID,
+		OnlyInStock:      snapshot.OnlyInStock,
+		Line:             snapshot.Line,
+		PriceUpdatedAt:   snapshot.PriceUpdatedAt,
+		OriginalUserID:   snapshot.OriginalUserID,
+		OriginalUsername: snapshot.OriginalUsername,
+	}, nil
+}
+
+type configurationSpecPriceFingerprint struct {
+	Items       []configurationSpecPriceFingerprintItem `json:"items"`
+	ServerCount int                                     `json:"server_count"`
+	TotalPrice  *float64                                `json:"total_price,omitempty"`
+	CustomPrice *float64                                `json:"custom_price,omitempty"`
+}
+
+type configurationSpecPriceFingerprintItem struct {
+	LotName   string  `json:"lot_name"`
+	Quantity  int     `json:"quantity"`
+	UnitPrice float64 `json:"unit_price"`
+}
+
+// BuildConfigurationSpecPriceFingerprint returns a stable JSON key based on
+// spec + price fields only, used for revision deduplication.
+func BuildConfigurationSpecPriceFingerprint(localCfg *LocalConfiguration) (string, error) {
+	items := make([]configurationSpecPriceFingerprintItem, 0, len(localCfg.Items))
+	for _, item := range localCfg.Items {
+		items = append(items, configurationSpecPriceFingerprintItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
+		})
+	}
+	sort.Slice(items, func(i, j int) bool {
+		if items[i].LotName != items[j].LotName {
+			return items[i].LotName < items[j].LotName
+		}
+		if items[i].Quantity != items[j].Quantity {
+			return items[i].Quantity < items[j].Quantity
+		}
+		return items[i].UnitPrice < items[j].UnitPrice
+	})
+
+	payload := configurationSpecPriceFingerprint{
+		Items:       items,
+		ServerCount: localCfg.ServerCount,
+		TotalPrice:  localCfg.TotalPrice,
+		CustomPrice: localCfg.CustomPrice,
+	}
+
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("marshal spec+price fingerprint: %w", err)
+	}
+	return string(raw), nil
+}

internal/lotmatch/resolver.go

@@ -0,0 +1,238 @@
+package lotmatch
+
+import (
+	"errors"
+	"regexp"
+	"sort"
+	"strings"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+var (
+	ErrResolveConflict = errors.New("multiple lot matches")
+	ErrResolveNotFound = errors.New("lot not found")
+)
+
+type LotResolver struct {
+	partnumberToLots map[string][]string
+	exactLots        map[string]string
+	allLots          []string
+}
+
+type MappingMatcher struct {
+	exact    map[string][]string
+	exactLot map[string]string
+	wildcard []wildcardMapping
+}
+
+type wildcardMapping struct {
+	lotName string
+	re      *regexp.Regexp
+}
+
+func NewLotResolverFromDB(db *gorm.DB) (*LotResolver, error) {
+	mappings, lots, err := loadMappingsAndLots(db)
+	if err != nil {
+		return nil, err
+	}
+	return NewLotResolver(mappings, lots), nil
+}
+
+func NewMappingMatcherFromDB(db *gorm.DB) (*MappingMatcher, error) {
+	mappings, lots, err := loadMappingsAndLots(db)
+	if err != nil {
+		return nil, err
+	}
+	return NewMappingMatcher(mappings, lots), nil
+}
+
+func NewLotResolver(mappings []models.LotPartnumber, lots []models.Lot) *LotResolver {
+	partnumberToLots := make(map[string][]string, len(mappings))
+	for _, m := range mappings {
+		pn := NormalizeKey(m.Partnumber)
+		lot := strings.TrimSpace(m.LotName)
+		if pn == "" || lot == "" {
+			continue
+		}
+		partnumberToLots[pn] = append(partnumberToLots[pn], lot)
+	}
+	for key := range partnumberToLots {
+		partnumberToLots[key] = uniqueCaseInsensitive(partnumberToLots[key])
+	}
+
+	exactLots := make(map[string]string, len(lots))
+	allLots := make([]string, 0, len(lots))
+	for _, l := range lots {
+		name := strings.TrimSpace(l.LotName)
+		if name == "" {
+			continue
+		}
+		exactLots[NormalizeKey(name)] = name
+		allLots = append(allLots, name)
+	}
+	sort.Slice(allLots, func(i, j int) bool {
+		li := len([]rune(allLots[i]))
+		lj := len([]rune(allLots[j]))
+		if li == lj {
+			return allLots[i] < allLots[j]
+		}
+		return li > lj
+	})
+
+	return &LotResolver{
+		partnumberToLots: partnumberToLots,
+		exactLots:        exactLots,
+		allLots:          allLots,
+	}
+}
+
+func NewMappingMatcher(mappings []models.LotPartnumber, lots []models.Lot) *MappingMatcher {
+	exact := make(map[string][]string, len(mappings))
+	wildcards := make([]wildcardMapping, 0, len(mappings))
+	for _, m := range mappings {
+		pn := NormalizeKey(m.Partnumber)
+		lot := strings.TrimSpace(m.LotName)
+		if pn == "" || lot == "" {
+			continue
+		}
+		if strings.Contains(pn, "*") {
+			pattern := "^" + regexp.QuoteMeta(pn) + "$"
+			pattern = strings.ReplaceAll(pattern, "\\*", ".*")
+			re, err := regexp.Compile(pattern)
+			if err != nil {
+				continue
+			}
+			wildcards = append(wildcards, wildcardMapping{lotName: lot, re: re})
+			continue
+		}
+		exact[pn] = append(exact[pn], lot)
+	}
+	for key := range exact {
+		exact[key] = uniqueCaseInsensitive(exact[key])
+	}
+
+	exactLot := make(map[string]string, len(lots))
+	for _, l := range lots {
+		name := strings.TrimSpace(l.LotName)
+		if name == "" {
+			continue
+		}
+		exactLot[NormalizeKey(name)] = name
+	}
+
+	return &MappingMatcher{
+		exact:    exact,
+		exactLot: exactLot,
+		wildcard: wildcards,
+	}
+}
+
+func (r *LotResolver) Resolve(partnumber string) (string, string, error) {
+	key := NormalizeKey(partnumber)
+	if key == "" {
+		return "", "", ErrResolveNotFound
+	}
+
+	if mapped := r.partnumberToLots[key]; len(mapped) > 0 {
+		if len(mapped) == 1 {
+			return mapped[0], "mapping_table", nil
+		}
+		return "", "", ErrResolveConflict
+	}
+	if exact, ok := r.exactLots[key]; ok {
+		return exact, "article_exact", nil
+	}
+
+	best := ""
+	bestLen := -1
+	tie := false
+	for _, lot := range r.allLots {
+		lotKey := NormalizeKey(lot)
+		if lotKey == "" {
+			continue
+		}
+		if strings.HasPrefix(key, lotKey) {
+			l := len([]rune(lotKey))
+			if l > bestLen {
+				best = lot
+				bestLen = l
+				tie = false
+			} else if l == bestLen && !strings.EqualFold(best, lot) {
+				tie = true
+			}
+		}
+	}
+	if best == "" {
+		return "", "", ErrResolveNotFound
+	}
+	if tie {
+		return "", "", ErrResolveConflict
+	}
+	return best, "prefix", nil
+}
+
+func (m *MappingMatcher) MatchLots(partnumber string) []string {
+	if m == nil {
+		return nil
+	}
+	key := NormalizeKey(partnumber)
+	if key == "" {
+		return nil
+	}
+
+	lots := make([]string, 0, 2)
+	if exact := m.exact[key]; len(exact) > 0 {
+		lots = append(lots, exact...)
+	}
+	for _, wc := range m.wildcard {
+		if wc.re == nil || !wc.re.MatchString(key) {
+			continue
+		}
+		lots = append(lots, wc.lotName)
+	}
+	if lot, ok := m.exactLot[key]; ok && strings.TrimSpace(lot) != "" {
+		lots = append(lots, lot)
+	}
+	return uniqueCaseInsensitive(lots)
+}
+
+func NormalizeKey(v string) string {
+	s := strings.ToLower(strings.TrimSpace(v))
+	replacer := strings.NewReplacer(" ", "", "-", "", "_", "", ".", "", "/", "", "\\", "", "\"", "", "'", "", "(", "", ")", "")
+	return replacer.Replace(s)
+}
+
+func loadMappingsAndLots(db *gorm.DB) ([]models.LotPartnumber, []models.Lot, error) {
+	var mappings []models.LotPartnumber
+	if err := db.Find(&mappings).Error; err != nil {
+		return nil, nil, err
+	}
+	var lots []models.Lot
+	if err := db.Select("lot_name").Find(&lots).Error; err != nil {
+		return nil, nil, err
+	}
+	return mappings, lots, nil
+}
+
+func uniqueCaseInsensitive(values []string) []string {
+	seen := make(map[string]struct{}, len(values))
+	out := make([]string, 0, len(values))
+	for _, v := range values {
+		trimmed := strings.TrimSpace(v)
+		if trimmed == "" {
+			continue
+		}
+		key := strings.ToLower(trimmed)
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		out = append(out, trimmed)
+	}
+	sort.Slice(out, func(i, j int) bool {
+		return strings.ToLower(out[i]) < strings.ToLower(out[j])
+	})
+	return out
+}

internal/lotmatch/resolver_test.go

@@ -0,0 +1,62 @@
+package lotmatch
+
+import (
+	"testing"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+)
+
+func TestLotResolverPrecedence(t *testing.T) {
+	resolver := NewLotResolver(
+		[]models.LotPartnumber{
+			{Partnumber: "PN-1", LotName: "LOT_A"},
+		},
+		[]models.Lot{
+			{LotName: "CPU_X_LONG"},
+			{LotName: "CPU_X"},
+		},
+	)
+
+	lot, by, err := resolver.Resolve("PN-1")
+	if err != nil || lot != "LOT_A" || by != "mapping_table" {
+		t.Fatalf("expected mapping_table LOT_A, got lot=%s by=%s err=%v", lot, by, err)
+	}
+
+	lot, by, err = resolver.Resolve("CPU_X")
+	if err != nil || lot != "CPU_X" || by != "article_exact" {
+		t.Fatalf("expected article_exact CPU_X, got lot=%s by=%s err=%v", lot, by, err)
+	}
+
+	lot, by, err = resolver.Resolve("CPU_X_LONG_001")
+	if err != nil || lot != "CPU_X_LONG" || by != "prefix" {
+		t.Fatalf("expected prefix CPU_X_LONG, got lot=%s by=%s err=%v", lot, by, err)
+	}
+}
+
+func TestMappingMatcherWildcardAndExactLot(t *testing.T) {
+	matcher := NewMappingMatcher(
+		[]models.LotPartnumber{
+			{Partnumber: "R750*", LotName: "SERVER_R750"},
+			{Partnumber: "HDD-01", LotName: "HDD_01"},
+		},
+		[]models.Lot{
+			{LotName: "MEM_DDR5_16G_4800"},
+		},
+	)
+
+	check := func(partnumber string, want string) {
+		t.Helper()
+		got := matcher.MatchLots(partnumber)
+		if len(got) != 1 || got[0] != want {
+			t.Fatalf("partnumber %s: expected [%s], got %#v", partnumber, want, got)
+		}
+	}
+
+	check("R750XD", "SERVER_R750")
+	check("HDD-01", "HDD_01")
+	check("MEM_DDR5_16G_4800", "MEM_DDR5_16G_4800")
+
+	if got := matcher.MatchLots("UNKNOWN"); len(got) != 0 {
+		t.Fatalf("expected no matches for UNKNOWN, got %#v", got)
+	}
+}

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/cors.go

@@ -1,22 +1,55 @@
 package middleware
 
 import (
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+
 	"github.com/gin-gonic/gin"
 )
 
 func CORS() gin.HandlerFunc {
 	return func(c *gin.Context) {
-		c.Header("Access-Control-Allow-Origin", "*")
-		c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
-		c.Header("Access-Control-Allow-Headers", "Origin, Content-Type, Accept, Authorization")
-		c.Header("Access-Control-Expose-Headers", "Content-Length, Content-Disposition")
-		c.Header("Access-Control-Max-Age", "86400")
+		origin := strings.TrimSpace(c.GetHeader("Origin"))
+		if origin != "" {
+			if isLoopbackOrigin(origin) {
+				c.Header("Access-Control-Allow-Origin", origin)
+				c.Header("Vary", "Origin")
+				c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
+				c.Header("Access-Control-Allow-Headers", "Origin, Content-Type, Accept, Authorization")
+				c.Header("Access-Control-Expose-Headers", "Content-Length, Content-Disposition")
+				c.Header("Access-Control-Max-Age", "86400")
+			} else if c.Request.Method == http.MethodOptions {
+				c.AbortWithStatus(http.StatusForbidden)
+				return
+			}
+		}
 
-		if c.Request.Method == "OPTIONS" {
-			c.AbortWithStatus(204)
+		if c.Request.Method == http.MethodOptions {
+			c.AbortWithStatus(http.StatusNoContent)
 			return
 		}
 
 		c.Next()
 	}
 }
+
+func isLoopbackOrigin(origin string) bool {
+	u, err := url.Parse(origin)
+	if err != nil {
+		return false
+	}
+	if u.Scheme != "http" && u.Scheme != "https" {
+		return false
+	}
+	host := strings.TrimSpace(u.Hostname())
+	if host == "" {
+		return false
+	}
+	if strings.EqualFold(host, "localhost") {
+		return true
+	}
+	ip := net.ParseIP(host)
+	return ip != nil && ip.IsLoopback()
+}

internal/models/configuration.go

@@ -40,18 +40,31 @@ 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"`
+	ProjectUUID           *string     `gorm:"size:36;index" json:"project_uuid,omitempty"`
+	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"`
+	ServerModel           string      `gorm:"size:100" json:"server_model,omitempty"`
+	SupportCode           string      `gorm:"size:20" json:"support_code,omitempty"`
+	Article               string      `gorm:"size:80" json:"article,omitempty"`
+	PricelistID           *uint       `gorm:"index" json:"pricelist_id,omitempty"`
+	WarehousePricelistID  *uint       `gorm:"index" json:"warehouse_pricelist_id,omitempty"`
+	CompetitorPricelistID *uint       `gorm:"index" json:"competitor_pricelist_id,omitempty"`
+	DisablePriceRefresh   bool        `gorm:"default:false" json:"disable_price_refresh"`
+	OnlyInStock           bool        `gorm:"default:false" json:"only_in_stock"`
+	Line                  int         `gorm:"column:line_no;index" json:"line"`
+	PriceUpdatedAt        *time.Time  `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
+	CreatedAt             time.Time   `gorm:"autoCreateTime" json:"created_at"`
+	CurrentVersionNo      int         `gorm:"-" json:"current_version_no,omitempty"`
 
 	User *User `gorm:"foreignKey:UserID" json:"user,omitempty"`
 }

internal/models/lot.go

@@ -37,3 +37,44 @@ type Supplier struct {
 func (Supplier) TableName() string {
 	return "supplier"
 }
+
+// StockLog stores warehouse stock snapshots imported from external files.
+type StockLog struct {
+	StockLogID uint      `gorm:"column:stock_log_id;primaryKey;autoIncrement"`
+	Partnumber string    `gorm:"column:partnumber;size:255;not null"`
+	Supplier   *string   `gorm:"column:supplier;size:255"`
+	Date       time.Time `gorm:"column:date;type:date;not null"`
+	Price      float64   `gorm:"column:price;not null"`
+	Quality    *string   `gorm:"column:quality;size:255"`
+	Comments   *string   `gorm:"column:comments;size:15000"`
+	Vendor     *string   `gorm:"column:vendor;size:255"`
+	Qty        *float64  `gorm:"column:qty"`
+}
+
+func (StockLog) TableName() string {
+	return "stock_log"
+}
+
+// LotPartnumber maps external part numbers to internal lots.
+type LotPartnumber struct {
+	Partnumber  string  `gorm:"column:partnumber;size:255;primaryKey" json:"partnumber"`
+	LotName     string  `gorm:"column:lot_name;size:255;primaryKey" json:"lot_name"`
+	Description *string `gorm:"column:description;size:10000" json:"description,omitempty"`
+}
+
+func (LotPartnumber) TableName() string {
+	return "lot_partnumbers"
+}
+
+// StockIgnoreRule contains import ignore pattern rules.
+type StockIgnoreRule struct {
+	ID        uint      `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+	Target    string    `gorm:"column:target;size:20;not null" json:"target"`         // partnumber|description
+	MatchType string    `gorm:"column:match_type;size:20;not null" json:"match_type"` // exact|prefix|suffix
+	Pattern   string    `gorm:"column:pattern;size:500;not null" json:"pattern"`
+	CreatedAt time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+}
+
+func (StockIgnoreRule) TableName() string {
+	return "stock_ignore_rules"
+}

internal/models/models.go

@@ -13,6 +13,7 @@ func AllModels() []interface{} {
 		&User{},
 		&Category{},
 		&LotMetadata{},
+		&Project{},
 		&Configuration{},
 		&PriceOverride{},
 		&PricingAlert{},

internal/models/pricelist.go

@@ -4,12 +4,41 @@ import (
 	"time"
 )
 
+type PricelistSource string
+
+const (
+	PricelistSourceEstimate   PricelistSource = "estimate"
+	PricelistSourceWarehouse  PricelistSource = "warehouse"
+	PricelistSourceCompetitor PricelistSource = "competitor"
+)
+
+func (s PricelistSource) IsValid() bool {
+	switch s {
+	case PricelistSourceEstimate, PricelistSourceWarehouse, PricelistSourceCompetitor:
+		return true
+	default:
+		return false
+	}
+}
+
+func NormalizePricelistSource(source string) PricelistSource {
+	switch PricelistSource(source) {
+	case PricelistSourceWarehouse:
+		return PricelistSourceWarehouse
+	case PricelistSourceCompetitor:
+		return PricelistSourceCompetitor
+	default:
+		return PricelistSourceEstimate
+	}
+}
+
 // Pricelist represents a versioned snapshot of prices
 type Pricelist struct {
 	ID           uint       `gorm:"primaryKey" json:"id"`
-	Version      string     `gorm:"size:20;uniqueIndex;not null" json:"version"` // Format: YYYY-MM-DD-NNN
-	Notification string     `gorm:"size:500" json:"notification"`                // Notification shown in configurator
-	CreatedAt    time.Time  `json:"created_at"`
+	Source       string     `gorm:"size:20;not null;default:'estimate';uniqueIndex:idx_qt_pricelists_source_version,priority:1;index:idx_qt_pricelists_source_created_at,priority:1" json:"source"`
+	Version      string     `gorm:"size:20;not null;uniqueIndex:idx_qt_pricelists_source_version,priority:2" json:"version"` // Format: YYYY-MM-DD-NNN
+	Notification string     `gorm:"size:500" json:"notification"`                                                            // Notification shown in configurator
+	CreatedAt    time.Time  `gorm:"index:idx_qt_pricelists_source_created_at,priority:2,sort:desc" json:"created_at"`
 	CreatedBy    string     `gorm:"size:100" json:"created_by"`
 	IsActive     bool       `gorm:"default:true" json:"is_active"`
 	UsageCount   int        `gorm:"default:0" json:"usage_count"`
@@ -26,6 +55,7 @@ type PricelistItem struct {
 	ID          uint    `gorm:"primaryKey" json:"id"`
 	PricelistID uint    `gorm:"not null;index:idx_pricelist_lot" json:"pricelist_id"`
 	LotName     string  `gorm:"size:255;not null;index:idx_pricelist_lot" json:"lot_name"`
+	LotCategory string  `gorm:"column:lot_category;size:50" json:"lot_category,omitempty"`
 	Price       float64 `gorm:"type:decimal(12,2);not null" json:"price"`
 	PriceMethod string  `gorm:"size:20" json:"price_method"`
 
@@ -36,8 +66,10 @@ type PricelistItem struct {
 	MetaPrices       string   `gorm:"size:1000" json:"meta_prices,omitempty"`
 
 	// Virtual fields for display
-	LotDescription string `gorm:"-" json:"lot_description,omitempty"`
-	Category       string `gorm:"-" json:"category,omitempty"`
+	LotDescription string   `gorm:"-" json:"lot_description,omitempty"`
+	Category       string   `gorm:"-" json:"category,omitempty"`
+	AvailableQty   *float64 `gorm:"-" json:"available_qty,omitempty"`
+	Partnumbers    []string `gorm:"-" json:"partnumbers,omitempty"`
 }
 
 func (PricelistItem) TableName() string {
@@ -47,6 +79,7 @@ func (PricelistItem) TableName() string {
 // PricelistSummary is used for list views
 type PricelistSummary struct {
 	ID           uint       `json:"id"`
+	Source       string     `json:"source"`
 	Version      string     `json:"version"`
 	Notification string     `json:"notification"`
 	CreatedAt    time.Time  `json:"created_at"`

internal/models/project.go

@@ -0,0 +1,21 @@
+package models
+
+import "time"
+
+type Project struct {
+	ID            uint      `gorm:"primaryKey;autoIncrement" json:"id"`
+	UUID          string    `gorm:"size:36;uniqueIndex;not null" json:"uuid"`
+	OwnerUsername string    `gorm:"size:100;not null;index" json:"owner_username"`
+	Code          string    `gorm:"size:100;not null;index:idx_qt_projects_code_variant,priority:1" json:"code"`
+	Variant       string    `gorm:"size:100;not null;default:'';index:idx_qt_projects_code_variant,priority:2" json:"variant"`
+	Name          *string   `gorm:"size:200" json:"name,omitempty"`
+	TrackerURL    string    `gorm:"size:500" json:"tracker_url"`
+	IsActive      bool      `gorm:"default:true;index" json:"is_active"`
+	IsSystem      bool      `gorm:"default:false;index" json:"is_system"`
+	CreatedAt     time.Time `gorm:"autoCreateTime" json:"created_at"`
+	UpdatedAt     time.Time `gorm:"autoUpdateTime" json:"updated_at"`
+}
+
+func (Project) TableName() string {
+	return "qt_projects"
+}

internal/models/sql_migrations.go

@@ -0,0 +1,227 @@
+package models
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	mysqlDriver "github.com/go-sql-driver/mysql"
+	"gorm.io/gorm"
+)
+
+type SQLSchemaMigration struct {
+	ID        uint      `gorm:"primaryKey;autoIncrement"`
+	Filename  string    `gorm:"size:255;uniqueIndex;not null"`
+	AppliedAt time.Time `gorm:"autoCreateTime"`
+}
+
+func (SQLSchemaMigration) TableName() string {
+	return "qt_schema_migrations"
+}
+
+// NeedsSQLMigrations reports whether at least one SQL migration from migrationsDir
+// is not yet recorded in qt_schema_migrations.
+func NeedsSQLMigrations(db *gorm.DB, migrationsDir string) (bool, error) {
+	files, err := listSQLMigrationFiles(migrationsDir)
+	if err != nil {
+		return false, err
+	}
+	if len(files) == 0 {
+		return false, nil
+	}
+
+	// If tracking table does not exist yet, migrations are required.
+	if !db.Migrator().HasTable(&SQLSchemaMigration{}) {
+		return true, nil
+	}
+
+	var count int64
+	if err := db.Model(&SQLSchemaMigration{}).Where("filename IN ?", files).Count(&count).Error; err != nil {
+		return false, fmt.Errorf("check applied migrations: %w", err)
+	}
+
+	return count < int64(len(files)), nil
+}
+
+// RunSQLMigrations applies SQL files from migrationsDir once and records them in qt_schema_migrations.
+// Local SQLite-only scripts are skipped automatically.
+func RunSQLMigrations(db *gorm.DB, migrationsDir string) error {
+	if err := ensureSQLMigrationsTable(db); err != nil {
+		return fmt.Errorf("migrate qt_schema_migrations table: %w", err)
+	}
+
+	files, err := listSQLMigrationFiles(migrationsDir)
+	if err != nil {
+		return err
+	}
+
+	for _, filename := range files {
+		var count int64
+		if err := db.Model(&SQLSchemaMigration{}).Where("filename = ?", filename).Count(&count).Error; err != nil {
+			return fmt.Errorf("check migration %s: %w", filename, err)
+		}
+		if count > 0 {
+			continue
+		}
+
+		path := filepath.Join(migrationsDir, filename)
+		content, err := os.ReadFile(path)
+		if err != nil {
+			return fmt.Errorf("read migration %s: %w", filename, err)
+		}
+
+		statements := splitSQLStatements(string(content))
+		if len(statements) == 0 {
+			if err := db.Create(&SQLSchemaMigration{Filename: filename}).Error; err != nil {
+				return fmt.Errorf("record empty migration %s: %w", filename, err)
+			}
+			continue
+		}
+
+		if err := executeMigrationStatements(db, filename, statements); err != nil {
+			return err
+		}
+		if err := db.Create(&SQLSchemaMigration{Filename: filename}).Error; err != nil {
+			return fmt.Errorf("record migration %s: %w", filename, err)
+		}
+	}
+
+	return nil
+}
+
+// IsMigrationPermissionError returns true if err indicates insufficient privileges
+// to create/alter/read migration metadata or target schema objects.
+func IsMigrationPermissionError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	var mysqlErr *mysqlDriver.MySQLError
+	if errors.As(err, &mysqlErr) {
+		switch mysqlErr.Number {
+		case 1044, 1045, 1142, 1143, 1227:
+			return true
+		}
+	}
+
+	lower := strings.ToLower(err.Error())
+	patterns := []string{
+		"command denied to user",
+		"access denied for user",
+		"permission denied",
+		"insufficient privilege",
+		"sqlstate 42000",
+	}
+	for _, pattern := range patterns {
+		if strings.Contains(lower, pattern) {
+			return true
+		}
+	}
+	return false
+}
+
+func ensureSQLMigrationsTable(db *gorm.DB) error {
+	stmt := `
+CREATE TABLE IF NOT EXISTS qt_schema_migrations (
+	id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+	filename VARCHAR(255) NOT NULL UNIQUE,
+	applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);`
+	return db.Exec(stmt).Error
+}
+
+func executeMigrationStatements(db *gorm.DB, filename string, statements []string) error {
+	for _, stmt := range statements {
+		if err := db.Exec(stmt).Error; err != nil {
+			if isIgnorableMigrationError(err.Error()) {
+				continue
+			}
+			return fmt.Errorf("exec migration %s statement %q: %w", filename, stmt, err)
+		}
+	}
+	return nil
+}
+
+func isSQLiteOnlyMigration(filename string) bool {
+	lower := strings.ToLower(filename)
+	return strings.Contains(lower, "local_")
+}
+
+func isIgnorableMigrationError(message string) bool {
+	lower := strings.ToLower(message)
+	ignorable := []string{
+		"duplicate column name",
+		"duplicate key name",
+		"already exists",
+		"can't create table",
+		"duplicate foreign key constraint name",
+		"errno 121",
+	}
+	for _, pattern := range ignorable {
+		if strings.Contains(lower, pattern) {
+			return true
+		}
+	}
+	return false
+}
+
+func splitSQLStatements(script string) []string {
+	scanner := bufio.NewScanner(strings.NewReader(script))
+	scanner.Buffer(make([]byte, 1024), 1024*1024)
+
+	lines := make([]string, 0, 128)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+		if strings.HasPrefix(line, "--") {
+			continue
+		}
+		lines = append(lines, scanner.Text())
+	}
+
+	combined := strings.Join(lines, "\n")
+	raw := strings.Split(combined, ";")
+	stmts := make([]string, 0, len(raw))
+	for _, stmt := range raw {
+		trimmed := strings.TrimSpace(stmt)
+		if trimmed == "" {
+			continue
+		}
+		stmts = append(stmts, trimmed)
+	}
+	return stmts
+}
+
+func listSQLMigrationFiles(migrationsDir string) ([]string, error) {
+	entries, err := os.ReadDir(migrationsDir)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("read migrations dir %s: %w", migrationsDir, err)
+	}
+
+	files := make([]string, 0, len(entries))
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+		name := entry.Name()
+		if !strings.HasSuffix(strings.ToLower(name), ".sql") {
+			continue
+		}
+		if isSQLiteOnlyMigration(name) {
+			continue
+		}
+		files = append(files, name)
+	}
+	sort.Strings(files)
+	return files, nil
+}

internal/repository/component.go

@@ -110,6 +110,10 @@ func (r *ComponentRepository) Update(component *models.LotMetadata) error {
 	return r.db.Save(component).Error
 }
 
+func (r *ComponentRepository) DB() *gorm.DB {
+	return r.db
+}
+
 func (r *ComponentRepository) Create(component *models.LotMetadata) error {
 	return r.db.Create(component).Error
 }

internal/repository/configuration.go

@@ -1,6 +1,8 @@
 package repository
 
 import (
+	"strings"
+
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"gorm.io/gorm"
 )
@@ -14,12 +16,18 @@ func NewConfigurationRepository(db *gorm.DB) *ConfigurationRepository {
 }
 
 func (r *ConfigurationRepository) Create(config *models.Configuration) error {
-	return r.db.Create(config).Error
+	if err := r.db.Create(config).Error; err != nil {
+		if isUnknownLineNoColumnError(err) {
+			return r.db.Omit("line_no").Create(config).Error
+		}
+		return err
+	}
+	return nil
 }
 
 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 +36,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
 	}
@@ -36,20 +44,36 @@ func (r *ConfigurationRepository) GetByUUID(uuid string) (*models.Configuration,
 }
 
 func (r *ConfigurationRepository) Update(config *models.Configuration) error {
-	return r.db.Save(config).Error
+	if err := r.db.Save(config).Error; err != nil {
+		if isUnknownLineNoColumnError(err) {
+			return r.db.Omit("line_no").Save(config).Error
+		}
+		return err
+	}
+	return nil
+}
+
+func isUnknownLineNoColumnError(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := strings.ToLower(err.Error())
+	return strings.Contains(msg, "unknown column 'line_no'") || strings.Contains(msg, "no column named line_no")
 }
 
 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 +88,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/partnumber_book.go

@@ -0,0 +1,66 @@
+package repository
+
+import (
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"gorm.io/gorm"
+)
+
+// PartnumberBookRepository provides read-only access to local partnumber book snapshots.
+type PartnumberBookRepository struct {
+	db *gorm.DB
+}
+
+func NewPartnumberBookRepository(db *gorm.DB) *PartnumberBookRepository {
+	return &PartnumberBookRepository{db: db}
+}
+
+// GetActiveBook returns the most recently active local partnumber book.
+func (r *PartnumberBookRepository) GetActiveBook() (*localdb.LocalPartnumberBook, error) {
+	var book localdb.LocalPartnumberBook
+	err := r.db.Where("is_active = 1").Order("created_at DESC, id DESC").First(&book).Error
+	if err != nil {
+		return nil, err
+	}
+	return &book, nil
+}
+
+// GetBookItems returns all items for the given local book ID.
+func (r *PartnumberBookRepository) GetBookItems(bookID uint) ([]localdb.LocalPartnumberBookItem, error) {
+	var items []localdb.LocalPartnumberBookItem
+	err := r.db.Where("book_id = ?", bookID).Find(&items).Error
+	return items, err
+}
+
+// FindLotByPartnumber looks up a partnumber in the active book and returns the matching items.
+func (r *PartnumberBookRepository) FindLotByPartnumber(bookID uint, partnumber string) ([]localdb.LocalPartnumberBookItem, error) {
+	var items []localdb.LocalPartnumberBookItem
+	err := r.db.Where("book_id = ? AND partnumber = ?", bookID, partnumber).Find(&items).Error
+	return items, err
+}
+
+// ListBooks returns all local partnumber books ordered newest first.
+func (r *PartnumberBookRepository) ListBooks() ([]localdb.LocalPartnumberBook, error) {
+	var books []localdb.LocalPartnumberBook
+	err := r.db.Order("created_at DESC, id DESC").Find(&books).Error
+	return books, err
+}
+
+// SaveBook saves a new partnumber book snapshot.
+func (r *PartnumberBookRepository) SaveBook(book *localdb.LocalPartnumberBook) error {
+	return r.db.Save(book).Error
+}
+
+// SaveBookItems bulk-inserts items for a book snapshot.
+func (r *PartnumberBookRepository) SaveBookItems(items []localdb.LocalPartnumberBookItem) error {
+	if len(items) == 0 {
+		return nil
+	}
+	return r.db.CreateInBatches(items, 500).Error
+}
+
+// CountBookItems returns the number of items for a given local book ID.
+func (r *PartnumberBookRepository) CountBookItems(bookID uint) int64 {
+	var count int64
+	r.db.Model(&localdb.LocalPartnumberBookItem{}).Where("book_id = ?", bookID).Count(&count)
+	return count
+}

internal/repository/pricelist.go

@@ -1,10 +1,15 @@
 package repository
 
 import (
+	"errors"
 	"fmt"
+	"log/slog"
+	"sort"
+	"strconv"
 	"strings"
 	"time"
 
+	"git.mchus.pro/mchus/quoteforge/internal/lotmatch"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"gorm.io/gorm"
 )
@@ -19,36 +24,89 @@ func NewPricelistRepository(db *gorm.DB) *PricelistRepository {
 
 // List returns pricelists with pagination
 func (r *PricelistRepository) List(offset, limit int) ([]models.PricelistSummary, int64, error) {
+	return r.ListBySource("", offset, limit)
+}
+
+// ListBySource returns pricelists filtered by source when provided.
+func (r *PricelistRepository) ListBySource(source string, offset, limit int) ([]models.PricelistSummary, int64, error) {
+	query := r.db.Model(&models.Pricelist{}).
+		Where("EXISTS (SELECT 1 FROM qt_pricelist_items WHERE qt_pricelist_items.pricelist_id = qt_pricelists.id)")
+	if source != "" {
+		query = query.Where("source = ?", source)
+	}
+
 	var total int64
-	if err := r.db.Model(&models.Pricelist{}).Count(&total).Error; err != nil {
+	if err := query.Count(&total).Error; err != nil {
 		return nil, 0, fmt.Errorf("counting pricelists: %w", err)
 	}
 
 	var pricelists []models.Pricelist
-	if err := r.db.Order("created_at DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
+	if err := query.Order("created_at DESC, id DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
 		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) {
+	return r.ListActiveBySource("", offset, limit)
+}
+
+// ListActiveBySource returns active pricelists filtered by source when provided.
+func (r *PricelistRepository) ListActiveBySource(source string, offset, limit int) ([]models.PricelistSummary, int64, error) {
+	query := r.db.Model(&models.Pricelist{}).
+		Where("is_active = ?", true).
+		Where("EXISTS (SELECT 1 FROM qt_pricelist_items WHERE qt_pricelist_items.pricelist_id = qt_pricelists.id)")
+	if source != "" {
+		query = query.Where("source = ?", source)
+	}
+
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, fmt.Errorf("counting active pricelists: %w", err)
+	}
+
+	var pricelists []models.Pricelist
+	if err := query.Order("created_at DESC, id 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 {
 		var itemCount int64
 		r.db.Model(&models.PricelistItem{}).Where("pricelist_id = ?", pl.ID).Count(&itemCount)
+		usageCount, _ := r.CountUsage(pl.ID)
 
 		summaries[i] = models.PricelistSummary{
 			ID:           pl.ID,
+			Source:       pl.Source,
 			Version:      pl.Version,
 			Notification: pl.Notification,
 			CreatedAt:    pl.CreatedAt,
 			CreatedBy:    pl.CreatedBy,
 			IsActive:     pl.IsActive,
-			UsageCount:   pl.UsageCount,
+			UsageCount:   int(usageCount),
 			ExpiresAt:    pl.ExpiresAt,
 			ItemCount:    itemCount,
 		}
 	}
 
-	return summaries, total, nil
+	return summaries
 }
 
 // GetByID returns a pricelist by ID
@@ -62,14 +120,22 @@ func (r *PricelistRepository) GetByID(id uint) (*models.Pricelist, error) {
 	var itemCount int64
 	r.db.Model(&models.PricelistItem{}).Where("pricelist_id = ?", id).Count(&itemCount)
 	pricelist.ItemCount = int(itemCount)
+	if usageCount, err := r.CountUsage(id); err == nil {
+		pricelist.UsageCount = int(usageCount)
+	}
 
 	return &pricelist, nil
 }
 
 // GetByVersion returns a pricelist by version string
 func (r *PricelistRepository) GetByVersion(version string) (*models.Pricelist, error) {
+	return r.GetBySourceAndVersion(string(models.PricelistSourceEstimate), version)
+}
+
+// GetBySourceAndVersion returns a pricelist by source/version.
+func (r *PricelistRepository) GetBySourceAndVersion(source, version string) (*models.Pricelist, error) {
 	var pricelist models.Pricelist
-	if err := r.db.Where("version = ?", version).First(&pricelist).Error; err != nil {
+	if err := r.db.Where("source = ? AND version = ?", source, version).First(&pricelist).Error; err != nil {
 		return nil, fmt.Errorf("getting pricelist by version: %w", err)
 	}
 	return &pricelist, nil
@@ -77,8 +143,17 @@ func (r *PricelistRepository) GetByVersion(version string) (*models.Pricelist, e
 
 // GetLatestActive returns the most recent active pricelist
 func (r *PricelistRepository) GetLatestActive() (*models.Pricelist, error) {
+	return r.GetLatestActiveBySource(string(models.PricelistSourceEstimate))
+}
+
+// GetLatestActiveBySource returns the most recent active pricelist by source.
+func (r *PricelistRepository) GetLatestActiveBySource(source string) (*models.Pricelist, error) {
 	var pricelist models.Pricelist
-	if err := r.db.Where("is_active = ?", true).Order("created_at DESC").First(&pricelist).Error; err != nil {
+	if err := r.db.
+		Where("is_active = ? AND source = ?", true, source).
+		Where("EXISTS (SELECT 1 FROM qt_pricelist_items WHERE qt_pricelist_items.pricelist_id = qt_pricelists.id)").
+		Order("created_at DESC, id DESC").
+		First(&pricelist).Error; err != nil {
 		return nil, fmt.Errorf("getting latest pricelist: %w", err)
 	}
 	return &pricelist, nil
@@ -102,13 +177,13 @@ func (r *PricelistRepository) Update(pricelist *models.Pricelist) error {
 
 // Delete deletes a pricelist if usage_count is 0
 func (r *PricelistRepository) Delete(id uint) error {
-	pricelist, err := r.GetByID(id)
+	usageCount, err := r.CountUsage(id)
 	if err != nil {
 		return err
 	}
 
-	if pricelist.UsageCount > 0 {
-		return fmt.Errorf("cannot delete pricelist with usage_count > 0 (current: %d)", pricelist.UsageCount)
+	if usageCount > 0 {
+		return fmt.Errorf("cannot delete pricelist with usage_count > 0 (current: %d)", usageCount)
 	}
 
 	// Delete items first
@@ -168,28 +243,205 @@ func (r *PricelistRepository) GetItems(pricelistID uint, offset, limit int, sear
 		if err := r.db.Where("lot_name = ?", items[i].LotName).First(&lot).Error; err == nil {
 			items[i].LotDescription = lot.LotDescription
 		}
-		// Parse category from lot_name (e.g., "CPU_AMD_9654" -> "CPU")
-		parts := strings.SplitN(items[i].LotName, "_", 2)
-		if len(parts) >= 1 {
-			items[i].Category = parts[0]
-		}
+		items[i].Category = strings.TrimSpace(items[i].LotCategory)
+	}
+
+	// Stock/partnumber enrichment is optional for pricelist item listing.
+	// Return base pricelist rows (lot_name/price/category) even when DB user lacks
+	// access to stock mapping tables (e.g. lot_partnumbers, stock_log).
+	if err := r.enrichItemsWithStock(items); err != nil {
+		slog.Warn("pricelist items stock enrichment skipped", "pricelist_id", pricelistID, "error", err)
 	}
 
 	return items, total, nil
 }
 
-// GenerateVersion generates a new version string in format YYYY-MM-DD-NNN
-func (r *PricelistRepository) GenerateVersion() (string, error) {
-	today := time.Now().Format("2006-01-02")
-
-	var count int64
-	if err := r.db.Model(&models.Pricelist{}).
-		Where("version LIKE ?", today+"%").
-		Count(&count).Error; err != nil {
-		return "", fmt.Errorf("counting today's pricelists: %w", err)
+func (r *PricelistRepository) enrichItemsWithStock(items []models.PricelistItem) error {
+	if len(items) == 0 {
+		return nil
 	}
 
-	return fmt.Sprintf("%s-%03d", today, count+1), nil
+	resolver, err := lotmatch.NewLotResolverFromDB(r.db)
+	if err != nil {
+		return err
+	}
+
+	type stockRow struct {
+		Partnumber string   `gorm:"column:partnumber"`
+		Qty        *float64 `gorm:"column:qty"`
+	}
+	rows := make([]stockRow, 0)
+	if err := r.db.Raw(`
+		SELECT s.partnumber, s.qty
+		FROM stock_log s
+		INNER JOIN (
+			SELECT partnumber, MAX(date) AS max_date
+			FROM stock_log
+			GROUP BY partnumber
+		) latest ON latest.partnumber = s.partnumber AND latest.max_date = s.date
+		WHERE s.qty IS NOT NULL
+	`).Scan(&rows).Error; err != nil {
+		return err
+	}
+
+	lotTotals := make(map[string]float64, len(items))
+	lotPartnumbers := make(map[string][]string, len(items))
+	seenPartnumbers := make(map[string]map[string]struct{}, len(items))
+
+	for i := range rows {
+		row := rows[i]
+		if strings.TrimSpace(row.Partnumber) == "" {
+			continue
+		}
+		lotName, _, resolveErr := resolver.Resolve(row.Partnumber)
+		if resolveErr != nil || strings.TrimSpace(lotName) == "" {
+			continue
+		}
+
+		if row.Qty != nil {
+			lotTotals[lotName] += *row.Qty
+		}
+
+		pn := strings.TrimSpace(row.Partnumber)
+		if pn == "" {
+			continue
+		}
+		if _, ok := seenPartnumbers[lotName]; !ok {
+			seenPartnumbers[lotName] = make(map[string]struct{}, 4)
+		}
+		key := strings.ToLower(pn)
+		if _, exists := seenPartnumbers[lotName][key]; exists {
+			continue
+		}
+		seenPartnumbers[lotName][key] = struct{}{}
+		lotPartnumbers[lotName] = append(lotPartnumbers[lotName], pn)
+	}
+
+	for i := range items {
+		lotName := items[i].LotName
+		if qty, ok := lotTotals[lotName]; ok {
+			qtyCopy := qty
+			items[i].AvailableQty = &qtyCopy
+		}
+		if partnumbers := lotPartnumbers[lotName]; len(partnumbers) > 0 {
+			sort.Slice(partnumbers, func(a, b int) bool {
+				return strings.ToLower(partnumbers[a]) < strings.ToLower(partnumbers[b])
+			})
+			items[i].Partnumbers = partnumbers
+		}
+	}
+
+	return nil
+}
+
+// GetLotNames returns distinct lot names from pricelist items.
+func (r *PricelistRepository) GetLotNames(pricelistID uint) ([]string, error) {
+	var lotNames []string
+	if err := r.db.Model(&models.PricelistItem{}).
+		Where("pricelist_id = ?", pricelistID).
+		Distinct("lot_name").
+		Order("lot_name ASC").
+		Pluck("lot_name", &lotNames).Error; err != nil {
+		return nil, fmt.Errorf("listing pricelist lot names: %w", err)
+	}
+	return lotNames, nil
+}
+
+// GetPriceForLot returns item price for a lot within a pricelist.
+func (r *PricelistRepository) GetPriceForLot(pricelistID uint, lotName string) (float64, error) {
+	var item models.PricelistItem
+	if err := r.db.Where("pricelist_id = ? AND lot_name = ?", pricelistID, lotName).First(&item).Error; err != nil {
+		return 0, err
+	}
+	return item.Price, nil
+}
+
+// GetPricesForLots returns price map for given lots within a pricelist.
+func (r *PricelistRepository) GetPricesForLots(pricelistID uint, lotNames []string) (map[string]float64, error) {
+	result := make(map[string]float64, len(lotNames))
+	if pricelistID == 0 || len(lotNames) == 0 {
+		return result, nil
+	}
+
+	var rows []models.PricelistItem
+	if err := r.db.Select("lot_name, price").
+		Where("pricelist_id = ? AND lot_name IN ?", pricelistID, lotNames).
+		Find(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	for _, row := range rows {
+		if row.Price > 0 {
+			result[row.LotName] = row.Price
+		}
+	}
+	return result, nil
+}
+
+// SetActive toggles active flag on a pricelist.
+func (r *PricelistRepository) SetActive(id uint, isActive bool) error {
+	return r.db.Model(&models.Pricelist{}).Where("id = ?", id).Update("is_active", isActive).Error
+}
+
+// GenerateVersion generates a new version string in format YYYY-MM-DD-NNN
+func (r *PricelistRepository) GenerateVersion() (string, error) {
+	return r.GenerateVersionBySource(string(models.PricelistSourceEstimate))
+}
+
+// GenerateVersionBySource generates a new version string in format YYYY-MM-DD-NNN scoped by source.
+func (r *PricelistRepository) GenerateVersionBySource(source string) (string, error) {
+	today := time.Now().Format("2006-01-02")
+	prefix := versionPrefixBySource(source)
+
+	var last models.Pricelist
+	err := r.db.Model(&models.Pricelist{}).
+		Select("version").
+		Where("source = ? AND version LIKE ?", source, prefix+"-"+today+"-%").
+		Order("version DESC").
+		Limit(1).
+		Take(&last).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return fmt.Sprintf("%s-%s-001", prefix, today), nil
+		}
+		return "", fmt.Errorf("loading latest today's pricelist version: %w", err)
+	}
+
+	parts := strings.Split(last.Version, "-")
+	if len(parts) < 4 {
+		return "", fmt.Errorf("invalid pricelist version format: %s", last.Version)
+	}
+
+	n, err := strconv.Atoi(parts[len(parts)-1])
+	if err != nil {
+		return "", fmt.Errorf("parsing pricelist sequence %q: %w", parts[len(parts)-1], err)
+	}
+
+	return fmt.Sprintf("%s-%s-%03d", prefix, today, n+1), nil
+}
+
+func versionPrefixBySource(source string) string {
+	switch models.NormalizePricelistSource(source) {
+	case models.PricelistSourceWarehouse:
+		return "S"
+	case models.PricelistSourceCompetitor:
+		return "B"
+	default:
+		return "E"
+	}
+}
+
+// GetPriceForLotBySource returns item price for a lot from latest active pricelist of source.
+func (r *PricelistRepository) GetPriceForLotBySource(source, lotName string) (float64, uint, error) {
+	latest, err := r.GetLatestActiveBySource(source)
+	if err != nil {
+		return 0, 0, err
+	}
+	price, err := r.GetPriceForLot(latest.ID, lotName)
+	if err != nil {
+		return 0, 0, err
+	}
+	return price, latest.ID, nil
 }
 
 // CanWrite checks if the current database user has INSERT permission on qt_pricelists
@@ -248,6 +500,15 @@ func (r *PricelistRepository) DecrementUsageCount(id uint) error {
 		UpdateColumn("usage_count", gorm.Expr("GREATEST(usage_count - 1, 0)")).Error
 }
 
+// CountUsage returns number of configurations referencing pricelist.
+func (r *PricelistRepository) CountUsage(id uint) (int64, error) {
+	var count int64
+	if err := r.db.Table("qt_configurations").Where("pricelist_id = ?", id).Count(&count).Error; err != nil {
+		return 0, fmt.Errorf("counting configurations for pricelist %d: %w", id, err)
+	}
+	return count, nil
+}
+
 // GetExpiredUnused returns pricelists that are expired and unused
 func (r *PricelistRepository) GetExpiredUnused() ([]models.Pricelist, error) {
 	var pricelists []models.Pricelist

internal/repository/pricelist_test.go

@@ -0,0 +1,235 @@
+package repository
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+)
+
+func TestGenerateVersion_FirstOfDay(t *testing.T) {
+	repo := newTestPricelistRepository(t)
+
+	version, err := repo.GenerateVersionBySource(string(models.PricelistSourceEstimate))
+	if err != nil {
+		t.Fatalf("GenerateVersionBySource returned error: %v", err)
+	}
+
+	today := time.Now().Format("2006-01-02")
+	want := fmt.Sprintf("E-%s-001", today)
+	if version != want {
+		t.Fatalf("expected %s, got %s", want, version)
+	}
+}
+
+func TestGenerateVersion_UsesMaxSuffixNotCount(t *testing.T) {
+	repo := newTestPricelistRepository(t)
+	today := time.Now().Format("2006-01-02")
+
+	seed := []models.Pricelist{
+		{Source: string(models.PricelistSourceEstimate), Version: fmt.Sprintf("E-%s-001", today), CreatedBy: "test", IsActive: true},
+		{Source: string(models.PricelistSourceEstimate), Version: fmt.Sprintf("E-%s-003", today), CreatedBy: "test", IsActive: true},
+	}
+	for _, pl := range seed {
+		if err := repo.Create(&pl); err != nil {
+			t.Fatalf("seed insert failed: %v", err)
+		}
+	}
+
+	version, err := repo.GenerateVersionBySource(string(models.PricelistSourceEstimate))
+	if err != nil {
+		t.Fatalf("GenerateVersionBySource returned error: %v", err)
+	}
+
+	want := fmt.Sprintf("E-%s-004", today)
+	if version != want {
+		t.Fatalf("expected %s, got %s", want, version)
+	}
+}
+
+func TestGenerateVersion_IsolatedBySource(t *testing.T) {
+	repo := newTestPricelistRepository(t)
+	today := time.Now().Format("2006-01-02")
+
+	seed := []models.Pricelist{
+		{Source: string(models.PricelistSourceEstimate), Version: fmt.Sprintf("E-%s-009", today), CreatedBy: "test", IsActive: true},
+		{Source: string(models.PricelistSourceWarehouse), Version: fmt.Sprintf("S-%s-002", today), CreatedBy: "test", IsActive: true},
+	}
+	for _, pl := range seed {
+		if err := repo.Create(&pl); err != nil {
+			t.Fatalf("seed insert failed: %v", err)
+		}
+	}
+
+	version, err := repo.GenerateVersionBySource(string(models.PricelistSourceWarehouse))
+	if err != nil {
+		t.Fatalf("GenerateVersionBySource returned error: %v", err)
+	}
+
+	want := fmt.Sprintf("S-%s-003", today)
+	if version != want {
+		t.Fatalf("expected %s, got %s", want, version)
+	}
+}
+
+func TestGetItems_WarehouseAvailableQtyUsesPrefixResolver(t *testing.T) {
+	repo := newTestPricelistRepository(t)
+	db := repo.db
+
+	warehouse := models.Pricelist{
+		Source:    string(models.PricelistSourceWarehouse),
+		Version:   "S-2026-02-07-001",
+		CreatedBy: "test",
+		IsActive:  true,
+	}
+	if err := db.Create(&warehouse).Error; err != nil {
+		t.Fatalf("create pricelist: %v", err)
+	}
+	if err := db.Create(&models.PricelistItem{
+		PricelistID: warehouse.ID,
+		LotName:     "SSD_NVME_03.2T",
+		Price:       100,
+	}).Error; err != nil {
+		t.Fatalf("create pricelist item: %v", err)
+	}
+	if err := db.Create(&models.Lot{LotName: "SSD_NVME_03.2T"}).Error; err != nil {
+		t.Fatalf("create lot: %v", err)
+	}
+	qty := 5.0
+	if err := db.Create(&models.StockLog{
+		Partnumber: "SSD_NVME_03.2T_GEN3_P4610",
+		Date:       time.Now(),
+		Price:      200,
+		Qty:        &qty,
+	}).Error; err != nil {
+		t.Fatalf("create stock log: %v", err)
+	}
+
+	items, total, err := repo.GetItems(warehouse.ID, 0, 20, "")
+	if err != nil {
+		t.Fatalf("GetItems: %v", err)
+	}
+	if total != 1 {
+		t.Fatalf("expected total=1, got %d", total)
+	}
+	if len(items) != 1 {
+		t.Fatalf("expected 1 item, got %d", len(items))
+	}
+	if items[0].AvailableQty == nil {
+		t.Fatalf("expected available qty to be set")
+	}
+	if *items[0].AvailableQty != 5 {
+		t.Fatalf("expected available qty=5, got %v", *items[0].AvailableQty)
+	}
+}
+
+func TestGetLatestActiveBySource_SkipsPricelistsWithoutItems(t *testing.T) {
+	repo := newTestPricelistRepository(t)
+	db := repo.db
+	ts := time.Now().Add(-time.Minute)
+	source := "test-estimate-skip-empty"
+
+	emptyLatest := models.Pricelist{
+		Source:    source,
+		Version:   "E-empty",
+		CreatedBy: "test",
+		IsActive:  true,
+		CreatedAt: ts.Add(2 * time.Second),
+	}
+	if err := db.Create(&emptyLatest).Error; err != nil {
+		t.Fatalf("create empty pricelist: %v", err)
+	}
+
+	withItems := models.Pricelist{
+		Source:    source,
+		Version:   "E-with-items",
+		CreatedBy: "test",
+		IsActive:  true,
+		CreatedAt: ts,
+	}
+	if err := db.Create(&withItems).Error; err != nil {
+		t.Fatalf("create pricelist with items: %v", err)
+	}
+	if err := db.Create(&models.PricelistItem{
+		PricelistID: withItems.ID,
+		LotName:     "CPU_A",
+		Price:       100,
+	}).Error; err != nil {
+		t.Fatalf("create pricelist item: %v", err)
+	}
+
+	got, err := repo.GetLatestActiveBySource(source)
+	if err != nil {
+		t.Fatalf("GetLatestActiveBySource: %v", err)
+	}
+	if got.ID != withItems.ID {
+		t.Fatalf("expected pricelist with items id=%d, got id=%d", withItems.ID, got.ID)
+	}
+}
+
+func TestGetLatestActiveBySource_TieBreaksByID(t *testing.T) {
+	repo := newTestPricelistRepository(t)
+	db := repo.db
+	ts := time.Now().Add(-time.Minute)
+	source := "test-warehouse-tie-break"
+
+	first := models.Pricelist{
+		Source:    source,
+		Version:   "S-1",
+		CreatedBy: "test",
+		IsActive:  true,
+		CreatedAt: ts,
+	}
+	if err := db.Create(&first).Error; err != nil {
+		t.Fatalf("create first pricelist: %v", err)
+	}
+	if err := db.Create(&models.PricelistItem{
+		PricelistID: first.ID,
+		LotName:     "CPU_A",
+		Price:       101,
+	}).Error; err != nil {
+		t.Fatalf("create first item: %v", err)
+	}
+
+	second := models.Pricelist{
+		Source:    source,
+		Version:   "S-2",
+		CreatedBy: "test",
+		IsActive:  true,
+		CreatedAt: ts,
+	}
+	if err := db.Create(&second).Error; err != nil {
+		t.Fatalf("create second pricelist: %v", err)
+	}
+	if err := db.Create(&models.PricelistItem{
+		PricelistID: second.ID,
+		LotName:     "CPU_A",
+		Price:       102,
+	}).Error; err != nil {
+		t.Fatalf("create second item: %v", err)
+	}
+
+	got, err := repo.GetLatestActiveBySource(source)
+	if err != nil {
+		t.Fatalf("GetLatestActiveBySource: %v", err)
+	}
+	if got.ID != second.ID {
+		t.Fatalf("expected later inserted pricelist id=%d, got id=%d", second.ID, got.ID)
+	}
+}
+
+func newTestPricelistRepository(t *testing.T) *PricelistRepository {
+	t.Helper()
+
+	db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+	if err := db.AutoMigrate(&models.Pricelist{}, &models.PricelistItem{}, &models.Lot{}, &models.LotPartnumber{}, &models.StockLog{}); err != nil {
+		t.Fatalf("migrate: %v", err)
+	}
+	return NewPricelistRepository(db)
+}

internal/repository/project.go

@@ -0,0 +1,196 @@
+package repository
+
+import (
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+type ProjectRepository struct {
+	db *gorm.DB
+}
+
+func NewProjectRepository(db *gorm.DB) *ProjectRepository {
+	return &ProjectRepository{db: db}
+}
+
+func (r *ProjectRepository) Create(project *models.Project) error {
+	return r.db.Create(project).Error
+}
+
+func (r *ProjectRepository) Update(project *models.Project) error {
+	return r.db.Save(project).Error
+}
+
+func (r *ProjectRepository) UpsertByUUID(project *models.Project) error {
+	if err := r.db.Clauses(clause.OnConflict{
+		Columns: []clause.Column{{Name: "uuid"}},
+		DoUpdates: clause.AssignmentColumns([]string{
+			"owner_username",
+			"code",
+			"variant",
+			"name",
+			"tracker_url",
+			"is_active",
+			"is_system",
+			"updated_at",
+		}),
+	}).Create(project).Error; err != nil {
+		return err
+	}
+
+	// Ensure caller always gets canonical server ID.
+	var persisted models.Project
+	if err := r.db.Where("uuid = ?", project.UUID).First(&persisted).Error; err != nil {
+		return err
+	}
+	project.ID = persisted.ID
+	return nil
+}
+
+func (r *ProjectRepository) GetByUUID(uuid string) (*models.Project, error) {
+	var project models.Project
+	if err := r.db.Where("uuid = ?", uuid).First(&project).Error; err != nil {
+		return nil, err
+	}
+	return &project, nil
+}
+
+func (r *ProjectRepository) GetSystemByOwner(ownerUsername string) (*models.Project, error) {
+	var project models.Project
+	if err := r.db.Where("owner_username = ? AND is_system = ? AND name = ?", ownerUsername, true, "Без проекта").
+		First(&project).Error; err != nil {
+		return nil, err
+	}
+	return &project, nil
+}
+
+func (r *ProjectRepository) List(offset, limit int, includeArchived bool) ([]models.Project, int64, error) {
+	var projects []models.Project
+	var total int64
+
+	query := r.db.Model(&models.Project{})
+	if !includeArchived {
+		query = query.Where("is_active = ?", true)
+	}
+
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	if err := query.Order("created_at DESC").Offset(offset).Limit(limit).Find(&projects).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return projects, total, nil
+}
+
+func (r *ProjectRepository) ListByOwner(ownerUsername string, includeArchived bool) ([]models.Project, error) {
+	var projects []models.Project
+
+	query := r.db.Where("owner_username = ?", ownerUsername)
+	if !includeArchived {
+		query = query.Where("is_active = ?", true)
+	}
+
+	if err := query.Order("created_at DESC").Find(&projects).Error; err != nil {
+		return nil, err
+	}
+	return projects, nil
+}
+
+func (r *ProjectRepository) Archive(uuid string) error {
+	return r.db.Model(&models.Project{}).Where("uuid = ?", uuid).Update("is_active", false).Error
+}
+
+func (r *ProjectRepository) Reactivate(uuid string) error {
+	return r.db.Model(&models.Project{}).Where("uuid = ?", uuid).Update("is_active", true).Error
+}
+
+// PurgeEmptyNamelessProjects removes service-trash projects that have no configurations attached:
+// 1) projects with empty names;
+// 2) duplicate "Без проекта" rows without configurations (case-insensitive, trimmed).
+func (r *ProjectRepository) PurgeEmptyNamelessProjects() (int64, error) {
+	tx := r.db.Exec(`
+DELETE p
+FROM qt_projects p
+WHERE (
+      TRIM(COALESCE(p.name, '')) = ''
+      OR LOWER(TRIM(COALESCE(p.name, ''))) = LOWER('Без проекта')
+)
+  AND NOT EXISTS (
+      SELECT 1
+      FROM qt_configurations c
+      WHERE c.project_uuid = p.uuid
+  )`)
+	return tx.RowsAffected, tx.Error
+}
+
+// EnsureSystemProjectsAndBackfillConfigurations ensures there is a single shared system project
+// named "Без проекта", reassigns orphan/legacy links to it and removes duplicates.
+func (r *ProjectRepository) EnsureSystemProjectsAndBackfillConfigurations() error {
+	return r.db.Transaction(func(tx *gorm.DB) error {
+		type row struct {
+			UUID string `gorm:"column:uuid"`
+		}
+		var canonical row
+		err := tx.Raw(`
+SELECT uuid
+FROM qt_projects
+WHERE LOWER(TRIM(COALESCE(name, ''))) = LOWER('Без проекта')
+  AND is_system = TRUE
+ORDER BY CASE WHEN TRIM(COALESCE(owner_username, '')) = '' THEN 0 ELSE 1 END, created_at ASC, id ASC
+LIMIT 1`).Scan(&canonical).Error
+		if err != nil {
+			return err
+		}
+		if canonical.UUID == "" {
+			if err := tx.Exec(`
+INSERT INTO qt_projects (uuid, owner_username, name, is_active, is_system, created_at, updated_at)
+VALUES (UUID(), '', 'Без проекта', TRUE, TRUE, NOW(), NOW())`).Error; err != nil {
+				return err
+			}
+			if err := tx.Raw(`
+SELECT uuid
+FROM qt_projects
+WHERE LOWER(TRIM(COALESCE(name, ''))) = LOWER('Без проекта')
+ORDER BY created_at DESC, id DESC
+LIMIT 1`).Scan(&canonical).Error; err != nil {
+				return err
+			}
+			if canonical.UUID == "" {
+				return gorm.ErrRecordNotFound
+			}
+		}
+
+		if err := tx.Exec(`
+UPDATE qt_projects
+SET name = 'Без проекта',
+    is_active = TRUE,
+    is_system = TRUE
+WHERE uuid = ?`, canonical.UUID).Error; err != nil {
+			return err
+		}
+
+		if err := tx.Exec(`
+UPDATE qt_configurations
+SET project_uuid = ?
+WHERE project_uuid IS NULL OR project_uuid = ''`, canonical.UUID).Error; err != nil {
+			return err
+		}
+
+		if err := tx.Exec(`
+UPDATE qt_configurations c
+JOIN qt_projects p ON p.uuid = c.project_uuid
+SET c.project_uuid = ?
+WHERE LOWER(TRIM(COALESCE(p.name, ''))) = LOWER('Без проекта')
+  AND p.uuid <> ?`, canonical.UUID, canonical.UUID).Error; err != nil {
+			return err
+		}
+
+		return tx.Exec(`
+DELETE FROM qt_projects
+WHERE LOWER(TRIM(COALESCE(name, ''))) = LOWER('Без проекта')
+  AND uuid <> ?`, canonical.UUID).Error
+	})
+}

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
 
@@ -83,10 +83,6 @@ func (r *UnifiedRepo) getComponentsOffline(filter ComponentFilter, offset, limit
 		search := "%" + filter.Search + "%"
 		query = query.Where("lot_name LIKE ? OR lot_description LIKE ? OR model LIKE ?", search, search, search)
 	}
-	if filter.HasPrice {
-		query = query.Where("current_price IS NOT NULL AND current_price > 0")
-	}
-
 	var total int64
 	query.Count(&total)
 
@@ -96,8 +92,6 @@ func (r *UnifiedRepo) getComponentsOffline(filter ComponentFilter, offset, limit
 		sortDir = "DESC"
 	}
 	switch filter.SortField {
-	case "current_price":
-		query = query.Order("current_price " + sortDir)
 	case "lot_name":
 		query = query.Order("lot_name " + sortDir)
 	default:
@@ -112,9 +106,8 @@ func (r *UnifiedRepo) getComponentsOffline(filter ComponentFilter, offset, limit
 	result := make([]models.LotMetadata, len(components))
 	for i, comp := range components {
 		result[i] = models.LotMetadata{
-			LotName:      comp.LotName,
-			Model:        comp.Model,
-			CurrentPrice: comp.CurrentPrice,
+			LotName: comp.LotName,
+			Model:   comp.Model,
 			Lot: &models.Lot{
 				LotName:        comp.LotName,
 				LotDescription: comp.LotDescription,
@@ -138,9 +131,8 @@ func (r *UnifiedRepo) GetComponent(lotName string) (*models.LotMetadata, error)
 	}
 
 	return &models.LotMetadata{
-		LotName:      comp.LotName,
-		Model:        comp.Model,
-		CurrentPrice: comp.CurrentPrice,
+		LotName: comp.LotName,
+		Model:   comp.Model,
 		Lot: &models.Lot{
 			LotName:        comp.LotName,
 			LotDescription: comp.LotDescription,
@@ -159,16 +151,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 +189,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 +215,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/alerts/service.go

@@ -1,199 +0,0 @@
-package alerts
-
-import (
-	"fmt"
-	"time"
-
-	"git.mchus.pro/mchus/quoteforge/internal/config"
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-)
-
-type Service struct {
-	alertRepo     *repository.AlertRepository
-	componentRepo *repository.ComponentRepository
-	priceRepo     *repository.PriceRepository
-	statsRepo     *repository.StatsRepository
-	config        config.AlertsConfig
-	pricingConfig config.PricingConfig
-}
-
-func NewService(
-	alertRepo *repository.AlertRepository,
-	componentRepo *repository.ComponentRepository,
-	priceRepo *repository.PriceRepository,
-	statsRepo *repository.StatsRepository,
-	alertCfg config.AlertsConfig,
-	pricingCfg config.PricingConfig,
-) *Service {
-	return &Service{
-		alertRepo:     alertRepo,
-		componentRepo: componentRepo,
-		priceRepo:     priceRepo,
-		statsRepo:     statsRepo,
-		config:        alertCfg,
-		pricingConfig: pricingCfg,
-	}
-}
-
-func (s *Service) List(filter repository.AlertFilter, page, perPage int) ([]models.PricingAlert, int64, error) {
-	if page < 1 {
-		page = 1
-	}
-	if perPage < 1 || perPage > 100 {
-		perPage = 20
-	}
-	offset := (page - 1) * perPage
-
-	return s.alertRepo.List(filter, offset, perPage)
-}
-
-func (s *Service) Acknowledge(id uint) error {
-	return s.alertRepo.UpdateStatus(id, models.AlertStatusAcknowledged)
-}
-
-func (s *Service) Resolve(id uint) error {
-	return s.alertRepo.UpdateStatus(id, models.AlertStatusResolved)
-}
-
-func (s *Service) Ignore(id uint) error {
-	return s.alertRepo.UpdateStatus(id, models.AlertStatusIgnored)
-}
-
-func (s *Service) GetNewAlertsCount() (int64, error) {
-	return s.alertRepo.CountByStatus(models.AlertStatusNew)
-}
-
-// CheckAndGenerateAlerts scans components and creates alerts
-func (s *Service) CheckAndGenerateAlerts() error {
-	if !s.config.Enabled {
-		return nil
-	}
-
-	// Get top components by usage
-	topComponents, err := s.statsRepo.GetTopComponents(100)
-	if err != nil {
-		return err
-	}
-
-	for _, stats := range topComponents {
-		component, err := s.componentRepo.GetByLotName(stats.LotName)
-		if err != nil {
-			continue
-		}
-
-		// Check high demand + stale price
-		if err := s.checkHighDemandStalePrice(component, &stats); err != nil {
-			continue
-		}
-
-		// Check trending without price
-		if err := s.checkTrendingNoPrice(component, &stats); err != nil {
-			continue
-		}
-
-		// Check no recent quotes
-		if err := s.checkNoRecentQuotes(component, &stats); err != nil {
-			continue
-		}
-	}
-
-	return nil
-}
-
-func (s *Service) checkHighDemandStalePrice(comp *models.LotMetadata, stats *models.ComponentUsageStats) error {
-	// high_demand_stale_price: >= 5 quotes/month AND price > 60 days old
-	if stats.QuotesLast30d < s.config.HighDemandThreshold {
-		return nil
-	}
-
-	if comp.PriceUpdatedAt == nil {
-		return nil
-	}
-
-	daysSinceUpdate := int(time.Since(*comp.PriceUpdatedAt).Hours() / 24)
-	if daysSinceUpdate <= s.pricingConfig.FreshnessYellowDays {
-		return nil
-	}
-
-	// Check if alert already exists
-	exists, _ := s.alertRepo.ExistsByLotAndType(comp.LotName, models.AlertHighDemandStalePrice)
-	if exists {
-		return nil
-	}
-
-	alert := &models.PricingAlert{
-		LotName:   comp.LotName,
-		AlertType: models.AlertHighDemandStalePrice,
-		Severity:  models.SeverityCritical,
-		Message:   fmt.Sprintf("Компонент %s: высокий спрос (%d КП/мес), но цена устарела (%d дней)", comp.LotName, stats.QuotesLast30d, daysSinceUpdate),
-		Details: models.AlertDetails{
-			"quotes_30d":     stats.QuotesLast30d,
-			"days_since_update": daysSinceUpdate,
-		},
-	}
-
-	return s.alertRepo.Create(alert)
-}
-
-func (s *Service) checkTrendingNoPrice(comp *models.LotMetadata, stats *models.ComponentUsageStats) error {
-	// trending_no_price: trend > 50% AND no price
-	if stats.TrendDirection != models.TrendUp || stats.TrendPercent < float64(s.config.TrendingThresholdPercent) {
-		return nil
-	}
-
-	if comp.CurrentPrice != nil && *comp.CurrentPrice > 0 {
-		return nil
-	}
-
-	exists, _ := s.alertRepo.ExistsByLotAndType(comp.LotName, models.AlertTrendingNoPrice)
-	if exists {
-		return nil
-	}
-
-	alert := &models.PricingAlert{
-		LotName:   comp.LotName,
-		AlertType: models.AlertTrendingNoPrice,
-		Severity:  models.SeverityHigh,
-		Message:   fmt.Sprintf("Компонент %s: рост спроса +%.0f%%, но цена не установлена", comp.LotName, stats.TrendPercent),
-		Details: models.AlertDetails{
-			"trend_percent": stats.TrendPercent,
-		},
-	}
-
-	return s.alertRepo.Create(alert)
-}
-
-func (s *Service) checkNoRecentQuotes(comp *models.LotMetadata, stats *models.ComponentUsageStats) error {
-	// no_recent_quotes: popular component, no supplier quotes > 90 days
-	if stats.QuotesLast30d < 3 {
-		return nil
-	}
-
-	quoteCount, err := s.priceRepo.GetQuoteCount(comp.LotName, s.pricingConfig.FreshnessRedDays)
-	if err != nil {
-		return err
-	}
-
-	if quoteCount > 0 {
-		return nil
-	}
-
-	exists, _ := s.alertRepo.ExistsByLotAndType(comp.LotName, models.AlertNoRecentQuotes)
-	if exists {
-		return nil
-	}
-
-	alert := &models.PricingAlert{
-		LotName:   comp.LotName,
-		AlertType: models.AlertNoRecentQuotes,
-		Severity:  models.SeverityMedium,
-		Message:   fmt.Sprintf("Компонент %s: популярный (%d КП), но нет новых котировок >%d дней", comp.LotName, stats.QuotesLast30d, s.pricingConfig.FreshnessRedDays),
-		Details: models.AlertDetails{
-			"quotes_30d":       stats.QuotesLast30d,
-			"no_quotes_days": s.pricingConfig.FreshnessRedDays,
-		},
-	}
-
-	return s.alertRepo.Create(alert)
-}

internal/services/component.go

@@ -53,7 +53,6 @@ type ComponentView struct {
 	Category        string                `json:"category"`
 	CategoryName    string                `json:"category_name"`
 	Model           string                `json:"model"`
-	CurrentPrice    *float64              `json:"current_price"`
 	PriceFreshness  models.PriceFreshness `json:"price_freshness"`
 	PopularityScore float64               `json:"popularity_score"`
 	Specs           models.Specs          `json:"specs,omitempty"`
@@ -92,7 +91,6 @@ func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage
 		view := ComponentView{
 			LotName:         c.LotName,
 			Model:           c.Model,
-			CurrentPrice:    c.CurrentPrice,
 			PriceFreshness:  c.GetPriceFreshness(30, 60, 90, 3),
 			PopularityScore: c.PopularityScore,
 			Specs:           c.Specs,
@@ -134,7 +132,6 @@ func (s *ComponentService) GetByLotName(lotName string) (*ComponentView, error)
 	view := &ComponentView{
 		LotName:         c.LotName,
 		Model:           c.Model,
-		CurrentPrice:    c.CurrentPrice,
 		PriceFreshness:  c.GetPriceFreshness(30, 60, 90, 3),
 		PopularityScore: c.PopularityScore,
 		Specs:           c.Specs,

internal/services/configuration.go

@@ -4,50 +4,78 @@ 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 {
 	configRepo    *repository.ConfigurationRepository
+	projectRepo   *repository.ProjectRepository
 	componentRepo *repository.ComponentRepository
+	pricelistRepo *repository.PricelistRepository
 	quoteService  *QuoteService
 }
 
 func NewConfigurationService(
 	configRepo *repository.ConfigurationRepository,
+	projectRepo *repository.ProjectRepository,
 	componentRepo *repository.ComponentRepository,
+	pricelistRepo *repository.PricelistRepository,
 	quoteService *QuoteService,
 ) *ConfigurationService {
 	return &ConfigurationService{
 		configRepo:    configRepo,
+		projectRepo:   projectRepo,
 		componentRepo: componentRepo,
+		pricelistRepo: pricelistRepo,
 		quoteService:  quoteService,
 	}
 }
 
 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"`
+	ProjectUUID *string            `json:"project_uuid,omitempty"`
+	CustomPrice *float64           `json:"custom_price"`
+	Notes       string             `json:"notes"`
+	IsTemplate  bool               `json:"is_template"`
+	ServerCount int                `json:"server_count"`
+	ServerModel string             `json:"server_model,omitempty"`
+	SupportCode string             `json:"support_code,omitempty"`
+	Article     string             `json:"article,omitempty"`
+	PricelistID *uint              `json:"pricelist_id,omitempty"`
+	OnlyInStock bool               `json:"only_in_stock"`
 }
 
-func (s *ConfigurationService) Create(userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+type ArticlePreviewRequest struct {
+	Items       models.ConfigItems `json:"items"`
+	ServerModel string             `json:"server_model"`
+	SupportCode string             `json:"support_code,omitempty"`
+	PricelistID *uint              `json:"pricelist_id,omitempty"`
+}
+
+func (s *ConfigurationService) Create(ownerUsername string, req *CreateConfigRequest) (*models.Configuration, error) {
+	projectUUID, err := s.resolveProjectUUID(ownerUsername, req.ProjectUUID)
+	if err != nil {
+		return nil, err
+	}
+	pricelistID, err := s.resolvePricelistID(req.PricelistID)
+	if err != nil {
+		return nil, err
+	}
+
 	total := req.Items.Total()
 
 	// If server count is greater than 1, multiply the total by server count
@@ -56,15 +84,21 @@ 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,
+		ProjectUUID:   projectUUID,
+		Name:          req.Name,
+		Items:         req.Items,
+		TotalPrice:    &total,
+		CustomPrice:   req.CustomPrice,
+		Notes:         req.Notes,
+		IsTemplate:    req.IsTemplate,
+		ServerCount:   req.ServerCount,
+		ServerModel:   req.ServerModel,
+		SupportCode:   req.SupportCode,
+		Article:       req.Article,
+		PricelistID:   pricelistID,
+		OnlyInStock:   req.OnlyInStock,
 	}
 
 	if err := s.configRepo.Create(config); err != nil {
@@ -77,30 +111,39 @@ 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
 	}
 
+	projectUUID, err := s.resolveProjectUUID(ownerUsername, req.ProjectUUID)
+	if err != nil {
+		return nil, err
+	}
+	pricelistID, err := s.resolvePricelistID(req.PricelistID)
+	if err != nil {
+		return nil, err
+	}
+
 	total := req.Items.Total()
 
 	// If server count is greater than 1, multiply the total by server count
@@ -109,12 +152,18 @@ func (s *ConfigurationService) Update(uuid string, userID uint, req *CreateConfi
 	}
 
 	config.Name = req.Name
+	config.ProjectUUID = projectUUID
 	config.Items = req.Items
 	config.TotalPrice = &total
 	config.CustomPrice = req.CustomPrice
 	config.Notes = req.Notes
 	config.IsTemplate = req.IsTemplate
 	config.ServerCount = req.ServerCount
+	config.ServerModel = req.ServerModel
+	config.SupportCode = req.SupportCode
+	config.Article = req.Article
+	config.PricelistID = pricelistID
+	config.OnlyInStock = req.OnlyInStock
 
 	if err := s.configRepo.Update(config); err != nil {
 		return nil, err
@@ -123,26 +172,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,11 +204,22 @@ 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) {
+	return s.CloneToProject(configUUID, ownerUsername, newName, nil)
+}
+
+func (s *ConfigurationService) CloneToProject(configUUID string, ownerUsername string, newName string, projectUUID *string) (*models.Configuration, error) {
+	original, err := s.GetByUUID(configUUID, ownerUsername)
 	if err != nil {
 		return nil, err
 	}
+	resolvedProjectUUID := original.ProjectUUID
+	if projectUUID != nil {
+		resolvedProjectUUID, err = s.resolveProjectUUID(ownerUsername, projectUUID)
+		if err != nil {
+			return nil, err
+		}
+	}
 
 	// Create copy with new UUID and name
 	total := original.Items.Total()
@@ -170,15 +230,18 @@ 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,
+		ProjectUUID:   resolvedProjectUUID,
+		Name:          newName,
+		Items:         original.Items,
+		TotalPrice:    &total,
+		CustomPrice:   original.CustomPrice,
+		Notes:         original.Notes,
+		IsTemplate:    false, // Clone is never a template
+		ServerCount:   original.ServerCount,
+		PricelistID:   original.PricelistID,
+		OnlyInStock:   original.OnlyInStock,
 	}
 
 	if err := s.configRepo.Create(clone); err != nil {
@@ -188,7 +251,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 +260,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)
@@ -229,18 +292,30 @@ func (s *ConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigReques
 		return nil, ErrConfigNotFound
 	}
 
+	projectUUID, err := s.resolveProjectUUID(config.OwnerUsername, req.ProjectUUID)
+	if err != nil {
+		return nil, err
+	}
+	pricelistID, err := s.resolvePricelistID(req.PricelistID)
+	if err != nil {
+		return nil, err
+	}
+
 	total := req.Items.Total()
 	if req.ServerCount > 1 {
 		total *= float64(req.ServerCount)
 	}
 
 	config.Name = req.Name
+	config.ProjectUUID = projectUUID
 	config.Items = req.Items
 	config.TotalPrice = &total
 	config.CustomPrice = req.CustomPrice
 	config.Notes = req.Notes
 	config.IsTemplate = req.IsTemplate
 	config.ServerCount = req.ServerCount
+	config.PricelistID = pricelistID
+	config.OnlyInStock = req.OnlyInStock
 
 	if err := s.configRepo.Update(config); err != nil {
 		return nil, err
@@ -274,11 +349,22 @@ 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) {
+	return s.CloneNoAuthToProject(configUUID, newName, ownerUsername, nil)
+}
+
+func (s *ConfigurationService) CloneNoAuthToProject(configUUID string, newName string, ownerUsername string, projectUUID *string) (*models.Configuration, error) {
 	original, err := s.configRepo.GetByUUID(configUUID)
 	if err != nil {
 		return nil, ErrConfigNotFound
 	}
+	resolvedProjectUUID := original.ProjectUUID
+	if projectUUID != nil {
+		resolvedProjectUUID, err = s.resolveProjectUUID(ownerUsername, projectUUID)
+		if err != nil {
+			return nil, err
+		}
+	}
 
 	total := original.Items.Total()
 	if original.ServerCount > 1 {
@@ -286,15 +372,18 @@ 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,
+		ProjectUUID:   resolvedProjectUUID,
+		Name:          newName,
+		Items:         original.Items,
+		TotalPrice:    &total,
+		CustomPrice:   original.CustomPrice,
+		Notes:         original.Notes,
+		IsTemplate:    false,
+		ServerCount:   original.ServerCount,
+		PricelistID:   original.PricelistID,
+		OnlyInStock:   original.OnlyInStock,
 	}
 
 	if err := s.configRepo.Create(clone); err != nil {
@@ -304,6 +393,43 @@ func (s *ConfigurationService) CloneNoAuth(configUUID string, newName string, us
 	return clone, nil
 }
 
+func (s *ConfigurationService) resolveProjectUUID(ownerUsername string, projectUUID *string) (*string, error) {
+	_ = ownerUsername
+	if s.projectRepo == nil {
+		return projectUUID, nil
+	}
+	if projectUUID == nil || *projectUUID == "" {
+		return nil, nil
+	}
+
+	project, err := s.projectRepo.GetByUUID(*projectUUID)
+	if err != nil {
+		return nil, ErrProjectNotFound
+	}
+	if !project.IsActive {
+		return nil, errors.New("project is archived")
+	}
+
+	return &project.UUID, nil
+}
+
+func (s *ConfigurationService) resolvePricelistID(pricelistID *uint) (*uint, error) {
+	if s.pricelistRepo == nil {
+		return pricelistID, nil
+	}
+	if pricelistID != nil && *pricelistID > 0 {
+		if _, err := s.pricelistRepo.GetByID(*pricelistID); err != nil {
+			return nil, err
+		}
+		return pricelistID, nil
+	}
+	latest, err := s.pricelistRepo.GetLatestActive()
+	if err != nil {
+		return nil, nil
+	}
+	return &latest.ID, nil
+}
+
 // RefreshPricesNoAuth refreshes prices without ownership check
 func (s *ConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Configuration, error) {
 	config, err := s.configRepo.GetByUUID(uuid)
@@ -311,8 +437,30 @@ func (s *ConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Configu
 		return nil, ErrConfigNotFound
 	}
 
+	var latestPricelistID *uint
+	if s.pricelistRepo != nil {
+		if pl, err := s.pricelistRepo.GetLatestActive(); err == nil {
+			latestPricelistID = &pl.ID
+		}
+	}
+
 	updatedItems := make(models.ConfigItems, len(config.Items))
 	for i, item := range config.Items {
+		if latestPricelistID != nil {
+			if price, err := s.pricelistRepo.GetPriceForLot(*latestPricelistID, item.LotName); err == nil && price > 0 {
+				updatedItems[i] = models.ConfigItem{
+					LotName:   item.LotName,
+					Quantity:  item.Quantity,
+					UnitPrice: price,
+				}
+				continue
+			}
+		}
+
+		if s.componentRepo == nil {
+			updatedItems[i] = item
+			continue
+		}
 		metadata, err := s.componentRepo.GetByLotName(item.LotName)
 		if err != nil || metadata.CurrentPrice == nil {
 			updatedItems[i] = item
@@ -333,6 +481,9 @@ func (s *ConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Configu
 	}
 
 	config.TotalPrice = &total
+	if latestPricelistID != nil {
+		config.PricelistID = latestPricelistID
+	}
 	now := time.Now()
 	config.PriceUpdatedAt = &now
 
@@ -356,20 +507,42 @@ 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
 	}
 
+	var latestPricelistID *uint
+	if s.pricelistRepo != nil {
+		if pl, err := s.pricelistRepo.GetLatestActive(); err == nil {
+			latestPricelistID = &pl.ID
+		}
+	}
+
 	// Update prices for all items
 	updatedItems := make(models.ConfigItems, len(config.Items))
 	for i, item := range config.Items {
+		if latestPricelistID != nil {
+			if price, err := s.pricelistRepo.GetPriceForLot(*latestPricelistID, item.LotName); err == nil && price > 0 {
+				updatedItems[i] = models.ConfigItem{
+					LotName:   item.LotName,
+					Quantity:  item.Quantity,
+					UnitPrice: price,
+				}
+				continue
+			}
+		}
+
 		// Get current component price
+		if s.componentRepo == nil {
+			updatedItems[i] = item
+			continue
+		}
 		metadata, err := s.componentRepo.GetByLotName(item.LotName)
 		if err != nil || metadata.CurrentPrice == nil {
 			// Keep original item if component not found or no price available
@@ -395,6 +568,9 @@ func (s *ConfigurationService) RefreshPrices(uuid string, userID uint) (*models.
 	}
 
 	config.TotalPrice = &total
+	if latestPricelistID != nil {
+		config.PricelistID = latestPricelistID
+	}
 
 	// Set price update timestamp
 	now := time.Now()
@@ -407,6 +583,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/export.go

@@ -4,33 +4,33 @@ import (
 	"bytes"
 	"encoding/csv"
 	"fmt"
+	"io"
+	"math"
+	"sort"
+	"strings"
 	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
 )
 
 type ExportService struct {
-	config     config.ExportConfig
+	config       config.ExportConfig
 	categoryRepo *repository.CategoryRepository
+	localDB      *localdb.LocalDB
 }
 
-func NewExportService(cfg config.ExportConfig, categoryRepo *repository.CategoryRepository) *ExportService {
+func NewExportService(cfg config.ExportConfig, categoryRepo *repository.CategoryRepository, local *localdb.LocalDB) *ExportService {
 	return &ExportService{
 		config:       cfg,
 		categoryRepo: categoryRepo,
+		localDB:      local,
 	}
 }
 
-type ExportData struct {
-	Name      string
-	Items     []ExportItem
-	Total     float64
-	Notes     string
-	CreatedAt time.Time
-}
-
+// ExportItem represents a single component in an export block.
 type ExportItem struct {
 	LotName     string
 	Description string
@@ -40,14 +40,46 @@ type ExportItem struct {
 	TotalPrice  float64
 }
 
-func (s *ExportService) ToCSV(data *ExportData) ([]byte, error) {
-	var buf bytes.Buffer
-	w := csv.NewWriter(&buf)
+// ConfigExportBlock represents one configuration (server) in the export.
+type ConfigExportBlock struct {
+	Article     string
+	Line        int
+	ServerCount int
+	UnitPrice   float64 // sum of component prices for one server
+	Items       []ExportItem
+}
+
+// ProjectExportData holds all configuration blocks for a project-level export.
+type ProjectExportData struct {
+	Configs   []ConfigExportBlock
+	CreatedAt time.Time
+}
+
+// ToCSV writes project export data in the new structured CSV format.
+//
+// Format:
+//
+//	Line;Type;p/n;Description;Qty (1 pcs.);Qty (total);Price (1 pcs.);Price (total)
+//	10;;DL380-ARTICLE;;;10;10470;104 700
+//	;;MB_INTEL_...;;1;;2074,5;
+//	...
+//	(empty row)
+//	20;;DL380-ARTICLE-2;;;2;10470;20 940
+//	...
+func (s *ExportService) ToCSV(w io.Writer, data *ProjectExportData) error {
+	// Write UTF-8 BOM for Excel compatibility
+	if _, err := w.Write([]byte{0xEF, 0xBB, 0xBF}); err != nil {
+		return fmt.Errorf("failed to write BOM: %w", err)
+	}
+
+	csvWriter := csv.NewWriter(w)
+	csvWriter.Comma = ';'
+	defer csvWriter.Flush()
 
 	// Header
-	headers := []string{"Артикул", "Описание", "Категория", "Количество", "Цена за единицу", "Сумма"}
-	if err := w.Write(headers); err != nil {
-		return nil, err
+	headers := []string{"Line", "Type", "p/n", "Description", "Qty (1 pcs.)", "Qty (total)", "Price (1 pcs.)", "Price (total)"}
+	if err := csvWriter.Write(headers); err != nil {
+		return fmt.Errorf("failed to write header: %w", err)
 	}
 
 	// Get category hierarchy for sorting
@@ -61,87 +93,260 @@ func (s *ExportService) ToCSV(data *ExportData) ([]byte, error) {
 		}
 	}
 
-	// Sort items by category display order
-	sortedItems := make([]ExportItem, len(data.Items))
-	copy(sortedItems, data.Items)
+	for i, block := range data.Configs {
+		lineNo := block.Line
+		if lineNo <= 0 {
+			lineNo = (i + 1) * 10
+		}
 
-	// Sort using category display order (items without category go to the end)
-	for i := 0; i < len(sortedItems)-1; i++ {
-		for j := i + 1; j < len(sortedItems); j++ {
-			orderI, hasI := categoryOrder[sortedItems[i].Category]
-			orderJ, hasJ := categoryOrder[sortedItems[j].Category]
+		serverCount := block.ServerCount
+		if serverCount < 1 {
+			serverCount = 1
+		}
 
-			// Items without category go to the end
-			if !hasI && hasJ {
-				sortedItems[i], sortedItems[j] = sortedItems[j], sortedItems[i]
-			} else if hasI && hasJ {
-				// Both have categories, sort by display order
-				if orderI > orderJ {
-					sortedItems[i], sortedItems[j] = sortedItems[j], sortedItems[i]
+		totalPrice := block.UnitPrice * float64(serverCount)
+
+		// Server summary row
+		serverRow := []string{
+			fmt.Sprintf("%d", lineNo),        // Line
+			"",                               // Type
+			block.Article,                    // p/n
+			"",                               // Description
+			"",                               // Qty (1 pcs.)
+			fmt.Sprintf("%d", serverCount),   // Qty (total)
+			formatPriceInt(block.UnitPrice),  // Price (1 pcs.)
+			formatPriceWithSpace(totalPrice), // Price (total)
+		}
+		if err := csvWriter.Write(serverRow); err != nil {
+			return fmt.Errorf("failed to write server row: %w", err)
+		}
+
+		// Sort items by category display order
+		sortedItems := make([]ExportItem, len(block.Items))
+		copy(sortedItems, block.Items)
+		sortItemsByCategory(sortedItems, categoryOrder)
+
+		// Component rows
+		for _, item := range sortedItems {
+			componentRow := []string{
+				"",                               // Line
+				item.Category,                    // Type
+				item.LotName,                     // p/n
+				"",                               // Description
+				fmt.Sprintf("%d", item.Quantity), // Qty (1 pcs.)
+				"",                               // Qty (total)
+				formatPriceComma(item.UnitPrice), // Price (1 pcs.)
+				"",                               // Price (total)
+			}
+			if err := csvWriter.Write(componentRow); err != nil {
+				return fmt.Errorf("failed to write component row: %w", err)
+			}
+		}
+
+		// Empty separator row between blocks (skip after last)
+		if i < len(data.Configs)-1 {
+			if err := csvWriter.Write([]string{"", "", "", "", "", "", "", ""}); err != nil {
+				return fmt.Errorf("failed to write separator row: %w", err)
+			}
+		}
+	}
+
+	csvWriter.Flush()
+	if err := csvWriter.Error(); err != nil {
+		return fmt.Errorf("csv writer error: %w", err)
+	}
+
+	return nil
+}
+
+// ToCSVBytes is a backward-compatible wrapper that returns CSV data as bytes.
+func (s *ExportService) ToCSVBytes(data *ProjectExportData) ([]byte, error) {
+	var buf bytes.Buffer
+	if err := s.ToCSV(&buf, data); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// ConfigToExportData converts a single configuration into ProjectExportData.
+func (s *ExportService) ConfigToExportData(cfg *models.Configuration) *ProjectExportData {
+	block := s.buildExportBlock(cfg)
+	return &ProjectExportData{
+		Configs:   []ConfigExportBlock{block},
+		CreatedAt: cfg.CreatedAt,
+	}
+}
+
+// ProjectToExportData converts multiple configurations into ProjectExportData.
+func (s *ExportService) ProjectToExportData(configs []models.Configuration) *ProjectExportData {
+	sortedConfigs := make([]models.Configuration, len(configs))
+	copy(sortedConfigs, configs)
+	sort.Slice(sortedConfigs, func(i, j int) bool {
+		leftLine := sortedConfigs[i].Line
+		rightLine := sortedConfigs[j].Line
+
+		if leftLine <= 0 {
+			leftLine = int(^uint(0) >> 1)
+		}
+		if rightLine <= 0 {
+			rightLine = int(^uint(0) >> 1)
+		}
+		if leftLine != rightLine {
+			return leftLine < rightLine
+		}
+		if !sortedConfigs[i].CreatedAt.Equal(sortedConfigs[j].CreatedAt) {
+			return sortedConfigs[i].CreatedAt.After(sortedConfigs[j].CreatedAt)
+		}
+		return sortedConfigs[i].UUID > sortedConfigs[j].UUID
+	})
+
+	blocks := make([]ConfigExportBlock, 0, len(configs))
+	for i := range sortedConfigs {
+		blocks = append(blocks, s.buildExportBlock(&sortedConfigs[i]))
+	}
+	return &ProjectExportData{
+		Configs:   blocks,
+		CreatedAt: time.Now(),
+	}
+}
+
+func (s *ExportService) buildExportBlock(cfg *models.Configuration) ConfigExportBlock {
+	// Batch-fetch categories from local data (pricelist items → local_components fallback)
+	lotNames := make([]string, len(cfg.Items))
+	for i, item := range cfg.Items {
+		lotNames[i] = item.LotName
+	}
+	categories := s.resolveCategories(cfg.PricelistID, lotNames)
+
+	items := make([]ExportItem, len(cfg.Items))
+	var unitTotal float64
+
+	for i, item := range cfg.Items {
+		itemTotal := item.UnitPrice * float64(item.Quantity)
+		items[i] = ExportItem{
+			LotName:    item.LotName,
+			Category:   categories[item.LotName],
+			Quantity:   item.Quantity,
+			UnitPrice:  item.UnitPrice,
+			TotalPrice: itemTotal,
+		}
+		unitTotal += itemTotal
+	}
+
+	serverCount := cfg.ServerCount
+	if serverCount < 1 {
+		serverCount = 1
+	}
+
+	return ConfigExportBlock{
+		Article:     cfg.Article,
+		Line:        cfg.Line,
+		ServerCount: serverCount,
+		UnitPrice:   unitTotal,
+		Items:       items,
+	}
+}
+
+// resolveCategories returns lot_name → category map.
+// Primary source: pricelist items (lot_category). Fallback: local_components table.
+func (s *ExportService) resolveCategories(pricelistID *uint, lotNames []string) map[string]string {
+	if len(lotNames) == 0 || s.localDB == nil {
+		return map[string]string{}
+	}
+
+	categories := make(map[string]string, len(lotNames))
+
+	// Primary: pricelist items
+	if pricelistID != nil && *pricelistID > 0 {
+		if cats, err := s.localDB.GetLocalLotCategoriesByServerPricelistID(*pricelistID, lotNames); err == nil {
+			for lot, cat := range cats {
+				if strings.TrimSpace(cat) != "" {
+					categories[lot] = cat
 				}
 			}
 		}
 	}
 
-	// Items
-	for _, item := range sortedItems {
-		row := []string{
-			item.LotName,
-			item.Description,
-			item.Category,
-			fmt.Sprintf("%d", item.Quantity),
-			fmt.Sprintf("%.2f", item.UnitPrice),
-			fmt.Sprintf("%.2f", item.TotalPrice),
-		}
-		if err := w.Write(row); err != nil {
-			return nil, err
+	// Fallback: local_components for any still missing
+	var missing []string
+	for _, lot := range lotNames {
+		if categories[lot] == "" {
+			missing = append(missing, lot)
 		}
 	}
-
-	// Total row
-	if err := w.Write([]string{"", "", "", "", "ИТОГО:", fmt.Sprintf("%.2f", data.Total)}); err != nil {
-		return nil, err
-	}
-
-	w.Flush()
-	return buf.Bytes(), w.Error()
-}
-
-func (s *ExportService) ConfigToExportData(config *models.Configuration, componentService *ComponentService) *ExportData {
-	items := make([]ExportItem, len(config.Items))
-	var total float64
-
-	for i, item := range config.Items {
-		itemTotal := item.UnitPrice * float64(item.Quantity)
-
-		// Получаем информацию о компоненте для заполнения категории
-		componentView, err := componentService.GetByLotName(item.LotName)
-		if err != nil {
-			// Если не удалось получить информацию о компоненте, используем только основные данные
-			items[i] = ExportItem{
-				LotName:    item.LotName,
-				Quantity:   item.Quantity,
-				UnitPrice:  item.UnitPrice,
-				TotalPrice: itemTotal,
-			}
-		} else {
-			items[i] = ExportItem{
-				LotName:     item.LotName,
-				Description: componentView.Description,
-				Category:    componentView.Category,
-				Quantity:    item.Quantity,
-				UnitPrice:   item.UnitPrice,
-				TotalPrice:  itemTotal,
+	if len(missing) > 0 {
+		if fallback, err := s.localDB.GetLocalComponentCategoriesByLotNames(missing); err == nil {
+			for lot, cat := range fallback {
+				if strings.TrimSpace(cat) != "" {
+					categories[lot] = cat
+				}
 			}
 		}
-		total += itemTotal
 	}
 
-	return &ExportData{
-		Name:      config.Name,
-		Items:     items,
-		Total:     total,
-		Notes:     config.Notes,
-		CreatedAt: config.CreatedAt,
+	return categories
+}
+
+// sortItemsByCategory sorts items by category display order (items without category go to the end).
+func sortItemsByCategory(items []ExportItem, categoryOrder map[string]int) {
+	for i := 0; i < len(items)-1; i++ {
+		for j := i + 1; j < len(items); j++ {
+			orderI, hasI := categoryOrder[items[i].Category]
+			orderJ, hasJ := categoryOrder[items[j].Category]
+
+			if !hasI && hasJ {
+				items[i], items[j] = items[j], items[i]
+			} else if hasI && hasJ && orderI > orderJ {
+				items[i], items[j] = items[j], items[i]
+			}
+		}
 	}
 }
+
+// formatPriceComma formats a price with comma as decimal separator (e.g., "2074,5").
+// Trailing zeros after the comma are trimmed, and if the value is an integer, no comma is shown.
+func formatPriceComma(value float64) string {
+	if value == math.Trunc(value) {
+		return fmt.Sprintf("%.0f", value)
+	}
+	s := fmt.Sprintf("%.2f", value)
+	s = strings.ReplaceAll(s, ".", ",")
+	// Trim trailing zero: "2074,50" -> "2074,5"
+	s = strings.TrimRight(s, "0")
+	s = strings.TrimRight(s, ",")
+	return s
+}
+
+// formatPriceInt formats price as integer (rounded), no decimal.
+func formatPriceInt(value float64) string {
+	return fmt.Sprintf("%.0f", math.Round(value))
+}
+
+// formatPriceWithSpace formats a price as an integer with space as thousands separator (e.g., "104 700").
+func formatPriceWithSpace(value float64) string {
+	intVal := int64(math.Round(value))
+	if intVal < 0 {
+		return "-" + formatIntWithSpace(-intVal)
+	}
+	return formatIntWithSpace(intVal)
+}
+
+func formatIntWithSpace(n int64) string {
+	s := fmt.Sprintf("%d", n)
+	if len(s) <= 3 {
+		return s
+	}
+
+	var result strings.Builder
+	remainder := len(s) % 3
+	if remainder > 0 {
+		result.WriteString(s[:remainder])
+	}
+	for i := remainder; i < len(s); i += 3 {
+		if result.Len() > 0 {
+			result.WriteByte(' ')
+		}
+		result.WriteString(s[i : i+3])
+	}
+	return result.String()
+}

internal/services/export_test.go

@@ -0,0 +1,452 @@
+package services
+
+import (
+	"bytes"
+	"encoding/csv"
+	"io"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+)
+
+func newTestProjectData(items []ExportItem, article string, serverCount int) *ProjectExportData {
+	var unitTotal float64
+	for _, item := range items {
+		unitTotal += item.UnitPrice * float64(item.Quantity)
+	}
+	if serverCount < 1 {
+		serverCount = 1
+	}
+	return &ProjectExportData{
+		Configs: []ConfigExportBlock{
+			{
+				Article:     article,
+				ServerCount: serverCount,
+				UnitPrice:   unitTotal,
+				Items:       items,
+			},
+		},
+		CreatedAt: time.Now(),
+	}
+}
+
+func TestToCSV_UTF8BOM(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := newTestProjectData([]ExportItem{
+		{
+			LotName:    "LOT-001",
+			Category:   "CAT",
+			Quantity:   1,
+			UnitPrice:  100.0,
+			TotalPrice: 100.0,
+		},
+	}, "TEST-ARTICLE", 1)
+
+	var buf bytes.Buffer
+	if err := svc.ToCSV(&buf, data); err != nil {
+		t.Fatalf("ToCSV failed: %v", err)
+	}
+
+	csvBytes := buf.Bytes()
+	if len(csvBytes) < 3 {
+		t.Fatalf("CSV too short to contain BOM")
+	}
+
+	expectedBOM := []byte{0xEF, 0xBB, 0xBF}
+	actualBOM := csvBytes[:3]
+	if !bytes.Equal(actualBOM, expectedBOM) {
+		t.Errorf("UTF-8 BOM mismatch. Expected %v, got %v", expectedBOM, actualBOM)
+	}
+}
+
+func TestToCSV_SemicolonDelimiter(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := newTestProjectData([]ExportItem{
+		{
+			LotName:    "LOT-001",
+			Category:   "CAT",
+			Quantity:   2,
+			UnitPrice:  100.50,
+			TotalPrice: 201.00,
+		},
+	}, "TEST-ARTICLE", 1)
+
+	var buf bytes.Buffer
+	if err := svc.ToCSV(&buf, data); err != nil {
+		t.Fatalf("ToCSV failed: %v", err)
+	}
+
+	csvBytes := buf.Bytes()
+	reader := csv.NewReader(bytes.NewReader(csvBytes[3:]))
+	reader.Comma = ';'
+
+	// Read header
+	header, err := reader.Read()
+	if err != nil {
+		t.Fatalf("Failed to read header: %v", err)
+	}
+
+	if len(header) != 8 {
+		t.Errorf("Expected 8 columns, got %d", len(header))
+	}
+
+	expectedHeader := []string{"Line", "Type", "p/n", "Description", "Qty (1 pcs.)", "Qty (total)", "Price (1 pcs.)", "Price (total)"}
+	for i, col := range expectedHeader {
+		if i < len(header) && header[i] != col {
+			t.Errorf("Column %d: expected %q, got %q", i, col, header[i])
+		}
+	}
+
+	// Read server row
+	serverRow, err := reader.Read()
+	if err != nil {
+		t.Fatalf("Failed to read server row: %v", err)
+	}
+	if serverRow[0] != "10" {
+		t.Errorf("Expected line number 10, got %s", serverRow[0])
+	}
+	if serverRow[2] != "TEST-ARTICLE" {
+		t.Errorf("Expected article TEST-ARTICLE, got %s", serverRow[2])
+	}
+
+	// Read component row
+	itemRow, err := reader.Read()
+	if err != nil {
+		t.Fatalf("Failed to read item row: %v", err)
+	}
+	if itemRow[2] != "LOT-001" {
+		t.Errorf("Lot name mismatch: expected LOT-001, got %s", itemRow[2])
+	}
+	if itemRow[4] != "2" {
+		t.Errorf("Quantity mismatch: expected 2, got %s", itemRow[4])
+	}
+	if itemRow[6] != "100,5" {
+		t.Errorf("Unit price mismatch: expected 100,5, got %s", itemRow[6])
+	}
+}
+
+func TestToCSV_ServerRow(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := newTestProjectData([]ExportItem{
+		{LotName: "LOT-001", Category: "CAT", Quantity: 1, UnitPrice: 100.0, TotalPrice: 100.0},
+		{LotName: "LOT-002", Category: "CAT", Quantity: 2, UnitPrice: 50.0, TotalPrice: 100.0},
+	}, "DL380-ART", 10)
+
+	var buf bytes.Buffer
+	if err := svc.ToCSV(&buf, data); err != nil {
+		t.Fatalf("ToCSV failed: %v", err)
+	}
+
+	csvBytes := buf.Bytes()
+	reader := csv.NewReader(bytes.NewReader(csvBytes[3:]))
+	reader.Comma = ';'
+
+	// Skip header
+	reader.Read()
+
+	// Read server row
+	serverRow, err := reader.Read()
+	if err != nil {
+		t.Fatalf("Failed to read server row: %v", err)
+	}
+
+	if serverRow[0] != "10" {
+		t.Errorf("Expected line 10, got %s", serverRow[0])
+	}
+	if serverRow[2] != "DL380-ART" {
+		t.Errorf("Expected article DL380-ART, got %s", serverRow[2])
+	}
+	if serverRow[5] != "10" {
+		t.Errorf("Expected server count 10, got %s", serverRow[5])
+	}
+	// UnitPrice = 100 + 100 = 200
+	if serverRow[6] != "200" {
+		t.Errorf("Expected unit price 200, got %s", serverRow[6])
+	}
+	// TotalPrice = 200 * 10 = 2000
+	if serverRow[7] != "2 000" {
+		t.Errorf("Expected total price '2 000', got %q", serverRow[7])
+	}
+}
+
+func TestToCSV_CategorySorting(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := newTestProjectData([]ExportItem{
+		{LotName: "LOT-001", Category: "CAT-A", Quantity: 1, UnitPrice: 100.0, TotalPrice: 100.0},
+		{LotName: "LOT-002", Category: "CAT-C", Quantity: 1, UnitPrice: 100.0, TotalPrice: 100.0},
+		{LotName: "LOT-003", Category: "CAT-B", Quantity: 1, UnitPrice: 100.0, TotalPrice: 100.0},
+	}, "ART", 1)
+
+	var buf bytes.Buffer
+	if err := svc.ToCSV(&buf, data); err != nil {
+		t.Fatalf("ToCSV failed: %v", err)
+	}
+
+	csvBytes := buf.Bytes()
+	reader := csv.NewReader(bytes.NewReader(csvBytes[3:]))
+	reader.Comma = ';'
+
+	// Skip header and server row
+	reader.Read()
+	reader.Read()
+
+	// Without category repo, items maintain original order
+	row1, _ := reader.Read()
+	if row1[2] != "LOT-001" {
+		t.Errorf("Expected LOT-001 first, got %s", row1[2])
+	}
+
+	row2, _ := reader.Read()
+	if row2[2] != "LOT-002" {
+		t.Errorf("Expected LOT-002 second, got %s", row2[2])
+	}
+
+	row3, _ := reader.Read()
+	if row3[2] != "LOT-003" {
+		t.Errorf("Expected LOT-003 third, got %s", row3[2])
+	}
+}
+
+func TestToCSV_EmptyData(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := &ProjectExportData{
+		Configs:   []ConfigExportBlock{},
+		CreatedAt: time.Now(),
+	}
+
+	var buf bytes.Buffer
+	if err := svc.ToCSV(&buf, data); err != nil {
+		t.Fatalf("ToCSV failed: %v", err)
+	}
+
+	csvBytes := buf.Bytes()
+	reader := csv.NewReader(bytes.NewReader(csvBytes[3:]))
+	reader.Comma = ';'
+
+	header, err := reader.Read()
+	if err != nil {
+		t.Fatalf("Failed to read header: %v", err)
+	}
+
+	if len(header) != 8 {
+		t.Errorf("Expected 8 columns, got %d", len(header))
+	}
+
+	// No more rows expected
+	_, err = reader.Read()
+	if err != io.EOF {
+		t.Errorf("Expected EOF after header, got: %v", err)
+	}
+}
+
+func TestToCSVBytes_BackwardCompat(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := newTestProjectData([]ExportItem{
+		{LotName: "LOT-001", Category: "CAT", Quantity: 1, UnitPrice: 100.0, TotalPrice: 100.0},
+	}, "ART", 1)
+
+	csvBytes, err := svc.ToCSVBytes(data)
+	if err != nil {
+		t.Fatalf("ToCSVBytes failed: %v", err)
+	}
+
+	if len(csvBytes) < 3 {
+		t.Fatalf("CSV bytes too short")
+	}
+
+	expectedBOM := []byte{0xEF, 0xBB, 0xBF}
+	actualBOM := csvBytes[:3]
+	if !bytes.Equal(actualBOM, expectedBOM) {
+		t.Errorf("UTF-8 BOM mismatch in ToCSVBytes")
+	}
+}
+
+func TestToCSV_WriterError(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := newTestProjectData([]ExportItem{
+		{LotName: "LOT-001", Category: "CAT", Quantity: 1, UnitPrice: 100.0, TotalPrice: 100.0},
+	}, "ART", 1)
+
+	failingWriter := &failingWriter{}
+
+	if err := svc.ToCSV(failingWriter, data); err == nil {
+		t.Errorf("Expected error from failing writer, got nil")
+	}
+}
+
+func TestToCSV_MultipleBlocks(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := &ProjectExportData{
+		Configs: []ConfigExportBlock{
+			{
+				Article:     "ART-1",
+				ServerCount: 2,
+				UnitPrice:   500.0,
+				Items: []ExportItem{
+					{LotName: "LOT-A", Category: "CPU", Quantity: 1, UnitPrice: 500.0, TotalPrice: 500.0},
+				},
+			},
+			{
+				Article:     "ART-2",
+				ServerCount: 3,
+				UnitPrice:   1000.0,
+				Items: []ExportItem{
+					{LotName: "LOT-B", Category: "MEM", Quantity: 2, UnitPrice: 500.0, TotalPrice: 1000.0},
+				},
+			},
+		},
+		CreatedAt: time.Now(),
+	}
+
+	var buf bytes.Buffer
+	if err := svc.ToCSV(&buf, data); err != nil {
+		t.Fatalf("ToCSV failed: %v", err)
+	}
+
+	csvBytes := buf.Bytes()
+	reader := csv.NewReader(bytes.NewReader(csvBytes[3:]))
+	reader.Comma = ';'
+	reader.FieldsPerRecord = -1 // allow variable fields
+
+	// Header
+	reader.Read()
+
+	// Block 1: server row
+	srv1, _ := reader.Read()
+	if srv1[0] != "10" {
+		t.Errorf("Block 1 line: expected 10, got %s", srv1[0])
+	}
+	if srv1[7] != "1 000" {
+		t.Errorf("Block 1 total: expected '1 000', got %q", srv1[7])
+	}
+
+	// Block 1: component row
+	comp1, _ := reader.Read()
+	if comp1[2] != "LOT-A" {
+		t.Errorf("Block 1 component: expected LOT-A, got %s", comp1[2])
+	}
+
+	// Separator row
+	sep, _ := reader.Read()
+	allEmpty := true
+	for _, v := range sep {
+		if v != "" {
+			allEmpty = false
+		}
+	}
+	if !allEmpty {
+		t.Errorf("Expected empty separator row, got %v", sep)
+	}
+
+	// Block 2: server row
+	srv2, _ := reader.Read()
+	if srv2[0] != "20" {
+		t.Errorf("Block 2 line: expected 20, got %s", srv2[0])
+	}
+	if srv2[7] != "3 000" {
+		t.Errorf("Block 2 total: expected '3 000', got %q", srv2[7])
+	}
+}
+
+func TestProjectToExportData_SortsByLine(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	configs := []models.Configuration{
+		{
+			UUID:        "cfg-1",
+			Line:        30,
+			Article:     "ART-30",
+			ServerCount: 1,
+			Items:       models.ConfigItems{{LotName: "LOT-30", Quantity: 1, UnitPrice: 300}},
+			CreatedAt:   time.Now().Add(-1 * time.Hour),
+		},
+		{
+			UUID:        "cfg-2",
+			Line:        10,
+			Article:     "ART-10",
+			ServerCount: 1,
+			Items:       models.ConfigItems{{LotName: "LOT-10", Quantity: 1, UnitPrice: 100}},
+			CreatedAt:   time.Now().Add(-2 * time.Hour),
+		},
+		{
+			UUID:        "cfg-3",
+			Line:        20,
+			Article:     "ART-20",
+			ServerCount: 1,
+			Items:       models.ConfigItems{{LotName: "LOT-20", Quantity: 1, UnitPrice: 200}},
+			CreatedAt:   time.Now().Add(-3 * time.Hour),
+		},
+	}
+
+	data := svc.ProjectToExportData(configs)
+	if len(data.Configs) != 3 {
+		t.Fatalf("expected 3 blocks, got %d", len(data.Configs))
+	}
+	if data.Configs[0].Article != "ART-10" || data.Configs[0].Line != 10 {
+		t.Fatalf("first block must be line 10, got article=%s line=%d", data.Configs[0].Article, data.Configs[0].Line)
+	}
+	if data.Configs[1].Article != "ART-20" || data.Configs[1].Line != 20 {
+		t.Fatalf("second block must be line 20, got article=%s line=%d", data.Configs[1].Article, data.Configs[1].Line)
+	}
+	if data.Configs[2].Article != "ART-30" || data.Configs[2].Line != 30 {
+		t.Fatalf("third block must be line 30, got article=%s line=%d", data.Configs[2].Article, data.Configs[2].Line)
+	}
+}
+
+func TestFormatPriceWithSpace(t *testing.T) {
+	tests := []struct {
+		input    float64
+		expected string
+	}{
+		{0, "0"},
+		{100, "100"},
+		{1000, "1 000"},
+		{10470, "10 470"},
+		{104700, "104 700"},
+		{1000000, "1 000 000"},
+	}
+
+	for _, tt := range tests {
+		result := formatPriceWithSpace(tt.input)
+		if result != tt.expected {
+			t.Errorf("formatPriceWithSpace(%v): expected %q, got %q", tt.input, tt.expected, result)
+		}
+	}
+}
+
+func TestFormatPriceComma(t *testing.T) {
+	tests := []struct {
+		input    float64
+		expected string
+	}{
+		{100.0, "100"},
+		{2074.5, "2074,5"},
+		{100.50, "100,5"},
+		{99.99, "99,99"},
+		{0, "0"},
+	}
+
+	for _, tt := range tests {
+		result := formatPriceComma(tt.input)
+		if result != tt.expected {
+			t.Errorf("formatPriceComma(%v): expected %q, got %q", tt.input, tt.expected, result)
+		}
+	}
+}
+
+// failingWriter always returns an error
+type failingWriter struct{}
+
+func (fw *failingWriter) Write(p []byte) (int, error) {
+	return 0, io.EOF
+}

internal/services/local_configuration_versioning_test.go

@@ -0,0 +1,639 @@
+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.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "v1",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 2, UnitPrice: 1000}},
+		ServerCount: 1,
+	}); err != nil {
+		t.Fatalf("update 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.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "base",
+		Items:       models.ConfigItems{{LotName: "RAM_A", Quantity: 3, UnitPrice: 100}},
+		ServerCount: 1,
+	}); err != nil {
+		t.Fatalf("update 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 TestUpdateNoAuthSkipsRevisionWhenSpecAndPriceUnchanged(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "dedupe",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 1000}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+
+	_, err = service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "dedupe",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 2, UnitPrice: 1000}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("first update config: %v", err)
+	}
+
+	_, err = service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "dedupe",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 2, UnitPrice: 1000}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("second update config: %v", err)
+	}
+
+	versions := loadVersions(t, local, created.UUID)
+	if len(versions) != 2 {
+		t.Fatalf("expected 2 versions (create + first update), got %d", len(versions))
+	}
+	if versions[1].VersionNo != 2 {
+		t.Fatalf("expected latest version_no=2, got %d", versions[1].VersionNo)
+	}
+
+	var pendingCount int64
+	if err := local.DB().
+		Table("pending_changes").
+		Where("entity_type = ? AND entity_uuid = ?", "configuration", created.UUID).
+		Count(&pendingCount).Error; err != nil {
+		t.Fatalf("count pending changes: %v", err)
+	}
+	if pendingCount != 2 {
+		t.Fatalf("expected 2 pending changes (create + first update), got %d", pendingCount)
+	}
+}
+
+func TestReorderProjectConfigurationsDoesNotCreateNewVersions(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	project := &localdb.LocalProject{
+		UUID:          "project-reorder",
+		OwnerUsername: "tester",
+		Code:          "PRJ-ORDER",
+		Variant:       "",
+		Name:          ptrString("Project Reorder"),
+		IsActive:      true,
+		CreatedAt:     time.Now(),
+		UpdatedAt:     time.Now(),
+		SyncStatus:    "pending",
+	}
+	if err := local.SaveProject(project); err != nil {
+		t.Fatalf("save project: %v", err)
+	}
+
+	first, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "Cfg A",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 100}},
+		ServerCount: 1,
+		ProjectUUID: &project.UUID,
+	})
+	if err != nil {
+		t.Fatalf("create first config: %v", err)
+	}
+	second, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "Cfg B",
+		Items:       models.ConfigItems{{LotName: "CPU_B", Quantity: 1, UnitPrice: 200}},
+		ServerCount: 1,
+		ProjectUUID: &project.UUID,
+	})
+	if err != nil {
+		t.Fatalf("create second config: %v", err)
+	}
+
+	beforeFirst := loadVersions(t, local, first.UUID)
+	beforeSecond := loadVersions(t, local, second.UUID)
+
+	reordered, err := service.ReorderProjectConfigurationsNoAuth(project.UUID, []string{second.UUID, first.UUID})
+	if err != nil {
+		t.Fatalf("reorder configurations: %v", err)
+	}
+	if len(reordered) != 2 {
+		t.Fatalf("expected 2 reordered configs, got %d", len(reordered))
+	}
+	if reordered[0].UUID != second.UUID || reordered[0].Line != 10 {
+		t.Fatalf("expected second config first with line 10, got uuid=%s line=%d", reordered[0].UUID, reordered[0].Line)
+	}
+	if reordered[1].UUID != first.UUID || reordered[1].Line != 20 {
+		t.Fatalf("expected first config second with line 20, got uuid=%s line=%d", reordered[1].UUID, reordered[1].Line)
+	}
+
+	afterFirst := loadVersions(t, local, first.UUID)
+	afterSecond := loadVersions(t, local, second.UUID)
+	if len(afterFirst) != len(beforeFirst) || len(afterSecond) != len(beforeSecond) {
+		t.Fatalf("reorder must not create new versions")
+	}
+
+	var pendingCount int64
+	if err := local.DB().
+		Table("pending_changes").
+		Where("entity_type = ? AND operation = ? AND entity_uuid IN ?", "configuration", "update", []string{first.UUID, second.UUID}).
+		Count(&pendingCount).Error; err != nil {
+		t.Fatalf("count reorder pending changes: %v", err)
+	}
+	if pendingCount < 2 {
+		t.Fatalf("expected at least 2 pending update changes for reorder, got %d", pendingCount)
+	}
+}
+
+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.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "initial",
+		Items:       models.ConfigItems{{LotName: "SSD_A", Quantity: 2, UnitPrice: 300}},
+		ServerCount: 1,
+	}); err != nil {
+		t.Fatalf("update 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 := updateWithRetry(service, created.UUID, i+2); 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 TestUpdateNoAuthKeepsProjectWhenProjectUUIDOmitted(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	project := &localdb.LocalProject{
+		UUID:          "project-keep",
+		OwnerUsername: "tester",
+		Code:          "TEST-KEEP",
+		Name:          ptrString("Keep Project"),
+		IsActive:      true,
+		CreatedAt:     time.Now(),
+		UpdatedAt:     time.Now(),
+		SyncStatus:    "synced",
+	}
+	if err := local.SaveProject(project); err != nil {
+		t.Fatalf("save project: %v", err)
+	}
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "cfg",
+		ProjectUUID: &project.UUID,
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 100}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+	if created.ProjectUUID == nil || *created.ProjectUUID != project.UUID {
+		t.Fatalf("expected created config project_uuid=%s", project.UUID)
+	}
+
+	updated, err := service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "cfg-updated",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 2, UnitPrice: 100}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("update config without project_uuid: %v", err)
+	}
+	if updated.ProjectUUID == nil || *updated.ProjectUUID != project.UUID {
+		t.Fatalf("expected project_uuid to stay %s after update, got %+v", project.UUID, updated.ProjectUUID)
+	}
+}
+
+func TestUpdateNoAuthAllowsOrphanProjectWhenUUIDUnchanged(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	project := &localdb.LocalProject{
+		UUID:          "project-orphan",
+		OwnerUsername: "tester",
+		Code:          "TEST-ORPHAN",
+		Name:          ptrString("Orphan Project"),
+		IsActive:      true,
+		CreatedAt:     time.Now(),
+		UpdatedAt:     time.Now(),
+		SyncStatus:    "synced",
+	}
+	if err := local.SaveProject(project); err != nil {
+		t.Fatalf("save project: %v", err)
+	}
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "cfg",
+		ProjectUUID: &project.UUID,
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 100}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+
+	// Simulate missing project in local cache while config still references its UUID.
+	if err := local.DB().Where("uuid = ?", project.UUID).Delete(&localdb.LocalProject{}).Error; err != nil {
+		t.Fatalf("delete project: %v", err)
+	}
+
+	updated, err := service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "cfg-updated",
+		ProjectUUID: &project.UUID,
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 2, UnitPrice: 100}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("update config with orphan project_uuid: %v", err)
+	}
+	if updated.ProjectUUID == nil || *updated.ProjectUUID != project.UUID {
+		t.Fatalf("expected project_uuid to stay %s after update, got %+v", project.UUID, updated.ProjectUUID)
+	}
+}
+
+func TestUpdateNoAuthRecoversWhenCurrentVersionMissing(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	created, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "cfg",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 100}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+
+	// Simulate corrupted/legacy versioning state:
+	// local configuration exists, but all version rows are gone and pointer is stale.
+	if err := local.DB().Where("configuration_uuid = ?", created.UUID).
+		Delete(&localdb.LocalConfigurationVersion{}).Error; err != nil {
+		t.Fatalf("delete versions: %v", err)
+	}
+	staleID := "missing-version-id"
+	if err := local.DB().Model(&localdb.LocalConfiguration{}).
+		Where("uuid = ?", created.UUID).
+		Update("current_version_id", staleID).Error; err != nil {
+		t.Fatalf("set stale current_version_id: %v", err)
+	}
+
+	updated, err := service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "cfg-updated",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 2, UnitPrice: 100}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("update config with missing current version: %v", err)
+	}
+
+	if updated.Name != "cfg-updated" {
+		t.Fatalf("expected updated name, got %q", updated.Name)
+	}
+
+	versions := loadVersions(t, local, created.UUID)
+	if len(versions) != 1 {
+		t.Fatalf("expected 1 recreated version, got %d", len(versions))
+	}
+	if versions[0].VersionNo != 1 {
+		t.Fatalf("expected recreated version_no=1, got %d", versions[0].VersionNo)
+	}
+}
+
+func ptrString(value string) *string {
+	return &value
+}
+
+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 updateWithRetry(service *LocalConfigurationService, uuid string, quantity int) error {
+	var lastErr error
+	for i := 0; i < 6; i++ {
+		_, err := service.UpdateNoAuth(uuid, &CreateConfigRequest{
+			Name:        "base",
+			Items:       models.ConfigItems{{LotName: "NIC_A", Quantity: quantity, UnitPrice: 150}},
+			ServerCount: 1,
+		})
+		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("update 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.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "initial",
+		Items:       models.ConfigItems{{LotName: "GPU_A", Quantity: 2, UnitPrice: 2000}},
+		ServerCount: 1,
+	}); err != nil {
+		t.Fatalf("update: %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

@@ -1,187 +0,0 @@
-package pricelist
-
-import (
-	"fmt"
-	"log/slog"
-	"time"
-
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-	"gorm.io/gorm"
-)
-
-type Service struct {
-	repo          *repository.PricelistRepository
-	componentRepo *repository.ComponentRepository
-	db            *gorm.DB
-}
-
-func NewService(db *gorm.DB, repo *repository.PricelistRepository, componentRepo *repository.ComponentRepository) *Service {
-	return &Service{
-		repo:          repo,
-		componentRepo: componentRepo,
-		db:            db,
-	}
-}
-
-// 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)
-	}
-
-	expiresAt := time.Now().AddDate(1, 0, 0) // +1 year
-
-	pricelist := &models.Pricelist{
-		Version:   version,
-		CreatedBy: createdBy,
-		IsActive:  true,
-		ExpiresAt: &expiresAt,
-	}
-
-	if err := s.repo.Create(pricelist); err != nil {
-		return nil, fmt.Errorf("creating pricelist: %w", err)
-	}
-
-	// Get all components with prices from qt_lot_metadata
-	var metadata []models.LotMetadata
-	if err := s.db.Where("current_price IS NOT NULL AND current_price > 0").Find(&metadata).Error; err != nil {
-		return nil, fmt.Errorf("getting lot metadata: %w", err)
-	}
-
-	// Create pricelist items with all price settings
-	items := make([]models.PricelistItem, 0, len(metadata))
-	for _, m := range metadata {
-		if m.CurrentPrice == nil || *m.CurrentPrice <= 0 {
-			continue
-		}
-		items = append(items, models.PricelistItem{
-			PricelistID:      pricelist.ID,
-			LotName:          m.LotName,
-			Price:            *m.CurrentPrice,
-			PriceMethod:      string(m.PriceMethod),
-			PricePeriodDays:  m.PricePeriodDays,
-			PriceCoefficient: m.PriceCoefficient,
-			ManualPrice:      m.ManualPrice,
-			MetaPrices:       m.MetaPrices,
-		})
-	}
-
-	if err := s.repo.CreateItems(items); err != nil {
-		// Clean up the pricelist if items creation fails
-		s.repo.Delete(pricelist.ID)
-		return nil, fmt.Errorf("creating pricelist items: %w", err)
-	}
-
-	pricelist.ItemCount = len(items)
-
-	slog.Info("pricelist created",
-		"id", pricelist.ID,
-		"version", pricelist.Version,
-		"items", len(items),
-		"created_by", createdBy,
-	)
-
-	return pricelist, nil
-}
-
-// 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
-	}
-	if perPage < 1 {
-		perPage = 20
-	}
-	offset := (page - 1) * perPage
-	return s.repo.List(offset, perPage)
-}
-
-// 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
-	}
-	if perPage < 1 {
-		perPage = 50
-	}
-	offset := (page - 1) * perPage
-	return s.repo.GetItems(pricelistID, offset, perPage, search)
-}
-
-// 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
-	}
-
-	deleted := 0
-	for _, pl := range expired {
-		if err := s.repo.Delete(pl.ID); err != nil {
-			slog.Warn("failed to delete expired pricelist", "id", pl.ID, "error", err)
-			continue
-		}
-		deleted++
-	}
-
-	slog.Info("cleaned up expired pricelists", "deleted", deleted)
-	return deleted, nil
-}

internal/services/pricing/calculator.go

@@ -1,121 +0,0 @@
-package pricing
-
-import (
-	"math"
-	"sort"
-	"time"
-
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-)
-
-// CalculateMedian returns the median of prices
-func CalculateMedian(prices []float64) float64 {
-	if len(prices) == 0 {
-		return 0
-	}
-
-	sorted := make([]float64, len(prices))
-	copy(sorted, prices)
-	sort.Float64s(sorted)
-
-	n := len(sorted)
-	if n%2 == 0 {
-		return (sorted[n/2-1] + sorted[n/2]) / 2
-	}
-	return sorted[n/2]
-}
-
-// CalculateAverage returns the arithmetic mean of prices
-func CalculateAverage(prices []float64) float64 {
-	if len(prices) == 0 {
-		return 0
-	}
-
-	var sum float64
-	for _, p := range prices {
-		sum += p
-	}
-	return sum / float64(len(prices))
-}
-
-// CalculateWeightedMedian calculates median with exponential decay weights
-// More recent prices have higher weight
-func CalculateWeightedMedian(points []repository.PricePoint, decayDays int) float64 {
-	if len(points) == 0 {
-		return 0
-	}
-
-	type weightedPrice struct {
-		price  float64
-		weight float64
-	}
-
-	now := time.Now()
-	weighted := make([]weightedPrice, len(points))
-	var totalWeight float64
-
-	for i, p := range points {
-		daysSince := now.Sub(p.Date).Hours() / 24
-		// weight = e^(-days / decay_days)
-		weight := math.Exp(-daysSince / float64(decayDays))
-		weighted[i] = weightedPrice{price: p.Price, weight: weight}
-		totalWeight += weight
-	}
-
-	// Sort by price
-	sort.Slice(weighted, func(i, j int) bool {
-		return weighted[i].price < weighted[j].price
-	})
-
-	// Find weighted median
-	targetWeight := totalWeight / 2
-	var cumulativeWeight float64
-
-	for _, wp := range weighted {
-		cumulativeWeight += wp.weight
-		if cumulativeWeight >= targetWeight {
-			return wp.price
-		}
-	}
-
-	return weighted[len(weighted)-1].price
-}
-
-// CalculatePercentile calculates the nth percentile of prices
-func CalculatePercentile(prices []float64, percentile float64) float64 {
-	if len(prices) == 0 {
-		return 0
-	}
-
-	sorted := make([]float64, len(prices))
-	copy(sorted, prices)
-	sort.Float64s(sorted)
-
-	index := (percentile / 100) * float64(len(sorted)-1)
-	lower := int(math.Floor(index))
-	upper := int(math.Ceil(index))
-
-	if lower == upper {
-		return sorted[lower]
-	}
-
-	fraction := index - float64(lower)
-	return sorted[lower]*(1-fraction) + sorted[upper]*fraction
-}
-
-// CalculateStdDev calculates standard deviation
-func CalculateStdDev(prices []float64) float64 {
-	if len(prices) < 2 {
-		return 0
-	}
-
-	mean := CalculateAverage(prices)
-	var sumSquares float64
-
-	for _, p := range prices {
-		diff := p - mean
-		sumSquares += diff * diff
-	}
-
-	return math.Sqrt(sumSquares / float64(len(prices)-1))
-}

internal/services/pricing/service.go

@@ -1,205 +0,0 @@
-package pricing
-
-import (
-	"time"
-
-	"git.mchus.pro/mchus/quoteforge/internal/config"
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-)
-
-type Service struct {
-	componentRepo *repository.ComponentRepository
-	priceRepo     *repository.PriceRepository
-	config        config.PricingConfig
-}
-
-func NewService(
-	componentRepo *repository.ComponentRepository,
-	priceRepo *repository.PriceRepository,
-	cfg config.PricingConfig,
-) *Service {
-	return &Service{
-		componentRepo: componentRepo,
-		priceRepo:     priceRepo,
-		config:        cfg,
-	}
-}
-
-// GetEffectivePrice returns the current effective price for a component
-// Priority: active override > calculated price > nil
-func (s *Service) GetEffectivePrice(lotName string) (*float64, error) {
-	// Check for active override first
-	override, err := s.priceRepo.GetPriceOverride(lotName)
-	if err == nil && override != nil {
-		return &override.Price, nil
-	}
-
-	// Get component metadata
-	component, err := s.componentRepo.GetByLotName(lotName)
-	if err != nil {
-		return nil, err
-	}
-
-	return component.CurrentPrice, nil
-}
-
-// CalculatePrice calculates price using the specified method
-func (s *Service) CalculatePrice(lotName string, method models.PriceMethod, periodDays int) (float64, error) {
-	if periodDays == 0 {
-		periodDays = s.config.DefaultPeriodDays
-	}
-
-	points, err := s.priceRepo.GetPriceHistory(lotName, periodDays)
-	if err != nil {
-		return 0, err
-	}
-
-	if len(points) == 0 {
-		return 0, nil
-	}
-
-	prices := make([]float64, len(points))
-	for i, p := range points {
-		prices[i] = p.Price
-	}
-
-	switch method {
-	case models.PriceMethodAverage:
-		return CalculateAverage(prices), nil
-	case models.PriceMethodWeightedMedian:
-		return CalculateWeightedMedian(points, periodDays), nil
-	case models.PriceMethodMedian:
-		fallthrough
-	default:
-		return CalculateMedian(prices), nil
-	}
-}
-
-// UpdateComponentPrice recalculates and updates the price for a component
-func (s *Service) UpdateComponentPrice(lotName string) error {
-	component, err := s.componentRepo.GetByLotName(lotName)
-	if err != nil {
-		return err
-	}
-
-	price, err := s.CalculatePrice(lotName, component.PriceMethod, component.PricePeriodDays)
-	if err != nil {
-		return err
-	}
-
-	now := time.Now()
-	if price > 0 {
-		component.CurrentPrice = &price
-		component.PriceUpdatedAt = &now
-	}
-
-	return s.componentRepo.Update(component)
-}
-
-// SetManualPrice sets a manual price override
-func (s *Service) SetManualPrice(lotName string, price float64, reason string, userID uint) error {
-	override := &models.PriceOverride{
-		LotName:   lotName,
-		Price:     price,
-		ValidFrom: time.Now(),
-		Reason:    reason,
-		CreatedBy: userID,
-	}
-	return s.priceRepo.CreatePriceOverride(override)
-}
-
-// UpdatePriceMethod changes the pricing method for a component
-func (s *Service) UpdatePriceMethod(lotName string, method models.PriceMethod, periodDays int) error {
-	component, err := s.componentRepo.GetByLotName(lotName)
-	if err != nil {
-		return err
-	}
-
-	component.PriceMethod = method
-	if periodDays > 0 {
-		component.PricePeriodDays = periodDays
-	}
-
-	if err := s.componentRepo.Update(component); err != nil {
-		return err
-	}
-
-	return s.UpdateComponentPrice(lotName)
-}
-
-// GetPriceStats returns statistics for a component's price history
-func (s *Service) GetPriceStats(lotName string, periodDays int) (*PriceStats, error) {
-	if periodDays == 0 {
-		periodDays = s.config.DefaultPeriodDays
-	}
-
-	points, err := s.priceRepo.GetPriceHistory(lotName, periodDays)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(points) == 0 {
-		return &PriceStats{QuoteCount: 0}, nil
-	}
-
-	prices := make([]float64, len(points))
-	for i, p := range points {
-		prices[i] = p.Price
-	}
-
-	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),
-	}, nil
-}
-
-type PriceStats struct {
-	QuoteCount   int       `json:"quote_count"`
-	MinPrice     float64   `json:"min_price"`
-	MaxPrice     float64   `json:"max_price"`
-	MedianPrice  float64   `json:"median_price"`
-	AveragePrice float64   `json:"average_price"`
-	StdDeviation float64   `json:"std_deviation"`
-	LatestPrice  float64   `json:"latest_price"`
-	LatestDate   time.Time `json:"latest_date"`
-	OldestDate   time.Time `json:"oldest_date"`
-	Percentile25 float64   `json:"percentile_25"`
-	Percentile75 float64   `json:"percentile_75"`
-}
-
-// RecalculateAllPrices recalculates prices for all components
-func (s *Service) RecalculateAllPrices() (updated int, errors int) {
-	// Get all components
-	filter := repository.ComponentFilter{}
-	offset := 0
-	limit := 100
-
-	for {
-		components, _, err := s.componentRepo.List(filter, offset, limit)
-		if err != nil || len(components) == 0 {
-			break
-		}
-
-		for _, comp := range components {
-			if err := s.UpdateComponentPrice(comp.LotName); err != nil {
-				errors++
-			} else {
-				updated++
-			}
-		}
-
-		offset += limit
-	}
-
-	return updated, errors
-}

internal/services/project.go

@@ -0,0 +1,387 @@
+package services
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"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"
+)
+
+var (
+	ErrProjectNotFound         = errors.New("project not found")
+	ErrProjectForbidden        = errors.New("access to project forbidden")
+	ErrProjectCodeExists       = errors.New("project code and variant already exist")
+	ErrCannotDeleteMainVariant = errors.New("cannot delete main variant")
+)
+
+type ProjectService struct {
+	localDB *localdb.LocalDB
+}
+
+func NewProjectService(localDB *localdb.LocalDB) *ProjectService {
+	return &ProjectService{localDB: localDB}
+}
+
+type CreateProjectRequest struct {
+	Code       string  `json:"code"`
+	Variant    string  `json:"variant,omitempty"`
+	Name       *string `json:"name,omitempty"`
+	TrackerURL string  `json:"tracker_url"`
+}
+
+type UpdateProjectRequest struct {
+	Code       *string `json:"code,omitempty"`
+	Variant    *string `json:"variant,omitempty"`
+	Name       *string `json:"name,omitempty"`
+	TrackerURL *string `json:"tracker_url,omitempty"`
+}
+
+type ProjectConfigurationsResult struct {
+	ProjectUUID string                 `json:"project_uuid"`
+	Configs     []models.Configuration `json:"configurations"`
+	Total       float64                `json:"total"`
+}
+
+func (s *ProjectService) Create(ownerUsername string, req *CreateProjectRequest) (*models.Project, error) {
+	var namePtr *string
+	if req.Name != nil {
+		name := strings.TrimSpace(*req.Name)
+		if name != "" {
+			namePtr = &name
+		}
+	}
+	code := strings.TrimSpace(req.Code)
+	if code == "" {
+		return nil, fmt.Errorf("project code is required")
+	}
+	variant := strings.TrimSpace(req.Variant)
+	if err := s.ensureUniqueProjectCodeVariant("", code, variant); err != nil {
+		return nil, err
+	}
+
+	now := time.Now()
+	localProject := &localdb.LocalProject{
+		UUID:          uuid.NewString(),
+		OwnerUsername: ownerUsername,
+		Code:          code,
+		Variant:       variant,
+		Name:          namePtr,
+		TrackerURL:    normalizeProjectTrackerURL(code, req.TrackerURL),
+		IsActive:      true,
+		IsSystem:      false,
+		CreatedAt:     now,
+		UpdatedAt:     now,
+		SyncStatus:    "pending",
+	}
+	if err := s.localDB.SaveProject(localProject); err != nil {
+		return nil, err
+	}
+	if err := s.enqueueProjectPendingChange(localProject, "create"); err != nil {
+		return nil, err
+	}
+	return localdb.LocalToProject(localProject), nil
+}
+
+func (s *ProjectService) Update(projectUUID, ownerUsername string, req *UpdateProjectRequest) (*models.Project, error) {
+	localProject, err := s.localDB.GetProjectByUUID(projectUUID)
+	if err != nil {
+		return nil, ErrProjectNotFound
+	}
+
+	if req.Code != nil {
+		code := strings.TrimSpace(*req.Code)
+		if code == "" {
+			return nil, fmt.Errorf("project code is required")
+		}
+		localProject.Code = code
+	}
+	if req.Variant != nil {
+		localProject.Variant = strings.TrimSpace(*req.Variant)
+	}
+	if err := s.ensureUniqueProjectCodeVariant(projectUUID, localProject.Code, localProject.Variant); err != nil {
+		return nil, err
+	}
+
+	if req.Name != nil {
+		name := strings.TrimSpace(*req.Name)
+		if name == "" {
+			localProject.Name = nil
+		} else {
+			localProject.Name = &name
+		}
+	}
+	if req.TrackerURL != nil {
+		localProject.TrackerURL = normalizeProjectTrackerURL(localProject.Code, *req.TrackerURL)
+	} else if strings.TrimSpace(localProject.TrackerURL) == "" {
+		localProject.TrackerURL = normalizeProjectTrackerURL(localProject.Code, "")
+	}
+	localProject.UpdatedAt = time.Now()
+	localProject.SyncStatus = "pending"
+	if err := s.localDB.SaveProject(localProject); err != nil {
+		return nil, err
+	}
+	if err := s.enqueueProjectPendingChange(localProject, "update"); err != nil {
+		return nil, err
+	}
+	return localdb.LocalToProject(localProject), nil
+}
+
+func (s *ProjectService) ensureUniqueProjectCodeVariant(excludeUUID, code, variant string) error {
+	normalizedCode := normalizeProjectCode(code)
+	normalizedVariant := normalizeProjectVariant(variant)
+	if normalizedCode == "" {
+		return fmt.Errorf("project code is required")
+	}
+
+	projects, err := s.localDB.GetAllProjects(true)
+	if err != nil {
+		return err
+	}
+	for i := range projects {
+		project := projects[i]
+		if excludeUUID != "" && project.UUID == excludeUUID {
+			continue
+		}
+		if normalizeProjectCode(project.Code) == normalizedCode &&
+			normalizeProjectVariant(project.Variant) == normalizedVariant {
+			return ErrProjectCodeExists
+		}
+	}
+	return nil
+}
+
+func normalizeProjectCode(code string) string {
+	return strings.ToLower(strings.TrimSpace(code))
+}
+
+func normalizeProjectVariant(variant string) string {
+	return strings.ToLower(strings.TrimSpace(variant))
+}
+
+func (s *ProjectService) Archive(projectUUID, ownerUsername string) error {
+	return s.setProjectActive(projectUUID, ownerUsername, false)
+}
+
+func (s *ProjectService) Reactivate(projectUUID, ownerUsername string) error {
+	return s.setProjectActive(projectUUID, ownerUsername, true)
+}
+
+func (s *ProjectService) DeleteVariant(projectUUID, ownerUsername string) error {
+	localProject, err := s.localDB.GetProjectByUUID(projectUUID)
+	if err != nil {
+		return ErrProjectNotFound
+	}
+	if strings.TrimSpace(localProject.Variant) == "" {
+		return ErrCannotDeleteMainVariant
+	}
+	return s.setProjectActive(projectUUID, ownerUsername, false)
+}
+
+func (s *ProjectService) setProjectActive(projectUUID, ownerUsername string, isActive bool) error {
+	return s.localDB.DB().Transaction(func(tx *gorm.DB) error {
+		var project localdb.LocalProject
+		if err := tx.Where("uuid = ?", projectUUID).First(&project).Error; err != nil {
+			return ErrProjectNotFound
+		}
+		if project.IsActive == isActive {
+			return nil
+		}
+
+		project.IsActive = isActive
+		project.UpdatedAt = time.Now()
+		project.SyncStatus = "pending"
+		if err := tx.Save(&project).Error; err != nil {
+			return err
+		}
+
+		if err := s.enqueueProjectPendingChangeTx(tx, &project, boolToOp(isActive, "reactivate", "archive")); err != nil {
+			return err
+		}
+
+		var configs []localdb.LocalConfiguration
+		if err := tx.Where("project_uuid = ?", projectUUID).Find(&configs).Error; err != nil {
+			return err
+		}
+		for i := range configs {
+			cfg := configs[i]
+			cfg.IsActive = isActive
+			cfg.SyncStatus = "pending"
+			cfg.UpdatedAt = time.Now()
+			if err := tx.Save(&cfg).Error; err != nil {
+				return err
+			}
+
+			modelCfg := localdb.LocalToConfiguration(&cfg)
+			payload, err := json.Marshal(modelCfg)
+			if err != nil {
+				return err
+			}
+			change := &localdb.PendingChange{
+				EntityType: "configuration",
+				EntityUUID: cfg.UUID,
+				Operation:  "update",
+				Payload:    string(payload),
+				CreatedAt:  time.Now(),
+				Attempts:   0,
+			}
+			if err := tx.Create(change).Error; err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func (s *ProjectService) ListByUser(ownerUsername string, includeArchived bool) ([]models.Project, error) {
+	localProjects, err := s.localDB.GetAllProjects(includeArchived)
+	if err != nil {
+		return nil, err
+	}
+
+	projects := make([]models.Project, 0, len(localProjects))
+	for i := range localProjects {
+		projects = append(projects, *localdb.LocalToProject(&localProjects[i]))
+	}
+	return projects, nil
+}
+
+func (s *ProjectService) GetByUUID(projectUUID, ownerUsername string) (*models.Project, error) {
+	localProject, err := s.localDB.GetProjectByUUID(projectUUID)
+	if err != nil {
+		return nil, ErrProjectNotFound
+	}
+	return localdb.LocalToProject(localProject), nil
+}
+
+func (s *ProjectService) ListConfigurations(projectUUID, ownerUsername, status string) (*ProjectConfigurationsResult, error) {
+	project, err := s.GetByUUID(projectUUID, ownerUsername)
+	if err != nil {
+		return nil, err
+	}
+	if !project.IsActive && status == "active" {
+		return &ProjectConfigurationsResult{
+			ProjectUUID: projectUUID,
+			Configs:     []models.Configuration{},
+			Total:       0,
+		}, nil
+	}
+
+	query := s.localDB.DB().
+		Preload("CurrentVersion").
+		Where("project_uuid = ?", projectUUID).
+		Order("CASE WHEN COALESCE(line_no, 0) <= 0 THEN 2147483647 ELSE line_no END ASC, created_at DESC, id DESC")
+
+	switch status {
+	case "active", "":
+		query = query.Where("is_active = ?", true)
+	case "archived":
+		query = query.Where("is_active = ?", false)
+	case "all":
+	default:
+		query = query.Where("is_active = ?", true)
+	}
+
+	var localConfigs []localdb.LocalConfiguration
+	if err := query.Find(&localConfigs).Error; err != nil {
+		return nil, err
+	}
+
+	configs := make([]models.Configuration, 0, len(localConfigs))
+	total := 0.0
+	for i := range localConfigs {
+		localCfg := localConfigs[i]
+		cfg := localdb.LocalToConfiguration(&localCfg)
+		if cfg.TotalPrice != nil {
+			total += *cfg.TotalPrice
+		}
+		configs = append(configs, *cfg)
+	}
+
+	return &ProjectConfigurationsResult{
+		ProjectUUID: projectUUID,
+		Configs:     configs,
+		Total:       total,
+	}, nil
+}
+
+func (s *ProjectService) ResolveProjectUUID(ownerUsername string, projectUUID *string) (*string, error) {
+	if projectUUID == nil || strings.TrimSpace(*projectUUID) == "" {
+		project, err := s.localDB.EnsureDefaultProject(ownerUsername)
+		if err != nil {
+			return nil, err
+		}
+		return &project.UUID, nil
+	}
+
+	project, err := s.localDB.GetProjectByUUID(strings.TrimSpace(*projectUUID))
+	if err != nil {
+		return nil, ErrProjectNotFound
+	}
+	if project.OwnerUsername != ownerUsername {
+		return nil, ErrProjectForbidden
+	}
+	if !project.IsActive {
+		return nil, fmt.Errorf("project is archived")
+	}
+
+	resolved := project.UUID
+	return &resolved, nil
+}
+
+func normalizeProjectTrackerURL(projectCode, trackerURL string) string {
+	trimmedURL := strings.TrimSpace(trackerURL)
+	if trimmedURL != "" {
+		return trimmedURL
+	}
+
+	trimmedCode := strings.TrimSpace(projectCode)
+	if trimmedCode == "" {
+		return ""
+	}
+
+	return "https://tracker.yandex.ru/" + url.PathEscape(trimmedCode)
+}
+
+func (s *ProjectService) enqueueProjectPendingChange(project *localdb.LocalProject, operation string) error {
+	return s.enqueueProjectPendingChangeTx(s.localDB.DB(), project, operation)
+}
+
+func (s *ProjectService) enqueueProjectPendingChangeTx(tx *gorm.DB, project *localdb.LocalProject, operation string) error {
+	payload := sync.ProjectChangePayload{
+		EventID:        uuid.NewString(),
+		ProjectUUID:    project.UUID,
+		Operation:      operation,
+		Snapshot:       *localdb.LocalToProject(project),
+		CreatedAt:      time.Now().UTC(),
+		IdempotencyKey: fmt.Sprintf("%s:%d:%s", project.UUID, project.UpdatedAt.UnixNano(), operation),
+	}
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+	change := &localdb.PendingChange{
+		EntityType: "project",
+		EntityUUID: project.UUID,
+		Operation:  operation,
+		Payload:    string(raw),
+		CreatedAt:  time.Now(),
+		Attempts:   0,
+	}
+	return tx.Create(change).Error
+}
+
+func boolToOp(v bool, whenTrue, whenFalse string) string {
+	if v {
+		return whenTrue
+	}
+	return whenFalse
+}

internal/services/quote.go

@@ -2,10 +2,13 @@ package services
 
 import (
 	"errors"
+	"fmt"
+	"sync"
+	"time"
 
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
-	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
 )
 
 var (
@@ -17,21 +20,41 @@ var (
 type QuoteService struct {
 	componentRepo  *repository.ComponentRepository
 	statsRepo      *repository.StatsRepository
-	pricingService *pricing.Service
+	pricelistRepo  *repository.PricelistRepository
+	localDB        *localdb.LocalDB
+	pricingService priceResolver
+	cacheMu        sync.RWMutex
+	priceCache     map[string]cachedLotPrice
+	cacheTTL       time.Duration
+}
+
+type priceResolver interface {
+	GetEffectivePrice(lotName string) (*float64, error)
 }
 
 func NewQuoteService(
 	componentRepo *repository.ComponentRepository,
 	statsRepo *repository.StatsRepository,
-	pricingService *pricing.Service,
+	pricelistRepo *repository.PricelistRepository,
+	localDB *localdb.LocalDB,
+	pricingService priceResolver,
 ) *QuoteService {
 	return &QuoteService{
 		componentRepo:  componentRepo,
 		statsRepo:      statsRepo,
+		pricelistRepo:  pricelistRepo,
+		localDB:        localDB,
 		pricingService: pricingService,
+		priceCache:     make(map[string]cachedLotPrice, 4096),
+		cacheTTL:       10 * time.Second,
 	}
 }
 
+type cachedLotPrice struct {
+	price     *float64
+	expiresAt time.Time
+}
+
 type QuoteItem struct {
 	LotName     string  `json:"lot_name"`
 	Quantity    int     `json:"quantity"`
@@ -55,14 +78,105 @@ type QuoteRequest struct {
 		LotName  string `json:"lot_name"`
 		Quantity int    `json:"quantity"`
 	} `json:"items"`
+	PricelistID *uint `json:"pricelist_id,omitempty"` // Optional: use specific pricelist for pricing
+}
+
+type PriceLevelsRequest struct {
+	Items []struct {
+		LotName  string `json:"lot_name"`
+		Quantity int    `json:"quantity"`
+	} `json:"items"`
+	PricelistIDs map[string]uint `json:"pricelist_ids,omitempty"`
+	NoCache      bool            `json:"no_cache,omitempty"`
+}
+
+type PriceLevelsItem struct {
+	LotName              string   `json:"lot_name"`
+	Quantity             int      `json:"quantity"`
+	EstimatePrice        *float64 `json:"estimate_price"`
+	WarehousePrice       *float64 `json:"warehouse_price"`
+	CompetitorPrice      *float64 `json:"competitor_price"`
+	DeltaWhEstimateAbs   *float64 `json:"delta_wh_estimate_abs"`
+	DeltaWhEstimatePct   *float64 `json:"delta_wh_estimate_pct"`
+	DeltaCompEstimateAbs *float64 `json:"delta_comp_estimate_abs"`
+	DeltaCompEstimatePct *float64 `json:"delta_comp_estimate_pct"`
+	DeltaCompWhAbs       *float64 `json:"delta_comp_wh_abs"`
+	DeltaCompWhPct       *float64 `json:"delta_comp_wh_pct"`
+	PriceMissing         []string `json:"price_missing"`
+}
+
+type PriceLevelsResult struct {
+	Items                []PriceLevelsItem `json:"items"`
+	ResolvedPricelistIDs map[string]uint   `json:"resolved_pricelist_ids"`
 }
 
 func (s *QuoteService) ValidateAndCalculate(req *QuoteRequest) (*QuoteValidationResult, error) {
 	if len(req.Items) == 0 {
 		return nil, ErrEmptyQuote
 	}
+
+	// Strict local-first path: calculations use local SQLite snapshot regardless of online status.
+	if s.localDB != nil {
+		result := &QuoteValidationResult{
+			Valid:    true,
+			Items:    make([]QuoteItem, 0, len(req.Items)),
+			Errors:   make([]string, 0),
+			Warnings: make([]string, 0),
+		}
+
+		// Determine which pricelist to use for pricing
+		pricelistID := req.PricelistID
+		if pricelistID == nil || *pricelistID == 0 {
+			// By default, use latest estimate pricelist
+			latestPricelist, err := s.localDB.GetLatestLocalPricelistBySource("estimate")
+			if err == nil && latestPricelist != nil {
+				pricelistID = &latestPricelist.ServerID
+			}
+		}
+
+		var total float64
+		for _, reqItem := range req.Items {
+			localComp, err := s.localDB.GetLocalComponent(reqItem.LotName)
+			if err != nil {
+				result.Valid = false
+				result.Errors = append(result.Errors, "Component not found: "+reqItem.LotName)
+				continue
+			}
+
+			item := QuoteItem{
+				LotName:     reqItem.LotName,
+				Quantity:    reqItem.Quantity,
+				Description: localComp.LotDescription,
+				Category:    localComp.Category,
+				HasPrice:    false,
+				UnitPrice:   0,
+				TotalPrice:  0,
+			}
+
+			// Get price from pricelist_items
+			if pricelistID != nil {
+				price, found := s.lookupPriceByPricelistID(*pricelistID, reqItem.LotName)
+				if found && price > 0 {
+					item.UnitPrice = price
+					item.TotalPrice = price * float64(reqItem.Quantity)
+					item.HasPrice = true
+					total += item.TotalPrice
+				} else {
+					result.Warnings = append(result.Warnings, "No price available for: "+reqItem.LotName)
+				}
+			} else {
+				result.Warnings = append(result.Warnings, "No pricelist available for: "+reqItem.LotName)
+			}
+
+			result.Items = append(result.Items, item)
+		}
+
+		result.Total = total
+		return result, nil
+	}
+
 	if s.componentRepo == nil || s.pricingService == nil {
-		return nil, errors.New("offline mode: quote calculation not available")
+		return nil, errors.New("quote calculation not available")
 	}
 
 	result := &QuoteValidationResult{
@@ -130,8 +244,272 @@ func (s *QuoteService) ValidateAndCalculate(req *QuoteRequest) (*QuoteValidation
 	return result, nil
 }
 
+func (s *QuoteService) CalculatePriceLevels(req *PriceLevelsRequest) (*PriceLevelsResult, error) {
+	if len(req.Items) == 0 {
+		return nil, ErrEmptyQuote
+	}
+
+	lotNames := make([]string, 0, len(req.Items))
+	seenLots := make(map[string]struct{}, len(req.Items))
+	for _, reqItem := range req.Items {
+		if _, ok := seenLots[reqItem.LotName]; ok {
+			continue
+		}
+		seenLots[reqItem.LotName] = struct{}{}
+		lotNames = append(lotNames, reqItem.LotName)
+	}
+
+	result := &PriceLevelsResult{
+		Items:                make([]PriceLevelsItem, 0, len(req.Items)),
+		ResolvedPricelistIDs: map[string]uint{},
+	}
+
+	type levelState struct {
+		id     uint
+		prices map[string]float64
+	}
+	levelBySource := map[models.PricelistSource]*levelState{
+		models.PricelistSourceEstimate:   {prices: map[string]float64{}},
+		models.PricelistSourceWarehouse:  {prices: map[string]float64{}},
+		models.PricelistSourceCompetitor: {prices: map[string]float64{}},
+	}
+
+	for source, st := range levelBySource {
+		sourceKey := string(source)
+		if req.PricelistIDs != nil {
+			if explicitID, ok := req.PricelistIDs[sourceKey]; ok && explicitID > 0 {
+				st.id = explicitID
+				result.ResolvedPricelistIDs[sourceKey] = explicitID
+			}
+		}
+		if st.id == 0 && s.pricelistRepo != nil {
+			latest, err := s.pricelistRepo.GetLatestActiveBySource(sourceKey)
+			if err == nil {
+				st.id = latest.ID
+				result.ResolvedPricelistIDs[sourceKey] = latest.ID
+			}
+		}
+		if st.id == 0 && s.localDB != nil {
+			localPL, err := s.localDB.GetLatestLocalPricelistBySource(sourceKey)
+			if err == nil && localPL != nil {
+				st.id = localPL.ServerID
+				result.ResolvedPricelistIDs[sourceKey] = localPL.ServerID
+			}
+		}
+		if st.id == 0 {
+			continue
+		}
+		prices, err := s.lookupPricesByPricelistID(st.id, lotNames, req.NoCache)
+		if err == nil {
+			st.prices = prices
+		}
+	}
+
+	for _, reqItem := range req.Items {
+		item := PriceLevelsItem{
+			LotName:      reqItem.LotName,
+			Quantity:     reqItem.Quantity,
+			PriceMissing: make([]string, 0, 3),
+		}
+
+		if p, ok := levelBySource[models.PricelistSourceEstimate].prices[reqItem.LotName]; ok && p > 0 {
+			price := p
+			item.EstimatePrice = &price
+		}
+		if p, ok := levelBySource[models.PricelistSourceWarehouse].prices[reqItem.LotName]; ok && p > 0 {
+			price := p
+			item.WarehousePrice = &price
+		}
+		if p, ok := levelBySource[models.PricelistSourceCompetitor].prices[reqItem.LotName]; ok && p > 0 {
+			price := p
+			item.CompetitorPrice = &price
+		}
+
+		if item.EstimatePrice == nil {
+			item.PriceMissing = append(item.PriceMissing, string(models.PricelistSourceEstimate))
+		}
+		if item.WarehousePrice == nil {
+			item.PriceMissing = append(item.PriceMissing, string(models.PricelistSourceWarehouse))
+		}
+		if item.CompetitorPrice == nil {
+			item.PriceMissing = append(item.PriceMissing, string(models.PricelistSourceCompetitor))
+		}
+
+		item.DeltaWhEstimateAbs, item.DeltaWhEstimatePct = calculateDelta(item.WarehousePrice, item.EstimatePrice)
+		item.DeltaCompEstimateAbs, item.DeltaCompEstimatePct = calculateDelta(item.CompetitorPrice, item.EstimatePrice)
+		item.DeltaCompWhAbs, item.DeltaCompWhPct = calculateDelta(item.CompetitorPrice, item.WarehousePrice)
+
+		result.Items = append(result.Items, item)
+	}
+
+	return result, nil
+}
+
+func (s *QuoteService) lookupPricesByPricelistID(pricelistID uint, lotNames []string, noCache bool) (map[string]float64, error) {
+	result := make(map[string]float64, len(lotNames))
+	if pricelistID == 0 || len(lotNames) == 0 {
+		return result, nil
+	}
+
+	missing := make([]string, 0, len(lotNames))
+	if noCache {
+		missing = append(missing, lotNames...)
+	} else {
+		now := time.Now()
+		s.cacheMu.RLock()
+		for _, lotName := range lotNames {
+			if entry, ok := s.priceCache[s.cacheKey(pricelistID, lotName)]; ok && entry.expiresAt.After(now) {
+				if entry.price != nil && *entry.price > 0 {
+					result[lotName] = *entry.price
+				}
+				continue
+			}
+			missing = append(missing, lotName)
+		}
+		s.cacheMu.RUnlock()
+	}
+
+	if len(missing) == 0 {
+		return result, nil
+	}
+
+	loaded := make(map[string]float64, len(missing))
+	if s.pricelistRepo != nil {
+		prices, err := s.pricelistRepo.GetPricesForLots(pricelistID, missing)
+		if err == nil {
+			for lotName, price := range prices {
+				if price > 0 {
+					result[lotName] = price
+					loaded[lotName] = price
+				}
+			}
+			s.updateCache(pricelistID, missing, loaded)
+			return result, nil
+		}
+	}
+
+	// Fallback path (usually offline): local per-lot lookup.
+	if s.localDB != nil {
+		for _, lotName := range missing {
+			price, found := s.lookupPriceByPricelistID(pricelistID, lotName)
+			if found && price > 0 {
+				result[lotName] = price
+				loaded[lotName] = price
+			}
+		}
+		s.updateCache(pricelistID, missing, loaded)
+		return result, nil
+	}
+
+	return result, fmt.Errorf("price lookup unavailable for pricelist %d", pricelistID)
+}
+
+func (s *QuoteService) updateCache(pricelistID uint, requested []string, loaded map[string]float64) {
+	if len(requested) == 0 {
+		return
+	}
+	expiresAt := time.Now().Add(s.cacheTTL)
+	s.cacheMu.Lock()
+	defer s.cacheMu.Unlock()
+
+	for _, lotName := range requested {
+		if price, ok := loaded[lotName]; ok && price > 0 {
+			priceCopy := price
+			s.priceCache[s.cacheKey(pricelistID, lotName)] = cachedLotPrice{
+				price:     &priceCopy,
+				expiresAt: expiresAt,
+			}
+			continue
+		}
+		s.priceCache[s.cacheKey(pricelistID, lotName)] = cachedLotPrice{
+			price:     nil,
+			expiresAt: expiresAt,
+		}
+	}
+}
+
+func (s *QuoteService) cacheKey(pricelistID uint, lotName string) string {
+	return fmt.Sprintf("%d|%s", pricelistID, lotName)
+}
+
+func calculateDelta(target, base *float64) (*float64, *float64) {
+	if target == nil || base == nil {
+		return nil, nil
+	}
+	abs := *target - *base
+	if *base == 0 {
+		return &abs, nil
+	}
+	pct := (abs / *base) * 100
+	return &abs, &pct
+}
+
+func (s *QuoteService) lookupLevelPrice(source models.PricelistSource, lotName string, pricelistIDs map[string]uint) (*float64, uint) {
+	sourceKey := string(source)
+	if id, ok := pricelistIDs[sourceKey]; ok && id > 0 {
+		price, found := s.lookupPriceByPricelistID(id, lotName)
+		if found {
+			return &price, id
+		}
+		return nil, id
+	}
+
+	if s.pricelistRepo != nil {
+		price, id, err := s.pricelistRepo.GetPriceForLotBySource(sourceKey, lotName)
+		if err == nil && price > 0 {
+			return &price, id
+		}
+
+		latest, latestErr := s.pricelistRepo.GetLatestActiveBySource(sourceKey)
+		if latestErr == nil {
+			return nil, latest.ID
+		}
+	}
+
+	if s.localDB != nil {
+		localPL, err := s.localDB.GetLatestLocalPricelistBySource(sourceKey)
+		if err != nil {
+			return nil, 0
+		}
+		price, err := s.localDB.GetLocalPriceForLot(localPL.ID, lotName)
+		if err != nil || price <= 0 {
+			return nil, localPL.ServerID
+		}
+		return &price, localPL.ServerID
+	}
+
+	return nil, 0
+}
+
+func (s *QuoteService) lookupPriceByPricelistID(pricelistID uint, lotName string) (float64, bool) {
+	if s.pricelistRepo != nil {
+		price, err := s.pricelistRepo.GetPriceForLot(pricelistID, lotName)
+		if err == nil && price > 0 {
+			return price, true
+		}
+	}
+
+	if s.localDB != nil {
+		localPL, err := s.localDB.GetLocalPricelistByServerID(pricelistID)
+		if err != nil {
+			return 0, false
+		}
+		price, err := s.localDB.GetLocalPriceForLot(localPL.ID, lotName)
+		if err == nil && price > 0 {
+			return price, true
+		}
+	}
+
+	return 0, false
+}
+
 // 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/quote_price_levels_test.go

@@ -0,0 +1,124 @@
+package services
+
+import (
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+)
+
+func TestCalculatePriceLevels_WithMissingLevel(t *testing.T) {
+	db := newPriceLevelsTestDB(t)
+	repo := repository.NewPricelistRepository(db)
+	service := NewQuoteService(nil, nil, repo, nil, nil)
+
+	estimate := seedPricelistWithItem(t, repo, "estimate", "CPU_X", 100)
+	_ = estimate
+	seedPricelistWithItem(t, repo, "warehouse", "CPU_X", 120)
+
+	result, err := service.CalculatePriceLevels(&PriceLevelsRequest{
+		Items: []struct {
+			LotName  string `json:"lot_name"`
+			Quantity int    `json:"quantity"`
+		}{
+			{LotName: "CPU_X", Quantity: 2},
+		},
+	})
+	if err != nil {
+		t.Fatalf("CalculatePriceLevels returned error: %v", err)
+	}
+	if len(result.Items) != 1 {
+		t.Fatalf("expected 1 item, got %d", len(result.Items))
+	}
+	item := result.Items[0]
+	if item.EstimatePrice == nil || *item.EstimatePrice != 100 {
+		t.Fatalf("expected estimate 100, got %#v", item.EstimatePrice)
+	}
+	if item.WarehousePrice == nil || *item.WarehousePrice != 120 {
+		t.Fatalf("expected warehouse 120, got %#v", item.WarehousePrice)
+	}
+	if item.CompetitorPrice != nil {
+		t.Fatalf("expected competitor nil, got %#v", item.CompetitorPrice)
+	}
+	if len(item.PriceMissing) != 1 || item.PriceMissing[0] != "competitor" {
+		t.Fatalf("expected price_missing [competitor], got %#v", item.PriceMissing)
+	}
+	if item.DeltaWhEstimateAbs == nil || *item.DeltaWhEstimateAbs != 20 {
+		t.Fatalf("expected delta abs 20, got %#v", item.DeltaWhEstimateAbs)
+	}
+	if item.DeltaWhEstimatePct == nil || *item.DeltaWhEstimatePct != 20 {
+		t.Fatalf("expected delta pct 20, got %#v", item.DeltaWhEstimatePct)
+	}
+}
+
+func TestCalculatePriceLevels_UsesExplicitPricelistIDs(t *testing.T) {
+	db := newPriceLevelsTestDB(t)
+	repo := repository.NewPricelistRepository(db)
+	service := NewQuoteService(nil, nil, repo, nil, nil)
+
+	olderEstimate := seedPricelistWithItem(t, repo, "estimate", "CPU_Y", 80)
+	seedPricelistWithItem(t, repo, "estimate", "CPU_Y", 90)
+
+	result, err := service.CalculatePriceLevels(&PriceLevelsRequest{
+		Items: []struct {
+			LotName  string `json:"lot_name"`
+			Quantity int    `json:"quantity"`
+		}{
+			{LotName: "CPU_Y", Quantity: 1},
+		},
+		PricelistIDs: map[string]uint{
+			"estimate": olderEstimate.ID,
+		},
+	})
+	if err != nil {
+		t.Fatalf("CalculatePriceLevels returned error: %v", err)
+	}
+	item := result.Items[0]
+	if item.EstimatePrice == nil || *item.EstimatePrice != 80 {
+		t.Fatalf("expected explicit estimate 80, got %#v", item.EstimatePrice)
+	}
+}
+
+func newPriceLevelsTestDB(t *testing.T) *gorm.DB {
+	t.Helper()
+	db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+	if err := db.AutoMigrate(&models.Pricelist{}, &models.PricelistItem{}); err != nil {
+		t.Fatalf("migrate: %v", err)
+	}
+	return db
+}
+
+func seedPricelistWithItem(t *testing.T, repo *repository.PricelistRepository, source, lot string, price float64) *models.Pricelist {
+	t.Helper()
+	version, err := repo.GenerateVersionBySource(source)
+	if err != nil {
+		t.Fatalf("GenerateVersionBySource: %v", err)
+	}
+	expiresAt := time.Now().Add(24 * time.Hour)
+	pl := &models.Pricelist{
+		Source:    source,
+		Version:   version,
+		CreatedBy: "test",
+		IsActive:  true,
+		ExpiresAt: &expiresAt,
+	}
+	if err := repo.Create(pl); err != nil {
+		t.Fatalf("create pricelist: %v", err)
+	}
+	if err := repo.CreateItems([]models.PricelistItem{
+		{
+			PricelistID: pl.ID,
+			LotName:     lot,
+			Price:       price,
+		},
+	}); err != nil {
+		t.Fatalf("create items: %v", err)
+	}
+	return pl
+}

internal/services/sync/partnumber_books.go

@@ -0,0 +1,127 @@
+package sync
+
+import (
+	"fmt"
+	"log/slog"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"gorm.io/gorm"
+)
+
+// PullPartnumberBooks synchronizes partnumber book snapshots from MariaDB to local SQLite.
+// Append-only for headers; re-pulls items if a book header exists but has 0 items.
+func (s *Service) PullPartnumberBooks() (int, error) {
+	slog.Info("starting partnumber book pull")
+
+	mariaDB, err := s.getDB()
+	if err != nil {
+		return 0, fmt.Errorf("database not available: %w", err)
+	}
+
+	localBookRepo := repository.NewPartnumberBookRepository(s.localDB.DB())
+
+	type serverBook struct {
+		ID        int       `gorm:"column:id"`
+		Version   string    `gorm:"column:version"`
+		CreatedAt time.Time `gorm:"column:created_at"`
+		IsActive  bool      `gorm:"column:is_active"`
+	}
+	var serverBooks []serverBook
+	if err := mariaDB.Raw("SELECT id, version, created_at, is_active FROM qt_partnumber_books ORDER BY created_at DESC, id DESC").Scan(&serverBooks).Error; err != nil {
+		return 0, fmt.Errorf("querying server partnumber books: %w", err)
+	}
+	slog.Info("partnumber books found on server", "count", len(serverBooks))
+
+	pulled := 0
+	for _, sb := range serverBooks {
+		var existing localdb.LocalPartnumberBook
+		err := s.localDB.DB().Where("server_id = ?", sb.ID).First(&existing).Error
+		if err == nil {
+			// Header exists — check whether items were saved
+			localItemCount := localBookRepo.CountBookItems(existing.ID)
+			if localItemCount > 0 {
+				slog.Debug("partnumber book already synced, skipping", "server_id", sb.ID, "version", sb.Version, "items", localItemCount)
+				continue
+			}
+			// Items missing — re-pull them
+			slog.Info("partnumber book header exists but has no items, re-pulling items", "server_id", sb.ID, "version", sb.Version)
+			n, err := pullBookItems(mariaDB, localBookRepo, sb.ID, existing.ID)
+			if err != nil {
+				slog.Error("failed to re-pull items for existing book", "server_id", sb.ID, "error", err)
+			} else {
+				slog.Info("re-pulled items for existing book", "server_id", sb.ID, "version", sb.Version, "items_saved", n)
+				pulled++
+			}
+			continue
+		}
+
+		slog.Info("pulling new partnumber book", "server_id", sb.ID, "version", sb.Version, "is_active", sb.IsActive)
+
+		localBook := &localdb.LocalPartnumberBook{
+			ServerID:  sb.ID,
+			Version:   sb.Version,
+			CreatedAt: sb.CreatedAt,
+			IsActive:  sb.IsActive,
+		}
+		if err := localBookRepo.SaveBook(localBook); err != nil {
+			slog.Error("failed to save local partnumber book", "server_id", sb.ID, "error", err)
+			continue
+		}
+
+		n, err := pullBookItems(mariaDB, localBookRepo, sb.ID, localBook.ID)
+		if err != nil {
+			slog.Error("failed to pull items for new book", "server_id", sb.ID, "error", err)
+			continue
+		}
+
+		slog.Info("partnumber book saved locally", "server_id", sb.ID, "version", sb.Version, "items_saved", n)
+		pulled++
+	}
+
+	slog.Info("partnumber book pull completed", "new_books_pulled", pulled, "total_on_server", len(serverBooks))
+	return pulled, nil
+}
+
+// pullBookItems fetches items for a single book from MariaDB and saves them to SQLite.
+// Returns the number of items saved.
+func pullBookItems(mariaDB *gorm.DB, repo *repository.PartnumberBookRepository, serverBookID int, localBookID uint) (int, error) {
+	type serverItem struct {
+		Partnumber  string `gorm:"column:partnumber"`
+		LotName     string `gorm:"column:lot_name"`
+		IsPrimaryPN bool   `gorm:"column:is_primary_pn"`
+		Description string `gorm:"column:description"`
+	}
+	// description column may not exist yet on older server schemas — query without it first,
+	// then retry with it to populate descriptions if available.
+	var serverItems []serverItem
+	err := mariaDB.Raw("SELECT partnumber, lot_name, is_primary_pn, description FROM qt_partnumber_book_items WHERE book_id = ?", serverBookID).Scan(&serverItems).Error
+	if err != nil {
+		slog.Warn("description column not available on server, retrying without it", "server_book_id", serverBookID, "error", err)
+		if err2 := mariaDB.Raw("SELECT partnumber, lot_name, is_primary_pn FROM qt_partnumber_book_items WHERE book_id = ?", serverBookID).Scan(&serverItems).Error; err2 != nil {
+			return 0, fmt.Errorf("querying items from server: %w", err2)
+		}
+	}
+	slog.Info("partnumber book items fetched from server", "server_book_id", serverBookID, "count", len(serverItems))
+
+	if len(serverItems) == 0 {
+		slog.Warn("server returned 0 items for book — check qt_partnumber_book_items on server", "server_book_id", serverBookID)
+		return 0, nil
+	}
+
+	localItems := make([]localdb.LocalPartnumberBookItem, 0, len(serverItems))
+	for _, si := range serverItems {
+		localItems = append(localItems, localdb.LocalPartnumberBookItem{
+			BookID:      localBookID,
+			Partnumber:  si.Partnumber,
+			LotName:     si.LotName,
+			IsPrimaryPN: si.IsPrimaryPN,
+			Description: si.Description,
+		})
+	}
+	if err := repo.SaveBookItems(localItems); err != nil {
+		return 0, fmt.Errorf("saving items to local db: %w", err)
+	}
+	return len(localItems), nil
+}