@owdproject/cli 0.1.0 → 0.2.0

package/go/tui/tui.go

@@ -1,232 +1,21 @@
 package tui
 
 import (
-	"bufio"
-	"context"
 	"encoding/json"
 	"fmt"
-	"io"
-	"math/rand"
 	"net/http"
-	"net/url"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
-	"syscall"
 	"time"
 
 	"owd-cli/bridge"
 
+	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
 )
 
-// ─────────────────────────────────────────────
-// Colors & Styles
-// ─────────────────────────────────────────────
-
-var (
-	colorAccent    = lipgloss.Color("#7ee787")
-	colorCyan      = lipgloss.Color("#24ebff")
-	colorDim       = lipgloss.Color("#3a3a4a")
-	colorMuted     = lipgloss.Color("#6c7086")
-	colorWarn      = lipgloss.Color("#f9e2af")
-	colorErr       = lipgloss.Color("#f38ba8")
-	colorNpm       = lipgloss.Color("#7ee787")
-	colorGit       = lipgloss.Color("#89dceb")
-	colorLocal     = lipgloss.Color("#ff79c6")
-	colorBorder    = lipgloss.Color("#4a4a6a")
-	colorBorderAct = lipgloss.Color("#7ee787")
-	colorWhite     = lipgloss.Color("#cdd6f4")
-	colorSubtle    = lipgloss.Color("#585b70")
-	colorBarBg     = lipgloss.Color("#11111b")
-	colorBarFg     = lipgloss.Color("#cdd6f4")
-)
-
-var (
-	panelBorderStyle = lipgloss.NewStyle().
-				Border(lipgloss.RoundedBorder()).
-				BorderForeground(colorBorder)
-
-	panelBorderActive = lipgloss.NewStyle().
-				Border(lipgloss.RoundedBorder()).
-				BorderForeground(colorBorderAct)
-
-	accentStyle = lipgloss.NewStyle().Foreground(colorAccent).Bold(true)
-	cyanStyle   = lipgloss.NewStyle().Foreground(colorCyan).Bold(true)
-	mutedStyle  = lipgloss.NewStyle().Foreground(colorMuted)
-	warnStyle   = lipgloss.NewStyle().Foreground(colorWarn)
-	errStyle    = lipgloss.NewStyle().Foreground(colorErr)
-	boldStyle   = lipgloss.NewStyle().Bold(true).Foreground(colorWhite)
-	dimStyle    = lipgloss.NewStyle().Foreground(colorDim)
-	subtleStyle = lipgloss.NewStyle().Foreground(colorSubtle)
-
-	tabActiveStyle = lipgloss.NewStyle().
-			Bold(true).
-			Background(colorAccent).
-			Foreground(lipgloss.Color("#1e1e2e")).
-			Padding(0, 2)
-
-	tabInactiveStyle = lipgloss.NewStyle().
-				Foreground(colorMuted).
-				Padding(0, 2)
-
-	selectedRowStyle = lipgloss.NewStyle().
-				Bold(true).
-				Foreground(colorAccent)
-
-	installedBadge   = lipgloss.NewStyle().Foreground(colorAccent).Render("●")
-	uninstalledBadge = lipgloss.NewStyle().Foreground(colorSubtle).Render("○")
-
-	// bottom bar — no border, gemini-style
-	barStyle = lipgloss.NewStyle().
-			Foreground(colorBarFg).
-			PaddingLeft(2)
-
-	barKeyStyle = lipgloss.NewStyle().
-			Foreground(colorAccent).
-			Bold(true)
-
-	barSepStyle = lipgloss.NewStyle().
-			Foreground(colorSubtle)
-
-	modalStyle = lipgloss.NewStyle().
-			Padding(1, 3)
-
-	modalOptionActive = lipgloss.NewStyle().
-				Background(colorCyan).
-				Foreground(lipgloss.Color("#000000")).
-				Bold(true).
-				Padding(0, 2)
-
-	modalOptionInactive = lipgloss.NewStyle().
-				Background(colorDim).
-				Foreground(colorMuted).
-				Padding(0, 2)
-)
-
-// ─────────────────────────────────────────────
-// Msg types
-// ─────────────────────────────────────────────
-
-type contextLoadedMsg struct {
-	Ctx *bridge.WorkspaceContext
-	Err error
-}
-
-type catalogLoadedMsg struct {
-	Cat *bridge.CatalogResponse
-	Err error
-}
-
-type logLineMsg string
-type clearLogsMsg struct{}
-
-type taskFinishedMsg struct {
-	Success bool
-	Err     error
-}
-
-type serverStatusMsg struct {
-	Running bool
-}
-
-type tickMsg time.Time
-
-type memTickMsg struct {
-	MemMB int
-}
-
-type GitChanges struct {
-	Added    int
-	Modified int
-	Deleted  int
-}
-
-type UpdateInfo struct {
-	LocalGit    bool
-	BehindCount int
-	Npm         bool
-}
-
-type updatesLoadedMsg struct {
-	GitChanges map[string]GitChanges
-	Updates    map[string]UpdateInfo
-}
-
-// ─────────────────────────────────────────────
-// Prompt states
-// ─────────────────────────────────────────────
-
-type PromptType int
-
-const (
-	PromptNone PromptType = iota
-	PromptInstallMethod
-	PromptUninstallConfirm
-	PromptManagePackage
-	PromptForceReinstallConfirm
-	PromptSettings
-)
-
-var Program *tea.Program
-var ServerCmd *exec.Cmd
-
-// ─────────────────────────────────────────────
-// Model
-// ─────────────────────────────────────────────
-
-type TuiModel struct {
-	workspaceRoot string
-	ctx           *bridge.WorkspaceContext
-	catalog       *bridge.CatalogResponse
-
-	activeTab    int // 0: Internal, 1: Apps, 2: Modules, 3: Themes
-	err          error
-	loading      bool
-	statusMsg    string
-	logLines     []string
-	memHistory   []int
-
-	// Selection
-	selectedIndex int
-	scrollOffset  int
-
-	// Prompts/Modals
-	activePrompt PromptType
-	promptPkg    *bridge.CatalogEntry
-	promptSel    int
-
-	promptPkgDeps        []string
-	promptPkgHasPrimevue bool
-	promptPkgHasTailwind bool
-
-	gitChangesMap map[string]GitChanges
-	updatesMap    map[string]UpdateInfo
-
-	settingsSel         int
-	settingsInstallMode string
-	settingsCatalogSort string
-
-	// Server status
-	serverRunning   bool
-	taskActive      bool
-	checkingUpdates bool
-
-	// Animation
-	blink      bool
-	tickCount  int
-
-	// Layout
-	termWidth  int
-	termHeight int
-
-	lastInstallMethod string
-	logTailerStarted  bool
-}
-
 func NewModel(root string) TuiModel {
 	return TuiModel{
 		workspaceRoot:    root,
@@ -237,20 +26,46 @@ func NewModel(root string) TuiModel {
 		memHistory:       []int{},
 		gitChangesMap:    make(map[string]GitChanges),
 		updatesMap:       make(map[string]UpdateInfo),
+		localGitDirs:     make(map[string]bool),
 		settingsSel:      0,
 		termWidth:        160,
 		termHeight:       40,
 		lastInstallMethod: "npm",
 		logTailerStarted:  false,
+		pendingPackages:  make(map[string]bool),
+		pendingTheme:     nil,
+		workQueue:        NewWorkQueue(),
+		enginePhase:      PhaseIdle,
+		runtime: &RuntimeState{
+			msgChan:      make(chan tea.Msg, 500),
+			engineResume: make(chan string, 1),
+		},
+		startServerAfterSetup: false,
+		setupStep:             0,
+		setupTotalSteps:       0,
+		setupLabel:            "",
+		activeTask:            TaskNone,
+		workspaceBranch:       "—",
+		workspaceChanges:      "clean",
+		clientStars:           -1,
+	}
+}
+
+func (m *TuiModel) listenToChannel() tea.Cmd {
+	return func() tea.Msg {
+		return <-m.runtime.msgChan
 	}
 }
 
-func (m TuiModel) Init() tea.Cmd {
+func (m *TuiModel) Init() tea.Cmd {
 	return tea.Batch(
 		m.loadContextCmd(),
 		m.loadCatalogCmd(false),
 		m.checkServerStatusCmd(),
+		m.updateWorkspaceGitStatusCmd(),
+		m.listenToChannel(),
 		tickCmd(),
+		m.fetchClientStarsCmd(),
 	)
 }
 
@@ -273,67 +88,150 @@ func memSampleCmd() tea.Cmd {
 	}
 }
 
-func (m TuiModel) loadContextCmd() tea.Cmd {
+func (m *TuiModel) loadContextCmd() tea.Cmd {
 	return func() tea.Msg {
 		ctx, err := bridge.ReadWorkspaceContext(m.workspaceRoot)
 		return contextLoadedMsg{Ctx: ctx, Err: err}
 	}
 }
 
-func (m TuiModel) loadCatalogCmd(force bool) tea.Cmd {
+func (m *TuiModel) loadCatalogCmd(force bool) tea.Cmd {
 	return func() tea.Msg {
 		cat, err := bridge.ReadCatalog(m.workspaceRoot, force)
 		return catalogLoadedMsg{Cat: cat, Err: err}
 	}
 }
 
-func (m TuiModel) checkServerStatusCmd() tea.Cmd {
+type clientStarsMsg int
+
+func (m *TuiModel) fetchClientStarsCmd() tea.Cmd {
+	return func() tea.Msg {
+		client := &http.Client{Timeout: 3 * time.Second}
+		req, err := http.NewRequest("GET", "https://api.github.com/repos/owdproject/client", nil)
+		if err != nil {
+			return clientStarsMsg(-1)
+		}
+		req.Header.Set("User-Agent", "owd-cli")
+		resp, err := client.Do(req)
+		if err != nil {
+			return clientStarsMsg(-1)
+		}
+		defer resp.Body.Close()
+
+		var res map[string]interface{}
+		if err := json.NewDecoder(resp.Body).Decode(&res); err == nil {
+			if starsVal, ok := res["stargazers_count"]; ok {
+				if starsFloat, ok := starsVal.(float64); ok {
+					return clientStarsMsg(int(starsFloat))
+				}
+			}
+		}
+		return clientStarsMsg(-1)
+	}
+}
+
+func (m *TuiModel) checkServerStatusCmd() tea.Cmd {
 	return func() tea.Msg {
 		if m.ctx == nil {
 			return serverStatusMsg{Running: false}
 		}
 
-		pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
-		data, err := os.ReadFile(pidPath)
-		if err != nil {
-			return serverStatusMsg{Running: false}
+		port := m.ctx.Settings.DevPort
+		if port == 0 {
+			port = 3000
 		}
 
-		var pid int
-		if _, err := fmt.Sscanf(strings.TrimSpace(string(data)), "%d", &pid); err != nil {
+		open := isPortOpen(port)
+		if !open {
+			pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
+			_ = os.Remove(pidPath)
 			return serverStatusMsg{Running: false}
 		}
 
-		process, err := os.FindProcess(pid)
-		if err != nil {
-			return serverStatusMsg{Running: false}
+		pid := findProcessPID(port)
+		if pid > 0 {
+			pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
+			_ = os.WriteFile(pidPath, []byte(fmt.Sprintf("%d", pid)), 0644)
 		}
 
-		err = process.Signal(syscall.Signal(0))
-		return serverStatusMsg{Running: err == nil}
+		return serverStatusMsg{Running: true}
 	}
 }
 
-// ─────────────────────────────────────────────
-// Update
-// ─────────────────────────────────────────────
+func (m *TuiModel) updateWorkspaceGitStatusCmd() tea.Cmd {
+	return func() tea.Msg {
+		branch := gitBranch(m.workspaceRoot)
+		changes := gitChanges(m.workspaceRoot)
+		return workspaceGitStatusMsg{Branch: branch, Changes: changes}
+	}
+}
 
-func (m TuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+func (m *TuiModel) hasPendingChanges() bool {
+	if len(m.pendingPackages) > 0 {
+		return true
+	}
+	if m.pendingTheme != nil {
+		if m.ctx != nil && m.ctx.Config.Theme != nil {
+			return *m.ctx.Config.Theme != *m.pendingTheme
+		}
+		return true
+	}
+	return false
+}
+
+func (m *TuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 
+	case tea.MouseMsg:
+		if msg.Action == tea.MouseActionRelease && msg.Button == tea.MouseButtonLeft {
+			if m.isClearLogsClick(msg) {
+				m.logLines = []string{}
+				m.statusMsg = "Logs cleared."
+				return m, nil
+			}
+			if msg.Y == 10 {
+				if msg.X <= 13 {
+					m.activeTab, m.selectedIndex, m.scrollOffset = 0, 0, 0
+					return m, nil
+				}
+				if msg.X >= 14 && msg.X <= 22 {
+					m.activeTab, m.selectedIndex, m.scrollOffset = 1, 0, 0
+					return m, nil
+				}
+				if msg.X >= 23 && msg.X <= 34 {
+					m.activeTab, m.selectedIndex, m.scrollOffset = 2, 0, 0
+					return m, nil
+				}
+				if msg.X >= 35 {
+					m.activeTab, m.selectedIndex, m.scrollOffset = 3, 0, 0
+					return m, nil
+				}
+			}
+		}
+		return m, nil
+
 	case tea.WindowSizeMsg:
 		m.termWidth = msg.Width
 		m.termHeight = msg.Height
 		return m, nil
 
+	case clientStarsMsg:
+		if int(msg) >= 0 {
+			m.clientStars = int(msg)
+		}
+		return m, nil
+
 	case tickMsg:
 		m.tickCount++
 		if m.tickCount%4 == 0 {
 			m.blink = !m.blink
 		}
-		
+
+		var cmds []tea.Cmd
+		cmds = append(cmds, tickCmd())
+
+		// Every ~1.5s: sample memory + check server status
 		if m.tickCount%10 == 0 {
-			// Sample Nuxt process memory stats
 			var mb int
 			if m.ctx != nil {
 				pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
@@ -348,17 +246,32 @@ func (m TuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if len(m.memHistory) > 30 {
 				m.memHistory = m.memHistory[1:]
 			}
+			if m.ctx != nil {
+				cmds = append(cmds, m.checkServerStatusCmd())
+			}
 		}
-		
-		if m.tickCount%100 == 0 && !m.loading && !m.taskActive && !m.checkingUpdates {
+
+		// Every ~15s: fast local git status check (no network)
+		if m.tickCount%100 == 0 && !m.loading && m.activeTask == TaskNone && !m.checkingUpdates {
 			m.checkingUpdates = true
-			return m, tea.Batch(tickCmd(), m.checkForUpdatesCmd())
+			cmds = append(cmds, m.checkLocalChangesCmd(), m.updateWorkspaceGitStatusCmd())
+		}
+
+		// Every ~5min: slow remote check (git behind without fetch + npm versions)
+		if m.tickCount%2000 == 0 && !m.loading && m.activeTask == TaskNone {
+			cmds = append(cmds, m.checkRemoteUpdatesCmd())
 		}
-		
-		return m, tickCmd()
+
+		return m, tea.Batch(cmds...)
 
 	case tea.KeyMsg:
-		if m.activePrompt != PromptNone {
+		promptToShow := m.activePrompt
+		if (m.activeTask == TaskSetup || m.activeTask == TaskWipe) &&
+			m.activePrompt != PromptResolveDependency &&
+			(promptToShow == PromptNone || promptToShow == PromptUninstallConfirm || promptToShow == PromptInstallMethod || promptToShow == PromptWipeWorkspaceConfirm) {
+			promptToShow = PromptSetupProgress
+		}
+		if promptToShow != PromptNone {
 			return m.handlePromptKeys(msg)
 		}
 		switch msg.String() {
@@ -403,20 +316,33 @@ func (m TuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.statusMsg = "Refreshing package catalog…"
 			return m, m.loadCatalogCmd(true)
 		case "s":
-			if !m.serverRunning && !m.taskActive {
-				m.statusMsg = "Starting dev server…"
-				m.taskActive = true
-				if Program != nil {
-					m.RunServeTask(Program)
+			if m.hasPendingChanges() {
+				return m, m.startWizard(WizardSave)
+			}
+			cmd := m.startWizard(WizardStartupCheck)
+			if cmd != nil {
+				return m, cmd
+			}
+		case "d":
+			if !m.serverRunning && m.activeTask == TaskNone {
+				if m.hasPendingChanges() {
+					return m, m.startWizard(WizardSaveAndServe)
 				}
+				cmd := m.startWizard(WizardStartupCheck)
+				if cmd != nil {
+					m.startServerAfterSetup = true
+					return m, cmd
+				}
+
+				m.statusMsg = "Starting dev server…"
+				m.activeTask = TaskServe
+				m.RunServeTask()
 			}
 		case "x":
 			if m.serverRunning {
 				m.statusMsg = "Stopping dev server…"
-				m.taskActive = true
-				if Program != nil {
-					m.StopServeTask(Program)
-				}
+				m.activeTask = TaskServe
+				m.StopServeTask()
 			}
 		case "c":
 			items := m.getActiveItems()
@@ -431,35 +357,73 @@ func (m TuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			items := m.getActiveItems()
 			if len(items) > 0 && m.selectedIndex < len(items) {
 				pkg := items[m.selectedIndex]
-				m.promptPkg = &pkg
-				if pkg.Installed {
-					m.activePrompt = PromptUninstallConfirm
-					m.promptSel = 1
-				} else {
-					m.activePrompt = PromptInstallMethod
-					methods := m.getInstallMethods(&pkg)
-					selIdx := 0
-					for idx, mth := range methods {
-						if mth.Name == m.lastInstallMethod {
-							selIdx = idx
-							break
+				if m.activeTab == 3 { // Themes (radiobox)
+					current := activeThemeName(m.ctx, m.pendingTheme)
+					if current == pkg.Name && m.pendingTheme != nil {
+						m.pendingTheme = nil
+					} else if current != pkg.Name {
+						themeName := pkg.Name
+						m.pendingTheme = &themeName
+					}
+				} else { // Apps or Modules (checkbox)
+					if pkg.Installed {
+						if _, exists := m.pendingPackages[pkg.Name]; exists {
+							delete(m.pendingPackages, pkg.Name)
+						} else {
+							m.pendingPackages[pkg.Name] = false
+						}
+					} else {
+						if _, exists := m.pendingPackages[pkg.Name]; exists {
+							delete(m.pendingPackages, pkg.Name)
+						} else {
+							m.pendingPackages[pkg.Name] = true
 						}
 					}
-					m.promptSel = selIdx
 				}
 			}
 		case "u":
-			m.loading = true
-			m.statusMsg = "Checking for updates…"
-			m.checkingUpdates = true
-			return m, m.checkForUpdatesCmd()
+			items := m.getActiveItems()
+			if len(items) > 0 && m.selectedIndex < len(items) {
+				pkg := items[m.selectedIndex]
+				if pkg.Installed && m.activeTask == TaskNone {
+					m.activeTask = TaskSetup
+					m.statusMsg = fmt.Sprintf("Updating %s…", pkg.ShortName)
+					m.RunUpdatePackageTask(pkg.Name, pkg.ShortName, pkg.Kind, pkg.LocalSource)
+				}
+			}
 		case "g":
 			if m.ctx != nil {
 				m.settingsInstallMode = m.ctx.Settings.InstallMode
 				m.settingsCatalogSort = m.ctx.Settings.CatalogSort
 				m.settingsSel = 0
 				m.activePrompt = PromptSettings
+
+				// Initialize text inputs
+				tiUser := textinput.New()
+				tiUser.Placeholder = "github_user"
+				tiUser.CharLimit = 64
+				tiUser.Width = 30
+				if m.ctx.Settings.GithubUser != nil {
+					tiUser.SetValue(*m.ctx.Settings.GithubUser)
+				}
+				m.settingsUserInput = tiUser
+
+				tiOrgs := textinput.New()
+				tiOrgs.Placeholder = "org1, org2"
+				tiOrgs.CharLimit = 256
+				tiOrgs.Width = 40
+				if len(m.ctx.Settings.GithubOrgs) > 0 {
+					tiOrgs.SetValue(strings.Join(m.ctx.Settings.GithubOrgs, ", "))
+				} else {
+					tiOrgs.SetValue("owdproject, atproto-os")
+				}
+				m.settingsOrgsInput = tiOrgs
+
+				m.updateSettingsFocus()
 			}
+		case "n":
+			m.ExitCode = 10
+			return m, tea.Quit
 		}
 		return m, nil
 
@@ -475,8 +439,10 @@ func (m TuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if !m.logTailerStarted && m.ctx != nil {
 				m.logTailerStarted = true
 				logPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.log")
-				StartLogTailer(logPath, Program)
+				m.StartLogTailer(logPath)
 			}
+
+			return m, m.checkServerStatusCmd()
 		}
 
 	case catalogLoadedMsg:
@@ -487,2271 +453,272 @@ func (m TuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		} else {
 			m.catalog = msg.Cat
 			m.statusMsg = fmt.Sprintf("Catalog loaded (%s).", msg.Cat.CacheAge)
+
+			// Run fast local check immediately; schedule remote check too
 			m.checkingUpdates = true
-			return m, m.checkForUpdatesCmd()
+			return m, tea.Batch(m.checkLocalChangesCmd(), m.checkRemoteUpdatesCmd())
 		}
 
-	case updatesLoadedMsg:
+	case localChangesMsg:
 		m.gitChangesMap = msg.GitChanges
-		m.updatesMap = msg.Updates
+		m.localGitDirs = msg.LocalGitDirs
 		m.checkingUpdates = false
 		m.loading = false
-		count := 0
-		for _, up := range msg.Updates {
-			if up.LocalGit || up.Npm {
-				count++
+
+	case remoteUpdatesMsg:
+		m.updatesMap = msg.Updates
+		if msg.Err == nil {
+			count := 0
+			for _, up := range msg.Updates {
+				if up.LocalGit || up.Npm {
+					count++
+				}
+			}
+			if count > 0 {
+				m.statusMsg = fmt.Sprintf("%d update(s) available.", count)
 			}
 		}
-		if count > 0 {
-			m.statusMsg = fmt.Sprintf("Updates check completed: %d update(s) available.", count)
-		} else {
-			m.statusMsg = "All packages are up to date."
-		}
-		return m, nil
+
+	case setupProgressMsg:
+		m.setupStep = msg.Step
+		m.setupTotalSteps = msg.Total
+		m.setupLabel = msg.Label
+		return m, m.listenToChannel()
+
+	case engineQueueUpdatedMsg:
+		q := msg.Queue
+		m.workQueue = &q
+		completed, total := q.Progress()
+		m.setupStep = completed
+		m.setupTotalSteps = total
+		return m, m.listenToChannel()
+
+	case enginePhaseMsg:
+		m.enginePhase = msg.Phase
+		return m, m.listenToChannel()
+
+	case engineNeedsPromptMsg:
+		m.promptItem = &msg.Item
+		m.promptPkg = &msg.Item.Entry
+		m.activePrompt = PromptResolveDependency
+		m.promptSel = 0
+		m.statusMsg = fmt.Sprintf("Resolve dependency: %s", msg.Item.ShortName)
+		return m, m.listenToChannel()
 
 	case logLineMsg:
 		line := string(msg)
 		if strings.Contains(line, "█") || strings.Contains(line, "▄") || strings.Contains(line, "▀") {
-			break
+			return m, m.listenToChannel()
 		}
 		if strings.Contains(line, "Local:") || strings.Contains(line, "Network:") || strings.Contains(line, "expose") || strings.Contains(line, "➜") {
-			break
+			return m, m.listenToChannel()
 		}
 		m.addLog(line)
+		return m, m.listenToChannel()
 
 	case clearLogsMsg:
 		m.logLines = []string{}
-		return m, nil
+		return m, m.listenToChannel()
 
 	case taskFinishedMsg:
-		m.taskActive = false
+		m.activeTask = TaskNone
+		m.enginePhase = PhaseIdle
+		m.activePrompt = PromptNone
+		m.promptItem = nil
 		if msg.Success {
 			m.statusMsg = "Task completed."
-			m.addLog(">>> Task completed successfully.")
+			m.addLog("✓ Wizard completed successfully")
+			if m.serverRunning {
+				m.addLog("ℹ desktop.config.ts updated — Nuxt restarts automatically (see dev server log)")
+			}
+
+			if m.startServerAfterSetup {
+				m.startServerAfterSetup = false
+				m.statusMsg = "Starting dev server…"
+				m.addLog("ℹ Starting development server…")
+				m.activeTask = TaskServe
+				m.RunServeTask()
+			}
 		} else {
 			m.statusMsg = fmt.Sprintf("Task failed: %v", msg.Err)
-			m.addLog(fmt.Sprintf(">>> Task failed: %v", msg.Err))
+			m.addLog(fmt.Sprintf("✖ Wizard failed: %v", msg.Err))
+			m.startServerAfterSetup = false
 		}
-		return m, tea.Batch(m.loadContextCmd(), m.loadCatalogCmd(false))
+		return m, tea.Batch(m.loadContextCmd(), m.loadCatalogCmd(false), m.updateWorkspaceGitStatusCmd(), m.listenToChannel())
 
 	case serverStatusMsg:
 		m.serverRunning = msg.Running
-		m.taskActive = false
+		if m.activeTask == TaskServe {
+			m.activeTask = TaskNone
+		}
 		if !msg.Running {
 			m.statusMsg = "Dev server stopped."
 		} else {
 			m.statusMsg = "Dev server running."
 		}
+		return m, m.listenToChannel()
+	case workspaceGitStatusMsg:
+		m.workspaceBranch = msg.Branch
+		m.workspaceChanges = msg.Changes
+		return m, nil
 	}
 
 	return m, nil
 }
 
 func (m *TuiModel) addLog(line string) {
-	m.logLines = append(m.logLines, line)
+	// Split on embedded newlines — Nuxt can emit multi-line chunks as a single string.
+	// If we store them unsplit, the panel renders 1 counted line but N terminal lines → layout breaks.
+	line = strings.ReplaceAll(line, "\r\n", "\n")
+	sublines := strings.Split(line, "\n")
+	for _, sl := range sublines {
+		sl = strings.TrimRight(sl, "\r")
+		if sl == "" {
+			continue
+		}
+		m.logLines = append(m.logLines, sl)
+	}
 	if len(m.logLines) > 200 {
-		m.logLines = m.logLines[1:]
+		m.logLines = m.logLines[len(m.logLines)-200:]
 	}
 }
 
-// ─────────────────────────────────────────────
-// Prompt keys
-// ─────────────────────────────────────────────
 
-func (m TuiModel) handlePromptKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "esc", "q":
-		m.activePrompt = PromptNone
-		m.promptPkg = nil
-		return m, nil
-	case "up", "k":
-		if m.activePrompt == PromptManagePackage {
-			if m.promptSel > 0 {
-				m.promptSel--
-			}
-		} else if m.activePrompt == PromptSettings {
-			if m.settingsSel == 4 || m.settingsSel == 5 {
-				m.settingsSel = 3
-			} else if m.settingsSel > 0 {
-				m.settingsSel--
-			}
-		} else if m.promptSel > 0 {
-			m.promptSel--
-		}
-	case "down", "j":
-		if m.activePrompt == PromptManagePackage {
-			if m.promptSel < 5 {
-				m.promptSel++
-			}
-		} else if m.activePrompt == PromptSettings {
-			if m.settingsSel == 3 {
-				m.settingsSel = 4
-			} else if m.settingsSel < 3 {
-				m.settingsSel++
-			}
-		} else {
-			limit := 2
-			if m.activePrompt == PromptUninstallConfirm || m.activePrompt == PromptForceReinstallConfirm {
-				limit = 1
-			} else if m.activePrompt == PromptInstallMethod && m.promptPkg != nil {
-				limit = len(m.getInstallMethods(m.promptPkg)) - 1
-			}
-			if m.promptSel < limit {
-				m.promptSel++
-			}
-		}
-	case "left", "h":
-		if m.activePrompt == PromptSettings {
-			if m.settingsSel == 5 {
-				m.settingsSel = 4
-			}
-		} else if m.activePrompt != PromptManagePackage && m.activePrompt != PromptInstallMethod {
-			if m.promptSel > 0 {
-				m.promptSel--
-			}
-		}
-	case "right", "l":
-		if m.activePrompt == PromptSettings {
-			if m.settingsSel == 4 {
-				m.settingsSel = 5
-			}
-		} else if m.activePrompt != PromptManagePackage && m.activePrompt != PromptInstallMethod {
-			limit := 2
-			if m.activePrompt == PromptUninstallConfirm || m.activePrompt == PromptForceReinstallConfirm {
-				limit = 1
-			}
-			if m.promptSel < limit {
-				m.promptSel++
-			}
+// checkLocalChangesCmd runs a fast local-only git status check for every catalog entry.
+// No network activity — only reads the local working tree.
+// Runs every ~15s. Also detects which packages have their own .git folder.
+func (m *TuiModel) checkLocalChangesCmd() tea.Cmd {
+	return func() tea.Msg {
+		gitChangesMap := make(map[string]GitChanges)
+		localGitDirs := make(map[string]bool)
+
+		if m.catalog == nil {
+			return localChangesMsg{GitChanges: gitChangesMap, LocalGitDirs: localGitDirs}
 		}
-	case "enter":
-		pkg := m.promptPkg
-		prompt := m.activePrompt
-
-		if prompt == PromptUninstallConfirm {
-			m.activePrompt = PromptNone
-			m.promptPkg = nil
-			if m.promptSel == 0 {
-				return m.triggerUninstall(pkg)
-			}
-		} else if prompt == PromptInstallMethod {
-			m.activePrompt = PromptNone
-			m.promptPkg = nil
-			methods := m.getInstallMethods(pkg)
-			if m.promptSel >= 0 && m.promptSel < len(methods) {
-				m.lastInstallMethod = methods[m.promptSel].Name
-				return m.triggerInstall(pkg, methods[m.promptSel].Name)
-			}
-			return m, nil
-		} else if prompt == PromptForceReinstallConfirm {
-			m.activePrompt = PromptNone
-			m.promptPkg = nil
-			if m.promptSel == 0 {
-				return m.triggerForceReinstall(pkg)
+
+		for _, entry := range m.catalog.Entries {
+			short := entry.ShortName
+			var kindDir string
+			switch entry.Kind {
+			case "app":
+				kindDir = "apps"
+			case "module":
+				kindDir = "packages"
+			case "theme":
+				kindDir = "themes"
 			}
-		} else if prompt == PromptManagePackage {
-			m.activePrompt = PromptNone
-			m.promptPkg = nil
-			switch m.promptSel {
-			case 0: // Update Package
-				return m.triggerUpdate(pkg)
-			case 1: // Switch to NPM
-				m.lastInstallMethod = "npm"
-				return m.triggerInstall(pkg, "npm")
-			case 2: // Switch to Git HTTPS
-				m.lastInstallMethod = "git-https"
-				return m.triggerInstall(pkg, "git-https")
-			case 3: // Switch to Git SSH
-				m.lastInstallMethod = "git-ssh"
-				return m.triggerInstall(pkg, "git-ssh")
-			case 4: // Force Re-download
-				m.promptPkg = pkg
-				m.activePrompt = PromptForceReinstallConfirm
-				m.promptSel = 1 // default to No
-				return m, nil
-			case 5: // Back
-				return m, nil
+			if kindDir == "" {
+				continue
 			}
-		} else if prompt == PromptSettings {
-			switch m.settingsSel {
-			case 0: // Install Mode
-				if m.settingsInstallMode == "npm" {
-					m.settingsInstallMode = "workspace"
-				} else {
-					m.settingsInstallMode = "npm"
-				}
-				m.activePrompt = PromptSettings
-				return m, nil
-			case 1: // Catalog Sort
-				modes := []string{"updated", "name", "stars", "installed"}
-				idx := 0
-				for i, mth := range modes {
-					if mth == m.settingsCatalogSort {
-						idx = (i + 1) % len(modes)
-						break
-					}
+
+			pkgPath := filepath.Join(m.workspaceRoot, kindDir, short)
+			gitDir := filepath.Join(pkgPath, ".git")
+
+			if _, err := os.Stat(gitDir); err == nil {
+				// Package has its own .git repo
+				localGitDirs[short] = true
+				added, modified, deleted, err := runGitStatus(pkgPath)
+				if err == nil && (added > 0 || modified > 0 || deleted > 0) {
+					gitChangesMap[short] = GitChanges{Added: added, Modified: modified, Deleted: deleted}
 				}
-				m.settingsCatalogSort = modes[idx]
-				m.activePrompt = PromptSettings
-				return m, nil
-			case 2: // Trusted Orgs
-				m.addLog(">>> To configure Trusted Orgs, modify .desktop/settings.json (githubOrgs field).")
-				m.activePrompt = PromptSettings
-				return m, nil
-			case 3: // GitHub User
-				m.addLog(">>> To configure GitHub User, modify .desktop/settings.json or use OWD_GITHUB_USER env var.")
-				m.activePrompt = PromptSettings
-				return m, nil
-			case 4: // Save
-				m.activePrompt = PromptNone
-				if m.ctx != nil {
-					settings := m.ctx.Settings
-					settings.InstallMode = m.settingsInstallMode
-					settings.CatalogSort = m.settingsCatalogSort
-					payload := &bridge.WritePayload{
-						Settings: &settings,
-					}
-					m.statusMsg = "Saving settings…"
-					m.addLog(">>> Saving settings configuration…")
-					if err := bridge.WriteChanges(m.workspaceRoot, payload); err != nil {
-						m.statusMsg = fmt.Sprintf("Save failed: %v", err)
-						m.addLog(fmt.Sprintf(">>> Save settings failed: %v", err))
-					} else {
-						m.statusMsg = "Settings saved successfully."
-						m.addLog(">>> Settings saved successfully.")
+			} else {
+				// Fallback: check monorepo git for this subdirectory
+				parentGitDir := filepath.Join(m.workspaceRoot, ".git")
+				if _, err := os.Stat(parentGitDir); err == nil {
+					relPath := filepath.Join(kindDir, short)
+					added, modified, deleted, err := runGitStatusForSubdir(m.workspaceRoot, relPath)
+					if err == nil && (added > 0 || modified > 0 || deleted > 0) {
+						gitChangesMap[short] = GitChanges{Added: added, Modified: modified, Deleted: deleted}
 					}
 				}
-				m.loading = true
-				return m, tea.Batch(m.loadContextCmd(), m.loadCatalogCmd(false))
-			case 5: // Cancel
-				m.activePrompt = PromptNone
-				return m, nil
 			}
 		}
+
+		return localChangesMsg{GitChanges: gitChangesMap, LocalGitDirs: localGitDirs}
 	}
-	return m, nil
 }
 
-// ─────────────────────────────────────────────
-// Actions
-// ─────────────────────────────────────────────
-
-func (m TuiModel) triggerUninstall(pkg *bridge.CatalogEntry) (tea.Model, tea.Cmd) {
-	m.taskActive = true
-	m.statusMsg = fmt.Sprintf("Uninstalling %s…", pkg.ShortName)
-	m.addLog(fmt.Sprintf(">>> Uninstalling %s", pkg.Name))
+// checkRemoteUpdatesCmd runs the slow network-dependent checks:
+// - git behind count (uses cached remote refs, NO git fetch)
+// - npm latest version check
+// Runs every ~5 minutes.
+func (m *TuiModel) checkRemoteUpdatesCmd() tea.Cmd {
+	return func() tea.Msg {
+		updatesMap := make(map[string]UpdateInfo)
 
-	payload := &bridge.WritePayload{
-		Config:       &bridge.Config{Theme: m.ctx.Config.Theme, Apps: m.ctx.Config.Apps, Modules: m.ctx.Config.Modules},
-		DepsToRemove: []string{pkg.Name},
-	}
-	if pkg.Kind == "app" {
-		var next []string
-		for _, a := range m.ctx.Config.Apps {
-			if a != pkg.Name {
-				next = append(next, a)
-			}
+		if m.catalog == nil {
+			return remoteUpdatesMsg{Updates: updatesMap}
 		}
-		payload.Config.Apps = next
-	} else if pkg.Kind == "module" {
-		var next []string
-		for _, mod := range m.ctx.Config.Modules {
-			if mod != pkg.Name {
-				next = append(next, mod)
-			}
+
+		type result struct {
+			shortName string
+			update    *UpdateInfo
+			err       error
 		}
-		payload.Config.Modules = next
-	} else if pkg.Kind == "theme" {
-		e := ""
-		payload.Config.Theme = &e
-	}
 
-	if err := bridge.WriteChanges(m.workspaceRoot, payload); err != nil {
-		m.taskActive = false
-		m.statusMsg = fmt.Sprintf("Uninstall failed: %v", err)
-		return m, nil
-	}
-	if Program != nil {
-		m.RunUninstallTask(Program)
-	}
-	return m, nil
-}
+		resultsChan := make(chan result, len(m.catalog.Entries))
+		sem := make(chan struct{}, 5) // modest concurrency — these are network ops
 
-func (m TuiModel) triggerInstall(pkg *bridge.CatalogEntry, method string) (tea.Model, tea.Cmd) {
-	m.taskActive = true
-	m.statusMsg = fmt.Sprintf("Installing %s via %s…", pkg.ShortName, method)
-	m.addLog(fmt.Sprintf(">>> Installing %s via %s", pkg.Name, method))
+		for _, e := range m.catalog.Entries {
+			sem <- struct{}{}
+			go func(entry bridge.CatalogEntry) {
+				defer func() { <-sem }()
 
-	payload := &bridge.WritePayload{
-		Config:    &bridge.Config{Theme: m.ctx.Config.Theme, Apps: m.ctx.Config.Apps, Modules: m.ctx.Config.Modules},
-		DepsToAdd: make(map[string]string),
-	}
-	version := "latest"
-	if pkg.Version != nil {
-		version = *pkg.Version
-	}
+				res := result{shortName: entry.ShortName}
 
-	if method == "npm" {
-		payload.DepsToAdd[pkg.Name] = version
-	} else if method == "local" {
-		payload.DepsToAdd[pkg.Name] = "workspace:*"
-	} else {
-		user := "owdproject"
-		if m.ctx.Settings.GithubUser != nil && *m.ctx.Settings.GithubUser != "" {
-			user = *m.ctx.Settings.GithubUser
-		}
-		var gitUrl string
-		if method == "git-ssh" {
-			gitUrl = fmt.Sprintf("git@github.com:%s/%s.git", user, pkg.ShortName)
-		} else {
-			gitUrl = fmt.Sprintf("https://github.com/%s/%s.git", user, pkg.ShortName)
-		}
-		payload.DepsToAdd[pkg.Name] = "workspace:*"
-		settings := m.ctx.Settings
-		if settings.LastInstallChoices == nil {
-			settings.LastInstallChoices = make(map[string]interface{})
-		}
-		settings.LastInstallChoices[pkg.Name] = map[string]string{"type": "git", "gitUrl": gitUrl}
-		payload.Settings = &settings
-	}
+				short := entry.ShortName
+				var kindDir string
+				switch entry.Kind {
+				case "app":
+					kindDir = "apps"
+				case "module":
+					kindDir = "packages"
+				case "theme":
+					kindDir = "themes"
+				}
 
-	if pkg.Kind == "app" {
-		payload.Config.Apps = append(payload.Config.Apps, pkg.Name)
-	} else if pkg.Kind == "module" {
-		payload.Config.Modules = append(payload.Config.Modules, pkg.Name)
-	} else if pkg.Kind == "theme" {
-		payload.Config.Theme = &pkg.Name
-	}
+				// 1. Git behind check (NO fetch — uses cached remote refs)
+				if kindDir != "" {
+					pkgPath := filepath.Join(m.workspaceRoot, kindDir, short)
+					gitDir := filepath.Join(pkgPath, ".git")
+					if _, err := os.Stat(gitDir); err == nil {
+						behind, err := runGitBehindCheckNoFetch(pkgPath)
+						if err == nil && behind > 0 {
+							res.update = &UpdateInfo{LocalGit: true, BehindCount: behind}
+						}
+					}
+				}
 
-	if err := bridge.WriteChanges(m.workspaceRoot, payload); err != nil {
-		m.taskActive = false
-		m.statusMsg = fmt.Sprintf("Install failed: %v", err)
-		return m, nil
-	}
-	if Program != nil {
-		m.RunInstallTask(pkg.Name, method, Program)
-	}
-	return m, nil
-}
-
-func (m TuiModel) triggerForceReinstall(pkg *bridge.CatalogEntry) (tea.Model, tea.Cmd) {
-	m.taskActive = true
-	m.statusMsg = fmt.Sprintf("Force reinstalling %s…", pkg.ShortName)
-	m.addLog(fmt.Sprintf(">>> Deleting local folder and reinstalling %s", pkg.Name))
-
-	// Delete local folder
-	short := pkg.ShortName
-	kindDir := ""
-	switch pkg.Kind {
-	case "app":
-		kindDir = "apps"
-	case "module":
-		kindDir = "packages"
-	case "theme":
-		kindDir = "themes"
-	}
-	if kindDir != "" {
-		pkgPath := filepath.Join(m.workspaceRoot, kindDir, short)
-		m.addLog(fmt.Sprintf(">>> Removing directory: %s", pkgPath))
-		_ = os.RemoveAll(pkgPath)
-	}
-
-	// Reinstall using the original source method
-	method := "npm"
-	if pkg.LocalSource {
-		if m.ctx != nil && m.ctx.Settings.LastInstallChoices != nil {
-			if choice, exists := m.ctx.Settings.LastInstallChoices[pkg.Name]; exists {
-				if choiceMap, ok := choice.(map[string]interface{}); ok {
-					if gitUrl, hasGit := choiceMap["gitUrl"].(string); hasGit {
-						if strings.HasPrefix(gitUrl, "git@") {
-							method = "git-ssh"
-						} else {
-							method = "git-https"
-						}
-					}
-				}
-			}
-		}
-	}
-
-	if Program != nil {
-		m.RunInstallTask(pkg.Name, method, Program)
-	}
-	return m, nil
-}
-
-func (m TuiModel) triggerUpdate(pkg *bridge.CatalogEntry) (tea.Model, tea.Cmd) {
-	m.taskActive = true
-	m.statusMsg = fmt.Sprintf("Updating %s…", pkg.ShortName)
-	m.addLog(fmt.Sprintf(">>> Updating %s", pkg.Name))
-
-	if Program != nil {
-		go func() {
-			short := pkg.ShortName
-			kindDir := ""
-			switch pkg.Kind {
-			case "app":
-				kindDir = "apps"
-			case "module":
-				kindDir = "packages"
-			case "theme":
-				kindDir = "themes"
-			}
-			if kindDir != "" {
-				pkgPath := filepath.Join(m.workspaceRoot, kindDir, short)
-				gitDir := filepath.Join(pkgPath, ".git")
-				if _, err := os.Stat(gitDir); err == nil {
-					Program.Send(logLineMsg(">>> Local Git repository detected. Running git pull…"))
-					runProcessAndStreamLogs(pkgPath, "git", []string{"pull"}, Program)
-					Program.Send(taskFinishedMsg{Success: true})
-					return
-				}
-			}
-
-			Program.Send(logLineMsg(fmt.Sprintf(">>> Running pnpm install %s@latest…", pkg.Name)))
-			runProcessAndStreamLogs(m.workspaceRoot, "pnpm", []string{"install", pkg.Name + "@latest"}, Program)
-			Program.Send(logLineMsg(">>> Preparing workspace modules…"))
-			runProcessAndStreamLogs(m.workspaceRoot, "pnpm", []string{"run", "prepare:modules"}, Program)
-			Program.Send(taskFinishedMsg{Success: true})
-		}()
-	}
-	return m, nil
-}
-
-// ─────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────
-
-func (m TuiModel) getActiveItems() []bridge.CatalogEntry {
-	if m.catalog == nil {
-		return nil
-	}
-	var res []bridge.CatalogEntry
-	for _, e := range m.catalog.Entries {
-		switch m.activeTab {
-		case 0: // Internal
-			if e.Kind == "module" && !strings.HasPrefix(e.ShortName, "module-") {
-				res = append(res, e)
-			}
-		case 1: // Apps
-			if e.Kind == "app" {
-				res = append(res, e)
-			}
-		case 2: // Modules
-			if e.Kind == "module" && strings.HasPrefix(e.ShortName, "module-") {
-				res = append(res, e)
-			}
-		case 3: // Themes
-			if e.Kind == "theme" {
-				res = append(res, e)
-			}
-		}
-	}
-	return res
-}
-
-func sparkline(vals []int) string {
-	blocks := []rune{'\u2581', '\u2582', '\u2583', '\u2584', '\u2585', '\u2586', '\u2587', '\u2588'}
-	if len(vals) == 0 {
-		mutedBar := lipgloss.NewStyle().Foreground(colorDim).Render(string('\u2581'))
-		return strings.Repeat(mutedBar, 12)
-	}
-
-	min := vals[0]
-	max := vals[0]
-	for _, v := range vals {
-		if v < min {
-			min = v
-		}
-		if v > max {
-			max = v
-		}
-	}
-
-	var sb strings.Builder
-	show := vals
-	if len(show) > 12 {
-		show = show[len(show)-12:]
-	}
-
-	for _, v := range show {
-		var idx int
-		if max == min {
-			if v == 0 {
-				idx = 0
-			} else {
-				idx = 2
-			}
-		} else {
-			idx = int(float64(v-min) / float64(max-min) * float64(len(blocks)-1))
-			if idx < 0 {
-				idx = 0
-			}
-			if idx >= len(blocks) {
-				idx = len(blocks) - 1
-			}
-		}
-
-		var color lipgloss.Color
-		if v == 0 {
-			color = colorDim
-		} else {
-			if v > 1024 {
-				color = colorErr
-			} else if v > 512 {
-				color = colorWarn
-			} else {
-				color = colorCyan
-			}
-		}
-
-		styledRune := lipgloss.NewStyle().Foreground(color).Render(string(blocks[idx]))
-		sb.WriteString(styledRune)
-	}
-	return sb.String()
-}
-
-func gitBranch(root string) string {
-	out, err := exec.Command("git", "-C", root, "rev-parse", "--abbrev-ref", "HEAD").Output()
-	if err != nil {
-		return "—"
-	}
-	return strings.TrimSpace(string(out))
-}
-
-func gitChanges(root string) string {
-	out, err := exec.Command("git", "-C", root, "status", "--porcelain").Output()
-	if err != nil {
-		return "unknown"
-	}
-	lines := strings.Split(strings.TrimSpace(string(out)), "\n")
-	if len(lines) == 0 || (len(lines) == 1 && lines[0] == "") {
-		return "clean"
-	}
-	mod, add, del := 0, 0, 0
-	for _, l := range lines {
-		if len(l) < 2 {
-			continue
-		}
-		switch {
-		case strings.HasPrefix(l, "??"):
-			add++
-		case strings.HasPrefix(l, " D") || strings.HasPrefix(l, "D "):
-			del++
-		default:
-			mod++
-		}
-	}
-	var parts []string
-	if add > 0 {
-		parts = append(parts, accentStyle.Render(fmt.Sprintf("+%d", add)))
-	}
-	if mod > 0 {
-		parts = append(parts, warnStyle.Render(fmt.Sprintf("~%d", mod)))
-	}
-	if del > 0 {
-		parts = append(parts, errStyle.Render(fmt.Sprintf("-%d", del)))
-	}
-	if len(parts) == 0 {
-		return "clean"
-	}
-	return strings.Join(parts, " ")
-}
-
-func countLocalDirs(root, subdir string, excludePrefixes ...string) int {
-	dir := filepath.Join(root, subdir)
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return 0
-	}
-	count := 0
-	for _, e := range entries {
-		if !e.IsDir() || strings.HasPrefix(e.Name(), ".") {
-			continue
-		}
-		skip := false
-		for _, pf := range excludePrefixes {
-			if strings.HasPrefix(e.Name(), pf) {
-				skip = true
-				break
-			}
-		}
-		if !skip {
-			count++
-		}
-	}
-	return count
-}
-
-func truncate(s string, max int) string {
-	if len(s) <= max {
-		return s
-	}
-	return s[:max-1] + "…"
-}
-
-func padRight(s string, width int) string {
-	if len(s) >= width {
-		return s[:width]
-	}
-	return s + strings.Repeat(" ", width-len(s))
-}
-
-func padLeft(s string, width int) string {
-	if len(s) >= width {
-		return s[:width]
-	}
-	return strings.Repeat(" ", width-len(s)) + s
-}
-
-func formatCatalogAge(iso *string) string {
-	if iso == nil || *iso == "" {
-		return ""
-	}
-	t, err := time.Parse(time.RFC3339, *iso)
-	if err != nil {
-		t, err = time.Parse("2006-01-02T15:04:05.000Z", *iso)
-		if err != nil {
-			t, err = time.Parse("2006-01-02T15:04:05Z", *iso)
-			if err != nil {
-				return ""
-			}
-		}
-	}
-	duration := time.Since(t)
-	days := int(duration.Hours() / 24)
-	if days < 0 {
-		return "<1d"
-	}
-	if days < 1 {
-		return "<1d"
-	}
-	if days < 7 {
-		return fmt.Sprintf("%dd", days)
-	}
-	if days < 30 {
-		return fmt.Sprintf("%dw", days/7)
-	}
-	return fmt.Sprintf("%dmo", days/30)
-}
-
-// overlayCenter renders `overlay` centered on top of `bg` (both already rendered, ANSI-aware widths).
-func overlayCenter(bg, overlay string) string {
-	bgLines := strings.Split(bg, "\n")
-	ovLines := strings.Split(overlay, "\n")
-	bgH := len(bgLines)
-	ovH := len(ovLines)
-	bgW := 0
-	for _, l := range bgLines {
-		if w := lipgloss.Width(l); w > bgW {
-			bgW = w
-		}
-	}
-	ovW := 0
-	for _, l := range ovLines {
-		if w := lipgloss.Width(l); w > ovW {
-			ovW = w
-		}
-	}
-	topPad := (bgH - ovH) / 2
-	leftPad := (bgW - ovW) / 2
-	if leftPad < 0 {
-		leftPad = 0
-	}
-	out := make([]string, bgH)
-	copy(out, bgLines)
-	for i, ovLine := range ovLines {
-		row := topPad + i
-		if row < 0 || row >= bgH {
-			continue
-		}
-		bg := out[row]
-		bgVisible := lipgloss.Width(bg)
-		// pad bg line to bgW if shorter
-		if bgVisible < bgW {
-			bg = bg + strings.Repeat(" ", bgW-bgVisible)
-		}
-		// split bg into runes accounting for ANSI — use a simple approach:
-		// write leftPad chars of bg, then overlay line, then rest of bg
-		bgStripped := lipgloss.NewStyle().Render(bg) // no-op, keeps ansi
-		// For simplicity: rebuild as left + overlay + right using byte slicing on stripped
-		// We use lipgloss.Width-aware padding approach
-		prefix := strings.Repeat(" ", leftPad)
-		suffix := ""
-		rightStart := leftPad + ovW
-		if rightStart < bgW {
-			suffix = strings.Repeat(" ", bgW-rightStart)
-		}
-		_ = bgStripped
-		out[row] = prefix + ovLine + suffix
-	}
-	return strings.Join(out, "\n")
-}
-
-// ─────────────────────────────────────────────
-// Rendering helpers
-// ─────────────────────────────────────────────
-
-// Panel drawing helper with border labels
-func drawPanel(w, h int, title string, content string, active bool) string {
-	style := panelBorderStyle
-	if active {
-		style = panelBorderActive
-	}
-
-	// Ensure the style has the correct dimensions
-	style = style.Width(w - 2).Height(h - 2)
-
-	rendered := style.Render(content)
-
-	if title == "" {
-		return rendered
-	}
-
-	// If the title contains escape sequences, use it as is; otherwise format as bold white
-	var styledTitle string
-	if strings.Contains(title, "\x1b") {
-		styledTitle = title
-	} else {
-		styledTitle = lipgloss.NewStyle().Foreground(colorWhite).Bold(true).Render(title)
-	}
-
-	titleFmt := " " + styledTitle + " "
-	titleWidth := lipgloss.Width(titleFmt)
-
-	// Replace the first line's center with the title
-	lines := strings.Split(rendered, "\n")
-	if len(lines) > 0 {
-		borderColor := colorBorder
-		if active {
-			borderColor = colorBorderAct
-		}
-
-		dashCount := w - 3 - titleWidth
-		if dashCount < 2 {
-			dashCount = 2
-		}
-
-		borderStyle := lipgloss.NewStyle().Foreground(borderColor)
-
-		topBorder := borderStyle.Render("╭─") +
-			titleFmt +
-			borderStyle.Render(strings.Repeat("─", dashCount)+"╮")
-
-		lines[0] = topBorder
-		rendered = strings.Join(lines, "\n")
-	}
-
-	return rendered
-}
-
-type WorkspaceVersions struct {
-	Nuxt string
-	Pnpm string
-	Owd  string
-}
-
-func getVersions(root string, workspaceRoot string) WorkspaceVersions {
-	vers := WorkspaceVersions{Nuxt: "—", Pnpm: "—", Owd: "—"}
-	
-	// Read root package.json (monorepo or playground package)
-	rootPkgPath := filepath.Join(root, "package.json")
-	if data, err := os.ReadFile(rootPkgPath); err == nil {
-		lines := strings.Split(string(data), "\n")
-		for _, l := range lines {
-			if strings.Contains(l, `"packageManager"`) && strings.Contains(l, "pnpm@") {
-				parts := strings.Split(l, "pnpm@")
-				if len(parts) >= 2 {
-					vers.Pnpm = strings.Trim(parts[1], " \t\r\n,\"")
-					vers.Pnpm = strings.ReplaceAll(vers.Pnpm, `"`, "")
-					vers.Pnpm = strings.TrimSpace(vers.Pnpm)
-				}
-			}
-			if strings.Contains(l, `"nuxt"`) {
-				parts := strings.Split(l, ":")
-				if len(parts) >= 2 {
-					v := strings.Trim(parts[1], " \t\r\n,\"^~")
-					v = strings.ReplaceAll(v, `"`, "")
-					vers.Nuxt = strings.TrimSpace(v)
-				}
-			}
-		}
-	}
-	
-	// Read OWD Core version from workspaceRoot/packages/core/package.json
-	corePkgPath := filepath.Join(workspaceRoot, "packages", "core", "package.json")
-	if data, err := os.ReadFile(corePkgPath); err == nil {
-		lines := strings.Split(string(data), "\n")
-		for _, l := range lines {
-			if strings.Contains(l, `"version"`) {
-				parts := strings.Split(l, ":")
-				if len(parts) >= 2 {
-					v := strings.Trim(parts[1], " \t\r\n,\"")
-					v = strings.ReplaceAll(v, `"`, "")
-					vers.Owd = strings.TrimSpace(v)
-					break
-				}
-			}
-		}
-	}
-	
-	return vers
-}
-
-func getProcessMemoryMB(pid int) int {
-	if pid <= 0 {
-		return 0
-	}
-	path := fmt.Sprintf("/proc/%d/status", pid)
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return 0
-	}
-	lines := strings.Split(string(data), "\n")
-	for _, l := range lines {
-		if strings.HasPrefix(l, "VmRSS:") {
-			fields := strings.Fields(l)
-			if len(fields) >= 2 {
-				var kb int
-				if _, err := fmt.Sscanf(fields[1], "%d", &kb); err == nil {
-					return kb / 1024
-				}
-			}
-		}
-	}
-	return 0
-}
-
-func renderPanelTitle(title string) string {
-	return lipgloss.NewStyle().
-		Foreground(colorWhite).
-		Bold(true).
-		Render(title)
-}
-
-func kv(label, value string) string {
-	return mutedStyle.Render(padRight(label, 10)) + " " + boldStyle.Render(value)
-}
-
-func kvRaw(label, value string) string {
-	return mutedStyle.Render(padRight(label, 10)) + " " + value
-}
-
-func pill(text string, color lipgloss.Color) string {
-	return lipgloss.NewStyle().Foreground(color).Bold(true).Render(text)
-}
-
-// ─────────────────────────────────────────────
-// View
-// ─────────────────────────────────────────────
-
-func (m TuiModel) View() string {
-	w := m.termWidth
-	h := m.termHeight
-	if w < 40 {
-		w = 40
-	}
-	if h < 10 {
-		h = 10
-	}
-
-	showLogs := (m.serverRunning || m.taskActive) && w >= 120
-
-	// Heights
-	topH := 9    // top panels row (with borders = 9 rows)
-	barH := 4    // status bar lines (including prepended/trailing newlines)
-	// catalog gets the remaining height
-	catalogH := h - topH - barH
-	if catalogH < 4 {
-		catalogH = 4
-	}
-
-	// Column widths (including borders each panel takes +2 cols)
-	var leftW, midW, rightW int
-	if showLogs {
-		// 40% | 28% | 32%  — roughly matching original blessed layout
-		rightW = w * 32 / 100
-		leftW  = w * 40 / 100
-		midW   = w - leftW - rightW
-	} else {
-		leftW = w * 58 / 100
-		midW  = w - leftW
-		rightW = 0
-	}
-
-	// ── Render panel contents ─────────────────────────────
-	leftContent := m.renderClientPanel(leftW-4, topH-2)
-	midContent  := m.renderMetricsPanel(midW-4, topH-2)
-
-	desktopTitle := lipgloss.NewStyle().Foreground(colorAccent).Bold(true).Render("Desktop") + " " +
-		lipgloss.NewStyle().Foreground(colorMuted).Render("control panel")
-
-	var topRow, mainContent, catalogPanel string
-
-	if showLogs {
-		catW := leftW + midW
-		logContent := m.renderLogsPanel(rightW-4, h-barH-2)
-
-		// Top 2-panel row (left + mid)
-		topTwoPanels := lipgloss.JoinHorizontal(lipgloss.Top,
-			drawPanel(leftW-1, topH, desktopTitle, leftContent, false),
-			drawPanel(midW, topH, "Metrics", midContent, false),
-		)
-
-		// Catalog panel — always rendered; modal overlaid on top if active
-		catalogContent := m.renderCatalogPanel(catW-4, catalogH-2, showLogs)
-		catalogPanel = drawPanel(catW-1, catalogH, "Catalog", catalogContent, true)
-		if m.activePrompt != PromptNone {
-			modal := m.renderModal()
-			styledModal := lipgloss.NewStyle().
-				Border(lipgloss.RoundedBorder()).
-				BorderForeground(colorCyan).
-				Padding(1, 3).
-				Render(modal)
-			catalogPanel = overlayCenter(catalogPanel, styledModal)
-		}
-
-		// Left main block = top panels + catalog stacked
-		leftMain := lipgloss.JoinVertical(lipgloss.Left, topTwoPanels, catalogPanel)
-
-		// Right logs panel, spans full height
-		logsPanel := drawPanel(rightW, h-barH, "Logs", logContent, false)
-
-		topRow = lipgloss.JoinHorizontal(lipgloss.Top, leftMain, logsPanel)
-		mainContent = topRow
-	} else {
-		// No logs: top row = left + right panels side by side
-		topBlock := lipgloss.JoinHorizontal(lipgloss.Top,
-			drawPanel(leftW-1, topH, desktopTitle, leftContent, false),
-			drawPanel(midW, topH, "Metrics", midContent, false),
-		)
-
-		// Catalog full width — always rendered; modal overlaid on top if active
-		catalogContent := m.renderCatalogPanel(w-4, catalogH-2, showLogs)
-		catalogPanel = drawPanel(w, catalogH, "Catalog", catalogContent, true)
-		if m.activePrompt != PromptNone {
-			modal := m.renderModal()
-			styledModal := lipgloss.NewStyle().
-				Border(lipgloss.RoundedBorder()).
-				BorderForeground(colorCyan).
-				Padding(1, 3).
-				Render(modal)
-			catalogPanel = overlayCenter(catalogPanel, styledModal)
-		}
-
-		mainContent = lipgloss.JoinVertical(lipgloss.Left, topBlock, catalogPanel)
-	}
-
-	// ── Status bar (borderless) ───────────────────────────
-	statusBar := m.renderStatusBar(w)
-
-	return mainContent + statusBar
-}
-
-// ─────────────────────────────────────────────
-// Panel: Desktop Control Panel (left)
-// ─────────────────────────────────────────────
-
-func (m TuiModel) renderClientPanel(w, h int) string {
-	var lines []string
-
-	// Server status line
-	var statusLine string
-	if m.taskActive && strings.Contains(strings.ToLower(m.statusMsg), "stopping") {
-		spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-		frame := spinnerFrames[m.tickCount%len(spinnerFrames)]
-		dot := lipgloss.NewStyle().Foreground(colorWarn).Bold(true).Render(frame)
-		statusLine = dot + " " + boldStyle.Render("STOPPING") + "  " + mutedStyle.Render("http://localhost:3000")
-	} else if m.taskActive && strings.Contains(strings.ToLower(m.statusMsg), "starting") {
-		spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-		frame := spinnerFrames[m.tickCount%len(spinnerFrames)]
-		dot := lipgloss.NewStyle().Foreground(colorCyan).Bold(true).Render(frame)
-		statusLine = dot + " " + boldStyle.Render("STARTING") + "  " + mutedStyle.Render("http://localhost:3000")
-	} else if m.serverRunning {
-		dot := accentStyle.Render("●")
-		if m.blink {
-			dot = lipgloss.NewStyle().Foreground(lipgloss.Color("#2ea043")).Bold(true).Render("●")
-		}
-		url := lipgloss.NewStyle().Foreground(colorCyan).Render("http://localhost:3000")
-		statusLine = dot + " " + boldStyle.Render("RUNNING") + "   " + url
-		if m.ctx != nil {
-			_ = m.ctx
-		}
-	} else if m.taskActive {
-		spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-		frame := spinnerFrames[m.tickCount%len(spinnerFrames)]
-		dot := lipgloss.NewStyle().Foreground(colorWarn).Bold(true).Render(frame)
-		statusLine = dot + " " + boldStyle.Render("STARTING") + "  " + mutedStyle.Render("http://localhost:3000")
-	} else {
-		dot := errStyle.Render("○")
-		statusLine = dot + " " + boldStyle.Render("STOPPED") + "   " + mutedStyle.Render("http://localhost:3000")
-	}
-	lines = append(lines, "  "+statusLine)
-	lines = append(lines, "") // Space out server status line
-	lines = append(lines, mutedStyle.Render("  System     ")+boldStyle.Render("ready"))
-
-	// Theme
-	theme := "—"
-	if m.ctx != nil && m.ctx.Config.Theme != nil && *m.ctx.Config.Theme != "" {
-		t := *m.ctx.Config.Theme
-		if idx := strings.LastIndex(t, "/"); idx >= 0 {
-			t = t[idx+1:]
-		}
-		theme = t
-	}
-	lines = append(lines, mutedStyle.Render("  Theme      ")+boldStyle.Render(theme))
-
-	// Workspace
-	wsPath := "—"
-	if m.ctx != nil {
-		if m.ctx.Paths.IsPlayground {
-			wsPath = strings.Replace(m.ctx.Paths.Desktop, os.Getenv("HOME"), "~", 1)
-		} else {
-			wsPath = strings.Replace(m.ctx.WorkspaceRoot, os.Getenv("HOME"), "~", 1)
-		}
-	} else if m.workspaceRoot != "" {
-		wsPath = strings.Replace(m.workspaceRoot, os.Getenv("HOME"), "~", 1)
-	}
-	wsPath = truncate(wsPath, w-14)
-	lines = append(lines, mutedStyle.Render("  Workspace  ")+boldStyle.Render(wsPath))
-
-	// Git
-	root := m.workspaceRoot
-	workspaceRoot := m.workspaceRoot
-	if m.ctx != nil {
-		workspaceRoot = m.ctx.WorkspaceRoot
-		if m.ctx.Paths.IsPlayground {
-			root = m.ctx.Paths.PackageDir
-		} else {
-			root = m.ctx.WorkspaceRoot
-		}
-	}
-	branch := gitBranch(root)
-	changes := gitChanges(root)
-	gitLine := "branch: " + accentStyle.Render(branch) + "  ·  changes: " + changes
-	lines = append(lines, mutedStyle.Render("  Git        ")+gitLine)
-
-	// Versions
-	vers := getVersions(root, workspaceRoot)
-	lines = append(lines, mutedStyle.Render("  Runtime    ")+boldStyle.Render(fmt.Sprintf("Nuxt v%s  ·  OWD v%s  ·  pnpm v%s", vers.Nuxt, vers.Owd, vers.Pnpm)))
-
-	content := strings.Join(lines, "\n")
-	return content
-}
-
-// ─────────────────────────────────────────────
-// Panel: Metrics (right of control panel)
-// ─────────────────────────────────────────────
-
-func (m TuiModel) renderMetricsPanel(w, h int) string {
-	var lines []string
-
-	// Memory sparkline
-	spark := sparkline(m.memHistory)
-	memVal := "—"
-	if len(m.memHistory) > 0 && m.memHistory[len(m.memHistory)-1] > 0 {
-		memVal = fmt.Sprintf("%d MiB", m.memHistory[len(m.memHistory)-1])
-	}
-	memLine := mutedStyle.Render(padRight("Memory", 9)) + " " + boldStyle.Render(memVal) + "  " + spark
-	lines = append(lines, "  "+memLine)
-
-	// Local stats
-	root := m.workspaceRoot
-	if m.ctx != nil {
-		root = m.ctx.WorkspaceRoot
-	}
-	localApps := countLocalDirs(root, "apps")
-	localMods := countLocalDirs(root, "packages", "core", "nx", "kit-", "cli")
-	localThemes := countLocalDirs(root, "themes")
-	localLine := mutedStyle.Render(padRight("Local", 9)) + " " +
-		boldStyle.Render(fmt.Sprintf("%d", localApps)) + mutedStyle.Render(" apps · ") +
-		boldStyle.Render(fmt.Sprintf("%d", localMods)) + mutedStyle.Render(" modules · ") +
-		boldStyle.Render(fmt.Sprintf("%d", localThemes)) + mutedStyle.Render(" themes")
-	lines = append(lines, "  "+localLine)
-
-	// Registry stats
-	totalStars := 0
-	if m.catalog != nil {
-		for _, e := range m.catalog.Entries {
-			totalStars += e.Stars
-		}
-	}
-	catCount := "loading…"
-	cacheAge := ""
-	if m.catalog != nil {
-		catCount = fmt.Sprintf("%d pkgs", len(m.catalog.Entries))
-		cacheAge = m.catalog.CacheAge
-	}
-	regLine := mutedStyle.Render(padRight("Registry", 9)) + " " +
-		boldStyle.Render(fmt.Sprintf("%d", totalStars)) + mutedStyle.Render(" stars")
-	lines = append(lines, "  "+regLine)
-
-	// GitHub user
-	ghUser := "(not set)"
-	sshText := warnStyle.Render("HTTPS")
-	if m.ctx != nil && m.ctx.Settings.GithubUser != nil {
-		ghUser = *m.ctx.Settings.GithubUser
-		sshText = mutedStyle.Render("SSH ok")
-	}
-	ghLine := mutedStyle.Render(padRight("GitHub", 9)) + " " + boldStyle.Render(ghUser) + " · " + sshText
-	lines = append(lines, "  "+ghLine)
-
-	// Catalog
-	catalogLine := mutedStyle.Render(padRight("Catalog", 9)) + " " + boldStyle.Render(catCount)
-	if cacheAge != "" {
-		catalogLine += " " + mutedStyle.Render("("+cacheAge+")")
-	}
-	lines = append(lines, "  "+catalogLine)
-
-	// Divider + tip
-	lines = append(lines, "  "+subtleStyle.Render(strings.Repeat("─", w-2)))
-
-	tips := []string{
-		"Press 1, 2, or 3 to switch catalog tabs",
-		"Press [s] to start the dev server",
-		"Press [Enter] to install / uninstall a package",
-		"Press [c] to change the install source",
-		"Press [r] to refresh the package catalog",
-	}
-	tipIdx := (m.tickCount / 6) % len(tips)
-	tipText := "Tip: " + tips[tipIdx]
-	tipLine := subtleStyle.Render(truncate(tipText, w-4))
-	lines = append(lines, "  "+tipLine)
-
-	return strings.Join(lines, "\n")
-}
-
-// ─────────────────────────────────────────────
-// Panel: Catalog
-// ─────────────────────────────────────────────
-
-func (m TuiModel) renderCatalogPanel(w, h int, _ bool) string {
-	var lines []string
-
-	// Tabs row
-	var tabLine strings.Builder
-	tabLine.WriteString(" ")
-	if m.activeTab == 0 {
-		tabLine.WriteString(tabActiveStyle.Render("0 Internal") + "  ")
-	}
-	tabs := []string{"Apps", "Modules", "Themes"}
-	for i, t := range tabs {
-		tabIdx := i + 1
-		num := fmt.Sprintf("%d", tabIdx)
-		if tabIdx == m.activeTab {
-			tabLine.WriteString(tabActiveStyle.Render(num + " " + t))
-		} else {
-			tabLine.WriteString(tabInactiveStyle.Render(num + " " + t))
-		}
-		if i < len(tabs)-1 {
-			tabLine.WriteString("  ")
-		}
-	}
-	sortLabel := "  " + mutedStyle.Render("│") + " " + mutedStyle.Render("Sort: Updated")
-	if m.loading {
-		spinFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-		spin := lipgloss.NewStyle().Foreground(colorCyan).Render(spinFrames[m.tickCount%len(spinFrames)])
-		sortLabel += "  " + spin
-	}
-	tabLine.WriteString(sortLabel)
-	lines = append(lines, tabLine.String())
-
-	// Column header (proportional to width)
-	nameW := 26
-	if w > 120 {
-		nameW = 30
-	}
-	colHeader := "  " + lipgloss.NewStyle().Foreground(colorSubtle).Render(
-		padRight("", 2) + "  " + // badge space
-			padRight("NAME", nameW) + "  " +
-			padRight("SRC", 5) + "  " +
-			padRight("DIR", 5) + "  " +
-			padRight("SYNC", 6) + "  " +
-			padRight("PUBLISHER", 14) + "  " +
-			padLeft("STARS/AGE", 14),
-	)
-	lines = append(lines, colHeader)
-	lines = append(lines, "  "+subtleStyle.Render(strings.Repeat("─", max(w-2, 4))))
-
-	// Item list — reserve 4 rows for: header, col header, divider above detail, detail itself
-	detailLines := 2
-	fixedRows := 4 // tabrow + colheader + topdivider + bottomdivider
-	listH := h - fixedRows - detailLines
-	if listH < 1 {
-		listH = 1
-	}
-
-	items := m.getActiveItems()
-
-	// Clamp scroll
-	scrollOff := m.scrollOffset
-	if m.selectedIndex >= scrollOff+listH {
-		scrollOff = m.selectedIndex - listH + 1
-	}
-	if scrollOff < 0 {
-		scrollOff = 0
-	}
-
-	if len(items) == 0 {
-		if m.loading {
-			lines = append(lines, "  "+mutedStyle.Render("Loading packages…"))
-		} else {
-			lines = append(lines, "  "+mutedStyle.Render("No packages found."))
-		}
-	} else {
-		start := scrollOff
-		end := start + listH
-		if end > len(items) {
-			end = len(items)
-		}
-		for i := start; i < end; i++ {
-			item := items[i]
-			line := m.renderCatalogRow(item, i == m.selectedIndex, w, nameW)
-			lines = append(lines, line)
-		}
-		// Padding to fill listH
-		for i := end - start; i < listH; i++ {
-			lines = append(lines, "")
-		}
-	}
-
-	// Detail panel at bottom
-	lines = append(lines, "  "+subtleStyle.Render(strings.Repeat("─", max(w-2, 4))))
-	detail := m.renderDetailRow(items)
-	lines = append(lines, detail)
-
-	return strings.Join(lines, "\n")
-}
-
-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}
-
-func (m TuiModel) renderCatalogRow(item bridge.CatalogEntry, selected bool, w, nameW int) string {
-	badge := uninstalledBadge + " "
-	if item.Installed {
-		badge = installedBadge + " "
-	}
-
-	name := truncate(item.ShortName, nameW)
-
-	// Source badge
-	src := "NPM"
-	srcColor := colorNpm
-	if item.LocalSource {
-		src = "LOC"
-		srcColor = colorLocal
-	} else if item.Installed && !item.LocalSource {
-		src = "GIT"
-		srcColor = colorGit
-	}
-	srcStr := lipgloss.NewStyle().Foreground(srcColor).Bold(true).Render(src)
-	srcPad := strings.Repeat(" ", max(0, 5-lipgloss.Width(srcStr)))
-
-	dir := subtleStyle.Render("---")
-	if item.Installed && !item.LocalSource {
-		dir = errStyle.Bold(true).Render("MISS")
-	} else if item.LocalSource {
-		dir = accentStyle.Render("OK")
-	}
-	dirPad := strings.Repeat(" ", max(0, 5-lipgloss.Width(dir)))
-
-	sync := subtleStyle.Render("---")
-	var syncParts []string
-	if item.LocalSource {
-		if ch, hasChanges := m.gitChangesMap[item.ShortName]; hasChanges {
-			if ch.Added > 0 {
-				syncParts = append(syncParts, accentStyle.Render(fmt.Sprintf("+%d", ch.Added)))
-			}
-			if ch.Modified > 0 {
-				syncParts = append(syncParts, warnStyle.Render(fmt.Sprintf("~%d", ch.Modified)))
-			}
-			if ch.Deleted > 0 {
-				syncParts = append(syncParts, errStyle.Render(fmt.Sprintf("-%d", ch.Deleted)))
-			}
-		}
-	}
-	if up, hasUpdate := m.updatesMap[item.ShortName]; hasUpdate {
-		if up.LocalGit {
-			countStr := ""
-			if up.BehindCount > 0 {
-				countStr = fmt.Sprintf("%d", up.BehindCount)
-			}
-			syncParts = append(syncParts, cyanStyle.Render("↓"+countStr))
-		} else if up.Npm {
-			syncParts = append(syncParts, accentStyle.Render("↑"))
-		}
-	}
-	if len(syncParts) > 0 {
-		sync = strings.Join(syncParts, " ")
-	}
-	syncPad := strings.Repeat(" ", max(0, 6-lipgloss.Width(sync)))
-
-	pub := item.Org
-	if pub == "workspace" || pub == "" {
-		pub = "owdproject"
-	}
-	pubFmt := padRight(truncate(pub, 14), 14)
-
-	age := formatCatalogAge(item.UpdatedAt)
-	starsStr := ""
-	if item.Stars > 0 {
-		starsStr = fmt.Sprintf("★%d", item.Stars)
-	}
-
-	metaStr := ""
-	if starsStr != "" && age != "" {
-		metaStr = warnStyle.Render(starsStr) + " " + subtleStyle.Render(age)
-	} else if starsStr != "" {
-		metaStr = warnStyle.Render(starsStr)
-	} else if age != "" {
-		metaStr = subtleStyle.Render(age)
-	} else {
-		metaStr = subtleStyle.Render("—")
-	}
-
-	metaW := lipgloss.Width(metaStr)
-	metaPad := ""
-	if metaW < 14 {
-		metaPad = strings.Repeat(" ", 14-metaW)
-	}
-	metaFmt := metaPad + metaStr
-
-	nameFmt := padRight(name, nameW)
-
-	row := fmt.Sprintf("  %s  %s  %s%s  %s%s  %s%s  %s  %s",
-		badge,
-		nameFmt,
-		srcStr,
-		srcPad,
-		dir,
-		dirPad,
-		sync,
-		syncPad,
-		pubFmt,
-		metaFmt,
-	)
-
-	if selected {
-		return selectedRowStyle.Render("▶ " + strings.TrimPrefix(row, "  "))
-	}
-	return row
-}
-
-func (m TuiModel) renderDetailRow(items []bridge.CatalogEntry) string {
-	if len(items) == 0 || m.selectedIndex >= len(items) {
-		return "  " + mutedStyle.Render("Select a package for install preview")
-	}
-	item := items[m.selectedIndex]
-
-	status := mutedStyle.Render("Not Installed")
-	if item.Installed {
-		status = accentStyle.Render("Installed")
-		if item.LocalSource {
-			status += " " + lipgloss.NewStyle().Foreground(colorLocal).Render("(workspace)")
-		}
-	}
-
-	desc := item.Description
-	if desc == "" {
-		desc = "—"
-	}
-	desc = truncate(desc, 60)
-
-	org := item.Org
-	if org == "workspace" || org == "" {
-		org = "owdproject"
-	}
-
-	stars := fmt.Sprintf("%d", item.Stars)
-	kind := strings.ToUpper(item.Kind)
-
-	parts := []string{
-		accentStyle.Render(item.ShortName),
-		"  " + mutedStyle.Render("Publisher:") + " " + boldStyle.Render(org),
-		"  " + mutedStyle.Render("Stars:") + " " + boldStyle.Render(stars),
-		"  " + mutedStyle.Render("Status:") + " " + status,
-		"  " + mutedStyle.Render("Type:") + " " + boldStyle.Render(kind),
-		"  " + mutedStyle.Render("—") + " " + mutedStyle.Render(desc),
-	}
-
-	return "  " + strings.Join(parts, " ")
-}
-
-// ─────────────────────────────────────────────
-// Panel: Logs (right column, when server running)
-// ─────────────────────────────────────────────
-
-func (m TuiModel) renderLogsPanel(w, h int) string {
-	var lines []string
-
-	lines = append(lines, "")
-
-	// Server URLs
-	if m.serverRunning {
-		dot := accentStyle.Render("●")
-		if !m.blink {
-			dot = lipgloss.NewStyle().Foreground(lipgloss.Color("#2ea043")).Render("●")
-		}
-
-		lines = append(lines, "  "+dot+" "+lipgloss.NewStyle().Foreground(colorAccent).Bold(true).Render("Dev server started"))
-		lines = append(lines, "")
-		lines = append(lines, "  "+accentStyle.Render("✓")+" "+mutedStyle.Render("Listening on http://localhost:3000"))
-		lines = append(lines, "")
-	}
-
-	// Log lines — show last N that fit
-	logH := h - len(lines) - 1
-	if logH < 1 {
-		logH = 1
-	}
-	logStart := len(m.logLines) - logH
-	if logStart < 0 {
-		logStart = 0
-	}
-	for i := logStart; i < len(m.logLines); i++ {
-		line := m.logLines[i]
-		line = truncate(line, w)
-		// Colorize log levels
-		switch {
-		case strings.Contains(line, "WARN") || strings.Contains(line, "Warning"):
-			lines = append(lines, warnStyle.Render("  "+line))
-		case strings.Contains(line, "ERROR") || strings.Contains(line, "Error") || strings.Contains(line, "failed"):
-			lines = append(lines, errStyle.Render("  "+line))
-		case strings.HasPrefix(line, ">>>"):
-			lines = append(lines, accentStyle.Render("  "+line))
-		case strings.Contains(line, "✓") || strings.Contains(line, "ready") || strings.Contains(line, "started"):
-			lines = append(lines, lipgloss.NewStyle().Foreground(colorAccent).Render("  "+line))
-		default:
-			lines = append(lines, mutedStyle.Render("  "+line))
-		}
-	}
-
-	if len(m.logLines) == 0 {
-		if m.serverRunning && ServerCmd == nil {
-			lines = append(lines, mutedStyle.Render("  Logs unavailable (external server)"))
-		} else {
-			lines = append(lines, mutedStyle.Render("  Waiting for logs…"))
-		}
-	}
-
-	return strings.Join(lines, "\n")
-}
-
-// ─────────────────────────────────────────────
-// Status Bar (borderless, Gemini-style)
-// ─────────────────────────────────────────────
-
-func (m TuiModel) renderStatusBar(w int) string {
-	// Line 1: current mode + status
-	mode := ""
-	switch m.activeTab {
-	case 0:
-		mode = "Apps"
-	case 1:
-		mode = "Modules"
-	case 2:
-		mode = "Themes"
-	}
-
-	statusIcon := ""
-	if m.serverRunning {
-		if m.blink {
-			statusIcon = lipgloss.NewStyle().Foreground(colorAccent).Render("● ")
-		} else {
-			statusIcon = lipgloss.NewStyle().Foreground(lipgloss.Color("#2ea043")).Render("● ")
-		}
-	}
-
-	line1Parts := []string{
-		statusIcon + barKeyStyle.Render("Select packages") + barStyle.Render(" · "),
-		barKeyStyle.Render("u") + barStyle.Render(" updates · "),
-		barKeyStyle.Render("g") + barStyle.Render(" settings"),
-	}
-
-	var serverShortcut string
-	if m.serverRunning {
-		serverShortcut = barKeyStyle.Render("x") + barStyle.Render(" stop server")
-	} else {
-		serverShortcut = barKeyStyle.Render("s") + barStyle.Render(" start server")
-	}
-
-	if m.taskActive {
-		spinFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-		spin := lipgloss.NewStyle().Foreground(colorCyan).Render(spinFrames[m.tickCount%len(spinFrames)])
-		line1Parts = []string{spin + " " + barStyle.Render(m.statusMsg)}
-	}
-
-	_ = mode
-	line1 := barStyle.Width(w).Render(strings.Join(line1Parts, ""))
-
-	// Line 2: shortcuts
-	sep := barSepStyle.Render(" │ ")
-	shortcutParts := []string{
-		barKeyStyle.Render("↑↓") + barStyle.Render(" move"),
-		barKeyStyle.Render("Space") + barStyle.Render(" toggle"),
-		barKeyStyle.Render("c") + barStyle.Render(" manage"),
-		serverShortcut,
-		barKeyStyle.Render("r") + barStyle.Render(" refresh"),
-		barKeyStyle.Render("q") + barStyle.Render(" quit"),
-	}
-	line2 := barStyle.Width(w).Render(strings.Join(shortcutParts, sep))
-
-	return "\n\n" + line1 + "\n" + line2 + "\n"
-}
-
-type InstallMethod struct {
-	Name  string
-	Label string
-	Desc  string
-}
-
-func (m TuiModel) getInstallMethods(pkg *bridge.CatalogEntry) []InstallMethod {
-	var methods []InstallMethod
-
-	// 0. Local folder option if already present in workspace (pkg.LocalSource is true)
-	if pkg.LocalSource {
-		methods = append(methods, InstallMethod{
-			Name:  "local",
-			Label: "Use Existing Local Folder",
-			Desc:  "Import/link the existing local folder in your workspace",
-		})
-	}
-
-	// 1. NPM Registry
-	if pkg.SourcesMeta != nil && pkg.SourcesMeta.Npm != nil {
-		methods = append(methods, InstallMethod{
-			Name:  "npm",
-			Label: "NPM Registry",
-			Desc:  "Install from npm (default)",
-		})
-	}
-
-	// 2. Git options
-	hasFork := false
-	forkOwner := ""
-	officialOwner := pkg.Org
-	if officialOwner == "" || officialOwner == "workspace" {
-		officialOwner = "owdproject"
-	}
-
-	if pkg.SourcesMeta != nil && pkg.SourcesMeta.Github.Fork != nil && pkg.SourcesMeta.Github.Fork.Exists {
-		// Only treat as "your fork" if GitHub confirms it's actually a fork (forked from another repo)
-		if pkg.SourcesMeta.Github.Fork.IsFork {
-			hasFork = true
-			forkOwner = pkg.SourcesMeta.Github.Fork.Owner
-		}
-	}
-
-	if hasFork {
-		methods = append(methods, InstallMethod{
-			Name:  "git-https",
-			Label: "GIT HTTPS (your fork)",
-			Desc:  fmt.Sprintf("Clone via HTTPS from github.com/%s/%s", forkOwner, pkg.ShortName),
-		})
-		methods = append(methods, InstallMethod{
-			Name:  "git-ssh",
-			Label: "GIT SSH (your fork)",
-			Desc:  fmt.Sprintf("Clone via SSH from github.com/%s/%s", forkOwner, pkg.ShortName),
-		})
-	} else {
-		methods = append(methods, InstallMethod{
-			Name:  "git-https",
-			Label: "GIT HTTPS",
-			Desc:  fmt.Sprintf("Clone via HTTPS from github.com/%s/%s", officialOwner, pkg.ShortName),
-		})
-		methods = append(methods, InstallMethod{
-			Name:  "git-ssh",
-			Label: "GIT SSH",
-			Desc:  fmt.Sprintf("Clone via SSH from github.com/%s/%s", officialOwner, pkg.ShortName),
-		})
-	}
-
-	return methods
-}
-
-// ─────────────────────────────────────────────
-// Modal
-// ─────────────────────────────────────────────
-
-func (m TuiModel) renderModal() string {
-	pkg := m.promptPkg
-	var content strings.Builder
-
-	if m.activePrompt == PromptInstallMethod {
-		content.WriteString(boldStyle.Render("Install source for ") + accentStyle.Render(pkg.ShortName) + "\n\n")
-		methods := m.getInstallMethods(pkg)
-		for i, mth := range methods {
-			if i > 0 {
-				if mth.Name != "local" && methods[i-1].Name == "local" {
-					content.WriteString("\n  " + subtleStyle.Render(strings.Repeat("─", 62)) + "\n\n")
-				} else {
-					content.WriteString("\n")
-				}
-			}
-			var btn string
-			if i == m.promptSel {
-				btn = modalOptionActive.Render(mth.Label)
-			} else {
-				btn = modalOptionInactive.Render(mth.Label)
-			}
-			content.WriteString("  " + btn + "\n")
-			content.WriteString("    " + mutedStyle.Render(mth.Desc) + "\n")
-		}
-		content.WriteString("\n" + subtleStyle.Render("↑↓ select  Enter confirm  Esc cancel"))
-		return modalStyle.Width(72).Render(content.String())
-	} else if m.activePrompt == PromptUninstallConfirm {
-		content.WriteString(boldStyle.Render("Uninstall ") + errStyle.Render(pkg.ShortName) + boldStyle.Render("?") + "\n\n")
-		opts := []string{"Yes, uninstall", "No, keep it"}
-		for i, opt := range opts {
-			if i == m.promptSel {
-				bg := colorErr
-				if i == 1 {
-					bg = colorAccent
-				}
-				content.WriteString(lipgloss.NewStyle().Background(bg).Foreground(lipgloss.Color("#000000")).Bold(true).Padding(0, 2).Render(" "+opt+" "))
-			} else {
-				content.WriteString(modalOptionInactive.Render(" " + opt + " "))
-			}
-			content.WriteString("  ")
-		}
-		content.WriteString("\n\n" + subtleStyle.Render("← → select  Enter confirm  Esc cancel"))
-	} else if m.activePrompt == PromptForceReinstallConfirm {
-		content.WriteString(boldStyle.Render("Force re-download ") + errStyle.Render(pkg.ShortName) + boldStyle.Render("?") + "\n")
-		content.WriteString(warnStyle.Render("⚠ WARNING: This will delete the local directory and lose all modifications!") + "\n\n")
-		opts := []string{"Yes, wipe & reinstall", "No, cancel"}
-		for i, opt := range opts {
-			if i == m.promptSel {
-				bg := colorErr
-				if i == 1 {
-					bg = colorAccent
-				}
-				content.WriteString(lipgloss.NewStyle().Background(bg).Foreground(lipgloss.Color("#000000")).Bold(true).Padding(0, 2).Render(" "+opt+" "))
-			} else {
-				content.WriteString(modalOptionInactive.Render(" " + opt + " "))
-			}
-			content.WriteString("  ")
-		}
-		content.WriteString("\n\n" + subtleStyle.Render("← → select  Enter confirm  Esc cancel"))
-	} else if m.activePrompt == PromptManagePackage {
-		var leftCols []string
-		leftCols = append(leftCols, boldStyle.Render("Package:")+" "+accentStyle.Render(pkg.ShortName))
-		leftCols = append(leftCols, mutedStyle.Render("Type:   ")+" "+boldStyle.Render(strings.ToUpper(pkg.Kind)))
-
-		status := mutedStyle.Render("Not Installed")
-		if pkg.Installed {
-			status = accentStyle.Render("Installed")
-			if pkg.LocalSource {
-				status += " " + lipgloss.NewStyle().Foreground(colorLocal).Render("(workspace)")
-			}
-		}
-		leftCols = append(leftCols, mutedStyle.Render("Status: ")+" "+status)
-
-		src := "NPM"
-		if pkg.LocalSource {
-			src = "LOC (workspace)"
-		} else if pkg.Installed && !pkg.LocalSource {
-			src = "GIT"
-		}
-		leftCols = append(leftCols, mutedStyle.Render("Source: ")+" "+boldStyle.Render(src))
-
-		// Kits
-		var kits []string
-		for _, dep := range m.promptPkgDeps {
-			if strings.HasPrefix(dep, "@owdproject/kit-") {
-				shortKit := dep[strings.LastIndex(dep, "/")+1:]
-				kits = append(kits, shortKit)
-			}
-		}
-		kitsStr := "none"
-		if len(kits) > 0 {
-			var styledKits []string
-			for _, k := range kits {
-				styledKits = append(styledKits, accentStyle.Render(k))
-			}
-			kitsStr = strings.Join(styledKits, ", ")
-		}
-		leftCols = append(leftCols, mutedStyle.Render("Kits:   ")+" "+kitsStr)
-
-		gitStatus := "—"
-		if pkg.LocalSource {
-			kindDir := ""
-			switch pkg.Kind {
-			case "app":
-				kindDir = "apps"
-			case "module":
-				kindDir = "packages"
-			case "theme":
-				kindDir = "themes"
-			}
-			if kindDir != "" {
-				pkgPath := filepath.Join(m.workspaceRoot, kindDir, pkg.ShortName)
-				gitDir := filepath.Join(pkgPath, ".git")
-				if _, err := os.Stat(gitDir); err == nil {
-					branch := gitBranch(pkgPath)
-					changes := gitChanges(pkgPath)
-					gitStatus = fmt.Sprintf("branch: %s  (%s)", branch, changes)
-				}
-			}
-		}
-		leftCols = append(leftCols, mutedStyle.Render("Git:    ")+" "+gitStatus)
-
-		// NPM & GitHub Links
-		npmLink := fmt.Sprintf("https://www.npmjs.com/package/%s", pkg.Name)
-		leftCols = append(leftCols, mutedStyle.Render("NPM:    ")+" "+cyanStyle.Render(npmLink))
-
-		ghLink := fmt.Sprintf("https://github.com/owdproject/%s", pkg.ShortName)
-		if pkg.HtmlUrl != nil && *pkg.HtmlUrl != "" {
-			ghLink = *pkg.HtmlUrl
-		}
-		leftCols = append(leftCols, mutedStyle.Render("GitHub: ")+" "+cyanStyle.Render(ghLink))
-
-		// Deps (excluding kits)
-		var otherDeps []string
-		for _, d := range m.promptPkgDeps {
-			if !strings.HasPrefix(d, "@owdproject/kit-") {
-				s := d
-				if idx := strings.LastIndex(d, "/"); idx >= 0 {
-					s = d[idx+1:]
-				}
-				otherDeps = append(otherDeps, s)
-			}
-		}
-		depsStr := "none"
-		if len(otherDeps) > 0 {
-			depsStr = strings.Join(otherDeps, ", ")
-		}
-		leftCols = append(leftCols, mutedStyle.Render("Deps:   ")+" "+boldStyle.Render(depsStr))
-
-		leftPanel := strings.Join(leftCols, "\n")
-
-		var rightCols []string
-		rightCols = append(rightCols, boldStyle.Render("Management Actions:")+"\n")
-
-		actions := []string{
-			"Update package",
-			"Switch to NPM registry",
-			"Switch to Git (HTTPS)",
-			"Switch to Git (SSH)",
-			"Force Re-download (wipe changes)",
-			"Back to catalog",
-		}
-
-		for i, act := range actions {
-			if i == m.promptSel {
-				rightCols = append(rightCols, modalOptionActive.Render(fmt.Sprintf(" %s ", act)))
-			} else {
-				rightCols = append(rightCols, modalOptionInactive.Render(fmt.Sprintf(" %s ", act)))
-			}
-		}
-
-		rightPanel := strings.Join(rightCols, "\n")
-
-		splitLayout := lipgloss.JoinHorizontal(lipgloss.Top,
-			lipgloss.NewStyle().Width(65).Render(leftPanel),
-			lipgloss.NewStyle().Border(lipgloss.NormalBorder(), false, false, false, true).
-				BorderForeground(colorDim).
-				PaddingLeft(3).
-				Render(rightPanel),
-		)
-
-		content.WriteString(splitLayout)
-		content.WriteString("\n\n" + subtleStyle.Render("↑↓ select  Enter confirm  Esc close"))
-
-		return modalStyle.Width(110).Render(content.String())
-	} else if m.activePrompt == PromptSettings {
-		content.WriteString(boldStyle.Render("Control Panel Settings") + "\n\n")
-
-		// 1. Install Mode
-		modeLabel := "1. Install Mode"
-		var modeVal string
-		if m.settingsInstallMode == "npm" {
-			modeVal = modalOptionActive.Render(" NPM registry ") + "  " + modalOptionInactive.Render(" workspace ")
-		} else {
-			modeVal = modalOptionInactive.Render(" NPM registry ") + "  " + modalOptionActive.Render(" workspace ")
-		}
-		if m.settingsSel == 0 {
-			content.WriteString(accentStyle.Render("▶ ") + boldStyle.Render(modeLabel) + "\n   " + modeVal + "\n")
-		} else {
-			content.WriteString("  " + boldStyle.Render(modeLabel) + "\n   " + modeVal + "\n")
-		}
-		content.WriteString("\n")
-
-		// 2. Catalog Sort
-		sortLabel := "2. Catalog Sort"
-		var sortVal strings.Builder
-		sortModes := []string{"updated", "name", "stars", "installed"}
-		for _, sm := range sortModes {
-			if sm == m.settingsCatalogSort {
-				sortVal.WriteString(modalOptionActive.Render(" "+sm+" ") + " ")
-			} else {
-				sortVal.WriteString(modalOptionInactive.Render(" "+sm+" ") + " ")
-			}
-		}
-		if m.settingsSel == 1 {
-			content.WriteString(accentStyle.Render("▶ ") + boldStyle.Render(sortLabel) + "\n   " + sortVal.String() + "\n")
-		} else {
-			content.WriteString("  " + boldStyle.Render(sortLabel) + "\n   " + sortVal.String() + "\n")
-		}
-		content.WriteString("\n")
-
-		// 3. Trusted Orgs (Authors)
-		orgsLabel := "3. Trusted Orgs"
-		var orgsVal string
-		if m.ctx != nil && len(m.ctx.Settings.GithubOrgs) > 0 {
-			orgsVal = strings.Join(m.ctx.Settings.GithubOrgs, ", ")
-		} else {
-			orgsVal = "owdproject, atproto-os" // default/fallback
-		}
-		orgsValText := boldStyle.Render(orgsVal) + "   " + subtleStyle.Render("(Read-only. Edit settings.json)")
-		if m.settingsSel == 2 {
-			content.WriteString(accentStyle.Render("▶ ") + boldStyle.Render(orgsLabel) + "\n   " + orgsValText + "\n")
-		} else {
-			content.WriteString("  " + boldStyle.Render(orgsLabel) + "\n   " + orgsValText + "\n")
-		}
-		content.WriteString("\n")
-
-		// 4. GitHub User
-		ghLabel := "4. GitHub User"
-		ghUser := "(not set)"
-		if m.ctx != nil && m.ctx.Settings.GithubUser != nil && *m.ctx.Settings.GithubUser != "" {
-			ghUser = *m.ctx.Settings.GithubUser
-		}
-		ghVal := boldStyle.Render(ghUser) + "   " + subtleStyle.Render("(Read-only. Edit settings.json)")
-		if m.settingsSel == 3 {
-			content.WriteString(accentStyle.Render("▶ ") + boldStyle.Render(ghLabel) + "\n   " + ghVal + "\n")
-		} else {
-			content.WriteString("  " + boldStyle.Render(ghLabel) + "\n   " + ghVal + "\n")
-		}
-		content.WriteString("\n\n")
-
-		// Buttons Row: Save and Cancel
-		var saveBtn, cancelBtn string
-		if m.settingsSel == 4 {
-			saveBtn = lipgloss.NewStyle().Background(colorAccent).Foreground(lipgloss.Color("#000000")).Bold(true).Padding(0, 3).Render(" SAVE ")
-		} else {
-			saveBtn = lipgloss.NewStyle().Background(colorDim).Foreground(colorWhite).Padding(0, 3).Render(" SAVE ")
-		}
-
-		if m.settingsSel == 5 {
-			cancelBtn = lipgloss.NewStyle().Background(colorErr).Foreground(lipgloss.Color("#000000")).Bold(true).Padding(0, 3).Render(" CANCEL ")
-		} else {
-			cancelBtn = lipgloss.NewStyle().Background(colorDim).Foreground(colorWhite).Padding(0, 3).Render(" CANCEL ")
-		}
-
-		content.WriteString("      " + saveBtn + "    " + cancelBtn + "\n\n")
-		content.WriteString(subtleStyle.Render("↑↓ select item  ←→ toggle/buttons  Enter confirm  Esc exit"))
-		return modalStyle.Width(72).Render(content.String())
-	}
-
-	return modalStyle.Render(content.String())
-}
-
-// ─────────────────────────────────────────────
-// Background tasks
-// ─────────────────────────────────────────────
-
-func runProcessAndStreamLogs(root, command string, args []string, p *tea.Program) {
-	cmd := exec.Command(command, args...)
-	cmd.Dir = root
-
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		p.Send(taskFinishedMsg{Success: false, Err: err})
-		return
-	}
-	cmd.Stderr = cmd.Stdout
-
-	if err := cmd.Start(); err != nil {
-		p.Send(taskFinishedMsg{Success: false, Err: err})
-		return
-	}
-
-	reader := bufio.NewReader(stdout)
-	for {
-		line, err := reader.ReadString('\n')
-		if err != nil {
-			if err != io.EOF {
-				// ignore partial read errors
-			}
-			break
-		}
-		p.Send(logLineMsg(strings.TrimRight(line, "\r\n")))
-	}
-
-	err = cmd.Wait()
-	p.Send(taskFinishedMsg{Success: err == nil, Err: err})
-}
-
-func (m *TuiModel) RunInstallTask(pkgName string, method string, p *tea.Program) {
-	go func() {
-		shortName := pkgName
-		if idx := strings.LastIndex(pkgName, "/"); idx >= 0 {
-			shortName = pkgName[idx+1:]
-		}
-
-		desktopJs := filepath.Join(m.workspaceRoot, "packages", "cli", "bin", "desktop.js")
-
-		// Build arguments
-		args := []string{desktopJs, "add", shortName}
-		if method == "npm" {
-			args = append(args, "--npm")
-		} else if method == "local" {
-			args = append(args, "--dev")
-		} else {
-			// Find org/owner
-			owner := "owdproject"
-			if m.ctx != nil && m.ctx.Settings.GithubUser != nil && *m.ctx.Settings.GithubUser != "" {
-				owner = *m.ctx.Settings.GithubUser
-			} else if m.catalog != nil {
-				for _, e := range m.catalog.Entries {
-					if e.Name == pkgName && e.Org != "" {
-						owner = e.Org
-						break
-					}
-				}
-			}
-
-			var fromVal string
-			if method == "git-ssh" {
-				fromVal = fmt.Sprintf("git@github.com:%s/%s.git", owner, shortName)
-			} else {
-				fromVal = fmt.Sprintf("https://github.com/%s/%s.git", owner, shortName)
-			}
-			args = append(args, "--from", fromVal)
-		}
-
-		p.Send(logLineMsg(fmt.Sprintf(">>> Executing: node desktop.js add %s", shortName)))
-		runProcessAndStreamLogs(m.workspaceRoot, "node", args, p)
-
-		// Check if it's a theme and resolve dependencies!
-		isTheme := strings.HasPrefix(shortName, "theme-")
-		if isTheme {
-			p.Send(logLineMsg(">>> Resolving theme dependencies…"))
-			deps, err := getThemeDependencies(m.workspaceRoot, shortName)
-			if err == nil {
-				for _, dep := range deps {
-					// Check if already installed in context
-					installed := false
-					if m.ctx != nil {
-						for _, d := range m.ctx.Deps {
-							if d == dep {
-								installed = true
-								break
-							}
-						}
-					}
-
-					if !installed {
-						depShort := dep
-						if idx := strings.LastIndex(dep, "/"); idx >= 0 {
-							depShort = dep[idx+1:]
-						}
-
-						p.Send(logLineMsg(fmt.Sprintf(">>> Installing theme dependency: %s…", depShort)))
-						depArgs := []string{desktopJs, "add", depShort}
-						if method == "npm" {
-							depArgs = append(depArgs, "--npm")
-						} else {
-							depOwner := "owdproject"
-							if m.ctx != nil && m.ctx.Settings.GithubUser != nil && *m.ctx.Settings.GithubUser != "" {
-								depOwner = *m.ctx.Settings.GithubUser
-							}
-
-							var fromVal string
-							if method == "git-ssh" {
-								fromVal = fmt.Sprintf("git@github.com:%s/%s.git", depOwner, depShort)
-							} else {
-								fromVal = fmt.Sprintf("https://github.com/%s/%s.git", depOwner, depShort)
-							}
-							depArgs = append(depArgs, "--from", fromVal)
+				// 2. NPM latest version check
+				if entry.Installed && !entry.LocalSource {
+					localVer := getLocalVersion(m.workspaceRoot, entry)
+					if localVer != "" {
+						latestVer, err := fetchLatestNpmVersion(entry.Name)
+						if err != nil {
+							res.err = err
+						} else if semverCompare(localVer, latestVer) < 0 {
+							res.update = &UpdateInfo{Npm: true}
 						}
-						runProcessAndStreamLogs(m.workspaceRoot, "node", depArgs, p)
 					}
 				}
-			}
-		}
-
-		// Rebuild stubs
-		p.Send(logLineMsg(">>> Rebuilding stubs…"))
-		runProcessAndStreamLogs(m.workspaceRoot, "pnpm", []string{"run", "prepare:modules"}, p)
-
-		p.Send(taskFinishedMsg{Success: true})
-	}()
-}
-
-func (m *TuiModel) RunUninstallTask(p *tea.Program) {
-	go func() {
-		p.Send(logLineMsg(">>> Running pnpm install (cleanup)…"))
-		runProcessAndStreamLogs(m.workspaceRoot, "pnpm", []string{"install"}, p)
-		p.Send(logLineMsg(">>> Preparing workspace modules…"))
-		runProcessAndStreamLogs(m.workspaceRoot, "pnpm", []string{"run", "prepare:modules"}, p)
-		p.Send(taskFinishedMsg{Success: true})
-	}()
-}
-
-func (m *TuiModel) RunServeTask(p *tea.Program) {
-	go func() {
-		if m.ctx == nil {
-			p.Send(serverStatusMsg{Running: false})
-			return
-		}
-
-		_ = os.MkdirAll(m.ctx.Paths.MetaDir, 0755)
 
-		logPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.log")
-		logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
-		if err != nil {
-			p.Send(logLineMsg(fmt.Sprintf(">>> Failed to open log file: %v", err)))
-			p.Send(serverStatusMsg{Running: false})
-			return
-		}
-		defer logFile.Close()
-
-		logFile.WriteString(">>> Starting Nuxt dev server (pnpm run dev)…\n")
-
-		cmd := exec.Command("pnpm", "run", "dev")
-		if m.ctx.Paths.IsPlayground {
-			cmd.Dir = m.ctx.Paths.PackageDir
-		} else {
-			cmd.Dir = m.workspaceRoot
-		}
-
-		cmd.Env = append(os.Environ(), fmt.Sprintf("PORT=%d", m.ctx.Settings.DevPort))
-		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
-		cmd.Stdout = logFile
-		cmd.Stderr = logFile
-		ServerCmd = cmd
-
-		if err := cmd.Start(); err != nil {
-			logFile.WriteString(fmt.Sprintf(">>> Server failed to start: %v\n", err))
-			p.Send(serverStatusMsg{Running: false})
-			return
-		}
-
-		// Write PID file
-		pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
-		_ = os.WriteFile(pidPath, []byte(fmt.Sprintf("%d", cmd.Process.Pid)), 0644)
-
-		p.Send(serverStatusMsg{Running: true})
-
-		cmd.Wait()
-		logFile.WriteString(">>> Dev server exited.\n")
-		p.Send(serverStatusMsg{Running: false})
-		ServerCmd = nil
-	}()
-}
-
-func (m *TuiModel) StopServeTask(p *tea.Program) {
-	go func() {
-		if m.ctx == nil {
-			p.Send(serverStatusMsg{Running: false})
-			return
-		}
-
-		if ServerCmd != nil && ServerCmd.Process != nil {
-			_ = syscall.Kill(-ServerCmd.Process.Pid, syscall.SIGKILL)
-			ServerCmd = nil
-		}
-
-		pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
-		if data, err := os.ReadFile(pidPath); err == nil {
-			var pid int
-			if _, err := fmt.Sscanf(strings.TrimSpace(string(data)), "%d", &pid); err == nil {
-				_ = syscall.Kill(-pid, syscall.SIGKILL)
-				_ = syscall.Kill(pid, syscall.SIGKILL)
-			}
-			_ = os.Remove(pidPath)
-		}
-
-		_ = exec.Command("pkill", "-9", "-f", "nuxt.mjs").Run()
-		_ = exec.Command("pkill", "-9", "-f", "nuxt dev").Run()
-		_ = exec.Command("pkill", "-9", "-f", "nx run desktop:serve").Run()
-
-		p.Send(serverStatusMsg{Running: false})
-	}()
-}
-
-func StartLogTailer(logPath string, p *tea.Program) {
-	go func() {
-		var lastSize int64 = 0
-
-		// Check if file exists and get its initial size
-		if info, err := os.Stat(logPath); err == nil {
-			lastSize = info.Size()
-			// Seek back up to 10000 bytes (~100 lines) to show initial history
-			offset := lastSize - 10000
-			if offset < 0 {
-				offset = 0
-			}
-
-			file, err := os.Open(logPath)
-			if err == nil {
-				_, _ = file.Seek(offset, 0)
-				reader := bufio.NewReader(file)
-				if offset > 0 {
-					_, _ = reader.ReadString('\n') // discard first potentially cut line
-				}
-				for {
-					line, err := reader.ReadString('\n')
-					if err != nil {
-						break
-					}
-					p.Send(logLineMsg(strings.TrimRight(line, "\r\n")))
-				}
-				file.Close()
-			}
+				resultsChan <- res
+			}(e)
 		}
 
-		for {
-			time.Sleep(250 * time.Millisecond)
-
-			info, err := os.Stat(logPath)
-			if err != nil {
-				continue
-			}
-
-			if info.Size() < lastSize {
-				// File was truncated/cleared
-				lastSize = info.Size()
-				p.Send(clearLogsMsg{})
-				continue
+		var checkErr error
+		for i := 0; i < len(m.catalog.Entries); i++ {
+			res := <-resultsChan
+			if res.update != nil {
+				updatesMap[res.shortName] = *res.update
 			}
-
-			if info.Size() > lastSize {
-				file, err := os.Open(logPath)
-				if err != nil {
-					continue
-				}
-				_, err = file.Seek(lastSize, 0)
-				if err != nil {
-					file.Close()
-					continue
-				}
-
-				reader := bufio.NewReader(file)
-				for {
-					line, err := reader.ReadString('\n')
-					if err != nil {
-						break
-					}
-					p.Send(logLineMsg(strings.TrimRight(line, "\r\n")))
-				}
-				lastSize = info.Size()
-				file.Close()
+			if res.err != nil && checkErr == nil {
+				checkErr = res.err
 			}
 		}
-	}()
-}
-
-// ─────────────────────────────────────────────
-// Git & Updates Helpers
-// ─────────────────────────────────────────────
-
-func runGitStatus(dir string) (added, modified, deleted int, err error) {
-	cmd := exec.Command("git", "status", "--porcelain")
-	cmd.Dir = dir
-	out, err := cmd.Output()
-	if err != nil {
-		return 0, 0, 0, err
-	}
-	lines := strings.Split(string(out), "\n")
-	for _, line := range lines {
-		if len(line) < 3 {
-			continue
-		}
-		status := line[:2]
-		if strings.HasPrefix(status, "??") {
-			added++
-		} else if strings.Contains(status, "D") {
-			deleted++
-		} else if strings.Contains(status, "M") || strings.Contains(status, "A") || strings.Contains(status, "R") || strings.Contains(status, "C") {
-			modified++
-		}
-	}
-	return added, modified, deleted, nil
-}
-
-func runGitStatusForSubdir(rootDir, subdir string) (added, modified, deleted int, err error) {
-	cmd := exec.Command("git", "status", "--porcelain", subdir)
-	cmd.Dir = rootDir
-	out, err := cmd.Output()
-	if err != nil {
-		return 0, 0, 0, err
-	}
-	lines := strings.Split(string(out), "\n")
-	for _, line := range lines {
-		if len(line) < 3 {
-			continue
-		}
-		status := line[:2]
-		if strings.HasPrefix(status, "??") {
-			added++
-		} else if strings.Contains(status, "D") {
-			deleted++
-		} else if strings.Contains(status, "M") || strings.Contains(status, "A") || strings.Contains(status, "R") || strings.Contains(status, "C") {
-			modified++
-		}
-	}
-	return added, modified, deleted, nil
-}
-
-func runGitBehindCheck(dir string) (int, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel()
-
-	cmdFetch := exec.CommandContext(ctx, "git", "fetch")
-	cmdFetch.Dir = dir
-	_ = cmdFetch.Run() // ignore fetch errors
-
-	cmdRev := exec.Command("git", "rev-list", "--count", "HEAD..@{u}")
-	cmdRev.Dir = dir
-	out, err := cmdRev.Output()
-	if err != nil {
-		// Try with origin/branch
-		cmdBranch := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
-		cmdBranch.Dir = dir
-		branchOut, errBranch := cmdBranch.Output()
-		if errBranch != nil {
-			return 0, errBranch
-		}
-		branch := strings.TrimSpace(string(branchOut))
-		if branch == "" || branch == "HEAD" {
-			return 0, err
-		}
-		cmdRev = exec.Command("git", "rev-list", "--count", fmt.Sprintf("HEAD..origin/%s", branch))
-		cmdRev.Dir = dir
-		out, err = cmdRev.Output()
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	var behind int
-	_, err = fmt.Sscanf(strings.TrimSpace(string(out)), "%d", &behind)
-	return behind, err
-}
 
-func fetchLatestNpmVersion(pkgName string) (string, error) {
-	client := &http.Client{Timeout: 3 * time.Second}
-	resp, err := client.Get(fmt.Sprintf("https://registry.npmjs.org/%s/latest", url.PathEscape(pkgName)))
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("HTTP %d", resp.StatusCode)
-	}
-	var data struct {
-		Version string `json:"version"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
-		return "", err
+		return remoteUpdatesMsg{Updates: updatesMap, Err: checkErr}
 	}
-	return data.Version, nil
 }
 
 func getLocalVersion(workspaceRoot string, entry bridge.CatalogEntry) string {
@@ -2800,145 +767,6 @@ func semverCompare(v1, v2 string) int {
 	return len(parts1) - len(parts2)
 }
 
-func (m TuiModel) checkForUpdatesCmd() tea.Cmd {
-	return func() tea.Msg {
-		gitChangesMap := make(map[string]GitChanges)
-		updatesMap := make(map[string]UpdateInfo)
-
-		if m.catalog == nil {
-			return updatesLoadedMsg{GitChanges: gitChangesMap, Updates: updatesMap}
-		}
-
-		type result struct {
-			shortName string
-			changes   *GitChanges
-			update    *UpdateInfo
-		}
-
-		resultsChan := make(chan result, len(m.catalog.Entries))
-		sem := make(chan struct{}, 10) // Limit concurrency
-
-		for _, e := range m.catalog.Entries {
-			sem <- struct{}{}
-			go func(entry bridge.CatalogEntry) {
-				defer func() { <-sem }()
-
-				res := result{shortName: entry.ShortName}
-
-				// 1. Check local changes & upstream behind counts
-				short := entry.ShortName
-				kindDir := ""
-				switch entry.Kind {
-				case "app":
-					kindDir = "apps"
-				case "module":
-					kindDir = "packages"
-				case "theme":
-					kindDir = "themes"
-				}
-
-				if kindDir != "" {
-					pkgPath := filepath.Join(m.workspaceRoot, kindDir, short)
-					gitDir := filepath.Join(pkgPath, ".git")
-					if _, err := os.Stat(gitDir); err == nil {
-						added, modified, deleted, err := runGitStatus(pkgPath)
-						if err == nil && (added > 0 || modified > 0 || deleted > 0) {
-							res.changes = &GitChanges{Added: added, Modified: modified, Deleted: deleted}
-						}
-
-						behind, err := runGitBehindCheck(pkgPath)
-						if err == nil && behind > 0 {
-							res.update = &UpdateInfo{LocalGit: true, BehindCount: behind}
-						}
-					} else {
-						// Fallback: Check if the monorepo itself tracks changes for this directory
-						parentGitDir := filepath.Join(m.workspaceRoot, ".git")
-						if _, err := os.Stat(parentGitDir); err == nil {
-							relPath := filepath.Join(kindDir, short)
-							added, modified, deleted, err := runGitStatusForSubdir(m.workspaceRoot, relPath)
-							if err == nil && (added > 0 || modified > 0 || deleted > 0) {
-								res.changes = &GitChanges{Added: added, Modified: modified, Deleted: deleted}
-							}
-						}
-					}
-				}
-
-				// 2. Check NPM updates
-				if entry.Installed && !entry.LocalSource {
-					localVer := getLocalVersion(m.workspaceRoot, entry)
-					if localVer != "" {
-						latestVer, err := fetchLatestNpmVersion(entry.Name)
-						if err == nil && semverCompare(localVer, latestVer) < 0 {
-							res.update = &UpdateInfo{Npm: true}
-						}
-					}
-				}
-
-				resultsChan <- res
-			}(e)
-		}
-
-		for i := 0; i < len(m.catalog.Entries); i++ {
-			res := <-resultsChan
-			if res.changes != nil {
-				gitChangesMap[res.shortName] = *res.changes
-			}
-			if res.update != nil {
-				updatesMap[res.shortName] = *res.update
-			}
-		}
-
-		return updatesLoadedMsg{GitChanges: gitChangesMap, Updates: updatesMap}
-	}
-}
-
-// ─────────────────────────────────────────────
-// Theme Dependencies & Package Metadata Helpers
-// ─────────────────────────────────────────────
-
-func getThemeDependencies(workspaceRoot, themeShortName string) ([]string, error) {
-	var pathsToCheck []string
-	pathsToCheck = append(pathsToCheck, filepath.Join(workspaceRoot, "themes", themeShortName, "package.json"))
-	pathsToCheck = append(pathsToCheck, filepath.Join(workspaceRoot, "node_modules", "@owdproject", themeShortName, "package.json"))
-
-	var data []byte
-	var err error
-	for _, p := range pathsToCheck {
-		data, err = os.ReadFile(p)
-		if err == nil {
-			break
-		}
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	var pkg struct {
-		Dependencies    map[string]string `json:"dependencies"`
-		DevDependencies map[string]string `json:"devDependencies"`
-	}
-	if err := json.Unmarshal(data, &pkg); err != nil {
-		return nil, err
-	}
-
-	var deps []string
-	seen := make(map[string]bool)
-	for name := range pkg.Dependencies {
-		if strings.HasPrefix(name, "@owdproject/") && !seen[name] {
-			deps = append(deps, name)
-			seen[name] = true
-		}
-	}
-	for name := range pkg.DevDependencies {
-		if strings.HasPrefix(name, "@owdproject/") && !seen[name] {
-			deps = append(deps, name)
-			seen[name] = true
-		}
-	}
-	return deps, nil
-}
-
 func (m *TuiModel) loadPackageDetails(pkg *bridge.CatalogEntry) {
 	m.promptPkgDeps = []string{}
 	m.promptPkgHasPrimevue = false
@@ -3010,5 +838,32 @@ func (m *TuiModel) loadPackageDetails(pkg *bridge.CatalogEntry) {
 	}
 }
 
-// keep rand used (for future sparkline noise simulation)
-var _ = rand.Float64
+func (m *TuiModel) isClearLogsClick(msg tea.MouseMsg) bool {
+	if msg.Y != 0 {
+		return false
+	}
+
+	w := m.termWidth
+	if w < 120 {
+		return false
+	}
+
+	leftW := w * 40 / 100
+	midW := w * 28 / 100
+	catW := leftW + midW
+
+	panelStartX := catW - 1
+
+	rightPanelTitle := "Logs"
+	if m.activePrompt == PromptResolveDependency {
+		rightPanelTitle = "Wizard Setup"
+	} else if m.activeTask == TaskSetup || m.activeTask == TaskWipe {
+		rightPanelTitle = "Setup"
+	}
+
+	prefixLen := len(rightPanelTitle) + 2
+	clearStartX := panelStartX + 2 + prefixLen
+	clearEndX := clearStartX + 7
+
+	return msg.X >= clearStartX && msg.X < clearEndX
+}