kandev/apps/backend/internal/agent/lifecycle/manager_interaction_test.go

package lifecycle

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"slices"
	"sync"
	"testing"
	"time"

	"github.com/gorilla/websocket"
	"github.com/stretchr/testify/require"

	"github.com/kandev/kandev/internal/agent/executor"
	"github.com/kandev/kandev/internal/agentctl/server/process"
	"github.com/kandev/kandev/internal/agentctl/types/streams"
	"github.com/kandev/kandev/internal/events"
	"github.com/kandev/kandev/internal/task/models"
	v1 "github.com/kandev/kandev/pkg/api/v1"
	ws "github.com/kandev/kandev/pkg/websocket"
)

type restartMockAgentctlServer struct {
	server *httptest.Server

	mu          sync.Mutex
	httpActions []string
	wsActions   []string

	failStop       bool
	failSessionNew bool
}

func newRestartMockAgentctlServer(t *testing.T, failStop, failSessionNew bool) *restartMockAgentctlServer {
	t.Helper()

	m := &restartMockAgentctlServer{
		failStop:       failStop,
		failSessionNew: failSessionNew,
	}

	upgrader := websocket.Upgrader{
		CheckOrigin: func(_ *http.Request) bool { return true },
	}

	mux := http.NewServeMux()
	mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte(`{"ok":true}`))
	})
	mux.HandleFunc("/api/v1/stop", func(w http.ResponseWriter, _ *http.Request) {
		m.recordHTTP("stop")
		if m.failStop {
			_, _ = w.Write([]byte(`{"success":false,"error":"stop failed"}`))
			return
		}
		_, _ = w.Write([]byte(`{"success":true}`))
	})
	mux.HandleFunc("/api/v1/agent/configure", func(w http.ResponseWriter, _ *http.Request) {
		m.recordHTTP("configure")
		_, _ = w.Write([]byte(`{"success":true}`))
	})
	mux.HandleFunc("/api/v1/start", func(w http.ResponseWriter, _ *http.Request) {
		m.recordHTTP("start")
		_, _ = w.Write([]byte(`{"success":true,"command":"auggie --model test"}`))
	})
	mux.HandleFunc("/api/v1/agent/stream", func(w http.ResponseWriter, r *http.Request) {
		conn, err := upgrader.Upgrade(w, r, nil)
		if err != nil {
			return
		}
		defer func() { _ = conn.Close() }()

		for {
			_, message, err := conn.ReadMessage()
			if err != nil {
				return
			}

			var msg ws.Message
			if err := json.Unmarshal(message, &msg); err != nil {
				continue
			}
			if msg.Type != ws.MessageTypeRequest {
				continue
			}

			m.recordWS(msg.Action)

			var resp *ws.Message
			switch msg.Action {
			case "agent.initialize":
				resp, _ = ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
					"success": true,
					"agent_info": map[string]string{
						"name":    "test-agent",
						"version": "1.0.0",
					},
				})
			case "agent.session.new":
				if m.failSessionNew {
					resp, _ = ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
						"success": false,
						"error":   "session new failed",
					})
				} else {
					resp, _ = ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
						"success":    true,
						"session_id": "new-session-123",
					})
				}
			default:
				resp, _ = ws.NewError(msg.ID, msg.Action, ws.ErrorCodeUnknownAction, "unknown action", nil)
			}

			data, _ := json.Marshal(resp)
			if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
				return
			}
		}
	})
	mux.HandleFunc("/api/v1/workspace/stream", func(w http.ResponseWriter, r *http.Request) {
		conn, err := upgrader.Upgrade(w, r, nil)
		if err != nil {
			return
		}
		defer func() { _ = conn.Close() }()

		connected := map[string]string{"type": "connected"}
		data, _ := json.Marshal(connected)
		_ = conn.WriteMessage(websocket.TextMessage, data)

		for {
			if _, _, err := conn.ReadMessage(); err != nil {
				return
			}
		}
	})

	m.server = httptest.NewServer(mux)
	t.Cleanup(m.server.Close)
	return m
}

func (m *restartMockAgentctlServer) recordHTTP(action string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.httpActions = append(m.httpActions, action)
}

func (m *restartMockAgentctlServer) recordWS(action string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.wsActions = append(m.wsActions, action)
}

func (m *restartMockAgentctlServer) getHTTPActions() []string {
	m.mu.Lock()
	defer m.mu.Unlock()
	out := make([]string, len(m.httpActions))
	copy(out, m.httpActions)
	return out
}

func (m *restartMockAgentctlServer) getWSActions() []string {
	m.mu.Lock()
	defer m.mu.Unlock()
	out := make([]string, len(m.wsActions))
	copy(out, m.wsActions)
	return out
}

func TestManager_RestartAgentProcess_Success(t *testing.T) {
	mgr := newTestManager()
	mock := newRestartMockAgentctlServer(t, false, false)

	client := createTestClient(t, mock.server.URL)
	t.Cleanup(client.Close)

	exec := &AgentExecution{
		ID:             "exec-1",
		TaskID:         "task-1",
		SessionID:      "session-1",
		AgentProfileID: "profile-1",
		ACPSessionID:   "old-session",
		AgentCommand:   "auggie --model test",
		Status:         v1.AgentStatusRunning,
		WorkspacePath:  "/workspace",
		Metadata: map[string]interface{}{
			"task_description": "review the changes",
		},
		agentctl:     client,
		promptDoneCh: make(chan PromptCompletionSignal, 1),
	}
	exec.messageBuffer.WriteString("old-response")
	exec.thinkingBuffer.WriteString("old-thinking")
	exec.currentMessageID = "msg-1"
	exec.currentThinkingID = "th-1"
	exec.needsResumeContext = true
	exec.resumeContextInjected = true
	exec.promptDoneCh <- PromptCompletionSignal{StopReason: "stale"}

	mgr.executionStore.Add(exec)

	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer cancel()

	if err := mgr.RestartAgentProcess(ctx, exec.ID); err != nil {
		t.Fatalf("RestartAgentProcess failed: %v", err)
	}

	if exec.ACPSessionID != "new-session-123" {
		t.Fatalf("expected new ACP session ID, got %q", exec.ACPSessionID)
	}
	if exec.Status != v1.AgentStatusReady {
		t.Fatalf("expected status %q, got %q", v1.AgentStatusReady, exec.Status)
	}
	if exec.messageBuffer.Len() != 0 || exec.thinkingBuffer.Len() != 0 {
		t.Fatalf("expected message buffers to be reset")
	}
	if exec.currentMessageID != "" || exec.currentThinkingID != "" {
		t.Fatalf("expected streaming message IDs to be reset")
	}
	if exec.needsResumeContext || exec.resumeContextInjected {
		t.Fatalf("expected resume context flags to be reset")
	}
	select {
	case <-exec.promptDoneCh:
		t.Fatalf("expected stale prompt signal to be drained")
	default:
	}

	httpActions := mock.getHTTPActions()
	if !slices.Equal(httpActions, []string{"stop", "configure", "start"}) {
		t.Fatalf("unexpected HTTP action order: %v", httpActions)
	}

	wsActions := mock.getWSActions()
	if !slices.Equal(wsActions, []string{"agent.initialize", "agent.session.new"}) {
		t.Fatalf("unexpected WS action order: %v", wsActions)
	}

	mockBus, ok := mgr.eventBus.(*MockEventBus)
	if !ok {
		t.Fatal("expected mock event bus")
	}
	eventTypes := make([]string, 0, len(mockBus.PublishedEvents))
	for _, ev := range mockBus.PublishedEvents {
		eventTypes = append(eventTypes, ev.Type)
	}
	// Restart is a boot scenario — initializeACPSessionForRestart publishes
	// AgentBootReady (not AgentReady) so the orchestrator routes it to
	// handleAgentBootReady rather than evaluating on_turn_complete.
	if !slices.Contains(eventTypes, events.AgentBootReady) {
		t.Fatalf("expected %q event, got %v", events.AgentBootReady, eventTypes)
	}
	if !slices.Contains(eventTypes, events.AgentACPSessionCreated) {
		t.Fatalf("expected %q event, got %v", events.AgentACPSessionCreated, eventTypes)
	}
	if !slices.Contains(eventTypes, events.AgentContextReset) {
		t.Fatalf("expected %q event, got %v", events.AgentContextReset, eventTypes)
	}
}

func TestManager_RestartAgentProcess_StopErrorIsNonFatal(t *testing.T) {
	mgr := newTestManager()
	mock := newRestartMockAgentctlServer(t, true, false)

	client := createTestClient(t, mock.server.URL)
	t.Cleanup(client.Close)

	exec := &AgentExecution{
		ID:             "exec-stop-error",
		TaskID:         "task-1",
		SessionID:      "session-1",
		AgentProfileID: "profile-1",
		AgentCommand:   "auggie --model test",
		Status:         v1.AgentStatusRunning,
		WorkspacePath:  "/workspace",
		agentctl:       client,
		promptDoneCh:   make(chan PromptCompletionSignal, 1),
	}
	mgr.executionStore.Add(exec)

	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer cancel()

	if err := mgr.RestartAgentProcess(ctx, exec.ID); err != nil {
		t.Fatalf("expected restart to continue after stop failure, got: %v", err)
	}
}

func TestManager_RestartAgentProcess_SessionInitFailure(t *testing.T) {
	mgr := newTestManager()
	mock := newRestartMockAgentctlServer(t, false, true)

	client := createTestClient(t, mock.server.URL)
	t.Cleanup(client.Close)

	exec := &AgentExecution{
		ID:             "exec-session-fail",
		TaskID:         "task-1",
		SessionID:      "session-1",
		AgentProfileID: "profile-1",
		AgentCommand:   "auggie --model test",
		Status:         v1.AgentStatusRunning,
		WorkspacePath:  "/workspace",
		agentctl:       client,
		promptDoneCh:   make(chan PromptCompletionSignal, 1),
	}
	mgr.executionStore.Add(exec)

	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer cancel()

	err := mgr.RestartAgentProcess(ctx, exec.ID)
	if err == nil {
		t.Fatal("expected restart to fail when ACP session initialization fails")
	}

	updated, found := mgr.executionStore.Get(exec.ID)
	if !found {
		t.Fatal("expected execution to still exist")
	}
	if updated.Status != v1.AgentStatusFailed {
		t.Fatalf("expected status %q, got %q", v1.AgentStatusFailed, updated.Status)
	}
	if updated.ErrorMessage == "" {
		t.Fatal("expected execution error message to be set")
	}

	mockBus, ok := mgr.eventBus.(*MockEventBus)
	if !ok {
		t.Fatal("expected mock event bus")
	}
	for _, ev := range mockBus.PublishedEvents {
		if ev.Type == events.AgentContextReset {
			t.Fatalf("did not expect %q event on failed restart", events.AgentContextReset)
		}
	}
}

// --- IsAgentRunningForSession tests ---

// mockExecutorWithRunner implements ExecutorBackend and returns a real InteractiveRunner.
type mockExecutorWithRunner struct {
	MockExecutor
	runner *process.InteractiveRunner
}

func (m *mockExecutorWithRunner) GetInteractiveRunner() *process.InteractiveRunner {
	return m.runner
}

func TestIsAgentRunningForSession(t *testing.T) {
	t.Run("no execution returns false", func(t *testing.T) {
		store := NewExecutionStore()
		mgr := &Manager{executionStore: store, logger: newTestLogger().WithFields()}
		require.False(t, mgr.IsAgentRunningForSession(context.Background(), "nonexistent"))
	})

	t.Run("passthrough with alive process returns true", func(t *testing.T) {
		log := newTestLogger()
		runner := process.NewInteractiveRunner(nil, log, 2*1024*1024)

		// Start a deferred process (pending but alive)
		info, err := runner.Start(context.Background(), process.InteractiveStartRequest{
			SessionID: "session-pt",
			Command:   []string{"cat"},
		})
		require.NoError(t, err)

		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:                   "exec-pt",
			SessionID:            "session-pt",
			PassthroughProcessID: info.ID,
			Status:               v1.AgentStatusRunning,
		})

		execRegistry := NewExecutorRegistry(log)
		execRegistry.Register(&mockExecutorWithRunner{
			MockExecutor: MockExecutor{name: executor.NameStandalone},
			runner:       runner,
		})

		mgr := &Manager{
			executionStore:   store,
			executorRegistry: execRegistry,
			logger:           log.WithFields(),
		}
		require.True(t, mgr.IsAgentRunningForSession(context.Background(), "session-pt"))
	})

	t.Run("passthrough with dead process returns false", func(t *testing.T) {
		log := newTestLogger()
		runner := process.NewInteractiveRunner(nil, log, 2*1024*1024)

		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:                   "exec-dead",
			SessionID:            "session-dead",
			PassthroughProcessID: "nonexistent-process-id",
			Status:               v1.AgentStatusRunning,
		})

		execRegistry := NewExecutorRegistry(log)
		execRegistry.Register(&mockExecutorWithRunner{
			MockExecutor: MockExecutor{name: executor.NameStandalone},
			runner:       runner,
		})

		mgr := &Manager{
			executionStore:   store,
			executorRegistry: execRegistry,
			logger:           log.WithFields(),
		}
		require.False(t, mgr.IsAgentRunningForSession(context.Background(), "session-dead"))
	})

	t.Run("passthrough with nil executor registry returns false", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:                   "exec-noreg",
			SessionID:            "session-noreg",
			PassthroughProcessID: "some-process-id",
			Status:               v1.AgentStatusRunning,
		})

		mgr := &Manager{
			executionStore: store,
			logger:         newTestLogger().WithFields(),
		}
		require.False(t, mgr.IsAgentRunningForSession(context.Background(), "session-noreg"))
	})

	t.Run("ACP execution with nil agentctl returns false", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:        "exec-acp-nil",
			SessionID: "session-acp-nil",
			Status:    v1.AgentStatusRunning,
			// No PassthroughProcessID → ACP path
			// No agentctl → returns false
		})

		mgr := &Manager{
			executionStore: store,
			logger:         newTestLogger().WithFields(),
		}
		require.False(t, mgr.IsAgentRunningForSession(context.Background(), "session-acp-nil"))
	})

	t.Run("ACP execution with running agent returns true", func(t *testing.T) {
		// Mock agentctl server that returns "running" status
		statusServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.URL.Path == "/api/v1/status" {
				w.Header().Set("Content-Type", "application/json")
				_, _ = w.Write([]byte(`{"agent_status":"running"}`))
				return
			}
			w.WriteHeader(http.StatusNotFound)
		}))
		t.Cleanup(statusServer.Close)

		client := createTestClient(t, statusServer.URL)
		t.Cleanup(client.Close)

		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:        "exec-acp-running",
			SessionID: "session-acp-running",
			Status:    v1.AgentStatusRunning,
			agentctl:  client,
		})

		mgr := &Manager{
			executionStore: store,
			logger:         newTestLogger().WithFields(),
		}
		require.True(t, mgr.IsAgentRunningForSession(context.Background(), "session-acp-running"))
	})

	t.Run("ACP execution with stopped agent returns false", func(t *testing.T) {
		statusServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.URL.Path == "/api/v1/status" {
				w.Header().Set("Content-Type", "application/json")
				_, _ = w.Write([]byte(`{"agent_status":"stopped"}`))
				return
			}
			w.WriteHeader(http.StatusNotFound)
		}))
		t.Cleanup(statusServer.Close)

		client := createTestClient(t, statusServer.URL)
		t.Cleanup(client.Close)

		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:        "exec-acp-stopped",
			SessionID: "session-acp-stopped",
			Status:    v1.AgentStatusRunning,
			agentctl:  client,
		})

		mgr := &Manager{
			executionStore: store,
			logger:         newTestLogger().WithFields(),
		}
		require.False(t, mgr.IsAgentRunningForSession(context.Background(), "session-acp-stopped"))
	})
}

// --- IsRemoteSession tests ---

type mockWorkspaceInfoProvider struct {
	infos    map[string]*WorkspaceInfo
	envInfos map[string]*WorkspaceInfo
	err      error
}

func (m *mockWorkspaceInfoProvider) GetWorkspaceInfoForSession(_ context.Context, _, sessionID string) (*WorkspaceInfo, error) {
	if m.err != nil {
		return nil, m.err
	}
	return m.infos[sessionID], nil
}

func (m *mockWorkspaceInfoProvider) GetWorkspaceInfoForEnvironment(_ context.Context, taskEnvironmentID string) (*WorkspaceInfo, error) {
	if m.err != nil {
		return nil, m.err
	}
	if m.envInfos != nil {
		return m.envInfos[taskEnvironmentID], nil
	}
	for _, info := range m.infos {
		if info.TaskEnvironmentID == taskEnvironmentID {
			return info, nil
		}
	}
	return nil, nil
}

func TestIsRemoteSession(t *testing.T) {
	t.Run("in-memory execution with sprites runtime", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:          "exec-1",
			SessionID:   "session-1",
			RuntimeName: string(executor.NameSprites),
			Status:      v1.AgentStatusRunning,
		})
		mgr := &Manager{executionStore: store}
		require.True(t, mgr.IsRemoteSession(context.Background(), "session-1"))
	})

	t.Run("in-memory execution with is_remote metadata", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:          "exec-2",
			SessionID:   "session-2",
			RuntimeName: string(executor.NameStandalone),
			Status:      v1.AgentStatusRunning,
			Metadata:    map[string]interface{}{MetadataKeyIsRemote: true},
		})
		mgr := &Manager{executionStore: store}
		require.True(t, mgr.IsRemoteSession(context.Background(), "session-2"))
	})

	t.Run("in-memory execution with local runtime", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:          "exec-3",
			SessionID:   "session-3",
			RuntimeName: string(executor.NameStandalone),
			Status:      v1.AgentStatusRunning,
		})
		mgr := &Manager{executionStore: store}
		require.False(t, mgr.IsRemoteSession(context.Background(), "session-3"))
	})

	t.Run("not in memory, DB returns sprites executor type", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{
			infos: map[string]*WorkspaceInfo{
				"session-4": {ExecutorType: string(models.ExecutorTypeSprites)},
			},
		}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.True(t, mgr.IsRemoteSession(context.Background(), "session-4"))
	})

	t.Run("not in memory, DB returns remote_docker executor type", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{
			infos: map[string]*WorkspaceInfo{
				"session-5": {ExecutorType: string(models.ExecutorTypeRemoteDocker)},
			},
		}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.True(t, mgr.IsRemoteSession(context.Background(), "session-5"))
	})

	t.Run("not in memory, DB returns sprites runtime name", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{
			infos: map[string]*WorkspaceInfo{
				"session-6": {RuntimeName: string(executor.NameSprites)},
			},
		}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.True(t, mgr.IsRemoteSession(context.Background(), "session-6"))
	})

	t.Run("not in memory, DB returns local type", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{
			infos: map[string]*WorkspaceInfo{
				"session-7": {ExecutorType: string(models.ExecutorTypeLocal)},
			},
		}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.False(t, mgr.IsRemoteSession(context.Background(), "session-7"))
	})

	t.Run("not in memory, DB error returns false", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{err: fmt.Errorf("db error")}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.False(t, mgr.IsRemoteSession(context.Background(), "session-8"))
	})

	t.Run("nil workspaceInfoProvider returns false", func(t *testing.T) {
		store := NewExecutionStore()
		mgr := &Manager{executionStore: store}
		require.False(t, mgr.IsRemoteSession(context.Background(), "nonexistent"))
	})
}

func TestShouldUseContainerShell(t *testing.T) {
	t.Run("in-memory execution with docker runtime", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:          "exec-1",
			SessionID:   "session-1",
			RuntimeName: string(executor.NameDocker),
			Status:      v1.AgentStatusRunning,
		})
		mgr := &Manager{executionStore: store}
		require.True(t, mgr.ShouldUseContainerShell(context.Background(), "session-1"))
	})

	t.Run("in-memory execution with sprites runtime", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:          "exec-2",
			SessionID:   "session-2",
			RuntimeName: string(executor.NameSprites),
			Status:      v1.AgentStatusRunning,
		})
		mgr := &Manager{executionStore: store}
		require.True(t, mgr.ShouldUseContainerShell(context.Background(), "session-2"))
	})

	t.Run("in-memory execution with is_remote metadata", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:          "exec-3",
			SessionID:   "session-3",
			RuntimeName: string(executor.NameStandalone),
			Status:      v1.AgentStatusRunning,
			Metadata:    map[string]interface{}{MetadataKeyIsRemote: true},
		})
		mgr := &Manager{executionStore: store}
		require.True(t, mgr.ShouldUseContainerShell(context.Background(), "session-3"))
	})

	t.Run("in-memory execution with standalone runtime", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:          "exec-4",
			SessionID:   "session-4",
			RuntimeName: string(executor.NameStandalone),
			Status:      v1.AgentStatusRunning,
		})
		mgr := &Manager{executionStore: store}
		require.False(t, mgr.ShouldUseContainerShell(context.Background(), "session-4"))
	})

	t.Run("not in memory, DB returns local_docker executor type", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{
			infos: map[string]*WorkspaceInfo{
				"session-5": {ExecutorType: string(models.ExecutorTypeLocalDocker)},
			},
		}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.True(t, mgr.ShouldUseContainerShell(context.Background(), "session-5"))
	})

	t.Run("not in memory, DB returns sprites executor type", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{
			infos: map[string]*WorkspaceInfo{
				"session-6": {ExecutorType: string(models.ExecutorTypeSprites)},
			},
		}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.True(t, mgr.ShouldUseContainerShell(context.Background(), "session-6"))
	})

	t.Run("not in memory, DB returns docker runtime name", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{
			infos: map[string]*WorkspaceInfo{
				"session-7": {RuntimeName: string(executor.NameDocker)},
			},
		}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.True(t, mgr.ShouldUseContainerShell(context.Background(), "session-7"))
	})

	t.Run("not in memory, DB returns local type", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{
			infos: map[string]*WorkspaceInfo{
				"session-8": {ExecutorType: string(models.ExecutorTypeLocal)},
			},
		}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.False(t, mgr.ShouldUseContainerShell(context.Background(), "session-8"))
	})

	t.Run("not in memory, DB error returns false", func(t *testing.T) {
		store := NewExecutionStore()
		provider := &mockWorkspaceInfoProvider{err: fmt.Errorf("db error")}
		mgr := &Manager{executionStore: store, workspaceInfoProvider: provider}
		require.False(t, mgr.ShouldUseContainerShell(context.Background(), "session-9"))
	})

	t.Run("nil workspaceInfoProvider returns false", func(t *testing.T) {
		store := NewExecutionStore()
		mgr := &Manager{executionStore: store}
		require.False(t, mgr.ShouldUseContainerShell(context.Background(), "nonexistent"))
	})
}

func TestFallbackAuthMethods(t *testing.T) {
	t.Run("claude-acp returns auth login method", func(t *testing.T) {
		methods := fallbackAuthMethods("claude-acp")
		require.Len(t, methods, 1)
		require.Equal(t, "claude-auth-login", methods[0].ID)
		require.Equal(t, "Anthropic Authentication", methods[0].Name)
		require.NotNil(t, methods[0].TerminalAuth)
		require.Equal(t, "claude", methods[0].TerminalAuth.Command)
		require.Equal(t, []string{"auth", "login"}, methods[0].TerminalAuth.Args)
	})

	t.Run("auggie returns login method", func(t *testing.T) {
		methods := fallbackAuthMethods("auggie")
		require.Len(t, methods, 1)
		require.Equal(t, "auggie-login", methods[0].ID)
		require.Equal(t, "Auggie Authentication", methods[0].Name)
		require.NotNil(t, methods[0].TerminalAuth)
		require.Equal(t, "auggie", methods[0].TerminalAuth.Command)
		require.Equal(t, []string{"login"}, methods[0].TerminalAuth.Args)
	})

	t.Run("unknown agent returns nil", func(t *testing.T) {
		require.Nil(t, fallbackAuthMethods("unknown-agent"))
	})

	t.Run("empty agent ID returns nil", func(t *testing.T) {
		require.Nil(t, fallbackAuthMethods(""))
	})
}

func TestGetSessionAuthMethodsFallback(t *testing.T) {
	t.Run("returns cached methods when available", func(t *testing.T) {
		store := NewExecutionStore()
		exec := &AgentExecution{
			ID:        "exec-1",
			SessionID: "session-1",
			AgentID:   "claude-acp",
		}
		exec.SetAuthMethods([]streams.AuthMethodInfo{
			{ID: "custom-method", Name: "Custom"},
		})
		store.Add(exec)
		mgr := &Manager{executionStore: store}

		methods := mgr.GetSessionAuthMethods("session-1")
		require.Len(t, methods, 1)
		require.Equal(t, "custom-method", methods[0].ID)
	})

	t.Run("falls back to static methods when cache is empty", func(t *testing.T) {
		store := NewExecutionStore()
		store.Add(&AgentExecution{
			ID:        "exec-2",
			SessionID: "session-2",
			AgentID:   "claude-acp",
		})
		mgr := &Manager{executionStore: store}

		methods := mgr.GetSessionAuthMethods("session-2")
		require.Len(t, methods, 1)
		require.Equal(t, "claude-auth-login", methods[0].ID)
	})

	t.Run("returns nil for unknown session", func(t *testing.T) {
		store := NewExecutionStore()
		mgr := &Manager{executionStore: store}
		require.Nil(t, mgr.GetSessionAuthMethods("nonexistent"))
	})
}