Store config in user state and clean old release notes

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

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

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

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

.gitignore

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

CLAUDE.md

@@ -134,9 +134,22 @@ Go 1.22+ | Gin | GORM | MariaDB 11 | SQLite (glebarez/sqlite) | htmx + Tailwind
 
 ## Commands
 ```bash
-go run ./cmd/server          # Dev server
-go run ./cmd/cron -job=X     # cleanup-pricelists | update-prices | update-popularity
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
+# Development
+go run ./cmd/qfs                # Dev server
+make run                        # Dev server (via Makefile)
+
+# Production build
+make build-release              # Optimized build with version (recommended)
+VERSION=$(git describe --tags --always --dirty)
+CGO_ENABLED=0 go build -ldflags="-s -w -X main.Version=$VERSION" -o bin/qfs ./cmd/qfs
+
+# Cron jobs
+go run ./cmd/cron -job=cleanup-pricelists  # Remove old unused pricelists
+go run ./cmd/cron -job=update-prices       # Recalculate all prices
+go run ./cmd/cron -job=update-popularity   # Update popularity scores
+
+# Check version
+./bin/qfs -version
 ```
 
 ## Code Style

LOCAL_FIRST_INTEGRATION.md

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

MIGRATION_PRICE_REFRESH.md

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

Makefile

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

README.md

@@ -82,7 +82,7 @@ auth:
 ### 3. Миграции базы данных
 
 ```bash
-go run ./cmd/server -migrate
+go run ./cmd/qfs -migrate
 ```
 
 ### 4. Импорт метаданных компонентов
@@ -95,15 +95,47 @@ go run ./cmd/importer
 
 ```bash
 # Development
-go run ./cmd/server
+go run ./cmd/qfs
 
-# Production
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
-./bin/quoteforge
+# Production (with Makefile - recommended)
+make build-release    # Builds with version info
+./bin/qfs -version    # Check version
+
+# Production (manual)
+VERSION=$(git describe --tags --always --dirty)
+CGO_ENABLED=0 go build -ldflags="-s -w -X main.Version=$VERSION" -o bin/qfs ./cmd/qfs
+./bin/qfs -version
+```
+
+**Makefile команды:**
+```bash
+make build-release   # Оптимизированная сборка с версией
+make build-all       # Сборка для всех платформ (Linux, macOS, Windows)
+make build-windows   # Только для Windows
+make run             # Запуск dev сервера
+make test            # Запуск тестов
+make clean           # Очистка bin/
+make help            # Показать все команды
 ```
 
 Приложение будет доступно по адресу: http://localhost:8080
 
+### Локальная SQLite база (state)
+
+Локальная база приложения хранится в профиле пользователя и не зависит от расположения бинарника.
+Имя файла: `qfs.db`.
+
+- macOS: `~/Library/Application Support/QuoteForge/qfs.db`
+- Linux: `$XDG_STATE_HOME/quoteforge/qfs.db` (или `~/.local/state/quoteforge/qfs.db`)
+- Windows: `%LOCALAPPDATA%\\QuoteForge\\qfs.db`
+
+Можно переопределить путь через `-localdb` или переменную окружения `QFS_DB_PATH`.
+
+### Локальный config.yaml
+
+По умолчанию `qfs` ищет `config.yaml` в той же user-state папке, где лежит `qfs.db` (а не рядом с бинарником).
+Можно переопределить путь через `-config` или `QFS_CONFIG_PATH`.
+
 ## Docker
 
 ```bash
@@ -209,13 +241,13 @@ go run ./cmd/cron -job=update-popularity
 
 ```bash
 # Запуск в режиме разработки (hot reload)
-go run ./cmd/server
+go run ./cmd/qfs
 
 # Запуск тестов
 go test ./...
 
 # Сборка для Linux
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
+CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/qfs ./cmd/qfs
 ```
 
 ## Переменные окружения
@@ -229,6 +261,9 @@ CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
 | `QF_DB_PASSWORD` | Пароль БД | — |
 | `QF_JWT_SECRET` | Секрет для JWT | — |
 | `QF_SERVER_PORT` | Порт сервера | 8080 |
+| `QFS_DB_PATH` | Полный путь к локальной SQLite БД | OS-specific user state dir |
+| `QFS_STATE_DIR` | Каталог state (если `QFS_DB_PATH` не задан) | OS-specific user state dir |
+| `QFS_CONFIG_PATH` | Полный путь к `config.yaml` | OS-specific user state dir |
 
 ## Интеграция с существующей БД
 

assets_embed.go

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

cmd/migrate/main.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"time"
 
+	"git.mchus.pro/mchus/quoteforge/internal/appstate"
 	"git.mchus.pro/mchus/quoteforge/internal/config"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
@@ -16,7 +17,11 @@ import (
 
 func main() {
 	configPath := flag.String("config", "config.yaml", "path to config file")
-	localDBPath := flag.String("localdb", "./data/settings.db", "path to local SQLite database")
+	defaultLocalDBPath, err := appstate.ResolveDBPath("")
+	if err != nil {
+		log.Fatalf("Failed to resolve default local SQLite path: %v", err)
+	}
+	localDBPath := flag.String("localdb", defaultLocalDBPath, "path to local SQLite database (default: user state dir or QFS_DB_PATH)")
 	dryRun := flag.Bool("dry-run", false, "show what would be migrated without actually doing it")
 	flag.Parse()
 

cmd/qfs/main.go

@@ -2,17 +2,23 @@ package main
 
 import (
 	"context"
+	"errors"
 	"flag"
 	"fmt"
+	"io/fs"
 	"log/slog"
 	"net/http"
 	"os"
+	"os/exec"
 	"os/signal"
+	"path/filepath"
+	"runtime"
 	"strconv"
 	"syscall"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	qfassets "git.mchus.pro/mchus/quoteforge"
+	"git.mchus.pro/mchus/quoteforge/internal/appstate"
 	"git.mchus.pro/mchus/quoteforge/internal/config"
 	"git.mchus.pro/mchus/quoteforge/internal/db"
 	"git.mchus.pro/mchus/quoteforge/internal/handlers"
@@ -25,22 +31,69 @@ import (
 	"git.mchus.pro/mchus/quoteforge/internal/services/pricelist"
 	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
 	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
+	"github.com/gin-gonic/gin"
 	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 )
 
-const (
-	localDBPath = "./data/settings.db"
-)
+// Version is set via ldflags during build
+var Version = "dev"
 
 func main() {
-	configPath := flag.String("config", "config.yaml", "path to config file (optional, for server settings)")
+	configPath := flag.String("config", "", "path to config file (default: user state dir or QFS_CONFIG_PATH)")
+	localDBPath := flag.String("localdb", "", "path to local SQLite database (default: user state dir or QFS_DB_PATH)")
 	migrate := flag.Bool("migrate", false, "run database migrations")
+	version := flag.Bool("version", false, "show version information")
 	flag.Parse()
 
+	// Show version if requested
+	if *version {
+		fmt.Printf("qfs version %s\n", Version)
+		os.Exit(0)
+	}
+
+	exePath, _ := os.Executable()
+	slog.Info("starting qfs", "version", Version, "executable", exePath)
+
+	resolvedConfigPath, err := appstate.ResolveConfigPath(*configPath)
+	if err != nil {
+		slog.Error("failed to resolve config path", "error", err)
+		os.Exit(1)
+	}
+
+	resolvedLocalDBPath, err := appstate.ResolveDBPath(*localDBPath)
+	if err != nil {
+		slog.Error("failed to resolve local database path", "error", err)
+		os.Exit(1)
+	}
+
+	// Migrate legacy project-local config path to the user state directory when using defaults.
+	if *configPath == "" && os.Getenv("QFS_CONFIG_PATH") == "" {
+		migratedFrom, migrateErr := appstate.MigrateLegacyFile(resolvedConfigPath, []string{"config.yaml"})
+		if migrateErr != nil {
+			slog.Warn("failed to migrate legacy config file", "error", migrateErr)
+		} else if migratedFrom != "" {
+			slog.Info("migrated legacy config file", "from", migratedFrom, "to", resolvedConfigPath)
+		}
+	}
+
+	// Migrate legacy project-local DB path to the user state directory when using defaults.
+	if *localDBPath == "" && os.Getenv("QFS_DB_PATH") == "" {
+		legacyPaths := []string{
+			filepath.Join("data", "settings.db"),
+			filepath.Join("data", "qfs.db"),
+		}
+		migratedFrom, migrateErr := appstate.MigrateLegacyDB(resolvedLocalDBPath, legacyPaths)
+		if migrateErr != nil {
+			slog.Warn("failed to migrate legacy local database", "error", migrateErr)
+		} else if migratedFrom != "" {
+			slog.Info("migrated legacy local database", "from", migratedFrom, "to", resolvedLocalDBPath)
+		}
+	}
+
 	// Initialize local SQLite database (always used)
-	local, err := localdb.New(localDBPath)
+	local, err := localdb.New(resolvedLocalDBPath)
 	if err != nil {
 		slog.Error("failed to initialize local database", "error", err)
 		os.Exit(1)
@@ -54,13 +107,19 @@ func main() {
 	}
 
 	// Load config for server settings (optional)
-	cfg, err := config.Load(*configPath)
+	cfg, err := config.Load(resolvedConfigPath)
 	if err != nil {
-		// Use defaults if config file doesn't exist
-		slog.Info("config file not found, using defaults", "path", *configPath)
-		cfg = &config.Config{}
+		if errors.Is(err, fs.ErrNotExist) {
+			// Use defaults if config file doesn't exist
+			slog.Info("config file not found, using defaults", "path", resolvedConfigPath)
+			cfg = &config.Config{}
+		} else {
+			slog.Error("failed to load config", "path", resolvedConfigPath, "error", err)
+			os.Exit(1)
+		}
 	}
 	setConfigDefaults(cfg)
+	slog.Info("resolved runtime files", "config_path", resolvedConfigPath, "localdb_path", resolvedLocalDBPath)
 
 	setupLogger(cfg.Logging)
 
@@ -86,6 +145,7 @@ func main() {
 	}
 
 	slog.Info("starting QuoteForge server",
+		"version", Version,
 		"host", cfg.Server.Host,
 		"port", cfg.Server.Port,
 		"db_user", dbUser,
@@ -139,6 +199,18 @@ func main() {
 		}
 	}()
 
+	// Automatically open browser after server starts (with a small delay)
+	go func() {
+		time.Sleep(1 * time.Second)
+		// Always use localhost for browser, even if server binds to 0.0.0.0
+		browserURL := fmt.Sprintf("http://127.0.0.1:%d", cfg.Server.Port)
+		slog.Info("Opening browser to", "url", browserURL)
+		err := openBrowser(browserURL)
+		if err != nil {
+			slog.Warn("Failed to open browser", "error", err)
+		}
+	}()
+
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 	<-quit
@@ -162,7 +234,7 @@ func main() {
 
 func setConfigDefaults(cfg *config.Config) {
 	if cfg.Server.Host == "" {
-		cfg.Server.Host = "0.0.0.0"
+		cfg.Server.Host = "127.0.0.1"
 	}
 	if cfg.Server.Port == 0 {
 		cfg.Server.Port = 8080
@@ -201,7 +273,8 @@ func runSetupMode(local *localdb.LocalDB) {
 	restartSig := make(chan struct{}, 1)
 
 	// In setup mode, we don't have a connection manager yet (will restart after setup)
-	setupHandler, err := handlers.NewSetupHandler(local, nil, "web/templates", restartSig)
+	templatesPath := filepath.Join("web", "templates")
+	setupHandler, err := handlers.NewSetupHandler(local, nil, templatesPath, restartSig)
 	if err != nil {
 		slog.Error("failed to create setup handler", "error", err)
 		os.Exit(1)
@@ -211,7 +284,12 @@ func runSetupMode(local *localdb.LocalDB) {
 	router := gin.New()
 	router.Use(gin.Recovery())
 
-	router.Static("/static", "web/static")
+	staticPath := filepath.Join("web", "static")
+	if stat, err := os.Stat(staticPath); err == nil && stat.IsDir() {
+		router.Static("/static", staticPath)
+	} else if staticFS, err := qfassets.StaticFS(); err == nil {
+		router.StaticFS("/static", http.FS(staticFS))
+	}
 
 	// Setup routes only
 	router.GET("/", func(c *gin.Context) {
@@ -230,9 +308,8 @@ func runSetupMode(local *localdb.LocalDB) {
 		})
 	})
 
-	addr := ":8080"
-	slog.Info("starting setup mode server", "address", addr)
-	slog.Info("open http://localhost:8080/setup to configure database connection")
+	addr := "127.0.0.1:8080"
+	slog.Info("starting setup mode server", "address", addr, "version", Version)
 
 	srv := &http.Server{
 		Addr:    addr,
@@ -246,6 +323,17 @@ func runSetupMode(local *localdb.LocalDB) {
 		}
 	}()
 
+	// Open browser to setup page
+	go func() {
+		time.Sleep(1 * time.Second)
+		browserURL := "http://127.0.0.1:8080/setup"
+		slog.Info("Opening browser to setup page", "url", browserURL)
+		err := openBrowser(browserURL)
+		if err != nil {
+			slog.Warn("Failed to open browser", "error", err)
+		}
+	}()
+
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 
@@ -373,25 +461,28 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 	// Local-first configuration service (replaces old ConfigurationService)
 	configService := services.NewLocalConfigurationService(local, syncService, quoteService, isOnline)
 
+	// Use filepath.Join for cross-platform path compatibility
+	templatesPath := filepath.Join("web", "templates")
+
 	// Handlers
 	componentHandler := handlers.NewComponentHandler(componentService, local)
 	quoteHandler := handlers.NewQuoteHandler(quoteService)
 	exportHandler := handlers.NewExportHandler(exportService, configService, componentService)
 	pricingHandler := handlers.NewPricingHandler(mariaDB, pricingService, alertService, componentRepo, priceRepo, statsRepo)
 	pricelistHandler := handlers.NewPricelistHandler(pricelistService, local)
-	syncHandler, err := handlers.NewSyncHandler(local, syncService, connMgr, "web/templates")
+	syncHandler, err := handlers.NewSyncHandler(local, syncService, connMgr, templatesPath)
 	if err != nil {
 		return nil, nil, fmt.Errorf("creating sync handler: %w", err)
 	}
 
 	// Setup handler (for reconfiguration) - no restart signal in normal mode
-	setupHandler, err := handlers.NewSetupHandler(local, connMgr, "web/templates", nil)
+	setupHandler, err := handlers.NewSetupHandler(local, connMgr, templatesPath, nil)
 	if err != nil {
 		return nil, nil, fmt.Errorf("creating setup handler: %w", err)
 	}
 
 	// Web handler (templates)
-	webHandler, err := handlers.NewWebHandler("web/templates", componentService)
+	webHandler, err := handlers.NewWebHandler(templatesPath, componentService)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -403,8 +494,13 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 	router.Use(middleware.CORS())
 	router.Use(middleware.OfflineDetector(connMgr, local))
 
-	// Static files
-	router.Static("/static", "web/static")
+	// Static files (use filepath.Join for Windows compatibility)
+	staticPath := filepath.Join("web", "static")
+	if stat, err := os.Stat(staticPath); err == nil && stat.IsDir() {
+		router.Static("/static", staticPath)
+	} else if staticFS, err := qfassets.StaticFS(); err == nil {
+		router.StaticFS("/static", http.FS(staticFS))
+	}
 
 	// Health check
 	router.GET("/health", func(c *gin.Context) {
@@ -414,6 +510,18 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 		})
 	})
 
+	// Restart endpoint (for development purposes)
+	router.POST("/api/restart", func(c *gin.Context) {
+		// This will cause the server to restart by exiting
+		// The restartProcess function will be called to restart the process
+		slog.Info("Restart requested via API")
+		go func() {
+			time.Sleep(100 * time.Millisecond)
+			restartProcess()
+		}()
+		c.JSON(http.StatusOK, gin.H{"message": "restarting..."})
+	})
+
 	// DB status endpoint
 	router.GET("/api/db-status", func(c *gin.Context) {
 		var lotCount, lotLogCount, metadataCount int64
@@ -698,6 +806,25 @@ func restartProcess() {
 	}
 }
 
+func openBrowser(url string) error {
+	var cmd string
+	var args []string
+
+	switch runtime.GOOS {
+	case "windows":
+		cmd = "cmd"
+		args = []string{"/c", "start", url}
+	case "darwin":
+		cmd = "open"
+		args = []string{url}
+	default: // "linux", "freebsd", "openbsd", "netbsd"
+		cmd = "xdg-open"
+		args = []string{url}
+	}
+
+	return exec.Command(cmd, args...).Start()
+}
+
 func requestLogger() gin.HandlerFunc {
 	return func(c *gin.Context) {
 		start := time.Now()

config.example.yaml

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

internal/appstate/path.go

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

internal/config/config.go

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

internal/handlers/component.go

@@ -4,10 +4,10 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"github.com/gin-gonic/gin"
 )
 
 type ComponentHandler struct {
@@ -40,7 +40,13 @@ func (h *ComponentHandler) List(c *gin.Context) {
 	}
 
 	// If offline mode (empty result), fallback to local components
-	if result.Total == 0 && h.localDB != nil {
+	isOffline := false
+	if v, ok := c.Get("is_offline"); ok {
+		if b, ok := v.(bool); ok {
+			isOffline = b
+		}
+	}
+	if isOffline && result.Total == 0 && h.localDB != nil {
 		localFilter := localdb.ComponentFilter{
 			Category: filter.Category,
 			Search:   filter.Search,

internal/handlers/setup.go

@@ -5,13 +5,15 @@ import (
 	"html/template"
 	"log/slog"
 	"net/http"
+	"os"
 	"path/filepath"
 	"strconv"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	qfassets "git.mchus.pro/mchus/quoteforge"
 	"git.mchus.pro/mchus/quoteforge/internal/db"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"github.com/gin-gonic/gin"
 	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
@@ -34,7 +36,13 @@ func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, te
 
 	// Load setup template (standalone, no base needed)
 	setupPath := filepath.Join(templatesPath, "setup.html")
-	tmpl, err := template.New("").Funcs(funcMap).ParseFiles(setupPath)
+	var tmpl *template.Template
+	var err error
+	if stat, statErr := os.Stat(templatesPath); statErr == nil && stat.IsDir() {
+		tmpl, err = template.New("").Funcs(funcMap).ParseFiles(setupPath)
+	} else {
+		tmpl, err = template.New("").Funcs(funcMap).ParseFS(qfassets.TemplatesFS, "web/templates/setup.html")
+	}
 	if err != nil {
 		return nil, fmt.Errorf("parsing setup template: %w", err)
 	}
@@ -195,10 +203,11 @@ func (h *SetupHandler) SaveConnection(c *gin.Context) {
 	}
 
 	// Always restart to properly initialize all services with the new connection
+	restartRequired := h.restartSig == nil
 	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "Settings saved. Please restart the application to apply changes.",
-		"restart_required": true,
+		"success":          true,
+		"message":          "Settings saved.",
+		"restart_required": restartRequired,
 	})
 
 	// Signal restart after response is sent (if restart signal is configured)

internal/handlers/sync.go

@@ -4,13 +4,15 @@ import (
 	"html/template"
 	"log/slog"
 	"net/http"
+	"os"
 	"path/filepath"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	qfassets "git.mchus.pro/mchus/quoteforge"
 	"git.mchus.pro/mchus/quoteforge/internal/db"
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
+	"github.com/gin-gonic/gin"
 )
 
 // SyncHandler handles sync API endpoints
@@ -25,7 +27,13 @@ type SyncHandler struct {
 func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, templatesPath string) (*SyncHandler, error) {
 	// Load sync_status partial template
 	partialPath := filepath.Join(templatesPath, "partials", "sync_status.html")
-	tmpl, err := template.ParseFiles(partialPath)
+	var tmpl *template.Template
+	var err error
+	if stat, statErr := os.Stat(templatesPath); statErr == nil && stat.IsDir() {
+		tmpl, err = template.ParseFiles(partialPath)
+	} else {
+		tmpl, err = template.ParseFS(qfassets.TemplatesFS, "web/templates/partials/sync_status.html")
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -40,14 +48,14 @@ func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr
 
 // SyncStatusResponse represents the sync status
 type SyncStatusResponse struct {
-	LastComponentSync  *time.Time `json:"last_component_sync"`
-	LastPricelistSync  *time.Time `json:"last_pricelist_sync"`
-	IsOnline           bool       `json:"is_online"`
-	ComponentsCount    int64      `json:"components_count"`
-	PricelistsCount    int64      `json:"pricelists_count"`
-	ServerPricelists   int        `json:"server_pricelists"`
-	NeedComponentSync  bool       `json:"need_component_sync"`
-	NeedPricelistSync  bool       `json:"need_pricelist_sync"`
+	LastComponentSync *time.Time `json:"last_component_sync"`
+	LastPricelistSync *time.Time `json:"last_pricelist_sync"`
+	IsOnline          bool       `json:"is_online"`
+	ComponentsCount   int64      `json:"components_count"`
+	PricelistsCount   int64      `json:"pricelists_count"`
+	ServerPricelists  int        `json:"server_pricelists"`
+	NeedComponentSync bool       `json:"need_component_sync"`
+	NeedPricelistSync bool       `json:"need_pricelist_sync"`
 }
 
 // GetStatus returns current sync status
@@ -79,14 +87,14 @@ func (h *SyncHandler) GetStatus(c *gin.Context) {
 	needComponentSync := h.localDB.NeedComponentSync(24)
 
 	c.JSON(http.StatusOK, SyncStatusResponse{
-		LastComponentSync:  lastComponentSync,
-		LastPricelistSync:  lastPricelistSync,
-		IsOnline:           isOnline,
-		ComponentsCount:    componentsCount,
-		PricelistsCount:    pricelistsCount,
-		ServerPricelists:   serverPricelists,
-		NeedComponentSync:  needComponentSync,
-		NeedPricelistSync:  needPricelistSync,
+		LastComponentSync: lastComponentSync,
+		LastPricelistSync: lastPricelistSync,
+		IsOnline:          isOnline,
+		ComponentsCount:   componentsCount,
+		PricelistsCount:   pricelistsCount,
+		ServerPricelists:  serverPricelists,
+		NeedComponentSync: needComponentSync,
+		NeedPricelistSync: needPricelistSync,
 	})
 }
 
@@ -169,11 +177,11 @@ func (h *SyncHandler) SyncPricelists(c *gin.Context) {
 
 // SyncAllResponse represents result of full sync
 type SyncAllResponse struct {
-	Success            bool   `json:"success"`
-	Message            string `json:"message"`
-	ComponentsSynced   int    `json:"components_synced"`
-	PricelistsSynced   int    `json:"pricelists_synced"`
-	Duration           string `json:"duration"`
+	Success          bool   `json:"success"`
+	Message          string `json:"message"`
+	ComponentsSynced int    `json:"components_synced"`
+	PricelistsSynced int    `json:"pricelists_synced"`
+	Duration         string `json:"duration"`
 }
 
 // SyncAll syncs both components and pricelists
@@ -216,8 +224,8 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 	if err != nil {
 		slog.Error("pricelist sync failed during full sync", "error", err)
 		c.JSON(http.StatusInternalServerError, gin.H{
-			"success":          false,
-			"error":            "Pricelist sync failed: " + err.Error(),
+			"success":           false,
+			"error":             "Pricelist sync failed: " + err.Error(),
 			"components_synced": componentsSynced,
 		})
 		return
@@ -294,9 +302,9 @@ func (h *SyncHandler) GetPendingChanges(c *gin.Context) {
 
 // SyncInfoResponse represents sync information
 type SyncInfoResponse struct {
-	LastSyncAt *time.Time `json:"last_sync_at"`
-	IsOnline   bool       `json:"is_online"`
-	ErrorCount int        `json:"error_count"`
+	LastSyncAt *time.Time  `json:"last_sync_at"`
+	IsOnline   bool        `json:"is_online"`
+	ErrorCount int         `json:"error_count"`
 	Errors     []SyncError `json:"errors,omitempty"`
 }
 

internal/handlers/web.go

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

internal/repository/pricelist.go

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

internal/services/pricing/service.go

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

internal/services/quote.go

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

internal/services/sync/service.go

@@ -44,9 +44,9 @@ func (s *Service) GetStatus() (*SyncStatus, error) {
 	if connStatus.IsConnected {
 		if mariaDB, err := s.connMgr.GetDB(); err == nil && mariaDB != nil {
 			pricelistRepo := repository.NewPricelistRepository(mariaDB)
-			serverPricelists, _, err := pricelistRepo.List(0, 1)
+			activeCount, err := pricelistRepo.CountActive()
 			if err == nil {
-				serverCount = len(serverPricelists)
+				serverCount = int(activeCount)
 			}
 		}
 	}
@@ -126,20 +126,24 @@ func (s *Service) SyncPricelists() (int, error) {
 	// Create repository
 	pricelistRepo := repository.NewPricelistRepository(mariaDB)
 
-	// Get all active pricelists from server (up to 100)
-	serverPricelists, _, err := pricelistRepo.List(0, 100)
+	// Get active pricelists from server (up to 100)
+	serverPricelists, _, err := pricelistRepo.ListActive(0, 100)
 	if err != nil {
-		return 0, fmt.Errorf("getting server pricelists: %w", err)
+		return 0, fmt.Errorf("getting active server pricelists: %w", err)
 	}
 
 	synced := 0
 	var latestLocalID uint
+	var latestServerID uint
 	for _, pl := range serverPricelists {
 		// Check if pricelist already exists locally
 		existing, _ := s.localDB.GetLocalPricelistByServerID(pl.ID)
 		if existing != nil {
-			// Already synced, track latest
-			latestLocalID = existing.ID
+			// Already synced, track latest by server ID
+			if pl.ID > latestServerID {
+				latestServerID = pl.ID
+				latestLocalID = existing.ID
+			}
 			continue
 		}
 
@@ -167,7 +171,10 @@ func (s *Service) SyncPricelists() (int, error) {
 			slog.Debug("synced pricelist with items", "version", pl.Version, "items", itemCount)
 		}
 
-		latestLocalID = localPL.ID
+		if pl.ID > latestServerID {
+			latestServerID = pl.ID
+			latestLocalID = localPL.ID
+		}
 		synced++
 	}
 

scripts/release.sh

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

web/templates/setup.html

@@ -158,6 +158,16 @@
             }, 1000); // Check every second
         }
 
+        async function requestRestartAndWait() {
+            showStatus('Перезапуск приложения...', 'info');
+            try {
+                await fetch('/api/restart', { method: 'POST' });
+            } catch (e) {
+                // Ignore network errors here: restart may break connection immediately.
+            }
+            checkServerReady();
+        }
+
         document.getElementById('setup-form').addEventListener('submit', async function(e) {
             e.preventDefault();
             showStatus('Сохранение настроек...', 'info');
@@ -176,9 +186,8 @@
 
                     // Check if restart is required
                     if (data.restart_required) {
-                        // In normal mode, restart must be done manually
                         setTimeout(() => {
-                            showStatus('⚠️ Пожалуйста, перезапустите приложение вручную для применения изменений', 'warning');
+                            requestRestartAndWait();
                         }, 2000);
                     } else {
                         // In setup mode, auto-restart is happening