Fix article generator producing 1xINTEL in GPU segment

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

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

.gitmodules

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

AGENTS.md

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

CLAUDE.md

@@ -1,83 +1,17 @@
-# QuoteForge - Claude Code Instructions
+# QuoteForge — Instructions for Claude
 
-## Overview
-Корпоративный конфигуратор серверов с offline-first архитектурой.
-Приложение работает через локальную SQLite базу, синхронизация с MariaDB выполняется фоново.
+## Shared Engineering Rules
+Read `bible/` — shared rules for all projects (CSV, logging, DB, tables, background tasks, code style).
+Start with `bible/rules/patterns/` for specific contracts.
 
-## Product Scope
-- Конфигуратор компонентов и расчёт КП
-- Проекты и конфигурации
-- Read-only просмотр прайслистов из локального кэша
-- Sync (pull компонентов/прайслистов, push локальных изменений)
+## Project Architecture
+Read `bible-local/` — QuoteForge specific architecture.
+Read order: `bible-local/README.md` → relevant files for the task.
 
-Из области исключены:
-- admin pricing UI/API
-- stock import
-- alerts
-- cron/importer утилиты
+Every architectural decision specific to this project must be recorded in `bible-local/`.
 
-## Architecture
-- Local-first: чтение и запись происходят в SQLite
-- MariaDB используется как сервер синхронизации
-- Background worker: периодический sync push+pull
-
-## Guardrails
-- Не возвращать в проект удалённые legacy-разделы: cron jobs, importer utility, admin pricing, alerts, stock import.
-- Runtime-конфиг читается из user state (`config.yaml`) или через `-config` / `QFS_CONFIG_PATH`; не хранить рабочий `config.yaml` в репозитории.
-- `config.example.yaml` остаётся единственным шаблоном конфигурации в репо.
-- Любые изменения в sync должны сохранять local-first поведение: локальные CRUD не блокируются из-за недоступности MariaDB.
-
-## Key SQLite Data
-- `connection_settings`
-- `local_components`
-- `local_pricelists`, `local_pricelist_items`
-- `local_configurations`
-- `local_projects`
-- `pending_changes`
-
-## API Endpoints
-| Group | Endpoints |
-|-------|-----------|
-| Setup | `GET /setup`, `POST /setup`, `POST /setup/test`, `GET /setup/status` |
-| Components | `GET /api/components`, `GET /api/components/:lot_name`, `GET /api/categories` |
-| Quote | `POST /api/quote/validate`, `POST /api/quote/calculate`, `POST /api/quote/price-levels` |
-| Pricelists (read-only) | `GET /api/pricelists`, `GET /api/pricelists/latest`, `GET /api/pricelists/:id`, `GET /api/pricelists/:id/items`, `GET /api/pricelists/:id/lots` |
-| Configs | CRUD + refresh/clone/reactivate/rename/project binding via `/api/configs/*` |
-| Projects | CRUD + nested configs via `/api/projects/*` |
-| Sync | `GET /api/sync/status`, `GET /api/sync/readiness`, `GET /api/sync/info`, `GET /api/sync/users-status`, `POST /api/sync/components`, `POST /api/sync/pricelists`, `POST /api/sync/all`, `POST /api/sync/push`, `GET /api/sync/pending`, `GET /api/sync/pending/count` |
-| Export | `POST /api/export/csv` |
-
-## Web Routes
-- `/configs`
-- `/configurator`
-- `/projects`
-- `/projects/:uuid`
-- `/pricelists`
-- `/pricelists/:id`
-- `/setup`
-
-## Release Notes & Change Log
-Release notes are maintained in `releases/memory/` directory organized by version tags (e.g., `v1.2.1.md`).
-Before working on the codebase, review the most recent release notes to understand recent changes.
-- Check `releases/memory/` for detailed changelog between tags
-- Each release file documents commits, breaking changes, and migration notes
-
-## Commands
 ```bash
-# Development
-go run ./cmd/qfs
-make run
-
-# Build
-make build-release
-CGO_ENABLED=0 go build -o bin/qfs ./cmd/qfs
-
-# Verification
-go build ./cmd/qfs
-go vet ./...
+go build ./cmd/qfs && go vet ./...   # verify
+go run ./cmd/qfs                      # run
+make build-release                    # release build
 ```
-
-## Code Style
-- gofmt
-- structured logging (`slog`)
-- explicit error wrapping with context

README.md

@@ -1,475 +1,66 @@
 # QuoteForge
 
-**Server Configuration & Quotation Tool**
+**Корпоративный конфигуратор серверов и расчёт КП**
 
-QuoteForge — корпоративный инструмент для конфигурирования серверов и формирования коммерческих предложений (КП).  
-Приложение работает в strict local-first режиме: пользовательские операции выполняются через локальную SQLite, MariaDB используется для синхронизации и серверного администрирования прайслистов.
+Offline-first архитектура: пользовательские операции через локальную SQLite, MariaDB только для синхронизации.
 
 ![Go Version](https://img.shields.io/badge/Go-1.22+-00ADD8?style=flat&logo=go)
 ![License](https://img.shields.io/badge/License-Proprietary-red)
 ![Status](https://img.shields.io/badge/Status-In%20Development-yellow)
 
-## Возможности
+---
 
-### Для пользователей
-- 📱 **Mobile-first интерфейс** — удобная работа с телефона и планшета
-- 🖥️ **Конфигуратор серверов** — пошаговый выбор компонентов с проверкой совместимости
-- 💰 **Автоматический расчёт цен** — актуальные цены на основе истории закупок
-- 📊 **Экспорт в CSV/XLSX** — готовые спецификации для клиентов
-- 💾 **Сохранение конфигураций** — история и шаблоны для повторного использования
-- 🔌 **Полная офлайн-работа** — можно продолжать работу без сети и синхронизировать позже
-- 🛡️ **Защищенная синхронизация** — sync блокируется preflight-проверкой, если локальная схема не готова
+## Документация
 
-### Для ценовых администраторов
-- 📈 **Умный расчёт цен** — медиана, взвешенная медиана, среднее
-- 🎯 **Система алертов** — уведомления о популярных компонентах с устаревшими ценами
-- 📉 **Аналитика использования** — какие компоненты востребованы в КП
-- ⚙️ **Гибкие настройки** — периоды расчёта, методы, ручные переопределения
+Полная архитектурная документация хранится в **[bible/](bible/README.md)**:
 
-### Индикация актуальности цен
-| Цвет | Статус | Условие |
-|------|--------|---------|
-| 🟢 Зелёный | Свежая | < 30 дней, ≥ 3 источника |
-| 🟡 Жёлтый | Нормальная | 30-60 дней |
-| 🟠 Оранжевый | Устаревающая | 60-90 дней |
-| 🔴 Красный | Устаревшая | > 90 дней или нет данных |
+| Файл | Тема |
+|------|------|
+| [bible/01-overview.md](bible/01-overview.md) | Продукт, возможности, технологии, структура репо |
+| [bible/02-architecture.md](bible/02-architecture.md) | Local-first, sync, ценообразование, версионность |
+| [bible/03-database.md](bible/03-database.md) | SQLite и MariaDB схемы, права, миграции |
+| [bible/04-api.md](bible/04-api.md) | Все API endpoints и web-маршруты |
+| [bible/05-config.md](bible/05-config.md) | Конфигурация, env vars, установка |
+| [bible/06-backup.md](bible/06-backup.md) | Резервное копирование |
+| [bible/07-dev.md](bible/07-dev.md) | Команды разработки, стиль кода, guardrails |
 
-## Технологии
+---
 
-- **Backend:** Go 1.22+, Gin, GORM
-- **Frontend:** HTML, Tailwind CSS, htmx
-- **Database:** SQLite (runtime/local-first), MariaDB 11+ (sync + server admin)
-- **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. Настройка runtime-конфига (опционально)
-
-`config.yaml` создаётся автоматически при первом старте в той же user-state папке, где находится `qfs.db`.
-Если найден старый формат, приложение автоматически мигрирует файл в актуальный runtime-формат
-(оставляя только используемые секции `server` и `logging`).
-
-При необходимости можно создать/отредактировать файл вручную:
-
-```yaml
-server:
-  host: "0.0.0.0"
-  port: 8080
-  mode: "release"
-
-logging:
-  level: "info"
-  format: "json"
-  output: "stdout"
-```
-
-### 3. Миграции базы данных
+## Быстрый старт
 
 ```bash
+# Применить миграции
 go run ./cmd/qfs -migrate
-```
 
-### Мигратор OPS -> проекты (preview/apply)
-
-Переносит квоты, чьи названия начинаются с `OPS-xxxx` (где `x` — цифра), в проект `OPS-xxxx`.
-Если проекта нет, он будет создан; если архивный — реактивирован.
-
-Сначала всегда смотрите preview:
-
-```bash
-go run ./cmd/migrate_ops_projects
-```
-
-Применение изменений:
-
-```bash
-go run ./cmd/migrate_ops_projects -apply
-```
-
-Без интерактивного подтверждения:
-
-```bash
-go run ./cmd/migrate_ops_projects -apply -yes
-```
-
-### Права БД для пользователя приложения
-
-#### Полный набор прав для обычного пользователя
-
-Чтобы выдать существующему пользователю все необходимые права (без переоздания):
-
-```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, 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;
-
--- Проверка выданных прав
-SHOW GRANTS FOR '<DB_USER>'@'%';
-```
-
-#### Таблицы и их назначение
-
-| Таблица | Назначение | Права | Примечание |
-|---------|-----------|-------|-----------|
-| `lot` | Справочник компонентов | SELECT | Существующая таблица |
-| `qt_lot_metadata` | Расширенные данные компонентов | SELECT | Метаданные компонентов |
-| `qt_categories` | Категории компонентов | SELECT | Справочник |
-| `qt_pricelists` | Прайслисты | SELECT | Управляется сервером |
-| `qt_pricelist_items` | Позиции прайслистов | SELECT | Управляется сервером |
-| `qt_configurations` | Сохранённые конфигурации | SELECT, INSERT, UPDATE | Основная таблица работы |
-| `qt_projects` | Проекты | SELECT, INSERT, UPDATE | Для группировки конфигураций |
-| `qt_client_local_migrations` | Справочник миграций БД | SELECT | Только чтение (управляется админом) |
-| `qt_client_schema_state` | Состояние локальной схемы | SELECT, INSERT, UPDATE | Отслеживание примененных миграций |
-| `qt_pricelist_sync_status` | Статус синхронизации | SELECT, INSERT, UPDATE | Отслеживание активности синхронизации |
-
-#### При создании нового пользователя
-
-Если нужно создать нового пользователя с нуля:
-
-```sql
--- 1) Создать пользователя
-CREATE USER IF NOT EXISTS 'quote_user'@'%' IDENTIFIED BY '<DB_PASSWORD>';
-
--- 2) Выдать все необходимые права
-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'@'%';
-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'@'%';
-
--- 3) Применить изменения
-FLUSH PRIVILEGES;
-
--- 4) Проверить права
-SHOW GRANTS FOR 'quote_user'@'%';
-```
-
-#### Важные замечания
-
-- **Таблицы синхронизации** должны быть созданы администратором БД один раз. Приложение не требует прав CREATE TABLE.
-- **Прайслисты** (`qt_pricelists`, `qt_pricelist_items`) — справочные таблицы, управляются сервером, пользователь имеет только SELECT.
-- **Конфигурации и проекты** — таблицы, в которые пишет само приложение (INSERT, UPDATE при сохранении изменений).
-- **Таблицы миграций** нужны для синхронизации: приложение читает список миграций и отчитывается о применённых.
-- Если видите ошибку `Access denied for user ...@'<ip>'`, проверьте наличие конфликтующих записей пользователя с разными хостами (user@localhost vs user@'%').
-
-### 4. Импорт метаданных компонентов
-
-```bash
-go run ./cmd/importer
-```
-
-### 5. Запуск
-
-```bash
-# Development
+# Запустить
 go run ./cmd/qfs
-
-# Production (with Makefile - recommended)
-make build-release    # Builds with version info
-./bin/qfs -version    # Check version
-
-# Production (manual)
-VERSION=$(git describe --tags --always --dirty)
-CGO_ENABLED=0 go build -ldflags="-s -w -X main.Version=$VERSION" -o bin/qfs ./cmd/qfs
-./bin/qfs -version
+# или
+make run
 ```
 
-**Makefile команды:**
-```bash
-make build-release   # Оптимизированная сборка с версией
-make build-all       # Сборка для всех платформ (Linux, macOS, Windows)
-make build-windows   # Только для Windows
-make run             # Запуск dev сервера
-make test            # Запуск тестов
-make install-hooks   # Установить git hooks (блокировка коммита с секретами)
-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`.
-
-#### Sync readiness guard
-
-Перед `push/pull` выполняется preflight-проверка:
-- доступен ли сервер (MariaDB);
-- можно ли проверить и применить централизованные миграции локальной БД;
-- подходит ли версия приложения под `min_app_version` миграций.
-
-Если проверка не пройдена:
-- локальная работа (CRUD) продолжается;
-- sync API возвращает `423 Locked` с `reason_code` и `reason_text`;
-- в UI показывается красный индикатор и причина блокировки в модалке синхронизации.
-
-#### Схема потоков данных синхронизации
-
-```text
-                          [ SERVER / MariaDB ]
-                     ┌───────────────────────────┐
-                     │ qt_projects               │
-                     │ qt_configurations         │
-                     │ qt_pricelists             │
-                     │ qt_pricelist_items        │
-                     │ qt_pricelist_sync_status  │
-                     └─────────────┬─────────────┘
-                                   │
-                    pull (projects/configs/pricelists)
-                                   │
-                ┌──────────────────┴──────────────────┐
-                │                                     │
-      [ CLIENT A / local SQLite ]           [ CLIENT B / local SQLite ]
-   ┌───────────────────────────────┐       ┌───────────────────────────────┐
-   │ local_projects                │       │ local_projects                │
-   │ local_configurations          │       │ local_configurations          │
-   │ local_pricelists              │       │ local_pricelists              │
-   │ local_pricelist_items         │       │ local_pricelist_items         │
-   │ pending_changes (proj/config) │       │ pending_changes (proj/config) │
-   └───────────────┬───────────────┘       └───────────────┬───────────────┘
-                   │                                       │
-      push (projects/configurations only)     push (projects/configurations only)
-                   │                                       │
-                   └──────────────────┬────────────────────┘
-                                      │
-                              [ SERVER / MariaDB ]
-```
-
-По сущностям:
-- Конфигурации: `Client <-> Server <-> Other Clients`
-- Проекты: `Client <-> Server <-> Other Clients`
-- Прайслисты: `Server -> Clients only` (локальный push отсутствует)
-- Локальная очистка прайслистов на клиенте: удаляются записи, которых нет на сервере и которые не используются активными локальными конфигурациями
-
-### Версионность конфигураций (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-методом:
+Приложение: http://localhost:8080 → откроется `/setup` для настройки подключения к MariaDB.
 
 ```bash
-POST /api/configs/:uuid/rollback
-{
-  "target_version": 3,
-  "note": "optional"
-}
+# Сборка
+make build-release
+
+# Проверка
+go build ./cmd/qfs && go vet ./...
 ```
 
-Результат:
-- создаётся новая версия `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` (а не рядом с бинарником).
-Если файла нет, он создаётся автоматически. Если формат устарел, он автоматически мигрируется в runtime-формат (`server` + `logging`).
-Можно переопределить путь через `-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.example.yaml  # Пример конфигурации
-├── releases/
-│   └── memory/         # Changelog между тегами (v1.2.1.md, v1.2.2.md, ...)
-└── go.mod
-```
+---
 
 ## Releases & Changelog
 
-Change log между версиями хранится в `releases/memory/` каталоге в файлах вида `v{major}.{minor}.{patch}.md`.
+Changelog между версиями: `releases/memory/v{major}.{minor}.{patch}.md`
 
-Каждый файл содержит:
-- Список коммитов между версиями
-- Описание изменений и их влияния
-- Breaking changes и заметки о миграции
-
-**Перед работой над кодом проверьте последний файл в этой папке, чтобы понять текущее состояние проекта.**
-
-## Роли пользователей
-
-| Роль | Описание |
-|------|----------|
-| `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          # Вернуть архивную конфигурацию в активные
-GET  /api/sync/readiness                   # Статус readiness guard (ready|blocked|unknown)
-GET  /api/sync/status                      # Сводный статус синхронизации
-GET  /api/sync/info                        # Данные для модалки синхронизации
-POST /api/sync/push                        # Push pending changes (423, если blocked)
-POST /api/sync/all                         # Full sync push+pull (423, если blocked)
-POST /api/sync/components                  # Pull components (423, если blocked)
-POST /api/sync/pricelists                  # Pull pricelists (423, если blocked)
-```
-
-### Краткая карта sync API
-
-| Endpoint | Назначение | Поток |
-|----------|------------|-------|
-| `POST /api/sync/push` | Отправить локальные pending-изменения | `SQLite -> MariaDB` |
-| `POST /api/sync/components` | Подтянуть справочник компонентов | `MariaDB -> SQLite` |
-| `POST /api/sync/pricelists` | Подтянуть прайслисты и позиции | `MariaDB -> SQLite` |
-| `POST /api/sync/all` | Полный цикл: push + pull + импорт проектов/конфигураций | `двунаправленно` |
-| `GET /api/sync/readiness` | Статус preflight/readiness | `read-only` |
-| `GET /api/sync/status` / `GET /api/sync/info` | Сводка статуса и данных синхронизации | `read-only` |
-
-#### 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.
-
-## Разработка
-
-```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-local/01-overview.md

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

bible-local/02-architecture.md

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

bible-local/03-database.md

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

bible-local/04-api.md

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

bible-local/05-config.md

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

bible-local/06-backup.md

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

bible-local/07-dev.md

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

bible-local/09-vendor-spec.md

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

bible-local/README.md

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

cmd/migrate_ops_projects/main.go

@@ -163,7 +163,7 @@ func buildPlan(db *gorm.DB, fallbackOwner string) ([]migrationAction, map[string
 		}
 		for i := range projects {
 			p := projects[i]
-			existingProjects[projectKey(p.OwnerUsername, p.Name)] = &p
+			existingProjects[projectKey(p.OwnerUsername, derefString(p.Name))] = &p
 		}
 	}
 
@@ -253,12 +253,13 @@ 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,
-					Name:          action.TargetProjectName,
+					Code:          action.TargetProjectName,
+					Name:          ptrString(action.TargetProjectName),
 					IsActive:      true,
 					IsSystem:      false,
 				}
@@ -268,7 +269,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", project.Name, project.UUID, err)
+					return fmt.Errorf("reactivate project %s (%s): %w", derefString(project.Name), project.UUID, err)
 				}
 				project.IsActive = true
 			}
@@ -294,3 +295,14 @@ 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/main.go

@@ -46,10 +46,14 @@ var Version = "dev"
 
 const backgroundSyncInterval = 5 * time.Minute
 const onDemandPullCooldown = 30 * time.Second
+const startupConsoleWarning = "Не закрывайте консоль иначе приложение не будет работать"
 
 func main() {
+	showStartupConsoleWarning()
+
 	configPath := flag.String("config", "", "path to config file (default: user state dir or QFS_CONFIG_PATH)")
 	localDBPath := flag.String("localdb", "", "path to local SQLite database (default: user state dir or QFS_DB_PATH)")
+	resetLocalDB := flag.Bool("reset-localdb", false, "reset local SQLite data on startup (keeps connection settings)")
 	migrate := flag.Bool("migrate", false, "run database migrations")
 	version := flag.Bool("version", false, "show version information")
 	flag.Parse()
@@ -100,6 +104,13 @@ func main() {
 		}
 	}
 
+	if shouldResetLocalDB(*resetLocalDB) {
+		if err := localdb.ResetData(resolvedLocalDBPath); err != nil {
+			slog.Error("failed to reset local database", "error", err)
+			os.Exit(1)
+		}
+	}
+
 	// Initialize local SQLite database (always used)
 	local, err := localdb.New(resolvedLocalDBPath)
 	if err != nil {
@@ -232,6 +243,10 @@ func main() {
 	syncWorker := sync.NewWorker(syncService, connMgr, backgroundSyncInterval)
 	go syncWorker.Start(workerCtx)
 
+	backupCtx, backupCancel := context.WithCancel(context.Background())
+	defer backupCancel()
+	go startBackupScheduler(backupCtx, cfg, resolvedLocalDBPath, resolvedConfigPath)
+
 	srv := &http.Server{
 		Addr:         cfg.Address(),
 		Handler:      router,
@@ -274,6 +289,7 @@ func main() {
 	// Stop background sync worker first
 	syncWorker.Stop()
 	workerCancel()
+	backupCancel()
 
 	// Then shutdown HTTP server
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
@@ -290,6 +306,36 @@ func main() {
 	}
 }
 
+func showStartupConsoleWarning() {
+	// Visible in console output.
+	fmt.Println(startupConsoleWarning)
+	// Keep the warning always visible in the console window title when supported.
+	fmt.Printf("\033]0;%s\007", startupConsoleWarning)
+}
+
+func shouldResetLocalDB(flagValue bool) bool {
+	if flagValue {
+		return true
+	}
+	value := strings.TrimSpace(os.Getenv("QFS_RESET_LOCAL_DB"))
+	if value == "" {
+		return false
+	}
+	switch strings.ToLower(value) {
+	case "1", "true", "yes", "y":
+		return true
+	default:
+		return false
+	}
+}
+
+func derefString(value *string) string {
+	if value == nil {
+		return ""
+	}
+	return *value
+}
+
 func setConfigDefaults(cfg *config.Config) {
 	if cfg.Server.Host == "" {
 		cfg.Server.Host = "127.0.0.1"
@@ -324,6 +370,9 @@ func setConfigDefaults(cfg *config.Config) {
 	if cfg.Pricing.MinQuotesForMedian == 0 {
 		cfg.Pricing.MinQuotesForMedian = 3
 	}
+	if cfg.Backup.Time == "" {
+		cfg.Backup.Time = "00:00"
+	}
 }
 
 func ensureDefaultConfigFile(configPath string) error {
@@ -347,6 +396,9 @@ func ensureDefaultConfigFile(configPath string) error {
   read_timeout: 30s
   write_timeout: 30s
 
+backup:
+  time: "00:00"
+
 logging:
   level: "info"
   format: "json"
@@ -373,9 +425,14 @@ type runtimeLoggingConfig struct {
 	Output string `yaml:"output"`
 }
 
+type runtimeBackupConfig struct {
+	Time string `yaml:"time"`
+}
+
 type runtimeConfigFile struct {
 	Server  runtimeServerConfig  `yaml:"server"`
 	Logging runtimeLoggingConfig `yaml:"logging"`
+	Backup  runtimeBackupConfig  `yaml:"backup"`
 }
 
 // migrateConfigFileToRuntimeShape rewrites config.yaml in a minimal runtime format.
@@ -398,6 +455,9 @@ func migrateConfigFileToRuntimeShape(configPath string, cfg *config.Config) erro
 			Format: cfg.Logging.Format,
 			Output: cfg.Logging.Output,
 		},
+		Backup: runtimeBackupConfig{
+			Time: cfg.Backup.Time,
+		},
 	}
 
 	rendered, err := yaml.Marshal(&runtimeCfg)
@@ -416,6 +476,69 @@ func migrateConfigFileToRuntimeShape(configPath string, cfg *config.Config) erro
 	return nil
 }
 
+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 = 0
+		minute = 0
+	}
+
+	if created, backupErr := appstate.EnsureRotatingLocalBackup(dbPath, configPath); backupErr != nil {
+		slog.Error("local backup failed", "error", backupErr)
+	} else if len(created) > 0 {
+		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 {
+	location := now.Location()
+	target := time.Date(now.Year(), now.Month(), now.Day(), hour, minute, 0, 0, location)
+	if !now.Before(target) {
+		target = target.Add(24 * time.Hour)
+	}
+	return target
+}
+
 // runSetupMode starts a minimal server that only serves the setup page
 func runSetupMode(local *localdb.LocalDB) {
 	restartSig := make(chan struct{}, 1)
@@ -432,11 +555,11 @@ func runSetupMode(local *localdb.LocalDB) {
 	router := gin.New()
 	router.Use(gin.Recovery())
 
-	staticPath := filepath.Join("web", "static")
-	if stat, err := os.Stat(staticPath); err == nil && stat.IsDir() {
-		router.Static("/static", staticPath)
-	} else if staticFS, err := qfassets.StaticFS(); err == nil {
+	if staticFS, err := qfassets.StaticFS(); err == nil {
 		router.StaticFS("/static", http.FS(staticFS))
+	} else {
+		slog.Error("failed to load embedded static assets", "error", err)
+		os.Exit(1)
 	}
 
 	// Setup routes only
@@ -581,12 +704,12 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 	if mariaDB != nil {
 		componentService = services.NewComponentService(componentRepo, categoryRepo, statsRepo)
 		quoteService = services.NewQuoteService(componentRepo, statsRepo, pricelistRepo, local, nil)
-		exportService = services.NewExportService(cfg.Export, categoryRepo)
+		exportService = services.NewExportService(cfg.Export, categoryRepo, local)
 	} else {
 		// In offline mode, we still need to create services that don't require DB.
 		componentService = services.NewComponentService(nil, nil, nil)
 		quoteService = services.NewQuoteService(nil, nil, nil, local, nil)
-		exportService = services.NewExportService(cfg.Export, nil)
+		exportService = services.NewExportService(cfg.Export, nil, local)
 	}
 
 	// isOnline function for local-first architecture
@@ -695,8 +818,10 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 	// Handlers
 	componentHandler := handlers.NewComponentHandler(componentService, local)
 	quoteHandler := handlers.NewQuoteHandler(quoteService)
-	exportHandler := handlers.NewExportHandler(exportService, configService, componentService, projectService)
+	exportHandler := handlers.NewExportHandler(exportService, configService, projectService)
 	pricelistHandler := handlers.NewPricelistHandler(local)
+	vendorSpecHandler := handlers.NewVendorSpecHandler(local)
+	partnumberBooksHandler := handlers.NewPartnumberBooksHandler(local)
 	syncHandler, err := handlers.NewSyncHandler(local, syncService, connMgr, templatesPath, backgroundSyncInterval)
 	if err != nil {
 		return nil, nil, fmt.Errorf("creating sync handler: %w", err)
@@ -722,11 +847,10 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 	router.Use(middleware.OfflineDetector(connMgr, local))
 
 	// Static files (use filepath.Join for Windows compatibility)
-	staticPath := filepath.Join("web", "static")
-	if stat, err := os.Stat(staticPath); err == nil && stat.IsDir() {
-		router.Static("/static", staticPath)
-	} else if staticFS, err := qfassets.StaticFS(); err == nil {
+	if staticFS, err := qfassets.StaticFS(); err == nil {
 		router.StaticFS("/static", http.FS(staticFS))
+	} else {
+		return nil, nil, fmt.Errorf("load embedded static assets: %w", err)
 	}
 
 	// Health check
@@ -815,8 +939,10 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 	router.GET("/configurator", webHandler.Configurator)
 	router.GET("/projects", webHandler.Projects)
 	router.GET("/projects/:uuid", webHandler.ProjectDetail)
+	router.GET("/configs/:uuid/revisions", webHandler.ConfigRevisions)
 	router.GET("/pricelists", webHandler.Pricelists)
 	router.GET("/pricelists/:id", webHandler.PricelistDetail)
+	router.GET("/partnumber-books", webHandler.PartnumberBooks)
 
 	// htmx partials
 	partials := router.Group("/partials")
@@ -866,6 +992,13 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 			pricelists.GET("/:id/lots", pricelistHandler.GetLotNames)
 		}
 
+		// Partnumber books (read-only)
+		pnBooks := api.Group("/partnumber-books")
+		{
+			pnBooks.GET("", partnumberBooksHandler.List)
+			pnBooks.GET("/:id", partnumberBooksHandler.GetItems)
+		}
+
 		// Configurations (public - RBAC disabled)
 		configs := api.Group("/configs")
 		{
@@ -963,7 +1096,16 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 
 				config, err := configService.UpdateNoAuth(uuid, &req)
 				if err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					switch {
+					case errors.Is(err, services.ErrConfigNotFound):
+						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+					case errors.Is(err, services.ErrProjectNotFound):
+						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+					case errors.Is(err, services.ErrProjectForbidden):
+						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+					default:
+						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					}
 					return
 				}
 
@@ -1014,15 +1156,20 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 			configs.POST("/:uuid/clone", func(c *gin.Context) {
 				uuid := c.Param("uuid")
 				var req struct {
-					Name string `json:"name"`
+					Name        string `json:"name"`
+					FromVersion int    `json:"from_version"`
 				}
 				if err := c.ShouldBindJSON(&req); err != nil {
 					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 					return
 				}
 
-				config, err := configService.CloneNoAuth(uuid, req.Name, dbUsername)
+				config, err := configService.CloneNoAuthToProjectFromVersion(uuid, req.Name, dbUsername, nil, req.FromVersion)
 				if err != nil {
+					if errors.Is(err, services.ErrConfigVersionNotFound) {
+						c.JSON(http.StatusNotFound, gin.H{"error": "version not found"})
+						return
+					}
 					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 					return
 				}
@@ -1171,6 +1318,29 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 			})
 
 			configs.GET("/:uuid/export", exportHandler.ExportConfigCSV)
+
+			// Vendor spec (BOM) endpoints
+			configs.GET("/:uuid/vendor-spec", vendorSpecHandler.GetVendorSpec)
+			configs.PUT("/:uuid/vendor-spec", vendorSpecHandler.PutVendorSpec)
+			configs.POST("/:uuid/vendor-spec/resolve", vendorSpecHandler.ResolveVendorSpec)
+			configs.POST("/:uuid/vendor-spec/apply", vendorSpecHandler.ApplyVendorSpec)
+
+			configs.PATCH("/:uuid/server-count", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				var req struct {
+					ServerCount int `json:"server_count" binding:"required,min=1"`
+				}
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+				config, err := configService.UpdateServerCount(uuid, req.ServerCount)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+				c.JSON(http.StatusOK, config)
+			})
 		}
 
 		projects := api.Group("/projects")
@@ -1224,7 +1394,10 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 					if status == "archived" && p.IsActive {
 						continue
 					}
-					if search != "" && !strings.Contains(strings.ToLower(p.Name), search) {
+					if search != "" &&
+						!strings.Contains(strings.ToLower(derefString(p.Name)), search) &&
+						!strings.Contains(strings.ToLower(p.Code), search) &&
+						!strings.Contains(strings.ToLower(p.Variant), search) {
 						continue
 					}
 					if author != "" && !strings.Contains(strings.ToLower(strings.TrimSpace(p.OwnerUsername)), author) {
@@ -1237,8 +1410,8 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 					left := filtered[i]
 					right := filtered[j]
 					if sortField == "name" {
-						leftName := strings.ToLower(strings.TrimSpace(left.Name))
-						rightName := strings.ToLower(strings.TrimSpace(right.Name))
+						leftName := strings.ToLower(strings.TrimSpace(derefString(left.Name)))
+						rightName := strings.ToLower(strings.TrimSpace(derefString(right.Name)))
 						if leftName == rightName {
 							if sortDir == "asc" {
 								return left.CreatedAt.Before(right.CreatedAt)
@@ -1251,8 +1424,8 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 						return leftName > rightName
 					}
 					if left.CreatedAt.Equal(right.CreatedAt) {
-						leftName := strings.ToLower(strings.TrimSpace(left.Name))
-						rightName := strings.ToLower(strings.TrimSpace(right.Name))
+						leftName := strings.ToLower(strings.TrimSpace(derefString(left.Name)))
+						rightName := strings.ToLower(strings.TrimSpace(derefString(right.Name)))
 						if sortDir == "asc" {
 							return leftName < rightName
 						}
@@ -1311,6 +1484,8 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 						"id":             p.ID,
 						"uuid":           p.UUID,
 						"owner_username": p.OwnerUsername,
+						"code":           p.Code,
+						"variant":        p.Variant,
 						"name":           p.Name,
 						"tracker_url":    p.TrackerURL,
 						"is_active":      p.IsActive,
@@ -1336,31 +1511,36 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 				})
 			})
 
+			// GET /api/projects/all - Returns all projects without pagination for UI dropdowns
+			projects.GET("/all", func(c *gin.Context) {
+				allProjects, err := projectService.ListByUser(dbUsername, true)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
 
-		// GET /api/projects/all - Returns all projects without pagination for UI dropdowns
-		projects.GET("/all", func(c *gin.Context) {
-			allProjects, err := projectService.ListByUser(dbUsername, true)
-			if err != nil {
-				c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-				return
-			}
+				// Return simplified list of all projects (UUID + Name only)
+				type ProjectSimple struct {
+					UUID     string `json:"uuid"`
+					Code     string `json:"code"`
+					Variant  string `json:"variant"`
+					Name     string `json:"name"`
+					IsActive bool   `json:"is_active"`
+				}
 
-			// Return simplified list of all projects (UUID + Name only)
-			type ProjectSimple struct {
-				UUID string `json:"uuid"`
-				Name string `json:"name"`
-			}
+				simplified := make([]ProjectSimple, 0, len(allProjects))
+				for _, p := range allProjects {
+					simplified = append(simplified, ProjectSimple{
+						UUID:     p.UUID,
+						Code:     p.Code,
+						Variant:  p.Variant,
+						Name:     derefString(p.Name),
+						IsActive: p.IsActive,
+					})
+				}
 
-			simplified := make([]ProjectSimple, 0, len(allProjects))
-			for _, p := range allProjects {
-				simplified = append(simplified, ProjectSimple{
-					UUID: p.UUID,
-					Name: p.Name,
-				})
-			}
-
-			c.JSON(http.StatusOK, simplified)
-		})
+				c.JSON(http.StatusOK, simplified)
+			})
 
 			projects.POST("", func(c *gin.Context) {
 				var req services.CreateProjectRequest
@@ -1368,13 +1548,18 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 					return
 				}
-				if strings.TrimSpace(req.Name) == "" {
-					c.JSON(http.StatusBadRequest, gin.H{"error": "project name is required"})
+				if strings.TrimSpace(req.Code) == "" {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "project code is required"})
 					return
 				}
 				project, err := projectService.Create(dbUsername, &req)
 				if err != nil {
-					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					switch {
+					case errors.Is(err, services.ErrProjectCodeExists):
+						c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
+					default:
+						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					}
 					return
 				}
 				c.JSON(http.StatusCreated, project)
@@ -1402,13 +1587,11 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 					return
 				}
-				if strings.TrimSpace(req.Name) == "" {
-					c.JSON(http.StatusBadRequest, gin.H{"error": "project name is required"})
-					return
-				}
 				project, err := projectService.Update(c.Param("uuid"), dbUsername, &req)
 				if err != nil {
 					switch {
+					case errors.Is(err, services.ErrProjectCodeExists):
+						c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
 					case errors.Is(err, services.ErrProjectNotFound):
 						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
 					case errors.Is(err, services.ErrProjectForbidden):
@@ -1451,6 +1634,23 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 				c.JSON(http.StatusOK, gin.H{"message": "project reactivated"})
 			})
 
+			projects.DELETE("/:uuid", func(c *gin.Context) {
+				if err := projectService.DeleteVariant(c.Param("uuid"), dbUsername); err != nil {
+					switch {
+					case errors.Is(err, services.ErrCannotDeleteMainVariant):
+						c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					case errors.Is(err, services.ErrProjectNotFound):
+						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+					case errors.Is(err, services.ErrProjectForbidden):
+						c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+					default:
+						c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					}
+					return
+				}
+				c.JSON(http.StatusOK, gin.H{"message": "variant deleted"})
+			})
+
 			projects.GET("/:uuid/configs", func(c *gin.Context) {
 				triggerPull("configs", &configsPullState, syncConfigurationsFromServer)
 
@@ -1476,6 +1676,43 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 				c.JSON(http.StatusOK, result)
 			})
 
+			projects.PATCH("/:uuid/configs/reorder", func(c *gin.Context) {
+				var req struct {
+					OrderedUUIDs []string `json:"ordered_uuids"`
+				}
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+				if len(req.OrderedUUIDs) == 0 {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "ordered_uuids is required"})
+					return
+				}
+
+				configs, err := configService.ReorderProjectConfigurationsNoAuth(c.Param("uuid"), req.OrderedUUIDs)
+				if err != nil {
+					switch {
+					case errors.Is(err, services.ErrProjectNotFound):
+						c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+					default:
+						c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					}
+					return
+				}
+
+				total := 0.0
+				for i := range configs {
+					if configs[i].TotalPrice != nil {
+						total += *configs[i].TotalPrice
+					}
+				}
+				c.JSON(http.StatusOK, gin.H{
+					"project_uuid":   c.Param("uuid"),
+					"configurations": configs,
+					"total":          total,
+				})
+			})
+
 			projects.POST("/:uuid/configs", func(c *gin.Context) {
 				var req services.CreateConfigRequest
 				if err := c.ShouldBindJSON(&req); err != nil {
@@ -1493,6 +1730,8 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 				c.JSON(http.StatusCreated, config)
 			})
 
+			projects.GET("/:uuid/export", exportHandler.ExportProjectCSV)
+
 			projects.POST("/:uuid/configs/:config_uuid/clone", func(c *gin.Context) {
 				var req struct {
 					Name string `json:"name"`
@@ -1521,10 +1760,13 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 			syncAPI.GET("/users-status", syncHandler.GetUsersStatus)
 			syncAPI.POST("/components", syncHandler.SyncComponents)
 			syncAPI.POST("/pricelists", syncHandler.SyncPricelists)
+			syncAPI.POST("/partnumber-books", syncHandler.SyncPartnumberBooks)
+			syncAPI.POST("/partnumber-seen", syncHandler.ReportPartnumberSeen)
 			syncAPI.POST("/all", syncHandler.SyncAll)
 			syncAPI.POST("/push", syncHandler.PushPendingChanges)
 			syncAPI.GET("/pending/count", syncHandler.GetPendingCount)
 			syncAPI.GET("/pending", syncHandler.GetPendingChanges)
+			syncAPI.POST("/repair", syncHandler.RepairPendingChanges)
 		}
 	}
 
@@ -1576,11 +1818,37 @@ func requestLogger() gin.HandlerFunc {
 		path := c.Request.URL.Path
 		query := c.Request.URL.RawQuery
 
+		blw := &captureResponseWriter{
+			ResponseWriter: c.Writer,
+			body:           bytes.NewBuffer(nil),
+		}
+		c.Writer = blw
+
 		c.Next()
 
 		latency := time.Since(start)
 		status := c.Writer.Status()
 
+		if status >= http.StatusBadRequest {
+			responseBody := strings.TrimSpace(blw.body.String())
+			if len(responseBody) > 2048 {
+				responseBody = responseBody[:2048] + "...(truncated)"
+			}
+			errText := strings.TrimSpace(c.Errors.String())
+
+			slog.Error("request failed",
+				"method", c.Request.Method,
+				"path", path,
+				"query", query,
+				"status", status,
+				"latency", latency,
+				"ip", c.ClientIP(),
+				"errors", errText,
+				"response", responseBody,
+			)
+			return
+		}
+
 		slog.Info("request",
 			"method", c.Request.Method,
 			"path", path,
@@ -1591,3 +1859,22 @@ func requestLogger() gin.HandlerFunc {
 		)
 	}
 }
+
+type captureResponseWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+func (w *captureResponseWriter) Write(b []byte) (int, error) {
+	if len(b) > 0 {
+		_, _ = w.body.Write(b)
+	}
+	return w.ResponseWriter.Write(b)
+}
+
+func (w *captureResponseWriter) WriteString(s string) (int, error) {
+	if s != "" {
+		_, _ = w.body.WriteString(s)
+	}
+	return w.ResponseWriter.WriteString(s)
+}

cmd/qfs/versioning_api_test.go

@@ -77,7 +77,7 @@ func TestConfigurationVersioningAPI(t *testing.T) {
 	if err := json.Unmarshal(rbRec.Body.Bytes(), &rbResp); err != nil {
 		t.Fatalf("unmarshal rollback response: %v", err)
 	}
-	if rbResp.Message == "" || rbResp.CurrentVersion.VersionNo != 3 {
+	if rbResp.Message == "" || rbResp.CurrentVersion.VersionNo != 2 {
 		t.Fatalf("unexpected rollback response: %+v", rbResp)
 	}
 
@@ -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"}`)))
+	createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"P1","code":"P1"}`)))
 	createProjectReq.Header.Set("Content-Type", "application/json")
 	createProjectRec := httptest.NewRecorder()
 	router.ServeHTTP(createProjectRec, createProjectReq)
@@ -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"}`)))
+	createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"Move Project","code":"MOVE"}`)))
 	createProjectReq.Header.Set("Content-Type", "application/json")
 	createProjectRec := httptest.NewRecorder()
 	router.ServeHTTP(createProjectRec, createProjectReq)

config.example.yaml

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

internal/appstate/backup.go

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

internal/appstate/backup_test.go

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

internal/article/categories.go

@@ -71,13 +71,31 @@ func ResolveLotCategoriesStrict(local *localdb.LocalDB, serverPricelistID uint,
 	if err != nil {
 		return nil, err
 	}
+	missing := make([]string, 0)
 	for _, lot := range lotNames {
 		cat := strings.TrimSpace(cats[lot])
 		if cat == "" {
-			return nil, &MissingCategoryForLotError{LotName: lot}
+			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
 }
 

internal/article/categories_test.go

@@ -45,6 +45,49 @@ func TestResolveLotCategoriesStrict_MissingCategoryReturnsError(t *testing.T) {
 	}
 }
 
+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")
@@ -53,4 +96,3 @@ func TestGroupForLotCategory(t *testing.T) {
 		t.Fatalf("expected SFP to be excluded")
 	}
 }
-

internal/article/generator.go

@@ -195,6 +195,9 @@ func buildGPUSegment(items []models.ConfigItem, cats map[string]string) string {
 		if !ok || group != GroupGPU {
 			continue
 		}
+		if strings.HasPrefix(strings.ToUpper(it.LotName), "MB_") {
+			continue
+		}
 		model := parseGPUModel(it.LotName)
 		if model == "" {
 			model = "UNK"
@@ -332,7 +335,7 @@ func parseGPUModel(lotName string) string {
 			continue
 		}
 		switch p {
-		case "NV", "NVIDIA", "AMD", "RADEON", "PCIE", "PCI", "SXM", "SXMX":
+		case "NV", "NVIDIA", "INTEL", "AMD", "RADEON", "PCIE", "PCI", "SXM", "SXMX":
 			continue
 		default:
 			if strings.Contains(p, "GB") {

internal/config/config.go

@@ -20,6 +20,7 @@ type Config struct {
 	Alerts        AlertsConfig        `yaml:"alerts"`
 	Notifications NotificationsConfig `yaml:"notifications"`
 	Logging       LoggingConfig       `yaml:"logging"`
+	Backup        BackupConfig        `yaml:"backup"`
 }
 
 type ServerConfig struct {
@@ -101,6 +102,10 @@ type LoggingConfig struct {
 	FilePath string `yaml:"file_path"`
 }
 
+type BackupConfig struct {
+	Time string `yaml:"time"`
+}
+
 func Load(path string) (*Config, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
@@ -182,6 +187,10 @@ func (c *Config) setDefaults() {
 	if c.Logging.Output == "" {
 		c.Logging.Output = "stdout"
 	}
+
+	if c.Backup.Time == "" {
+		c.Backup.Time = "00:00"
+	}
 }
 
 func (c *Config) Address() string {

internal/handlers/export.go

@@ -7,37 +7,37 @@ import (
 	"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
-	componentService *services.ComponentService
-	projectService   *services.ProjectService
+	exportService  *services.ExportService
+	configService  services.ConfigurationGetter
+	projectService *services.ProjectService
 }
 
 func NewExportHandler(
 	exportService *services.ExportService,
 	configService services.ConfigurationGetter,
-	componentService *services.ComponentService,
 	projectService *services.ProjectService,
 ) *ExportHandler {
 	return &ExportHandler{
-		exportService:    exportService,
-		configService:    configService,
-		componentService: componentService,
-		projectService:   projectService,
+		exportService:  exportService,
+		configService:  configService,
+		projectService: projectService,
 	}
 }
 
 type ExportRequest struct {
-	Name         string `json:"name" binding:"required"`
-	ProjectName  string `json:"project_name"`
-	ProjectUUID  string `json:"project_uuid"`
-	Article      string `json:"article"`
-	Items        []struct {
+	Name        string `json:"name" binding:"required"`
+	ProjectName string `json:"project_name"`
+	ProjectUUID string `json:"project_uuid"`
+	Article     string `json:"article"`
+	ServerCount int    `json:"server_count"`
+	PricelistID *uint  `json:"pricelist_id"`
+	Items       []struct {
 		LotName   string  `json:"lot_name" binding:"required"`
 		Quantity  int     `json:"quantity" binding:"required,min=1"`
 		UnitPrice float64 `json:"unit_price"`
@@ -55,22 +55,21 @@ func (h *ExportHandler) ExportCSV(c *gin.Context) {
 	data := h.buildExportData(&req)
 
 	// Validate before streaming (can return JSON error)
-	if len(data.Items) == 0 {
+	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 name if available
-	projectName := req.ProjectName
-	if projectName == "" && req.ProjectUUID != "" {
-		// Try to load project name from database
+	// 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 {
-			projectName = project.Name
+			projectCode = project.Code
 		}
 	}
-	if projectName == "" {
-		projectName = req.Name
+	if projectCode == "" {
+		projectCode = req.Name
 	}
 
 	// Set headers before streaming
@@ -79,7 +78,7 @@ func (h *ExportHandler) ExportCSV(c *gin.Context) {
 	if articleSegment == "" {
 		articleSegment = "BOM"
 	}
-	filename := fmt.Sprintf("%s (%s) %s %s.csv", exportDate.Format("2006-01-02"), projectName, req.Name, articleSegment)
+	filename := fmt.Sprintf("%s (%s) %s %s.csv", exportDate.Format("2006-01-02"), projectCode, req.Name, articleSegment)
 	c.Header("Content-Type", "text/csv; charset=utf-8")
 	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
 
@@ -90,44 +89,32 @@ func (h *ExportHandler) ExportCSV(c *gin.Context) {
 	}
 }
 
-func (h *ExportHandler) buildExportData(req *ExportRequest) *services.ExportData {
-	items := make([]services.ExportItem, len(req.Items))
-	var total float64
-
+// buildExportData converts an ExportRequest into a ProjectExportData using a temporary Configuration model
+// so that ExportService.ConfigToExportData can resolve categories via localDB.
+func (h *ExportHandler) buildExportData(req *ExportRequest) *services.ProjectExportData {
+	configItems := make(models.ConfigItems, len(req.Items))
 	for i, item := range req.Items {
-		itemTotal := item.UnitPrice * float64(item.Quantity)
-
-		// Получаем информацию о компоненте для заполнения категории и описания
-		componentView, err := h.componentService.GetByLotName(item.LotName)
-		if err != nil {
-			// Если не удалось получить информацию о компоненте, используем только основные данные
-			items[i] = services.ExportItem{
-				LotName:    item.LotName,
-				Quantity:   item.Quantity,
-				UnitPrice:  item.UnitPrice,
-				TotalPrice: itemTotal,
-			}
-		} else {
-			items[i] = services.ExportItem{
-				LotName:     item.LotName,
-				Description: componentView.Description,
-				Category:    componentView.Category,
-				Quantity:    item.Quantity,
-				UnitPrice:   item.UnitPrice,
-				TotalPrice:  itemTotal,
-			}
+		configItems[i] = models.ConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
 		}
-		total += itemTotal
 	}
 
-	return &services.ExportData{
-		Name:      req.Name,
-		Article:   req.Article,
-		Items:     items,
-		Total:     total,
-		Notes:     req.Notes,
-		CreatedAt: time.Now(),
+	serverCount := req.ServerCount
+	if serverCount < 1 {
+		serverCount = 1
 	}
+
+	cfg := &models.Configuration{
+		Article:     req.Article,
+		ServerCount: serverCount,
+		PricelistID: req.PricelistID,
+		Items:       configItems,
+		CreatedAt:   time.Now(),
+	}
+
+	return h.exportService.ConfigToExportData(cfg)
 }
 
 func sanitizeFilenameSegment(value string) string {
@@ -159,19 +146,19 @@ func (h *ExportHandler) ExportConfigCSV(c *gin.Context) {
 		return
 	}
 
-	data := h.exportService.ConfigToExportData(config, h.componentService)
+	data := h.exportService.ConfigToExportData(config)
 
 	// Validate before streaming (can return JSON error)
-	if len(data.Items) == 0 {
+	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 name if configuration belongs to a project
-	projectName := config.Name // fallback: use config name if no project
+	// 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 {
-			projectName = project.Name
+			projectCode = project.Code
 		}
 	}
 
@@ -181,7 +168,7 @@ func (h *ExportHandler) ExportConfigCSV(c *gin.Context) {
 	if config.PriceUpdatedAt != nil {
 		exportDate = *config.PriceUpdatedAt
 	}
-	filename := fmt.Sprintf("%s (%s) %s BOM.csv", exportDate.Format("2006-01-02"), projectName, config.Name)
+	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))
 
@@ -191,3 +178,38 @@ func (h *ExportHandler) ExportConfigCSV(c *gin.Context) {
 		return
 	}
 }
+
+// ExportProjectCSV exports all active configurations of a project as a single CSV file.
+func (h *ExportHandler) ExportProjectCSV(c *gin.Context) {
+	username := middleware.GetUsername(c)
+	projectUUID := c.Param("uuid")
+
+	project, err := h.projectService.GetByUUID(projectUUID, username)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+
+	result, err := h.projectService.ListConfigurations(projectUUID, username, "active")
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	if len(result.Configs) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "no configurations to export"})
+		return
+	}
+
+	data := h.exportService.ProjectToExportData(result.Configs)
+
+	// Filename: YYYY-MM-DD (ProjectCode) BOM.csv
+	filename := fmt.Sprintf("%s (%s) BOM.csv", time.Now().Format("2006-01-02"), project.Code)
+	c.Header("Content-Type", "text/csv; charset=utf-8")
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
+
+	if err := h.exportService.ToCSV(c.Writer, data); err != nil {
+		c.Error(err)
+		return
+	}
+}

internal/handlers/export_test.go

@@ -30,15 +30,11 @@ func (m *mockConfigService) GetByUUID(uuid string, ownerUsername string) (*model
 func TestExportCSV_Success(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
-	// Create a basic mock component service that doesn't panic
-	mockComponentService := &services.ComponentService{}
-
 	// Create handler with mocks
-	exportSvc := services.NewExportService(config.ExportConfig{}, nil)
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
 	handler := NewExportHandler(
 		exportSvc,
 		&mockConfigService{},
-		mockComponentService,
 		nil,
 	)
 
@@ -88,7 +84,7 @@ func TestExportCSV_Success(t *testing.T) {
 
 	expectedBOM := []byte{0xEF, 0xBB, 0xBF}
 	actualBOM := responseBody[:3]
-	if bytes.Compare(actualBOM, expectedBOM) != 0 {
+	if !bytes.Equal(actualBOM, expectedBOM) {
 		t.Errorf("UTF-8 BOM mismatch. Expected %v, got %v", expectedBOM, actualBOM)
 	}
 
@@ -101,19 +97,18 @@ func TestExportCSV_Success(t *testing.T) {
 		t.Errorf("Failed to parse CSV header: %v", err)
 	}
 
-	if len(header) != 6 {
-		t.Errorf("Expected 6 columns, got %d", len(header))
+	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)
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
 	handler := NewExportHandler(
 		exportSvc,
 		&mockConfigService{},
-		&services.ComponentService{},
 		nil,
 	)
 
@@ -143,11 +138,10 @@ func TestExportCSV_InvalidRequest(t *testing.T) {
 func TestExportCSV_EmptyItems(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
-	exportSvc := services.NewExportService(config.ExportConfig{}, nil)
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
 	handler := NewExportHandler(
 		exportSvc,
 		&mockConfigService{},
-		&services.ComponentService{},
 		nil,
 	)
 
@@ -185,11 +179,10 @@ func TestExportConfigCSV_Success(t *testing.T) {
 		CreatedAt: time.Now(),
 	}
 
-	exportSvc := services.NewExportService(config.ExportConfig{}, nil)
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
 	handler := NewExportHandler(
 		exportSvc,
 		&mockConfigService{config: mockConfig},
-		&services.ComponentService{},
 		nil,
 	)
 
@@ -227,7 +220,7 @@ func TestExportConfigCSV_Success(t *testing.T) {
 
 	expectedBOM := []byte{0xEF, 0xBB, 0xBF}
 	actualBOM := responseBody[:3]
-	if bytes.Compare(actualBOM, expectedBOM) != 0 {
+	if !bytes.Equal(actualBOM, expectedBOM) {
 		t.Errorf("UTF-8 BOM mismatch")
 	}
 }
@@ -235,11 +228,10 @@ func TestExportConfigCSV_Success(t *testing.T) {
 func TestExportConfigCSV_NotFound(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
-	exportSvc := services.NewExportService(config.ExportConfig{}, nil)
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
 	handler := NewExportHandler(
 		exportSvc,
 		&mockConfigService{err: errors.New("config not found")},
-		&services.ComponentService{},
 		nil,
 	)
 
@@ -280,11 +272,10 @@ func TestExportConfigCSV_EmptyItems(t *testing.T) {
 		CreatedAt:     time.Now(),
 	}
 
-	exportSvc := services.NewExportService(config.ExportConfig{}, nil)
+	exportSvc := services.NewExportService(config.ExportConfig{}, nil, nil)
 	handler := NewExportHandler(
 		exportSvc,
 		&mockConfigService{config: mockConfig},
-		&services.ComponentService{},
 		nil,
 	)
 

internal/handlers/partnumber_books.go

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

internal/handlers/pricelist.go

@@ -46,8 +46,30 @@ func (h *PricelistHandler) List(c *gin.Context) {
 		}
 		localPLs = filtered
 	}
-	if activeOnly {
-		// Local cache stores only active snapshots for normal operations.
+	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)
@@ -62,10 +84,14 @@ func (h *PricelistHandler) List(c *gin.Context) {
 	pageSlice := localPLs[start:end]
 	summaries := make([]map[string]interface{}, 0, len(pageSlice))
 	for _, lpl := range pageSlice {
-		itemCount := h.localDB.CountLocalPricelistItems(lpl.ID)
+		itemCount := int64(0)
 		usageCount := 0
-		if lpl.IsUsed {
-			usageCount = 1
+		for _, row := range withCounts {
+			if row.pricelist.ID == lpl.ID {
+				itemCount = row.itemCount
+				usageCount = row.usageCount
+				break
+			}
 		}
 		summaries = append(summaries, map[string]interface{}{
 			"id":          lpl.ServerID,

internal/handlers/pricelist_test.go

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

internal/handlers/sync.go

@@ -6,8 +6,6 @@ import (
 	"html/template"
 	"log/slog"
 	"net/http"
-	"os"
-	"path/filepath"
 	stdsync "sync"
 	"time"
 
@@ -32,16 +30,9 @@ type SyncHandler struct {
 }
 
 // NewSyncHandler creates a new sync handler
-func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, templatesPath string, autoSyncInterval time.Duration) (*SyncHandler, error) {
+func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, _ string, autoSyncInterval time.Duration) (*SyncHandler, error) {
 	// Load sync_status partial template
-	partialPath := filepath.Join(templatesPath, "partials", "sync_status.html")
-	var tmpl *template.Template
-	var err error
-	if stat, statErr := os.Stat(templatesPath); statErr == nil && stat.IsDir() {
-		tmpl, err = template.ParseFiles(partialPath)
-	} else {
-		tmpl, err = template.ParseFS(qfassets.TemplatesFS, "web/templates/partials/sync_status.html")
-	}
+	tmpl, err := template.ParseFS(qfassets.TemplatesFS, "web/templates/partials/sync_status.html")
 	if err != nil {
 		return nil, err
 	}
@@ -243,6 +234,33 @@ func (h *SyncHandler) SyncPricelists(c *gin.Context) {
 	h.syncService.RecordSyncHeartbeat()
 }
 
+// SyncPartnumberBooks syncs partnumber book snapshots from MariaDB to local SQLite.
+// POST /api/sync/partnumber-books
+func (h *SyncHandler) SyncPartnumberBooks(c *gin.Context) {
+	if !h.ensureSyncReadiness(c) {
+		return
+	}
+
+	startTime := time.Now()
+	pulled, err := h.syncService.PullPartnumberBooks()
+	if err != nil {
+		slog.Error("partnumber books pull failed", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, SyncResultResponse{
+		Success:  true,
+		Message:  "Partnumber books synced successfully",
+		Synced:   pulled,
+		Duration: time.Since(startTime).String(),
+	})
+	h.syncService.RecordSyncHeartbeat()
+}
+
 // SyncAllResponse represents result of full sync
 type SyncAllResponse struct {
 	Success                bool   `json:"success"`
@@ -419,6 +437,26 @@ 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
 type SyncInfoResponse struct {
 	// Connection
@@ -632,3 +670,37 @@ func (h *SyncHandler) getReadinessCached(maxAge time.Duration) *sync.SyncReadine
 	h.readinessMu.Unlock()
 	return readiness
 }
+
+// ReportPartnumberSeen pushes unresolved vendor partnumbers to qt_vendor_partnumber_seen on MariaDB.
+// POST /api/sync/partnumber-seen
+func (h *SyncHandler) ReportPartnumberSeen(c *gin.Context) {
+	var body struct {
+		Items []struct {
+			Partnumber  string `json:"partnumber"`
+			Description string `json:"description"`
+			Ignored     bool   `json:"ignored"`
+		} `json:"items"`
+	}
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	items := make([]sync.SeenPartnumber, 0, len(body.Items))
+	for _, it := range body.Items {
+		if it.Partnumber != "" {
+			items = append(items, sync.SeenPartnumber{
+				Partnumber:  it.Partnumber,
+				Description: it.Description,
+				Ignored:     it.Ignored,
+			})
+		}
+	}
+
+	if err := h.syncService.PushPartnumberSeen(items); err != nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"reported": len(items)})
+}

internal/handlers/vendor_spec.go

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

internal/handlers/web.go

@@ -2,8 +2,6 @@ package handlers
 
 import (
 	"html/template"
-	"os"
-	"path/filepath"
 	"strconv"
 
 	qfassets "git.mchus.pro/mchus/quoteforge"
@@ -17,7 +15,7 @@ type WebHandler struct {
 	componentService *services.ComponentService
 }
 
-func NewWebHandler(templatesPath string, componentService *services.ComponentService) (*WebHandler, error) {
+func NewWebHandler(_ string, componentService *services.ComponentService) (*WebHandler, error) {
 	funcMap := template.FuncMap{
 		"sub": func(a, b int) int { return a - b },
 		"add": func(a, b int) int { return a + b },
@@ -60,27 +58,16 @@ func NewWebHandler(templatesPath string, componentService *services.ComponentSer
 	}
 
 	templates := make(map[string]*template.Template)
-	basePath := filepath.Join(templatesPath, "base.html")
-	useDisk := false
-	if stat, statErr := os.Stat(templatesPath); statErr == nil && stat.IsDir() {
-		useDisk = true
-	}
-
 	// Load each page template with base
-	simplePages := []string{"login.html", "configs.html", "projects.html", "project_detail.html", "pricelists.html", "pricelist_detail.html"}
+	simplePages := []string{"login.html", "configs.html", "projects.html", "project_detail.html", "pricelists.html", "pricelist_detail.html", "config_revisions.html", "partnumber_books.html"}
 	for _, page := range simplePages {
-		pagePath := filepath.Join(templatesPath, page)
 		var tmpl *template.Template
 		var err error
-		if useDisk {
-			tmpl, err = template.New("").Funcs(funcMap).ParseFiles(basePath, pagePath)
-		} else {
-			tmpl, err = template.New("").Funcs(funcMap).ParseFS(
-				qfassets.TemplatesFS,
-				"web/templates/base.html",
-				"web/templates/"+page,
-			)
-		}
+		tmpl, err = template.New("").Funcs(funcMap).ParseFS(
+			qfassets.TemplatesFS,
+			"web/templates/base.html",
+			"web/templates/"+page,
+		)
 		if err != nil {
 			return nil, err
 		}
@@ -88,20 +75,14 @@ func NewWebHandler(templatesPath string, componentService *services.ComponentSer
 	}
 
 	// Index page needs components_list.html as well
-	indexPath := filepath.Join(templatesPath, "index.html")
-	componentsListPath := filepath.Join(templatesPath, "components_list.html")
 	var indexTmpl *template.Template
 	var err error
-	if useDisk {
-		indexTmpl, err = template.New("").Funcs(funcMap).ParseFiles(basePath, indexPath, componentsListPath)
-	} else {
-		indexTmpl, err = template.New("").Funcs(funcMap).ParseFS(
-			qfassets.TemplatesFS,
-			"web/templates/base.html",
-			"web/templates/index.html",
-			"web/templates/components_list.html",
-		)
-	}
+	indexTmpl, err = template.New("").Funcs(funcMap).ParseFS(
+		qfassets.TemplatesFS,
+		"web/templates/base.html",
+		"web/templates/index.html",
+		"web/templates/components_list.html",
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -110,17 +91,12 @@ func NewWebHandler(templatesPath string, componentService *services.ComponentSer
 	// Load partial templates (no base needed)
 	partials := []string{"components_list.html"}
 	for _, partial := range partials {
-		partialPath := filepath.Join(templatesPath, partial)
 		var tmpl *template.Template
 		var err error
-		if useDisk {
-			tmpl, err = template.New("").Funcs(funcMap).ParseFiles(partialPath)
-		} else {
-			tmpl, err = template.New("").Funcs(funcMap).ParseFS(
-				qfassets.TemplatesFS,
-				"web/templates/"+partial,
-			)
-		}
+		tmpl, err = template.New("").Funcs(funcMap).ParseFS(
+			qfassets.TemplatesFS,
+			"web/templates/"+partial,
+		)
 		if err != nil {
 			return nil, err
 		}
@@ -147,8 +123,8 @@ func (h *WebHandler) render(c *gin.Context, name string, data gin.H) {
 }
 
 func (h *WebHandler) Index(c *gin.Context) {
-	// Redirect to configs page - configurator is accessed via /configurator?uuid=...
-	c.Redirect(302, "/configs")
+	// Redirect to projects page - configurator is accessed via /configurator?uuid=...
+	c.Redirect(302, "/projects")
 }
 
 func (h *WebHandler) Configurator(c *gin.Context) {
@@ -197,6 +173,13 @@ 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) Pricelists(c *gin.Context) {
 	h.render(c, "pricelists.html", gin.H{"ActivePage": "pricelists"})
 }
@@ -205,6 +188,10 @@ func (h *WebHandler) PricelistDetail(c *gin.Context) {
 	h.render(c, "pricelist_detail.html", gin.H{"ActivePage": "pricelists"})
 }
 
+func (h *WebHandler) PartnumberBooks(c *gin.Context) {
+	h.render(c, "partnumber_books.html", gin.H{"ActivePage": "partnumber-books"})
+}
+
 // Partials for htmx
 
 func (h *WebHandler) ComponentsPartial(c *gin.Context) {

internal/localdb/components.go

@@ -242,6 +242,31 @@ func (l *LocalDB) GetLocalComponent(lotName string) (*LocalComponent, error) {
 	return &component, nil
 }
 
+// GetLocalComponentCategoriesByLotNames returns category for each lot_name in the local component cache.
+// Missing lots are not included in the map; caller is responsible for strict validation.
+func (l *LocalDB) GetLocalComponentCategoriesByLotNames(lotNames []string) (map[string]string, error) {
+	result := make(map[string]string, len(lotNames))
+	if len(lotNames) == 0 {
+		return result, nil
+	}
+
+	type row struct {
+		LotName  string `gorm:"column:lot_name"`
+		Category string `gorm:"column:category"`
+	}
+	var rows []row
+	if err := l.db.Model(&LocalComponent{}).
+		Select("lot_name, category").
+		Where("lot_name IN ?", lotNames).
+		Find(&rows).Error; err != nil {
+		return nil, err
+	}
+	for _, r := range rows {
+		result[r.LotName] = r.Category
+	}
+	return result, nil
+}
+
 // GetLocalComponentCategories returns distinct categories from local components
 func (l *LocalDB) GetLocalComponentCategories() ([]string, error) {
 	var categories []string
@@ -302,4 +327,3 @@ func (l *LocalDB) NeedComponentSync(maxAgeHours int) bool {
 	}
 	return time.Since(*syncTime).Hours() > float64(maxAgeHours)
 }
-

internal/localdb/converters.go

@@ -33,6 +33,7 @@ func ConfigurationToLocal(cfg *models.Configuration) *LocalConfiguration {
 		Article:          cfg.Article,
 		PricelistID:      cfg.PricelistID,
 		OnlyInStock:      cfg.OnlyInStock,
+		Line:             cfg.Line,
 		PriceUpdatedAt:   cfg.PriceUpdatedAt,
 		CreatedAt:        cfg.CreatedAt,
 		UpdatedAt:        time.Now(),
@@ -80,6 +81,7 @@ func LocalToConfiguration(local *LocalConfiguration) *models.Configuration {
 		Article:        local.Article,
 		PricelistID:    local.PricelistID,
 		OnlyInStock:    local.OnlyInStock,
+		Line:           local.Line,
 		PriceUpdatedAt: local.PriceUpdatedAt,
 		CreatedAt:      local.CreatedAt,
 	}
@@ -91,6 +93,9 @@ func LocalToConfiguration(local *LocalConfiguration) *models.Configuration {
 		userID := local.OriginalUserID
 		cfg.UserID = &userID
 	}
+	if local.CurrentVersion != nil {
+		cfg.CurrentVersionNo = local.CurrentVersion.VersionNo
+	}
 
 	return cfg
 }
@@ -106,6 +111,8 @@ 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,
@@ -125,6 +132,8 @@ 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,

internal/localdb/local_migrations_test.go

@@ -4,6 +4,8 @@ import (
 	"path/filepath"
 	"testing"
 	"time"
+
+	"github.com/google/uuid"
 )
 
 func TestRunLocalMigrationsBackfillsExistingConfigurations(t *testing.T) {
@@ -125,3 +127,189 @@ 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")
+	}
+}
+
+func TestRunLocalMigrationsBackfillsConfigurationLineNo(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "line_no_backfill.db")
+
+	local, err := New(dbPath)
+	if err != nil {
+		t.Fatalf("open localdb: %v", err)
+	}
+	t.Cleanup(func() { _ = local.Close() })
+
+	projectUUID := "project-line"
+	cfg1 := &LocalConfiguration{
+		UUID:             "line-cfg-1",
+		ProjectUUID:      &projectUUID,
+		Name:             "Cfg 1",
+		Items:            LocalConfigItems{},
+		SyncStatus:       "pending",
+		OriginalUsername: "tester",
+		IsActive:         true,
+		CreatedAt:        time.Now().Add(-2 * time.Hour),
+	}
+	cfg2 := &LocalConfiguration{
+		UUID:             "line-cfg-2",
+		ProjectUUID:      &projectUUID,
+		Name:             "Cfg 2",
+		Items:            LocalConfigItems{},
+		SyncStatus:       "pending",
+		OriginalUsername: "tester",
+		IsActive:         true,
+		CreatedAt:        time.Now().Add(-1 * time.Hour),
+	}
+	if err := local.SaveConfiguration(cfg1); err != nil {
+		t.Fatalf("save cfg1: %v", err)
+	}
+	if err := local.SaveConfiguration(cfg2); err != nil {
+		t.Fatalf("save cfg2: %v", err)
+	}
+
+	if err := local.DB().Model(&LocalConfiguration{}).Where("uuid IN ?", []string{cfg1.UUID, cfg2.UUID}).Update("line_no", 0).Error; err != nil {
+		t.Fatalf("reset line_no: %v", err)
+	}
+	if err := local.DB().Where("id = ?", "2026_02_19_local_config_line_no").Delete(&LocalSchemaMigration{}).Error; err != nil {
+		t.Fatalf("delete migration record: %v", err)
+	}
+
+	if err := runLocalMigrations(local.DB()); err != nil {
+		t.Fatalf("rerun local migrations: %v", err)
+	}
+
+	var rows []LocalConfiguration
+	if err := local.DB().Where("uuid IN ?", []string{cfg1.UUID, cfg2.UUID}).Order("created_at ASC").Find(&rows).Error; err != nil {
+		t.Fatalf("load configurations: %v", err)
+	}
+	if len(rows) != 2 {
+		t.Fatalf("expected 2 configurations, got %d", len(rows))
+	}
+	if rows[0].Line != 10 || rows[1].Line != 20 {
+		t.Fatalf("expected line_no [10,20], got [%d,%d]", rows[0].Line, rows[1].Line)
+	}
+}

internal/localdb/localdb.go

@@ -12,6 +12,7 @@ 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"
@@ -41,6 +42,49 @@ 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
@@ -49,6 +93,14 @@ 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),
 	})
@@ -56,10 +108,31 @@ 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{},
@@ -69,6 +142,8 @@ func New(dbPath string) (*LocalDB, error) {
 		&LocalRemoteMigrationApplied{},
 		&LocalSyncGuardState{},
 		&PendingChange{},
+		&LocalPartnumberBook{},
+		&LocalPartnumberBookItem{},
 	); err != nil {
 		return nil, fmt.Errorf("migrating sqlite database: %w", err)
 	}
@@ -84,6 +159,38 @@ 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
@@ -236,7 +343,7 @@ func (l *LocalDB) GetProjectByName(ownerUsername, name string) (*LocalProject, e
 func (l *LocalDB) GetProjectConfigurations(projectUUID string) ([]LocalConfiguration, error) {
 	var configs []LocalConfiguration
 	err := l.db.Where("project_uuid = ? AND is_active = ?", projectUUID, true).
-		Order("created_at DESC").
+		Order(configurationLineOrderClause()).
 		Find(&configs).Error
 	return configs, err
 }
@@ -258,7 +365,8 @@ func (l *LocalDB) EnsureDefaultProject(ownerUsername string) (*LocalProject, err
 	project = &LocalProject{
 		UUID:          uuidpkg.NewString(),
 		OwnerUsername: "",
-		Name:          "Без проекта",
+		Code:          "Без проекта",
+		Name:          ptrString("Без проекта"),
 		IsActive:      true,
 		IsSystem:      true,
 		CreatedAt:     now,
@@ -286,7 +394,8 @@ func (l *LocalDB) ConsolidateSystemProjects() (int64, error) {
 			canonical = LocalProject{
 				UUID:          uuidpkg.NewString(),
 				OwnerUsername: "",
-				Name:          "Без проекта",
+				Code:          "Без проекта",
+				Name:          ptrString("Без проекта"),
 				IsActive:      true,
 				IsSystem:      true,
 				CreatedAt:     now,
@@ -367,6 +476,10 @@ 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 {
@@ -403,9 +516,54 @@ func (l *LocalDB) BackfillConfigurationProjects(defaultOwner string) error {
 
 // SaveConfiguration saves a configuration to local SQLite
 func (l *LocalDB) SaveConfiguration(config *LocalConfiguration) error {
+	if config != nil && config.IsActive && config.Line <= 0 {
+		line, err := l.NextConfigurationLine(config.ProjectUUID, config.UUID)
+		if err != nil {
+			return err
+		}
+		config.Line = line
+	}
 	return l.db.Save(config).Error
 }
 
+func (l *LocalDB) NextConfigurationLine(projectUUID *string, excludeUUID string) (int, error) {
+	return NextConfigurationLineTx(l.db, projectUUID, excludeUUID)
+}
+
+func NextConfigurationLineTx(tx *gorm.DB, projectUUID *string, excludeUUID string) (int, error) {
+	query := tx.Model(&LocalConfiguration{}).
+		Where("is_active = ?", true)
+
+	trimmedExclude := strings.TrimSpace(excludeUUID)
+	if trimmedExclude != "" {
+		query = query.Where("uuid <> ?", trimmedExclude)
+	}
+
+	if projectUUID != nil && strings.TrimSpace(*projectUUID) != "" {
+		query = query.Where("project_uuid = ?", strings.TrimSpace(*projectUUID))
+	} else {
+		query = query.Where("project_uuid IS NULL OR TRIM(project_uuid) = ''")
+	}
+
+	var maxLine int
+	if err := query.Select("COALESCE(MAX(line_no), 0)").Scan(&maxLine).Error; err != nil {
+		return 0, fmt.Errorf("read max line_no: %w", err)
+	}
+	if maxLine < 0 {
+		maxLine = 0
+	}
+
+	next := ((maxLine / 10) + 1) * 10
+	if next < 10 {
+		next = 10
+	}
+	return next, nil
+}
+
+func configurationLineOrderClause() string {
+	return "CASE WHEN COALESCE(local_configurations.line_no, 0) <= 0 THEN 2147483647 ELSE local_configurations.line_no END ASC, local_configurations.created_at DESC, local_configurations.id DESC"
+}
+
 // GetConfigurations returns all local configurations
 func (l *LocalDB) GetConfigurations() ([]LocalConfiguration, error) {
 	var configs []LocalConfiguration
@@ -425,18 +583,36 @@ func (l *LocalDB) ListConfigurationsWithFilters(status string, search string, of
 	query := l.db.Model(&LocalConfiguration{})
 	switch status {
 	case "active":
-		query = query.Where("is_active = ?", true)
+		query = query.Where("local_configurations.is_active = ?", true)
 	case "archived":
-		query = query.Where("is_active = ?", false)
+		query = query.Where("local_configurations.is_active = ?", false)
 	case "all", "":
 		// no-op
 	default:
-		query = query.Where("is_active = ?", true)
+		query = query.Where("local_configurations.is_active = ?", true)
 	}
 
 	search = strings.TrimSpace(search)
 	if search != "" {
-		query = query.Where("LOWER(name) LIKE ?", "%"+strings.ToLower(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
@@ -445,7 +621,7 @@ func (l *LocalDB) ListConfigurationsWithFilters(status string, search string, of
 	}
 
 	var configs []LocalConfiguration
-	if err := query.Order("created_at DESC").Offset(offset).Limit(limit).Find(&configs).Error; err != nil {
+	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
@@ -563,7 +739,11 @@ 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").Order("created_at DESC").First(&pricelist).Error; err != nil {
+	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 {
 		return nil, err
 	}
 	return &pricelist, nil
@@ -572,7 +752,11 @@ 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).Order("created_at DESC").First(&pricelist).Error; err != nil {
+	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 {
 		return nil, err
 	}
 	return &pricelist, nil
@@ -912,6 +1096,145 @@ 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

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

internal/localdb/migrations.go

@@ -88,6 +88,31 @@ var localMigrations = []localMigration{
 		name: "Add support_code to local_configurations",
 		run:  addLocalConfigurationSupportCode,
 	},
+	{
+		id:   "2026_02_13_local_project_code",
+		name: "Add project code to local_projects and backfill",
+		run:  addLocalProjectCode,
+	},
+	{
+		id:   "2026_02_13_local_project_variant",
+		name: "Add project variant to local_projects and backfill",
+		run:  addLocalProjectVariant,
+	},
+	{
+		id:   "2026_02_13_local_project_name_nullable",
+		name: "Allow NULL project names in local_projects",
+		run:  allowLocalProjectNameNull,
+	},
+	{
+		id:   "2026_02_19_configuration_versions_dedup_spec_price",
+		name: "Deduplicate configuration revisions by spec+price",
+		run:  deduplicateConfigurationVersionsBySpecAndPrice,
+	},
+	{
+		id:   "2026_02_19_local_config_line_no",
+		name: "Add line_no to local_configurations and backfill ordering",
+		run:  addLocalConfigurationLineNo,
+	},
 }
 
 func runLocalMigrations(db *gorm.DB) error {
@@ -224,7 +249,8 @@ func ensureDefaultProjectTx(tx *gorm.DB, ownerUsername string) (*LocalProject, e
 	project = LocalProject{
 		UUID:          uuid.NewString(),
 		OwnerUsername: ownerUsername,
-		Name:          "Без проекта",
+		Code:          "Без проекта",
+		Name:          ptrString("Без проекта"),
 		IsActive:      true,
 		IsSystem:      true,
 		CreatedAt:     now,
@@ -238,6 +264,139 @@ 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 {
@@ -279,6 +438,93 @@ 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"`
@@ -565,3 +811,57 @@ func addLocalConfigurationSupportCode(tx *gorm.DB) error {
 	}
 	return nil
 }
+
+func addLocalConfigurationLineNo(tx *gorm.DB) error {
+	type columnInfo struct {
+		Name string `gorm:"column:name"`
+	}
+	var columns []columnInfo
+	if err := tx.Raw(`
+		SELECT name FROM pragma_table_info('local_configurations')
+		WHERE name IN ('line_no')
+	`).Scan(&columns).Error; err != nil {
+		return fmt.Errorf("check local_configurations(line_no) existence: %w", err)
+	}
+	if len(columns) == 0 {
+		if err := tx.Exec(`
+			ALTER TABLE local_configurations
+			ADD COLUMN line_no INTEGER
+		`).Error; err != nil {
+			return fmt.Errorf("add local_configurations.line_no: %w", err)
+		}
+		slog.Info("added line_no to local_configurations")
+	}
+
+	if err := tx.Exec(`
+WITH ranked AS (
+	SELECT
+		id,
+		ROW_NUMBER() OVER (
+			PARTITION BY COALESCE(NULLIF(TRIM(project_uuid), ''), '__NO_PROJECT__')
+			ORDER BY created_at ASC, id ASC
+		) AS rn
+	FROM local_configurations
+	WHERE line_no IS NULL OR line_no <= 0
+)
+UPDATE local_configurations
+SET line_no = (
+	SELECT rn * 10
+	FROM ranked
+	WHERE ranked.id = local_configurations.id
+)
+WHERE id IN (SELECT id FROM ranked)
+`).Error; err != nil {
+		return fmt.Errorf("backfill local_configurations.line_no: %w", err)
+	}
+
+	if err := tx.Exec(`
+		CREATE INDEX IF NOT EXISTS idx_local_configurations_project_line_no
+		ON local_configurations(project_uuid, line_no)
+	`).Error; err != nil {
+		return fmt.Errorf("ensure idx_local_configurations_project_line_no: %w", err)
+	}
+
+	return nil
+}
+

internal/localdb/models.go

@@ -83,35 +83,37 @@ func (s *LocalStringList) Scan(value interface{}) error {
 
 // LocalConfiguration stores configurations in local SQLite
 type LocalConfiguration struct {
-	ID               uint                        `gorm:"primaryKey;autoIncrement" json:"id"`
-	UUID             string                      `gorm:"uniqueIndex;not null" json:"uuid"`
-	ServerID         *uint                       `json:"server_id"` // ID on MariaDB server, NULL if local only
-	ProjectUUID      *string                     `gorm:"index" json:"project_uuid,omitempty"`
-	CurrentVersionID *string                     `gorm:"index" json:"current_version_id,omitempty"`
-	IsActive         bool                        `gorm:"default:true;index" json:"is_active"`
-	Name             string                      `gorm:"not null" json:"name"`
-	Items            LocalConfigItems            `gorm:"type:text" json:"items"` // JSON stored as text in SQLite
-	TotalPrice       *float64                    `json:"total_price"`
-	CustomPrice      *float64                    `json:"custom_price"`
-	Notes            string                      `json:"notes"`
-	IsTemplate       bool                        `gorm:"default:false" json:"is_template"`
-	ServerCount      int                         `gorm:"default:1" json:"server_count"`
-	ServerModel      string                      `gorm:"size:100" json:"server_model,omitempty"`
-	SupportCode      string                      `gorm:"size:20" json:"support_code,omitempty"`
-	Article          string                      `gorm:"size:80" json:"article,omitempty"`
+	ID                    uint                        `gorm:"primaryKey;autoIncrement" json:"id"`
+	UUID                  string                      `gorm:"uniqueIndex;not null" json:"uuid"`
+	ServerID              *uint                       `json:"server_id"` // ID on MariaDB server, NULL if local only
+	ProjectUUID           *string                     `gorm:"index" json:"project_uuid,omitempty"`
+	CurrentVersionID      *string                     `gorm:"index" json:"current_version_id,omitempty"`
+	IsActive              bool                        `gorm:"default:true;index" json:"is_active"`
+	Name                  string                      `gorm:"not null" json:"name"`
+	Items                 LocalConfigItems            `gorm:"type:text" json:"items"` // JSON stored as text in SQLite
+	TotalPrice            *float64                    `json:"total_price"`
+	CustomPrice           *float64                    `json:"custom_price"`
+	Notes                 string                      `json:"notes"`
+	IsTemplate            bool                        `gorm:"default:false" json:"is_template"`
+	ServerCount           int                         `gorm:"default:1" json:"server_count"`
+	ServerModel           string                      `gorm:"size:100" json:"server_model,omitempty"`
+	SupportCode           string                      `gorm:"size:20" json:"support_code,omitempty"`
+	Article               string                      `gorm:"size:80" json:"article,omitempty"`
 	PricelistID           *uint                       `gorm:"index" json:"pricelist_id,omitempty"`
 	WarehousePricelistID  *uint                       `gorm:"index" json:"warehouse_pricelist_id,omitempty"`
 	CompetitorPricelistID *uint                       `gorm:"index" json:"competitor_pricelist_id,omitempty"`
 	OnlyInStock           bool                        `gorm:"default:false" json:"only_in_stock"`
-	PriceUpdatedAt   *time.Time                  `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
-	CreatedAt        time.Time                   `json:"created_at"`
-	UpdatedAt        time.Time                   `json:"updated_at"`
-	SyncedAt         *time.Time                  `json:"synced_at"`
-	SyncStatus       string                      `gorm:"default:'local'" json:"sync_status"` // 'local', 'synced', 'modified'
-	OriginalUserID   uint                        `json:"original_user_id"`                   // UserID from MariaDB for reference
-	OriginalUsername string                      `gorm:"not null;default:'';index" json:"original_username"`
-	CurrentVersion   *LocalConfigurationVersion  `gorm:"foreignKey:CurrentVersionID;references:ID" json:"current_version,omitempty"`
-	Versions         []LocalConfigurationVersion `gorm:"foreignKey:ConfigurationUUID;references:UUID" json:"versions,omitempty"`
+	VendorSpec             VendorSpec                  `gorm:"type:text" json:"vendor_spec,omitempty"`
+	Line                  int                         `gorm:"column:line_no;index" json:"line"`
+	PriceUpdatedAt        *time.Time                  `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
+	CreatedAt             time.Time                   `json:"created_at"`
+	UpdatedAt             time.Time                   `json:"updated_at"`
+	SyncedAt              *time.Time                  `json:"synced_at"`
+	SyncStatus            string                      `gorm:"default:'local'" json:"sync_status"` // 'local', 'synced', 'modified'
+	OriginalUserID        uint                        `json:"original_user_id"`                   // UserID from MariaDB for reference
+	OriginalUsername      string                      `gorm:"not null;default:'';index" json:"original_username"`
+	CurrentVersion        *LocalConfigurationVersion  `gorm:"foreignKey:CurrentVersionID;references:ID" json:"current_version,omitempty"`
+	Versions              []LocalConfigurationVersion `gorm:"foreignKey:ConfigurationUUID;references:UUID" json:"versions,omitempty"`
 }
 
 func (LocalConfiguration) TableName() string {
@@ -123,7 +125,9 @@ 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"`
-	Name          string     `gorm:"not null" json:"name"`
+	Code          string     `gorm:"not null;index:idx_local_projects_code_variant,priority:1" json:"code"`
+	Variant       string     `gorm:"default:'';index:idx_local_projects_code_variant,priority:2" json:"variant"`
+	Name          *string    `json:"name,omitempty"`
 	TrackerURL    string     `json:"tracker_url"`
 	IsActive      bool       `gorm:"default:true;index" json:"is_active"`
 	IsSystem      bool       `gorm:"default:false;index" json:"is_system"`
@@ -240,3 +244,85 @@ type PendingChange struct {
 func (PendingChange) TableName() string {
 	return "pending_changes"
 }
+
+// LocalPartnumberBook stores a version snapshot of the PN→LOT mapping book (pull-only from PriceForge)
+type LocalPartnumberBook struct {
+	ID        uint      `gorm:"primaryKey;autoIncrement" json:"id"`
+	ServerID  int       `gorm:"uniqueIndex;not null" json:"server_id"`
+	Version   string    `gorm:"not null" json:"version"`
+	CreatedAt time.Time `gorm:"not null" json:"created_at"`
+	IsActive  bool      `gorm:"not null;default:true" json:"is_active"`
+}
+
+func (LocalPartnumberBook) TableName() string {
+	return "local_partnumber_books"
+}
+
+// LocalPartnumberBookItem stores a single PN→LOT mapping within a book snapshot
+type LocalPartnumberBookItem struct {
+	ID          uint   `gorm:"primaryKey;autoIncrement" json:"id"`
+	BookID      uint   `gorm:"not null;index:idx_local_book_pn,priority:1" json:"book_id"`
+	Partnumber  string `gorm:"not null;index:idx_local_book_pn,priority:2" json:"partnumber"`
+	LotName     string `gorm:"not null" json:"lot_name"`
+	IsPrimaryPN bool   `gorm:"not null;default:false" json:"is_primary_pn"`
+	Description string `json:"description,omitempty"`
+}
+
+func (LocalPartnumberBookItem) TableName() string {
+	return "local_partnumber_book_items"
+}
+
+// VendorSpecItem represents a single row in a vendor BOM specification
+type VendorSpecItem struct {
+	SortOrder           int      `json:"sort_order"`
+	VendorPartnumber    string   `json:"vendor_partnumber"`
+	Quantity            int      `json:"quantity"`
+	Description         string   `json:"description,omitempty"`
+	UnitPrice           *float64 `json:"unit_price,omitempty"`
+	TotalPrice          *float64 `json:"total_price,omitempty"`
+	ResolvedLotName     string   `json:"resolved_lot_name,omitempty"`
+	ResolutionSource    string   `json:"resolution_source,omitempty"` // "book", "manual", "unresolved"
+	ManualLotSuggestion string   `json:"manual_lot_suggestion,omitempty"`
+	LotQtyPerPN         int      `json:"lot_qty_per_pn,omitempty"`
+	LotAllocations      []VendorSpecLotAllocation `json:"lot_allocations,omitempty"`
+	LotMappings         []VendorSpecLotMapping `json:"lot_mappings,omitempty"`
+}
+
+type VendorSpecLotAllocation struct {
+	LotName  string `json:"lot_name"`
+	Quantity int    `json:"quantity"` // quantity of LOT per 1 vendor PN
+}
+
+// VendorSpecLotMapping is the canonical persisted LOT mapping for a vendor PN row.
+// It stores all mapped LOTs (base + bundle) uniformly.
+type VendorSpecLotMapping struct {
+	LotName       string `json:"lot_name"`
+	QuantityPerPN int    `json:"quantity_per_pn"`
+}
+
+// VendorSpec is a JSON-encodable slice of VendorSpecItem
+type VendorSpec []VendorSpecItem
+
+func (v VendorSpec) Value() (driver.Value, error) {
+	if v == nil {
+		return nil, nil
+	}
+	return json.Marshal(v)
+}
+
+func (v *VendorSpec) Scan(value interface{}) error {
+	if value == nil {
+		*v = nil
+		return nil
+	}
+	var bytes []byte
+	switch val := value.(type) {
+	case []byte:
+		bytes = val
+	case string:
+		bytes = []byte(val)
+	default:
+		return errors.New("type assertion failed for VendorSpec")
+	}
+	return json.Unmarshal(bytes, v)
+}

internal/localdb/pricelist_latest_test.go

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

internal/localdb/snapshots.go

@@ -3,6 +3,7 @@ package localdb
 import (
 	"encoding/json"
 	"fmt"
+	"sort"
 	"time"
 )
 
@@ -27,6 +28,7 @@ func BuildConfigurationSnapshot(localCfg *LocalConfiguration) (string, error) {
 		"article":            localCfg.Article,
 		"pricelist_id":       localCfg.PricelistID,
 		"only_in_stock":      localCfg.OnlyInStock,
+		"line":               localCfg.Line,
 		"price_updated_at":   localCfg.PriceUpdatedAt,
 		"created_at":         localCfg.CreatedAt,
 		"updated_at":         localCfg.UpdatedAt,
@@ -60,6 +62,7 @@ func DecodeConfigurationSnapshot(data string) (*LocalConfiguration, error) {
 		Article          string           `json:"article"`
 		PricelistID      *uint            `json:"pricelist_id"`
 		OnlyInStock      bool             `json:"only_in_stock"`
+		Line             int              `json:"line"`
 		PriceUpdatedAt   *time.Time       `json:"price_updated_at"`
 		OriginalUserID   uint             `json:"original_user_id"`
 		OriginalUsername string           `json:"original_username"`
@@ -89,8 +92,57 @@ func DecodeConfigurationSnapshot(data string) (*LocalConfiguration, error) {
 		Article:          snapshot.Article,
 		PricelistID:      snapshot.PricelistID,
 		OnlyInStock:      snapshot.OnlyInStock,
+		Line:             snapshot.Line,
 		PriceUpdatedAt:   snapshot.PriceUpdatedAt,
 		OriginalUserID:   snapshot.OriginalUserID,
 		OriginalUsername: snapshot.OriginalUsername,
 	}, nil
 }
+
+type configurationSpecPriceFingerprint struct {
+	Items       []configurationSpecPriceFingerprintItem `json:"items"`
+	ServerCount int                                     `json:"server_count"`
+	TotalPrice  *float64                                `json:"total_price,omitempty"`
+	CustomPrice *float64                                `json:"custom_price,omitempty"`
+}
+
+type configurationSpecPriceFingerprintItem struct {
+	LotName   string  `json:"lot_name"`
+	Quantity  int     `json:"quantity"`
+	UnitPrice float64 `json:"unit_price"`
+}
+
+// BuildConfigurationSpecPriceFingerprint returns a stable JSON key based on
+// spec + price fields only, used for revision deduplication.
+func BuildConfigurationSpecPriceFingerprint(localCfg *LocalConfiguration) (string, error) {
+	items := make([]configurationSpecPriceFingerprintItem, 0, len(localCfg.Items))
+	for _, item := range localCfg.Items {
+		items = append(items, configurationSpecPriceFingerprintItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
+		})
+	}
+	sort.Slice(items, func(i, j int) bool {
+		if items[i].LotName != items[j].LotName {
+			return items[i].LotName < items[j].LotName
+		}
+		if items[i].Quantity != items[j].Quantity {
+			return items[i].Quantity < items[j].Quantity
+		}
+		return items[i].UnitPrice < items[j].UnitPrice
+	})
+
+	payload := configurationSpecPriceFingerprint{
+		Items:       items,
+		ServerCount: localCfg.ServerCount,
+		TotalPrice:  localCfg.TotalPrice,
+		CustomPrice: localCfg.CustomPrice,
+	}
+
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("marshal spec+price fingerprint: %w", err)
+	}
+	return string(raw), nil
+}

internal/models/configuration.go

@@ -61,8 +61,10 @@ type Configuration struct {
 	CompetitorPricelistID *uint       `gorm:"index" json:"competitor_pricelist_id,omitempty"`
 	DisablePriceRefresh   bool        `gorm:"default:false" json:"disable_price_refresh"`
 	OnlyInStock           bool        `gorm:"default:false" json:"only_in_stock"`
+	Line                  int         `gorm:"column:line_no;index" json:"line"`
 	PriceUpdatedAt        *time.Time  `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
 	CreatedAt             time.Time   `gorm:"autoCreateTime" json:"created_at"`
+	CurrentVersionNo      int         `gorm:"-" json:"current_version_no,omitempty"`
 
 	User *User `gorm:"foreignKey:UserID" json:"user,omitempty"`
 }

internal/models/project.go

@@ -6,7 +6,9 @@ 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"`
-	Name          string    `gorm:"size:200;not null" json:"name"`
+	Code          string    `gorm:"size:100;not null;index:idx_qt_projects_code_variant,priority:1" json:"code"`
+	Variant       string    `gorm:"size:100;not null;default:'';index:idx_qt_projects_code_variant,priority:2" json:"variant"`
+	Name          *string   `gorm:"size:200" json:"name,omitempty"`
 	TrackerURL    string    `gorm:"size:500" json:"tracker_url"`
 	IsActive      bool      `gorm:"default:true;index" json:"is_active"`
 	IsSystem      bool      `gorm:"default:false;index" json:"is_system"`

internal/repository/configuration.go

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

internal/repository/partnumber_book.go

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

internal/repository/pricelist.go

@@ -3,6 +3,7 @@ package repository
 import (
 	"errors"
 	"fmt"
+	"log/slog"
 	"sort"
 	"strconv"
 	"strings"
@@ -40,7 +41,7 @@ func (r *PricelistRepository) ListBySource(source string, offset, limit int) ([]
 	}
 
 	var pricelists []models.Pricelist
-	if err := query.Order("created_at DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
+	if err := query.Order("created_at DESC, id DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
 		return nil, 0, fmt.Errorf("listing pricelists: %w", err)
 	}
 
@@ -67,7 +68,7 @@ func (r *PricelistRepository) ListActiveBySource(source string, offset, limit in
 	}
 
 	var pricelists []models.Pricelist
-	if err := query.Order("created_at DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
+	if err := query.Order("created_at DESC, id DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
 		return nil, 0, fmt.Errorf("listing active pricelists: %w", err)
 	}
 
@@ -148,7 +149,11 @@ 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).Order("created_at DESC").First(&pricelist).Error; err != nil {
+	if err := r.db.
+		Where("is_active = ? AND source = ?", true, source).
+		Where("EXISTS (SELECT 1 FROM qt_pricelist_items WHERE qt_pricelist_items.pricelist_id = qt_pricelists.id)").
+		Order("created_at DESC, id DESC").
+		First(&pricelist).Error; err != nil {
 		return nil, fmt.Errorf("getting latest pricelist: %w", err)
 	}
 	return &pricelist, nil
@@ -241,8 +246,11 @@ func (r *PricelistRepository) GetItems(pricelistID uint, offset, limit int, sear
 		items[i].Category = strings.TrimSpace(items[i].LotCategory)
 	}
 
+	// Stock/partnumber enrichment is optional for pricelist item listing.
+	// Return base pricelist rows (lot_name/price/category) even when DB user lacks
+	// access to stock mapping tables (e.g. lot_partnumbers, stock_log).
 	if err := r.enrichItemsWithStock(items); err != nil {
-		return nil, 0, fmt.Errorf("enriching pricelist items with stock: %w", err)
+		slog.Warn("pricelist items stock enrichment skipped", "pricelist_id", pricelistID, "error", err)
 	}
 
 	return items, total, nil

internal/repository/pricelist_test.go

@@ -126,6 +126,101 @@ func TestGetItems_WarehouseAvailableQtyUsesPrefixResolver(t *testing.T) {
 	}
 }
 
+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()
 

internal/repository/project.go

@@ -27,6 +27,8 @@ 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/services/export.go

@@ -5,35 +5,32 @@ import (
 	"encoding/csv"
 	"fmt"
 	"io"
+	"math"
+	"sort"
 	"strings"
 	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
 )
 
 type ExportService struct {
-	config     config.ExportConfig
+	config       config.ExportConfig
 	categoryRepo *repository.CategoryRepository
+	localDB      *localdb.LocalDB
 }
 
-func NewExportService(cfg config.ExportConfig, categoryRepo *repository.CategoryRepository) *ExportService {
+func NewExportService(cfg config.ExportConfig, categoryRepo *repository.CategoryRepository, local *localdb.LocalDB) *ExportService {
 	return &ExportService{
 		config:       cfg,
 		categoryRepo: categoryRepo,
+		localDB:      local,
 	}
 }
 
-type ExportData struct {
-	Name      string
-	Article   string
-	Items     []ExportItem
-	Total     float64
-	Notes     string
-	CreatedAt time.Time
-}
-
+// ExportItem represents a single component in an export block.
 type ExportItem struct {
 	LotName     string
 	Description string
@@ -43,19 +40,44 @@ type ExportItem struct {
 	TotalPrice  float64
 }
 
-func (s *ExportService) ToCSV(w io.Writer, data *ExportData) error {
+// ConfigExportBlock represents one configuration (server) in the export.
+type ConfigExportBlock struct {
+	Article     string
+	Line        int
+	ServerCount int
+	UnitPrice   float64 // sum of component prices for one server
+	Items       []ExportItem
+}
+
+// ProjectExportData holds all configuration blocks for a project-level export.
+type ProjectExportData struct {
+	Configs   []ConfigExportBlock
+	CreatedAt time.Time
+}
+
+// ToCSV writes project export data in the new structured CSV format.
+//
+// Format:
+//
+//	Line;Type;p/n;Description;Qty (1 pcs.);Qty (total);Price (1 pcs.);Price (total)
+//	10;;DL380-ARTICLE;;;10;10470;104 700
+//	;;MB_INTEL_...;;1;;2074,5;
+//	...
+//	(empty row)
+//	20;;DL380-ARTICLE-2;;;2;10470;20 940
+//	...
+func (s *ExportService) ToCSV(w io.Writer, data *ProjectExportData) error {
 	// Write UTF-8 BOM for Excel compatibility
 	if _, err := w.Write([]byte{0xEF, 0xBB, 0xBF}); err != nil {
 		return fmt.Errorf("failed to write BOM: %w", err)
 	}
 
 	csvWriter := csv.NewWriter(w)
-	// Use semicolon as delimiter for Russian Excel locale
 	csvWriter.Comma = ';'
 	defer csvWriter.Flush()
 
 	// Header
-	headers := []string{"Артикул", "Описание", "Категория", "Количество", "Цена за единицу", "Сумма"}
+	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)
 	}
@@ -71,47 +93,62 @@ func (s *ExportService) ToCSV(w io.Writer, data *ExportData) error {
 		}
 	}
 
-	// Sort items by category display order
-	sortedItems := make([]ExportItem, len(data.Items))
-	copy(sortedItems, data.Items)
+	for i, block := range data.Configs {
+		lineNo := block.Line
+		if lineNo <= 0 {
+			lineNo = (i + 1) * 10
+		}
 
-	// Sort using category display order (items without category go to the end)
-	for i := 0; i < len(sortedItems)-1; i++ {
-		for j := i + 1; j < len(sortedItems); j++ {
-			orderI, hasI := categoryOrder[sortedItems[i].Category]
-			orderJ, hasJ := categoryOrder[sortedItems[j].Category]
+		serverCount := block.ServerCount
+		if serverCount < 1 {
+			serverCount = 1
+		}
 
-			// Items without category go to the end
-			if !hasI && hasJ {
-				sortedItems[i], sortedItems[j] = sortedItems[j], sortedItems[i]
-			} else if hasI && hasJ {
-				// Both have categories, sort by display order
-				if orderI > orderJ {
-					sortedItems[i], sortedItems[j] = sortedItems[j], sortedItems[i]
-				}
+		totalPrice := block.UnitPrice * float64(serverCount)
+
+		// Server summary row
+		serverRow := []string{
+			fmt.Sprintf("%d", lineNo),        // Line
+			"",                               // Type
+			block.Article,                    // p/n
+			"",                               // Description
+			"",                               // Qty (1 pcs.)
+			fmt.Sprintf("%d", serverCount),   // Qty (total)
+			formatPriceInt(block.UnitPrice),  // Price (1 pcs.)
+			formatPriceWithSpace(totalPrice), // Price (total)
+		}
+		if err := csvWriter.Write(serverRow); err != nil {
+			return fmt.Errorf("failed to write server row: %w", err)
+		}
+
+		// Sort items by category display order
+		sortedItems := make([]ExportItem, len(block.Items))
+		copy(sortedItems, block.Items)
+		sortItemsByCategory(sortedItems, categoryOrder)
+
+		// Component rows
+		for _, item := range sortedItems {
+			componentRow := []string{
+				"",                               // Line
+				item.Category,                    // Type
+				item.LotName,                     // p/n
+				"",                               // Description
+				fmt.Sprintf("%d", item.Quantity), // Qty (1 pcs.)
+				"",                               // Qty (total)
+				formatPriceComma(item.UnitPrice), // Price (1 pcs.)
+				"",                               // Price (total)
+			}
+			if err := csvWriter.Write(componentRow); err != nil {
+				return fmt.Errorf("failed to write component row: %w", err)
 			}
 		}
-	}
 
-	// Items
-	for _, item := range sortedItems {
-		row := []string{
-			item.LotName,
-			item.Description,
-			item.Category,
-			fmt.Sprintf("%d", item.Quantity),
-			strings.ReplaceAll(fmt.Sprintf("%.2f", item.UnitPrice), ".", ","),
-			strings.ReplaceAll(fmt.Sprintf("%.2f", item.TotalPrice), ".", ","),
+		// 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)
+			}
 		}
-		if err := csvWriter.Write(row); err != nil {
-			return fmt.Errorf("failed to write row: %w", err)
-		}
-	}
-
-	// Total row
-	totalStr := strings.ReplaceAll(fmt.Sprintf("%.2f", data.Total), ".", ",")
-	if err := csvWriter.Write([]string{data.Article, "", "", "", "ИТОГО:", totalStr}); err != nil {
-		return fmt.Errorf("failed to write total row: %w", err)
 	}
 
 	csvWriter.Flush()
@@ -122,8 +159,8 @@ func (s *ExportService) ToCSV(w io.Writer, data *ExportData) error {
 	return nil
 }
 
-// ToCSVBytes is a backward-compatible wrapper that returns CSV data as bytes
-func (s *ExportService) ToCSVBytes(data *ExportData) ([]byte, error) {
+// ToCSVBytes is a backward-compatible wrapper that returns CSV data as bytes.
+func (s *ExportService) ToCSVBytes(data *ProjectExportData) ([]byte, error) {
 	var buf bytes.Buffer
 	if err := s.ToCSV(&buf, data); err != nil {
 		return nil, err
@@ -131,42 +168,185 @@ func (s *ExportService) ToCSVBytes(data *ExportData) ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-func (s *ExportService) ConfigToExportData(config *models.Configuration, componentService *ComponentService) *ExportData {
-	items := make([]ExportItem, len(config.Items))
-	var total float64
-
-	for i, item := range config.Items {
-		itemTotal := item.UnitPrice * float64(item.Quantity)
-
-		// Получаем информацию о компоненте для заполнения категории
-		componentView, err := componentService.GetByLotName(item.LotName)
-		if err != nil {
-			// Если не удалось получить информацию о компоненте, используем только основные данные
-			items[i] = ExportItem{
-				LotName:    item.LotName,
-				Quantity:   item.Quantity,
-				UnitPrice:  item.UnitPrice,
-				TotalPrice: itemTotal,
-			}
-		} else {
-			items[i] = ExportItem{
-				LotName:     item.LotName,
-				Description: componentView.Description,
-				Category:    componentView.Category,
-				Quantity:    item.Quantity,
-				UnitPrice:   item.UnitPrice,
-				TotalPrice:  itemTotal,
-			}
-		}
-		total += itemTotal
-	}
-
-	return &ExportData{
-		Name:      config.Name,
-		Article:   "",
-		Items:     items,
-		Total:     total,
-		Notes:     config.Notes,
-		CreatedAt: config.CreatedAt,
+// ConfigToExportData converts a single configuration into ProjectExportData.
+func (s *ExportService) ConfigToExportData(cfg *models.Configuration) *ProjectExportData {
+	block := s.buildExportBlock(cfg)
+	return &ProjectExportData{
+		Configs:   []ConfigExportBlock{block},
+		CreatedAt: cfg.CreatedAt,
 	}
 }
+
+// ProjectToExportData converts multiple configurations into ProjectExportData.
+func (s *ExportService) ProjectToExportData(configs []models.Configuration) *ProjectExportData {
+	sortedConfigs := make([]models.Configuration, len(configs))
+	copy(sortedConfigs, configs)
+	sort.Slice(sortedConfigs, func(i, j int) bool {
+		leftLine := sortedConfigs[i].Line
+		rightLine := sortedConfigs[j].Line
+
+		if leftLine <= 0 {
+			leftLine = int(^uint(0) >> 1)
+		}
+		if rightLine <= 0 {
+			rightLine = int(^uint(0) >> 1)
+		}
+		if leftLine != rightLine {
+			return leftLine < rightLine
+		}
+		if !sortedConfigs[i].CreatedAt.Equal(sortedConfigs[j].CreatedAt) {
+			return sortedConfigs[i].CreatedAt.After(sortedConfigs[j].CreatedAt)
+		}
+		return sortedConfigs[i].UUID > sortedConfigs[j].UUID
+	})
+
+	blocks := make([]ConfigExportBlock, 0, len(configs))
+	for i := range sortedConfigs {
+		blocks = append(blocks, s.buildExportBlock(&sortedConfigs[i]))
+	}
+	return &ProjectExportData{
+		Configs:   blocks,
+		CreatedAt: time.Now(),
+	}
+}
+
+func (s *ExportService) buildExportBlock(cfg *models.Configuration) ConfigExportBlock {
+	// Batch-fetch categories from local data (pricelist items → local_components fallback)
+	lotNames := make([]string, len(cfg.Items))
+	for i, item := range cfg.Items {
+		lotNames[i] = item.LotName
+	}
+	categories := s.resolveCategories(cfg.PricelistID, lotNames)
+
+	items := make([]ExportItem, len(cfg.Items))
+	var unitTotal float64
+
+	for i, item := range cfg.Items {
+		itemTotal := item.UnitPrice * float64(item.Quantity)
+		items[i] = ExportItem{
+			LotName:    item.LotName,
+			Category:   categories[item.LotName],
+			Quantity:   item.Quantity,
+			UnitPrice:  item.UnitPrice,
+			TotalPrice: itemTotal,
+		}
+		unitTotal += itemTotal
+	}
+
+	serverCount := cfg.ServerCount
+	if serverCount < 1 {
+		serverCount = 1
+	}
+
+	return ConfigExportBlock{
+		Article:     cfg.Article,
+		Line:        cfg.Line,
+		ServerCount: serverCount,
+		UnitPrice:   unitTotal,
+		Items:       items,
+	}
+}
+
+// resolveCategories returns lot_name → category map.
+// Primary source: pricelist items (lot_category). Fallback: local_components table.
+func (s *ExportService) resolveCategories(pricelistID *uint, lotNames []string) map[string]string {
+	if len(lotNames) == 0 || s.localDB == nil {
+		return map[string]string{}
+	}
+
+	categories := make(map[string]string, len(lotNames))
+
+	// Primary: pricelist items
+	if pricelistID != nil && *pricelistID > 0 {
+		if cats, err := s.localDB.GetLocalLotCategoriesByServerPricelistID(*pricelistID, lotNames); err == nil {
+			for lot, cat := range cats {
+				if strings.TrimSpace(cat) != "" {
+					categories[lot] = cat
+				}
+			}
+		}
+	}
+
+	// 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]
+			}
+		}
+	}
+}
+
+// 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

@@ -8,27 +8,42 @@ import (
 	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
 )
 
-
-func TestToCSV_UTF8BOM(t *testing.T) {
-	svc := NewExportService(config.ExportConfig{}, nil)
-
-	data := &ExportData{
-		Name: "Test",
-		Items: []ExportItem{
+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{
 			{
-				LotName:     "LOT-001",
-				Description: "Test Item",
-				Category:    "CAT",
-				Quantity:    1,
-				UnitPrice:   100.0,
-				TotalPrice:  100.0,
+				Article:     article,
+				ServerCount: serverCount,
+				UnitPrice:   unitTotal,
+				Items:       items,
 			},
 		},
-		Total:     100.0,
 		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 {
@@ -40,40 +55,31 @@ func TestToCSV_UTF8BOM(t *testing.T) {
 		t.Fatalf("CSV too short to contain BOM")
 	}
 
-	// Check UTF-8 BOM: 0xEF 0xBB 0xBF
 	expectedBOM := []byte{0xEF, 0xBB, 0xBF}
 	actualBOM := csvBytes[:3]
-
-	if bytes.Compare(actualBOM, expectedBOM) != 0 {
+	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)
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
 
-	data := &ExportData{
-		Name: "Test",
-		Items: []ExportItem{
-			{
-				LotName:     "LOT-001",
-				Description: "Test Item",
-				Category:    "CAT",
-				Quantity:    2,
-				UnitPrice:   100.50,
-				TotalPrice:  201.00,
-			},
+	data := newTestProjectData([]ExportItem{
+		{
+			LotName:    "LOT-001",
+			Category:   "CAT",
+			Quantity:   2,
+			UnitPrice:  100.50,
+			TotalPrice: 201.00,
 		},
-		Total:     201.00,
-		CreatedAt: time.Now(),
-	}
+	}, "TEST-ARTICLE", 1)
 
 	var buf bytes.Buffer
 	if err := svc.ToCSV(&buf, data); err != nil {
 		t.Fatalf("ToCSV failed: %v", err)
 	}
 
-	// Skip BOM and read CSV with semicolon delimiter
 	csvBytes := buf.Bytes()
 	reader := csv.NewReader(bytes.NewReader(csvBytes[3:]))
 	reader.Comma = ';'
@@ -84,125 +90,52 @@ func TestToCSV_SemicolonDelimiter(t *testing.T) {
 		t.Fatalf("Failed to read header: %v", err)
 	}
 
-	if len(header) != 6 {
-		t.Errorf("Expected 6 columns, got %d", len(header))
+	if len(header) != 8 {
+		t.Errorf("Expected 8 columns, got %d", len(header))
 	}
 
-	expectedHeader := []string{"Артикул", "Описание", "Категория", "Количество", "Цена за единицу", "Сумма"}
+	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 item row
+	// 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[0] != "LOT-001" {
-		t.Errorf("Lot name mismatch: expected LOT-001, got %s", itemRow[0])
+	if itemRow[2] != "LOT-001" {
+		t.Errorf("Lot name mismatch: expected LOT-001, got %s", itemRow[2])
 	}
-
-	if itemRow[3] != "2" {
-		t.Errorf("Quantity mismatch: expected 2, got %s", itemRow[3])
+	if itemRow[4] != "2" {
+		t.Errorf("Quantity mismatch: expected 2, got %s", itemRow[4])
 	}
-
-	if itemRow[4] != "100,50" {
-		t.Errorf("Unit price mismatch: expected 100,50, got %s", itemRow[4])
+	if itemRow[6] != "100,5" {
+		t.Errorf("Unit price mismatch: expected 100,5, got %s", itemRow[6])
 	}
 }
 
-func TestToCSV_TotalRow(t *testing.T) {
-	svc := NewExportService(config.ExportConfig{}, nil)
+func TestToCSV_ServerRow(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
 
-	data := &ExportData{
-		Name: "Test",
-		Items: []ExportItem{
-			{
-				LotName:     "LOT-001",
-				Description: "Item 1",
-				Category:    "CAT",
-				Quantity:    1,
-				UnitPrice:   100.0,
-				TotalPrice:  100.0,
-			},
-			{
-				LotName:     "LOT-002",
-				Description: "Item 2",
-				Category:    "CAT",
-				Quantity:    2,
-				UnitPrice:   50.0,
-				TotalPrice:  100.0,
-			},
-		},
-		Total:     200.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 = ';'
-
-	// Skip header and item rows
-	reader.Read()
-	reader.Read()
-	reader.Read()
-
-	// Read total row
-	totalRow, err := reader.Read()
-	if err != nil {
-		t.Fatalf("Failed to read total row: %v", err)
-	}
-
-	// Total row should have "ИТОГО:" in position 4 and total value in position 5
-	if totalRow[4] != "ИТОГО:" {
-		t.Errorf("Expected 'ИТОГО:' in column 4, got %q", totalRow[4])
-	}
-
-	if totalRow[5] != "200,00" {
-		t.Errorf("Expected total 200,00, got %s", totalRow[5])
-	}
-}
-
-func TestToCSV_CategorySorting(t *testing.T) {
-	// Test category sorting without category repo (items maintain original order)
-	svc := NewExportService(config.ExportConfig{}, nil)
-
-	data := &ExportData{
-		Name: "Test",
-		Items: []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,
-			},
-		},
-		Total:     300.0,
-		CreatedAt: time.Now(),
-	}
+	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 {
@@ -216,30 +149,75 @@ func TestToCSV_CategorySorting(t *testing.T) {
 	// 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[0] != "LOT-001" {
-		t.Errorf("Expected LOT-001 first, got %s", row1[0])
+	if row1[2] != "LOT-001" {
+		t.Errorf("Expected LOT-001 first, got %s", row1[2])
 	}
 
 	row2, _ := reader.Read()
-	if row2[0] != "LOT-002" {
-		t.Errorf("Expected LOT-002 second, got %s", row2[0])
+	if row2[2] != "LOT-002" {
+		t.Errorf("Expected LOT-002 second, got %s", row2[2])
 	}
 
 	row3, _ := reader.Read()
-	if row3[0] != "LOT-003" {
-		t.Errorf("Expected LOT-003 third, got %s", row3[0])
+	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)
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
 
-	data := &ExportData{
-		Name:      "Test",
-		Items:     []ExportItem{},
-		Total:     0.0,
+	data := &ProjectExportData{
+		Configs:   []ConfigExportBlock{},
 		CreatedAt: time.Now(),
 	}
 
@@ -252,44 +230,28 @@ func TestToCSV_EmptyData(t *testing.T) {
 	reader := csv.NewReader(bytes.NewReader(csvBytes[3:]))
 	reader.Comma = ';'
 
-	// Should have header and total row
 	header, err := reader.Read()
 	if err != nil {
 		t.Fatalf("Failed to read header: %v", err)
 	}
 
-	if len(header) != 6 {
-		t.Errorf("Expected 6 columns, got %d", len(header))
+	if len(header) != 8 {
+		t.Errorf("Expected 8 columns, got %d", len(header))
 	}
 
-	totalRow, err := reader.Read()
-	if err != nil {
-		t.Fatalf("Failed to read total row: %v", err)
-	}
-
-	if totalRow[4] != "ИТОГО:" {
-		t.Errorf("Expected ИТОГО: in total row, got %s", totalRow[4])
+	// 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)
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
 
-	data := &ExportData{
-		Name: "Test",
-		Items: []ExportItem{
-			{
-				LotName:     "LOT-001",
-				Description: "Test Item",
-				Category:    "CAT",
-				Quantity:    1,
-				UnitPrice:   100.0,
-				TotalPrice:  100.0,
-			},
-		},
-		Total:     100.0,
-		CreatedAt: time.Now(),
-	}
+	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 {
@@ -300,34 +262,20 @@ func TestToCSVBytes_BackwardCompat(t *testing.T) {
 		t.Fatalf("CSV bytes too short")
 	}
 
-	// Verify BOM is present
 	expectedBOM := []byte{0xEF, 0xBB, 0xBF}
 	actualBOM := csvBytes[:3]
-	if bytes.Compare(actualBOM, expectedBOM) != 0 {
+	if !bytes.Equal(actualBOM, expectedBOM) {
 		t.Errorf("UTF-8 BOM mismatch in ToCSVBytes")
 	}
 }
 
 func TestToCSV_WriterError(t *testing.T) {
-	svc := NewExportService(config.ExportConfig{}, nil)
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
 
-	data := &ExportData{
-		Name: "Test",
-		Items: []ExportItem{
-			{
-				LotName:     "LOT-001",
-				Description: "Test",
-				Category:    "CAT",
-				Quantity:    1,
-				UnitPrice:   100.0,
-				TotalPrice:  100.0,
-			},
-		},
-		Total:     100.0,
-		CreatedAt: time.Now(),
-	}
+	data := newTestProjectData([]ExportItem{
+		{LotName: "LOT-001", Category: "CAT", Quantity: 1, UnitPrice: 100.0, TotalPrice: 100.0},
+	}, "ART", 1)
 
-	// Use a failing writer
 	failingWriter := &failingWriter{}
 
 	if err := svc.ToCSV(failingWriter, data); err == nil {
@@ -335,6 +283,167 @@ func TestToCSV_WriterError(t *testing.T) {
 	}
 }
 
+func TestToCSV_MultipleBlocks(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	data := &ProjectExportData{
+		Configs: []ConfigExportBlock{
+			{
+				Article:     "ART-1",
+				ServerCount: 2,
+				UnitPrice:   500.0,
+				Items: []ExportItem{
+					{LotName: "LOT-A", Category: "CPU", Quantity: 1, UnitPrice: 500.0, TotalPrice: 500.0},
+				},
+			},
+			{
+				Article:     "ART-2",
+				ServerCount: 3,
+				UnitPrice:   1000.0,
+				Items: []ExportItem{
+					{LotName: "LOT-B", Category: "MEM", Quantity: 2, UnitPrice: 500.0, TotalPrice: 1000.0},
+				},
+			},
+		},
+		CreatedAt: time.Now(),
+	}
+
+	var buf bytes.Buffer
+	if err := svc.ToCSV(&buf, data); err != nil {
+		t.Fatalf("ToCSV failed: %v", err)
+	}
+
+	csvBytes := buf.Bytes()
+	reader := csv.NewReader(bytes.NewReader(csvBytes[3:]))
+	reader.Comma = ';'
+	reader.FieldsPerRecord = -1 // allow variable fields
+
+	// Header
+	reader.Read()
+
+	// Block 1: server row
+	srv1, _ := reader.Read()
+	if srv1[0] != "10" {
+		t.Errorf("Block 1 line: expected 10, got %s", srv1[0])
+	}
+	if srv1[7] != "1 000" {
+		t.Errorf("Block 1 total: expected '1 000', got %q", srv1[7])
+	}
+
+	// Block 1: component row
+	comp1, _ := reader.Read()
+	if comp1[2] != "LOT-A" {
+		t.Errorf("Block 1 component: expected LOT-A, got %s", comp1[2])
+	}
+
+	// Separator row
+	sep, _ := reader.Read()
+	allEmpty := true
+	for _, v := range sep {
+		if v != "" {
+			allEmpty = false
+		}
+	}
+	if !allEmpty {
+		t.Errorf("Expected empty separator row, got %v", sep)
+	}
+
+	// Block 2: server row
+	srv2, _ := reader.Read()
+	if srv2[0] != "20" {
+		t.Errorf("Block 2 line: expected 20, got %s", srv2[0])
+	}
+	if srv2[7] != "3 000" {
+		t.Errorf("Block 2 total: expected '3 000', got %q", srv2[7])
+	}
+}
+
+func TestProjectToExportData_SortsByLine(t *testing.T) {
+	svc := NewExportService(config.ExportConfig{}, nil, nil)
+
+	configs := []models.Configuration{
+		{
+			UUID:        "cfg-1",
+			Line:        30,
+			Article:     "ART-30",
+			ServerCount: 1,
+			Items:       models.ConfigItems{{LotName: "LOT-30", Quantity: 1, UnitPrice: 300}},
+			CreatedAt:   time.Now().Add(-1 * time.Hour),
+		},
+		{
+			UUID:        "cfg-2",
+			Line:        10,
+			Article:     "ART-10",
+			ServerCount: 1,
+			Items:       models.ConfigItems{{LotName: "LOT-10", Quantity: 1, UnitPrice: 100}},
+			CreatedAt:   time.Now().Add(-2 * time.Hour),
+		},
+		{
+			UUID:        "cfg-3",
+			Line:        20,
+			Article:     "ART-20",
+			ServerCount: 1,
+			Items:       models.ConfigItems{{LotName: "LOT-20", Quantity: 1, UnitPrice: 200}},
+			CreatedAt:   time.Now().Add(-3 * time.Hour),
+		},
+	}
+
+	data := svc.ProjectToExportData(configs)
+	if len(data.Configs) != 3 {
+		t.Fatalf("expected 3 blocks, got %d", len(data.Configs))
+	}
+	if data.Configs[0].Article != "ART-10" || data.Configs[0].Line != 10 {
+		t.Fatalf("first block must be line 10, got article=%s line=%d", data.Configs[0].Article, data.Configs[0].Line)
+	}
+	if data.Configs[1].Article != "ART-20" || data.Configs[1].Line != 20 {
+		t.Fatalf("second block must be line 20, got article=%s line=%d", data.Configs[1].Article, data.Configs[1].Line)
+	}
+	if data.Configs[2].Article != "ART-30" || data.Configs[2].Line != 30 {
+		t.Fatalf("third block must be line 30, got article=%s line=%d", data.Configs[2].Article, data.Configs[2].Line)
+	}
+}
+
+func TestFormatPriceWithSpace(t *testing.T) {
+	tests := []struct {
+		input    float64
+		expected string
+	}{
+		{0, "0"},
+		{100, "100"},
+		{1000, "1 000"},
+		{10470, "10 470"},
+		{104700, "104 700"},
+		{1000000, "1 000 000"},
+	}
+
+	for _, tt := range tests {
+		result := formatPriceWithSpace(tt.input)
+		if result != tt.expected {
+			t.Errorf("formatPriceWithSpace(%v): expected %q, got %q", tt.input, tt.expected, result)
+		}
+	}
+}
+
+func TestFormatPriceComma(t *testing.T) {
+	tests := []struct {
+		input    float64
+		expected string
+	}{
+		{100.0, "100"},
+		{2074.5, "2074,5"},
+		{100.50, "100,5"},
+		{99.99, "99,99"},
+		{0, "0"},
+	}
+
+	for _, tt := range tests {
+		result := formatPriceComma(tt.input)
+		if result != tt.expected {
+			t.Errorf("formatPriceComma(%v): expected %q, got %q", tt.input, tt.expected, result)
+		}
+	}
+}
+
 // failingWriter always returns an error
 type failingWriter struct{}
 

internal/services/local_configuration.go

@@ -107,6 +107,7 @@ func (s *LocalConfigurationService) Create(ownerUsername string, req *CreateConf
 	if err := s.createWithVersion(localCfg, ownerUsername); err != nil {
 		return nil, fmt.Errorf("create configuration with version: %w", err)
 	}
+	cfg.Line = localCfg.Line
 
 	// Record usage stats
 	_ = s.quoteService.RecordUsage(req.Items)
@@ -325,6 +326,7 @@ func (s *LocalConfigurationService) CloneToProject(configUUID string, ownerUsern
 	if err := s.createWithVersion(localCfg, ownerUsername); err != nil {
 		return nil, fmt.Errorf("clone configuration with version: %w", err)
 	}
+	clone.Line = localCfg.Line
 
 	return clone, nil
 }
@@ -442,14 +444,14 @@ func (s *LocalConfigurationService) RefreshPrices(uuid string, ownerUsername str
 
 // GetByUUIDNoAuth returns configuration without ownership check
 func (s *LocalConfigurationService) GetByUUIDNoAuth(uuid string) (*models.Configuration, error) {
-	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
-	if err != nil {
+	var localCfg localdb.LocalConfiguration
+	if err := s.localDB.DB().Preload("CurrentVersion").Where("uuid = ?", uuid).First(&localCfg).Error; 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,9 +463,21 @@ 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 {
-			return nil, err
+			// 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
+			}
 		}
 	}
 	pricelistID, err := s.resolvePricelistID(req.PricelistID)
@@ -571,10 +585,30 @@ 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)
@@ -608,6 +642,7 @@ func (s *LocalConfigurationService) CloneNoAuthToProject(configUUID string, newN
 	if err := s.createWithVersion(localCfg, ownerUsername); err != nil {
 		return nil, fmt.Errorf("clone configuration without auth with version: %w", err)
 	}
+	clone.Line = localCfg.Line
 
 	return clone, nil
 }
@@ -768,6 +803,143 @@ 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)
+		}
+
+		version, err := s.loadVersionForPendingTx(tx, localCfg)
+		if err != nil {
+			return 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
+}
+
+func (s *LocalConfigurationService) ReorderProjectConfigurationsNoAuth(projectUUID string, orderedUUIDs []string) ([]models.Configuration, error) {
+	projectUUID = strings.TrimSpace(projectUUID)
+	if projectUUID == "" {
+		return nil, ErrProjectNotFound
+	}
+	if _, err := s.localDB.GetProjectByUUID(projectUUID); err != nil {
+		return nil, ErrProjectNotFound
+	}
+	if len(orderedUUIDs) == 0 {
+		return []models.Configuration{}, nil
+	}
+
+	seen := make(map[string]struct{}, len(orderedUUIDs))
+	normalized := make([]string, 0, len(orderedUUIDs))
+	for _, raw := range orderedUUIDs {
+		u := strings.TrimSpace(raw)
+		if u == "" {
+			return nil, fmt.Errorf("ordered_uuids contains empty uuid")
+		}
+		if _, exists := seen[u]; exists {
+			return nil, fmt.Errorf("ordered_uuids contains duplicate uuid: %s", u)
+		}
+		seen[u] = struct{}{}
+		normalized = append(normalized, u)
+	}
+
+	err := s.localDB.DB().Transaction(func(tx *gorm.DB) error {
+		var active []localdb.LocalConfiguration
+		if err := tx.Where("project_uuid = ? AND is_active = ?", projectUUID, true).
+			Find(&active).Error; err != nil {
+			return fmt.Errorf("load project active configurations: %w", err)
+		}
+		if len(active) != len(normalized) {
+			return fmt.Errorf("ordered_uuids count mismatch: expected %d got %d", len(active), len(normalized))
+		}
+
+		byUUID := make(map[string]*localdb.LocalConfiguration, len(active))
+		for i := range active {
+			cfg := active[i]
+			byUUID[cfg.UUID] = &cfg
+		}
+		for _, id := range normalized {
+			if _, ok := byUUID[id]; !ok {
+				return fmt.Errorf("configuration %s not found in project %s", id, projectUUID)
+			}
+		}
+
+		now := time.Now()
+		for idx, id := range normalized {
+			cfg := byUUID[id]
+			newLine := (idx + 1) * 10
+			if cfg.Line == newLine {
+				continue
+			}
+
+			cfg.Line = newLine
+			cfg.UpdatedAt = now
+			cfg.SyncStatus = "pending"
+
+			if err := tx.Save(cfg).Error; err != nil {
+				return fmt.Errorf("save reordered configuration %s: %w", cfg.UUID, err)
+			}
+
+			version, err := s.loadVersionForPendingTx(tx, cfg)
+			if err != nil {
+				return err
+			}
+			if err := s.enqueueConfigurationPendingChangeTx(tx, cfg, "update", version, ""); err != nil {
+				return fmt.Errorf("enqueue reorder pending change for %s: %w", cfg.UUID, err)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	var localConfigs []localdb.LocalConfiguration
+	if err := s.localDB.DB().
+		Preload("CurrentVersion").
+		Where("project_uuid = ? AND is_active = ?", projectUUID, true).
+		Order("CASE WHEN COALESCE(line_no, 0) <= 0 THEN 2147483647 ELSE line_no END ASC, created_at DESC, id DESC").
+		Find(&localConfigs).Error; err != nil {
+		return nil, fmt.Errorf("load reordered configurations: %w", err)
+	}
+
+	result := make([]models.Configuration, 0, len(localConfigs))
+	for i := range localConfigs {
+		result = append(result, *localdb.LocalToConfiguration(&localConfigs[i]))
+	}
+	return result, nil
+}
+
 // ImportFromServer imports configurations from MariaDB to local SQLite cache.
 func (s *LocalConfigurationService) ImportFromServer() (*sync.ConfigImportResult, error) {
 	return s.syncService.ImportConfigurationsToLocal()
@@ -881,6 +1053,11 @@ func (s *LocalConfigurationService) isOwner(cfg *localdb.LocalConfiguration, own
 
 func (s *LocalConfigurationService) createWithVersion(localCfg *localdb.LocalConfiguration, createdBy string) error {
 	return s.localDB.DB().Transaction(func(tx *gorm.DB) error {
+		if localCfg.IsActive {
+			if err := s.ensureConfigurationLineTx(tx, localCfg); err != nil {
+				return err
+			}
+		}
 		if err := tx.Create(localCfg).Error; err != nil {
 			return fmt.Errorf("create local configuration: %w", err)
 		}
@@ -896,6 +1073,7 @@ 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)
@@ -922,6 +1100,45 @@ 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 {
+					if !hasNonRevisionConfigurationChanges(&locked, localCfg) {
+						cfg = localdb.LocalToConfiguration(&locked)
+						return nil
+					}
+					if err := tx.Save(localCfg).Error; err != nil {
+						return fmt.Errorf("save local configuration (no new revision): %w", err)
+					}
+					cfg = localdb.LocalToConfiguration(localCfg)
+					if err := s.enqueueConfigurationPendingChangeTx(tx, localCfg, operation, currentVersion, createdBy); err != nil {
+						return fmt.Errorf("enqueue %s pending change without revision: %w", operation, err)
+					}
+					if err := s.recalculateLocalPricelistUsageTx(tx); err != nil {
+						return fmt.Errorf("recalculate local pricelist usage: %w", err)
+					}
+					return nil
+				}
+			}
+		}
+
+		if localCfg.IsActive {
+			if err := s.ensureConfigurationLineTx(tx, localCfg); err != nil {
+				return err
+			}
+		}
+
 		if err := tx.Save(localCfg).Error; err != nil {
 			return fmt.Errorf("save local configuration: %w", err)
 		}
@@ -937,6 +1154,7 @@ 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 {
@@ -955,6 +1173,158 @@ func (s *LocalConfigurationService) saveWithVersionAndPending(localCfg *localdb.
 	return cfg, nil
 }
 
+func hasNonRevisionConfigurationChanges(current *localdb.LocalConfiguration, next *localdb.LocalConfiguration) bool {
+	if current == nil || next == nil {
+		return true
+	}
+	if current.Name != next.Name ||
+		current.Notes != next.Notes ||
+		current.IsTemplate != next.IsTemplate ||
+		current.ServerModel != next.ServerModel ||
+		current.SupportCode != next.SupportCode ||
+		current.Article != next.Article ||
+		current.OnlyInStock != next.OnlyInStock ||
+		current.IsActive != next.IsActive ||
+		current.Line != next.Line {
+		return true
+	}
+	if !equalUintPtr(current.PricelistID, next.PricelistID) ||
+		!equalUintPtr(current.WarehousePricelistID, next.WarehousePricelistID) ||
+		!equalUintPtr(current.CompetitorPricelistID, next.CompetitorPricelistID) ||
+		!equalStringPtr(current.ProjectUUID, next.ProjectUUID) {
+		return true
+	}
+	return false
+}
+
+func equalStringPtr(a, b *string) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	return strings.TrimSpace(*a) == strings.TrimSpace(*b)
+}
+
+func equalUintPtr(a, b *uint) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	return *a == *b
+}
+
+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) loadVersionForPendingTx(tx *gorm.DB, localCfg *localdb.LocalConfiguration) (*localdb.LocalConfigurationVersion, error) {
+	if localCfg.CurrentVersionID != nil && *localCfg.CurrentVersionID != "" {
+		var current localdb.LocalConfigurationVersion
+		if err := tx.Where("id = ?", *localCfg.CurrentVersionID).First(&current).Error; err == nil {
+			return &current, nil
+		}
+	}
+
+	var latest localdb.LocalConfigurationVersion
+	if err := tx.Where("configuration_uuid = ?", localCfg.UUID).
+		Order("version_no DESC").
+		First(&latest).Error; err != nil {
+		if !errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fmt.Errorf("load version for pending change: %w", err)
+		}
+
+		// Legacy/imported rows may exist without local version history.
+		// Bootstrap the first version so pending sync payloads can reference a version.
+		version, createErr := s.appendVersionTx(tx, localCfg, "bootstrap", "")
+		if createErr != nil {
+			return nil, fmt.Errorf("bootstrap version for pending change: %w", createErr)
+		}
+		if err := tx.Model(&localdb.LocalConfiguration{}).
+			Where("uuid = ?", localCfg.UUID).
+			Update("current_version_id", version.ID).Error; err != nil {
+			return nil, fmt.Errorf("set current version id for bootstrapped pending change: %w", err)
+		}
+		localCfg.CurrentVersionID = &version.ID
+		return version, nil
+	}
+	return &latest, nil
+}
+
+func (s *LocalConfigurationService) ensureConfigurationLineTx(tx *gorm.DB, localCfg *localdb.LocalConfiguration) error {
+	if localCfg == nil || !localCfg.IsActive {
+		return nil
+	}
+
+	needsAssign := localCfg.Line <= 0
+	if !needsAssign {
+		query := tx.Model(&localdb.LocalConfiguration{}).
+			Where("is_active = ? AND line_no = ?", true, localCfg.Line)
+
+		if strings.TrimSpace(localCfg.UUID) != "" {
+			query = query.Where("uuid <> ?", strings.TrimSpace(localCfg.UUID))
+		}
+
+		if localCfg.ProjectUUID != nil && strings.TrimSpace(*localCfg.ProjectUUID) != "" {
+			query = query.Where("project_uuid = ?", strings.TrimSpace(*localCfg.ProjectUUID))
+		} else {
+			query = query.Where("project_uuid IS NULL OR TRIM(project_uuid) = ''")
+		}
+
+		var conflicts int64
+		if err := query.Count(&conflicts).Error; err != nil {
+			return fmt.Errorf("check line_no conflict for configuration %s: %w", localCfg.UUID, err)
+		}
+		needsAssign = conflicts > 0
+	}
+
+	if needsAssign {
+		line, err := localdb.NextConfigurationLineTx(tx, localCfg.ProjectUUID, localCfg.UUID)
+		if err != nil {
+			return fmt.Errorf("assign line_no for configuration %s: %w", localCfg.UUID, err)
+		}
+		localCfg.Line = line
+	}
+	return 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,
@@ -1051,6 +1421,9 @@ func (s *LocalConfigurationService) rollbackToVersion(configurationUUID string,
 		current.ServerCount = rollbackData.ServerCount
 		current.PricelistID = rollbackData.PricelistID
 		current.OnlyInStock = rollbackData.OnlyInStock
+		if rollbackData.Line > 0 {
+			current.Line = rollbackData.Line
+		}
 		current.PriceUpdatedAt = rollbackData.PriceUpdatedAt
 		current.UpdatedAt = time.Now()
 		current.SyncStatus = "pending"

internal/services/local_configuration_versioning_test.go

@@ -27,8 +27,12 @@ func TestSaveCreatesNewVersionAndUpdatesCurrentPointer(t *testing.T) {
 		t.Fatalf("create config: %v", err)
 	}
 
-	if _, err := service.RenameNoAuth(created.UUID, "v2"); err != nil {
-		t.Fatalf("rename config: %v", err)
+	if _, err := service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "v1",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 2, UnitPrice: 1000}},
+		ServerCount: 1,
+	}); err != nil {
+		t.Fatalf("update config: %v", err)
 	}
 
 	versions := loadVersions(t, local, created.UUID)
@@ -60,8 +64,12 @@ func TestRollbackCreatesNewVersionWithTargetData(t *testing.T) {
 		t.Fatalf("create config: %v", err)
 	}
 
-	if _, err := service.RenameNoAuth(created.UUID, "changed"); err != nil {
-		t.Fatalf("rename config: %v", err)
+	if _, err := service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "base",
+		Items:       models.ConfigItems{{LotName: "RAM_A", Quantity: 3, UnitPrice: 100}},
+		ServerCount: 1,
+	}); err != nil {
+		t.Fatalf("update config: %v", err)
 	}
 	if _, err := service.RollbackToVersionWithNote(created.UUID, 1, "tester", "test rollback"); err != nil {
 		t.Fatalf("rollback to v1: %v", err)
@@ -79,6 +87,128 @@ 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 TestReorderProjectConfigurationsDoesNotCreateNewVersions(t *testing.T) {
+	service, local := newLocalConfigServiceForTest(t)
+
+	project := &localdb.LocalProject{
+		UUID:          "project-reorder",
+		OwnerUsername: "tester",
+		Code:          "PRJ-ORDER",
+		Variant:       "",
+		Name:          ptrString("Project Reorder"),
+		IsActive:      true,
+		CreatedAt:     time.Now(),
+		UpdatedAt:     time.Now(),
+		SyncStatus:    "pending",
+	}
+	if err := local.SaveProject(project); err != nil {
+		t.Fatalf("save project: %v", err)
+	}
+
+	first, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "Cfg A",
+		Items:       models.ConfigItems{{LotName: "CPU_A", Quantity: 1, UnitPrice: 100}},
+		ServerCount: 1,
+		ProjectUUID: &project.UUID,
+	})
+	if err != nil {
+		t.Fatalf("create first config: %v", err)
+	}
+	second, err := service.Create("tester", &CreateConfigRequest{
+		Name:        "Cfg B",
+		Items:       models.ConfigItems{{LotName: "CPU_B", Quantity: 1, UnitPrice: 200}},
+		ServerCount: 1,
+		ProjectUUID: &project.UUID,
+	})
+	if err != nil {
+		t.Fatalf("create second config: %v", err)
+	}
+
+	beforeFirst := loadVersions(t, local, first.UUID)
+	beforeSecond := loadVersions(t, local, second.UUID)
+
+	reordered, err := service.ReorderProjectConfigurationsNoAuth(project.UUID, []string{second.UUID, first.UUID})
+	if err != nil {
+		t.Fatalf("reorder configurations: %v", err)
+	}
+	if len(reordered) != 2 {
+		t.Fatalf("expected 2 reordered configs, got %d", len(reordered))
+	}
+	if reordered[0].UUID != second.UUID || reordered[0].Line != 10 {
+		t.Fatalf("expected second config first with line 10, got uuid=%s line=%d", reordered[0].UUID, reordered[0].Line)
+	}
+	if reordered[1].UUID != first.UUID || reordered[1].Line != 20 {
+		t.Fatalf("expected first config second with line 20, got uuid=%s line=%d", reordered[1].UUID, reordered[1].Line)
+	}
+
+	afterFirst := loadVersions(t, local, first.UUID)
+	afterSecond := loadVersions(t, local, second.UUID)
+	if len(afterFirst) != len(beforeFirst) || len(afterSecond) != len(beforeSecond) {
+		t.Fatalf("reorder must not create new versions")
+	}
+
+	var pendingCount int64
+	if err := local.DB().
+		Table("pending_changes").
+		Where("entity_type = ? AND operation = ? AND entity_uuid IN ?", "configuration", "update", []string{first.UUID, second.UUID}).
+		Count(&pendingCount).Error; err != nil {
+		t.Fatalf("count reorder pending changes: %v", err)
+	}
+	if pendingCount < 2 {
+		t.Fatalf("expected at least 2 pending update changes for reorder, got %d", pendingCount)
+	}
+}
+
 func TestAppendOnlyInvariantOldRowsUnchanged(t *testing.T) {
 	service, local := newLocalConfigServiceForTest(t)
 
@@ -97,8 +227,12 @@ func TestAppendOnlyInvariantOldRowsUnchanged(t *testing.T) {
 	}
 	v1Before := versionsBefore[0]
 
-	if _, err := service.RenameNoAuth(created.UUID, "after-rename"); err != nil {
-		t.Fatalf("rename config: %v", err)
+	if _, err := service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "initial",
+		Items:       models.ConfigItems{{LotName: "SSD_A", Quantity: 2, UnitPrice: 300}},
+		ServerCount: 1,
+	}); err != nil {
+		t.Fatalf("update config: %v", err)
 	}
 	if _, err := service.RollbackToVersion(created.UUID, 1, "tester"); err != nil {
 		t.Fatalf("rollback: %v", err)
@@ -144,7 +278,7 @@ func TestConcurrentSaveNoDuplicateVersionNumbers(t *testing.T) {
 		go func() {
 			defer wg.Done()
 			<-start
-			if err := renameWithRetry(service, created.UUID, fmt.Sprintf("name-%d", i)); err != nil {
+			if err := updateWithRetry(service, created.UUID, i+2); err != nil {
 				errCh <- err
 			}
 		}()
@@ -191,7 +325,8 @@ func TestUpdateNoAuthKeepsProjectWhenProjectUUIDOmitted(t *testing.T) {
 	project := &localdb.LocalProject{
 		UUID:          "project-keep",
 		OwnerUsername: "tester",
-		Name:          "Keep Project",
+		Code:          "TEST-KEEP",
+		Name:          ptrString("Keep Project"),
 		IsActive:      true,
 		CreatedAt:     time.Now(),
 		UpdatedAt:     time.Now(),
@@ -227,6 +362,103 @@ 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()
 
@@ -259,10 +491,14 @@ func loadVersions(t *testing.T, local *localdb.LocalDB, configurationUUID string
 	return versions
 }
 
-func renameWithRetry(service *LocalConfigurationService, uuid string, name string) error {
+func updateWithRetry(service *LocalConfigurationService, uuid string, quantity int) error {
 	var lastErr error
 	for i := 0; i < 6; i++ {
-		_, err := service.RenameNoAuth(uuid, name)
+		_, err := service.UpdateNoAuth(uuid, &CreateConfigRequest{
+			Name:        "base",
+			Items:       models.ConfigItems{{LotName: "NIC_A", Quantity: quantity, UnitPrice: 150}},
+			ServerCount: 1,
+		})
 		if err == nil {
 			return nil
 		}
@@ -273,7 +509,7 @@ func renameWithRetry(service *LocalConfigurationService, uuid string, name strin
 		}
 		return err
 	}
-	return fmt.Errorf("rename retries exhausted: %w", lastErr)
+	return fmt.Errorf("update retries exhausted: %w", lastErr)
 }
 
 func TestRollbackVersionSnapshotJSONMatchesV1(t *testing.T) {
@@ -287,8 +523,12 @@ func TestRollbackVersionSnapshotJSONMatchesV1(t *testing.T) {
 	if err != nil {
 		t.Fatalf("create config: %v", err)
 	}
-	if _, err := service.RenameNoAuth(created.UUID, "second"); err != nil {
-		t.Fatalf("rename: %v", err)
+	if _, err := service.UpdateNoAuth(created.UUID, &CreateConfigRequest{
+		Name:        "initial",
+		Items:       models.ConfigItems{{LotName: "GPU_A", Quantity: 2, UnitPrice: 2000}},
+		ServerCount: 1,
+	}); err != nil {
+		t.Fatalf("update: %v", err)
 	}
 	if _, err := service.RollbackToVersion(created.UUID, 1, "tester"); err != nil {
 		t.Fatalf("rollback: %v", err)

internal/services/project.go

@@ -16,8 +16,10 @@ import (
 )
 
 var (
-	ErrProjectNotFound  = errors.New("project not found")
-	ErrProjectForbidden = errors.New("access to project forbidden")
+	ErrProjectNotFound         = errors.New("project not found")
+	ErrProjectForbidden        = errors.New("access to project forbidden")
+	ErrProjectCodeExists       = errors.New("project code and variant already exist")
+	ErrCannotDeleteMainVariant = errors.New("cannot delete main variant")
 )
 
 type ProjectService struct {
@@ -29,12 +31,16 @@ func NewProjectService(localDB *localdb.LocalDB) *ProjectService {
 }
 
 type CreateProjectRequest struct {
-	Name       string `json:"name"`
-	TrackerURL string `json:"tracker_url"`
+	Code       string  `json:"code"`
+	Variant    string  `json:"variant,omitempty"`
+	Name       *string `json:"name,omitempty"`
+	TrackerURL string  `json:"tracker_url"`
 }
 
 type UpdateProjectRequest struct {
-	Name       string  `json:"name"`
+	Code       *string `json:"code,omitempty"`
+	Variant    *string `json:"variant,omitempty"`
+	Name       *string `json:"name,omitempty"`
 	TrackerURL *string `json:"tracker_url,omitempty"`
 }
 
@@ -45,17 +51,30 @@ type ProjectConfigurationsResult struct {
 }
 
 func (s *ProjectService) Create(ownerUsername string, req *CreateProjectRequest) (*models.Project, error) {
-	name := strings.TrimSpace(req.Name)
-	if name == "" {
-		return nil, fmt.Errorf("project name is required")
+	var namePtr *string
+	if req.Name != nil {
+		name := strings.TrimSpace(*req.Name)
+		if name != "" {
+			namePtr = &name
+		}
+	}
+	code := strings.TrimSpace(req.Code)
+	if code == "" {
+		return nil, fmt.Errorf("project code is required")
+	}
+	variant := strings.TrimSpace(req.Variant)
+	if err := s.ensureUniqueProjectCodeVariant("", code, variant); err != nil {
+		return nil, err
 	}
 
 	now := time.Now()
 	localProject := &localdb.LocalProject{
 		UUID:          uuid.NewString(),
 		OwnerUsername: ownerUsername,
-		Name:          name,
-		TrackerURL:    normalizeProjectTrackerURL(name, req.TrackerURL),
+		Code:          code,
+		Variant:       variant,
+		Name:          namePtr,
+		TrackerURL:    normalizeProjectTrackerURL(code, req.TrackerURL),
 		IsActive:      true,
 		IsSystem:      false,
 		CreatedAt:     now,
@@ -77,16 +96,32 @@ func (s *ProjectService) Update(projectUUID, ownerUsername string, req *UpdatePr
 		return nil, ErrProjectNotFound
 	}
 
-	name := strings.TrimSpace(req.Name)
-	if name == "" {
-		return nil, fmt.Errorf("project name is required")
+	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
 	}
 
-	localProject.Name = name
+	if req.Name != nil {
+		name := strings.TrimSpace(*req.Name)
+		if name == "" {
+			localProject.Name = nil
+		} else {
+			localProject.Name = &name
+		}
+	}
 	if req.TrackerURL != nil {
-		localProject.TrackerURL = normalizeProjectTrackerURL(name, *req.TrackerURL)
+		localProject.TrackerURL = normalizeProjectTrackerURL(localProject.Code, *req.TrackerURL)
 	} else if strings.TrimSpace(localProject.TrackerURL) == "" {
-		localProject.TrackerURL = normalizeProjectTrackerURL(name, "")
+		localProject.TrackerURL = normalizeProjectTrackerURL(localProject.Code, "")
 	}
 	localProject.UpdatedAt = time.Now()
 	localProject.SyncStatus = "pending"
@@ -99,6 +134,38 @@ 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)
 }
@@ -107,6 +174,17 @@ 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
@@ -197,8 +275,23 @@ func (s *ProjectService) ListConfigurations(projectUUID, ownerUsername, status s
 		}, nil
 	}
 
-	localConfigs, err := s.localDB.GetConfigurations()
-	if err != nil {
+	query := s.localDB.DB().
+		Preload("CurrentVersion").
+		Where("project_uuid = ?", projectUUID).
+		Order("CASE WHEN COALESCE(line_no, 0) <= 0 THEN 2147483647 ELSE line_no END ASC, created_at DESC, id DESC")
+
+	switch status {
+	case "active", "":
+		query = query.Where("is_active = ?", true)
+	case "archived":
+		query = query.Where("is_active = ?", false)
+	case "all":
+	default:
+		query = query.Where("is_active = ?", true)
+	}
+
+	var localConfigs []localdb.LocalConfiguration
+	if err := query.Find(&localConfigs).Error; err != nil {
 		return nil, err
 	}
 
@@ -206,25 +299,6 @@ func (s *ProjectService) ListConfigurations(projectUUID, ownerUsername, status s
 	total := 0.0
 	for i := range localConfigs {
 		localCfg := localConfigs[i]
-		if localCfg.ProjectUUID == nil || *localCfg.ProjectUUID != projectUUID {
-			continue
-		}
-		switch status {
-		case "active", "":
-			if !localCfg.IsActive {
-				continue
-			}
-		case "archived":
-			if localCfg.IsActive {
-				continue
-			}
-		case "all":
-		default:
-			if !localCfg.IsActive {
-				continue
-			}
-		}
-
 		cfg := localdb.LocalToConfiguration(&localCfg)
 		if cfg.TotalPrice != nil {
 			total += *cfg.TotalPrice

internal/services/quote.go

@@ -289,6 +289,13 @@ func (s *QuoteService) CalculatePriceLevels(req *PriceLevelsRequest) (*PriceLeve
 				result.ResolvedPricelistIDs[sourceKey] = latest.ID
 			}
 		}
+		if st.id == 0 && s.localDB != nil {
+			localPL, err := s.localDB.GetLatestLocalPricelistBySource(sourceKey)
+			if err == nil && localPL != nil {
+				st.id = localPL.ServerID
+				result.ResolvedPricelistIDs[sourceKey] = localPL.ServerID
+			}
+		}
 		if st.id == 0 {
 			continue
 		}

internal/services/sync/partnumber_books.go

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

internal/services/sync/partnumber_seen.go

@@ -0,0 +1,51 @@
+package sync
+
+import (
+	"fmt"
+	"log/slog"
+	"time"
+)
+
+// SeenPartnumber represents an unresolved vendor partnumber to report.
+type SeenPartnumber struct {
+	Partnumber  string
+	Description string
+	Ignored     bool
+}
+
+// PushPartnumberSeen inserts unresolved vendor partnumbers into qt_vendor_partnumber_seen on MariaDB.
+// Uses INSERT ... ON DUPLICATE KEY UPDATE so existing rows are updated (last_seen_at) without error.
+func (s *Service) PushPartnumberSeen(items []SeenPartnumber) error {
+	if len(items) == 0 {
+		return nil
+	}
+
+	mariaDB, err := s.getDB()
+	if err != nil {
+		return fmt.Errorf("database not available: %w", err)
+	}
+
+	now := time.Now().UTC()
+	for _, item := range items {
+		if item.Partnumber == "" {
+			continue
+		}
+		err := mariaDB.Exec(`
+			INSERT INTO qt_vendor_partnumber_seen
+				(source_type, vendor, partnumber, description, is_ignored, last_seen_at)
+			VALUES
+				('manual', '', ?, ?, ?, ?)
+			ON DUPLICATE KEY UPDATE
+				last_seen_at = VALUES(last_seen_at),
+				is_ignored   = VALUES(is_ignored),
+				description  = COALESCE(NULLIF(VALUES(description), ''), description)
+		`, item.Partnumber, item.Description, item.Ignored, now).Error
+		if err != nil {
+			slog.Error("failed to upsert partnumber_seen", "partnumber", item.Partnumber, "error", err)
+			// Continue with remaining items
+		}
+	}
+
+	slog.Info("partnumber_seen pushed to server", "count", len(items))
+	return nil
+}

internal/services/sync/service.go

@@ -145,6 +145,12 @@ func (s *Service) ImportConfigurationsToLocal() (*ConfigImportResult, error) {
 
 			if existing != nil && err == nil {
 				localCfg.ID = existing.ID
+				if localCfg.Line <= 0 && existing.Line > 0 {
+					localCfg.Line = existing.Line
+				}
+				// vendor_spec is local-only for BOM tab and is not stored on server.
+				// Preserve it during server pull updates.
+				localCfg.VendorSpec = existing.VendorSpec
 				result.Updated++
 			} else {
 				result.Imported++
@@ -200,6 +206,7 @@ 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
@@ -350,6 +357,15 @@ func (s *Service) SyncPricelists() (int, error) {
 		// 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)
+				}
+			}
 			continue
 		}
 
@@ -848,11 +864,36 @@ func (s *Service) pushProjectChange(change *localdb.PendingChange) error {
 	projectRepo := repository.NewProjectRepository(mariaDB)
 	project := payload.Snapshot
 	project.UUID = payload.ProjectUUID
-
-	if err := projectRepo.UpsertByUUID(&project); err != nil {
-		return fmt.Errorf("upsert project on server: %w", err)
+	if strings.TrimSpace(project.Code) == "" {
+		project.Code = strings.TrimSpace(derefString(project.Name))
+		if project.Code == "" {
+			project.Code = project.UUID
+		}
 	}
 
+	// 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 {
@@ -868,6 +909,17 @@ 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 != "" {
@@ -1138,7 +1190,8 @@ func (s *Service) ensureConfigurationProject(mariaDB *gorm.DB, cfg *models.Confi
 		systemProject = &models.Project{
 			UUID:          uuid.NewString(),
 			OwnerUsername: "",
-			Name:          "Без проекта",
+			Code:          "Без проекта",
+			Name:          ptrString("Без проекта"),
 			IsActive:      true,
 			IsSystem:      true,
 		}
@@ -1302,6 +1355,21 @@ 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)
 	}
@@ -1309,6 +1377,64 @@ 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_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: "Project A"})
+	project, err := projectService.Create("tester", &services.CreateProjectRequest{Name: ptrString("Project A"), Code: "PRJ-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: "Project v1"})
+	project, err := projectService.Create("tester", &services.CreateProjectRequest{Name: ptrString("Project v1"), Code: "PRJ-V1"})
 	if err != nil {
 		t.Fatalf("create project: %v", err)
 	}
-	if _, err := projectService.Update(project.UUID, "tester", &services.UpdateProjectRequest{Name: "Project v2"}); err != nil {
+	if _, err := projectService.Update(project.UUID, "tester", &services.UpdateProjectRequest{Name: ptrString("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 != "Project v2" {
-		t.Fatalf("expected latest project name, got %q", serverProject.Name)
+	if serverProject.Name == nil || *serverProject.Name != "Project v2" {
+		t.Fatalf("expected latest project name, got %v", serverProject.Name)
 	}
 
 	var serverCfg models.Configuration
@@ -250,6 +250,135 @@ func TestPushPendingChangesCreateIsIdempotent(t *testing.T) {
 	}
 }
 
+func TestPushPendingChangesConfigurationPushesLine(t *testing.T) {
+	local := newLocalDBForSyncTest(t)
+	serverDB := newServerDBForSyncTest(t)
+
+	localSync := syncsvc.NewService(nil, local)
+	configService := services.NewLocalConfigurationService(local, localSync, &services.QuoteService{}, func() bool { return false })
+	pushService := syncsvc.NewServiceWithDB(serverDB, local)
+
+	created, err := configService.Create("tester", &services.CreateConfigRequest{
+		Name:        "Cfg Line Push",
+		Items:       models.ConfigItems{{LotName: "CPU_LINE", Quantity: 1, UnitPrice: 1000}},
+		ServerCount: 1,
+	})
+	if err != nil {
+		t.Fatalf("create config: %v", err)
+	}
+	if created.Line != 10 {
+		t.Fatalf("expected local create line=10, got %d", created.Line)
+	}
+
+	if _, err := pushService.PushPendingChanges(); err != nil {
+		t.Fatalf("push pending changes: %v", err)
+	}
+
+	var serverCfg models.Configuration
+	if err := serverDB.Where("uuid = ?", created.UUID).First(&serverCfg).Error; err != nil {
+		t.Fatalf("load server config: %v", err)
+	}
+	if serverCfg.Line != 10 {
+		t.Fatalf("expected server line=10 after push, got %d", serverCfg.Line)
+	}
+}
+
+func TestImportConfigurationsToLocalPullsLine(t *testing.T) {
+	local := newLocalDBForSyncTest(t)
+	serverDB := newServerDBForSyncTest(t)
+
+	cfg := models.Configuration{
+		UUID:          "server-line-config",
+		OwnerUsername: "tester",
+		Name:          "Cfg Line Pull",
+		Items:         models.ConfigItems{{LotName: "CPU_PULL", Quantity: 1, UnitPrice: 900}},
+		ServerCount:   1,
+		Line:          40,
+	}
+	total := cfg.Items.Total()
+	cfg.TotalPrice = &total
+	if err := serverDB.Create(&cfg).Error; err != nil {
+		t.Fatalf("seed server config: %v", err)
+	}
+
+	svc := syncsvc.NewServiceWithDB(serverDB, local)
+	if _, err := svc.ImportConfigurationsToLocal(); err != nil {
+		t.Fatalf("import configurations to local: %v", err)
+	}
+
+	localCfg, err := local.GetConfigurationByUUID(cfg.UUID)
+	if err != nil {
+		t.Fatalf("load local config: %v", err)
+	}
+	if localCfg.Line != 40 {
+		t.Fatalf("expected imported line=40, got %d", localCfg.Line)
+	}
+}
+
+func TestImportConfigurationsToLocalPreservesLocalVendorSpec(t *testing.T) {
+	local := newLocalDBForSyncTest(t)
+	serverDB := newServerDBForSyncTest(t)
+
+	cfg := models.Configuration{
+		UUID:          "server-vendorspec-config",
+		OwnerUsername: "tester",
+		Name:          "Cfg VendorSpec Pull",
+		Items:         models.ConfigItems{{LotName: "CPU_PULL", Quantity: 1, UnitPrice: 900}},
+		ServerCount:   1,
+		Line:          50,
+	}
+	total := cfg.Items.Total()
+	cfg.TotalPrice = &total
+	if err := serverDB.Create(&cfg).Error; err != nil {
+		t.Fatalf("seed server config: %v", err)
+	}
+
+	localSpec := localdb.VendorSpec{
+		{
+			SortOrder:        10,
+			VendorPartnumber: "GPU-NVHGX-H200-8141",
+			Quantity:         1,
+			Description:      "NVIDIA HGX Delta-Next GPU Baseboard",
+			LotMappings: []localdb.VendorSpecLotMapping{
+				{LotName: "GPU_NV_H200_141GB_SXM_(HGX)", QuantityPerPN: 8},
+			},
+		},
+	}
+	if err := local.SaveConfiguration(&localdb.LocalConfiguration{
+		UUID:             cfg.UUID,
+		OriginalUsername: "tester",
+		Name:             "Local cfg",
+		Items:            localdb.LocalConfigItems{{LotName: "CPU_PULL", Quantity: 1, UnitPrice: 900}},
+		IsActive:         true,
+		SyncStatus:       "synced",
+		Line:             50,
+		VendorSpec:       localSpec,
+		CreatedAt:        time.Now().Add(-30 * time.Minute),
+		UpdatedAt:        time.Now().Add(-30 * time.Minute),
+	}); err != nil {
+		t.Fatalf("seed local configuration: %v", err)
+	}
+
+	svc := syncsvc.NewServiceWithDB(serverDB, local)
+	if _, err := svc.ImportConfigurationsToLocal(); err != nil {
+		t.Fatalf("import configurations to local: %v", err)
+	}
+
+	localCfg, err := local.GetConfigurationByUUID(cfg.UUID)
+	if err != nil {
+		t.Fatalf("load local config: %v", err)
+	}
+	if len(localCfg.VendorSpec) != 1 {
+		t.Fatalf("expected local vendor_spec preserved, got %d rows", len(localCfg.VendorSpec))
+	}
+	if localCfg.VendorSpec[0].VendorPartnumber != "GPU-NVHGX-H200-8141" {
+		t.Fatalf("unexpected vendor_partnumber after import: %q", localCfg.VendorSpec[0].VendorPartnumber)
+	}
+	if len(localCfg.VendorSpec[0].LotMappings) != 1 || localCfg.VendorSpec[0].LotMappings[0].LotName != "GPU_NV_H200_141GB_SXM_(HGX)" {
+		t.Fatalf("unexpected lot mappings after import: %+v", localCfg.VendorSpec[0].LotMappings)
+	}
+}
+
 func TestPushPendingChangesCreateThenUpdateBeforeFirstPush(t *testing.T) {
 	local := newLocalDBForSyncTest(t)
 	serverDB := newServerDBForSyncTest(t)
@@ -324,6 +453,8 @@ 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,
@@ -333,6 +464,9 @@ 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,
@@ -356,6 +490,7 @@ CREATE TABLE qt_configurations (
 	competitor_pricelist_id INTEGER NULL,
 	disable_price_refresh INTEGER NOT NULL DEFAULT 0,
 	only_in_stock INTEGER NOT NULL DEFAULT 0,
+	line_no INTEGER NULL,
 	price_updated_at DATETIME NULL,
 	created_at DATETIME
 );`).Error; err != nil {
@@ -364,6 +499,10 @@ 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/vendor_spec_resolver.go

@@ -0,0 +1,129 @@
+package services
+
+import (
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+)
+
+// ResolvedBOMRow is the result of resolving a single vendor BOM row.
+type ResolvedBOMRow struct {
+	localdb.VendorSpecItem
+	// ResolutionSource already on VendorSpecItem: "book", "manual_suggestion", "unresolved"
+}
+
+// AggregatedLOT represents a LOT with its aggregated quantity from the BOM.
+type AggregatedLOT struct {
+	LotName  string
+	Quantity int
+}
+
+// VendorSpecResolver resolves vendor BOM rows to LOT names using the active partnumber book.
+type VendorSpecResolver struct {
+	bookRepo *repository.PartnumberBookRepository
+}
+
+func NewVendorSpecResolver(bookRepo *repository.PartnumberBookRepository) *VendorSpecResolver {
+	return &VendorSpecResolver{bookRepo: bookRepo}
+}
+
+// Resolve resolves each vendor spec item's lot name using the 3-step algorithm.
+// It returns the resolved items. Manual lot suggestions from the input are preserved as pre-fill.
+func (r *VendorSpecResolver) Resolve(items []localdb.VendorSpecItem) ([]localdb.VendorSpecItem, error) {
+	// Step 1: Get the active book
+	book, err := r.bookRepo.GetActiveBook()
+	if err != nil {
+		// No book available — mark all as unresolved
+		for i := range items {
+			if items[i].ResolvedLotName == "" {
+				items[i].ResolutionSource = "unresolved"
+			}
+		}
+		return items, nil
+	}
+
+	for i, item := range items {
+		pn := item.VendorPartnumber
+
+		// Step 1: Look up in active book
+		matches, err := r.bookRepo.FindLotByPartnumber(book.ID, pn)
+		if err == nil && len(matches) > 0 {
+			items[i].ResolvedLotName = matches[0].LotName
+			items[i].ResolutionSource = "book"
+			continue
+		}
+
+		// Step 2: Pre-fill from manual_lot_suggestion if provided
+		if item.ManualLotSuggestion != "" {
+			items[i].ResolvedLotName = item.ManualLotSuggestion
+			items[i].ResolutionSource = "manual_suggestion"
+			continue
+		}
+
+		// Step 3: Unresolved
+		items[i].ResolvedLotName = ""
+		items[i].ResolutionSource = "unresolved"
+	}
+
+	return items, nil
+}
+
+// AggregateLOTs applies the qty-logic to compute per-LOT quantities from the resolved BOM.
+// qty(lot) = SUM(qty of primary PN rows for this lot) if any primary PN exists, else 1.
+func AggregateLOTs(items []localdb.VendorSpecItem, book *localdb.LocalPartnumberBook, bookRepo *repository.PartnumberBookRepository) ([]AggregatedLOT, error) {
+	// Gather all unique lot names that resolved
+	lotPrimary := make(map[string]int)     // lot_name → sum of primary PN quantities
+	lotAny := make(map[string]bool)        // lot_name → seen at least once (non-primary)
+	lotHasPrimary := make(map[string]bool) // lot_name → has at least one primary PN in spec
+
+	if book != nil {
+		for _, item := range items {
+			if item.ResolvedLotName == "" {
+				continue
+			}
+			lot := item.ResolvedLotName
+			pn := item.VendorPartnumber
+
+			// Find if this pn is primary for its lot
+			matches, err := bookRepo.FindLotByPartnumber(book.ID, pn)
+			if err != nil || len(matches) == 0 {
+				// manual/unresolved — treat as non-primary
+				lotAny[lot] = true
+				continue
+			}
+			for _, m := range matches {
+				if m.LotName == lot {
+					if m.IsPrimaryPN {
+						lotPrimary[lot] += item.Quantity
+						lotHasPrimary[lot] = true
+					} else {
+						lotAny[lot] = true
+					}
+				}
+			}
+		}
+	} else {
+		// No book: all resolved rows contribute qty=1 per lot
+		for _, item := range items {
+			if item.ResolvedLotName != "" {
+				lotAny[item.ResolvedLotName] = true
+			}
+		}
+	}
+
+	// Build aggregated list
+	seen := make(map[string]bool)
+	var result []AggregatedLOT
+	for _, item := range items {
+		lot := item.ResolvedLotName
+		if lot == "" || seen[lot] {
+			continue
+		}
+		seen[lot] = true
+		qty := 1
+		if lotHasPrimary[lot] {
+			qty = lotPrimary[lot]
+		}
+		result = append(result, AggregatedLOT{LotName: lot, Quantity: qty})
+	}
+	return result, nil
+}

markdown

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

@@ -36,3 +36,6 @@ Implemented strict `lot_category` flow using `pricelist_items.lot_category` only
 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/025_add_project_code.sql

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

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

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

migrations/028_add_line_no_to_configurations.sql

@@ -0,0 +1,18 @@
+ALTER TABLE qt_configurations
+    ADD COLUMN IF NOT EXISTS line_no INT NULL AFTER only_in_stock;
+
+UPDATE qt_configurations q
+JOIN (
+    SELECT
+        id,
+        ROW_NUMBER() OVER (
+            PARTITION BY COALESCE(NULLIF(TRIM(project_uuid), ''), '__NO_PROJECT__')
+            ORDER BY created_at ASC, id ASC
+        ) AS rn
+    FROM qt_configurations
+    WHERE line_no IS NULL OR line_no <= 0
+) ranked ON ranked.id = q.id
+SET q.line_no = ranked.rn * 10;
+
+ALTER TABLE qt_configurations
+    ADD INDEX IF NOT EXISTS idx_qt_configurations_project_line_no (project_uuid, line_no);

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "QuoteForge",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

package.json

@@ -0,0 +1 @@
+{}

pricelists_window.md

@@ -1,315 +0,0 @@
-# Промпт для ИИ: Перенос паттерна Прайслист
-
-Используй этот документ как промпт для ИИ при переносе реализации прайслиста в другой проект.
-
----
-
-## Задача
-
-Я имею рабочую реализацию окна "Прайслист" в проекте QuoteForge. Нужно перенести эту реализацию в проект [ДОП_ПРОЕКТ_НАЗВАНИЕ], сохраняя структуру, логику и UI/UX.
-
-## Что перенести
-
-### Frontend - Лист прайслистов (`/pricelists`)
-
-**Файл источник:** QuoteForge/web/templates/pricelists.html
-
-**Компоненты:**
-1. **Таблица** - список прайслистов с колонками:
-   - Версия (монофонт)
-   - Тип (estimate/warehouse/competitor)
-   - Дата создания
-   - Автор (обычно "sync")
-   - Позиций (количество товаров)
-   - Исп. (использований)
-   - Статус (зеленый "Активен" / серый "Неактивен")
-   - Действия (Просмотр, Удалить если не используется)
-
-2. **Пагинация** - навигация по страницам с активной страницей выделена
-
-3. **Модальное окно** - "Создать прайслист" (если есть прав на запись)
-
-**Что копировать:**
-- HTML структуру таблицы из lines 10-30
-- JavaScript функции:
-  - `loadPricelists(page)` - загрузка списка
-  - `renderPricelists(items)` - рендер таблицы
-  - `renderPagination(total, page, perPage)` - пагинация
-  - `checkPricelistWritePermission()` - проверка прав
-  - Модальные функции: `openCreateModal()`, `closeCreateModal()`, `createPricelist()`
-- CSS классы Tailwind (скопируются как есть)
-
-**Где использовать в дочернем проекте:**
-- URL: `/pricelists` (или адаптировать под ваши маршруты)
-- API: `GET /api/pricelists?page=1&per_page=20`
-
----
-
-### Frontend - Детали прайслиста (`/pricelists/:id`)
-
-**Файл источник:** QuoteForge/web/templates/pricelist_detail.html
-
-**Компоненты:**
-1. **Хлебная крошка** - кнопка назад на список
-
-2. **Инфо-панель** - сводка по прайслисту:
-   - Версия (монофонт)
-   - Дата создания
-   - Автор
-   - Позиций (количество)
-   - Использований (в скольких конфигах)
-   - Статус (зеленый/серый)
-   - Истекает (дата или "-")
-
-3. **Таблица товаров** - с поиском и пагинацией:
-   - Артикул (монофонт, lot_name)
-   - Категория (извлекается первая часть до "_")
-   - Описание (обрезается до 60 символов с "...")
-   - [УСЛОВНО] Доступно (qty) - только для warehouse источника
-   - [УСЛОВНО] Partnumbers - только для warehouse источника
-   - Цена, $ (с 2 знаками после запятой)
-   - Настройки (аббревиатуры: РУЧН, Сред, Взвеш.мед, периоды (1н, 1м, 3м, 1г), коэффициент, МЕТА)
-
-4. **Поиск** - дебаунс 300мс, поиск по lot_name
-
-5. **Динамические колонки** - qty и partnumbers скрываются/показываются в зависимости от source (warehouse или нет)
-
-**Что копировать:**
-- HTML структуру из lines 4-78
-- JavaScript функции:
-  - `loadPricelistInfo()` - загрузка деталей прайслиста
-  - `loadItems(page)` - загрузка товаров
-  - `renderItems(items)` - рендер таблицы товаров
-  - `renderItemsPagination(total, page, perPage)` - пагинация товаров
-  - `isWarehouseSource()` - проверка источника
-  - `toggleWarehouseColumns()` - показать/скрыть conditional колонки
-  - `formatQty(qty)` - форматирование количества
-  - `formatPriceSettings(item)` - форматирование строки настроек
-  - `escapeHtml(text)` - экранирование HTML
-  - Debounce для поиска (lines 300-306)
-- CSS классы Tailwind
-- Логику conditional колонок (lines 152-164)
-
-**Где использовать в дочернем проекте:**
-- URL: `/pricelists/:id`
-- API:
-  - `GET /api/pricelists/:id`
-  - `GET /api/pricelists/:id/items?page=1&per_page=50&search=...`
-
----
-
-### Backend - Handler
-
-**Файл источник:** QuoteForge/internal/handlers/pricelist.go
-
-**Методы для реализации:**
-
-1. **List** (lines 23-89)
-   - Параметры: `page`, `per_page`, `source` (фильтр), `active_only`
-   - Логика:
-     - Получить все прайслисты
-     - Отфильтровать по source (case-insensitive)
-     - Отсортировать по CreatedAt DESC (свежее сверху)
-     - Пагинировать
-     - Для каждого: посчитать товары (CountLocalPricelistItems), использования (IsUsed)
-     - Вернуть JSON с полями: id, source, version, created_by, item_count, usage_count, is_active, created_at, synced_from
-
-2. **Get** (lines 92-116)
-   - Параметр: `id` (uint из URL)
-   - Логика:
-     - Получить прайслист по ID
-     - Вернуть его детали (id, source, version, item_count, is_active, created_at)
-     - 404 если не найден
-
-3. **GetItems** (lines 119-181)
-   - Параметры: `id` (URL), `page`, `per_page`, `search` (query)
-   - Логика:
-     - Получить прайслист по ID
-     - Получить товары этого прайслиста
-     - Фильтровать по lot_name LIKE search (если передан)
-     - Посчитать total
-     - Пагинировать
-     - Для каждого товара: извлечь категорию из lot_name (первая часть до "_")
-     - Вернуть JSON: source, items (id, lot_name, price, category, available_qty, partnumbers), total, page, per_page
-
-4. **GetLotNames** (lines 183-211)
-   - Параметр: `id` (URL)
-   - Логика:
-     - Получить все lot_names из этого прайслиста
-     - Отсортировать alphabetically
-     - Вернуть JSON: lot_names (array of strings), total
-
-5. **GetLatest** (lines 214-233)
-   - Параметр: `source` (query, default "estimate")
-   - Логика:
-     - Нормализовать source (case-insensitive)
-     - Получить самый свежий прайслист по этому source
-     - Вернуть его детали
-     - 404 если не найден
-
-**Регистрация маршрутов:**
-```go
-pricelists := api.Group("/pricelists")
-{
-    pricelists.GET("", handler.List)
-    pricelists.GET("/latest", handler.GetLatest)
-    pricelists.GET("/:id", handler.Get)
-    pricelists.GET("/:id/items", handler.GetItems)
-    pricelists.GET("/:id/lots", handler.GetLotNames)
-}
-```
-
----
-
-## Адаптация для другого проекта
-
-### Что нужно изменить
-
-1. **Источник данных**
-   - QuoteForge использует local DB (LocalPricelist, LocalPricelistItem)
-   - В вашем проекте: замените на ваши структуры/таблицы
-   - Сущность "прайслист" может называться по-другому
-
-2. **API маршруты**
-   - `/api/pricelists` → ваш путь
-   - `:id` - может быть UUID вместо int, адаптировать parsing
-
-3. **Имена полей**
-   - Если у вас нет поля `version` - используйте ID или дату
-   - Если нет `source` - опустить фильтр
-   - Если нет `IsUsed` - считать как всегда 0
-
-4. **Структуры данных**
-   - Pricelist должна иметь: id, name/version, created_at, source, item_count
-   - PricelistItem должна иметь: id, lot_name, price, available_qty, partnumbers
-
-5. **Условные колонки**
-   - Логика: если source == "warehouse", показать qty и partnumbers
-   - Адаптировать под ваши источники/типы
-
-### Что копировать как есть
-
-- **HTML структура** - таблицы, модали, классы Tailwind
-- **JavaScript логика** - все функции загрузки, рендера, пагинации
-- **CSS классы** - Tailwind работает везде одинаково
-- **Форматирование функций** - formatPrice, formatQty, formatDate
-
----
-
-## Пошаговая инструкция для ИИ
-
-1. **Прочитай оба файла:**
-   - QuoteForge/web/templates/pricelists.html (список)
-   - QuoteForge/web/templates/pricelist_detail.html (детали)
-   - QuoteForge/internal/handlers/pricelist.go (backend)
-
-2. **Определи структуры данных в дочернем проекте:**
-   - Какая таблица хранит "прайслисты"?
-   - Какие у неё поля?
-   - Как связаны товары?
-
-3. **Адаптируй Backend:**
-   - Скопируй методы Handler
-   - Замени DB вызовы на вызовы вашего хранилища
-   - Замени имена полей в JSON ответах если нужно
-   - Убедись, что API возвращает нужный формат
-
-4. **Адаптируй Frontend - Список:**
-   - Скопируй HTML таблицу
-   - Скопируй функции load/render/pagination
-   - Замени маршруты `/pricelists` → ваши
-   - Замени API endpoint → ваш
-   - Протестируй список загружается
-
-5. **Адаптируй Frontend - Детали:**
-   - Скопируй HTML для деталей
-   - Скопируй функции loadInfo/loadItems/render
-   - Замени маршруты и endpoints
-   - Особое внимание на conditional колонки (toggleWarehouseColumns)
-   - Протестируй поиск работает
-
-6. **Протестируй:**
-   - Список загружается
-   - Пагинация работает
-   - Детали открываются
-   - Поиск работает
-   - Conditional колонки показываются/скрываются правильно
-   - Форматирование цен и дат работает
-
----
-
-## Пример адаптации
-
-### Backend (было):
-```go
-func (h *PricelistHandler) List(c *gin.Context) {
-    localPLs, err := h.localDB.GetLocalPricelists()
-    // ...
-}
-```
-
-### Backend (стало):
-```go
-func (h *CatalogHandler) List(c *gin.Context) {
-    catalogs, err := h.service.GetAllCatalogs(page, perPage)
-    // ...
-}
-```
-
-### Frontend (было):
-```javascript
-const resp = await fetch(`/api/pricelists?page=${page}&per_page=20`);
-```
-
-### Frontend (стало):
-```javascript
-const resp = await fetch(`/api/catalogs?page=${page}&per_page=20`);
-```
-
----
-
-## Качество результата
-
-Когда закончишь:
-- ✅ Список и детали выглядят идентично QuoteForge
-- ✅ Все функции работают (load, render, pagination, search, conditional columns)
-- ✅ Обработка ошибок (404, empty list, network errors)
-- ✅ Таблицы с Tailwind классами оформлены одинаково
-- ✅ Форматирование чисел/дат совпадает
-
----
-
-## Вопросы для ИИ
-
-Перед тем как давать этот промпт, ответь на эти вопросы:
-
-1. **Какие у тебя структуры данных для "прайслиста"?**
-   - Пример: какие поля, как называется таблица
-
-2. **Какие API endpoints уже есть?**
-   - Или нужно создать с нуля?
-
-3. **Есть ли уже разница в источниках (estimate/warehouse)?**
-   - Или все одного типа?
-
-4. **Нужна ли возможность создавать прайслисты?**
-   - Или только просмотр?
-
----
-
-## Чеклист для проверки
-
-После переноса проверь:
-
-- [ ] Backend: List возвращает правильный JSON
-- [ ] Backend: Get возвращает детали
-- [ ] Backend: GetItems возвращает товары с поиском
-- [ ] Frontend: Список загружается на `/pricelists`
-- [ ] Frontend: Клик на прайслист открывает `/pricelists/:id`
-- [ ] Frontend: Таблица на детальной странице рендеритсяся
-- [ ] Frontend: Поиск работает с дебаунсом
-- [ ] Frontend: Пагинация работает
-- [ ] Frontend: Conditional колонки показываются/скрываются
-- [ ] Frontend: Форматирование цен работает (2 знака)
-- [ ] Frontend: Форматирование дат работает (ru-RU)
-- [ ] UI: Выглядит идентично QuoteForge

releases/memory/v1.3.0.md

@@ -0,0 +1,68 @@
+# Release v1.3.0 (2026-02-11)
+
+## Summary
+
+Introduced article generation with pricelist categories, added local configuration storage, and expanded sync/export capabilities. Simplified article generator compression and loosened project update constraints.
+
+## Changes
+
+### Main Features: Articles + Pricelist Categories
+
+- **Article generation pipeline**
+  - New generator and tests under `internal/article/`
+  - Category support with test coverage
+- **Pricelist category integration**
+  - Handler and repository updates
+  - Sync backfill test for category propagation
+
+### Local Configuration Storage
+
+- **Local DB support**
+  - New localdb models, converters, snapshots, and migrations
+  - Local configuration service for cached configurations
+
+### Export & UI
+
+- **Export handler updates** for article data output
+- **Configs and index templates** adjusted for new article-related fields
+
+### Behavior Changes
+
+- **Cross-user project updates allowed**
+  - Removed restriction in project service
+- **Article compression refinement**
+  - Generator logic simplified to reduce complexity
+
+## Breaking Changes
+
+None identified. Existing APIs remain intact.
+
+## Files Modified
+
+1. `internal/article/*` - Article generator + categories + tests
+2. `internal/localdb/*` - Local DB models, migrations, snapshots
+3. `internal/handlers/export.go` - Export updates
+4. `internal/handlers/pricelist.go` - Category handling
+5. `internal/services/sync/service.go` - Category backfill logic
+6. `web/templates/configs.html` - Article field updates
+7. `web/templates/index.html` - Article field updates
+
+**Stats:** 33 files changed, 2059 insertions(+), 329 deletions(-)
+
+## Commits
+
+- `5edffe8` - Add article generation and pricelist categories
+- `e355903` - Allow cross-user project updates
+- `e58fd35` - Refine article compression and simplify generator
+
+## Testing Checklist
+
+- [ ] Tests not run (not requested)
+
+## Migration Notes
+
+- New migrations:
+  - `022_add_article_to_configurations.sql`
+  - `023_add_server_model_to_configurations.sql`
+  - `024_add_support_code_to_configurations.sql`
+  - Ensure migrations are applied before running v1.3.0

releases/memory/v1.3.2.md

@@ -0,0 +1,66 @@
+# Release v1.3.2 (2026-02-19)
+
+## Summary
+
+Release focuses on stability and data integrity for local configurations. Added configuration revision history, stronger recovery for broken local sync/version states, improved sync self-healing, and clearer API error logging.
+
+## Changes
+
+### Configuration Revisions
+
+- Added full local configuration revision flow with storage and UI support.
+- Introduced revisions page/template and backend plumbing for browsing revisions.
+- Prevented duplicate revisions when content did not actually change.
+
+### Local Data Integrity and Recovery
+
+- Added migration and snapshot support for local configuration version data.
+- Hardened updates for legacy/orphaned configuration rows:
+  - allow update when project UUID is unchanged even if referenced project is missing locally;
+  - recover gracefully when `current_version_id` is stale or version rows are missing.
+- Added regression tests for orphan-project and missing-current-version scenarios.
+
+### Sync Reliability
+
+- Added smart self-healing path for sync errors.
+- Fixed duplicate-project sync edge cases.
+
+### API and Logging
+
+- Improved HTTP error mapping for configuration updates (`404/403` instead of generic `500` in known cases).
+- Enhanced request logger to capture error responses (status, response body snippet, gin errors) for failed requests.
+
+### UI and Export
+
+- Updated project detail and index templates for revisions and related UX improvements.
+- Updated export pipeline and tests to align with revisions/project behavior changes.
+
+## Breaking Changes
+
+None identified.
+
+## Files Changed
+
+- 24 files changed, 2394 insertions(+), 482 deletions(-)
+- Main touched areas:
+  - `internal/services/local_configuration.go`
+  - `internal/services/local_configuration_versioning_test.go`
+  - `internal/localdb/{localdb.go,migrations.go,snapshots.go,local_migrations_test.go}`
+  - `internal/services/export.go`
+  - `cmd/qfs/main.go`
+  - `web/templates/{config_revisions.html,project_detail.html,index.html,base.html}`
+
+## Commits Included (`v1.3.1..v1.3.2`)
+
+- `b153afb` - Add smart self-healing for sync errors
+- `8508ee2` - Fix sync errors for duplicate projects and add modal scrolling
+- `2e973b6` - Add configuration revisions system and project variant deletion
+- `71f73e2` - chore: save current changes
+- `cbaeafa` - Deduplicate configuration revisions and update revisions UI
+- `075fc70` - Harden local config updates and error logging
+
+## Testing
+
+- [x] Targeted tests for local configuration update/version recovery:
+  - `go test ./internal/services -run 'TestUpdateNoAuth(AllowsOrphanProjectWhenUUIDUnchanged|RecoversWhenCurrentVersionMissing|KeepsProjectWhenProjectUUIDOmitted)$'`
+- [ ] Full regression suite not run in this release step.

web/templates/base.html

@@ -21,6 +21,7 @@
                     <div class="hidden md:flex space-x-4">
                         <a href="/projects" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Мои проекты</a>
                         <a href="/pricelists" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Прайслисты</a>
+                        <a href="/partnumber-books" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Партномера</a>
                         <a href="/setup" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Настройки</a>
                     </div>
                 </div>
@@ -45,10 +46,10 @@
     <div id="toast" class="fixed bottom-4 right-4 z-50"></div>
 
     <!-- Sync Info Modal -->
-    <div id="sync-modal" class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 hidden">
-        <div class="bg-white rounded-lg shadow-xl max-w-lg w-full mx-4">
-            <div class="p-6">
-                <div class="flex justify-between items-center mb-4">
+    <div id="sync-modal" class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 hidden p-4">
+        <div class="bg-white rounded-lg shadow-xl max-w-lg w-full max-h-[90vh] flex flex-col">
+            <div class="p-6 border-b border-gray-200 flex-shrink-0">
+                <div class="flex justify-between items-center">
                     <h3 class="text-lg font-medium text-gray-900">Информация о синхронизации</h3>
                     <button onclick="closeSyncModal()" class="text-gray-400 hover:text-gray-500">
                         <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
@@ -56,8 +57,10 @@
                         </svg>
                     </button>
                 </div>
+            </div>
 
-                <div class="space-y-5">
+            <div class="overflow-y-auto flex-1">
+                <div class="p-6 space-y-5">
                     <!-- Section 1: DB Connection -->
                     <div>
                         <h4 class="font-medium text-gray-900 mb-2">Подключение к БД</h4>
@@ -123,9 +126,31 @@
                         <h4 class="font-medium text-gray-900 mb-2">Ошибки синхронизации</h4>
                         <div id="modal-errors-list" class="text-sm max-h-40 overflow-y-auto space-y-1"></div>
                     </div>
-                </div>
 
-                <div class="mt-6 flex justify-end">
+                    <!-- Section 5: Self-Healing (shown only if errors exist) -->
+                    <div id="modal-repair-section" class="hidden">
+                        <div class="bg-blue-50 border border-blue-200 rounded-lg p-4">
+                            <h4 class="font-medium text-blue-900 mb-2">Автоматическое исправление</h4>
+                            <p class="text-sm text-blue-700 mb-3">
+                                Система может исправить данные и очистить ошибки синхронизации:
+                            </p>
+                            <ul class="text-sm text-blue-700 mb-3 ml-4 list-disc space-y-1">
+                                <li>Проверит и исправит названия проектов</li>
+                                <li>Восстановит битые ссылки на проекты</li>
+                                <li>Очистит ошибки и даст pending changes еще шанс</li>
+                            </ul>
+                            <button id="repair-button" onclick="repairPendingChanges()"
+                                class="w-full px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed">
+                                ИСПРАВИТЬ
+                            </button>
+                            <div id="repair-result" class="mt-2 text-sm hidden"></div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div class="p-6 border-t border-gray-200 flex-shrink-0">
+                <div class="flex justify-end">
                     <button onclick="closeSyncModal()" class="px-4 py-2 bg-gray-600 text-white rounded-md hover:bg-gray-700">
                         Закрыть
                     </button>
@@ -235,7 +260,8 @@
                 // Section 4: Errors
                 const errorsSection = document.getElementById('modal-errors-section');
                 const errorsList = document.getElementById('modal-errors-list');
-                if (data.errors && data.errors.length > 0) {
+                const hasErrors = data.errors && data.errors.length > 0;
+                if (hasErrors) {
                     errorsSection.classList.remove('hidden');
                     errorsList.innerHTML = data.errors.map(error => {
                         const time = new Date(error.timestamp).toLocaleString('ru-RU');
@@ -246,12 +272,65 @@
                 } else {
                     errorsSection.classList.add('hidden');
                 }
+
+                // Section 5: Repair (show only if errors exist)
+                const repairSection = document.getElementById('modal-repair-section');
+                const repairResult = document.getElementById('repair-result');
+                if (hasErrors) {
+                    repairSection.classList.remove('hidden');
+                    repairResult.classList.add('hidden');
+                    repairResult.innerHTML = '';
+                } else {
+                    repairSection.classList.add('hidden');
+                }
             } catch(e) {
                 console.error('Failed to load sync info:', e);
                 document.getElementById('modal-db-status').textContent = 'Ошибка загрузки';
             }
         }
 
+        // Repair pending changes
+        async function repairPendingChanges() {
+            const button = document.getElementById('repair-button');
+            const resultDiv = document.getElementById('repair-result');
+
+            button.disabled = true;
+            button.textContent = 'Исправление...';
+            resultDiv.classList.add('hidden');
+
+            try {
+                const resp = await fetch('/api/sync/repair', { method: 'POST' });
+                const data = await resp.json();
+
+                if (data.success) {
+                    resultDiv.classList.remove('hidden');
+                    if (data.repaired > 0) {
+                        resultDiv.className = 'mt-2 text-sm text-green-700 bg-green-50 rounded px-3 py-2';
+                        resultDiv.textContent = `✓ Исправлено: ${data.repaired}`;
+                        // Reload sync info after repair
+                        setTimeout(() => loadSyncInfo(), 1000);
+                    } else {
+                        resultDiv.className = 'mt-2 text-sm text-yellow-700 bg-yellow-50 rounded px-3 py-2';
+                        resultDiv.textContent = 'Нечего исправлять или проблемы остались';
+                        if (data.remaining_errors && data.remaining_errors.length > 0) {
+                            resultDiv.innerHTML += '<div class="mt-1 text-xs">' + data.remaining_errors.join('<br>') + '</div>';
+                        }
+                    }
+                } else {
+                    resultDiv.classList.remove('hidden');
+                    resultDiv.className = 'mt-2 text-sm text-red-700 bg-red-50 rounded px-3 py-2';
+                    resultDiv.textContent = 'Ошибка: ' + (data.error || 'неизвестная ошибка');
+                }
+            } catch (e) {
+                resultDiv.classList.remove('hidden');
+                resultDiv.className = 'mt-2 text-sm text-red-700 bg-red-50 rounded px-3 py-2';
+                resultDiv.textContent = 'Ошибка запроса: ' + e.message;
+            } finally {
+                button.disabled = false;
+                button.textContent = 'ИСПРАВИТЬ';
+            }
+        }
+
         // Event delegation for sync dropdown and actions
         document.addEventListener('DOMContentLoaded', function() {
             loadDBUser();

web/templates/config_revisions.html

@@ -0,0 +1,238 @@
+{{define "title"}}Ревизии - QuoteForge{{end}}
+
+{{define "content"}}
+<div class="space-y-4">
+    <div class="flex items-center gap-3">
+        <a href="/projects" class="text-gray-500 hover:text-gray-700" title="Все проекты">
+            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 9.75L12 3l9 6.75v9A2.25 2.25 0 0118.75 21h-13.5A2.25 2.25 0 013 18.75v-9z"></path>
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 21v-6h6v6"></path>
+            </svg>
+        </a>
+        <div class="text-2xl font-bold flex items-center gap-2" id="revisions-breadcrumbs">
+            <a id="breadcrumb-code-link" href="/projects" class="text-blue-700 hover:underline">
+                <span id="breadcrumb-code">—</span>
+            </a>
+            <span class="text-gray-400">-</span>
+            <a id="breadcrumb-variant-link" href="/projects" class="text-blue-700 hover:underline">
+                <span id="breadcrumb-variant">main</span>
+            </a>
+            <span class="text-gray-400">-</span>
+            <a id="breadcrumb-config-link" href="/configurator" class="text-blue-700 hover:underline">
+                <span id="breadcrumb-config">—</span>
+            </a>
+            <span class="text-gray-400">-</span>
+            <span class="text-gray-600">Ревизии</span>
+        </div>
+    </div>
+
+    <div id="revisions-list">
+        <div class="text-center py-8 text-gray-500">Загрузка...</div>
+    </div>
+</div>
+
+<script>
+const configUUID = '{{.ConfigUUID}}';
+let configData = null;
+let projectData = null;
+
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text || '';
+    return div.innerHTML;
+}
+
+function formatMoney(value) {
+    const num = Number(value);
+    if (!Number.isFinite(num)) return '—';
+    return '$\u00A0' + num.toLocaleString('ru-RU', {minimumFractionDigits: 0, maximumFractionDigits: 2});
+}
+
+function parseVersionSnapshot(version) {
+    try {
+        const raw = typeof version.data === 'string' ? version.data : '';
+        if (!raw) return { article: '—', price: null, serverCount: 1 };
+        const parsed = JSON.parse(raw);
+        return {
+            article: parsed.article || '—',
+            price: typeof parsed.total_price === 'number' ? parsed.total_price : null,
+            serverCount: Number.isFinite(Number(parsed.server_count)) && Number(parsed.server_count) > 0
+                ? Number(parsed.server_count)
+                : 1
+        };
+    } catch (_) {
+        return { article: '—', price: null, serverCount: 1 };
+    }
+}
+
+function truncateBreadcrumbSpecName(name) {
+    const maxLength = 16;
+    if (!name || name.length <= maxLength) return name;
+    return name.slice(0, maxLength - 1) + '…';
+}
+
+async function loadConfigInfo() {
+    try {
+        const resp = await fetch('/api/configs/' + configUUID);
+        if (!resp.ok) {
+            document.getElementById('revisions-list').innerHTML =
+                '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Конфигурация не найдена</div>';
+            return false;
+        }
+        configData = await resp.json();
+
+        const fullConfigName = configData.name || 'Конфигурация';
+        const configBreadcrumbEl = document.getElementById('breadcrumb-config');
+        configBreadcrumbEl.textContent = truncateBreadcrumbSpecName(fullConfigName);
+        configBreadcrumbEl.title = fullConfigName;
+        document.getElementById('breadcrumb-config-link').href = '/configurator?uuid=' + configUUID;
+
+        if (configData.project_uuid) {
+            const projResp = await fetch('/api/projects/' + configData.project_uuid);
+            if (projResp.ok) {
+                projectData = await projResp.json();
+                document.getElementById('breadcrumb-code').textContent = projectData.code || '—';
+                const variant = (projectData.variant || '').trim();
+                document.getElementById('breadcrumb-variant').textContent = variant === '' ? 'main' : variant;
+                document.getElementById('breadcrumb-variant-link').href = '/projects/' + projectData.uuid;
+
+                // Find main variant for code link
+                const allResp = await fetch('/api/projects/all');
+                if (allResp.ok) {
+                    const allProjects = await allResp.json();
+                    const main = (Array.isArray(allProjects) ? allProjects : []).find(
+                        p => p.code === projectData.code && (p.variant || '').trim() === ''
+                    );
+                    if (main) {
+                        document.getElementById('breadcrumb-code-link').href = '/projects/' + main.uuid;
+                    }
+                }
+            }
+        }
+        return true;
+    } catch (e) {
+        document.getElementById('revisions-list').innerHTML =
+            '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Ошибка загрузки</div>';
+        return false;
+    }
+}
+
+async function loadVersions() {
+    try {
+        const resp = await fetch('/api/configs/' + configUUID + '/versions?limit=200');
+        if (!resp.ok) {
+            document.getElementById('revisions-list').innerHTML =
+                '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Ошибка загрузки ревизий</div>';
+            return;
+        }
+        const data = await resp.json();
+        const versions = data.versions || [];
+        renderVersions(versions);
+    } catch (e) {
+        document.getElementById('revisions-list').innerHTML =
+            '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Ошибка загрузки</div>';
+    }
+}
+
+function renderVersions(versions) {
+    if (versions.length === 0) {
+        document.getElementById('revisions-list').innerHTML =
+            '<div class="bg-white rounded-lg shadow p-8 text-center text-gray-500">Нет ревизий</div>';
+        return;
+    }
+
+    let html = '<div class="bg-white rounded-lg shadow overflow-hidden"><table class="w-full">';
+    html += '<thead class="bg-gray-50"><tr>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Версия</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Дата</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Автор</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Артикул</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Цена</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Серверов</th>';
+    html += '<th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Действия</th>';
+    html += '</tr></thead><tbody class="divide-y">';
+
+    versions.forEach((v, idx) => {
+        const date = new Date(v.created_at).toLocaleString('ru-RU');
+        const author = v.created_by || '—';
+        const snapshot = parseVersionSnapshot(v);
+        const isCurrent = idx === 0;
+
+        html += '<tr class="hover:bg-gray-50' + (isCurrent ? ' bg-blue-50' : '') + '">';
+        html += '<td class="px-4 py-3 text-sm font-medium">';
+        html += 'v' + v.version_no;
+        if (isCurrent) html += ' <span class="text-xs text-blue-600 font-normal">(текущая)</span>';
+        html += '</td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + escapeHtml(date) + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + escapeHtml(author) + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + escapeHtml(snapshot.article) + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + formatMoney(snapshot.price) + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + escapeHtml(String(snapshot.serverCount)) + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-right space-x-2">';
+
+        // Open in configurator (readonly view)
+        html += '<a href="/configurator?uuid=' + configUUID + '&version=' + v.version_no + '" class="text-blue-600 hover:text-blue-800 inline-block" title="Открыть">';
+        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"></path><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z"></path></svg></a>';
+
+        // Clone from this version
+        html += '<button onclick="cloneFromVersion(' + v.version_no + ')" class="text-green-600 hover:text-green-800" title="Скопировать из этой ревизии">';
+        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"></path></svg></button>';
+
+        // Rollback (not for current version)
+        if (!isCurrent) {
+            html += '<button onclick="rollbackToVersion(' + v.version_no + ')" class="text-orange-600 hover:text-orange-800" title="Восстановить эту ревизию">';
+            html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 10h10a8 8 0 018 8v2M3 10l6 6m-6-6l6-6"></path></svg></button>';
+        }
+
+        html += '</td></tr>';
+    });
+
+    html += '</tbody></table></div>';
+    document.getElementById('revisions-list').innerHTML = html;
+}
+
+async function cloneFromVersion(versionNo) {
+    const name = prompt('Название копии:', (configData ? configData.name : '') + ' (v' + versionNo + ')');
+    if (!name) return;
+    const resp = await fetch('/api/configs/' + configUUID + '/clone', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({name: name, from_version: versionNo})
+    });
+    if (!resp.ok) {
+        const data = await resp.json().catch(() => ({}));
+        alert(data.error || 'Не удалось скопировать');
+        return;
+    }
+    const created = await resp.json();
+    showToast('Копия создана', 'success');
+    if (created && created.uuid) {
+        window.location.href = '/configurator?uuid=' + created.uuid;
+    }
+}
+
+async function rollbackToVersion(versionNo) {
+    if (!confirm('Восстановить конфигурацию до ревизии v' + versionNo + '?')) return;
+    const resp = await fetch('/api/configs/' + configUUID + '/rollback', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({target_version: versionNo})
+    });
+    if (!resp.ok) {
+        const data = await resp.json().catch(() => ({}));
+        alert(data.error || 'Не удалось восстановить');
+        return;
+    }
+    showToast('Ревизия восстановлена', 'success');
+    loadVersions();
+}
+
+document.addEventListener('DOMContentLoaded', async function() {
+    const ok = await loadConfigInfo();
+    if (!ok) return;
+    await loadVersions();
+});
+</script>
+{{end}}
+
+{{template "base" .}}

web/templates/configs.html

@@ -62,7 +62,7 @@
                 <label class="block text-sm font-medium text-gray-700 mb-1">Код проекта</label>
                 <input id="create-project-input"
                        list="create-project-options"
-                       placeholder="Начните вводить название проекта"
+                       placeholder="Например: OPS-123 (Lenovo)"
                        class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
                 <datalist id="create-project-options"></datalist>
                 <div class="mt-2 flex justify-between items-center gap-3">
@@ -147,7 +147,7 @@
                 <label class="block text-sm font-medium text-gray-700 mb-1">Проект</label>
                 <input id="move-project-input"
                        list="move-project-options"
-                       placeholder="Начните вводить название проекта"
+                       placeholder="Например: OPS-123 (Lenovo)"
                        class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
                 <datalist id="move-project-options"></datalist>
                 <div class="mt-2 flex justify-between items-center gap-3">
@@ -174,7 +174,17 @@
 <div id="create-project-on-move-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
     <div class="bg-white rounded-lg shadow-xl w-full max-w-md mx-4 p-6">
         <h2 class="text-xl font-semibold mb-3">Проект не найден</h2>
-        <p class="text-sm text-gray-600 mb-4">Проект "<span id="create-project-on-move-name" class="font-medium text-gray-900"></span>" не найден. <span id="create-project-on-move-description">Создать и привязать квоту?</span></p>
+        <p class="text-sm text-gray-600 mb-4">Проект с кодом "<span id="create-project-on-move-code" class="font-medium text-gray-900"></span>" не найден. <span id="create-project-on-move-description">Создать и привязать квоту?</span></p>
+        <div class="mb-4">
+            <label for="create-project-on-move-name" class="block text-sm font-medium text-gray-700 mb-1">Название проекта</label>
+            <input id="create-project-on-move-name" type="text" placeholder="Например: Инфраструктура для OPS-123"
+                   class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
+        </div>
+        <div class="mb-4">
+            <label for="create-project-on-move-variant" class="block text-sm font-medium text-gray-700 mb-1">Вариант (необязательно)</label>
+            <input id="create-project-on-move-variant" type="text" placeholder="Например: Lenovo"
+                   class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
+        </div>
         <div class="flex justify-end space-x-3">
             <button onclick="closeCreateProjectOnMoveModal()" class="px-4 py-2 text-gray-600 hover:text-gray-800">Отмена</button>
             <button id="create-project-on-move-confirm-btn" onclick="confirmCreateProjectOnMove()" class="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700">Создать и привязать</button>
@@ -191,10 +201,12 @@ let configStatusMode = 'active';
 let configsSearch = '';
 let projectsCache = [];
 let projectNameByUUID = {};
+let projectCodeByUUID = {};
+let projectVariantByUUID = {};
 let pendingMoveConfigUUID = '';
-let pendingMoveProjectName = '';
+let pendingMoveProjectCode = '';
 let pendingCreateConfigName = '';
-let pendingCreateProjectName = '';
+let pendingCreateProjectCode = '';
 
 function renderConfigs(configs) {
     const emptyText = configStatusMode === 'archived'
@@ -307,6 +319,30 @@ function renderConfigs(configs) {
     document.getElementById('configs-list').innerHTML = html;
 }
 
+function projectDisplayKey(project) {
+    const code = (project.code || '').trim();
+    const variant = (project.variant || '').trim();
+    if (!code) return '';
+    return variant ? (code + ' (' + variant + ')') : code;
+}
+
+function findProjectByInput(input) {
+    const trimmed = (input || '').trim().toLowerCase();
+    if (!trimmed) return null;
+
+    const directMatch = projectsCache.find(p => projectDisplayKey(p).toLowerCase() === trimmed);
+    if (directMatch) return directMatch;
+
+    const codeMatches = projectsCache.filter(p => (p.code || '').toLowerCase() === trimmed);
+    if (codeMatches.length === 1) {
+        return codeMatches[0];
+    }
+    if (codeMatches.length > 1) {
+        alert('У проекта несколько вариантов. Укажите вариант в формате "CODE (variant)".');
+    }
+    return null;
+}
+
 function escapeHtml(text) {
     const div = document.createElement('div');
     div.textContent = text;
@@ -444,17 +480,21 @@ async function createConfig() {
         return;
     }
 
-    const projectName = document.getElementById('create-project-input').value.trim();
+    const projectCode = document.getElementById('create-project-input').value.trim();
     let projectUUID = '';
 
-    if (projectName) {
-        const existingProject = projectsCache.find(p => p.is_active && p.name.toLowerCase() === projectName.toLowerCase());
-        if (existingProject) {
-            projectUUID = existingProject.uuid;
+    if (projectCode) {
+        const matchedProject = findProjectByInput(projectCode);
+        if (matchedProject) {
+            if (!matchedProject.is_active) {
+                alert('Проект с таким кодом находится в архиве. Восстановите его или выберите другой.');
+                return;
+            }
+            projectUUID = matchedProject.uuid;
         } else {
             pendingCreateConfigName = name;
-            pendingCreateProjectName = projectName;
-            openCreateProjectOnCreateModal(projectName);
+            pendingCreateProjectCode = projectCode;
+            openCreateProjectOnCreateModal(projectCode);
             return;
         }
     }
@@ -502,12 +542,14 @@ function openMoveProjectModal(uuid, configName, currentProjectUUID) {
     projectsCache.forEach(project => {
         if (!project.is_active) return;
         const option = document.createElement('option');
-        option.value = project.name;
+        option.value = projectDisplayKey(project);
+        option.label = project.name || '';
         options.appendChild(option);
     });
 
-    if (currentProjectUUID && projectNameByUUID[currentProjectUUID]) {
-        input.value = projectNameByUUID[currentProjectUUID];
+    if (currentProjectUUID && projectCodeByUUID[currentProjectUUID]) {
+        const variant = projectVariantByUUID[currentProjectUUID] || '';
+        input.value = variant ? (projectCodeByUUID[currentProjectUUID] + ' (' + variant + ')') : projectCodeByUUID[currentProjectUUID];
     } else {
         input.value = '';
     }
@@ -523,19 +565,23 @@ function closeMoveProjectModal() {
 
 async function confirmMoveProject() {
     const uuid = document.getElementById('move-project-uuid').value;
-    const projectName = document.getElementById('move-project-input').value.trim();
+    const projectCode = document.getElementById('move-project-input').value.trim();
 
     if (!uuid) return;
     let projectUUID = '';
 
-    if (projectName) {
-        const existingProject = projectsCache.find(p => p.is_active && p.name.toLowerCase() === projectName.toLowerCase());
-        if (existingProject) {
-            projectUUID = existingProject.uuid;
+    if (projectCode) {
+        const matchedProject = findProjectByInput(projectCode);
+        if (matchedProject) {
+            if (!matchedProject.is_active) {
+                alert('Проект с таким кодом находится в архиве. Восстановите его или выберите другой.');
+                return;
+            }
+            projectUUID = matchedProject.uuid;
         } else {
             pendingMoveConfigUUID = uuid;
-            pendingMoveProjectName = projectName;
-            openCreateProjectOnMoveModal(projectName);
+            pendingMoveProjectCode = projectCode;
+            openCreateProjectOnMoveModal(projectCode);
             return;
         }
     }
@@ -552,7 +598,9 @@ function clearCreateProjectInput() {
 }
 
 function openCreateProjectOnMoveModal(projectName) {
-    document.getElementById('create-project-on-move-name').textContent = projectName;
+    document.getElementById('create-project-on-move-code').textContent = projectName;
+    document.getElementById('create-project-on-move-name').value = projectName;
+    document.getElementById('create-project-on-move-variant').value = '';
     document.getElementById('create-project-on-move-description').textContent = 'Создать и привязать квоту?';
     document.getElementById('create-project-on-move-confirm-btn').textContent = 'Создать и привязать';
     document.getElementById('create-project-on-move-modal').classList.remove('hidden');
@@ -560,7 +608,9 @@ function openCreateProjectOnMoveModal(projectName) {
 }
 
 function openCreateProjectOnCreateModal(projectName) {
-    document.getElementById('create-project-on-move-name').textContent = projectName;
+    document.getElementById('create-project-on-move-code').textContent = projectName;
+    document.getElementById('create-project-on-move-name').value = projectName;
+    document.getElementById('create-project-on-move-variant').value = '';
     document.getElementById('create-project-on-move-description').textContent = 'Создать и использовать для новой конфигурации?';
     document.getElementById('create-project-on-move-confirm-btn').textContent = 'Создать и использовать';
     document.getElementById('create-project-on-move-modal').classList.remove('hidden');
@@ -571,22 +621,32 @@ function closeCreateProjectOnMoveModal() {
     document.getElementById('create-project-on-move-modal').classList.add('hidden');
     document.getElementById('create-project-on-move-modal').classList.remove('flex');
     pendingMoveConfigUUID = '';
-    pendingMoveProjectName = '';
+    pendingMoveProjectCode = '';
     pendingCreateConfigName = '';
-    pendingCreateProjectName = '';
+    pendingCreateProjectCode = '';
+    document.getElementById('create-project-on-move-name').value = '';
+    document.getElementById('create-project-on-move-variant').value = '';
 }
 
 async function confirmCreateProjectOnMove() {
-    if (pendingCreateConfigName && pendingCreateProjectName) {
+    const projectNameInput = document.getElementById('create-project-on-move-name');
+    const projectVariantInput = document.getElementById('create-project-on-move-variant');
+    const projectName = (projectNameInput.value || '').trim();
+    const projectVariant = (projectVariantInput.value || '').trim();
+    if (pendingCreateConfigName && pendingCreateProjectCode) {
         const configName = pendingCreateConfigName;
-        const projectName = pendingCreateProjectName;
+        const projectCode = pendingCreateProjectCode;
         try {
             const createResp = await fetch('/api/projects', {
                 method: 'POST',
                 headers: {'Content-Type': 'application/json'},
-                body: JSON.stringify({ name: projectName })
+                body: JSON.stringify({ name: projectName, code: projectCode, variant: projectVariant })
             });
             if (!createResp.ok) {
+                if (createResp.status === 409) {
+                    alert('Проект с таким кодом и вариантом уже существует');
+                    return;
+                }
                 const err = await createResp.json();
                 alert('Не удалось создать проект: ' + (err.error || 'ошибка'));
                 return;
@@ -594,14 +654,14 @@ async function confirmCreateProjectOnMove() {
 
             const newProject = await createResp.json();
             pendingCreateConfigName = '';
-            pendingCreateProjectName = '';
+            pendingCreateProjectCode = '';
             await loadProjectsForConfigUI();
             const created = await createConfigWithProject(configName, newProject.uuid);
             if (created) {
                 closeCreateProjectOnMoveModal();
             } else {
                 closeCreateProjectOnMoveModal();
-                document.getElementById('create-project-input').value = projectName;
+                document.getElementById('create-project-input').value = projectCode;
             }
         } catch (e) {
             alert('Ошибка создания проекта');
@@ -610,8 +670,8 @@ async function confirmCreateProjectOnMove() {
     }
 
     const configUUID = pendingMoveConfigUUID;
-    const projectName = pendingMoveProjectName;
-    if (!configUUID || !projectName) {
+    const projectCode = pendingMoveProjectCode;
+    if (!configUUID || !projectCode) {
         closeCreateProjectOnMoveModal();
         return;
     }
@@ -620,9 +680,13 @@ async function confirmCreateProjectOnMove() {
         const createResp = await fetch('/api/projects', {
             method: 'POST',
             headers: {'Content-Type': 'application/json'},
-            body: JSON.stringify({ name: projectName })
+            body: JSON.stringify({ name: projectName, code: projectCode, variant: projectVariant })
         });
         if (!createResp.ok) {
+            if (createResp.status === 409) {
+                alert('Проект с таким кодом и вариантом уже существует');
+                return;
+            }
             const err = await createResp.json();
             alert('Не удалось создать проект: ' + (err.error || 'ошибка'));
             return;
@@ -630,9 +694,9 @@ async function confirmCreateProjectOnMove() {
 
         const newProject = await createResp.json();
         pendingMoveConfigUUID = '';
-        pendingMoveProjectName = '';
+        pendingMoveProjectCode = '';
         await loadProjectsForConfigUI();
-        document.getElementById('move-project-input').value = projectName;
+        document.getElementById('move-project-input').value = projectCode;
         const moved = await moveConfigToProject(configUUID, newProject.uuid);
         if (moved) {
             closeCreateProjectOnMoveModal();
@@ -819,6 +883,8 @@ document.getElementById('configs-search').addEventListener('input', function(e)
 async function loadProjectsForConfigUI() {
     projectsCache = [];
     projectNameByUUID = {};
+    projectCodeByUUID = {};
+    projectVariantByUUID = {};
     try {
         // Use /api/projects/all to get all projects without pagination
         const resp = await fetch('/api/projects/all');
@@ -831,7 +897,11 @@ async function loadProjectsForConfigUI() {
         projectsCache = allProjects;
 
         allProjects.forEach(project => {
-            projectNameByUUID[project.uuid] = project.name;
+            const variant = (project.variant || '').trim();
+            const baseName = project.name || '';
+            projectNameByUUID[project.uuid] = variant ? (baseName + ' (' + variant + ')') : baseName;
+            projectCodeByUUID[project.uuid] = project.code || '';
+            projectVariantByUUID[project.uuid] = project.variant || '';
         });
 
         const createOptions = document.getElementById('create-project-options');
@@ -840,7 +910,8 @@ async function loadProjectsForConfigUI() {
             projectsCache.forEach(project => {
                 if (!project.is_active) return;
                 const option = document.createElement('option');
-                option.value = project.name;
+                option.value = projectDisplayKey(project);
+                option.label = project.name || '';
                 createOptions.appendChild(option);
             });
         }

web/templates/partnumber_books.html

@@ -0,0 +1,256 @@
+{{define "title"}}QuoteForge - Партномера{{end}}
+
+{{define "content"}}
+<div class="space-y-4">
+    <h1 class="text-2xl font-bold text-gray-900">Партномера</h1>
+
+    <!-- Summary cards -->
+    <div id="summary-cards" class="grid grid-cols-2 md:grid-cols-4 gap-4 hidden">
+        <div class="bg-white rounded-lg shadow p-4">
+            <div class="text-xs text-gray-500 mb-1">Активный лист</div>
+            <div id="card-version" class="font-mono font-semibold text-gray-800 text-sm truncate">—</div>
+            <div id="card-date" class="text-xs text-gray-400 mt-0.5">—</div>
+        </div>
+        <div class="bg-white rounded-lg shadow p-4">
+            <div class="text-xs text-gray-500 mb-1">Уникальных LOT</div>
+            <div id="card-lots" class="text-2xl font-bold text-blue-600">—</div>
+        </div>
+        <div class="bg-white rounded-lg shadow p-4">
+            <div class="text-xs text-gray-500 mb-1">Всего PN</div>
+            <div id="card-pn-total" class="text-2xl font-bold text-gray-800">—</div>
+        </div>
+        <div class="bg-white rounded-lg shadow p-4">
+            <div class="text-xs text-gray-500 mb-1">Primary PN</div>
+            <div id="card-pn-primary" class="text-2xl font-bold text-green-600">—</div>
+        </div>
+    </div>
+
+    <div id="summary-empty" class="hidden bg-yellow-50 border border-yellow-200 rounded-lg p-4 text-sm text-yellow-800">
+        Нет активного листа сопоставлений. Нажмите «Синхронизировать» для загрузки с сервера.
+    </div>
+
+    <!-- Active book items with search -->
+    <div id="active-book-section" class="hidden bg-white rounded-lg shadow overflow-hidden">
+        <div class="px-4 py-3 border-b flex items-center justify-between gap-3">
+            <span class="font-semibold text-gray-800 whitespace-nowrap">Сопоставления активного листа</span>
+            <input type="text" id="pn-search" placeholder="Поиск по PN или LOT..."
+                   class="flex-1 max-w-xs px-3 py-1.5 border rounded text-sm focus:ring-2 focus:ring-blue-400 focus:outline-none"
+                   oninput="filterItems(this.value)">
+            <span id="pn-count" class="text-xs text-gray-400 whitespace-nowrap"></span>
+        </div>
+        <div class="overflow-x-auto">
+            <table class="w-full text-sm">
+                <thead class="bg-gray-50 text-gray-600 sticky top-0">
+                    <tr>
+                        <th class="px-4 py-2 text-left">Partnumber</th>
+                        <th class="px-4 py-2 text-left">LOT</th>
+                        <th class="px-4 py-2 text-center w-24">Primary</th>
+                        <th class="px-4 py-2 text-left">Описание</th>
+                    </tr>
+                </thead>
+                <tbody id="active-items-body"></tbody>
+            </table>
+        </div>
+    </div>
+
+    <!-- All books list (collapsed by default) -->
+    <div class="bg-white rounded-lg shadow overflow-hidden">
+        <!-- Header row — always visible -->
+        <div class="px-4 py-3 flex items-center justify-between">
+            <button onclick="toggleBooksSection()" class="flex items-center gap-2 text-sm font-semibold text-gray-800 hover:text-gray-600 select-none">
+                <svg id="books-chevron" class="w-4 h-4 text-gray-400 transition-transform duration-150" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M9 5l7 7-7 7"/></svg>
+                Снимки сопоставлений (Partnumber Books)
+            </button>
+            <button onclick="syncPartnumberBooks()" class="px-4 py-2 bg-orange-500 text-white rounded hover:bg-orange-600 text-sm font-medium">
+                Синхронизировать
+            </button>
+        </div>
+        <!-- Collapsible body -->
+        <div id="books-section-body" class="hidden border-t">
+            <div id="books-list-loading" class="p-6 text-center text-gray-400 text-sm">Загрузка...</div>
+            <table id="books-table" class="w-full text-sm hidden">
+                <thead class="bg-gray-50 text-gray-600">
+                    <tr>
+                        <th class="px-4 py-2 text-left">Версия</th>
+                        <th class="px-4 py-2 text-left">Дата</th>
+                        <th class="px-4 py-2 text-right">Позиций</th>
+                        <th class="px-4 py-2 text-center">Статус</th>
+                    </tr>
+                </thead>
+                <tbody id="books-table-body"></tbody>
+            </table>
+            <div id="books-empty" class="hidden p-6 text-center text-gray-400 text-sm">
+                Нет загруженных снимков.
+            </div>
+            <!-- Pagination -->
+            <div id="books-pagination" class="hidden px-4 py-3 border-t flex items-center justify-between text-sm text-gray-600">
+                <span id="books-page-info"></span>
+                <div class="flex gap-2">
+                    <button id="books-prev" onclick="changeBooksPage(-1)" class="px-3 py-1 rounded border hover:bg-gray-50 disabled:opacity-40 disabled:cursor-not-allowed">← Назад</button>
+                    <button id="books-next" onclick="changeBooksPage(1)"  class="px-3 py-1 rounded border hover:bg-gray-50 disabled:opacity-40 disabled:cursor-not-allowed">Вперёд →</button>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+
+<script>
+let allItems = [];
+let allBooks = [];
+let booksPage = 1;
+const BOOKS_PER_PAGE = 10;
+
+function toggleBooksSection() {
+    const body = document.getElementById('books-section-body');
+    const chevron = document.getElementById('books-chevron');
+    const collapsed = body.classList.toggle('hidden');
+    chevron.style.transform = collapsed ? '' : 'rotate(90deg)';
+}
+
+async function loadBooks() {
+    let resp, data;
+    try {
+        resp = await fetch('/api/partnumber-books');
+        data = await resp.json();
+    } catch (e) {
+        document.getElementById('books-list-loading').classList.add('hidden');
+        document.getElementById('books-empty').classList.remove('hidden');
+        return;
+    }
+
+    allBooks = data.books || [];
+    document.getElementById('books-list-loading').classList.add('hidden');
+
+    if (!allBooks.length) {
+        document.getElementById('books-empty').classList.remove('hidden');
+        document.getElementById('summary-empty').classList.remove('hidden');
+        return;
+    }
+
+    booksPage = 1;
+    renderBooksPage();
+
+    const active = allBooks.find(b => b.is_active) || allBooks[0];
+    await loadActiveBookItems(active);
+}
+
+function renderBooksPage() {
+    const total = allBooks.length;
+    const totalPages = Math.ceil(total / BOOKS_PER_PAGE);
+    const start = (booksPage - 1) * BOOKS_PER_PAGE;
+    const pageBooks = allBooks.slice(start, start + BOOKS_PER_PAGE);
+
+    const tbody = document.getElementById('books-table-body');
+    tbody.innerHTML = '';
+    pageBooks.forEach(b => {
+        const tr = document.createElement('tr');
+        tr.className = 'border-b hover:bg-gray-50';
+        tr.innerHTML = `
+            <td class="px-4 py-2 font-mono text-xs">${b.version}</td>
+            <td class="px-4 py-2 text-gray-500 text-xs">${b.created_at}</td>
+            <td class="px-4 py-2 text-right text-xs">${b.item_count}</td>
+            <td class="px-4 py-2 text-center">
+                ${b.is_active
+                    ? '<span class="px-2 py-0.5 bg-green-100 text-green-700 rounded text-xs">Активный</span>'
+                    : '<span class="px-2 py-0.5 bg-gray-100 text-gray-500 rounded text-xs">Архив</span>'}
+            </td>
+        `;
+        tbody.appendChild(tr);
+    });
+    document.getElementById('books-table').classList.remove('hidden');
+
+    // Pagination controls
+    if (total > BOOKS_PER_PAGE) {
+        document.getElementById('books-pagination').classList.remove('hidden');
+        document.getElementById('books-page-info').textContent =
+            `Снимки ${start + 1}–${Math.min(start + BOOKS_PER_PAGE, total)} из ${total}`;
+        document.getElementById('books-prev').disabled = booksPage === 1;
+        document.getElementById('books-next').disabled = booksPage === totalPages;
+    } else {
+        document.getElementById('books-pagination').classList.add('hidden');
+    }
+}
+
+function changeBooksPage(delta) {
+    const totalPages = Math.ceil(allBooks.length / BOOKS_PER_PAGE);
+    booksPage = Math.max(1, Math.min(totalPages, booksPage + delta));
+    renderBooksPage();
+}
+
+async function loadActiveBookItems(book) {
+    let resp, data;
+    try {
+        resp = await fetch(`/api/partnumber-books/${book.server_id}`);
+        data = await resp.json();
+    } catch (e) {
+        return;
+    }
+    if (!resp.ok) return;
+
+    allItems = data.items || [];
+
+    const lots = new Set(allItems.map(i => i.lot_name));
+    const primaryCount = allItems.filter(i => i.is_primary_pn).length;
+
+    document.getElementById('card-version').textContent = book.version;
+    document.getElementById('card-date').textContent = book.created_at;
+    document.getElementById('card-lots').textContent = lots.size;
+    document.getElementById('card-pn-total').textContent = allItems.length;
+    document.getElementById('card-pn-primary').textContent = primaryCount;
+    document.getElementById('summary-cards').classList.remove('hidden');
+    document.getElementById('active-book-section').classList.remove('hidden');
+
+    renderItems(allItems);
+}
+
+function renderItems(items) {
+    const tbody = document.getElementById('active-items-body');
+    tbody.innerHTML = '';
+    items.forEach(item => {
+        const tr = document.createElement('tr');
+        tr.className = 'border-b hover:bg-gray-50';
+        tr.innerHTML = `
+            <td class="px-4 py-1.5 font-mono text-xs">${item.partnumber}</td>
+            <td class="px-4 py-1.5 text-xs font-medium text-blue-700">${item.lot_name}</td>
+            <td class="px-4 py-1.5 text-center text-green-600 text-xs">${item.is_primary_pn ? '✓' : ''}</td>
+            <td class="px-4 py-1.5 text-xs text-gray-500">${item.description || ''}</td>
+        `;
+        tbody.appendChild(tr);
+    });
+    document.getElementById('pn-count').textContent = `${items.length} из ${allItems.length}`;
+}
+
+function filterItems(query) {
+    const q = query.trim().toLowerCase();
+    if (!q) { renderItems(allItems); return; }
+    renderItems(allItems.filter(i =>
+        i.partnumber.toLowerCase().includes(q) || i.lot_name.toLowerCase().includes(q)
+    ));
+}
+
+async function syncPartnumberBooks() {
+    let resp, data;
+    try {
+        resp = await fetch('/api/sync/partnumber-books', {method: 'POST'});
+        data = await resp.json();
+    } catch (e) {
+        showToast('Ошибка синхронизации', 'error');
+        return;
+    }
+    if (data.success) {
+        showToast(`Синхронизировано: ${data.synced} листов`, 'success');
+        loadBooks();
+    } else if (data.blocked) {
+        showToast(`Синк заблокирован: ${data.reason_text}`, 'error');
+    } else {
+        showToast('Ошибка: ' + (data.error || 'неизвестная ошибка'), 'error');
+    }
+}
+
+document.addEventListener('DOMContentLoaded', loadBooks);
+</script>
+{{end}}
+
+{{template "base" .}}
+

web/templates/pricelist_detail.html

@@ -3,9 +3,10 @@
 {{define "content"}}
 <div class="space-y-6">
     <div class="flex items-center space-x-4">
-        <a href="/pricelists" class="text-gray-500 hover:text-gray-700">
+        <a href="/projects" class="text-gray-500 hover:text-gray-700" title="Все проекты">
             <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"></path>
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 9.75L12 3l9 6.75v9A2.25 2.25 0 0118.75 21h-13.5A2.25 2.25 0 013 18.75v-9z"></path>
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 21v-6h6v6"></path>
             </svg>
         </a>
         <h1 id="page-title" class="text-2xl font-bold text-gray-900">Загрузка...</h1>

web/templates/projects.html

@@ -20,7 +20,7 @@
     </div>
 
     <div class="max-w-md">
-        <input id="projects-search" type="text" placeholder="Поиск проекта по названию"
+        <input id="projects-search" type="text" placeholder="Поиск проекта по названию или коду"
                class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
     </div>
 
@@ -31,11 +31,21 @@
     <div class="bg-white rounded-lg shadow-xl w-full max-w-md mx-4 p-6">
         <h2 class="text-xl font-semibold mb-4">Новый проект</h2>
         <div class="space-y-4">
+            <div>
+                <label for="create-project-name" class="block text-sm font-medium text-gray-700 mb-1">Название проекта</label>
+                <input id="create-project-name" type="text" placeholder="Например: Инфраструктура для OPS-123"
+                       class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
+            </div>
             <div>
                 <label for="create-project-code" class="block text-sm font-medium text-gray-700 mb-1">Код проекта</label>
                 <input id="create-project-code" type="text" placeholder="Например: OPS-123"
                        class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
             </div>
+            <div>
+                <label for="create-project-variant" class="block text-sm font-medium text-gray-700 mb-1">Вариант (необязательно)</label>
+                <input id="create-project-variant" type="text" placeholder="Например: Lenovo"
+                       class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
+            </div>
             <div>
                 <label for="create-project-tracker-url" class="block text-sm font-medium text-gray-700 mb-1">Ссылка на трекер</label>
                 <input id="create-project-tracker-url" type="url" placeholder="https://tracker.yandex.ru/OPS-123"
@@ -59,6 +69,8 @@ let sortField = 'created_at';
 let sortDir = 'desc';
 let createProjectTrackerManuallyEdited = false;
 let createProjectLastAutoTrackerURL = '';
+let variantsByCode = {};
+let variantsLoaded = false;
 
 const trackerBaseURL = 'https://tracker.yandex.ru/';
 
@@ -85,6 +97,89 @@ function formatDateTime(value) {
     });
 }
 
+function formatDateParts(value) {
+    if (!value) return null;
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) return null;
+    return {
+        date: date.toLocaleDateString('ru-RU', {
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit'
+        }),
+        time: date.toLocaleTimeString('ru-RU', {
+            hour: '2-digit',
+            minute: '2-digit'
+        })
+    };
+}
+
+function renderAuditCell(value, user) {
+    const parts = formatDateParts(value);
+    const safeUser = escapeHtml((user || '—').trim() || '—');
+    if (!parts) {
+        return '<div class="leading-tight">' +
+            '<div class="text-gray-400">—</div>' +
+            '<div class="text-gray-400">—</div>' +
+            '<div class="text-gray-500">@ ' + safeUser + '</div>' +
+        '</div>';
+    }
+    return '<div class="leading-tight whitespace-nowrap">' +
+        '<div>' + escapeHtml(parts.date) + '</div>' +
+        '<div class="text-gray-500">' + escapeHtml(parts.time) + '</div>' +
+        '<div class="text-gray-600">@ ' + safeUser + '</div>' +
+    '</div>';
+}
+
+function normalizeVariant(variant) {
+    const trimmed = (variant || '').trim();
+    return trimmed === '' ? 'main' : trimmed;
+}
+
+function renderVariantChips(code, fallbackVariant, fallbackUUID) {
+    const variants = variantsByCode[code || ''] || [];
+    if (!variants.length) {
+        const single = normalizeVariant(fallbackVariant);
+        const href = fallbackUUID ? ('/projects/' + fallbackUUID) : '/projects';
+        return '<a href="' + href + '" class="inline-flex items-center px-2 py-0.5 text-xs rounded-full bg-gray-100 text-gray-600 hover:bg-gray-200 hover:text-gray-900">' + escapeHtml(single) + '</a>';
+    }
+    return variants.map(v => {
+        const href = v.uuid ? ('/projects/' + v.uuid) : '/projects';
+        return '<a href="' + href + '" class="inline-flex items-center px-2 py-0.5 text-xs rounded-full bg-gray-100 text-gray-700 hover:bg-gray-200 hover:text-gray-900">' + escapeHtml(v.label) + '</a>';
+    }).join(' ');
+}
+
+async function loadVariantsIndex() {
+    if (variantsLoaded) return;
+    try {
+        const resp = await fetch('/api/projects/all');
+        if (!resp.ok) return;
+        const data = await resp.json();
+        const allProjects = Array.isArray(data) ? data : (data.projects || []);
+        variantsByCode = {};
+        allProjects.forEach(p => {
+            const code = (p.code || '').trim();
+            const variant = normalizeVariant(p.variant);
+            if (!variantsByCode[code]) {
+                variantsByCode[code] = [];
+            }
+            if (!variantsByCode[code].some(v => v.label === variant)) {
+                variantsByCode[code].push({label: variant, uuid: p.uuid});
+            }
+        });
+        Object.keys(variantsByCode).forEach(code => {
+            variantsByCode[code].sort((a, b) => {
+                if (a.label === 'main') return -1;
+                if (b.label === 'main') return 1;
+                return a.label.localeCompare(b.label);
+            });
+        });
+        variantsLoaded = true;
+    } catch (e) {
+        // ignore
+    }
+}
+
 function toggleSort(field) {
     if (sortField === field) {
         sortDir = sortDir === 'asc' ? 'desc' : 'asc';
@@ -132,39 +227,57 @@ async function loadProjects() {
         }
         const data = await resp.json();
         rows = data.projects || [];
+        if (Array.isArray(rows) && rows.length) {
+            const byCode = {};
+            rows.forEach(p => {
+                const codeKey = (p.code || '').trim();
+                if (!codeKey) {
+                    const fallbackKey = p.uuid || Math.random().toString(36);
+                    byCode[fallbackKey] = p;
+                    return;
+                }
+                const variant = (p.variant || '').trim();
+                if (!byCode[codeKey]) {
+                    byCode[codeKey] = p;
+                    return;
+                }
+                const current = byCode[codeKey];
+                const currentVariant = (current.variant || '').trim();
+                if (currentVariant !== '' && variant === '') {
+                    byCode[codeKey] = p;
+                }
+            });
+            rows = Object.values(byCode);
+        }
         total = data.total || 0;
         totalPages = data.total_pages || 0;
         page = data.page || currentPage;
         currentPage = page;
+        await loadVariantsIndex();
     } catch (e) {
         root.innerHTML = '<div class="text-red-600">Ошибка загрузки проектов: ' + escapeHtml(String(e.message || e)) + '</div>';
         return;
     }
 
-    let html = '<div class="overflow-x-auto"><table class="w-full">';
+    let html = '<div class="overflow-x-auto"><table class="w-full table-fixed min-w-[980px]">';
     html += '<thead class="bg-gray-50">';
     html += '<tr>';
+    html += '<th class="w-28 px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Код</th>';
     html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">';
-    html += '<button type="button" onclick="toggleSort(\'name\')" class="inline-flex items-center gap-1 hover:text-gray-700">Название проекта';
+    html += '<button type="button" onclick="toggleSort(\'name\')" class="inline-flex items-center gap-1 hover:text-gray-700">Название';
     if (sortField === 'name') {
         html += sortDir === 'asc' ? ' <span>↑</span>' : ' <span>↓</span>';
     }
     html += '</button></th>';
-    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Автор</th>';
-    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">';
-    html += '<button type="button" onclick="toggleSort(\'created_at\')" class="inline-flex items-center gap-1 hover:text-gray-700">Создан';
-    if (sortField === 'created_at') {
-        html += sortDir === 'asc' ? ' <span>↑</span>' : ' <span>↓</span>';
-    }
-    html += '</button></th>';
-    html += '<th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Кол-во квот</th>';
-    html += '<th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Сумма</th>';
-    html += '<th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Действия</th>';
+    html += '<th class="w-44 px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Создан</th>';
+    html += '<th class="w-44 px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Изменен</th>';
+    html += '<th class="w-36 px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Варианты</th>';
+    html += '<th class="w-36 px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Действия</th>';
     html += '</tr>';
     html += '<tr>';
     html += '<th class="px-4 py-2"></th>';
-    html += '<th class="px-4 py-2"><input id="projects-author-filter" type="text" value="' + escapeHtml(authorSearch) + '" placeholder="Фильтр автора" class="w-full px-2 py-1 border rounded text-xs focus:ring-1 focus:ring-blue-500 focus:border-blue-500"></th>';
     html += '<th class="px-4 py-2"></th>';
+    html += '<th class="px-4 py-2"><input id="projects-author-filter" type="text" value="' + escapeHtml(authorSearch) + '" placeholder="Фильтр автора" class="w-full px-2 py-1 border rounded text-xs focus:ring-1 focus:ring-blue-500 focus:border-blue-500"></th>';
     html += '<th class="px-4 py-2"></th>';
     html += '<th class="px-4 py-2"></th>';
     html += '<th class="px-4 py-2"></th>';
@@ -175,21 +288,26 @@ async function loadProjects() {
         html += '<tr><td colspan="6" class="px-4 py-6 text-sm text-gray-500 text-center">Проектов нет</td></tr>';
     }
 
-    rows.forEach(p => {
-        html += '<tr class="hover:bg-gray-50">';
-        html += '<td class="px-4 py-3 text-sm font-medium"><a class="text-blue-600 hover:underline" href="/projects/' + p.uuid + '">' + escapeHtml(p.name) + '</a></td>';
-        html += '<td class="px-4 py-3 text-sm text-gray-600">' + escapeHtml(p.owner_username || '—') + '</td>';
-        html += '<td class="px-4 py-3 text-sm text-gray-600">' + escapeHtml(formatDateTime(p.created_at)) + '</td>';
-        html += '<td class="px-4 py-3 text-sm text-right text-gray-700">' + (p.config_count || 0) + '</td>';
-        html += '<td class="px-4 py-3 text-sm text-right text-gray-700">' + formatMoney(p.total) + '</td>';
+        rows.forEach(p => {
+            html += '<tr class="hover:bg-gray-50">';
+        const displayName = p.name || '';
+        const createdBy = p.owner_username || '—';
+        const updatedBy = '—';
+        const variantChips = renderVariantChips(p.code, p.variant, p.uuid);
+        html += '<td class="px-4 py-3 text-sm font-medium align-top"><a class="inline-block max-w-full text-blue-600 hover:underline whitespace-nowrap" href="/projects/' + p.uuid + '">' + escapeHtml(p.code || '—') + '</a></td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-700 align-top"><div class="truncate" title="' + escapeHtml(displayName) + '">' + escapeHtml(displayName || '—') + '</div></td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-600 align-top">' + renderAuditCell(p.created_at, createdBy) + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-600 align-top">' + renderAuditCell(p.updated_at, updatedBy) + '</td>';
+        html += '<td class="px-4 py-3 text-sm align-top"><div class="flex flex-wrap gap-1">' + variantChips + '</div></td>';
         html += '<td class="px-4 py-3 text-sm text-right"><div class="inline-flex items-center gap-2">';
 
         if (p.is_active) {
-            html += '<button onclick="copyProject(\'' + p.uuid + '\', \'' + escapeHtml(p.name).replace(/'/g, "\\'") + '\')" class="text-green-700 hover:text-green-900" title="Копировать">';
+            const safeName = escapeHtml(displayName).replace(/'/g, "\\'");
+            html += '<button onclick="copyProject(' + JSON.stringify(p.uuid) + ', ' + JSON.stringify(displayName) + ')" class="text-green-700 hover:text-green-900" title="Копировать">';
             html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"></path></svg>';
             html += '</button>';
 
-            html += '<button onclick="renameProject(\'' + p.uuid + '\', \'' + escapeHtml(p.name).replace(/'/g, "\\'") + '\')" class="text-blue-700 hover:text-blue-900" title="Переименовать">';
+            html += '<button onclick="renameProject(' + JSON.stringify(p.uuid) + ', ' + JSON.stringify(displayName) + ')" class="text-blue-700 hover:text-blue-900" title="Переименовать">';
             html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"></path></svg>';
             html += '</button>';
 
@@ -251,15 +369,19 @@ function buildTrackerURLFromProjectCode(projectCode) {
 }
 
 function openCreateProjectModal() {
+    const nameInput = document.getElementById('create-project-name');
     const codeInput = document.getElementById('create-project-code');
+    const variantInput = document.getElementById('create-project-variant');
     const trackerInput = document.getElementById('create-project-tracker-url');
+    nameInput.value = '';
     codeInput.value = '';
+    variantInput.value = '';
     trackerInput.value = '';
     createProjectTrackerManuallyEdited = false;
     createProjectLastAutoTrackerURL = '';
     document.getElementById('create-project-modal').classList.remove('hidden');
     document.getElementById('create-project-modal').classList.add('flex');
-    codeInput.focus();
+    nameInput.focus();
 }
 
 function closeCreateProjectModal() {
@@ -278,10 +400,14 @@ function updateCreateProjectTrackerURL() {
 }
 
 async function createProject() {
+    const nameInput = document.getElementById('create-project-name');
     const codeInput = document.getElementById('create-project-code');
+    const variantInput = document.getElementById('create-project-variant');
     const trackerInput = document.getElementById('create-project-tracker-url');
-    const name = (codeInput.value || '').trim();
-    if (!name) {
+    const name = (nameInput.value || '').trim();
+    const code = (codeInput.value || '').trim();
+    const variant = (variantInput.value || '').trim();
+    if (!code) {
         alert('Введите код проекта');
         return;
     }
@@ -290,10 +416,16 @@ async function createProject() {
         headers: {'Content-Type': 'application/json'},
         body: JSON.stringify({
             name: name,
+            code: code,
+            variant: variant,
             tracker_url: (trackerInput.value || '').trim()
         })
     });
     if (!resp.ok) {
+        if (resp.status === 409) {
+            alert('Проект с таким кодом и вариантом уже существует');
+            return;
+        }
         alert('Не удалось создать проект');
         return;
     }
@@ -310,6 +442,10 @@ async function renameProject(projectUUID, currentName) {
         body: JSON.stringify({name: name.trim()})
     });
     if (!resp.ok) {
+        if (resp.status === 409) {
+            alert('Проект с таким названием уже существует');
+            return;
+        }
         alert('Не удалось переименовать проект');
         return;
     }
@@ -353,13 +489,20 @@ async function addConfigToProject(projectUUID) {
 async function copyProject(projectUUID, projectName) {
     const newName = prompt('Название копии проекта', projectName + ' (копия)');
     if (!newName || !newName.trim()) return;
+    const newCode = prompt('Код проекта', '');
+    if (!newCode || !newCode.trim()) return;
+    const newVariant = prompt('Вариант (необязательно)', '');
 
     const createResp = await fetch('/api/projects', {
         method: 'POST',
         headers: {'Content-Type': 'application/json'},
-        body: JSON.stringify({name: newName.trim()})
+        body: JSON.stringify({name: newName.trim(), code: newCode.trim(), variant: (newVariant || '').trim()})
     });
     if (!createResp.ok) {
+        if (createResp.status === 409) {
+            alert('Проект с таким кодом и вариантом уже существует');
+            return;
+        }
         alert('Не удалось создать копию проекта');
         return;
     }
@@ -398,6 +541,13 @@ document.addEventListener('DOMContentLoaded', function() {
         updateCreateProjectTrackerURL();
     });
 
+    document.getElementById('create-project-name').addEventListener('keydown', function(e) {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            createProject();
+        }
+    });
+
     document.getElementById('create-project-tracker-url').addEventListener('input', function(e) {
         createProjectTrackerManuallyEdited = (e.target.value || '').trim() !== createProjectLastAutoTrackerURL;
     });