feat(tui): session restore (-c), mouse fix, compare NDSL|MDL, palette layout

Session restore:
- Save TUI state to ~/.mxcli/tui-session.json on quit
- -c/--continue flag restores project, navigation path, preview mode
- Edge cases: deleted nodes fall back to miller path

Mouse coordinate fix:
- Fix tab bar click Y-offset for LLM anchor line (row 0 → 1)
- Fix content area Y-offset (−1 → −2 for anchor + tab bar)
- Remove broken DisableMouse/EnableMouseCellMotion on resize
  (these return Msg not Cmd, sending them broke mouse state)

Compare view:
- Default to NDSL|MDL mode, load both sides simultaneously

Command palette layout:
- Add scroll window to prevent overflow
- Fix shortcut key alignment with plain string padding

Author: engalar

cmd/mxcli/cmd_tui.go

@@ -33,13 +33,33 @@ Commands (via : bar):
   :diagram         open diagram in browser
   :search <kw>     full-text search
 
+Flags:
+  -c, --continue   Restore previous session (tab, navigation, preview mode)
+
 Example:
   mxcli tui -p app.mpr
+  mxcli tui -c
 `,
 	Run: func(cmd *cobra.Command, args []string) {
 		projectPath, _ := cmd.Flags().GetString("project")
+		continueSession, _ := cmd.Flags().GetBool("continue")
 		mxcliPath, _ := os.Executable()
 
+		// Try to restore session when -c flag is set
+		var session *tui.TUISession
+		if continueSession {
+			loaded, err := tui.LoadSession()
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Warning: could not load session: %v\n", err)
+			} else if loaded != nil {
+				session = loaded
+				// Use project path from session if not explicitly provided
+				if projectPath == "" && len(session.Tabs) > 0 {
+					projectPath = session.Tabs[0].ProjectPath
+				}
+			}
+		}
+
 		if projectPath == "" {
 			picker := tui.NewPickerModel()
 			p := tea.NewProgram(picker, tea.WithAltScreen())
@@ -55,9 +75,18 @@ Example:
 			projectPath = m.Chosen()
 		}
 
+		// Verify project file exists
+		if _, err := os.Stat(projectPath); err != nil {
+			fmt.Fprintf(os.Stderr, "Error: project file not found: %s\n", projectPath)
+			os.Exit(1)
+		}
+
 		tui.SaveHistory(projectPath)
 
 		m := tui.NewApp(mxcliPath, projectPath)
+		if session != nil {
+			m.SetPendingSession(session)
+		}
 		p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion())
 		m.StartWatcher(p)
 		if _, err := p.Run(); err != nil {
@@ -66,3 +95,7 @@ Example:
 		}
 	},
 }
+
+func init() {
+	tuiCmd.Flags().BoolP("continue", "c", false, "Restore previous TUI session")
+}

cmd/mxcli/tui/app.go

@@ -50,6 +50,8 @@ type App struct {
 	watcher       *Watcher
 	checkErrors   []CheckError // nil = no check run yet, empty = pass
 	checkRunning  bool
+
+	pendingSession *TUISession // session to restore after tree loads
 }
 
 // NewApp creates the root App model.
@@ -405,8 +407,8 @@ func (a App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return a, nil
 		}
 
-		// Tab bar clicks (row 0) — only when in browser mode
-		if msg.Y == 0 && a.views.Active().Mode() == ModeBrowser &&
+		// Tab bar clicks (row 1, after LLM anchor line) — only when in browser mode
+		if msg.Y == 1 && a.views.Active().Mode() == ModeBrowser &&
 			msg.Action == tea.MouseActionPress && msg.Button == tea.MouseButtonLeft {
 			if clickMsg := a.tabBar.HandleClick(msg.X); clickMsg != nil {
 				if tc, ok := clickMsg.(TabClickMsg); ok {
@@ -434,10 +436,10 @@ func (a App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			}
 		}
 
-		// Offset Y by -1 for tab bar when in browser mode
+		// Offset Y by -2 (LLM anchor line + tab bar) when in browser mode
 		if a.views.Active().Mode() == ModeBrowser {
 			offsetMsg := tea.MouseMsg{
-				X: msg.X, Y: msg.Y - 1,
+				X: msg.X, Y: msg.Y - 2,
 				Button: msg.Button, Action: msg.Action,
 			}
 			updated, cmd := a.views.Active().Update(offsetMsg)
@@ -487,6 +489,11 @@ func (a App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					a.views.SetBase(bv)
 				}
 			}
+
+			// Apply pending session restore after tree is loaded
+			if a.pendingSession != nil {
+				applySessionRestore(&a)
+			}
 		}
 		return a, nil
 
@@ -630,6 +637,10 @@ func (a *App) handleBrowserAppKeys(msg tea.KeyMsg) tea.Cmd {
 
 	switch msg.String() {
 	case "q":
+		// Save session state before quitting
+		if session := ExtractSession(a); session != nil {
+			_ = SaveSession(session)
+		}
 		if a.watcher != nil {
 			a.watcher.Close()
 		}
@@ -743,13 +754,17 @@ func (a *App) handleBrowserAppKeys(msg tea.KeyMsg) tea.Cmd {
 		cv := NewCompareView()
 		cv.mxcliPath = a.mxcliPath
 		cv.projectPath = a.activeTabProjectPath()
-		cv.Show(CompareNDSL, a.width, a.height)
+		cv.Show(CompareNDSLMDL, a.width, a.height)
 		if tab != nil {
 			cv.SetItems(flattenQualifiedNames(tab.AllNodes))
 			if node := tab.Miller.SelectedNode(); node != nil && node.QualifiedName != "" {
 				cv.SetLoading(CompareFocusLeft)
+				cv.SetLoading(CompareFocusRight)
 				a.views.Push(cv)
-				return cv.loadBsonNDSL(node.QualifiedName, node.Type, CompareFocusLeft)
+				return tea.Batch(
+					cv.loadBsonNDSL(node.QualifiedName, node.Type, CompareFocusLeft),
+					cv.loadMDL(node.QualifiedName, node.Type, CompareFocusRight),
+				)
 			}
 		}
 		a.views.Push(cv)
@@ -779,6 +794,102 @@ func (a *App) switchToTabByID(id int) {
 	}
 }
 
+// SetPendingSession stores a session to be restored after the project tree loads.
+func (a *App) SetPendingSession(session *TUISession) {
+	a.pendingSession = session
+}
+
+// applySessionRestore applies the pending session state to the loaded app.
+// Called after LoadTreeMsg delivers nodes so navigation paths can be resolved.
+// Takes *App because it's called from Update (value receiver) via &a.
+func applySessionRestore(a *App) {
+	session := a.pendingSession
+	if session == nil {
+		return
+	}
+	a.pendingSession = nil
+
+	if len(session.Tabs) == 0 {
+		return
+	}
+
+	// Restore the first tab's navigation (multi-tab restore: only the
+	// primary tab is restored since additional tabs need separate
+	// project-tree loads which are not wired yet).
+	ts := session.Tabs[0]
+	tab := a.activeTabPtr()
+	if tab == nil || len(tab.AllNodes) == 0 {
+		return
+	}
+
+	// Navigate to the selected node if available
+	if ts.SelectedNode != "" {
+		if bv, ok := a.views.Base().(BrowserView); ok {
+			bv.allNodes = tab.AllNodes
+			bv.navigateToNode(ts.SelectedNode)
+			// Set preview mode after navigation (navigateToNode resets miller)
+			setPreviewMode(&bv.miller, ts.PreviewMode)
+			tab.Miller = bv.miller
+			tab.UpdateLabel()
+			a.views.SetBase(bv)
+			a.syncTabBar()
+			Trace("app: session restored — navigated to %q", ts.SelectedNode)
+			return
+		}
+	}
+
+	// Fallback: navigate the miller path breadcrumb
+	if len(ts.MillerPath) > 0 {
+		restoreMillerPath(a, tab, ts.MillerPath)
+	}
+
+	// Set preview mode (for path-based or no-navigation restore)
+	setPreviewMode(&tab.Miller, ts.PreviewMode)
+}
+
+// setPreviewMode sets the miller preview mode from a string value.
+func setPreviewMode(miller *MillerView, mode string) {
+	if mode == "NDSL" {
+		miller.preview.mode = PreviewNDSL
+	} else {
+		miller.preview.mode = PreviewMDL
+	}
+}
+
+// restoreMillerPath drills the miller view through a breadcrumb path.
+func restoreMillerPath(a *App, tab *Tab, millerPath []string) {
+	bv, ok := a.views.Base().(BrowserView)
+	if !ok {
+		return
+	}
+	bv.allNodes = tab.AllNodes
+	bv.miller.SetRootNodes(tab.AllNodes)
+
+	for _, segment := range millerPath {
+		found := false
+		for j, item := range bv.miller.current.items {
+			if item.Label == segment {
+				bv.miller.current.SetCursor(j)
+				if item.Node != nil && len(item.Node.Children) > 0 {
+					bv.miller, _ = bv.miller.drillIn()
+				}
+				found = true
+				break
+			}
+		}
+		if !found {
+			Trace("app: session restore — path segment %q not found, stopping", segment)
+			break
+		}
+	}
+
+	tab.Miller = bv.miller
+	tab.UpdateLabel()
+	a.views.SetBase(bv)
+	a.syncTabBar()
+	Trace("app: session restored via miller path %v", millerPath)
+}
+
 // --- View ---
 
 func (a App) View() string {

cmd/mxcli/tui/commandpalette.go

@@ -163,39 +163,60 @@ func (cp CommandPaletteView) Render(width, height int) string {
 	keyStyle := lipgloss.NewStyle().Foreground(MutedColor)
 	titleStyle := lipgloss.NewStyle().Bold(true).Foreground(AccentColor)
 
-	boxWidth := max(30, min(60, width-10))
+	contentWidth := max(30, min(56, width-14)) // inner content width (box adds border+padding)
 
 	var sb strings.Builder
 	sb.WriteString(titleStyle.Render("Commands") + "\n")
 	sb.WriteString(cp.input.View() + "\n\n")
 
-	// Build visible entries with scroll
+	// Determine scroll window
+	maxVisibleLines := max(6, min(paletteMaxVisible, height-10))
 	entries := cp.filtered
+
+	// Find scroll offset to keep selected item visible
+	scrollOffset := cp.computeScrollOffset(maxVisibleLines)
+
 	selectableIdx := 0
+	visibleLines := 0
+
+	for i, entry := range entries {
+		if i < scrollOffset {
+			if !entry.isHeader {
+				selectableIdx++
+			}
+			continue
+		}
+		if visibleLines >= maxVisibleLines {
+			break
+		}
 
-	for _, entry := range entries {
 		if entry.isHeader {
 			sb.WriteString(catStyle.Render("  "+entry.category) + "\n")
+			visibleLines++
 			continue
 		}
 
-		prefix := "    "
 		shortcut := entry.command.Key
 		name := entry.command.Name
 
+		// Calculate padding between name and shortcut
+		shortcutWidth := len(shortcut)
+		nameMaxWidth := contentWidth - 6 - shortcutWidth // "  > " prefix + spacing
+		if len(name) > nameMaxWidth {
+			name = name[:nameMaxWidth-1] + "~"
+		}
+		pad := contentWidth - 4 - len(name) - shortcutWidth
+		if pad < 1 {
+			pad = 1
+		}
+
 		if selectableIdx == cp.selectedIdx {
-			line := fmt.Sprintf("%s> %-*s %s",
-				"  ", boxWidth-12, name, shortcut)
-			sb.WriteString(selStyle.Render(line) + "\n")
+			sb.WriteString(selStyle.Render("  > "+name) + strings.Repeat(" ", pad) + selStyle.Render(shortcut) + "\n")
 		} else {
-			label := prefix + normStyle.Render(name)
-			pad := boxWidth - 8 - lipgloss.Width(name)
-			if pad < 1 {
-				pad = 1
-			}
-			sb.WriteString(label + strings.Repeat(" ", pad) + keyStyle.Render(shortcut) + "\n")
+			sb.WriteString("    " + normStyle.Render(name) + strings.Repeat(" ", pad) + keyStyle.Render(shortcut) + "\n")
 		}
 		selectableIdx++
+		visibleLines++
 	}
 
 	selectableCount := cp.countSelectable()
@@ -205,13 +226,42 @@ func (cp CommandPaletteView) Render(width, height int) string {
 		Border(lipgloss.RoundedBorder()).
 		BorderForeground(AccentColor).
 		Padding(1, 2).
-		Width(boxWidth).
 		Render(sb.String())
 
 	return lipgloss.Place(width, height,
 		lipgloss.Center, lipgloss.Center,
-		box,
-		lipgloss.WithWhitespaceBackground(lipgloss.Color("0")))
+		box)
+}
+
+// computeScrollOffset returns the first entry index to render, keeping selectedIdx visible.
+func (cp *CommandPaletteView) computeScrollOffset(maxVisible int) int {
+	if len(cp.filtered) <= maxVisible {
+		return 0
+	}
+
+	// Find the line index of the selected command
+	targetLine := 0
+	selectableIdx := 0
+	for i, entry := range cp.filtered {
+		if !entry.isHeader {
+			if selectableIdx == cp.selectedIdx {
+				targetLine = i
+				break
+			}
+			selectableIdx++
+		}
+	}
+
+	// Ensure selected item is within visible window
+	// Show a few lines of context above
+	offset := targetLine - maxVisible/3
+	if offset < 0 {
+		offset = 0
+	}
+	if offset+maxVisible > len(cp.filtered) {
+		offset = max(0, len(cp.filtered)-maxVisible)
+	}
+	return offset
 }
 
 // refilter rebuilds the filtered entries based on the current input.