Default autopilot mode for new sessions (d key) (#32)

* autoresearch: cycle 2 — wire Config into state.Manager with Get/SetDefaultAutopilot

* autoresearch: cycle 3 — apply default autopilot in RegisterSession for new sessions

* autoresearch: cycle 4 — apply default autopilot in UpdateSessionFromScanner, extract helper

* autoresearch: cycles 5+6 — add set_default_autopilot and get_config actions to control server

* autoresearch: cycle 7 — add SetDefaultAutopilot and GetConfig client methods

* autoresearch: cycle 8 — include default_autopilot in state snapshot sent to TUI subscribers

* autoresearch: cycle 10 — add tests for default autopilot behavior

* autoresearch: add 'd' key binding to cycle default autopilot mode

Cycles through "" → "on" → "yolo" → "" with appropriate flash feedback
using existing styleAutopilotOn/styleAutopilotWarn styles. Includes TODO
comment for wiring client.SetDefaultAutopilot once Agent B's changes land.

* autoresearch: show default autopilot indicator in status bar

When defaultAutopilot is "on" shows [⚙ default: AUTO] badge (green),
when "yolo" shows [⚠ default: YOLO] badge (yellow). No indicator when
no default is set — status bar stays clean.

* autoresearch: annotate autopilot badge with '(default)' in zoom panel

When a session's AutopilotMode matches the global defaultAutopilot,
the zoom header badge shows '⚙ AUTO (default)' or '⚠ YOLO (default)'
so users can distinguish daemon-inherited from manually-set modes.

* autoresearch: add 'd default' hint to session hints bar

Adds 'd default' hint after 'a autopilot' in the session hints bar
so users discover the default autopilot feature. Not shown for PR view
since PRs don't have a session default concept.

* autoresearch: document 'd' key and default autopilot behavior in help overlay

Adds 'd  Cycle default autopilot for new sessions' to the Sessions section
of the help overlay, and explanatory text clarifying that defaults apply
only to new sessions and per-session overrides take precedence.

* autoresearch: add first-run discoverability tip in empty state

When no sessions exist and no default autopilot is configured, the empty
state shows a subtle italic tip: "Press 'd' to set a default autopilot
mode for all new sessions". Tip disappears once a default is set.

* autoresearch: refine flash message styling for default autopilot toggle

Uses inline text styles (no padding) for flash messages instead of badge
styles to keep status bar flash clean: green bold for AUTO, orange bold
for YOLO, dim for OFF.

* autoresearch: fix zoom_test.go calls after renderZoom signature change

All renderZoom calls in test file updated to pass the new defaultAutopilot
string parameter. All tests pass cleanly.

* autoresearch: finalize cycle log for agent-c default autopilot UX

Complete 10-cycle autoresearch log for default autopilot TUI presentation:
Model field, 'd' key binding, status bar indicator, zoom badge annotation,
hints bar, help overlay, empty state tip, flash styling, build/test fixes.

* autoresearch: cycle 1 — add Config struct and config load/save helpers

* autoresearch: add defaultAutopilot field to Model struct

Adds the defaultAutopilot string field to Model for tracking the global
default autopilot mode for new sessions ("", "on", "yolo"). Includes
TODO comment for wiring to StateUpdate.DefaultAutopilot post-merge.

* Wire TUI default autopilot to daemon client

- Remove TODO stubs: stateMsg now reads DefaultAutopilot from daemon
- d key calls client.SetDefaultAutopilot() instead of local-only update

* Remove .autoresearch artifacts from tracking

Author: bearmug

daemon/internal/ctlserver/handler.go

@@ -15,20 +15,22 @@ import (
 )
 
 type ctlRequest struct {
-	Action      string `json:"action"`
-	SessionID   string `json:"session_id,omitempty"`
-	PRURL       string `json:"pr_url,omitempty"`       // for add_pr
-	PRKey       string `json:"pr_key,omitempty"`       // "owner/repo#N" for remove_pr, cycle_pr_autopilot, set_merge_method
-	MergeMethod string `json:"merge_method,omitempty"` // for set_merge_method
+	Action           string `json:"action"`
+	SessionID        string `json:"session_id,omitempty"`
+	PRURL            string `json:"pr_url,omitempty"`            // for add_pr
+	PRKey            string `json:"pr_key,omitempty"`            // "owner/repo#N" for remove_pr, cycle_pr_autopilot, set_merge_method
+	MergeMethod      string `json:"merge_method,omitempty"`      // for set_merge_method
+	DefaultAutopilot string `json:"default_autopilot,omitempty"` // for set_default_autopilot
 }
 
 type ctlResponse struct {
-	OK            *bool           `json:"ok,omitempty"`
-	Sessions      []model.Session `json:"sessions,omitempty"`
-	PRs           []pr.TrackedPR  `json:"prs,omitempty"`
-	Event         string          `json:"event,omitempty"`
-	AutopilotMode string          `json:"autopilot_mode,omitempty"`
-	NewRepo       bool            `json:"new_repo,omitempty"` // true when add_pr is the first PR for this repo
+	OK               *bool           `json:"ok,omitempty"`
+	Sessions         []model.Session `json:"sessions,omitempty"`
+	PRs              []pr.TrackedPR  `json:"prs,omitempty"`
+	Event            string          `json:"event,omitempty"`
+	AutopilotMode    string          `json:"autopilot_mode,omitempty"`
+	NewRepo          bool            `json:"new_repo,omitempty"` // true when add_pr is the first PR for this repo
+	DefaultAutopilot string          `json:"default_autopilot,omitempty"`
 }
 
 type Handler struct {
@@ -76,6 +78,10 @@ func (h *Handler) Handle(conn net.Conn) {
 			h.handleSetMergeMethod(conn, req.PRKey, req.MergeMethod)
 		case "toggle_review":
 			h.handleToggleReview(conn, req.PRKey)
+		case "set_default_autopilot":
+			h.handleSetDefaultAutopilot(conn, req.DefaultAutopilot)
+		case "get_config":
+			h.handleGetConfig(conn)
 		}
 	}
 }
@@ -102,8 +108,9 @@ func (h *Handler) handleSubscribe(conn net.Conn) {
 
 func (h *Handler) stateSnapshot() ctlResponse {
 	resp := ctlResponse{
-		Event:    "state_updated",
-		Sessions: h.state.GetSessions(),
+		Event:            "state_updated",
+		Sessions:         h.state.GetSessions(),
+		DefaultAutopilot: h.state.GetDefaultAutopilot(),
 	}
 	if h.prPoll != nil {
 		resp.PRs = h.prPoll.GetAll()
@@ -274,6 +281,18 @@ func (h *Handler) handleToggleReview(conn net.Conn, key string) {
 	writeJSON(conn, ctlResponse{OK: &ok})
 }
 
+func (h *Handler) handleSetDefaultAutopilot(conn net.Conn, mode string) {
+	h.state.SetDefaultAutopilot(mode)
+	ok := true
+	writeJSON(conn, ctlResponse{OK: &ok, DefaultAutopilot: mode})
+}
+
+func (h *Handler) handleGetConfig(conn net.Conn) {
+	mode := h.state.GetDefaultAutopilot()
+	ok := true
+	writeJSON(conn, ctlResponse{OK: &ok, DefaultAutopilot: mode})
+}
+
 func writeJSON(conn net.Conn, v any) {
 	data, _ := json.Marshal(v)
 	data = append(data, '\n')

daemon/internal/state/config.go

@@ -0,0 +1,59 @@
+package state
+
+import (
+	"encoding/json"
+	"log"
+	"os"
+	"path/filepath"
+)
+
+// Config holds daemon-wide configuration persisted to ~/.csm/config.json.
+type Config struct {
+	// DefaultAutopilot is the autopilot mode applied to newly discovered
+	// sessions that have no persisted per-session override.
+	// Valid values: "" (none), "on", "yolo".
+	DefaultAutopilot string `json:"default_autopilot"`
+}
+
+// configPath returns the path to the config file (~/.csm/config.json).
+func configPath() string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(home, ".csm", "config.json")
+}
+
+// loadConfig reads ~/.csm/config.json and returns the parsed Config.
+// Missing file is treated as empty Config (zero value).
+func loadConfig(path string) Config {
+	if path == "" {
+		return Config{}
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		// File not found is normal on first run.
+		return Config{}
+	}
+	var cfg Config
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		log.Printf("state: failed to parse config %s: %v", path, err)
+		return Config{}
+	}
+	return cfg
+}
+
+// saveConfig writes cfg to the given path as JSON.
+func saveConfig(path string, cfg Config) {
+	if path == "" {
+		return
+	}
+	data, err := json.MarshalIndent(cfg, "", "  ")
+	if err != nil {
+		log.Printf("state: failed to marshal config: %v", err)
+		return
+	}
+	if err := os.WriteFile(path, data, 0o644); err != nil {
+		log.Printf("state: failed to save config to %s: %v", path, err)
+	}
+}

daemon/internal/state/state.go

@@ -44,6 +44,11 @@ type Manager struct {
 	subMu       sync.Mutex
 
 	autopilotPath string
+
+	// config holds daemon-wide settings (e.g., default autopilot mode).
+	config Config
+	// configFilePath is the path to ~/.csm/config.json (empty = no persistence).
+	configFilePath string
 }
 
 // New creates a new state Manager, loading persisted autopilot state.
@@ -61,6 +66,8 @@ func New() *Manager {
 		_ = os.MkdirAll(dir, 0o755)
 		m.autopilotPath = filepath.Join(dir, "autopilot.json")
 		m.loadAutopilot()
+		m.configFilePath = filepath.Join(dir, "config.json")
+		m.config = loadConfig(m.configFilePath)
 	}
 
 	return m
@@ -79,6 +86,8 @@ func NewWithDir(dir string) *Manager {
 		_ = os.MkdirAll(dir, 0o755)
 		m.autopilotPath = filepath.Join(dir, "autopilot.json")
 		m.loadAutopilot()
+		m.configFilePath = filepath.Join(dir, "config.json")
+		m.config = loadConfig(m.configFilePath)
 	}
 	return m
 }
@@ -101,9 +110,12 @@ func (m *Manager) RegisterSession(sid, cwd, permMode string) {
 	s.PermissionMode = permMode
 	s.ProjectName = filepath.Base(cwd)
 
-	// Restore persisted autopilot state.
+	// Restore persisted autopilot state; fall back to config default for new sessions.
 	if mode, ok := m.autopilot[sid]; ok && mode != "" {
 		s.AutopilotMode = mode
+	} else if !exists && m.config.DefaultAutopilot != "" {
+		s.AutopilotMode = m.config.DefaultAutopilot
+		log.Printf("state: applied default autopilot %s to session %s", m.config.DefaultAutopilot, sid)
 	}
 
 	m.notifySubscribers()
@@ -123,16 +135,32 @@ func (m *Manager) UnregisterSession(sid string) {
 	m.notifySubscribers()
 }
 
+// applyDefaultAutopilot sets the session's AutopilotMode to the configured
+// default when the session has no persisted per-session mode. Caller must
+// hold m.mu (write lock).
+func (m *Manager) applyDefaultAutopilot(s *model.Session) {
+	if _, hasPersisted := m.autopilot[s.SessionID]; hasPersisted {
+		// Per-session persisted state already handled separately; skip.
+		return
+	}
+	if s.AutopilotMode == "" && m.config.DefaultAutopilot != "" {
+		s.AutopilotMode = m.config.DefaultAutopilot
+		log.Printf("state: applied default autopilot %s to session %s", m.config.DefaultAutopilot, s.SessionID)
+	}
+}
+
 // UpdateSessionFromScanner merges scanner-discovered session data.
 func (m *Manager) UpdateSessionFromScanner(s *model.Session) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
 	existing, ok := m.sessions[s.SessionID]
 	if !ok {
-		// New session from scanner.
+		// New session from scanner — restore persisted mode or apply default.
 		if mode, okAP := m.autopilot[s.SessionID]; okAP && mode != "" {
 			s.AutopilotMode = mode
+		} else {
+			m.applyDefaultAutopilot(s)
 		}
 		m.sessions[s.SessionID] = s
 		m.notifySubscribers()
@@ -467,3 +495,24 @@ func (m *Manager) saveAutopilot() {
 		log.Printf("failed to save autopilot state: %v", err)
 	}
 }
+
+// GetDefaultAutopilot returns the daemon-wide default autopilot mode.
+// Empty string means no default (sessions start with autopilot off).
+func (m *Manager) GetDefaultAutopilot() string {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.config.DefaultAutopilot
+}
+
+// SetDefaultAutopilot updates the daemon-wide default autopilot mode and
+// persists it to ~/.csm/config.json. Valid values: "" (none), "on", "yolo".
+func (m *Manager) SetDefaultAutopilot(mode string) {
+	m.mu.Lock()
+	m.config.DefaultAutopilot = mode
+	cfgPath := m.configFilePath
+	cfg := m.config
+	m.mu.Unlock()
+
+	saveConfig(cfgPath, cfg)
+	log.Printf("state: default autopilot set to %q", mode)
+}

daemon/internal/state/state_test.go

@@ -858,3 +858,114 @@ func TestResolvePendingClearsPendingTools(t *testing.T) {
 		t.Error("HasDestructive should be false after resolve")
 	}
 }
+
+// --- Default autopilot ---
+
+// newTestManagerWithDefault creates a Manager without disk persistence but
+// with a pre-configured default autopilot mode.
+func newTestManagerWithDefault(defaultMode string) *Manager {
+	return &Manager{
+		sessions:  make(map[string]*model.Session),
+		autopilot: make(map[string]string),
+		pending:   make(map[string]*model.PendingApproval),
+		cooldowns: make(map[string]time.Time),
+		config:    Config{DefaultAutopilot: defaultMode},
+	}
+}
+
+// TestDefaultAutopilotAppliedOnRegister verifies that new sessions receive the
+// default autopilot mode when no per-session override exists.
+func TestDefaultAutopilotAppliedOnRegister(t *testing.T) {
+	m := newTestManagerWithDefault(model.AutopilotYolo)
+	m.RegisterSession("s1", "/path", "default")
+
+	sessions := m.GetSessions()
+	if sessions[0].AutopilotMode != model.AutopilotYolo {
+		t.Errorf("autopilot = %q, want yolo (default)", sessions[0].AutopilotMode)
+	}
+}
+
+// TestPersistedAutopilotOverridesDefault verifies that a persisted per-session
+// mode takes priority over the daemon-wide default.
+func TestPersistedAutopilotOverridesDefault(t *testing.T) {
+	m := newTestManagerWithDefault(model.AutopilotYolo)
+	m.autopilot["s1"] = model.AutopilotOn // persisted override
+	m.RegisterSession("s1", "/path", "default")
+
+	sessions := m.GetSessions()
+	if sessions[0].AutopilotMode != model.AutopilotOn {
+		t.Errorf("autopilot = %q, want on (persisted should override default yolo)", sessions[0].AutopilotMode)
+	}
+}
+
+// TestSetDefaultAutopilotPersistsToDisk verifies that SetDefaultAutopilot
+// writes to disk and is readable by a new manager loaded from the same dir.
+func TestSetDefaultAutopilotPersistsToDisk(t *testing.T) {
+	dir := t.TempDir()
+	m := NewWithDir(dir)
+	m.SetDefaultAutopilot(model.AutopilotYolo)
+
+	// New manager from same dir should load the persisted default.
+	m2 := NewWithDir(dir)
+	if got := m2.GetDefaultAutopilot(); got != model.AutopilotYolo {
+		t.Errorf("GetDefaultAutopilot = %q, want yolo", got)
+	}
+}
+
+// TestDefaultAutopilotAppliedOnScanner verifies that scanner-discovered
+// sessions also receive the default autopilot mode.
+func TestDefaultAutopilotAppliedOnScanner(t *testing.T) {
+	m := newTestManagerWithDefault(model.AutopilotOn)
+	s := &model.Session{SessionID: "scan-1", CWD: "/path", State: model.StateRunning, PID: 1}
+	m.UpdateSessionFromScanner(s)
+
+	sessions := m.GetSessions()
+	if sessions[0].AutopilotMode != model.AutopilotOn {
+		t.Errorf("scanner session autopilot = %q, want on (default)", sessions[0].AutopilotMode)
+	}
+}
+
+// TestDefaultNotAppliedWhenSessionAlreadyRegistered verifies that when a
+// session is first registered via hook (getting the default), a subsequent
+// scanner update does not clobber the mode.
+func TestDefaultNotAppliedWhenSessionAlreadyRegistered(t *testing.T) {
+	m := newTestManagerWithDefault(model.AutopilotOn)
+	// Hook registers the session; default is applied.
+	m.RegisterSession("s1", "/path", "default")
+
+	// User later cycles to yolo.
+	m.CycleAutopilot("s1") // on → yolo (since default applied "on" first)
+	// Actually start from registered state: default=on → cycle → yolo.
+	sessions := m.GetSessions()
+	if sessions[0].AutopilotMode != model.AutopilotYolo {
+		t.Fatalf("after cycle: want yolo, got %q", sessions[0].AutopilotMode)
+	}
+
+	// Now scanner update comes in for the existing session — should NOT reset mode.
+	s := &model.Session{SessionID: "s1", CWD: "/scanner/path", State: model.StateRunning, PID: 999}
+	m.UpdateSessionFromScanner(s)
+
+	sessions = m.GetSessions()
+	if sessions[0].AutopilotMode != model.AutopilotYolo {
+		t.Errorf("scanner update clobbered autopilot: got %q, want yolo", sessions[0].AutopilotMode)
+	}
+}
+
+// TestGetSetDefaultAutopilot verifies the get/set round-trip in-memory.
+func TestGetSetDefaultAutopilot(t *testing.T) {
+	m := newTestManager()
+
+	if got := m.GetDefaultAutopilot(); got != "" {
+		t.Errorf("initial default = %q, want empty", got)
+	}
+
+	m.SetDefaultAutopilot(model.AutopilotOn)
+	if got := m.GetDefaultAutopilot(); got != model.AutopilotOn {
+		t.Errorf("after set: default = %q, want on", got)
+	}
+
+	m.SetDefaultAutopilot("")
+	if got := m.GetDefaultAutopilot(); got != "" {
+		t.Errorf("after clear: default = %q, want empty", got)
+	}
+}