Refine stock import UX with suggestions, ignore rules, and inline mapping controls

.githooks/pre-commit

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

.gitignore

@@ -1,16 +1,5 @@
 # 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
@@ -23,7 +12,6 @@ secrets.yml
 /importer
 /cron
 /bin/
-qfs
 
 # Local Go build cache used in sandboxed runs
 .gocache/
@@ -75,7 +63,4 @@ Network Trash Folder
 Temporary Items
 .apdisk
 
-# Release artifacts (binaries, archives, checksums), but DO track releases/memory/ for changelog
-releases/*
-!releases/memory/
-!releases/memory/**
+releases/

CLAUDE.md

@@ -1,24 +1,163 @@
 # QuoteForge - Claude Code Instructions
 
-## Bible
+## Overview
+Корпоративный конфигуратор серверов и формирование КП. MariaDB (RFQ_LOG) + SQLite для оффлайн.
 
-The **[bible/](bible/README.md)** is the single source of truth for this project's architecture, schemas, patterns, and rules. Read it before making any changes.
+## Development Phases
 
-**Rules:**
-- Every architectural decision must be recorded in `bible/` in the same commit as the code.
-- Bible files are written and updated in **English only**.
-- Before working on the codebase, check `releases/memory/` for the latest release notes.
+### Phase 1: Pricelists in MariaDB ✅ DONE
+### Phase 2: Local SQLite Database ✅ DONE
 
-## Quick Reference
+### 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
-# Verify build
-go build ./cmd/qfs && go vet ./...
+# Development
+go run ./cmd/qfs                # Dev server
+make run                        # Dev server (via Makefile)
 
-# Run
-go run ./cmd/qfs
-make run
+# 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
 
-# Build
-make build-release
+# Cron jobs
+go run ./cmd/cron -job=cleanup-pricelists  # Remove old unused pricelists
+go run ./cmd/cron -job=update-prices       # Recalculate all prices
+go run ./cmd/cron -job=update-popularity   # Update popularity scores
+
+# Check version
+./bin/qfs -version
 ```
+
+## Code Style
+- 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

@@ -0,0 +1,178 @@
+# 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

@@ -0,0 +1,121 @@
+# Миграция: Функционал пересчета цен в конфигураторе
+
+## Описание изменений
+
+Добавлен функционал автоматического обновления цен компонентов в сохраненных конфигурациях.
+
+### Новые возможности
+
+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 install-hooks
+.PHONY: build build-release clean test run version
 
 # Get version from git
 VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
@@ -72,12 +72,6 @@ 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"
@@ -98,7 +92,6 @@ 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,66 +1,414 @@
 # QuoteForge
 
-**Корпоративный конфигуратор серверов и расчёт КП**
+**Server Configuration & Quotation Tool**
 
-Offline-first архитектура: пользовательские операции через локальную SQLite, MariaDB только для синхронизации.
+QuoteForge — корпоративный инструмент для конфигурирования серверов и формирования коммерческих предложений (КП). Приложение интегрируется с существующей базой данных RFQ_LOG.
 
 ![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)**:
+### Для ценовых администраторов
+- 📈 **Умный расчёт цен** — медиана, взвешенная медиана, среднее
+- 🎯 **Система алертов** — уведомления о популярных компонентах с устаревшими ценами
+- 📉 **Аналитика использования** — какие компоненты востребованы в КП
+- ⚙️ **Гибкие настройки** — периоды расчёта, методы, ручные переопределения
 
-| Файл | Тема |
-|------|------|
-| [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 |
+### Индикация актуальности цен
+| Цвет | Статус | Условие |
+|------|--------|---------|
+| 🟢 Зелёный | Свежая | < 30 дней, ≥ 3 источника |
+| 🟡 Жёлтый | Нормальная | 30-60 дней |
+| 🟠 Оранжевый | Устаревающая | 60-90 дней |
+| 🔴 Красный | Устаревшая | > 90 дней или нет данных |
 
----
+## Технологии
 
-## Быстрый старт
+- **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
-
-# Запустить
-go run ./cmd/qfs
-# или
-make run
 ```
 
-Приложение: http://localhost:8080 → откроется `/setup` для настройки подключения к MariaDB.
+### Мигратор OPS -> проекты (preview/apply)
+
+Переносит квоты, чьи названия начинаются с `OPS-xxxx` (где `x` — цифра), в проект `OPS-xxxx`.
+Если проекта нет, он будет создан; если архивный — реактивирован.
+
+Сначала всегда смотрите preview:
 
 ```bash
-# Сборка
-make build-release
-
-# Проверка
-go build ./cmd/qfs && go vet ./...
+go run ./cmd/migrate_ops_projects -config config.yaml
 ```
 
----
+Применение изменений:
 
-## Releases & Changelog
+```bash
+go run ./cmd/migrate_ops_projects -config config.yaml -apply
+```
 
-Changelog между версиями: `releases/memory/v{major}.{minor}.{patch}.md`
+Без интерактивного подтверждения:
 
----
+```bash
+go run ./cmd/migrate_ops_projects -config config.yaml -apply -yes
+```
+
+### Минимальные права БД для пользователя квотаций
+
+Если нужен пользователь, который может работать с конфигурациями, но не может создавать/удалять прайслисты:
+
+```sql
+-- 1) Создать пользователя (если его ещё нет)
+CREATE USER IF NOT EXISTS 'quote_user'@'%' IDENTIFIED BY 'StrongPassword!';
+
+-- 2) Если пользователь уже существовал, принудительно обновить пароль
+ALTER USER 'quote_user'@'%' IDENTIFIED BY 'StrongPassword!';
+
+-- 3) (Опционально, но рекомендуется) удалить дубли пользователя с другими host,
+-- чтобы не возникало конфликтов вида user@localhost vs user@'%'
+DROP USER IF EXISTS 'quote_user'@'localhost';
+DROP USER IF EXISTS 'quote_user'@'127.0.0.1';
+DROP USER IF EXISTS 'quote_user'@'::1';
+
+-- 4) Сбросить лишние права
+REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'quote_user'@'%';
+
+-- 5) Чтение данных для конфигуратора и синка
+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'@'%';
+
+-- 6) Работа с конфигурациями
+GRANT SELECT, INSERT, UPDATE ON RFQ_LOG.qt_configurations TO 'quote_user'@'%';
+
+FLUSH PRIVILEGES;
+
+SHOW GRANTS FOR 'quote_user'@'%';
+SHOW CREATE USER 'quote_user'@'%';
+```
+
+Полный набор прав для пользователя квотаций:
+
+```sql
+GRANT USAGE ON *.* TO 'quote_user'@'%' IDENTIFIED BY 'StrongPassword!';
+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, INSERT, UPDATE ON RFQ_LOG.qt_configurations TO 'quote_user'@'%';
+```
+
+Важно:
+- не выдавайте `INSERT/UPDATE/DELETE` на `qt_pricelists` и `qt_pricelist_items`, если пользователь не должен управлять прайслистами;
+- если видите ошибку `Access denied for user ...@'<ip>'`, проверьте, что не осталось других записей `quote_user@host` кроме `quote_user@'%'`;
+- после смены DB-настроек через `/setup` приложение перезапускается автоматически и подхватывает нового пользователя.
+
+### 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
+```
+
+**Makefile команды:**
+```bash
+make build-release   # Оптимизированная сборка с версией
+make build-all       # Сборка для всех платформ (Linux, macOS, Windows)
+make build-windows   # Только для Windows
+make run             # Запуск dev сервера
+make test            # Запуск тестов
+make clean           # Очистка bin/
+make help            # Показать все команды
+```
+
+Приложение будет доступно по адресу: http://localhost:8080
+
+### Локальная SQLite база (state)
+
+Локальная база приложения хранится в профиле пользователя и не зависит от расположения бинарника.
+Имя файла: `qfs.db`.
+
+- macOS: `~/Library/Application Support/QuoteForge/qfs.db`
+- Linux: `$XDG_STATE_HOME/quoteforge/qfs.db` (или `~/.local/state/quoteforge/qfs.db`)
+- Windows: `%LOCALAPPDATA%\\QuoteForge\\qfs.db`
+
+Можно переопределить путь через `-localdb` или переменную окружения `QFS_DB_PATH`.
+
+### Версионность конфигураций (local-first)
+
+Для `local_configurations` используется append-only versioning через полные snapshot-версии:
+
+- таблица: `local_configuration_versions`
+- для каждого изменения создаётся новая версия (`version_no = max + 1`)
+- `local_configurations.current_version_id` указывает на активную версию
+- старые версии не изменяются и не удаляются в обычном потоке
+- rollback не "перематывает" историю, а создаёт новую версию из выбранного snapshot
+
+При backfill (миграция `006_add_local_configuration_versions.sql`) для существующих конфигураций создаётся `v1` и проставляется `current_version_id`.
+
+#### Rollback
+
+Rollback выполняется API-методом:
+
+```bash
+POST /api/configs/:uuid/rollback
+{
+  "target_version": 3,
+  "note": "optional"
+}
+```
+
+Результат:
+- создаётся новая версия `vN` с `data` из целевой версии
+- `change_note = "rollback to v{target_version}"` (+ note, если передан)
+- `current_version_id` переключается на новую версию
+- конфигурация уходит в `sync_status = pending`
+
+### Локальный config.yaml
+
+По умолчанию `qfs` ищет `config.yaml` в той же user-state папке, где лежит `qfs.db` (а не рядом с бинарником).
+Можно переопределить путь через `-config` или `QFS_CONFIG_PATH`.
+
+## Docker
+
+```bash
+# Сборка образа
+docker build -t quoteforge .
+
+# Запуск с docker-compose
+docker-compose up -d
+```
+
+## Структура проекта
+
+```
+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
+```
+
+## Роли пользователей
+
+| Роль | Описание |
+|------|----------|
+| `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             # Сохранённые конфигурации
+GET  /api/configs/:uuid/versions            # Список версий конфигурации
+GET  /api/configs/:uuid/versions/:version   # Получить конкретную версию
+POST /api/configs/:uuid/rollback            # Rollback на указанную версию
+POST /api/configs/:uuid/reactivate          # Вернуть архивную конфигурацию в активные
+```
+
+#### Sync payload для versioning
+
+События в `pending_changes` для конфигураций содержат:
+- `configuration_uuid`
+- `operation` (`create` / `update` / `rollback`)
+- `current_version_id` и `current_version_no`
+- `snapshot` (текущее состояние конфигурации)
+- `idempotency_key` и `conflict_policy` (`last_write_wins`)
+
+Это позволяет push-слою отправлять на сервер актуальное состояние и готовит основу для будущего conflict resolution.
+
+## Cron Jobs
+
+QuoteForge now includes automated cron jobs for maintenance tasks. These can be run using the built-in cron functionality in the Docker container.
+
+### 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 |
+| `QFS_DB_PATH` | Полный путь к локальной SQLite БД | OS-specific user state dir |
+| `QFS_STATE_DIR` | Каталог state (если `QFS_DB_PATH` не задан) | OS-specific user state dir |
+| `QFS_CONFIG_PATH` | Полный путь к `config.yaml` | OS-specific user state dir |
+
+## Интеграция с существующей БД
+
+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) для подробностей.

bible/01-overview.md

@@ -1,119 +0,0 @@
-# 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/02-architecture.md

@@ -1,205 +0,0 @@
-# 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: every save creates an immutable snapshot 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` on every save
-- Old versions are never modified or deleted in normal flow
-- Rollback does **not** rewind history — it creates a **new** version from the 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
-```
-
----
-
-## 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/03-database.md

@@ -1,181 +0,0 @@
-# 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` |
-
-#### Configurations and Projects
-
-| Table | Purpose | Key Fields |
-|-------|---------|------------|
-| `local_configurations` | Saved configurations | `id`, `uuid` (unique), `items` (JSON), `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)
-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 | SELECT, INSERT, UPDATE |
-| `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 |
-
-### 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>'@'%';
-
-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'@'%';
-
-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)
-
-- Stored in `migrations/` (SQL files)
-- Applied via `-migrate` flag or automatically on first run
-- Idempotent: checked by `id` in `local_schema_migrations`
-- Already-applied migrations are skipped
-
-```bash
-go run ./cmd/qfs -migrate
-```
-
-### Centralized Migrations (server-side)
-
-- Stored in `qt_client_local_migrations` (MariaDB)
-- Applied automatically during sync readiness check
-- `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/04-api.md

@@ -1,127 +0,0 @@
-# 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 |
-
-### 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 |
-
-### 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 |
-
-**If sync is blocked by the readiness guard:** all POST sync methods return `423 Locked` with `reason_code` and `reason_text`.
-
-### 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 |
-| `/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/05-config.md

@@ -1,129 +0,0 @@
-# 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/06-backup.md

@@ -1,221 +0,0 @@
-# 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/07-dev.md

@@ -1,136 +0,0 @@
-# 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)
-- **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/README.md

@@ -1,55 +0,0 @@
-# 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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,160 @@
+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

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/appstate"
+	"git.mchus.pro/mchus/quoteforge/internal/config"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"gorm.io/driver/mysql"
@@ -15,6 +16,7 @@ import (
 )
 
 func main() {
+	configPath := flag.String("config", "config.yaml", "path to config file")
 	defaultLocalDBPath, err := appstate.ResolveDBPath("")
 	if err != nil {
 		log.Fatalf("Failed to resolve default local SQLite path: %v", err)
@@ -26,6 +28,22 @@ func main() {
 	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)
@@ -33,28 +51,6 @@ 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
@@ -153,7 +149,23 @@ func main() {
 	log.Printf("  Skipped:  %d", skipped)
 	log.Printf("  Errors:   %d", errors)
 
-	fmt.Println("\nDone! You can now run the server with: go run ./cmd/qfs")
+	// 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")
 }
 
 func derefUint(v *uint) uint {

cmd/migrate_ops_projects/main.go

@@ -10,8 +10,7 @@ import (
 	"sort"
 	"strings"
 
-	"git.mchus.pro/mchus/quoteforge/internal/appstate"
-	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/config"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"github.com/google/uuid"
 	"gorm.io/driver/mysql"
@@ -39,29 +38,17 @@ type migrationAction struct {
 }
 
 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)")
+	configPath := flag.String("config", "config.yaml", "path to config file")
 	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)
+	cfg, err := config.Load(*configPath)
 	if err != nil {
-		log.Fatalf("failed to initialize local database: %v", err)
+		log.Fatalf("failed to load config: %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{
+	db, err := gorm.Open(mysql.Open(cfg.Database.DSN()), &gorm.Config{
 		Logger: logger.Default.LogMode(logger.Silent),
 	})
 	if err != nil {
@@ -72,7 +59,7 @@ func main() {
 		log.Fatalf("precheck failed: %v", err)
 	}
 
-	actions, existingProjects, err := buildPlan(db, dbUser)
+	actions, existingProjects, err := buildPlan(db, cfg.Database.User)
 	if err != nil {
 		log.Fatalf("failed to build migration plan: %v", err)
 	}
@@ -163,7 +150,7 @@ func buildPlan(db *gorm.DB, fallbackOwner string) ([]migrationAction, map[string
 		}
 		for i := range projects {
 			p := projects[i]
-			existingProjects[projectKey(p.OwnerUsername, derefString(p.Name))] = &p
+			existingProjects[projectKey(p.OwnerUsername, p.Name)] = &p
 		}
 	}
 
@@ -253,13 +240,12 @@ func executePlan(db *gorm.DB, actions []migrationAction, existingProjects map[st
 
 		for _, action := range actions {
 			key := projectKey(action.OwnerUsername, action.TargetProjectName)
-		project := projectCache[key]
+			project := projectCache[key]
 			if project == nil {
 				project = &models.Project{
 					UUID:          uuid.NewString(),
 					OwnerUsername: action.OwnerUsername,
-					Code:          action.TargetProjectName,
-					Name:          ptrString(action.TargetProjectName),
+					Name:          action.TargetProjectName,
 					IsActive:      true,
 					IsSystem:      false,
 				}
@@ -269,7 +255,7 @@ func executePlan(db *gorm.DB, actions []migrationAction, existingProjects map[st
 				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)
+					return fmt.Errorf("reactivate project %s (%s): %w", project.Name, project.UUID, err)
 				}
 				project.IsActive = true
 			}
@@ -295,14 +281,3 @@ func setKeys(set map[string]struct{}) []string {
 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

@@ -1,66 +0,0 @@
-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

@@ -149,7 +149,7 @@ func TestProjectArchiveHidesConfigsAndCloneIntoProject(t *testing.T) {
 		t.Fatalf("setup router: %v", err)
 	}
 
-	createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"P1","code":"P1"}`)))
+	createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"P1"}`)))
 	createProjectReq.Header.Set("Content-Type", "application/json")
 	createProjectRec := httptest.NewRecorder()
 	router.ServeHTTP(createProjectRec, createProjectReq)
@@ -243,7 +243,7 @@ func TestConfigMoveToProjectEndpoint(t *testing.T) {
 		t.Fatalf("setup router: %v", err)
 	}
 
-	createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"Move Project","code":"MOVE"}`)))
+	createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"Move Project"}`)))
 	createProjectReq.Header.Set("Content-Type", "application/json")
 	createProjectRec := httptest.NewRecorder()
 	router.ServeHTTP(createProjectRec, createProjectReq)

config.example.yaml

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

crontab

@@ -0,0 +1,15 @@
+# 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/appstate/backup.go

@@ -1,273 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -6,7 +6,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"strings"
 )
 
 const (
@@ -56,25 +55,6 @@ func ResolveConfigPath(explicitPath string) (string, error) {
 	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.

internal/article/categories.go

@@ -1,124 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,602 +0,0 @@
-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
-		}
-		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", "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

@@ -1,66 +0,0 @@
-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

@@ -20,7 +20,6 @@ type Config struct {
 	Alerts        AlertsConfig        `yaml:"alerts"`
 	Notifications NotificationsConfig `yaml:"notifications"`
 	Logging       LoggingConfig       `yaml:"logging"`
-	Backup        BackupConfig        `yaml:"backup"`
 }
 
 type ServerConfig struct {
@@ -102,10 +101,6 @@ 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 {
@@ -187,10 +182,6 @@ 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/handlers/component.go

@@ -3,10 +3,8 @@ 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"
@@ -27,12 +25,6 @@ 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"),
@@ -41,68 +33,73 @@ func (h *ComponentHandler) List(c *gin.Context) {
 		ExcludeHidden: c.Query("include_hidden") != "true", // По умолчанию скрытые не показываются
 	}
 
-	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)
+	result, err := h.componentService.List(filter, page, perPage)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		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,
+	// If offline mode (empty result), fallback to local components
+	isOffline := false
+	if v, ok := c.Get("is_offline"); ok {
+		if b, ok := v.(bool); ok {
+			isOffline = b
+		}
+	}
+	if isOffline && result.Total == 0 && h.localDB != nil {
+		localFilter := localdb.ComponentFilter{
+			Category: filter.Category,
+			Search:   filter.Search,
+			HasPrice: filter.HasPrice,
+		}
+
+		offset := (page - 1) * perPage
+		localComps, total, err := h.localDB.ListComponents(localFilter, offset, perPage)
+		if err == nil && len(localComps) > 0 {
+			// Convert local components to ComponentView format
+			components := make([]services.ComponentView, len(localComps))
+			for i, lc := range localComps {
+				components[i] = services.ComponentView{
+					LotName:      lc.LotName,
+					Description:  lc.LotDescription,
+					Category:     lc.Category,
+					CategoryName: lc.Category, // No translation in local mode
+					Model:        lc.Model,
+					CurrentPrice: lc.CurrentPrice,
+				}
+			}
+
+			c.JSON(http.StatusOK, &services.ComponentListResult{
+				Components: components,
+				Total:      total,
+				Page:       page,
+				PerPage:    perPage,
+			})
+			return
 		}
 	}
 
-	c.JSON(http.StatusOK, &services.ComponentListResult{
-		Components: components,
-		Total:      total,
-		Page:       page,
-		PerPage:    perPage,
-	})
+	c.JSON(http.StatusOK, result)
 }
 
 func (h *ComponentHandler) Get(c *gin.Context) {
 	lotName := c.Param("lot_name")
-	component, err := h.localDB.GetLocalComponent(lotName)
+
+	component, err := h.componentService.GetByLotName(lotName)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "component not found"})
 		return
 	}
 
-	c.JSON(http.StatusOK, services.ComponentView{
-		LotName:      component.LotName,
-		Description:  component.LotDescription,
-		Category:     component.Category,
-		CategoryName: component.Category,
-		Model:        component.Model,
-	})
+	c.JSON(http.StatusOK, component)
 }
 
 func (h *ComponentHandler) GetCategories(c *gin.Context) {
-	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)
+	categories, err := h.componentService.GetCategories()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 
-	c.JSON(http.StatusOK, models.DefaultCategories)
+	c.JSON(http.StatusOK, categories)
 }

internal/handlers/export.go

@@ -3,41 +3,34 @@ package handlers
 import (
 	"fmt"
 	"net/http"
-	"strings"
 	"time"
 
 	"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
-	projectService *services.ProjectService
+	exportService    *services.ExportService
+	configService    services.ConfigurationGetter
+	componentService *services.ComponentService
 }
 
 func NewExportHandler(
 	exportService *services.ExportService,
 	configService services.ConfigurationGetter,
-	projectService *services.ProjectService,
+	componentService *services.ComponentService,
 ) *ExportHandler {
 	return &ExportHandler{
-		exportService:  exportService,
-		configService:  configService,
-		projectService: projectService,
+		exportService:    exportService,
+		configService:    configService,
+		componentService: componentService,
 	}
 }
 
 type ExportRequest 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 {
+	Name  string `json:"name" binding:"required"`
+	Items []struct {
 		LotName   string  `json:"lot_name" binding:"required"`
 		Quantity  int     `json:"quantity" binding:"required,min=1"`
 		UnitPrice float64 `json:"unit_price"`
@@ -54,162 +47,75 @@ func (h *ExportHandler) ExportCSV(c *gin.Context) {
 
 	data := h.buildExportData(&req)
 
-	// 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"})
+	csvData, err := h.exportService.ToCSV(data)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 
-	// 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")
+	filename := fmt.Sprintf("%s %s SPEC.csv", time.Now().Format("2006-01-02"), req.Name)
 	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
-	}
+	c.Data(http.StatusOK, "text/csv; charset=utf-8", csvData)
 }
 
-// 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))
+func (h *ExportHandler) buildExportData(req *ExportRequest) *services.ExportData {
+	items := make([]services.ExportItem, len(req.Items))
+	var total float64
+
 	for i, item := range req.Items {
-		configItems[i] = models.ConfigItem{
-			LotName:   item.LotName,
-			Quantity:  item.Quantity,
-			UnitPrice: item.UnitPrice,
+		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,
+			}
 		}
+		total += itemTotal
 	}
 
-	serverCount := req.ServerCount
-	if serverCount < 1 {
-		serverCount = 1
+	return &services.ExportData{
+		Name:      req.Name,
+		Items:     items,
+		Total:     total,
+		Notes:     req.Notes,
+		CreatedAt: time.Now(),
 	}
-
-	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) {
 	username := middleware.GetUsername(c)
 	uuid := c.Param("uuid")
 
-	// 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)
+	data := h.exportService.ConfigToExportData(config, h.componentService)
 
-	// 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")
+	csvData, err := h.exportService.ToCSV(data)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 
-	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")
+	filename := fmt.Sprintf("%s %s SPEC.csv", config.CreatedAt.Format("2006-01-02"), config.Name)
 	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
-
-	if err := h.exportService.ToCSV(c.Writer, data); err != nil {
-		c.Error(err)
-		return
-	}
+	c.Data(http.StatusOK, "text/csv; charset=utf-8", csvData)
 }

internal/handlers/export_test.go

@@ -1,305 +0,0 @@
-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/pricelist.go

@@ -1,120 +1,99 @@
 package handlers
 
 import (
+	"errors"
+	"fmt"
+	"io"
 	"net/http"
-	"sort"
 	"strconv"
-	"strings"
 
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricelist"
 	"github.com/gin-gonic/gin"
 )
 
 type PricelistHandler struct {
+	service *pricelist.Service
 	localDB *localdb.LocalDB
 }
 
-func NewPricelistHandler(localDB *localdb.LocalDB) *PricelistHandler {
-	return &PricelistHandler{localDB: localDB}
+func NewPricelistHandler(service *pricelist.Service, localDB *localdb.LocalDB) *PricelistHandler {
+	return &PricelistHandler{service: service, 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"
+	source := c.Query("source")
 
-	localPLs, err := h.localDB.GetLocalPricelists()
+	var (
+		pricelists any
+		total      int64
+		err        error
+	)
+
+	if activeOnly {
+		pricelists, total, err = h.service.ListActiveBySource(page, perPage, source)
+	} else {
+		pricelists, total, err = h.service.ListBySource(page, perPage, source)
+	}
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
-	if source != "" {
-		filtered := localPLs[:0]
-		for _, lpl := range localPLs {
-			if strings.EqualFold(lpl.Source, source) {
-				filtered = append(filtered, lpl)
+
+	// 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 {
+			if source != "" {
+				filtered := localPLs[:0]
+				for _, lpl := range localPLs {
+					if lpl.Source == source {
+						filtered = append(filtered, lpl)
+					}
+				}
+				localPLs = filtered
 			}
-		}
-		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
+			// Convert to PricelistSummary format
+			summaries := make([]map[string]interface{}, len(localPLs))
+			for i, lpl := range localPLs {
+				summaries[i] = map[string]interface{}{
+					"id":          lpl.ServerID,
+					"source":      lpl.Source,
+					"version":     lpl.Version,
+					"created_by":  "sync",
+					"item_count":  0, // Not tracked
+					"usage_count": 0, // Not tracked in local
+					"is_active":   true,
+					"created_at":  lpl.CreatedAt,
+					"synced_from": "local",
+				}
 			}
+
+			c.JSON(http.StatusOK, gin.H{
+				"pricelists": summaries,
+				"total":      len(summaries),
+				"page":       page,
+				"per_page":   perPage,
+				"offline":    true,
+			})
+			return
 		}
-		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": summaries,
+		"pricelists": pricelists,
 		"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)
@@ -123,25 +102,210 @@ func (h *PricelistHandler) Get(c *gin.Context) {
 		return
 	}
 
-	localPL, err := h.localDB.GetLocalPricelistByServerID(uint(id))
+	pl, err := h.service.GetByID(uint(id))
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "pricelist not found"})
 		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",
+	c.JSON(http.StatusOK, pl)
+}
+
+// Create creates a new pricelist from current prices
+func (h *PricelistHandler) Create(c *gin.Context) {
+	canWrite, debugInfo := h.service.CanWriteDebug()
+	if !canWrite {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "pricelist write is not allowed",
+			"debug": debugInfo,
+		})
+		return
+	}
+
+	var req struct {
+		Source string `json:"source"`
+		Items  []struct {
+			LotName string  `json:"lot_name"`
+			Price   float64 `json:"price"`
+		} `json:"items"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	source := string(models.NormalizePricelistSource(req.Source))
+
+	// Get the database username as the creator
+	createdBy := h.localDB.GetDBUser()
+	if createdBy == "" {
+		createdBy = "unknown"
+	}
+	sourceItems := make([]pricelist.CreateItemInput, 0, len(req.Items))
+	for _, item := range req.Items {
+		sourceItems = append(sourceItems, pricelist.CreateItemInput{
+			LotName: item.LotName,
+			Price:   item.Price,
+		})
+	}
+
+	pl, err := h.service.CreateForSourceWithProgress(createdBy, source, sourceItems, nil)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusCreated, pl)
+}
+
+// CreateWithProgress creates a pricelist and streams progress updates over SSE.
+func (h *PricelistHandler) CreateWithProgress(c *gin.Context) {
+	canWrite, debugInfo := h.service.CanWriteDebug()
+	if !canWrite {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "pricelist write is not allowed",
+			"debug": debugInfo,
+		})
+		return
+	}
+
+	var req struct {
+		Source string `json:"source"`
+		Items  []struct {
+			LotName string  `json:"lot_name"`
+			Price   float64 `json:"price"`
+		} `json:"items"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	source := string(models.NormalizePricelistSource(req.Source))
+
+	createdBy := h.localDB.GetDBUser()
+	if createdBy == "" {
+		createdBy = "unknown"
+	}
+	sourceItems := make([]pricelist.CreateItemInput, 0, len(req.Items))
+	for _, item := range req.Items {
+		sourceItems = append(sourceItems, pricelist.CreateItemInput{
+			LotName: item.LotName,
+			Price:   item.Price,
+		})
+	}
+
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+	c.Header("X-Accel-Buffering", "no")
+
+	flusher, ok := c.Writer.(http.Flusher)
+	if !ok {
+		pl, err := h.service.CreateForSourceWithProgress(createdBy, source, sourceItems, nil)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusCreated, pl)
+		return
+	}
+
+	sendProgress := func(payload gin.H) {
+		c.SSEvent("progress", payload)
+		flusher.Flush()
+	}
+
+	sendProgress(gin.H{"current": 0, "total": 4, "status": "starting", "message": "Запуск..."})
+	pl, err := h.service.CreateForSourceWithProgress(createdBy, source, sourceItems, func(p pricelist.CreateProgress) {
+		sendProgress(gin.H{
+			"current":  p.Current,
+			"total":    p.Total,
+			"status":   p.Status,
+			"message":  p.Message,
+			"updated":  p.Updated,
+			"errors":   p.Errors,
+			"lot_name": p.LotName,
+		})
+	})
+	if err != nil {
+		sendProgress(gin.H{
+			"current": 0,
+			"total":   4,
+			"status":  "error",
+			"message": fmt.Sprintf("Ошибка: %v", err),
+		})
+		return
+	}
+
+	sendProgress(gin.H{
+		"current":   4,
+		"total":     4,
+		"status":    "completed",
+		"message":   "Готово",
+		"pricelist": pl,
 	})
 }
 
-// GetItems returns items for a pricelist with pagination.
+// Delete deletes a pricelist by ID
+func (h *PricelistHandler) Delete(c *gin.Context) {
+	canWrite, debugInfo := h.service.CanWriteDebug()
+	if !canWrite {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "pricelist write is not allowed",
+			"debug": debugInfo,
+		})
+		return
+	}
+
+	idStr := c.Param("id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		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"})
+}
+
+// SetActive toggles active flag on a pricelist.
+func (h *PricelistHandler) SetActive(c *gin.Context) {
+	canWrite, debugInfo := h.service.CanWriteDebug()
+	if !canWrite {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "pricelist write is not allowed",
+			"debug": debugInfo,
+		})
+		return
+	}
+
+	idStr := c.Param("id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
+		return
+	}
+
+	var req struct {
+		IsActive bool `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if err := h.service.SetActive(uint(id), req.IsActive); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "updated", "is_active": req.IsActive})
+}
+
+// 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)
@@ -154,102 +318,67 @@ func (h *PricelistHandler) GetItems(c *gin.Context) {
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "50"))
 	search := c.Query("search")
 
-	localPL, err := h.localDB.GetLocalPricelistByServerID(uint(id))
+	items, total, err := h.service.GetItems(uint(id), page, perPage, search)
 	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),
-		})
+	pl, _ := h.service.GetByID(uint(id))
+	source := ""
+	if pl != nil {
+		source = pl.Source
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"source":   localPL.Source,
-		"items":    resultItems,
+		"source":   source,
+		"items":    items,
 		"total":    total,
 		"page":     page,
 		"per_page": perPage,
 	})
 }
 
-func (h *PricelistHandler) GetLotNames(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
-	}
-
-	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),
-	})
+// 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.
+// 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)
+	// Try to get from server first
+	pl, err := h.service.GetLatestActiveBySource(source)
 	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "no pricelists available"})
+		// 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.GetLatestLocalPricelistBySource(source)
+		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,
+			"source":      localPL.Source,
+			"version":     localPL.Version,
+			"created_by":  "sync",
+			"item_count":  0, // Not tracked in local pricelists
+			"is_active":   true,
+			"created_at":  localPL.CreatedAt,
+			"synced_from": "local",
+		})
 		return
 	}
-	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",
-	})
+
+	c.JSON(http.StatusOK, pl)
 }

internal/handlers/pricelist_test.go

@@ -1,161 +0,0 @@
-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/setup.go

@@ -6,6 +6,8 @@ import (
 	"log/slog"
 	"net"
 	"net/http"
+	"os"
+	"path/filepath"
 	"strconv"
 	"time"
 
@@ -26,7 +28,7 @@ type SetupHandler struct {
 	restartSig chan struct{}
 }
 
-func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, _ string, restartSig chan struct{}) (*SetupHandler, error) {
+func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, templatesPath string, restartSig chan struct{}) (*SetupHandler, error) {
 	funcMap := template.FuncMap{
 		"sub": func(a, b int) int { return a - b },
 		"add": func(a, b int) int { return a + b },
@@ -35,9 +37,14 @@ func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, _
 	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
-	tmpl, err = template.New("").Funcs(funcMap).ParseFS(qfassets.TemplatesFS, "web/templates/setup.html")
+	if stat, statErr := os.Stat(templatesPath); statErr == nil && stat.IsDir() {
+		tmpl, err = template.New("").Funcs(funcMap).ParseFiles(setupPath)
+	} else {
+		tmpl, err = template.New("").Funcs(funcMap).ParseFS(qfassets.TemplatesFS, "web/templates/setup.html")
+	}
 	if err != nil {
 		return nil, fmt.Errorf("parsing setup template: %w", err)
 	}

internal/handlers/sync.go

@@ -1,12 +1,11 @@
 package handlers
 
 import (
-	"errors"
-	"fmt"
 	"html/template"
 	"log/slog"
 	"net/http"
-	stdsync "sync"
+	"os"
+	"path/filepath"
 	"time"
 
 	qfassets "git.mchus.pro/mchus/quoteforge"
@@ -24,15 +23,19 @@ type SyncHandler struct {
 	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, _ string, autoSyncInterval time.Duration) (*SyncHandler, error) {
+func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, templatesPath string, autoSyncInterval time.Duration) (*SyncHandler, error) {
 	// Load sync_status partial template
-	tmpl, err := template.ParseFS(qfassets.TemplatesFS, "web/templates/partials/sync_status.html")
+	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")
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -49,24 +52,14 @@ func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr
 
 // 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"`
-	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"`
+	LastComponentSync *time.Time `json:"last_component_sync"`
+	LastPricelistSync *time.Time `json:"last_pricelist_sync"`
+	IsOnline          bool       `json:"is_online"`
+	ComponentsCount   int64      `json:"components_count"`
+	PricelistsCount   int64      `json:"pricelists_count"`
+	ServerPricelists  int        `json:"server_pricelists"`
+	NeedComponentSync bool       `json:"need_component_sync"`
+	NeedPricelistSync bool       `json:"need_pricelist_sync"`
 }
 
 // GetStatus returns current sync status
@@ -96,7 +89,6 @@ 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,
@@ -107,63 +99,9 @@ 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"`
@@ -175,7 +113,11 @@ type SyncResultResponse struct {
 // SyncComponents syncs components from MariaDB to local SQLite
 // POST /api/sync/components
 func (h *SyncHandler) SyncComponents(c *gin.Context) {
-	if !h.ensureSyncReadiness(c) {
+	if !h.checkOnline() {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database is offline",
+		})
 		return
 	}
 
@@ -210,7 +152,11 @@ 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.ensureSyncReadiness(c) {
+	if !h.checkOnline() {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database is offline",
+		})
 		return
 	}
 
@@ -255,7 +201,11 @@ type SyncAllResponse struct {
 // - pull components, pricelists, projects, and configurations from server
 // POST /api/sync/all
 func (h *SyncHandler) SyncAll(c *gin.Context) {
-	if !h.ensureSyncReadiness(c) {
+	if !h.checkOnline() {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database is offline",
+		})
 		return
 	}
 
@@ -361,7 +311,11 @@ 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.ensureSyncReadiness(c) {
+	if !h.checkOnline() {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database is offline",
+		})
 		return
 	}
 
@@ -410,52 +364,12 @@ func (h *SyncHandler) GetPendingChanges(c *gin.Context) {
 	})
 }
 
-// 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
+// SyncInfoResponse represents sync information
 type SyncInfoResponse struct {
-	// 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
+	LastSyncAt *time.Time  `json:"last_sync_at"`
+	IsOnline   bool        `json:"is_online"`
 	ErrorCount int         `json:"error_count"`
 	Errors     []SyncError `json:"errors,omitempty"`
-
-	// Readiness guard
-	Readiness *sync.SyncReadiness `json:"readiness,omitempty"`
 }
 
 type SyncUsersStatusResponse struct {
@@ -478,44 +392,31 @@ 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 pending changes
+	// Get recent errors (last 10)
 	changes, err := h.localDB.GetPendingChanges()
 	if err != nil {
 		slog.Error("failed to get pending changes for sync info", "error", err)
-		changes = []localdb.PendingChange{}
+		// Even if we can't get changes, we can still return the error count
+		c.JSON(http.StatusOK, SyncInfoResponse{
+			LastSyncAt: lastPricelistSync,
+			IsOnline:   isOnline,
+			ErrorCount: errorCount,
+			Errors:     []SyncError{}, // Return empty errors list
+		})
+		return
 	}
 
-	var syncErrors []SyncError
+	var errors []SyncError
 	for _, change := range changes {
+		// Check if there's a last error and it's not empty
 		if change.LastError != "" {
-			syncErrors = append(syncErrors, SyncError{
+			errors = append(errors, SyncError{
 				Timestamp: change.CreatedAt,
 				Message:   change.LastError,
 			})
@@ -523,26 +424,15 @@ func (h *SyncHandler) GetInfo(c *gin.Context) {
 	}
 
 	// Limit to last 10 errors
-	if len(syncErrors) > 10 {
-		syncErrors = syncErrors[:10]
+	if len(errors) > 10 {
+		errors = errors[:10]
 	}
 
-	readiness := h.getReadinessCached(10 * time.Second)
-
 	c.JSON(http.StatusOK, SyncInfoResponse{
-		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,
+		LastSyncAt: lastPricelistSync,
+		IsOnline:   isOnline,
+		ErrorCount: errorCount,
+		Errors:     errors,
 	})
 }
 
@@ -599,21 +489,12 @@ 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, "sync_blocked", isBlocked)
+	slog.Debug("rendering sync status", "is_offline", isOffline, "pending_count", pendingCount)
 
 	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")
@@ -622,24 +503,3 @@ 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
-}

internal/handlers/sync_readiness_test.go

@@ -1,64 +0,0 @@
-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/web.go

@@ -2,6 +2,8 @@ package handlers
 
 import (
 	"html/template"
+	"os"
+	"path/filepath"
 	"strconv"
 
 	qfassets "git.mchus.pro/mchus/quoteforge"
@@ -15,7 +17,7 @@ type WebHandler struct {
 	componentService *services.ComponentService
 }
 
-func NewWebHandler(_ string, componentService *services.ComponentService) (*WebHandler, error) {
+func NewWebHandler(templatesPath 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 },
@@ -58,16 +60,27 @@ func NewWebHandler(_ string, componentService *services.ComponentService) (*WebH
 	}
 
 	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", "projects.html", "project_detail.html", "pricelists.html", "pricelist_detail.html", "config_revisions.html"}
+	simplePages := []string{"login.html", "configs.html", "projects.html", "project_detail.html", "admin_pricing.html", "pricelists.html", "pricelist_detail.html"}
 	for _, page := range simplePages {
+		pagePath := filepath.Join(templatesPath, page)
 		var tmpl *template.Template
 		var err error
-		tmpl, err = template.New("").Funcs(funcMap).ParseFS(
-			qfassets.TemplatesFS,
-			"web/templates/base.html",
-			"web/templates/"+page,
-		)
+		if useDisk {
+			tmpl, err = template.New("").Funcs(funcMap).ParseFiles(basePath, pagePath)
+		} else {
+			tmpl, err = template.New("").Funcs(funcMap).ParseFS(
+				qfassets.TemplatesFS,
+				"web/templates/base.html",
+				"web/templates/"+page,
+			)
+		}
 		if err != nil {
 			return nil, err
 		}
@@ -75,14 +88,20 @@ func NewWebHandler(_ string, componentService *services.ComponentService) (*WebH
 	}
 
 	// 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
-	indexTmpl, err = template.New("").Funcs(funcMap).ParseFS(
-		qfassets.TemplatesFS,
-		"web/templates/base.html",
-		"web/templates/index.html",
-		"web/templates/components_list.html",
-	)
+	if useDisk {
+		indexTmpl, err = template.New("").Funcs(funcMap).ParseFiles(basePath, indexPath, componentsListPath)
+	} else {
+		indexTmpl, err = template.New("").Funcs(funcMap).ParseFS(
+			qfassets.TemplatesFS,
+			"web/templates/base.html",
+			"web/templates/index.html",
+			"web/templates/components_list.html",
+		)
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -91,12 +110,17 @@ func NewWebHandler(_ string, componentService *services.ComponentService) (*WebH
 	// 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
-		tmpl, err = template.New("").Funcs(funcMap).ParseFS(
-			qfassets.TemplatesFS,
-			"web/templates/"+partial,
-		)
+		if useDisk {
+			tmpl, err = template.New("").Funcs(funcMap).ParseFiles(partialPath)
+		} else {
+			tmpl, err = template.New("").Funcs(funcMap).ParseFS(
+				qfassets.TemplatesFS,
+				"web/templates/"+partial,
+			)
+		}
 		if err != nil {
 			return nil, err
 		}
@@ -123,8 +147,8 @@ func (h *WebHandler) render(c *gin.Context, name string, data gin.H) {
 }
 
 func (h *WebHandler) Index(c *gin.Context) {
-	// Redirect to projects page - configurator is accessed via /configurator?uuid=...
-	c.Redirect(302, "/projects")
+	// Redirect to configs page - configurator is accessed via /configurator?uuid=...
+	c.Redirect(302, "/configs")
 }
 
 func (h *WebHandler) Configurator(c *gin.Context) {
@@ -173,11 +197,8 @@ func (h *WebHandler) ProjectDetail(c *gin.Context) {
 	})
 }
 
-func (h *WebHandler) ConfigRevisions(c *gin.Context) {
-	h.render(c, "config_revisions.html", gin.H{
-		"ActivePage": "configs",
-		"ConfigUUID": c.Param("uuid"),
-	})
+func (h *WebHandler) AdminPricing(c *gin.Context) {
+	h.render(c, "admin_pricing.html", gin.H{"ActivePage": "admin"})
 }
 
 func (h *WebHandler) Pricelists(c *gin.Context) {

internal/localdb/components.go

@@ -28,13 +28,14 @@ type ComponentSyncResult struct {
 func (l *LocalDB) SyncComponents(mariaDB *gorm.DB) (*ComponentSyncResult, error) {
 	startTime := time.Now()
 
-	// Query to join lot with qt_lot_metadata (metadata only, no pricing)
+	// Query to join lot with qt_lot_metadata
 	// Use LEFT JOIN to include lots without metadata
 	type componentRow struct {
 		LotName        string
 		LotDescription string
 		Category       *string
 		Model          *string
+		CurrentPrice   *float64
 	}
 
 	var rows []componentRow
@@ -43,7 +44,8 @@ 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.model,
+			m.current_price
 		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
@@ -98,6 +100,8 @@ 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)
 
@@ -217,6 +221,11 @@ 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 {
@@ -242,31 +251,6 @@ 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
@@ -327,3 +311,99 @@ 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, load from latest estimate pricelist.
+	var latestPricelist LocalPricelist
+	if err := l.db.Where("source = ?", "estimate").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

@@ -28,11 +28,7 @@ func ConfigurationToLocal(cfg *models.Configuration) *LocalConfiguration {
 		Notes:            cfg.Notes,
 		IsTemplate:       cfg.IsTemplate,
 		ServerCount:      cfg.ServerCount,
-		ServerModel:      cfg.ServerModel,
-		SupportCode:      cfg.SupportCode,
-		Article:          cfg.Article,
 		PricelistID:      cfg.PricelistID,
-		OnlyInStock:      cfg.OnlyInStock,
 		PriceUpdatedAt:   cfg.PriceUpdatedAt,
 		CreatedAt:        cfg.CreatedAt,
 		UpdatedAt:        time.Now(),
@@ -75,11 +71,7 @@ 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,
 		PriceUpdatedAt: local.PriceUpdatedAt,
 		CreatedAt:      local.CreatedAt,
 	}
@@ -91,9 +83,6 @@ func LocalToConfiguration(local *LocalConfiguration) *models.Configuration {
 		userID := local.OriginalUserID
 		cfg.UserID = &userID
 	}
-	if local.CurrentVersion != nil {
-		cfg.CurrentVersionNo = local.CurrentVersion.VersionNo
-	}
 
 	return cfg
 }
@@ -109,8 +98,6 @@ 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,
@@ -130,8 +117,6 @@ 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,
@@ -177,30 +162,20 @@ 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,
-		LotCategory:  item.LotCategory,
-		Price:        item.Price,
-		AvailableQty: item.AvailableQty,
-		Partnumbers:  partnumbers,
+		PricelistID: localPricelistID,
+		LotName:     item.LotName,
+		Price:       item.Price,
 	}
 }
 
 // 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,
-		LotCategory:  local.LotCategory,
-		Price:        local.Price,
-		AvailableQty: local.AvailableQty,
-		Partnumbers:  partnumbers,
+		ID:          local.ID,
+		PricelistID: serverPricelistID,
+		LotName:     local.LotName,
+		Price:       local.Price,
 	}
 }
 
@@ -228,14 +203,17 @@ 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,
+		LotName:      local.LotName,
+		Model:        local.Model,
+		CurrentPrice: local.CurrentPrice,
 		Lot: &models.Lot{
 			LotName:        local.LotName,
 			LotDescription: local.LotDescription,

internal/localdb/converters_test.go

@@ -1,34 +0,0 @@
-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

@@ -4,8 +4,6 @@ import (
 	"path/filepath"
 	"testing"
 	"time"
-
-	"github.com/google/uuid"
 )
 
 func TestRunLocalMigrationsBackfillsExistingConfigurations(t *testing.T) {
@@ -127,129 +125,3 @@ func TestRunLocalMigrationsFixesPricelistVersionUniqueIndex(t *testing.T) {
 		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")
-	}
-}

internal/localdb/localdb.go

@@ -12,7 +12,6 @@ import (
 	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
-	"git.mchus.pro/mchus/quoteforge/internal/appstate"
 	"github.com/glebarez/sqlite"
 	mysqlDriver "github.com/go-sql-driver/mysql"
 	uuidpkg "github.com/google/uuid"
@@ -42,49 +41,6 @@ type LocalDB struct {
 	path string
 }
 
-// ResetData clears local data tables while keeping connection settings.
-// It does not drop schema or connection_settings.
-func ResetData(dbPath string) error {
-	if strings.TrimSpace(dbPath) == "" {
-		return nil
-	}
-	if _, err := os.Stat(dbPath); err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil
-		}
-		return fmt.Errorf("stat local db: %w", err)
-	}
-
-	db, err := gorm.Open(sqlite.Open(dbPath), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
-	})
-	if err != nil {
-		return fmt.Errorf("opening sqlite database: %w", err)
-	}
-
-	// Order does not matter because we use DELETEs without FK constraints in SQLite.
-	tables := []string{
-		"local_projects",
-		"local_configurations",
-		"local_configuration_versions",
-		"local_pricelists",
-		"local_pricelist_items",
-		"local_components",
-		"local_remote_migrations_applied",
-		"local_sync_guard_state",
-		"pending_changes",
-		"app_settings",
-	}
-	for _, table := range tables {
-		if err := db.Exec("DELETE FROM " + table).Error; err != nil {
-			return fmt.Errorf("clear %s: %w", table, err)
-		}
-	}
-
-	slog.Info("local database data reset", "path", dbPath)
-	return nil
-}
-
 // New creates a new LocalDB instance
 func New(dbPath string) (*LocalDB, error) {
 	// Ensure directory exists
@@ -93,14 +49,6 @@ func New(dbPath string) (*LocalDB, error) {
 		return nil, fmt.Errorf("creating data directory: %w", err)
 	}
 
-	if cfgPath, err := appstate.ResolveConfigPathNearDB("", dbPath); err == nil {
-		if _, err := appstate.EnsureRotatingLocalBackup(dbPath, cfgPath); err != nil {
-			return nil, fmt.Errorf("backup local data: %w", err)
-		}
-	} else {
-		return nil, fmt.Errorf("resolve config path: %w", err)
-	}
-
 	db, err := gorm.Open(sqlite.Open(dbPath), &gorm.Config{
 		Logger: logger.Default.LogMode(logger.Silent),
 	})
@@ -108,39 +56,16 @@ func New(dbPath string) (*LocalDB, error) {
 		return nil, fmt.Errorf("opening sqlite database: %w", err)
 	}
 
-	if err := ensureLocalProjectsTable(db); err != nil {
-		return nil, fmt.Errorf("ensure local_projects table: %w", err)
-	}
-
-	// Preflight: ensure local_projects has non-null UUIDs before AutoMigrate rebuilds tables.
-	if db.Migrator().HasTable(&LocalProject{}) {
-		if !db.Migrator().HasColumn(&LocalProject{}, "uuid") {
-			if err := db.Exec(`ALTER TABLE local_projects ADD COLUMN uuid TEXT`).Error; err != nil {
-				return nil, fmt.Errorf("adding local_projects.uuid: %w", err)
-			}
-		}
-		var ids []uint
-		if err := db.Raw(`SELECT id FROM local_projects WHERE uuid IS NULL OR uuid = ''`).Scan(&ids).Error; err != nil {
-			return nil, fmt.Errorf("finding local_projects without uuid: %w", err)
-		}
-		for _, id := range ids {
-			if err := db.Exec(`UPDATE local_projects SET uuid = ? WHERE id = ?`, uuidpkg.New().String(), id).Error; err != nil {
-				return nil, fmt.Errorf("backfilling local_projects.uuid: %w", err)
-			}
-		}
-	}
-
 	// Auto-migrate all local tables
 	if err := db.AutoMigrate(
 		&ConnectionSettings{},
+		&LocalProject{},
 		&LocalConfiguration{},
 		&LocalConfigurationVersion{},
 		&LocalPricelist{},
 		&LocalPricelistItem{},
 		&LocalComponent{},
 		&AppSetting{},
-		&LocalRemoteMigrationApplied{},
-		&LocalSyncGuardState{},
 		&PendingChange{},
 	); err != nil {
 		return nil, fmt.Errorf("migrating sqlite database: %w", err)
@@ -157,38 +82,6 @@ func New(dbPath string) (*LocalDB, error) {
 	}, nil
 }
 
-func ensureLocalProjectsTable(db *gorm.DB) error {
-	if db.Migrator().HasTable(&LocalProject{}) {
-		return nil
-	}
-
-	if err := db.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
-	}
-
-	_ = db.Exec(`CREATE INDEX IF NOT EXISTS idx_local_projects_owner_username ON local_projects(owner_username)`).Error
-	_ = db.Exec(`CREATE INDEX IF NOT EXISTS idx_local_projects_is_active ON local_projects(is_active)`).Error
-	_ = db.Exec(`CREATE INDEX IF NOT EXISTS idx_local_projects_is_system ON local_projects(is_system)`).Error
-	_ = db.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_local_projects_code_variant ON local_projects(code, variant)`).Error
-	return nil
-}
-
 // HasSettings returns true if connection settings exist
 func (l *LocalDB) HasSettings() bool {
 	var count int64
@@ -363,8 +256,7 @@ func (l *LocalDB) EnsureDefaultProject(ownerUsername string) (*LocalProject, err
 	project = &LocalProject{
 		UUID:          uuidpkg.NewString(),
 		OwnerUsername: "",
-		Code:          "Без проекта",
-		Name:          ptrString("Без проекта"),
+		Name:          "Без проекта",
 		IsActive:      true,
 		IsSystem:      true,
 		CreatedAt:     now,
@@ -392,8 +284,7 @@ func (l *LocalDB) ConsolidateSystemProjects() (int64, error) {
 			canonical = LocalProject{
 				UUID:          uuidpkg.NewString(),
 				OwnerUsername: "",
-				Code:          "Без проекта",
-				Name:          ptrString("Без проекта"),
+				Name:          "Без проекта",
 				IsActive:      true,
 				IsSystem:      true,
 				CreatedAt:     now,
@@ -474,10 +365,6 @@ WHERE (
 	return tx.RowsAffected, tx.Error
 }
 
-func ptrString(value string) *string {
-	return &value
-}
-
 // BackfillConfigurationProjects ensures every configuration has project_uuid set.
 // If missing, it assigns system project "Без проекта" for configuration owner.
 func (l *LocalDB) BackfillConfigurationProjects(defaultOwner string) error {
@@ -531,55 +418,6 @@ func (l *LocalDB) GetConfigurationByUUID(uuid string) (*LocalConfiguration, erro
 	return &config, err
 }
 
-// ListConfigurationsWithFilters returns configurations with DB-level filtering and pagination.
-func (l *LocalDB) ListConfigurationsWithFilters(status string, search string, offset, limit int) ([]LocalConfiguration, int64, error) {
-	query := l.db.Model(&LocalConfiguration{})
-	switch status {
-	case "active":
-		query = query.Where("local_configurations.is_active = ?", true)
-	case "archived":
-		query = query.Where("local_configurations.is_active = ?", false)
-	case "all", "":
-		// no-op
-	default:
-		query = query.Where("local_configurations.is_active = ?", true)
-	}
-
-	search = strings.TrimSpace(search)
-	if search != "" {
-		needle := "%" + strings.ToLower(search) + "%"
-		hasProjectsTable := l.db.Migrator().HasTable(&LocalProject{})
-		hasServerModel := l.db.Migrator().HasColumn(&LocalConfiguration{}, "server_model")
-
-		conditions := []string{"LOWER(local_configurations.name) LIKE ?"}
-		args := []interface{}{needle}
-
-		if hasProjectsTable {
-			query = query.Joins("LEFT JOIN local_projects lp ON lp.uuid = local_configurations.project_uuid")
-			conditions = append(conditions, "LOWER(COALESCE(lp.name, '')) LIKE ?")
-			args = append(args, needle)
-		}
-
-		if hasServerModel {
-			conditions = append(conditions, "LOWER(COALESCE(local_configurations.server_model, '')) LIKE ?")
-			args = append(args, needle)
-		}
-
-		query = query.Where(strings.Join(conditions, " OR "), args...)
-	}
-
-	var total int64
-	if err := query.Count(&total).Error; err != nil {
-		return nil, 0, err
-	}
-
-	var configs []LocalConfiguration
-	if err := query.Order("local_configurations.created_at DESC").Offset(offset).Limit(limit).Find(&configs).Error; err != nil {
-		return nil, 0, err
-	}
-	return configs, total, nil
-}
-
 // DeleteConfiguration deletes a configuration by UUID
 func (l *LocalDB) DeleteConfiguration(uuid string) error {
 	return l.DeactivateConfiguration(uuid)
@@ -645,13 +483,6 @@ func (l *LocalDB) CountConfigurations() int64 {
 	return count
 }
 
-// CountProjects returns the number of local projects
-func (l *LocalDB) CountProjects() int64 {
-	var count int64
-	l.db.Model(&LocalProject{}).Count(&count)
-	return count
-}
-
 // Pricelist methods
 
 // GetLastSyncTime returns the last sync timestamp
@@ -692,11 +523,7 @@ func (l *LocalDB) CountLocalPricelists() int64 {
 // GetLatestLocalPricelist returns the most recently synced pricelist
 func (l *LocalDB) GetLatestLocalPricelist() (*LocalPricelist, error) {
 	var pricelist LocalPricelist
-	if err := l.db.
-		Where("source = ?", "estimate").
-		Where("EXISTS (SELECT 1 FROM local_pricelist_items WHERE local_pricelist_items.pricelist_id = local_pricelists.id)").
-		Order("created_at DESC, id DESC").
-		First(&pricelist).Error; err != nil {
+	if err := l.db.Where("source = ?", "estimate").Order("created_at DESC").First(&pricelist).Error; err != nil {
 		return nil, err
 	}
 	return &pricelist, nil
@@ -705,11 +532,7 @@ func (l *LocalDB) GetLatestLocalPricelist() (*LocalPricelist, error) {
 // GetLatestLocalPricelistBySource returns the most recently synced pricelist for a source.
 func (l *LocalDB) GetLatestLocalPricelistBySource(source string) (*LocalPricelist, error) {
 	var pricelist LocalPricelist
-	if err := l.db.
-		Where("source = ?", source).
-		Where("EXISTS (SELECT 1 FROM local_pricelist_items WHERE local_pricelist_items.pricelist_id = local_pricelists.id)").
-		Order("created_at DESC, id DESC").
-		First(&pricelist).Error; err != nil {
+	if err := l.db.Where("source = ?", source).Order("created_at DESC").First(&pricelist).Error; err != nil {
 		return nil, err
 	}
 	return &pricelist, nil
@@ -782,17 +605,6 @@ func (l *LocalDB) CountLocalPricelistItems(pricelistID uint) int64 {
 	return count
 }
 
-// CountLocalPricelistItemsWithEmptyCategory returns the number of items for a pricelist with missing lot_category.
-func (l *LocalDB) CountLocalPricelistItemsWithEmptyCategory(pricelistID uint) (int64, error) {
-	var count int64
-	if err := l.db.Model(&LocalPricelistItem{}).
-		Where("pricelist_id = ? AND (lot_category IS NULL OR TRIM(lot_category) = '')", pricelistID).
-		Count(&count).Error; err != nil {
-		return 0, err
-	}
-	return count, nil
-}
-
 // SaveLocalPricelistItems saves pricelist items to local SQLite
 func (l *LocalDB) SaveLocalPricelistItems(items []LocalPricelistItem) error {
 	if len(items) == 0 {
@@ -813,30 +625,6 @@ func (l *LocalDB) SaveLocalPricelistItems(items []LocalPricelistItem) error {
 	return nil
 }
 
-// ReplaceLocalPricelistItems atomically replaces all items for a pricelist.
-func (l *LocalDB) ReplaceLocalPricelistItems(pricelistID uint, items []LocalPricelistItem) error {
-	return l.db.Transaction(func(tx *gorm.DB) error {
-		if err := tx.Where("pricelist_id = ?", pricelistID).Delete(&LocalPricelistItem{}).Error; err != nil {
-			return err
-		}
-		if len(items) == 0 {
-			return nil
-		}
-
-		batchSize := 500
-		for i := 0; i < len(items); i += batchSize {
-			end := i + batchSize
-			if end > len(items) {
-				end = len(items)
-			}
-			if err := tx.CreateInBatches(items[i:end], batchSize).Error; err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-}
-
 // GetLocalPricelistItems returns items for a local pricelist
 func (l *LocalDB) GetLocalPricelistItems(pricelistID uint) ([]LocalPricelistItem, error) {
 	var items []LocalPricelistItem
@@ -856,36 +644,6 @@ func (l *LocalDB) GetLocalPriceForLot(pricelistID uint, lotName string) (float64
 	return item.Price, nil
 }
 
-// GetLocalLotCategoriesByServerPricelistID returns lot_category for each lot_name from a local pricelist resolved by server ID.
-// Missing lots are not included in the map; caller is responsible for strict validation.
-func (l *LocalDB) GetLocalLotCategoriesByServerPricelistID(serverPricelistID uint, lotNames []string) (map[string]string, error) {
-	result := make(map[string]string, len(lotNames))
-	if serverPricelistID == 0 || len(lotNames) == 0 {
-		return result, nil
-	}
-
-	localPL, err := l.GetLocalPricelistByServerID(serverPricelistID)
-	if err != nil {
-		return nil, err
-	}
-
-	type row struct {
-		LotName     string `gorm:"column:lot_name"`
-		LotCategory string `gorm:"column:lot_category"`
-	}
-	var rows []row
-	if err := l.db.Model(&LocalPricelistItem{}).
-		Select("lot_name, lot_category").
-		Where("pricelist_id = ? AND lot_name IN ?", localPL.ID, lotNames).
-		Find(&rows).Error; err != nil {
-		return nil, err
-	}
-	for _, r := range rows {
-		result[r.LotName] = r.LotCategory
-	}
-	return result, nil
-}
-
 // MarkPricelistAsUsed marks a pricelist as used by a configuration
 func (l *LocalDB) MarkPricelistAsUsed(pricelistID uint, isUsed bool) error {
 	return l.db.Model(&LocalPricelist{}).Where("id = ?", pricelistID).
@@ -921,47 +679,6 @@ func (l *LocalDB) DeleteLocalPricelist(id uint) error {
 	return l.db.Delete(&LocalPricelist{}, id).Error
 }
 
-// DeleteUnusedLocalPricelistsMissingOnServer removes local pricelists that are absent on server
-// and not referenced by active local configurations.
-func (l *LocalDB) DeleteUnusedLocalPricelistsMissingOnServer(serverPricelistIDs []uint) (int, error) {
-	returned := 0
-	err := l.db.Transaction(func(tx *gorm.DB) error {
-		var candidates []LocalPricelist
-		query := tx.Model(&LocalPricelist{})
-		if len(serverPricelistIDs) > 0 {
-			query = query.Where("server_id NOT IN ?", serverPricelistIDs)
-		}
-		if err := query.Find(&candidates).Error; err != nil {
-			return err
-		}
-
-		for i := range candidates {
-			pl := candidates[i]
-			var refs int64
-			if err := tx.Model(&LocalConfiguration{}).
-				Where("pricelist_id = ? AND is_active = 1", pl.ServerID).
-				Count(&refs).Error; err != nil {
-				return err
-			}
-			if refs > 0 {
-				continue
-			}
-			if err := tx.Where("pricelist_id = ?", pl.ID).Delete(&LocalPricelistItem{}).Error; err != nil {
-				return err
-			}
-			if err := tx.Delete(&LocalPricelist{}, pl.ID).Error; err != nil {
-				return err
-			}
-			returned++
-		}
-		return nil
-	})
-	if err != nil {
-		return 0, err
-	}
-	return returned, nil
-}
-
 // PendingChange methods
 
 // AddPendingChange adds a change to the sync queue
@@ -1048,210 +765,3 @@ func (l *LocalDB) PurgeOrphanConfigurationPendingChanges() (int64, error) {
 func (l *LocalDB) GetPendingCount() int64 {
 	return l.CountPendingChanges()
 }
-
-// RepairPendingChanges attempts to fix errored pending changes by validating and correcting data.
-// Returns the number of changes repaired and a list of errors that couldn't be fixed.
-func (l *LocalDB) RepairPendingChanges() (int, []string, error) {
-	var erroredChanges []PendingChange
-	if err := l.db.Where("last_error != ?", "").Find(&erroredChanges).Error; err != nil {
-		return 0, nil, fmt.Errorf("fetching errored changes: %w", err)
-	}
-
-	if len(erroredChanges) == 0 {
-		return 0, nil, nil
-	}
-
-	repaired := 0
-	var remainingErrors []string
-
-	for _, change := range erroredChanges {
-		var repairErr error
-		switch change.EntityType {
-		case "project":
-			repairErr = l.repairProjectChange(&change)
-		case "configuration":
-			repairErr = l.repairConfigurationChange(&change)
-		default:
-			repairErr = fmt.Errorf("unknown entity type: %s", change.EntityType)
-		}
-
-		if repairErr != nil {
-			remainingErrors = append(remainingErrors, fmt.Sprintf("%s %s %s: %v",
-				change.Operation, change.EntityType, change.EntityUUID[:8], repairErr))
-			continue
-		}
-
-		// Clear error and reset attempts
-		if err := l.db.Model(&PendingChange{}).Where("id = ?", change.ID).Updates(map[string]interface{}{
-			"last_error": "",
-			"attempts":   0,
-		}).Error; err != nil {
-			remainingErrors = append(remainingErrors, fmt.Sprintf("clearing error for %s: %v", change.EntityUUID[:8], err))
-			continue
-		}
-
-		repaired++
-	}
-
-	return repaired, remainingErrors, nil
-}
-
-// repairProjectChange validates and fixes project data.
-// Note: This only validates local data. Server-side conflicts (like duplicate code+variant)
-// are handled by sync service layer with deduplication logic.
-func (l *LocalDB) repairProjectChange(change *PendingChange) error {
-	project, err := l.GetProjectByUUID(change.EntityUUID)
-	if err != nil {
-		return fmt.Errorf("project not found locally: %w", err)
-	}
-
-	modified := false
-
-	// Fix Code: must be non-empty
-	if strings.TrimSpace(project.Code) == "" {
-		if project.Name != nil && strings.TrimSpace(*project.Name) != "" {
-			project.Code = strings.TrimSpace(*project.Name)
-		} else {
-			project.Code = project.UUID[:8]
-		}
-		modified = true
-	}
-
-	// Fix Name: use Code if empty
-	if project.Name == nil || strings.TrimSpace(*project.Name) == "" {
-		name := project.Code
-		project.Name = &name
-		modified = true
-	}
-
-	// Fix OwnerUsername: must be non-empty
-	if strings.TrimSpace(project.OwnerUsername) == "" {
-		project.OwnerUsername = l.GetDBUser()
-		if project.OwnerUsername == "" {
-			return fmt.Errorf("cannot determine owner username")
-		}
-		modified = true
-	}
-
-	// Check for local duplicates with same (code, variant)
-	var duplicate LocalProject
-	err = l.db.Where("code = ? AND variant = ? AND uuid != ?", project.Code, project.Variant, project.UUID).
-		First(&duplicate).Error
-	if err == nil {
-		// Found local duplicate - deduplicate by appending UUID suffix to variant
-		if project.Variant == "" {
-			project.Variant = project.UUID[:8]
-		} else {
-			project.Variant = project.Variant + "-" + project.UUID[:8]
-		}
-		modified = true
-	}
-
-	if modified {
-		if err := l.SaveProject(project); err != nil {
-			return fmt.Errorf("saving repaired project: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// repairConfigurationChange validates and fixes configuration data
-func (l *LocalDB) repairConfigurationChange(change *PendingChange) error {
-	config, err := l.GetConfigurationByUUID(change.EntityUUID)
-	if err != nil {
-		return fmt.Errorf("configuration not found locally: %w", err)
-	}
-
-	modified := false
-
-	// Check if referenced project exists
-	if config.ProjectUUID != nil && *config.ProjectUUID != "" {
-		_, err := l.GetProjectByUUID(*config.ProjectUUID)
-		if err != nil {
-			// Project doesn't exist locally - use default system project
-			systemProject, sysErr := l.EnsureDefaultProject(config.OriginalUsername)
-			if sysErr != nil {
-				return fmt.Errorf("getting system project: %w", sysErr)
-			}
-			config.ProjectUUID = &systemProject.UUID
-			modified = true
-		}
-	}
-
-	if modified {
-		if err := l.SaveConfiguration(config); err != nil {
-			return fmt.Errorf("saving repaired configuration: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// GetRemoteMigrationApplied returns a locally applied remote migration by ID.
-func (l *LocalDB) GetRemoteMigrationApplied(id string) (*LocalRemoteMigrationApplied, error) {
-	var migration LocalRemoteMigrationApplied
-	if err := l.db.Where("id = ?", id).First(&migration).Error; err != nil {
-		return nil, err
-	}
-	return &migration, nil
-}
-
-// UpsertRemoteMigrationApplied writes applied migration metadata.
-func (l *LocalDB) UpsertRemoteMigrationApplied(id, checksum, appVersion string, appliedAt time.Time) error {
-	record := &LocalRemoteMigrationApplied{
-		ID:         id,
-		Checksum:   checksum,
-		AppVersion: appVersion,
-		AppliedAt:  appliedAt,
-	}
-	return l.db.Clauses(clause.OnConflict{
-		Columns: []clause.Column{{Name: "id"}},
-		DoUpdates: clause.Assignments(map[string]interface{}{
-			"checksum":    checksum,
-			"app_version": appVersion,
-			"applied_at":  appliedAt,
-		}),
-	}).Create(record).Error
-}
-
-// GetLatestAppliedRemoteMigrationID returns last applied remote migration id.
-func (l *LocalDB) GetLatestAppliedRemoteMigrationID() (string, error) {
-	var record LocalRemoteMigrationApplied
-	if err := l.db.Order("applied_at DESC").First(&record).Error; err != nil {
-		return "", err
-	}
-	return record.ID, nil
-}
-
-// GetSyncGuardState returns the latest readiness guard state.
-func (l *LocalDB) GetSyncGuardState() (*LocalSyncGuardState, error) {
-	var state LocalSyncGuardState
-	if err := l.db.Order("id DESC").First(&state).Error; err != nil {
-		return nil, err
-	}
-	return &state, nil
-}
-
-// SetSyncGuardState upserts readiness guard state (single-row logical table).
-func (l *LocalDB) SetSyncGuardState(status, reasonCode, reasonText string, requiredMinAppVersion *string, checkedAt *time.Time) error {
-	state := &LocalSyncGuardState{
-		ID:                    1,
-		Status:                status,
-		ReasonCode:            reasonCode,
-		ReasonText:            reasonText,
-		RequiredMinAppVersion: requiredMinAppVersion,
-		LastCheckedAt:         checkedAt,
-	}
-	return l.db.Clauses(clause.OnConflict{
-		Columns: []clause.Column{{Name: "id"}},
-		DoUpdates: clause.Assignments(map[string]interface{}{
-			"status":                   status,
-			"reason_code":              reasonCode,
-			"reason_text":              reasonText,
-			"required_min_app_version": requiredMinAppVersion,
-			"last_checked_at":          checkedAt,
-			"updated_at":               time.Now(),
-		}),
-	}).Create(state).Error
-}

internal/localdb/migration_projects_test.go

@@ -51,8 +51,8 @@ func TestRunLocalMigrationsBackfillsDefaultProject(t *testing.T) {
 	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.Name != "Без проекта" {
+		t.Fatalf("expected system project name, got %q", project.Name)
 	}
 	if !project.IsSystem {
 		t.Fatalf("expected system project flag")

internal/localdb/migrations.go

@@ -58,56 +58,6 @@ var localMigrations = []localMigration{
 		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,
-	},
 }
 
 func runLocalMigrations(db *gorm.DB) error {
@@ -244,8 +194,7 @@ func ensureDefaultProjectTx(tx *gorm.DB, ownerUsername string) (*LocalProject, e
 	project = LocalProject{
 		UUID:          uuid.NewString(),
 		OwnerUsername: ownerUsername,
-		Code:          "Без проекта",
-		Name:          ptrString("Без проекта"),
+		Name:          "Без проекта",
 		IsActive:      true,
 		IsSystem:      true,
 		CreatedAt:     now,
@@ -259,139 +208,6 @@ func ensureDefaultProjectTx(tx *gorm.DB, ownerUsername string) (*LocalProject, e
 	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 {
@@ -433,93 +249,6 @@ func chooseNonZeroTime(candidate time.Time, fallback time.Time) time.Time {
 	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"`
@@ -587,222 +316,3 @@ func backfillLocalPricelistSource(tx *gorm.DB) error {
 
 	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
-}

internal/localdb/models.go

@@ -57,30 +57,6 @@ 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"`
@@ -96,13 +72,7 @@ type LocalConfiguration struct {
 	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"`
+	PricelistID      *uint                       `gorm:"index" json:"pricelist_id,omitempty"`
 	PriceUpdatedAt   *time.Time                  `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
 	CreatedAt        time.Time                   `json:"created_at"`
 	UpdatedAt        time.Time                   `json:"updated_at"`
@@ -123,9 +93,7 @@ type LocalProject struct {
 	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"`
+	Name          string     `gorm:"not null" json:"name"`
 	TrackerURL    string     `json:"tracker_url"`
 	IsActive      bool       `gorm:"default:true;index" json:"is_active"`
 	IsSystem      bool       `gorm:"default:false;index" json:"is_system"`
@@ -174,59 +142,30 @@ 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"`
-	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"`
+	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"`
 }
 
 func (LocalPricelistItem) TableName() string {
 	return "local_pricelist_items"
 }
 
-// LocalComponent stores cached components for offline search (metadata only)
-// All pricing is now sourced from local_pricelist_items based on configuration pricelist selection
+// LocalComponent stores cached components for offline search
 type LocalComponent struct {
-	LotName        string `gorm:"primaryKey" json:"lot_name"`
-	LotDescription string `json:"lot_description"`
-	Category       string `json:"category"`
-	Model          string `json:"model"`
+	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"`
 }
 
 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"`

internal/localdb/pricelist_latest_test.go

@@ -1,128 +0,0 @@
-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

@@ -3,7 +3,6 @@ package localdb
 import (
 	"encoding/json"
 	"fmt"
-	"sort"
 	"time"
 )
 
@@ -23,11 +22,7 @@ func BuildConfigurationSnapshot(localCfg *LocalConfiguration) (string, error) {
 		"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,
 		"price_updated_at":   localCfg.PriceUpdatedAt,
 		"created_at":         localCfg.CreatedAt,
 		"updated_at":         localCfg.UpdatedAt,
@@ -56,11 +51,7 @@ func DecodeConfigurationSnapshot(data string) (*LocalConfiguration, error) {
 		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"`
 		PriceUpdatedAt   *time.Time       `json:"price_updated_at"`
 		OriginalUserID   uint             `json:"original_user_id"`
 		OriginalUsername string           `json:"original_username"`
@@ -85,61 +76,9 @@ func DecodeConfigurationSnapshot(data string) (*LocalConfiguration, error) {
 		Notes:            snapshot.Notes,
 		IsTemplate:       snapshot.IsTemplate,
 		ServerCount:      snapshot.ServerCount,
-		ServerModel:      snapshot.ServerModel,
-		SupportCode:      snapshot.SupportCode,
-		Article:          snapshot.Article,
 		PricelistID:      snapshot.PricelistID,
-		OnlyInStock:      snapshot.OnlyInStock,
 		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

@@ -1,238 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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/cors.go

@@ -1,55 +1,22 @@
 package middleware
 
 import (
-	"net"
-	"net/http"
-	"net/url"
-	"strings"
-
 	"github.com/gin-gonic/gin"
 )
 
 func CORS() gin.HandlerFunc {
 	return func(c *gin.Context) {
-		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
-			}
-		}
+		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")
 
-		if c.Request.Method == http.MethodOptions {
-			c.AbortWithStatus(http.StatusNoContent)
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
 			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,30 +40,25 @@ 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       `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"`
-	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"`
+	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"`
+	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"`
+	PriceUpdatedAt *time.Time  `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
+	CreatedAt      time.Time   `gorm:"autoCreateTime" json:"created_at"`
 
 	User *User `gorm:"foreignKey:UserID" json:"user,omitempty"`
 }

internal/models/lot.go

@@ -41,7 +41,7 @@ func (Supplier) TableName() string {
 // 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"`
+	Lot        string    `gorm:"column:lot;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"`

internal/models/pricelist.go

@@ -55,7 +55,6 @@ 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"`
 

internal/models/project.go

@@ -6,9 +6,7 @@ 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"`
+	Name          string    `gorm:"size:200;not null" json:"name"`
 	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"`

internal/repository/pricelist.go

@@ -3,13 +3,10 @@ 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"
 )
@@ -29,8 +26,7 @@ func (r *PricelistRepository) List(offset, limit int) ([]models.PricelistSummary
 
 // 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)")
+	query := r.db.Model(&models.Pricelist{})
 	if source != "" {
 		query = query.Where("source = ?", source)
 	}
@@ -41,7 +37,7 @@ func (r *PricelistRepository) ListBySource(source string, offset, limit int) ([]
 	}
 
 	var pricelists []models.Pricelist
-	if err := query.Order("created_at DESC, id DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
+	if err := query.Order("created_at DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
 		return nil, 0, fmt.Errorf("listing pricelists: %w", err)
 	}
 
@@ -55,9 +51,7 @@ func (r *PricelistRepository) ListActive(offset, limit int) ([]models.PricelistS
 
 // 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)")
+	query := r.db.Model(&models.Pricelist{}).Where("is_active = ?", true)
 	if source != "" {
 		query = query.Where("source = ?", source)
 	}
@@ -68,7 +62,7 @@ func (r *PricelistRepository) ListActiveBySource(source string, offset, limit in
 	}
 
 	var pricelists []models.Pricelist
-	if err := query.Order("created_at DESC, id DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
+	if err := query.Order("created_at DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
 		return nil, 0, fmt.Errorf("listing active pricelists: %w", err)
 	}
 
@@ -149,11 +143,7 @@ func (r *PricelistRepository) GetLatestActive() (*models.Pricelist, error) {
 // 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 = ? 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 {
+	if err := r.db.Where("is_active = ? AND source = ?", true, source).Order("created_at DESC").First(&pricelist).Error; err != nil {
 		return nil, fmt.Errorf("getting latest pricelist: %w", err)
 	}
 	return &pricelist, nil
@@ -243,110 +233,93 @@ 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
 		}
-		items[i].Category = strings.TrimSpace(items[i].LotCategory)
+		// 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]
+		}
 	}
 
-	// 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)
+	var pl models.Pricelist
+	if err := r.db.Select("source").Where("id = ?", pricelistID).First(&pl).Error; err == nil && pl.Source == string(models.PricelistSourceWarehouse) {
+		if err := r.enrichWarehouseItems(items); err != nil {
+			return nil, 0, fmt.Errorf("enriching warehouse items: %w", err)
+		}
 	}
 
 	return items, total, nil
 }
 
-func (r *PricelistRepository) enrichItemsWithStock(items []models.PricelistItem) error {
+func (r *PricelistRepository) enrichWarehouseItems(items []models.PricelistItem) error {
 	if len(items) == 0 {
 		return nil
 	}
+	lots := make([]string, 0, len(items))
+	seen := make(map[string]struct{}, len(items))
+	for _, item := range items {
+		lot := strings.TrimSpace(item.LotName)
+		if lot == "" {
+			continue
+		}
+		if _, ok := seen[lot]; ok {
+			continue
+		}
+		seen[lot] = struct{}{}
+		lots = append(lots, lot)
+	}
+	if len(lots) == 0 {
+		return nil
+	}
 
-	resolver, err := lotmatch.NewLotResolverFromDB(r.db)
-	if err != nil {
+	type lotQty struct {
+		Lot string
+		Qty float64
+	}
+	var qtyRows []lotQty
+	if err := r.db.Model(&models.StockLog{}).
+		Select("lot, COALESCE(SUM(qty), 0) AS qty").
+		Where("lot IN ?", lots).
+		Group("lot").
+		Scan(&qtyRows).Error; err != nil {
 		return err
 	}
-
-	type stockRow struct {
-		Partnumber string   `gorm:"column:partnumber"`
-		Qty        *float64 `gorm:"column:qty"`
+	qtyByLot := make(map[string]float64, len(qtyRows))
+	for _, row := range qtyRows {
+		qtyByLot[row.Lot] = row.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 {
+
+	var mappings []models.LotPartnumber
+	if err := r.db.Where("lot_name IN ? AND TRIM(lot_name) <> ''", lots).
+		Order("partnumber ASC").
+		Find(&mappings).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) == "" {
+	partnumbersByLot := make(map[string][]string, len(lots))
+	seenPair := make(map[string]struct{}, len(mappings))
+	for _, m := range mappings {
+		lot := strings.TrimSpace(m.LotName)
+		pn := strings.TrimSpace(m.Partnumber)
+		if lot == "" || pn == "" {
 			continue
 		}
-		lotName, _, resolveErr := resolver.Resolve(row.Partnumber)
-		if resolveErr != nil || strings.TrimSpace(lotName) == "" {
+		key := lot + "\x00" + strings.ToLower(pn)
+		if _, ok := seenPair[key]; ok {
 			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)
+		seenPair[key] = struct{}{}
+		partnumbersByLot[lot] = append(partnumbersByLot[lot], 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
+		if qty, ok := qtyByLot[items[i].LotName]; ok {
+			q := qty
+			items[i].AvailableQty = &q
 		}
+		items[i].Partnumbers = partnumbersByLot[items[i].LotName]
 	}
-
 	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
@@ -356,28 +329,6 @@ func (r *PricelistRepository) GetPriceForLot(pricelistID uint, lotName string) (
 	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

internal/repository/pricelist_test.go

@@ -75,152 +75,6 @@ func TestGenerateVersion_IsolatedBySource(t *testing.T) {
 	}
 }
 
-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()
 
@@ -228,7 +82,7 @@ func newTestPricelistRepository(t *testing.T) *PricelistRepository {
 	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 {
+	if err := db.AutoMigrate(&models.Pricelist{}); err != nil {
 		t.Fatalf("migrate: %v", err)
 	}
 	return NewPricelistRepository(db)

internal/repository/project.go

@@ -27,8 +27,6 @@ func (r *ProjectRepository) UpsertByUUID(project *models.Project) error {
 		Columns: []clause.Column{{Name: "uuid"}},
 		DoUpdates: clause.AssignmentColumns([]string{
 			"owner_username",
-			"code",
-			"variant",
 			"name",
 			"tracker_url",
 			"is_active",

internal/repository/unified.go

@@ -83,6 +83,10 @@ 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)
 
@@ -92,6 +96,8 @@ 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:
@@ -106,8 +112,9 @@ 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,
+			LotName:      comp.LotName,
+			Model:        comp.Model,
+			CurrentPrice: comp.CurrentPrice,
 			Lot: &models.Lot{
 				LotName:        comp.LotName,
 				LotDescription: comp.LotDescription,
@@ -131,8 +138,9 @@ func (r *UnifiedRepo) GetComponent(lotName string) (*models.LotMetadata, error)
 	}
 
 	return &models.LotMetadata{
-		LotName: comp.LotName,
-		Model:   comp.Model,
+		LotName:      comp.LotName,
+		Model:        comp.Model,
+		CurrentPrice: comp.CurrentPrice,
 		Lot: &models.Lot{
 			LotName:        comp.LotName,
 			LotDescription: comp.LotDescription,

internal/services/alerts/service.go

@@ -0,0 +1,199 @@
+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,6 +53,7 @@ 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"`
@@ -91,6 +92,7 @@ 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,
@@ -132,6 +134,7 @@ 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

@@ -52,17 +52,6 @@ type CreateConfigRequest struct {
 	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"`
-}
-
-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"`
 }
 
@@ -94,11 +83,7 @@ func (s *ConfigurationService) Create(ownerUsername string, req *CreateConfigReq
 		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 {
@@ -159,11 +144,7 @@ func (s *ConfigurationService) Update(uuid string, ownerUsername string, req *Cr
 	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
@@ -241,7 +222,6 @@ func (s *ConfigurationService) CloneToProject(configUUID string, ownerUsername s
 		IsTemplate:    false, // Clone is never a template
 		ServerCount:   original.ServerCount,
 		PricelistID:   original.PricelistID,
-		OnlyInStock:   original.OnlyInStock,
 	}
 
 	if err := s.configRepo.Create(clone); err != nil {
@@ -315,7 +295,6 @@ func (s *ConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigReques
 	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
@@ -383,7 +362,6 @@ func (s *ConfigurationService) CloneNoAuthToProject(configUUID string, newName s
 		IsTemplate:    false,
 		ServerCount:   original.ServerCount,
 		PricelistID:   original.PricelistID,
-		OnlyInStock:   original.OnlyInStock,
 	}
 
 	if err := s.configRepo.Create(clone); err != nil {

internal/services/export.go

@@ -4,32 +4,33 @@ import (
 	"bytes"
 	"encoding/csv"
 	"fmt"
-	"io"
-	"math"
-	"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, local *localdb.LocalDB) *ExportService {
+func NewExportService(cfg config.ExportConfig, categoryRepo *repository.CategoryRepository) *ExportService {
 	return &ExportService{
 		config:       cfg,
 		categoryRepo: categoryRepo,
-		localDB:      local,
 	}
 }
 
-// ExportItem represents a single component in an export block.
+type ExportData struct {
+	Name      string
+	Items     []ExportItem
+	Total     float64
+	Notes     string
+	CreatedAt time.Time
+}
+
 type ExportItem struct {
 	LotName     string
 	Description string
@@ -39,45 +40,14 @@ type ExportItem struct {
 	TotalPrice  float64
 }
 
-// ConfigExportBlock represents one configuration (server) in the export.
-type ConfigExportBlock struct {
-	Article     string
-	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()
+func (s *ExportService) ToCSV(data *ExportData) ([]byte, error) {
+	var buf bytes.Buffer
+	w := csv.NewWriter(&buf)
 
 	// Header
-	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)
+	headers := []string{"Артикул", "Описание", "Категория", "Количество", "Цена за единицу", "Сумма"}
+	if err := w.Write(headers); err != nil {
+		return nil, err
 	}
 
 	// Get category hierarchy for sorting
@@ -91,235 +61,87 @@ func (s *ExportService) ToCSV(w io.Writer, data *ProjectExportData) error {
 		}
 	}
 
-	for i, block := range data.Configs {
-		lineNo := (i + 1) * 10
+	// Sort items by category display order
+	sortedItems := make([]ExportItem, len(data.Items))
+	copy(sortedItems, data.Items)
 
-		serverCount := block.ServerCount
-		if serverCount < 1 {
-			serverCount = 1
-		}
+	// 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]
 
-		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)
+			// 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]
+				}
 			}
 		}
 	}
 
-	csvWriter.Flush()
-	if err := csvWriter.Error(); err != nil {
-		return fmt.Errorf("csv writer error: %w", err)
+	// 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
+		}
 	}
 
-	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 {
+	// Total row
+	if err := w.Write([]string{"", "", "", "", "ИТОГО:", fmt.Sprintf("%.2f", data.Total)}); err != nil {
 		return nil, err
 	}
-	return buf.Bytes(), nil
+
+	w.Flush()
+	return buf.Bytes(), w.Error()
 }
 
-// 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,
-	}
-}
+func (s *ExportService) ConfigToExportData(config *models.Configuration, componentService *ComponentService) *ExportData {
+	items := make([]ExportItem, len(config.Items))
+	var total float64
 
-// ProjectToExportData converts multiple configurations into ProjectExportData.
-func (s *ExportService) ProjectToExportData(configs []models.Configuration) *ProjectExportData {
-	blocks := make([]ConfigExportBlock, 0, len(configs))
-	for i := range configs {
-		blocks = append(blocks, s.buildExportBlock(&configs[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 {
+	for i, item := range config.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,
-		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
-				}
+		// Получаем информацию о компоненте для заполнения категории
+		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,
 			}
 		}
+		total += itemTotal
 	}
 
-	// Fallback: local_components for any still missing
-	var missing []string
-	for _, lot := range lotNames {
-		if categories[lot] == "" {
-			missing = append(missing, lot)
-		}
-	}
-	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
-				}
-			}
-		}
-	}
-
-	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]
-			}
-		}
+	return &ExportData{
+		Name:      config.Name,
+		Items:     items,
+		Total:     total,
+		Notes:     config.Notes,
+		CreatedAt: config.CreatedAt,
 	}
 }
-
-// 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

@@ -1,406 +0,0 @@
-package services
-
-import (
-	"bytes"
-	"encoding/csv"
-	"io"
-	"testing"
-	"time"
-
-	"git.mchus.pro/mchus/quoteforge/internal/config"
-)
-
-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 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.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
-	"git.mchus.pro/mchus/quoteforge/internal/article"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
@@ -65,18 +64,6 @@ func (s *LocalConfigurationService) Create(ownerUsername string, req *CreateConf
 		return nil, err
 	}
 
-	if strings.TrimSpace(req.ServerModel) != "" {
-		articleResult, articleErr := article.Build(s.localDB, req.Items, article.BuildOptions{
-			ServerModel:     req.ServerModel,
-			SupportCode:     req.SupportCode,
-			ServerPricelist: pricelistID,
-		})
-		if articleErr != nil {
-			return nil, articleErr
-		}
-		req.Article = articleResult.Article
-	}
-
 	total := req.Items.Total()
 	if req.ServerCount > 1 {
 		total *= float64(req.ServerCount)
@@ -93,11 +80,7 @@ func (s *LocalConfigurationService) Create(ownerUsername string, req *CreateConf
 		Notes:         req.Notes,
 		IsTemplate:    req.IsTemplate,
 		ServerCount:   req.ServerCount,
-		ServerModel:   req.ServerModel,
-		SupportCode:   req.SupportCode,
-		Article:       req.Article,
 		PricelistID:   pricelistID,
-		OnlyInStock:   req.OnlyInStock,
 		CreatedAt:     time.Now(),
 	}
 
@@ -158,18 +141,6 @@ func (s *LocalConfigurationService) Update(uuid string, ownerUsername string, re
 		return nil, err
 	}
 
-	if strings.TrimSpace(req.ServerModel) != "" {
-		articleResult, articleErr := article.Build(s.localDB, req.Items, article.BuildOptions{
-			ServerModel:     req.ServerModel,
-			SupportCode:     req.SupportCode,
-			ServerPricelist: pricelistID,
-		})
-		if articleErr != nil {
-			return nil, articleErr
-		}
-		req.Article = articleResult.Article
-	}
-
 	total := req.Items.Total()
 	if req.ServerCount > 1 {
 		total *= float64(req.ServerCount)
@@ -191,11 +162,7 @@ func (s *LocalConfigurationService) Update(uuid string, ownerUsername string, re
 	localCfg.Notes = req.Notes
 	localCfg.IsTemplate = req.IsTemplate
 	localCfg.ServerCount = req.ServerCount
-	localCfg.ServerModel = req.ServerModel
-	localCfg.SupportCode = req.SupportCode
-	localCfg.Article = req.Article
 	localCfg.PricelistID = pricelistID
-	localCfg.OnlyInStock = req.OnlyInStock
 	localCfg.UpdatedAt = time.Now()
 	localCfg.SyncStatus = "pending"
 
@@ -207,19 +174,6 @@ func (s *LocalConfigurationService) Update(uuid string, ownerUsername string, re
 	return cfg, nil
 }
 
-// BuildArticlePreview generates server article based on current items and server_model/support_code.
-func (s *LocalConfigurationService) BuildArticlePreview(req *ArticlePreviewRequest) (article.BuildResult, error) {
-	pricelistID, err := s.resolvePricelistID(req.PricelistID)
-	if err != nil {
-		return article.BuildResult{}, err
-	}
-	return article.Build(s.localDB, req.Items, article.BuildOptions{
-		ServerModel:     req.ServerModel,
-		SupportCode:     req.SupportCode,
-		ServerPricelist: pricelistID,
-	})
-}
-
 // Delete deletes a configuration from local SQLite and queues it for sync
 func (s *LocalConfigurationService) Delete(uuid string, ownerUsername string) error {
 	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
@@ -313,11 +267,7 @@ func (s *LocalConfigurationService) CloneToProject(configUUID string, ownerUsern
 		Notes:         original.Notes,
 		IsTemplate:    false,
 		ServerCount:   original.ServerCount,
-		ServerModel:   original.ServerModel,
-		SupportCode:   original.SupportCode,
-		Article:       original.Article,
 		PricelistID:   original.PricelistID,
-		OnlyInStock:   original.OnlyInStock,
 		CreatedAt:     time.Now(),
 	}
 
@@ -394,7 +344,7 @@ func (s *LocalConfigurationService) RefreshPrices(uuid string, ownerUsername str
 	}
 	latestPricelist, latestErr := s.localDB.GetLatestLocalPricelist()
 
-	// Update prices for all items from pricelist
+	// Update prices for all items
 	updatedItems := make(localdb.LocalConfigItems, len(localCfg.Items))
 	for i, item := range localCfg.Items {
 		if latestErr == nil && latestPricelist != nil {
@@ -409,8 +359,20 @@ func (s *LocalConfigurationService) RefreshPrices(uuid string, ownerUsername str
 			}
 		}
 
-		// Keep original item if price not found in pricelist
-		updatedItems[i] = item
+		// Fallback to current component price from local cache
+		component, err := s.localDB.GetLocalComponent(item.LotName)
+		if err != nil || component.CurrentPrice == nil {
+			// Keep original item if component not found or no price available
+			updatedItems[i] = item
+			continue
+		}
+
+		// Update item with current price from local cache
+		updatedItems[i] = localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: *component.CurrentPrice,
+		}
 	}
 
 	// Update configuration
@@ -442,14 +404,14 @@ func (s *LocalConfigurationService) RefreshPrices(uuid string, ownerUsername str
 
 // GetByUUIDNoAuth returns configuration without ownership check
 func (s *LocalConfigurationService) GetByUUIDNoAuth(uuid string) (*models.Configuration, error) {
-	var localCfg localdb.LocalConfiguration
-	if err := s.localDB.DB().Preload("CurrentVersion").Where("uuid = ?", uuid).First(&localCfg).Error; err != nil {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
 		return nil, ErrConfigNotFound
 	}
 	if !localCfg.IsActive {
 		return nil, ErrConfigNotFound
 	}
-	return localdb.LocalToConfiguration(&localCfg), nil
+	return localdb.LocalToConfiguration(localCfg), nil
 }
 
 // UpdateNoAuth updates configuration without ownership check
@@ -461,21 +423,9 @@ func (s *LocalConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigR
 
 	projectUUID := localCfg.ProjectUUID
 	if req.ProjectUUID != nil {
-		requestedProjectUUID := strings.TrimSpace(*req.ProjectUUID)
-		currentProjectUUID := ""
-		if localCfg.ProjectUUID != nil {
-			currentProjectUUID = strings.TrimSpace(*localCfg.ProjectUUID)
-		}
-
 		projectUUID, err = s.resolveProjectUUID(localCfg.OriginalUsername, req.ProjectUUID)
 		if err != nil {
-			// Allow save for legacy/orphaned configs when request keeps the same project UUID.
-			// This can happen for imported configs whose project is not present in local cache.
-			if errors.Is(err, ErrProjectNotFound) && requestedProjectUUID != "" && requestedProjectUUID == currentProjectUUID {
-				projectUUID = localCfg.ProjectUUID
-			} else {
-				return nil, err
-			}
+			return nil, err
 		}
 	}
 	pricelistID, err := s.resolvePricelistID(req.PricelistID)
@@ -483,18 +433,6 @@ func (s *LocalConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigR
 		return nil, err
 	}
 
-	if strings.TrimSpace(req.ServerModel) != "" {
-		articleResult, articleErr := article.Build(s.localDB, req.Items, article.BuildOptions{
-			ServerModel:     req.ServerModel,
-			SupportCode:     req.SupportCode,
-			ServerPricelist: pricelistID,
-		})
-		if articleErr != nil {
-			return nil, articleErr
-		}
-		req.Article = articleResult.Article
-	}
-
 	total := req.Items.Total()
 	if req.ServerCount > 1 {
 		total *= float64(req.ServerCount)
@@ -515,11 +453,7 @@ func (s *LocalConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigR
 	localCfg.Notes = req.Notes
 	localCfg.IsTemplate = req.IsTemplate
 	localCfg.ServerCount = req.ServerCount
-	localCfg.ServerModel = req.ServerModel
-	localCfg.SupportCode = req.SupportCode
-	localCfg.Article = req.Article
 	localCfg.PricelistID = pricelistID
-	localCfg.OnlyInStock = req.OnlyInStock
 	localCfg.UpdatedAt = time.Now()
 	localCfg.SyncStatus = "pending"
 
@@ -583,30 +517,10 @@ func (s *LocalConfigurationService) CloneNoAuth(configUUID string, newName strin
 }
 
 func (s *LocalConfigurationService) CloneNoAuthToProject(configUUID string, newName string, ownerUsername string, projectUUID *string) (*models.Configuration, error) {
-	return s.CloneNoAuthToProjectFromVersion(configUUID, newName, ownerUsername, projectUUID, 0)
-}
-
-func (s *LocalConfigurationService) CloneNoAuthToProjectFromVersion(configUUID string, newName string, ownerUsername string, projectUUID *string, fromVersion int) (*models.Configuration, error) {
 	original, err := s.GetByUUIDNoAuth(configUUID)
 	if err != nil {
 		return nil, err
 	}
-
-	// If fromVersion specified, use snapshot from that version
-	if fromVersion > 0 {
-		version, vErr := s.GetVersion(configUUID, fromVersion)
-		if vErr != nil {
-			return nil, vErr
-		}
-		snapshot, decErr := s.decodeConfigurationSnapshot(version.Data)
-		if decErr != nil {
-			return nil, fmt.Errorf("decode version snapshot for clone: %w", decErr)
-		}
-		snapshotCfg := localdb.LocalToConfiguration(snapshot)
-		original = snapshotCfg
-		original.UUID = configUUID // preserve original UUID for project resolution
-	}
-
 	resolvedProjectUUID := original.ProjectUUID
 	if projectUUID != nil {
 		resolvedProjectUUID, err = s.resolveProjectUUID(ownerUsername, projectUUID)
@@ -632,7 +546,6 @@ func (s *LocalConfigurationService) CloneNoAuthToProjectFromVersion(configUUID s
 		IsTemplate:    false,
 		ServerCount:   original.ServerCount,
 		PricelistID:   original.PricelistID,
-		OnlyInStock:   original.OnlyInStock,
 		CreatedAt:     time.Now(),
 	}
 
@@ -682,6 +595,26 @@ func (s *LocalConfigurationService) ListAll(page, perPage int) ([]models.Configu
 
 // ListAllWithStatus returns configurations filtered by status: active|archived|all.
 func (s *LocalConfigurationService) ListAllWithStatus(page, perPage int, status string, search string) ([]models.Configuration, int64, error) {
+	localConfigs, err := s.localDB.GetConfigurations()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	search = strings.ToLower(strings.TrimSpace(search))
+	configs := make([]models.Configuration, len(localConfigs))
+	configs = configs[:0]
+	for _, lc := range localConfigs {
+		if !matchesConfigStatus(lc.IsActive, status) {
+			continue
+		}
+		if search != "" && !strings.Contains(strings.ToLower(lc.Name), search) {
+			continue
+		}
+		configs = append(configs, *localdb.LocalToConfiguration(&lc))
+	}
+
+	total := int64(len(configs))
+
 	// Apply pagination
 	if page < 1 {
 		page = 1
@@ -690,15 +623,17 @@ func (s *LocalConfigurationService) ListAllWithStatus(page, perPage int, status
 		perPage = 20
 	}
 	offset := (page - 1) * perPage
-	localConfigs, total, err := s.localDB.ListConfigurationsWithFilters(status, search, offset, perPage)
-	if err != nil {
-		return nil, 0, err
+
+	start := offset
+	if start > len(configs) {
+		start = len(configs)
 	}
-	configs := make([]models.Configuration, 0, len(localConfigs))
-	for _, lc := range localConfigs {
-		configs = append(configs, *localdb.LocalToConfiguration(&lc))
+	end := start + perPage
+	if end > len(configs) {
+		end = len(configs)
 	}
-	return configs, total, nil
+
+	return configs[start:end], total, nil
 }
 
 // ListTemplates returns all template configurations
@@ -754,7 +689,7 @@ func (s *LocalConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Co
 	}
 	latestPricelist, latestErr := s.localDB.GetLatestLocalPricelist()
 
-	// Update prices for all items from pricelist
+	// Update prices for all items
 	updatedItems := make(localdb.LocalConfigItems, len(localCfg.Items))
 	for i, item := range localCfg.Items {
 		if latestErr == nil && latestPricelist != nil {
@@ -769,8 +704,20 @@ func (s *LocalConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Co
 			}
 		}
 
-		// Keep original item if price not found in pricelist
-		updatedItems[i] = item
+		// Fallback to current component price from local cache
+		component, err := s.localDB.GetLocalComponent(item.LotName)
+		if err != nil || component.CurrentPrice == nil {
+			// Keep original item if component not found or no price available
+			updatedItems[i] = item
+			continue
+		}
+
+		// Update item with current price from local cache
+		updatedItems[i] = localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: *component.CurrentPrice,
+		}
 	}
 
 	// Update configuration
@@ -800,58 +747,6 @@ func (s *LocalConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Co
 	return cfg, nil
 }
 
-// UpdateServerCount updates server count and recalculates total price without creating a new version.
-func (s *LocalConfigurationService) UpdateServerCount(configUUID string, serverCount int) (*models.Configuration, error) {
-	if serverCount < 1 {
-		return nil, fmt.Errorf("server count must be at least 1")
-	}
-
-	localCfg, err := s.localDB.GetConfigurationByUUID(configUUID)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-
-	localCfg.ServerCount = serverCount
-	total := localCfg.Items.Total()
-	if serverCount > 1 {
-		total *= float64(serverCount)
-	}
-	localCfg.TotalPrice = &total
-	localCfg.UpdatedAt = time.Now()
-	localCfg.SyncStatus = "pending"
-
-	var cfg *models.Configuration
-	err = s.localDB.DB().Transaction(func(tx *gorm.DB) error {
-		if err := tx.Save(localCfg).Error; err != nil {
-			return fmt.Errorf("save local configuration: %w", err)
-		}
-
-		// Use existing current version for the pending change
-		var version localdb.LocalConfigurationVersion
-		if localCfg.CurrentVersionID != nil && *localCfg.CurrentVersionID != "" {
-			if err := tx.Where("id = ?", *localCfg.CurrentVersionID).First(&version).Error; err != nil {
-				return fmt.Errorf("load current version: %w", err)
-			}
-		} else {
-			if err := tx.Where("configuration_uuid = ?", localCfg.UUID).
-				Order("version_no DESC").First(&version).Error; err != nil {
-				return fmt.Errorf("load latest version: %w", err)
-			}
-		}
-
-		cfg = localdb.LocalToConfiguration(localCfg)
-		if err := s.enqueueConfigurationPendingChangeTx(tx, localCfg, "update", &version, ""); err != nil {
-			return fmt.Errorf("enqueue server-count pending change: %w", err)
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return cfg, nil
-}
-
 // ImportFromServer imports configurations from MariaDB to local SQLite cache.
 func (s *LocalConfigurationService) ImportFromServer() (*sync.ConfigImportResult, error) {
 	return s.syncService.ImportConfigurationsToLocal()
@@ -980,7 +875,6 @@ func (s *LocalConfigurationService) createWithVersion(localCfg *localdb.LocalCon
 			return fmt.Errorf("set current version id: %w", err)
 		}
 		localCfg.CurrentVersionID = &version.ID
-		localCfg.CurrentVersion = version
 
 		if err := s.enqueueConfigurationPendingChangeTx(tx, localCfg, "create", version, createdBy); err != nil {
 			return fmt.Errorf("enqueue create pending change: %w", err)
@@ -1007,26 +901,6 @@ func (s *LocalConfigurationService) saveWithVersionAndPending(localCfg *localdb.
 			return fmt.Errorf("lock configuration row: %w", err)
 		}
 
-		if operation == "update" {
-			currentVersion, err := s.loadCurrentVersionTx(tx, &locked)
-			if err != nil {
-				return fmt.Errorf("load current version before save: %w", err)
-			}
-
-			// Legacy/orphaned rows may have empty or stale current_version_id.
-			// In that case we treat update as content-changing and append a fresh version.
-			if currentVersion != nil {
-				sameRevisionContent, err := s.hasSameRevisionContent(localCfg, currentVersion)
-				if err != nil {
-					return fmt.Errorf("compare revision content: %w", err)
-				}
-				if sameRevisionContent {
-					cfg = localdb.LocalToConfiguration(&locked)
-					return nil
-				}
-			}
-		}
-
 		if err := tx.Save(localCfg).Error; err != nil {
 			return fmt.Errorf("save local configuration: %w", err)
 		}
@@ -1042,7 +916,6 @@ func (s *LocalConfigurationService) saveWithVersionAndPending(localCfg *localdb.
 			return fmt.Errorf("update current version id: %w", err)
 		}
 		localCfg.CurrentVersionID = &version.ID
-		localCfg.CurrentVersion = version
 
 		cfg = localdb.LocalToConfiguration(localCfg)
 		if err := s.enqueueConfigurationPendingChangeTx(tx, localCfg, operation, version, createdBy); err != nil {
@@ -1061,44 +934,6 @@ func (s *LocalConfigurationService) saveWithVersionAndPending(localCfg *localdb.
 	return cfg, nil
 }
 
-func (s *LocalConfigurationService) loadCurrentVersionTx(tx *gorm.DB, localCfg *localdb.LocalConfiguration) (*localdb.LocalConfigurationVersion, error) {
-	var version localdb.LocalConfigurationVersion
-	if localCfg.CurrentVersionID != nil && *localCfg.CurrentVersionID != "" {
-		if err := tx.Where("id = ?", *localCfg.CurrentVersionID).First(&version).Error; err == nil {
-			return &version, nil
-		} else if !errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, err
-		}
-	}
-
-	if err := tx.Where("configuration_uuid = ?", localCfg.UUID).
-		Order("version_no DESC").
-		First(&version).Error; err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return &version, nil
-}
-
-func (s *LocalConfigurationService) hasSameRevisionContent(localCfg *localdb.LocalConfiguration, currentVersion *localdb.LocalConfigurationVersion) (bool, error) {
-	currentSnapshotCfg, err := s.decodeConfigurationSnapshot(currentVersion.Data)
-	if err != nil {
-		return false, fmt.Errorf("decode current version snapshot: %w", err)
-	}
-
-	currentFingerprint, err := localdb.BuildConfigurationSpecPriceFingerprint(currentSnapshotCfg)
-	if err != nil {
-		return false, fmt.Errorf("build current snapshot fingerprint: %w", err)
-	}
-	nextFingerprint, err := localdb.BuildConfigurationSpecPriceFingerprint(localCfg)
-	if err != nil {
-		return false, fmt.Errorf("build next snapshot fingerprint: %w", err)
-	}
-	return currentFingerprint == nextFingerprint, nil
-}
-
 func (s *LocalConfigurationService) appendVersionTx(
 	tx *gorm.DB,
 	localCfg *localdb.LocalConfiguration,
@@ -1194,7 +1029,6 @@ func (s *LocalConfigurationService) rollbackToVersion(configurationUUID string,
 		current.IsTemplate = rollbackData.IsTemplate
 		current.ServerCount = rollbackData.ServerCount
 		current.PricelistID = rollbackData.PricelistID
-		current.OnlyInStock = rollbackData.OnlyInStock
 		current.PriceUpdatedAt = rollbackData.PriceUpdatedAt
 		current.UpdatedAt = time.Now()
 		current.SyncStatus = "pending"

internal/services/local_configuration_versioning_test.go

@@ -27,12 +27,8 @@ func TestSaveCreatesNewVersionAndUpdatesCurrentPointer(t *testing.T) {
 		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)
+	if _, err := service.RenameNoAuth(created.UUID, "v2"); err != nil {
+		t.Fatalf("rename config: %v", err)
 	}
 
 	versions := loadVersions(t, local, created.UUID)
@@ -64,12 +60,8 @@ func TestRollbackCreatesNewVersionWithTargetData(t *testing.T) {
 		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.RenameNoAuth(created.UUID, "changed"); err != nil {
+		t.Fatalf("rename config: %v", err)
 	}
 	if _, err := service.RollbackToVersionWithNote(created.UUID, 1, "tester", "test rollback"); err != nil {
 		t.Fatalf("rollback to v1: %v", err)
@@ -87,56 +79,6 @@ func TestRollbackCreatesNewVersionWithTargetData(t *testing.T) {
 	}
 }
 
-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 TestAppendOnlyInvariantOldRowsUnchanged(t *testing.T) {
 	service, local := newLocalConfigServiceForTest(t)
 
@@ -155,12 +97,8 @@ func TestAppendOnlyInvariantOldRowsUnchanged(t *testing.T) {
 	}
 	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.RenameNoAuth(created.UUID, "after-rename"); err != nil {
+		t.Fatalf("rename config: %v", err)
 	}
 	if _, err := service.RollbackToVersion(created.UUID, 1, "tester"); err != nil {
 		t.Fatalf("rollback: %v", err)
@@ -206,7 +144,7 @@ func TestConcurrentSaveNoDuplicateVersionNumbers(t *testing.T) {
 		go func() {
 			defer wg.Done()
 			<-start
-			if err := updateWithRetry(service, created.UUID, i+2); err != nil {
+			if err := renameWithRetry(service, created.UUID, fmt.Sprintf("name-%d", i)); err != nil {
 				errCh <- err
 			}
 		}()
@@ -253,8 +191,7 @@ func TestUpdateNoAuthKeepsProjectWhenProjectUUIDOmitted(t *testing.T) {
 	project := &localdb.LocalProject{
 		UUID:          "project-keep",
 		OwnerUsername: "tester",
-		Code:          "TEST-KEEP",
-		Name:          ptrString("Keep Project"),
+		Name:          "Keep Project",
 		IsActive:      true,
 		CreatedAt:     time.Now(),
 		UpdatedAt:     time.Now(),
@@ -290,103 +227,6 @@ func TestUpdateNoAuthKeepsProjectWhenProjectUUIDOmitted(t *testing.T) {
 	}
 }
 
-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()
 
@@ -419,14 +259,10 @@ func loadVersions(t *testing.T, local *localdb.LocalDB, configurationUUID string
 	return versions
 }
 
-func updateWithRetry(service *LocalConfigurationService, uuid string, quantity int) error {
+func renameWithRetry(service *LocalConfigurationService, uuid string, name string) 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,
-		})
+		_, err := service.RenameNoAuth(uuid, name)
 		if err == nil {
 			return nil
 		}
@@ -437,7 +273,7 @@ func updateWithRetry(service *LocalConfigurationService, uuid string, quantity i
 		}
 		return err
 	}
-	return fmt.Errorf("update retries exhausted: %w", lastErr)
+	return fmt.Errorf("rename retries exhausted: %w", lastErr)
 }
 
 func TestRollbackVersionSnapshotJSONMatchesV1(t *testing.T) {
@@ -451,12 +287,8 @@ func TestRollbackVersionSnapshotJSONMatchesV1(t *testing.T) {
 	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.RenameNoAuth(created.UUID, "second"); err != nil {
+		t.Fatalf("rename: %v", err)
 	}
 	if _, err := service.RollbackToVersion(created.UUID, 1, "tester"); err != nil {
 		t.Fatalf("rollback: %v", err)

internal/services/pricelist/service.go

@@ -0,0 +1,340 @@
+package pricelist
+
+import (
+	"errors"
+	"fmt"
+	"log/slog"
+	"strings"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
+	"gorm.io/gorm"
+)
+
+type Service struct {
+	repo          *repository.PricelistRepository
+	componentRepo *repository.ComponentRepository
+	pricingSvc    *pricing.Service
+	db            *gorm.DB
+}
+
+type CreateProgress struct {
+	Current int
+	Total   int
+	Status  string
+	Message string
+	Updated int
+	Errors  int
+	LotName string
+}
+
+type CreateItemInput struct {
+	LotName string
+	Price   float64
+}
+
+func NewService(db *gorm.DB, repo *repository.PricelistRepository, componentRepo *repository.ComponentRepository, pricingSvc *pricing.Service) *Service {
+	return &Service{
+		repo:          repo,
+		componentRepo: componentRepo,
+		pricingSvc:    pricingSvc,
+		db:            db,
+	}
+}
+
+// CreateFromCurrentPrices creates a new pricelist by taking a snapshot of current prices
+func (s *Service) CreateFromCurrentPrices(createdBy string) (*models.Pricelist, error) {
+	return s.CreateFromCurrentPricesForSource(createdBy, string(models.PricelistSourceEstimate))
+}
+
+// CreateFromCurrentPricesForSource creates a new pricelist snapshot for one source.
+func (s *Service) CreateFromCurrentPricesForSource(createdBy, source string) (*models.Pricelist, error) {
+	return s.CreateForSourceWithProgress(createdBy, source, nil, nil)
+}
+
+// CreateFromCurrentPricesWithProgress creates a pricelist and reports coarse-grained progress.
+func (s *Service) CreateFromCurrentPricesWithProgress(createdBy, source string, onProgress func(CreateProgress)) (*models.Pricelist, error) {
+	return s.CreateForSourceWithProgress(createdBy, source, nil, onProgress)
+}
+
+// CreateForSourceWithProgress creates a source pricelist from current estimate snapshot or explicit item list.
+func (s *Service) CreateForSourceWithProgress(createdBy, source string, sourceItems []CreateItemInput, onProgress func(CreateProgress)) (*models.Pricelist, error) {
+	if s.repo == nil || s.db == nil {
+		return nil, fmt.Errorf("offline mode: cannot create pricelists")
+	}
+	source = string(models.NormalizePricelistSource(source))
+
+	report := func(p CreateProgress) {
+		if onProgress != nil {
+			onProgress(p)
+		}
+	}
+	report(CreateProgress{Current: 0, Total: 100, Status: "starting", Message: "Подготовка"})
+
+	updated, errs := 0, 0
+	if source == string(models.PricelistSourceEstimate) && s.pricingSvc != nil {
+		report(CreateProgress{Current: 1, Total: 100, Status: "recalculating", Message: "Обновление цен компонентов"})
+		updated, errs = s.pricingSvc.RecalculateAllPricesWithProgress(func(p pricing.RecalculateProgress) {
+			if p.Total <= 0 {
+				return
+			}
+			phaseCurrent := 1 + int(float64(p.Current)/float64(p.Total)*90.0)
+			if phaseCurrent > 91 {
+				phaseCurrent = 91
+			}
+			report(CreateProgress{
+				Current: phaseCurrent,
+				Total:   100,
+				Status:  "recalculating",
+				Message: "Обновление цен компонентов",
+				Updated: p.Updated,
+				Errors:  p.Errors,
+				LotName: p.LotName,
+			})
+		})
+	}
+	report(CreateProgress{Current: 92, Total: 100, Status: "recalculated", Message: "Цены обновлены", Updated: updated, Errors: errs})
+
+	report(CreateProgress{Current: 95, Total: 100, Status: "snapshot", Message: "Создание снимка прайслиста"})
+	expiresAt := time.Now().AddDate(1, 0, 0) // +1 year
+	const maxCreateAttempts = 5
+	var pricelist *models.Pricelist
+	for attempt := 1; attempt <= maxCreateAttempts; attempt++ {
+		version, err := s.repo.GenerateVersionBySource(source)
+		if err != nil {
+			return nil, fmt.Errorf("generating version: %w", err)
+		}
+
+		pricelist = &models.Pricelist{
+			Source:    source,
+			Version:   version,
+			CreatedBy: createdBy,
+			IsActive:  true,
+			ExpiresAt: &expiresAt,
+		}
+
+		if err := s.repo.Create(pricelist); err != nil {
+			if isVersionConflictError(err) && attempt < maxCreateAttempts {
+				slog.Warn("pricelist version conflict, retrying",
+					"attempt", attempt,
+					"version", version,
+					"error", err,
+				)
+				time.Sleep(time.Duration(attempt*25) * time.Millisecond)
+				continue
+			}
+			return nil, fmt.Errorf("creating pricelist: %w", err)
+		}
+		break
+	}
+
+	items := make([]models.PricelistItem, 0)
+	if len(sourceItems) > 0 {
+		items = make([]models.PricelistItem, 0, len(sourceItems))
+		for _, srcItem := range sourceItems {
+			if strings.TrimSpace(srcItem.LotName) == "" || srcItem.Price <= 0 {
+				continue
+			}
+			items = append(items, models.PricelistItem{
+				PricelistID: pricelist.ID,
+				LotName:     strings.TrimSpace(srcItem.LotName),
+				Price:       srcItem.Price,
+			})
+		}
+	} else {
+		// Default snapshot source for estimate and backward compatibility.
+		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,
+	)
+	report(CreateProgress{Current: 100, Total: 100, Status: "completed", Message: "Прайслист создан", Updated: updated, Errors: errs})
+
+	return pricelist, nil
+}
+
+func isVersionConflictError(err error) bool {
+	if errors.Is(err, gorm.ErrDuplicatedKey) {
+		return true
+	}
+	msg := strings.ToLower(err.Error())
+	return strings.Contains(msg, "duplicate entry") &&
+		(strings.Contains(msg, "idx_qt_pricelists_source_version") || strings.Contains(msg, "idx_qt_pricelists_version"))
+}
+
+// List returns pricelists with pagination
+func (s *Service) List(page, perPage int) ([]models.PricelistSummary, int64, error) {
+	return s.ListBySource(page, perPage, "")
+}
+
+// ListBySource returns pricelists with optional source filter.
+func (s *Service) ListBySource(page, perPage int, source string) ([]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.ListBySource(source, offset, perPage)
+}
+
+// ListActive returns active pricelists with pagination.
+func (s *Service) ListActive(page, perPage int) ([]models.PricelistSummary, int64, error) {
+	return s.ListActiveBySource(page, perPage, "")
+}
+
+// ListActiveBySource returns active pricelists with optional source filter.
+func (s *Service) ListActiveBySource(page, perPage int, source string) ([]models.PricelistSummary, int64, error) {
+	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.ListActiveBySource(source, 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)
+}
+
+// SetActive toggles active state for a pricelist.
+func (s *Service) SetActive(id uint, isActive bool) error {
+	if s.repo == nil {
+		return fmt.Errorf("offline mode: cannot update pricelists")
+	}
+	return s.repo.SetActive(id, isActive)
+}
+
+// GetPriceForLot returns price by pricelist/lot.
+func (s *Service) GetPriceForLot(pricelistID uint, lotName string) (float64, error) {
+	if s.repo == nil {
+		return 0, fmt.Errorf("offline mode: pricelist service not available")
+	}
+	return s.repo.GetPriceForLot(pricelistID, lotName)
+}
+
+// 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) {
+	return s.GetLatestActiveBySource(string(models.PricelistSourceEstimate))
+}
+
+// GetLatestActiveBySource returns the latest active pricelist for a source.
+func (s *Service) GetLatestActiveBySource(source string) (*models.Pricelist, error) {
+	if s.repo == nil {
+		return nil, fmt.Errorf("offline mode: pricelist service not available")
+	}
+	return s.repo.GetLatestActiveBySource(source)
+}
+
+// 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

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,378 @@
+package pricing
+
+import (
+	"strings"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"gorm.io/gorm"
+)
+
+type Service struct {
+	componentRepo *repository.ComponentRepository
+	priceRepo     *repository.PriceRepository
+	config        config.PricingConfig
+	db            *gorm.DB
+}
+
+type RecalculateProgress struct {
+	Current int
+	Total   int
+	LotName string
+	Updated int
+	Errors  int
+}
+
+func NewService(
+	componentRepo *repository.ComponentRepository,
+	priceRepo *repository.PriceRepository,
+	cfg config.PricingConfig,
+) *Service {
+	var db *gorm.DB
+	if componentRepo != nil {
+		db = componentRepo.DB()
+	}
+
+	return &Service{
+		componentRepo: componentRepo,
+		priceRepo:     priceRepo,
+		config:        cfg,
+		db:            db,
+	}
+}
+
+// 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) {
+	return s.RecalculateAllPricesWithProgress(nil)
+}
+
+// RecalculateAllPricesWithProgress recalculates prices and reports progress.
+func (s *Service) RecalculateAllPricesWithProgress(onProgress func(RecalculateProgress)) (updated int, errors int) {
+	if s.db == nil {
+		return 0, 0
+	}
+
+	// Logic mirrors "Обновить цены" in admin pricing.
+	var components []models.LotMetadata
+	if err := s.db.Find(&components).Error; err != nil {
+		return 0, len(components)
+	}
+	total := len(components)
+
+	var allLotNames []string
+	_ = s.db.Model(&models.LotMetadata{}).Pluck("lot_name", &allLotNames).Error
+
+	type lotDate struct {
+		Lot  string
+		Date time.Time
+	}
+	var latestDates []lotDate
+	_ = s.db.Raw(`SELECT lot, MAX(date) as date FROM lot_log GROUP BY lot`).Scan(&latestDates).Error
+	lotLatestDate := make(map[string]time.Time, len(latestDates))
+	for _, ld := range latestDates {
+		lotLatestDate[ld.Lot] = ld.Date
+	}
+
+	var skipped, manual, unchanged int
+	now := time.Now()
+	current := 0
+
+	for _, comp := range components {
+		current++
+		reportProgress := func() {
+			if onProgress != nil && (current%10 == 0 || current == total) {
+				onProgress(RecalculateProgress{
+					Current: current,
+					Total:   total,
+					LotName: comp.LotName,
+					Updated: updated,
+					Errors:  errors,
+				})
+			}
+		}
+
+		if comp.ManualPrice != nil && *comp.ManualPrice > 0 {
+			manual++
+			reportProgress()
+			continue
+		}
+
+		method := comp.PriceMethod
+		if method == "" {
+			method = models.PriceMethodMedian
+		}
+
+		var sourceLots []string
+		if comp.MetaPrices != "" {
+			sourceLots = expandMetaPricesWithCache(comp.MetaPrices, comp.LotName, allLotNames)
+		} else {
+			sourceLots = []string{comp.LotName}
+		}
+		if len(sourceLots) == 0 {
+			skipped++
+			reportProgress()
+			continue
+		}
+
+		if comp.PriceUpdatedAt != nil {
+			hasNewData := false
+			for _, lot := range sourceLots {
+				if latestDate, ok := lotLatestDate[lot]; ok && latestDate.After(*comp.PriceUpdatedAt) {
+					hasNewData = true
+					break
+				}
+			}
+			if !hasNewData {
+				unchanged++
+				reportProgress()
+				continue
+			}
+		}
+
+		var prices []float64
+		if comp.PricePeriodDays > 0 {
+			_ = s.db.Raw(
+				`SELECT price FROM lot_log WHERE lot IN ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
+				sourceLots, comp.PricePeriodDays,
+			).Pluck("price", &prices).Error
+		} else {
+			_ = s.db.Raw(
+				`SELECT price FROM lot_log WHERE lot IN ? ORDER BY price`,
+				sourceLots,
+			).Pluck("price", &prices).Error
+		}
+
+		if len(prices) == 0 && comp.PricePeriodDays > 0 {
+			_ = s.db.Raw(`SELECT price FROM lot_log WHERE lot IN ? ORDER BY price`, sourceLots).Pluck("price", &prices).Error
+		}
+		if len(prices) == 0 {
+			skipped++
+			reportProgress()
+			continue
+		}
+
+		var basePrice float64
+		switch method {
+		case models.PriceMethodAverage:
+			basePrice = CalculateAverage(prices)
+		default:
+			basePrice = CalculateMedian(prices)
+		}
+		if basePrice <= 0 {
+			skipped++
+			reportProgress()
+			continue
+		}
+
+		finalPrice := basePrice
+		if comp.PriceCoefficient != 0 {
+			finalPrice = finalPrice * (1 + comp.PriceCoefficient/100)
+		}
+
+		if err := s.db.Model(&models.LotMetadata{}).
+			Where("lot_name = ?", comp.LotName).
+			Updates(map[string]interface{}{
+				"current_price":    finalPrice,
+				"price_updated_at": now,
+			}).Error; err != nil {
+			errors++
+		} else {
+			updated++
+		}
+
+		reportProgress()
+	}
+
+	if onProgress != nil && total == 0 {
+		onProgress(RecalculateProgress{
+			Current: 0,
+			Total:   0,
+			LotName: "",
+			Updated: updated,
+			Errors:  errors,
+		})
+	}
+
+	return updated, errors
+}
+
+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, "*") {
+			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/services/project.go

@@ -16,10 +16,8 @@ import (
 )
 
 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")
+	ErrProjectNotFound  = errors.New("project not found")
+	ErrProjectForbidden = errors.New("access to project forbidden")
 )
 
 type ProjectService struct {
@@ -31,16 +29,12 @@ func NewProjectService(localDB *localdb.LocalDB) *ProjectService {
 }
 
 type CreateProjectRequest struct {
-	Code       string `json:"code"`
-	Variant    string `json:"variant,omitempty"`
-	Name       *string `json:"name,omitempty"`
+	Name       string `json:"name"`
 	TrackerURL string `json:"tracker_url"`
 }
 
 type UpdateProjectRequest struct {
-	Code       *string `json:"code,omitempty"`
-	Variant    *string `json:"variant,omitempty"`
-	Name       *string `json:"name,omitempty"`
+	Name       string  `json:"name"`
 	TrackerURL *string `json:"tracker_url,omitempty"`
 }
 
@@ -51,30 +45,17 @@ type ProjectConfigurationsResult struct {
 }
 
 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
+	name := strings.TrimSpace(req.Name)
+	if name == "" {
+		return nil, fmt.Errorf("project name is required")
 	}
 
 	now := time.Now()
 	localProject := &localdb.LocalProject{
 		UUID:          uuid.NewString(),
 		OwnerUsername: ownerUsername,
-		Code:          code,
-		Variant:       variant,
-		Name:          namePtr,
-		TrackerURL:    normalizeProjectTrackerURL(code, req.TrackerURL),
+		Name:          name,
+		TrackerURL:    normalizeProjectTrackerURL(name, req.TrackerURL),
 		IsActive:      true,
 		IsSystem:      false,
 		CreatedAt:     now,
@@ -95,33 +76,20 @@ func (s *ProjectService) Update(projectUUID, ownerUsername string, req *UpdatePr
 	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 localProject.OwnerUsername != ownerUsername {
+		return nil, ErrProjectForbidden
 	}
 
-	if req.Name != nil {
-		name := strings.TrimSpace(*req.Name)
-		if name == "" {
-			localProject.Name = nil
-		} else {
-			localProject.Name = &name
-		}
+	name := strings.TrimSpace(req.Name)
+	if name == "" {
+		return nil, fmt.Errorf("project name is required")
 	}
+
+	localProject.Name = name
 	if req.TrackerURL != nil {
-		localProject.TrackerURL = normalizeProjectTrackerURL(localProject.Code, *req.TrackerURL)
+		localProject.TrackerURL = normalizeProjectTrackerURL(name, *req.TrackerURL)
 	} else if strings.TrimSpace(localProject.TrackerURL) == "" {
-		localProject.TrackerURL = normalizeProjectTrackerURL(localProject.Code, "")
+		localProject.TrackerURL = normalizeProjectTrackerURL(name, "")
 	}
 	localProject.UpdatedAt = time.Now()
 	localProject.SyncStatus = "pending"
@@ -134,38 +102,6 @@ func (s *ProjectService) Update(projectUUID, ownerUsername string, req *UpdatePr
 	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)
 }
@@ -174,23 +110,15 @@ 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.OwnerUsername != ownerUsername {
+			return ErrProjectForbidden
+		}
 		if project.IsActive == isActive {
 			return nil
 		}
@@ -275,8 +203,8 @@ func (s *ProjectService) ListConfigurations(projectUUID, ownerUsername, status s
 		}, nil
 	}
 
-	var localConfigs []localdb.LocalConfiguration
-	if err := s.localDB.DB().Preload("CurrentVersion").Order("created_at DESC").Find(&localConfigs).Error; err != nil {
+	localConfigs, err := s.localDB.GetConfigurations()
+	if err != nil {
 		return nil, err
 	}
 

internal/services/quote.go

@@ -2,13 +2,11 @@ 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 (
@@ -22,14 +20,7 @@ type QuoteService struct {
 	statsRepo      *repository.StatsRepository
 	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)
+	pricingService *pricing.Service
 }
 
 func NewQuoteService(
@@ -37,7 +28,7 @@ func NewQuoteService(
 	statsRepo *repository.StatsRepository,
 	pricelistRepo *repository.PricelistRepository,
 	localDB *localdb.LocalDB,
-	pricingService priceResolver,
+	pricingService *pricing.Service,
 ) *QuoteService {
 	return &QuoteService{
 		componentRepo:  componentRepo,
@@ -45,16 +36,9 @@ func NewQuoteService(
 		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"`
@@ -78,7 +62,6 @@ 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 {
@@ -87,7 +70,6 @@ type PriceLevelsRequest struct {
 		Quantity int    `json:"quantity"`
 	} `json:"items"`
 	PricelistIDs map[string]uint `json:"pricelist_ids,omitempty"`
-	NoCache      bool            `json:"no_cache,omitempty"`
 }
 
 type PriceLevelsItem struct {
@@ -114,69 +96,8 @@ func (s *QuoteService) ValidateAndCalculate(req *QuoteRequest) (*QuoteValidation
 	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("quote calculation not available")
+		return nil, errors.New("offline mode: quote calculation not available")
 	}
 
 	result := &QuoteValidationResult{
@@ -249,55 +170,11 @@ func (s *QuoteService) CalculatePriceLevels(req *PriceLevelsRequest) (*PriceLeve
 		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 {
-			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,
@@ -305,17 +182,22 @@ func (s *QuoteService) CalculatePriceLevels(req *PriceLevelsRequest) (*PriceLeve
 			PriceMissing: make([]string, 0, 3),
 		}
 
-		if p, ok := levelBySource[models.PricelistSourceEstimate].prices[reqItem.LotName]; ok && p > 0 {
-			price := p
-			item.EstimatePrice = &price
+		estimatePrice, estimateID := s.lookupLevelPrice(models.PricelistSourceEstimate, reqItem.LotName, req.PricelistIDs)
+		warehousePrice, warehouseID := s.lookupLevelPrice(models.PricelistSourceWarehouse, reqItem.LotName, req.PricelistIDs)
+		competitorPrice, competitorID := s.lookupLevelPrice(models.PricelistSourceCompetitor, reqItem.LotName, req.PricelistIDs)
+
+		item.EstimatePrice = estimatePrice
+		item.WarehousePrice = warehousePrice
+		item.CompetitorPrice = competitorPrice
+
+		if estimateID != 0 {
+			result.ResolvedPricelistIDs[string(models.PricelistSourceEstimate)] = estimateID
 		}
-		if p, ok := levelBySource[models.PricelistSourceWarehouse].prices[reqItem.LotName]; ok && p > 0 {
-			price := p
-			item.WarehousePrice = &price
+		if warehouseID != 0 {
+			result.ResolvedPricelistIDs[string(models.PricelistSourceWarehouse)] = warehouseID
 		}
-		if p, ok := levelBySource[models.PricelistSourceCompetitor].prices[reqItem.LotName]; ok && p > 0 {
-			price := p
-			item.CompetitorPrice = &price
+		if competitorID != 0 {
+			result.ResolvedPricelistIDs[string(models.PricelistSourceCompetitor)] = competitorID
 		}
 
 		if item.EstimatePrice == nil {
@@ -338,93 +220,6 @@ func (s *QuoteService) CalculatePriceLevels(req *PriceLevelsRequest) (*PriceLeve
 	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

internal/services/stock_import_test.go

@@ -0,0 +1,256 @@
+package services
+
+import (
+	"archive/zip"
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+)
+
+func TestParseMXLRows(t *testing.T) {
+	content := strings.Join([]string{
+		`MOXCEL`,
+		`{16,2,{1,1,{"ru","Папка"}},0},1,`,
+		`{16,2,{1,1,{"ru","Артикул"}},0},2,`,
+		`{16,2,{1,1,{"ru","Описание"}},0},3,`,
+		`{16,2,{1,1,{"ru","Вендор"}},0},4,`,
+		`{16,2,{1,1,{"ru","Стоимость"}},0},5,`,
+		`{16,2,{1,1,{"ru","Свободно"}},0},6,`,
+		`{16,2,{1,1,{"ru","Серверы"}},0},1,`,
+		`{16,2,{1,1,{"ru","CPU_X"}},0},2,`,
+		`{16,2,{1,1,{"ru","Процессор"}},0},3,`,
+		`{16,2,{1,1,{"ru","AMD"}},0},4,`,
+		`{16,2,{1,1,{"ru","125,50"}},0},5,`,
+		`{16,2,{1,1,{"ru","10"}},0},6,`,
+	}, "\n")
+
+	rows, err := parseMXLRows([]byte(content))
+	if err != nil {
+		t.Fatalf("parseMXLRows: %v", err)
+	}
+	if len(rows) != 1 {
+		t.Fatalf("expected 1 row, got %d", len(rows))
+	}
+	if rows[0].Article != "CPU_X" {
+		t.Fatalf("unexpected article: %s", rows[0].Article)
+	}
+	if rows[0].Price != 125.50 {
+		t.Fatalf("unexpected price: %v", rows[0].Price)
+	}
+	if rows[0].Qty != 10 {
+		t.Fatalf("unexpected qty: %v", rows[0].Qty)
+	}
+}
+
+func TestParseXLSXRows(t *testing.T) {
+	xlsx := buildMinimalXLSX(t, []string{
+		"Папка", "Артикул", "Описание", "Вендор", "Стоимость", "Свободно",
+	}, []string{
+		"Серверы", "CPU_A", "Процессор", "AMD", "99,25", "7",
+	})
+
+	rows, err := parseXLSXRows(xlsx)
+	if err != nil {
+		t.Fatalf("parseXLSXRows: %v", err)
+	}
+	if len(rows) != 1 {
+		t.Fatalf("expected 1 row, got %d", len(rows))
+	}
+	if rows[0].Article != "CPU_A" {
+		t.Fatalf("unexpected article: %s", rows[0].Article)
+	}
+	if rows[0].Price != 99.25 {
+		t.Fatalf("unexpected price: %v", rows[0].Price)
+	}
+}
+
+func TestLotResolverPrecedenceAndConflicts(t *testing.T) {
+	r := &lotResolver{
+		partnumberToLots: map[string][]string{
+			"pn-1":        {"LOT_MAPPED"},
+			"pn-conflict": {"LOT_A", "LOT_B"},
+		},
+		exactLots: map[string]string{
+			"cpu_a": "CPU_A",
+		},
+		allLots: []string{"CPU_A_LONG", "CPU_A", "ABC ", "ABC\t"},
+	}
+
+	lot, typ, err := r.resolve("pn-1")
+	if err != nil || lot != "LOT_MAPPED" || typ != "mapping_table" {
+		t.Fatalf("mapping_table mismatch: lot=%s typ=%s err=%v", lot, typ, err)
+	}
+
+	lot, typ, err = r.resolve("cpu_a")
+	if err != nil || lot != "CPU_A" || typ != "article_exact" {
+		t.Fatalf("article_exact mismatch: lot=%s typ=%s err=%v", lot, typ, err)
+	}
+
+	lot, typ, err = r.resolve("cpu_a_long_suffix")
+	if err != nil || lot != "CPU_A_LONG" || typ != "prefix" {
+		t.Fatalf("prefix mismatch: lot=%s typ=%s err=%v", lot, typ, err)
+	}
+
+	_, _, err = r.resolve("abx")
+	if err == nil {
+		t.Fatalf("expected not found error")
+	}
+
+	_, _, err = r.resolve("pn-conflict")
+	if err == nil || err != errResolveConflict {
+		t.Fatalf("expected conflict, got %v", err)
+	}
+}
+
+func TestImportNoValidRowsKeepsStockLog(t *testing.T) {
+	db := openTestDB(t)
+	if err := db.AutoMigrate(&models.StockLog{}); err != nil {
+		t.Fatalf("automigrate stock_log: %v", err)
+	}
+
+	existing := models.StockLog{
+		Lot:   "CPU_A",
+		Date:  time.Now(),
+		Price: 10,
+	}
+	if err := db.Create(&existing).Error; err != nil {
+		t.Fatalf("seed stock_log: %v", err)
+	}
+
+	svc := NewStockImportService(db, nil)
+	headerOnly := []byte(strings.Join([]string{
+		`MOXCEL`,
+		`{16,2,{1,1,{"ru","Папка"}},0},1,`,
+		`{16,2,{1,1,{"ru","Артикул"}},0},2,`,
+		`{16,2,{1,1,{"ru","Описание"}},0},3,`,
+		`{16,2,{1,1,{"ru","Вендор"}},0},4,`,
+		`{16,2,{1,1,{"ru","Стоимость"}},0},5,`,
+		`{16,2,{1,1,{"ru","Свободно"}},0},6,`,
+	}, "\n"))
+
+	if _, err := svc.Import("test.mxl", headerOnly, time.Now(), "tester", nil); err == nil {
+		t.Fatalf("expected import error")
+	}
+
+	var count int64
+	if err := db.Model(&models.StockLog{}).Count(&count).Error; err != nil {
+		t.Fatalf("count stock_log: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("expected stock_log unchanged, got %d rows", count)
+	}
+}
+
+func TestReplaceStockLogs(t *testing.T) {
+	db := openTestDB(t)
+	if err := db.AutoMigrate(&models.StockLog{}); err != nil {
+		t.Fatalf("automigrate stock_log: %v", err)
+	}
+
+	if err := db.Create(&models.StockLog{Lot: "OLD", Date: time.Now(), Price: 1}).Error; err != nil {
+		t.Fatalf("seed old row: %v", err)
+	}
+
+	svc := NewStockImportService(db, nil)
+	records := []models.StockLog{
+		{Lot: "NEW_1", Date: time.Now(), Price: 2},
+		{Lot: "NEW_2", Date: time.Now(), Price: 3},
+	}
+
+	deleted, inserted, err := svc.replaceStockLogs(records)
+	if err != nil {
+		t.Fatalf("replaceStockLogs: %v", err)
+	}
+	if deleted != 1 || inserted != 2 {
+		t.Fatalf("unexpected replace stats deleted=%d inserted=%d", deleted, inserted)
+	}
+
+	var rows []models.StockLog
+	if err := db.Order("lot").Find(&rows).Error; err != nil {
+		t.Fatalf("read rows: %v", err)
+	}
+	if len(rows) != 2 || rows[0].Lot != "NEW_1" || rows[1].Lot != "NEW_2" {
+		t.Fatalf("unexpected rows after replace: %#v", rows)
+	}
+}
+
+func openTestDB(t *testing.T) *gorm.DB {
+	t.Helper()
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+	return db
+}
+
+func buildMinimalXLSX(t *testing.T, headers, values []string) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+
+	write := func(name, body string) {
+		w, err := zw.Create(name)
+		if err != nil {
+			t.Fatalf("create zip entry %s: %v", name, err)
+		}
+		if _, err := w.Write([]byte(body)); err != nil {
+			t.Fatalf("write zip entry %s: %v", name, err)
+		}
+	}
+
+	write("[Content_Types].xml", `<?xml version="1.0" encoding="UTF-8"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+  <Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>
+</Types>`)
+	write("_rels/.rels", `<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+</Relationships>`)
+	write("xl/workbook.xml", `<?xml version="1.0" encoding="UTF-8"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <sheets>
+    <sheet name="Sheet1" sheetId="1" r:id="rId1" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"/>
+  </sheets>
+</workbook>`)
+	write("xl/_rels/workbook.xml.rels", `<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>
+</Relationships>`)
+
+	makeCell := func(ref, value string) string {
+		escaped := strings.ReplaceAll(value, "&", "&amp;")
+		escaped = strings.ReplaceAll(escaped, "<", "&lt;")
+		escaped = strings.ReplaceAll(escaped, ">", "&gt;")
+		return `<c r="` + ref + `" t="inlineStr"><is><t>` + escaped + `</t></is></c>`
+	}
+
+	cols := []string{"A", "B", "C", "D", "E", "F"}
+	var headerCells, valueCells strings.Builder
+	for i := 0; i < len(cols) && i < len(headers); i++ {
+		headerCells.WriteString(makeCell(cols[i]+"1", headers[i]))
+	}
+	for i := 0; i < len(cols) && i < len(values); i++ {
+		valueCells.WriteString(makeCell(cols[i]+"2", values[i]))
+	}
+
+	write("xl/worksheets/sheet1.xml", `<?xml version="1.0" encoding="UTF-8"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <sheetData>
+    <row r="1">`+headerCells.String()+`</row>
+    <row r="2">`+valueCells.String()+`</row>
+  </sheetData>
+</worksheet>`)
+
+	if err := zw.Close(); err != nil {
+		t.Fatalf("close zip: %v", err)
+	}
+	return buf.Bytes()
+}

internal/services/sync/readiness.go

@@ -1,410 +0,0 @@
-package sync
-
-import (
-	"bufio"
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"log/slog"
-	"strconv"
-	"strings"
-	"time"
-
-	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
-	"git.mchus.pro/mchus/quoteforge/internal/localdb"
-	"gorm.io/gorm"
-)
-
-const (
-	ReadinessReady   = "ready"
-	ReadinessBlocked = "blocked"
-	ReadinessUnknown = "unknown"
-)
-
-var ErrSyncBlockedByReadiness = errors.New("sync blocked by readiness guard")
-
-type SyncReadiness 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"`
-}
-
-type SyncBlockedError struct {
-	Readiness SyncReadiness
-}
-
-func (e *SyncBlockedError) Error() string {
-	if e == nil {
-		return ErrSyncBlockedByReadiness.Error()
-	}
-	if strings.TrimSpace(e.Readiness.ReasonText) != "" {
-		return e.Readiness.ReasonText
-	}
-	return ErrSyncBlockedByReadiness.Error()
-}
-
-func (s *Service) EnsureReadinessForSync() (*SyncReadiness, error) {
-	readiness, err := s.GetReadiness()
-	if err != nil {
-		return nil, err
-	}
-	if readiness.Blocked {
-		return readiness, &SyncBlockedError{Readiness: *readiness}
-	}
-	return readiness, nil
-}
-
-func (s *Service) GetReadiness() (*SyncReadiness, error) {
-	now := time.Now().UTC()
-	if !s.isOnline() {
-		return s.blockedReadiness(
-			now,
-			"OFFLINE_UNVERIFIED_SCHEMA",
-			"Синхронизация недоступна: нет соединения с сервером и нельзя проверить миграции локальной БД.",
-			nil,
-		)
-	}
-
-	mariaDB, err := s.getDB()
-	if err != nil || mariaDB == nil {
-		return s.blockedReadiness(
-			now,
-			"OFFLINE_UNVERIFIED_SCHEMA",
-			"Синхронизация недоступна: нет соединения с сервером и нельзя проверить миграции локальной БД.",
-			nil,
-		)
-	}
-
-	migrations, err := listActiveClientMigrations(mariaDB)
-	if err != nil {
-		return s.blockedReadiness(
-			now,
-			"REMOTE_MIGRATION_REGISTRY_UNAVAILABLE",
-			"Синхронизация заблокирована: не удалось проверить централизованные миграции локальной БД.",
-			nil,
-		)
-	}
-
-	for i := range migrations {
-		m := migrations[i]
-		if strings.TrimSpace(m.MinAppVersion) != "" {
-			if compareVersions(appmeta.Version(), m.MinAppVersion) < 0 {
-				min := m.MinAppVersion
-				return s.blockedReadiness(
-					now,
-					"MIN_APP_VERSION_REQUIRED",
-					fmt.Sprintf("Требуется обновление приложения до версии %s для безопасной синхронизации.", m.MinAppVersion),
-					&min,
-				)
-			}
-		}
-	}
-
-	if err := s.applyMissingRemoteMigrations(migrations); err != nil {
-		if strings.Contains(strings.ToLower(err.Error()), "checksum") {
-			return s.blockedReadiness(
-				now,
-				"REMOTE_MIGRATION_CHECKSUM_MISMATCH",
-				"Синхронизация заблокирована: контрольная сумма миграции не совпадает.",
-				nil,
-			)
-		}
-		return s.blockedReadiness(
-			now,
-			"LOCAL_MIGRATION_APPLY_FAILED",
-			"Синхронизация заблокирована: не удалось применить миграции локальной БД.",
-			nil,
-		)
-	}
-
-	if err := s.reportClientSchemaState(mariaDB, now); err != nil {
-		slog.Warn("failed to report client schema state", "error", err)
-	}
-
-	ready := &SyncReadiness{Status: ReadinessReady, Blocked: false, LastCheckedAt: &now}
-	if setErr := s.localDB.SetSyncGuardState(ReadinessReady, "", "", nil, &now); setErr != nil {
-		slog.Warn("failed to persist sync guard state", "error", setErr)
-	}
-	return ready, nil
-}
-
-func (s *Service) blockedReadiness(now time.Time, code, text string, minVersion *string) (*SyncReadiness, error) {
-	readiness := &SyncReadiness{
-		Status:                ReadinessBlocked,
-		Blocked:               true,
-		ReasonCode:            code,
-		ReasonText:            text,
-		RequiredMinAppVersion: minVersion,
-		LastCheckedAt:         &now,
-	}
-	if err := s.localDB.SetSyncGuardState(ReadinessBlocked, code, text, minVersion, &now); err != nil {
-		slog.Warn("failed to persist blocked sync guard state", "error", err)
-	}
-	return readiness, nil
-}
-
-func (s *Service) isOnline() bool {
-	if s.directDB != nil {
-		return true
-	}
-	if s.connMgr == nil {
-		return false
-	}
-	return s.connMgr.IsOnline()
-}
-
-type clientLocalMigration struct {
-	ID            string    `gorm:"column:id"`
-	Name          string    `gorm:"column:name"`
-	SQLText       string    `gorm:"column:sql_text"`
-	Checksum      string    `gorm:"column:checksum"`
-	MinAppVersion string    `gorm:"column:min_app_version"`
-	OrderNo       int       `gorm:"column:order_no"`
-	CreatedAt     time.Time `gorm:"column:created_at"`
-}
-
-func listActiveClientMigrations(db *gorm.DB) ([]clientLocalMigration, error) {
-	if strings.EqualFold(db.Dialector.Name(), "sqlite") {
-		return []clientLocalMigration{}, nil
-	}
-	if err := ensureClientMigrationRegistryTable(db); err != nil {
-		return nil, err
-	}
-
-	rows := make([]clientLocalMigration, 0)
-	if err := db.Raw(`
-		SELECT id, name, sql_text, checksum, COALESCE(min_app_version, '') AS min_app_version, order_no, created_at
-		FROM qt_client_local_migrations
-		WHERE is_active = 1
-		ORDER BY order_no ASC, created_at ASC, id ASC
-	`).Scan(&rows).Error; err != nil {
-		return nil, fmt.Errorf("load client local migrations: %w", err)
-	}
-
-	return rows, nil
-}
-
-func ensureClientMigrationRegistryTable(db *gorm.DB) error {
-	// Check if table exists instead of trying to create (avoids permission issues)
-	if !tableExists(db, "qt_client_local_migrations") {
-		if err := db.Exec(`
-			CREATE TABLE IF NOT EXISTS qt_client_local_migrations (
-				id VARCHAR(128) NOT NULL,
-				name VARCHAR(255) NOT NULL,
-				sql_text LONGTEXT NOT NULL,
-				checksum VARCHAR(128) NOT NULL,
-				min_app_version VARCHAR(64) NULL,
-				order_no INT NOT NULL DEFAULT 0,
-				is_active TINYINT(1) NOT NULL DEFAULT 1,
-				created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-				PRIMARY KEY (id),
-				INDEX idx_qt_client_local_migrations_active_order (is_active, order_no, created_at)
-			)
-		`).Error; err != nil {
-			return fmt.Errorf("create qt_client_local_migrations table: %w", err)
-		}
-	}
-
-	if !tableExists(db, "qt_client_schema_state") {
-		if err := db.Exec(`
-			CREATE TABLE IF NOT EXISTS qt_client_schema_state (
-				username VARCHAR(100) NOT NULL,
-				last_applied_migration_id VARCHAR(128) NULL,
-				app_version VARCHAR(64) NULL,
-				last_checked_at DATETIME NOT NULL,
-				updated_at DATETIME NOT NULL,
-				PRIMARY KEY (username),
-				INDEX idx_qt_client_schema_state_checked (last_checked_at)
-			)
-		`).Error; err != nil {
-			return fmt.Errorf("create qt_client_schema_state table: %w", err)
-		}
-	}
-	return nil
-}
-
-func tableExists(db *gorm.DB, tableName string) bool {
-	var count int64
-	// For MariaDB/MySQL, check information_schema
-	if err := db.Raw(`
-		SELECT COUNT(*) FROM information_schema.TABLES
-		WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
-	`, tableName).Scan(&count).Error; err != nil {
-		return false
-	}
-	return count > 0
-}
-
-func (s *Service) applyMissingRemoteMigrations(migrations []clientLocalMigration) error {
-	for i := range migrations {
-		m := migrations[i]
-		computedChecksum := digestSQL(m.SQLText)
-		checksum := strings.TrimSpace(m.Checksum)
-		if checksum == "" {
-			checksum = computedChecksum
-		} else if !strings.EqualFold(checksum, computedChecksum) {
-			return fmt.Errorf("checksum mismatch for migration %s", m.ID)
-		}
-
-		applied, err := s.localDB.GetRemoteMigrationApplied(m.ID)
-		if err == nil {
-			if strings.TrimSpace(applied.Checksum) != checksum {
-				return fmt.Errorf("checksum mismatch for migration %s", m.ID)
-			}
-			continue
-		}
-		if !errors.Is(err, gorm.ErrRecordNotFound) {
-			return fmt.Errorf("check local applied migration %s: %w", m.ID, err)
-		}
-
-		if strings.TrimSpace(m.SQLText) == "" {
-			if err := s.localDB.UpsertRemoteMigrationApplied(m.ID, checksum, appmeta.Version(), time.Now().UTC()); err != nil {
-				return fmt.Errorf("mark empty migration %s as applied: %w", m.ID, err)
-			}
-			continue
-		}
-
-		statements := splitSQLStatementsLite(m.SQLText)
-		if err := s.localDB.DB().Transaction(func(tx *gorm.DB) error {
-			for _, stmt := range statements {
-				if err := tx.Exec(stmt).Error; err != nil {
-					return fmt.Errorf("apply migration %s statement %q: %w", m.ID, stmt, err)
-				}
-			}
-			return nil
-		}); err != nil {
-			return err
-		}
-
-		if err := s.localDB.UpsertRemoteMigrationApplied(m.ID, checksum, appmeta.Version(), time.Now().UTC()); err != nil {
-			return fmt.Errorf("record applied migration %s: %w", m.ID, err)
-		}
-	}
-	return nil
-}
-
-func splitSQLStatementsLite(script string) []string {
-	scanner := bufio.NewScanner(strings.NewReader(script))
-	scanner.Buffer(make([]byte, 1024), 1024*1024)
-
-	lines := make([]string, 0, 64)
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line == "" || 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 digestSQL(sqlText string) string {
-	hash := sha256.Sum256([]byte(sqlText))
-	return hex.EncodeToString(hash[:])
-}
-
-func compareVersions(left, right string) int {
-	leftParts := normalizeVersionParts(left)
-	rightParts := normalizeVersionParts(right)
-	maxLen := len(leftParts)
-	if len(rightParts) > maxLen {
-		maxLen = len(rightParts)
-	}
-	for i := 0; i < maxLen; i++ {
-		lv := 0
-		rv := 0
-		if i < len(leftParts) {
-			lv = leftParts[i]
-		}
-		if i < len(rightParts) {
-			rv = rightParts[i]
-		}
-		if lv < rv {
-			return -1
-		}
-		if lv > rv {
-			return 1
-		}
-	}
-	return 0
-}
-
-func (s *Service) reportClientSchemaState(mariaDB *gorm.DB, checkedAt time.Time) error {
-	if strings.EqualFold(mariaDB.Dialector.Name(), "sqlite") {
-		return nil
-	}
-	username := strings.TrimSpace(s.localDB.GetDBUser())
-	if username == "" {
-		return nil
-	}
-	lastMigrationID := ""
-	if id, err := s.localDB.GetLatestAppliedRemoteMigrationID(); err == nil {
-		lastMigrationID = id
-	}
-	return mariaDB.Exec(`
-		INSERT INTO qt_client_schema_state (username, last_applied_migration_id, app_version, last_checked_at, updated_at)
-		VALUES (?, ?, ?, ?, ?)
-		ON DUPLICATE KEY UPDATE
-			last_applied_migration_id = VALUES(last_applied_migration_id),
-			app_version = VALUES(app_version),
-			last_checked_at = VALUES(last_checked_at),
-			updated_at = VALUES(updated_at)
-	`, username, lastMigrationID, appmeta.Version(), checkedAt, checkedAt).Error
-}
-
-func normalizeVersionParts(v string) []int {
-	trimmed := strings.TrimSpace(v)
-	trimmed = strings.TrimPrefix(trimmed, "v")
-	chunks := strings.Split(trimmed, ".")
-	parts := make([]int, 0, len(chunks))
-	for _, chunk := range chunks {
-		clean := strings.TrimSpace(chunk)
-		if clean == "" {
-			parts = append(parts, 0)
-			continue
-		}
-		n := 0
-		for i := 0; i < len(clean); i++ {
-			if clean[i] < '0' || clean[i] > '9' {
-				clean = clean[:i]
-				break
-			}
-		}
-		if clean != "" {
-			if parsed, err := strconv.Atoi(clean); err == nil {
-				n = parsed
-			}
-		}
-		parts = append(parts, n)
-	}
-	return parts
-}
-
-func toReadinessFromState(state *localdb.LocalSyncGuardState) *SyncReadiness {
-	if state == nil {
-		return nil
-	}
-	blocked := state.Status == ReadinessBlocked
-	return &SyncReadiness{
-		Status:                state.Status,
-		Blocked:               blocked,
-		ReasonCode:            state.ReasonCode,
-		ReasonText:            state.ReasonText,
-		RequiredMinAppVersion: state.RequiredMinAppVersion,
-		LastCheckedAt:         state.LastCheckedAt,
-	}
-}

internal/services/sync/service.go

@@ -200,7 +200,6 @@ func (s *Service) ImportProjectsToLocal() (*ProjectImportResult, error) {
 				}
 
 				existing.OwnerUsername = project.OwnerUsername
-				existing.Code = project.Code
 				existing.Name = project.Name
 				existing.TrackerURL = project.TrackerURL
 				existing.IsActive = project.IsActive
@@ -323,9 +322,6 @@ func (s *Service) NeedSync() (bool, error) {
 // SyncPricelists synchronizes all active pricelists from server to local SQLite
 func (s *Service) SyncPricelists() (int, error) {
 	slog.Info("starting pricelist sync")
-	if _, err := s.EnsureReadinessForSync(); err != nil {
-		return 0, err
-	}
 
 	// Get database connection
 	mariaDB, err := s.getDB()
@@ -341,24 +337,18 @@ func (s *Service) SyncPricelists() (int, error) {
 	if err != nil {
 		return 0, fmt.Errorf("getting active server pricelists: %w", err)
 	}
-	serverPricelistIDs := make([]uint, 0, len(serverPricelists))
-	for i := range serverPricelists {
-		serverPricelistIDs = append(serverPricelistIDs, serverPricelists[i].ID)
-	}
 
 	synced := 0
+	var latestEstimateLocalID uint
+	var latestEstimateCreatedAt time.Time
 	for _, pl := range serverPricelists {
 		// Check if pricelist already exists locally
 		existing, _ := s.localDB.GetLocalPricelistByServerID(pl.ID)
 		if existing != nil {
-			// Backfill items for legacy/partial local caches where only pricelist metadata exists.
-			if s.localDB.CountLocalPricelistItems(existing.ID) == 0 {
-				itemCount, err := s.SyncPricelistItems(existing.ID)
-				if err != nil {
-					slog.Warn("failed to sync missing pricelist items for existing local pricelist", "version", pl.Version, "error", err)
-				} else {
-					slog.Info("synced missing pricelist items for existing local pricelist", "version", pl.Version, "items", itemCount)
-				}
+			// Track latest estimate pricelist by created_at for component refresh.
+			if pl.Source == string(models.PricelistSourceEstimate) && (latestEstimateCreatedAt.IsZero() || pl.CreatedAt.After(latestEstimateCreatedAt)) {
+				latestEstimateCreatedAt = pl.CreatedAt
+				latestEstimateLocalID = existing.ID
 			}
 			continue
 		}
@@ -388,19 +378,23 @@ func (s *Service) SyncPricelists() (int, error) {
 			slog.Debug("synced pricelist with items", "version", pl.Version, "items", itemCount)
 		}
 
+		if pl.Source == string(models.PricelistSourceEstimate) && (latestEstimateCreatedAt.IsZero() || pl.CreatedAt.After(latestEstimateCreatedAt)) {
+			latestEstimateCreatedAt = pl.CreatedAt
+			latestEstimateLocalID = localPL.ID
+		}
 		synced++
 	}
 
-	removed, err := s.localDB.DeleteUnusedLocalPricelistsMissingOnServer(serverPricelistIDs)
-	if err != nil {
-		slog.Warn("failed to cleanup stale local pricelists", "error", err)
-	} else if removed > 0 {
-		slog.Info("deleted stale local pricelists", "deleted", removed)
+	// Update component prices from latest estimate pricelist only.
+	if latestEstimateLocalID > 0 {
+		updated, err := s.localDB.UpdateComponentPricesFromPricelist(latestEstimateLocalID)
+		if err != nil {
+			slog.Warn("failed to update component prices from pricelist", "error", err)
+		} else {
+			slog.Info("updated component prices from latest pricelist", "updated", updated)
+		}
 	}
 
-	// Backfill lot_category for used pricelists (older local caches may miss the column values).
-	s.backfillUsedPricelistItemCategories(pricelistRepo, serverPricelistIDs)
-
 	// Update last sync time
 	s.localDB.SetLastSyncTime(time.Now())
 	s.RecordSyncHeartbeat()
@@ -409,83 +403,6 @@ func (s *Service) SyncPricelists() (int, error) {
 	return synced, nil
 }
 
-func (s *Service) backfillUsedPricelistItemCategories(pricelistRepo *repository.PricelistRepository, activeServerPricelistIDs []uint) {
-	if s.localDB == nil || pricelistRepo == nil {
-		return
-	}
-
-	activeSet := make(map[uint]struct{}, len(activeServerPricelistIDs))
-	for _, id := range activeServerPricelistIDs {
-		activeSet[id] = struct{}{}
-	}
-
-	type row struct {
-		ID uint `gorm:"column:id"`
-	}
-	var usedRows []row
-	if err := s.localDB.DB().Raw(`
-		SELECT DISTINCT pricelist_id AS id
-		FROM local_configurations
-		WHERE is_active = 1 AND pricelist_id IS NOT NULL
-		UNION
-		SELECT DISTINCT warehouse_pricelist_id AS id
-		FROM local_configurations
-		WHERE is_active = 1 AND warehouse_pricelist_id IS NOT NULL
-		UNION
-		SELECT DISTINCT competitor_pricelist_id AS id
-		FROM local_configurations
-		WHERE is_active = 1 AND competitor_pricelist_id IS NOT NULL
-	`).Scan(&usedRows).Error; err != nil {
-		slog.Warn("pricelist category backfill: failed to list used pricelists", "error", err)
-		return
-	}
-
-	for _, r := range usedRows {
-		serverID := r.ID
-		if serverID == 0 {
-			continue
-		}
-		if _, ok := activeSet[serverID]; !ok {
-			// Not present on server (or not active) - cannot backfill from remote.
-			continue
-		}
-
-		localPL, err := s.localDB.GetLocalPricelistByServerID(serverID)
-		if err != nil || localPL == nil {
-			continue
-		}
-
-		if s.localDB.CountLocalPricelistItems(localPL.ID) == 0 {
-			continue
-		}
-
-		missing, err := s.localDB.CountLocalPricelistItemsWithEmptyCategory(localPL.ID)
-		if err != nil {
-			slog.Warn("pricelist category backfill: failed to check local items", "server_id", serverID, "error", err)
-			continue
-		}
-		if missing == 0 {
-			continue
-		}
-
-		serverItems, _, err := pricelistRepo.GetItems(serverID, 0, 10000, "")
-		if err != nil {
-			slog.Warn("pricelist category backfill: failed to load server items", "server_id", serverID, "error", err)
-			continue
-		}
-		localItems := make([]localdb.LocalPricelistItem, len(serverItems))
-		for i := range serverItems {
-			localItems[i] = *localdb.PricelistItemToLocal(&serverItems[i], localPL.ID)
-		}
-
-		if err := s.localDB.ReplaceLocalPricelistItems(localPL.ID, localItems); err != nil {
-			slog.Warn("pricelist category backfill: failed to replace local items", "server_id", serverID, "error", err)
-			continue
-		}
-		slog.Info("pricelist category backfill: refreshed local items", "server_id", serverID, "items", len(localItems))
-	}
-}
-
 // RecordSyncHeartbeat updates shared sync heartbeat for current DB user.
 // Only users with write rights are expected to be able to update this table.
 func (s *Service) RecordSyncHeartbeat() {
@@ -622,34 +539,24 @@ func (s *Service) listConnectedDBUsers(mariaDB *gorm.DB) (map[string]struct{}, e
 }
 
 func ensureUserSyncStatusTable(db *gorm.DB) error {
-	// Check if table exists instead of trying to create (avoids permission issues)
-	if !tableExists(db, "qt_pricelist_sync_status") {
-		if err := db.Exec(`
-			CREATE TABLE IF NOT EXISTS qt_pricelist_sync_status (
-				username VARCHAR(100) NOT NULL,
-				last_sync_at DATETIME NOT NULL,
-				updated_at DATETIME NOT NULL,
-				app_version VARCHAR(64) NULL,
-				PRIMARY KEY (username),
-				INDEX idx_qt_pricelist_sync_status_last_sync (last_sync_at)
-			)
-		`).Error; err != nil {
-			return fmt.Errorf("create qt_pricelist_sync_status table: %w", err)
-		}
+	if err := db.Exec(`
+		CREATE TABLE IF NOT EXISTS qt_pricelist_sync_status (
+			username VARCHAR(100) NOT NULL,
+			last_sync_at DATETIME NOT NULL,
+			updated_at DATETIME NOT NULL,
+			app_version VARCHAR(64) NULL,
+			PRIMARY KEY (username),
+			INDEX idx_qt_pricelist_sync_status_last_sync (last_sync_at)
+		)
+	`).Error; err != nil {
+		return err
 	}
 
 	// Backward compatibility for environments where table was created without app_version.
-	// Only try to add column if table exists.
-	if tableExists(db, "qt_pricelist_sync_status") {
-		if err := db.Exec(`
-			ALTER TABLE qt_pricelist_sync_status
-			ADD COLUMN IF NOT EXISTS app_version VARCHAR(64) NULL
-		`).Error; err != nil {
-			// Log but don't fail if alter fails (column might already exist)
-			slog.Debug("failed to add app_version column", "error", err)
-		}
-	}
-	return nil
+	return db.Exec(`
+		ALTER TABLE qt_pricelist_sync_status
+		ADD COLUMN IF NOT EXISTS app_version VARCHAR(64) NULL
+	`).Error
 }
 
 // SyncPricelistItems synchronizes items for a specific pricelist
@@ -685,7 +592,11 @@ func (s *Service) SyncPricelistItems(localPricelistID uint) (int, error) {
 	// Convert and save locally
 	localItems := make([]localdb.LocalPricelistItem, len(serverItems))
 	for i, item := range serverItems {
-		localItems[i] = *localdb.PricelistItemToLocal(&item, localPricelistID)
+		localItems[i] = localdb.LocalPricelistItem{
+			PricelistID: localPricelistID,
+			LotName:     item.LotName,
+			Price:       item.Price,
+		}
 	}
 
 	if err := s.localDB.SaveLocalPricelistItems(localItems); err != nil {
@@ -761,10 +672,6 @@ func (s *Service) SyncPricelistsIfNeeded() error {
 
 // PushPendingChanges pushes all pending changes to the server
 func (s *Service) PushPendingChanges() (int, error) {
-	if _, err := s.EnsureReadinessForSync(); err != nil {
-		return 0, err
-	}
-
 	removed, err := s.localDB.PurgeOrphanConfigurationPendingChanges()
 	if err != nil {
 		slog.Warn("failed to purge orphan configuration pending changes", "error", err)
@@ -858,36 +765,11 @@ func (s *Service) pushProjectChange(change *localdb.PendingChange) error {
 	projectRepo := repository.NewProjectRepository(mariaDB)
 	project := payload.Snapshot
 	project.UUID = payload.ProjectUUID
-	if strings.TrimSpace(project.Code) == "" {
-		project.Code = strings.TrimSpace(derefString(project.Name))
-		if project.Code == "" {
-			project.Code = project.UUID
-		}
+
+	if err := projectRepo.UpsertByUUID(&project); err != nil {
+		return fmt.Errorf("upsert project on server: %w", err)
 	}
 
-	// Try upsert by UUID first
-	err = projectRepo.UpsertByUUID(&project)
-	if err != nil {
-		// Check if it's a duplicate (code, variant) constraint violation
-		// In this case, find existing project with same (code, variant) and link to it
-		var existing models.Project
-		lookupErr := mariaDB.Where("code = ? AND variant = ?", project.Code, project.Variant).First(&existing).Error
-		if lookupErr == nil {
-			// Found duplicate - link local project to existing server project
-			slog.Info("project duplicate found, linking to existing",
-				"local_uuid", project.UUID,
-				"server_uuid", existing.UUID,
-				"server_id", existing.ID,
-				"code", project.Code,
-				"variant", project.Variant)
-			project.ID = existing.ID
-		} else {
-			// Not a duplicate issue, return original error
-			return fmt.Errorf("upsert project on server: %w", err)
-		}
-	}
-
-	// Update local project with server ID
 	localProject, localErr := s.localDB.GetProjectByUUID(project.UUID)
 	if localErr == nil {
 		if project.ID > 0 {
@@ -903,17 +785,6 @@ func (s *Service) pushProjectChange(change *localdb.PendingChange) error {
 	return nil
 }
 
-func derefString(value *string) string {
-	if value == nil {
-		return ""
-	}
-	return *value
-}
-
-func ptrString(value string) *string {
-	return &value
-}
-
 func decodeProjectChangePayload(change *localdb.PendingChange) (ProjectChangePayload, error) {
 	var payload ProjectChangePayload
 	if err := json.Unmarshal([]byte(change.Payload), &payload); err == nil && payload.ProjectUUID != "" {
@@ -1184,8 +1055,7 @@ func (s *Service) ensureConfigurationProject(mariaDB *gorm.DB, cfg *models.Confi
 		systemProject = &models.Project{
 			UUID:          uuid.NewString(),
 			OwnerUsername: "",
-			Code:          "Без проекта",
-			Name:          ptrString("Без проекта"),
+			Name:          "Без проекта",
 			IsActive:      true,
 			IsSystem:      true,
 		}
@@ -1349,21 +1219,6 @@ func (s *Service) loadCurrentConfigurationState(configurationUUID string) (model
 		}
 	}
 
-	if currentVersionNo == 0 {
-		if err := s.repairMissingConfigurationVersion(localCfg); err != nil {
-			return models.Configuration{}, "", 0, fmt.Errorf("repair missing configuration version: %w", err)
-		}
-		var latest localdb.LocalConfigurationVersion
-		err = s.localDB.DB().
-			Where("configuration_uuid = ?", configurationUUID).
-			Order("version_no DESC").
-			First(&latest).Error
-		if err == nil {
-			currentVersionNo = latest.VersionNo
-			currentVersionID = latest.ID
-		}
-	}
-
 	if currentVersionNo == 0 {
 		return models.Configuration{}, "", 0, fmt.Errorf("no local configuration version found for %s", configurationUUID)
 	}
@@ -1371,64 +1226,6 @@ func (s *Service) loadCurrentConfigurationState(configurationUUID string) (model
 	return cfg, currentVersionID, currentVersionNo, nil
 }
 
-func (s *Service) repairMissingConfigurationVersion(localCfg *localdb.LocalConfiguration) error {
-	if localCfg == nil {
-		return fmt.Errorf("local configuration is nil")
-	}
-
-	return s.localDB.DB().Transaction(func(tx *gorm.DB) error {
-		var cfg localdb.LocalConfiguration
-		if err := tx.Where("uuid = ?", localCfg.UUID).First(&cfg).Error; err != nil {
-			return fmt.Errorf("load local configuration: %w", err)
-		}
-
-		// If versions exist, just make sure current_version_id is set.
-		var latest localdb.LocalConfigurationVersion
-		if err := tx.Where("configuration_uuid = ?", cfg.UUID).
-			Order("version_no DESC").
-			First(&latest).Error; err == nil {
-			if cfg.CurrentVersionID == nil || *cfg.CurrentVersionID == "" {
-				if err := tx.Model(&localdb.LocalConfiguration{}).
-					Where("uuid = ?", cfg.UUID).
-					Update("current_version_id", latest.ID).Error; err != nil {
-					return fmt.Errorf("set current version id: %w", err)
-				}
-			}
-			return nil
-		} else if !errors.Is(err, gorm.ErrRecordNotFound) {
-			return fmt.Errorf("load latest version: %w", err)
-		}
-
-		snapshot, err := localdb.BuildConfigurationSnapshot(&cfg)
-		if err != nil {
-			return fmt.Errorf("build configuration snapshot: %w", err)
-		}
-
-		note := "Auto-repaired missing local version"
-		version := localdb.LocalConfigurationVersion{
-			ID:                uuid.NewString(),
-			ConfigurationUUID: cfg.UUID,
-			VersionNo:         1,
-			Data:              snapshot,
-			ChangeNote:        &note,
-			AppVersion:        appmeta.Version(),
-			CreatedAt:         time.Now(),
-		}
-
-		if err := tx.Create(&version).Error; err != nil {
-			return fmt.Errorf("create initial version: %w", err)
-		}
-		if err := tx.Model(&localdb.LocalConfiguration{}).
-			Where("uuid = ?", cfg.UUID).
-			Update("current_version_id", version.ID).Error; err != nil {
-			return fmt.Errorf("set current version id: %w", err)
-		}
-
-		slog.Warn("repaired missing local configuration version", "uuid", cfg.UUID, "version_no", version.VersionNo)
-		return nil
-	})
-}
-
 // NOTE: prepared for future conflict resolution:
 // when server starts storing version metadata, we can compare payload.CurrentVersionNo
 // against remote version and branch into custom strategies. For now use last-write-wins.

internal/services/sync/service_pricelist_category_backfill_test.go

@@ -1,107 +0,0 @@
-package sync_test
-
-import (
-	"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 TestSyncPricelists_BackfillsLotCategoryForUsedPricelistItems(t *testing.T) {
-	local := newLocalDBForSyncTest(t)
-	serverDB := newServerDBForSyncTest(t)
-
-	if err := serverDB.AutoMigrate(
-		&models.Pricelist{},
-		&models.PricelistItem{},
-		&models.Lot{},
-		&models.LotPartnumber{},
-		&models.StockLog{},
-	); err != nil {
-		t.Fatalf("migrate server tables: %v", err)
-	}
-
-	serverPL := models.Pricelist{
-		Source:       "estimate",
-		Version:      "2026-02-11-001",
-		Notification: "server",
-		CreatedBy:    "tester",
-		IsActive:     true,
-		CreatedAt:    time.Now().Add(-1 * time.Hour),
-	}
-	if err := serverDB.Create(&serverPL).Error; err != nil {
-		t.Fatalf("create server pricelist: %v", err)
-	}
-	if err := serverDB.Create(&models.PricelistItem{
-		PricelistID:  serverPL.ID,
-		LotName:      "CPU_A",
-		LotCategory:  "CPU",
-		Price:        10,
-		PriceMethod:  "",
-		MetaPrices:   "",
-		ManualPrice:  nil,
-		AvailableQty: nil,
-	}).Error; err != nil {
-		t.Fatalf("create server pricelist item: %v", err)
-	}
-
-	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
-		ServerID:  serverPL.ID,
-		Source:    serverPL.Source,
-		Version:   serverPL.Version,
-		Name:      serverPL.Notification,
-		CreatedAt: serverPL.CreatedAt,
-		SyncedAt:  time.Now(),
-		IsUsed:    false,
-	}); err != nil {
-		t.Fatalf("seed local pricelist: %v", err)
-	}
-	localPL, err := local.GetLocalPricelistByServerID(serverPL.ID)
-	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("seed local pricelist items: %v", err)
-	}
-
-	if err := local.SaveConfiguration(&localdb.LocalConfiguration{
-		UUID:             "cfg-1",
-		OriginalUsername: "tester",
-		Name:             "cfg",
-		Items:            localdb.LocalConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 10}},
-		IsActive:         true,
-		PricelistID:      &serverPL.ID,
-		SyncStatus:       "synced",
-		CreatedAt:        time.Now().Add(-30 * time.Minute),
-		UpdatedAt:        time.Now().Add(-30 * time.Minute),
-	}); err != nil {
-		t.Fatalf("seed local configuration with pricelist ref: %v", err)
-	}
-
-	svc := syncsvc.NewServiceWithDB(serverDB, local)
-	if _, err := svc.SyncPricelists(); err != nil {
-		t.Fatalf("sync pricelists: %v", err)
-	}
-
-	items, err := local.GetLocalPricelistItems(localPL.ID)
-	if err != nil {
-		t.Fatalf("load local items: %v", err)
-	}
-	if len(items) != 1 {
-		t.Fatalf("expected 1 local item, got %d", len(items))
-	}
-	if items[0].LotCategory != "CPU" {
-		t.Fatalf("expected lot_category backfilled to CPU, got %q", items[0].LotCategory)
-	}
-}
-

internal/services/sync/service_pricelist_cleanup_test.go

@@ -1,85 +0,0 @@
-package sync_test
-
-import (
-	"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 TestSyncPricelistsDeletesMissingUnusedLocalPricelists(t *testing.T) {
-	local := newLocalDBForSyncTest(t)
-	serverDB := newServerDBForSyncTest(t)
-	if err := serverDB.AutoMigrate(&models.Pricelist{}, &models.PricelistItem{}); err != nil {
-		t.Fatalf("migrate server pricelist tables: %v", err)
-	}
-
-	serverPL := models.Pricelist{
-		Source:       "estimate",
-		Version:      "2026-01-01-001",
-		Notification: "server",
-		CreatedBy:    "tester",
-		IsActive:     true,
-		CreatedAt:    time.Now().Add(-1 * time.Hour),
-	}
-	if err := serverDB.Create(&serverPL).Error; err != nil {
-		t.Fatalf("create server pricelist: %v", err)
-	}
-	if err := serverDB.Create(&models.PricelistItem{PricelistID: serverPL.ID, LotName: "CPU_A", Price: 10}).Error; err != nil {
-		t.Fatalf("create server pricelist item: %v", err)
-	}
-
-	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
-		ServerID:  9991,
-		Source:    "estimate",
-		Version:   "old-unused",
-		Name:      "old-unused",
-		CreatedAt: time.Now().Add(-2 * time.Hour),
-		SyncedAt:  time.Now().Add(-2 * time.Hour),
-		IsUsed:    false,
-	}); err != nil {
-		t.Fatalf("seed local missing pricelist: %v", err)
-	}
-	missingUsed := &localdb.LocalPricelist{
-		ServerID:  9992,
-		Source:    "estimate",
-		Version:   "old-used",
-		Name:      "old-used",
-		CreatedAt: time.Now().Add(-2 * time.Hour),
-		SyncedAt:  time.Now().Add(-2 * time.Hour),
-		IsUsed:    false,
-	}
-	if err := local.SaveLocalPricelist(missingUsed); err != nil {
-		t.Fatalf("seed local referenced pricelist: %v", err)
-	}
-	if err := local.SaveConfiguration(&localdb.LocalConfiguration{
-		UUID:             "cfg-1",
-		OriginalUsername: "tester",
-		Name:             "cfg",
-		Items:            localdb.LocalConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 1}},
-		IsActive:         true,
-		PricelistID:      &missingUsed.ServerID,
-		SyncStatus:       "synced",
-		CreatedAt:        time.Now().Add(-30 * time.Minute),
-		UpdatedAt:        time.Now().Add(-30 * time.Minute),
-	}); err != nil {
-		t.Fatalf("seed local configuration with pricelist ref: %v", err)
-	}
-
-	svc := syncsvc.NewServiceWithDB(serverDB, local)
-	if _, err := svc.SyncPricelists(); err != nil {
-		t.Fatalf("sync pricelists: %v", err)
-	}
-
-	if _, err := local.GetLocalPricelistByServerID(9991); err == nil {
-		t.Fatalf("expected unused missing local pricelist to be deleted")
-	}
-	if _, err := local.GetLocalPricelistByServerID(9992); err != nil {
-		t.Fatalf("expected local pricelist referenced by active config to stay: %v", err)
-	}
-	if _, err := local.GetLocalPricelistByServerID(serverPL.ID); err != nil {
-		t.Fatalf("expected server pricelist to be synced locally: %v", err)
-	}
-}

internal/services/sync/service_projects_push_test.go

@@ -23,7 +23,7 @@ func TestPushPendingChangesProjectsBeforeConfigurations(t *testing.T) {
 	projectService := services.NewProjectService(local)
 	configService := services.NewLocalConfigurationService(local, localSync, &services.QuoteService{}, func() bool { return false })
 
-	project, err := projectService.Create("tester", &services.CreateProjectRequest{Name: ptrString("Project A"), Code: "PRJ-A"})
+	project, err := projectService.Create("tester", &services.CreateProjectRequest{Name: "Project A"})
 	if err != nil {
 		t.Fatalf("create project: %v", err)
 	}
@@ -74,11 +74,11 @@ func TestPushPendingChangesProjectCreateThenUpdateBeforeFirstPush(t *testing.T)
 	configService := services.NewLocalConfigurationService(local, localSync, &services.QuoteService{}, func() bool { return false })
 	pushService := syncsvc.NewServiceWithDB(serverDB, local)
 
-	project, err := projectService.Create("tester", &services.CreateProjectRequest{Name: ptrString("Project v1"), Code: "PRJ-V1"})
+	project, err := projectService.Create("tester", &services.CreateProjectRequest{Name: "Project v1"})
 	if err != nil {
 		t.Fatalf("create project: %v", err)
 	}
-	if _, err := projectService.Update(project.UUID, "tester", &services.UpdateProjectRequest{Name: ptrString("Project v2")}); err != nil {
+	if _, err := projectService.Update(project.UUID, "tester", &services.UpdateProjectRequest{Name: "Project v2"}); err != nil {
 		t.Fatalf("update project: %v", err)
 	}
 
@@ -100,8 +100,8 @@ func TestPushPendingChangesProjectCreateThenUpdateBeforeFirstPush(t *testing.T)
 	if err := serverDB.Where("uuid = ?", project.UUID).First(&serverProject).Error; err != nil {
 		t.Fatalf("project not pushed to server: %v", err)
 	}
-	if serverProject.Name == nil || *serverProject.Name != "Project v2" {
-		t.Fatalf("expected latest project name, got %v", serverProject.Name)
+	if serverProject.Name != "Project v2" {
+		t.Fatalf("expected latest project name, got %q", serverProject.Name)
 	}
 
 	var serverCfg models.Configuration
@@ -324,8 +324,6 @@ CREATE TABLE qt_projects (
 	id INTEGER PRIMARY KEY AUTOINCREMENT,
 	uuid TEXT NOT NULL UNIQUE,
 	owner_username TEXT NOT NULL,
-	code TEXT NOT NULL,
-	variant TEXT NOT NULL DEFAULT '',
 	name TEXT NOT NULL,
 	tracker_url TEXT NULL,
 	is_active INTEGER NOT NULL DEFAULT 1,
@@ -335,9 +333,6 @@ CREATE TABLE qt_projects (
 );`).Error; err != nil {
 		t.Fatalf("create qt_projects: %v", err)
 	}
-	if err := db.Exec(`CREATE UNIQUE INDEX idx_qt_projects_code_variant ON qt_projects(code, variant);`).Error; err != nil {
-		t.Fatalf("create qt_projects index: %v", err)
-	}
 	if err := db.Exec(`
 CREATE TABLE qt_configurations (
 	id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -353,14 +348,7 @@ CREATE TABLE qt_configurations (
 	notes TEXT NULL,
 	is_template INTEGER NOT NULL DEFAULT 0,
 	server_count INTEGER NOT NULL DEFAULT 1,
-	server_model TEXT NULL,
-	support_code TEXT NULL,
-	article TEXT NULL,
 	pricelist_id INTEGER NULL,
-	warehouse_pricelist_id INTEGER NULL,
-	competitor_pricelist_id INTEGER NULL,
-	disable_price_refresh INTEGER NOT NULL DEFAULT 0,
-	only_in_stock INTEGER NOT NULL DEFAULT 0,
 	price_updated_at DATETIME NULL,
 	created_at DATETIME
 );`).Error; err != nil {
@@ -369,10 +357,6 @@ CREATE TABLE qt_configurations (
 	return db
 }
 
-func ptrString(value string) *string {
-	return &value
-}
-
 func getCurrentVersionInfo(t *testing.T, local *localdb.LocalDB, configurationUUID string, currentVersionID *string) (int, string) {
 	t.Helper()
 	if currentVersionID == nil || *currentVersionID == "" {

internal/services/sync/worker.go

@@ -71,15 +71,6 @@ func (w *Worker) runSync() {
 		return
 	}
 
-	if readiness, err := w.service.EnsureReadinessForSync(); err != nil {
-		w.logger.Warn("background sync: blocked by readiness guard",
-			"error", err,
-			"reason_code", readiness.ReasonCode,
-			"reason_text", readiness.ReasonText,
-		)
-		return
-	}
-
 	// Push pending changes first
 	pushed, err := w.service.PushPendingChanges()
 	if err != nil {

markdown

@@ -1,93 +0,0 @@
-<p><strong>ТЕХНИЧЕСКОЕ ЗАДАНИЕ</strong></p>
-<p>1. Требования к продукции</p>
-<p>Поставляемое оборудование должно быть новым, оригинальным, не бывшим
-в употреблении, не восстановленным. Гарантийный срок — не менее 12
-месяцев с момента поставки. Все компоненты, включая процессоры, память,
-накопители и контроллеры, должны быть совместимы и предварительно
-протестированы на совместимость и производительность в рамках единой
-системы.</p>
-<p>2. Количественные и качественные характеристики</p>
-<p>2.1. Базовые требования к серверной платформе:</p>
-<p>Модель (артикул): Сервер в конфигурации с шасси, поддерживающим 12
-отсека 2.5" для накопителей NVMe U.2/U.3.</p>
-<p>Форм-фактор: 2U для установки в стойку.</p>
-<p>Кол-во процессорных сокетов: 1.</p>
-<p>2.2. Требования к процессорам (CPU):</p>
-<p>Количество: 1 шт.</p>
-<p>Модель/семейство: 256t x AMD EPYC 9755 2.7 GHz 128c-Core Processor
-Объём кэша L3: 512MB Техпроцесс: 4 нм, архитектура процессора: Zen-5
-(Turin).</p>
-<p>Минимальная базовая тактовая частота: 2.7 ГГц.</p>
-<p>Максимальная частота работы процессора (Turboboost): 4.1 GHz</p>
-<p>Для обеспечения полной производительности всех 12 накопителей NVMe и
-сетевых адаптеров, процессор и системная платформа в целом должны
-обеспечивать достаточно линий PCIe 5.0.</p>
-<p>2.3. Требования к оперативной памяти (RAM):</p>
-<p>Тип памяти: DDR5 с коррекцией ошибок (ECC) RDIMM 6000Mhz.</p>
-<p>Минимальный объем оперативной памяти: 2048 ГБ.</p>
-<p>Конфигурация: Модули памяти должны быть установлены в оптимальной
-конфигурации для обеспечения полной пропускной способности всех линий
-PCIe 5.0 от NVMe-накопителей. Платформа должна поддерживать установку не
-менее 16 модулей DDR5 ECC REG 6000Mhz для последующего
-масштабирования.</p>
-<p>Поддерживаемая частота: Не менее 6000 МТ/с.</p>
-<p>Одобренные модули оперативной памяти - Samsung/Micron/Hynix, DDR5,
-64GB, RDIMM, ECC</p>
-<p>2.4 Требования к системе хранения данных:</p>
-<p>Конфигурация шасси: Обязательна поставка в конфигурации с 12 отсеками
-2.5" под горячую замену, поддерживающими интерфейс NVMe через PCIe 5.0
-x4 и 2 отсеками 2.5"/М.2 под горячую замену, поддерживающими SATA.</p>
-<p>Дополнительно (для ОС): Поддержка установки 2x M.2 NVMe накопителей в
-dedicated-слотах на материнской плате под операционную систему отдельно
-от основного хранилища данных.</p>
-<p>2.5. Требования к сетевым интерфейсам (NIC):</p>
-<p>Слоты расширения сети: Наличие не менее 1 слотов OCP 3.0 SFF для
-установки специализированных сетевых адаптеров.</p>
-<p>Дополнительные сетевые адаптеры (обязательная поставка): Один сетевой
-адаптер OCP 3.0 с 2 портами 25 Гбит/с Ethernet Intel 810 или Mellanox
-CX-6.</p>
-<p>Встроенные порты управления: порт 1 Гбит/с Ethernet (RJ-45) для
-модуля управления iBMC.</p>
-<p>2.6. Требования к интерфейсам расширения (PCIe):</p>
-<p>Количество слотов PCIe: Конфигурация с 12 дисками NVMe использует
-большую часть линий PCIe. Тем не менее, не менее слотов PCIe 5.0 должны
-оставаться свободными для будущего расширения (например, установки
-дополнительных сетевых карт или FPGA/GPU для специфических задач).</p>
-<p>Шинная архитектура: Поставщик должен предоставить схему распределения
-линий PCIe 5.0 между процессором контроллером RAID и слотами расширения,
-подтверждающую отсутствие узких мест (bottlenecks).</p>
-<p>2.7. Требования к системе управления:</p>
-<p>Внеполосный (out-of-band) модуль управления: Наличие выделенного чипа
-iBMC.</p>
-<p>Интеллектуальные функции: Критически важна поддержка детального
-мониторинга состояния NVMe-накопителей (SMART, температура, износ,
-прогнозирование сбоев) через интерфейс iBMC и поддержка технологии
-горячей замены NVMe-накопителей.</p>
-<p>Наличие безагентного КВМ (HTML5)</p>
-<p>Желательна поддержка shared LAN (через NCSI OCPv3 разъем) с
-тегированием VLAN, настройка по умолчанию DHCP IPv4</p>
-<p>Управление параметрами работы сервера (режим работы вентиляторов,
-потребление энергии, итд).</p>
-<p>Наличие 2х видов логирования:</p>
-<p>Все аппаратные события, включая ECC ошибки по памяти, ошибки PCIe,
-SATA (IPMI/Hardware Event Log)</p>
-<p>Все сессии аутентификации и изменения системных параметров
-(Audit/Security Log)</p>
-<p>Наличие функционала обновления прошивок сервера (BIOS, BMC, CPLD
-(опционально)) с сохранением и без сохранения настроек.</p>
-<p>2.8. Требования к системе питания и охлаждения:</p>
-<p>Блоки питания (PSU):</p>
-<p>Количество: 2 шт. (резервирование 1+1) с возможностью горячей
-замены.</p>
-<p>Номинальная мощность каждого: Минимум 1200 Вт с сертификацией 80 Plus
-Platinum/Titanium. Мощность должна быть достаточной для одновременной
-пиковой нагрузки от процессора, 12 NVMe-дисков и прочих компонентов.</p>
-<p>Система охлаждения: не менее N+1 резервирование вентиляторов.</p>
-<p>3. Упаковка и маркировка:</p>
-<p>Оборудование должно быть упаковано так, чтобы предотвратить
-повреждение при транспортировке.</p>
-<p>4. Требования к комплектации:</p>
-<p>Рельсовый комплект - без инструментов с горизонтальной загрузкой</p>
-<p>Оборудование - C19-C20 или С13-С14 кабели питания 1-2 m в зависимости
-от БП, 19 " комплект для монтажа в стойку, комплект винтов, все отсеки с
-корзинами.</p>

memory.md

@@ -1,41 +0,0 @@
-# Changes summary (2026-02-11)
-
-Implemented strict `lot_category` flow using `pricelist_items.lot_category` only (no parsing from `lot_name`), plus local caching and backfill:
-
-1. Local DB schema + migrations
-- Added `lot_category` column to `local_pricelist_items` via `LocalPricelistItem` model.
-- Added local migration `2026_02_11_local_pricelist_item_category` to add the column if missing and create indexes:
-  - `idx_local_pricelist_items_pricelist_lot (pricelist_id, lot_name)`
-  - `idx_local_pricelist_items_lot_category (lot_category)`
-
-2. Server model/repository
-- Added `LotCategory` field to `models.PricelistItem`.
-- `PricelistRepository.GetItems` now sets `Category` from `LotCategory` (no parsing from `lot_name`).
-
-3. Sync + local DB helpers
-- `SyncPricelistItems` now saves `lot_category` into local cache via `PricelistItemToLocal`.
-- Added `LocalDB.CountLocalPricelistItemsWithEmptyCategory` and `LocalDB.ReplaceLocalPricelistItems`.
-- Added `LocalDB.GetLocalLotCategoriesByServerPricelistID` for strict category lookup.
-- Added `SyncPricelists` backfill step: for used active pricelists with empty categories, force refresh items from server.
-
-4. API handler
-- `GET /api/pricelists/:id/items` returns `category` from `local_pricelist_items.lot_category` (no parsing from `lot_name`).
-
-5. Article category foundation
-- New package `internal/article`:
-  - `ResolveLotCategoriesStrict` pulls categories from local pricelist items and errors on missing category.
-  - `GroupForLotCategory` maps only allowed codes (CPU/MEM/GPU/M2/SSD/HDD/EDSFF/HHHL/NIC/HCA/DPU/PSU/PS) to article groups; excludes `SFP`.
-  - Error type `MissingCategoryForLotError` with base `ErrMissingCategoryForLot`.
-
-6. Tests
-- Added unit tests for converters and article category resolver.
-- Added handler test to ensure `/api/pricelists/:id/items` returns `lot_category`.
-- Added sync test for category backfill on used pricelist items.
-- `go test ./...` passed.
-
-Additional fixes (2026-02-11):
-- Fixed article parsing bug: CPU/GPU parsers were swapped in `internal/article/generator.go`. CPU now uses last token from CPU lot; GPU uses model+memory from `GPU_vendor_model_mem_iface`.
-- Adjusted configurator base tab layout to align labels on the same row (separate label row + input row grid).
-
-UI rule (2026-02-19):
-- In all breadcrumbs, truncate long specification/configuration names to 16 characters using ellipsis.

migrations/019_rename_stock_log_lot_to_partnumber.sql

@@ -1,2 +0,0 @@
-ALTER TABLE stock_log
-    CHANGE COLUMN lot partnumber VARCHAR(255) NOT NULL;

migrations/020_add_only_in_stock_to_configurations.sql

@@ -1,3 +0,0 @@
--- Add only_in_stock toggle to configuration settings persisted in MariaDB.
-ALTER TABLE qt_configurations
-    ADD COLUMN IF NOT EXISTS only_in_stock BOOLEAN NOT NULL DEFAULT FALSE AFTER disable_price_refresh;

migrations/021_add_pricelist_items_pricelist_lot_index.sql

@@ -1,19 +0,0 @@
--- Ensure fast lookup for /api/quote/price-levels batched queries:
--- SELECT ... FROM qt_pricelist_items WHERE pricelist_id = ? AND lot_name IN (...)
-SET @has_idx := (
-    SELECT COUNT(1)
-    FROM information_schema.statistics
-    WHERE table_schema = DATABASE()
-      AND table_name = 'qt_pricelist_items'
-      AND index_name IN ('idx_qt_pricelist_items_pricelist_lot', 'idx_pricelist_lot')
-);
-
-SET @ddl := IF(
-    @has_idx = 0,
-    'ALTER TABLE qt_pricelist_items ADD INDEX idx_qt_pricelist_items_pricelist_lot (pricelist_id, lot_name)',
-    'SELECT ''idx_qt_pricelist_items_pricelist_lot already exists, skip'''
-);
-
-PREPARE stmt FROM @ddl;
-EXECUTE stmt;
-DEALLOCATE PREPARE stmt;

migrations/022_add_article_to_configurations.sql

@@ -1,2 +0,0 @@
-ALTER TABLE qt_configurations
-    ADD COLUMN IF NOT EXISTS article VARCHAR(80) NULL AFTER server_count;

migrations/023_add_server_model_to_configurations.sql

@@ -1,2 +0,0 @@
-ALTER TABLE qt_configurations
-    ADD COLUMN IF NOT EXISTS server_model VARCHAR(100) NULL AFTER server_count;

migrations/024_add_support_code_to_configurations.sql

@@ -1,2 +0,0 @@
-ALTER TABLE qt_configurations
-    ADD COLUMN IF NOT EXISTS support_code VARCHAR(20) NULL AFTER server_model;

migrations/025_add_project_code.sql

@@ -1,38 +0,0 @@
--- Add project code and enforce uniqueness
-
-ALTER TABLE qt_projects
-    ADD COLUMN code VARCHAR(100) NULL AFTER owner_username;
-
--- Copy code from current project name (truncate to fit)
-UPDATE qt_projects
-SET code = LEFT(TRIM(COALESCE(name, '')), 100);
-
--- Fallback for any remaining blanks
-UPDATE qt_projects
-SET code = uuid
-WHERE code IS NULL OR TRIM(code) = '';
-
--- Drop unique index if it already exists to allow de-duplication updates
-DROP INDEX IF EXISTS idx_qt_projects_code ON qt_projects;
-
--- De-duplicate codes: OPS-1948-2, OPS-1948-3... (MariaDB without CTE)
-UPDATE qt_projects p
-JOIN (
-    SELECT p1.id,
-           p1.code AS base_code,
-           (
-               SELECT COUNT(*)
-               FROM qt_projects p2
-               WHERE p2.code = p1.code AND p2.id <= p1.id
-           ) AS rn
-    FROM qt_projects p1
-) r ON r.id = p.id
-SET p.code = CASE
-    WHEN r.rn = 1 THEN r.base_code
-    ELSE CONCAT(LEFT(r.base_code, 90), '-', r.rn)
-END;
-
-ALTER TABLE qt_projects
-    MODIFY COLUMN code VARCHAR(100) NOT NULL;
-
-CREATE UNIQUE INDEX idx_qt_projects_code ON qt_projects(code);

migrations/026_add_project_variant.sql

@@ -1,28 +0,0 @@
--- Add project variant and reset codes from project names
-
-ALTER TABLE qt_projects
-    ADD COLUMN variant VARCHAR(100) NOT NULL DEFAULT '' AFTER code;
-
--- Drop legacy unique index on code to allow duplicate codes
-DROP INDEX IF EXISTS idx_qt_projects_code ON qt_projects;
-DROP INDEX IF EXISTS idx_qt_projects_code_variant ON qt_projects;
-
--- Reset code from name and clear variant
-UPDATE qt_projects
-SET code = LEFT(TRIM(COALESCE(name, '')), 100),
-    variant = '';
-
--- De-duplicate by assigning variant numbers: -2, -3...
-UPDATE qt_projects p
-JOIN (
-    SELECT p1.id,
-           p1.code,
-           (SELECT COUNT(*)
-            FROM qt_projects p2
-            WHERE p2.code = p1.code AND p2.id <= p1.id) AS rn
-    FROM qt_projects p1
-) r ON r.id = p.id
-SET p.code = r.code,
-    p.variant = CASE WHEN r.rn = 1 THEN '' ELSE CONCAT('-', r.rn) END;
-
-CREATE UNIQUE INDEX idx_qt_projects_code_variant ON qt_projects(code, variant);

migrations/027_project_name_nullable.sql

@@ -1,4 +0,0 @@
--- Allow NULL project names
-
-ALTER TABLE qt_projects
-    MODIFY COLUMN name VARCHAR(200) NULL;

releases/memory/v1.2.1.md

@@ -1,72 +0,0 @@
-# v1.2.1 Release Notes
-
-**Date:** 2026-02-09
-**Changes since v1.2.0:** 2 commits
-
-## Summary
-Fixed configurator component substitution by updating to work with new pricelist-based pricing model. Addresses regression from v1.2.0 refactor that removed `CurrentPrice` field from components.
-
-## Commits
-
-### 1. Refactor: Remove CurrentPrice from local_components (5984a57)
-**Type:** Refactor
-**Files Changed:** 11 files, +167 insertions, -194 deletions
-
-#### Overview
-Transitioned from component-based pricing to pricelist-based pricing model:
-- Removed `CurrentPrice` and `SyncedAt` from LocalComponent (metadata-only now)
-- Added `WarehousePricelistID` and `CompetitorPricelistID` to LocalConfiguration
-- Removed 2 unused methods: UpdateComponentPricesFromPricelist, EnsureComponentPricesFromPricelists
-
-#### Key Changes
-- **Data Model:**
-  - LocalComponent: now stores only metadata (LotName, LotDescription, Category, Model)
-  - LocalConfiguration: added warehouse and competitor pricelist references
-
-- **Migrations:**
-  - drop_component_unused_fields - removes CurrentPrice, SyncedAt columns
-  - add_warehouse_competitor_pricelists - adds new pricelist fields
-
-- **Quote Calculation:**
-  - Updated to use pricelist_items instead of component.CurrentPrice
-  - Added PricelistID field to QuoteRequest
-  - Maintains offline-first behavior
-
-- **API:**
-  - Removed CurrentPrice from ComponentView
-  - Components API no longer returns pricing
-
-### 2. Fix: Load component prices via API (acf7c8a)
-**Type:** Bug Fix
-**Files Changed:** 1 file (web/templates/index.html), +66 insertions, -12 deletions
-
-#### Problem
-After v1.2.0 refactor, the configurator's autocomplete was filtering out all components because it checked for the removed `current_price` field on component objects.
-
-#### Solution
-Implemented on-demand price loading via API:
-- Added `ensurePricesLoaded()` function to fetch prices from `/api/quote/price-levels`
-- Added `componentPricesCache` to cache loaded prices in memory
-- Updated all 3 autocomplete modes (single, multi, section) to load prices when input is focused
-- Changed price validation from `c.current_price` to `hasComponentPrice(lot_name)`
-- Updated cart item creation to use cached API prices
-
-#### Impact
-- Components without prices are still filtered out (as required)
-- Price checks now use API data instead of removed database field
-- Frontend loads prices on-demand for better performance
-
-## Testing Notes
-- ✅ Configurator component substitution now works
-- ✅ Prices load correctly from pricelist
-- ✅ Offline mode still supported (prices cached after initial load)
-- ✅ Multi-pricelist support functional (estimate/warehouse/competitor)
-
-## Known Issues
-None
-
-## Migration Path
-No database migration needed from v1.2.0 - migrations were applied in v1.2.0 release.
-
-## Breaking Changes
-None for end users. Internal: `ComponentView` no longer includes `CurrentPrice` in API responses.

releases/memory/v1.2.2.md

@@ -1,59 +0,0 @@
-# Release v1.2.2 (2026-02-09)
-
-## Summary
-
-Fixed CSV export filename inconsistency where project names weren't being resolved correctly. Standardized export format across both manual exports and project configuration exports to use `YYYY-MM-DD (project_name) config_name BOM.csv`.
-
-## Commits
-
-- `8f596ce` fix: standardize CSV export filename format to use project name
-
-## Changes
-
-### CSV Export Filename Standardization
-
-**Problem:**
-- ExportCSV and ExportConfigCSV had inconsistent filename formats
-- Project names sometimes fell back to config names when not explicitly provided
-- Export timestamps didn't reflect actual price update time
-
-**Solution:**
-- Unified format: `YYYY-MM-DD (project_name) config_name BOM.csv`
-- Both export paths now use PriceUpdatedAt if available, otherwise CreatedAt
-- Project name resolved from ProjectUUID via ProjectService for both paths
-- Frontend passes project_uuid context when exporting
-
-**Technical Details:**
-
-Backend:
-- Added `ProjectUUID` field to `ExportRequest` struct in handlers/export.go
-- Updated ExportCSV to look up project name from ProjectUUID using ProjectService
-- Ensured ExportConfigCSV gets project name from config's ProjectUUID
-- Both use CreatedAt (for ExportCSV) or PriceUpdatedAt/CreatedAt (for ExportConfigCSV)
-
-Frontend:
-- Added `projectUUID` and `projectName` state variables in index.html
-- Load and store projectUUID when configuration is loaded
-- Pass `project_uuid` in JSON body for both export requests
-
-## Files Modified
-
-- `internal/handlers/export.go` - Project name resolution and ExportRequest update
-- `internal/handlers/export_test.go` - Updated mock initialization with projectService param
-- `cmd/qfs/main.go` - Pass projectService to ExportHandler constructor
-- `web/templates/index.html` - Add projectUUID tracking and export payload updates
-
-## Testing Notes
-
-✅ All existing tests updated and passing
-✅ Code builds without errors
-✅ Export filename now includes correct project name
-✅ Works for both form-based and project-based exports
-
-## Breaking Changes
-
-None - API response format unchanged, only filename generation updated.
-
-## Known Issues
-
-None identified.