Init UX overhaul: provider picker, model auto-pull, dimension fixes

- Add interactive provider choice even when Ollama is detected
- Auto-pull Ollama models during init if not already present
- Fix snowflake-arctic-embed2 dimensions (768 → 1024)
- Fix model choice not persisting across init steps
- Delete stale DB on re-init to prevent dimension mismatch
- Auto-background `same web` so it doesn't block the terminal
- Remove redundant openai-compatible base_url warning
- Update MCP setup prompt to "highly recommended"

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

Author: sgx-labs

CHANGELOG.md

@@ -229,7 +229,7 @@ One-command install of pre-built knowledge vaults. `same seed install claude-cod
 - **OpenAI-compatible embedding provider** — SAME now supports any server that exposes the OpenAI-compatible `/v1/embeddings` endpoint. Use `provider = "openai-compatible"` with llama.cpp, VLLM, LM Studio, or any other compatible inference engine. API key is optional for local servers. Configure via `[embedding]` in config or `SAME_EMBED_PROVIDER` / `SAME_EMBED_BASE_URL` / `SAME_EMBED_MODEL` environment variables.
 - **Non-localhost security warning** — when using an OpenAI-compatible provider with a remote base URL, SAME prints a warning that embedding requests will leave your machine. Local servers (localhost, 127.0.0.1, ::1) are silent.
 - **`--hooks-only` flag for init** — `same init --hooks-only` skips MCP setup for Claude Code-only workflows (mirrors existing `--mcp-only` for Cursor/Windsurf).
-- **Expanded embedding model support** — auto-detected dimensions for 5 new models: `snowflake-arctic-embed2` (768), `embeddinggemma` (768), `qwen3-embedding` (1024), `nomic-embed-text-v2-moe` (768), `bge-m3` (1024). All recognized in dimension defaults and embedding-only model filter.
+- **Expanded embedding model support** — auto-detected dimensions for 5 new models: `snowflake-arctic-embed2` (1024), `embeddinggemma` (768), `qwen3-embedding` (1024), `nomic-embed-text-v2-moe` (768), `bge-m3` (1024). All recognized in dimension defaults and embedding-only model filter.
 - **Provider-aware onboarding** — `same init` detects `openai`/`openai-compatible` providers and skips the Ollama connectivity check, showing provider/model/endpoint info instead.
 - **Pre-release verification gate** — `make precheck` runs 9 automated checks (version consistency, build, tests, PII scan, git identity, JSON validation, CLI smoke test).
 

README.md

@@ -502,7 +502,7 @@ Supported embedding models (auto-detected dimensions):
 | Model | Dims | Notes |
 |-------|------|-------|
 | `nomic-embed-text` | 768 | Default. Great balance of quality and speed |
-| `snowflake-arctic-embed2` | 768 | Recommended upgrade. Best retrieval in its size class |
+| `snowflake-arctic-embed2` | 1024 | Recommended upgrade. Best retrieval in its size class |
 | `mxbai-embed-large` | 1024 | Highest overall MTEB average |
 | `all-minilm` | 384 | Lightweight (~90MB). Good for constrained hardware |
 | `snowflake-arctic-embed` | 1024 | v1 large model |

cmd/same/web_cmd.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"net"
 	"os"
 	"os/exec"
 	"os/signal"
@@ -19,26 +20,40 @@ import (
 
 func webCmd() *cobra.Command {
 	var (
-		port     int
-		openFlag bool
+		port       int
+		openFlag   bool
+		foreground bool
 	)
 	cmd := &cobra.Command{
 		Use:   "web",
 		Short: "Open the vault dashboard in your browser",
 		Long: `Start a local web server for the vault dashboard.
 
 The dashboard is read-only and only accessible from localhost.
+The server runs in the background by default.
 
 Examples:
-  same web                  # Start on port 4078
+  same web                  # Start background server, open browser
   same web --port 8080      # Custom port
-  same web --open           # Auto-open browser`,
+  same web --fg             # Run in foreground (blocks terminal)`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			vp := config.VaultPath()
 			if vp == "" {
 				return config.ErrNoVault
 			}
+			// Verify the vault actually exists on disk
+			if _, err := os.Stat(vp); err != nil {
+				return fmt.Errorf("vault path does not exist: %s", vp)
+			}
+
+			addr := fmt.Sprintf("127.0.0.1:%d", port)
+
+			// Background mode: re-exec ourselves as a detached process
+			if !foreground && os.Getenv("_SAME_WEB_BG") == "" {
+				return launchBackground(addr, port, vp)
+			}
 
+			// Foreground mode (or background child process)
 			ctx, cancel := context.WithCancel(cmd.Context())
 			defer cancel()
 
@@ -50,33 +65,77 @@ Examples:
 				select {
 				case <-ctx.Done():
 				case <-sigCh:
-					fmt.Fprintln(os.Stderr, "Shutting down...")
 					cancel()
 				}
 			}()
 
 			// Create embed provider (nil is fine — keyword fallback)
 			embedClient, _ := newEmbedProvider()
 
-			addr := fmt.Sprintf("127.0.0.1:%d", port)
-			fmt.Printf("\n  Dashboard: %shttp://%s%s\n", cli.Bold, addr, cli.Reset)
-			fmt.Printf("  Press Ctrl+C to stop\n\n")
-
-			if openFlag {
-				go func() {
-					time.Sleep(300 * time.Millisecond)
-					openBrowser(fmt.Sprintf("http://%s", addr))
-				}()
+			if foreground {
+				fmt.Printf("\n  Dashboard: %shttp://%s%s\n", cli.Bold, addr, cli.Reset)
+				fmt.Printf("  %sPress Ctrl+C to stop%s\n\n", cli.Dim, cli.Reset)
 			}
 
 			return web.Serve(ctx, addr, embedClient, Version, vp)
 		},
 	}
 	cmd.Flags().IntVar(&port, "port", 4078, "Port to listen on")
-	cmd.Flags().BoolVar(&openFlag, "open", false, "Auto-open browser")
+	cmd.Flags().BoolVar(&openFlag, "open", false, "Auto-open browser (default in background mode)")
+	cmd.Flags().BoolVar(&foreground, "fg", false, "Run in foreground (blocks terminal)")
 	return cmd
 }
 
+// launchBackground re-execs `same web --fg` as a detached background process,
+// waits for the server to start, opens the browser, and returns.
+func launchBackground(addr string, port int, vaultPath string) error {
+	exe, err := os.Executable()
+	if err != nil {
+		return fmt.Errorf("find executable: %w", err)
+	}
+
+	child := exec.Command(exe, "web", "--fg", "--port", fmt.Sprintf("%d", port))
+	child.Env = append(os.Environ(), "_SAME_WEB_BG=1", "VAULT_PATH="+vaultPath)
+	child.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	child.Stdout = nil
+	child.Stderr = nil
+
+	if err := child.Start(); err != nil {
+		return fmt.Errorf("start background server: %w", err)
+	}
+
+	// Wait for server to be ready (up to 3 seconds)
+	url := fmt.Sprintf("http://%s", addr)
+	ready := false
+	for i := 0; i < 30; i++ {
+		time.Sleep(100 * time.Millisecond)
+		conn, err := net.DialTimeout("tcp", addr, 200*time.Millisecond)
+		if err == nil {
+			conn.Close()
+			ready = true
+			break
+		}
+	}
+
+	if !ready {
+		fmt.Printf("  %s!%s Server may not have started — check port %d\n", cli.Yellow, cli.Reset, port)
+		return nil
+	}
+
+	// Write PID file for `same web stop` (future feature)
+	pidPath := config.DataDir() + "/web.pid"
+	_ = os.WriteFile(pidPath, []byte(fmt.Sprintf("%d", child.Process.Pid)), 0o600)
+
+	fmt.Printf("\n  %s✓%s Dashboard running at %s%s%s\n", cli.Green, cli.Reset, cli.Bold, url, cli.Reset)
+	fmt.Printf("  %sPID %d • Stop with: kill %d%s\n\n", cli.Dim, child.Process.Pid, child.Process.Pid, cli.Reset)
+
+	openBrowser(url)
+
+	// Detach — don't wait for child
+	_ = child.Process.Release()
+	return nil
+}
+
 func openBrowser(url string) {
 	var cmd *exec.Cmd
 	switch runtime.GOOS {

internal/config/config.go

@@ -62,7 +62,7 @@ func EmbeddingDim() int {
 		case "snowflake-arctic-embed":
 			return 1024
 		case "snowflake-arctic-embed2":
-			return 768
+			return 1024
 		case "embeddinggemma":
 			return 768
 		case "qwen3-embedding":
@@ -88,7 +88,7 @@ type ModelInfo struct {
 // KnownModels lists supported embedding models with metadata.
 var KnownModels = []ModelInfo{
 	{"nomic-embed-text", 768, "ollama", "Default. Great balance of quality and speed"},
-	{"snowflake-arctic-embed2", 768, "ollama", "Best retrieval in its size class"},
+	{"snowflake-arctic-embed2", 1024, "ollama", "Best retrieval in its size class"},
 	{"mxbai-embed-large", 1024, "ollama", "Highest overall MTEB average"},
 	{"all-minilm", 384, "ollama", "Lightweight (~90MB). Good for constrained hardware"},
 	{"snowflake-arctic-embed", 1024, "ollama", "v1 large model"},
@@ -301,11 +301,6 @@ func LoadConfig() (*Config, error) {
 	} else if cfg.Memory.CompositeThreshold > 1.0 {
 		cfg.Memory.CompositeThreshold = 1.0
 	}
-	if strings.EqualFold(strings.TrimSpace(cfg.Embedding.Provider), "openai-compatible") &&
-		strings.TrimSpace(cfg.Embedding.BaseURL) == "" {
-		fmt.Fprintln(os.Stderr, "same: warning: openai-compatible provider requires base_url (set embedding.base_url or SAME_EMBED_BASE_URL)")
-	}
-
 	// Apply TOML skip_dirs to the global SkipDirs map.
 	// Previously parsed but never applied — this fixes the bug.
 	if len(cfg.Vault.SkipDirs) > 0 {
@@ -438,9 +433,16 @@ func generateTOMLContent(vaultPath string) string {
 	b.WriteString("handoff_dir = \"sessions\"\n")
 	b.WriteString("decision_log = \"decisions.md\"\n\n")
 
+	// Use the active model (may have been changed via model picker or env var)
+	activeModel := EmbeddingModel
+	ec := EmbeddingProviderConfig()
+	if ec.Model != "" {
+		activeModel = ec.Model
+	}
+
 	b.WriteString("[ollama]\n")
 	b.WriteString("url = \"http://localhost:11434\"\n")
-	b.WriteString("model = \"nomic-embed-text\"\n\n")
+	b.WriteString(fmt.Sprintf("model = %q\n\n", activeModel))
 
 	b.WriteString("[embedding]\n")
 	b.WriteString("# Embedding provider: \"ollama\" (default), \"openai\", \"openai-compatible\", or \"none\" (keyword-only)\n")
@@ -449,7 +451,7 @@ func generateTOMLContent(vaultPath string) string {
 		activeProvider = "ollama"
 	}
 	b.WriteString(fmt.Sprintf("provider = %q\n", activeProvider))
-	b.WriteString(fmt.Sprintf("model = %q\n", EmbeddingModel))
+	b.WriteString(fmt.Sprintf("model = %q\n", activeModel))
 	b.WriteString("# api_key = \"\"                  # required for cloud providers\n")
 	b.WriteString("#                               # or set SAME_EMBED_API_KEY / OPENAI_API_KEY\n")
 	b.WriteString("# dimensions = 0                # 0 = use provider default\n\n")

internal/config/config_test.go

@@ -1,7 +1,6 @@
 package config
 
 import (
-	"io"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -389,23 +388,7 @@ func TestLoadConfig_MissingBaseURL_OpenAICompatible(t *testing.T) {
 		t.Fatalf("write config: %v", err)
 	}
 
-	oldStderr := os.Stderr
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatalf("os.Pipe: %v", err)
-	}
-	os.Stderr = w
-
 	cfg, err := LoadConfig()
-
-	_ = w.Close()
-	os.Stderr = oldStderr
-
-	var warnBuf strings.Builder
-	if _, copyErr := io.Copy(&warnBuf, r); copyErr != nil {
-		t.Fatalf("io.Copy stderr: %v", copyErr)
-	}
-
 	if err != nil {
 		t.Fatalf("LoadConfig: %v", err)
 	}
@@ -416,9 +399,6 @@ func TestLoadConfig_MissingBaseURL_OpenAICompatible(t *testing.T) {
 	if ec.BaseURL != "" {
 		t.Fatalf("expected empty base URL, got %q", ec.BaseURL)
 	}
-	if !strings.Contains(warnBuf.String(), "openai-compatible provider requires base_url") {
-		t.Fatalf("expected base_url warning, got: %q", warnBuf.String())
-	}
 }
 
 func TestLoadConfig_ZeroDimensionsFallsBackToModelDefault(t *testing.T) {

internal/embedding/ollama.go

@@ -251,7 +251,7 @@ func ollamaDefaultDims(model string) int {
 	case "snowflake-arctic-embed":
 		return 1024
 	case "snowflake-arctic-embed2":
-		return 768
+		return 1024
 	case "embeddinggemma":
 		return 768
 	case "qwen3-embedding":

internal/embedding/ollama_test.go

@@ -276,7 +276,7 @@ func TestOllamaDefaultDims(t *testing.T) {
 		{"mxbai-embed-large", 1024},
 		{"all-minilm", 384},
 		{"snowflake-arctic-embed", 1024},
-		{"snowflake-arctic-embed2", 768},
+		{"snowflake-arctic-embed2", 1024},
 		{"embeddinggemma", 768},
 		{"qwen3-embedding", 1024},
 		{"nomic-embed-text-v2-moe", 768},