Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

94.4 KB
Raw Blame
package ai

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/agentcapabilities"
	"github.com/rcourtman/pulse-go-rewrite/internal/agentexec"
	"github.com/rcourtman/pulse-go-rewrite/internal/ai/cost"
	"github.com/rcourtman/pulse-go-rewrite/internal/ai/knowledge"
	"github.com/rcourtman/pulse-go-rewrite/internal/ai/providers"
	"github.com/rcourtman/pulse-go-rewrite/internal/config"
	"github.com/rcourtman/pulse-go-rewrite/internal/models"
	"github.com/rcourtman/pulse-go-rewrite/internal/monitoring"
	"github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
)

func TestServiceCommercialLogsUseSafeRemediationCopy(t *testing.T) {
	source, err := os.ReadFile("service.go")
	if err != nil {
		t.Fatalf("read service.go: %v", err)
	}
	text := string(source)

	if !strings.Contains(text, "Patrol safe remediation requires Pulse Pro license") {
		t.Fatal("expected Patrol remediation license log copy")
	}
	if strings.Contains(text, "AI Patrol Auto-Fix requires Pulse Pro license") {
		t.Fatal("runtime logs must not revive Patrol Auto-Fix commercial copy")
	}
}

func TestLegacyAssistantReadOnlyProjectionAndRuntimeAgree(t *testing.T) {
	svc := &Service{cfg: &config.AIConfig{ControlLevel: config.ControlLevelReadOnly}}
	projected := map[string]bool{}
	for _, tool := range svc.getTools() {
		projected[tool.Name] = true
	}
	if !projected[agentcapabilities.LegacyAssistantFetchURLToolName] {
		t.Fatal("read-only legacy projection must retain fetch_url")
	}
	for _, name := range []string{
		agentcapabilities.LegacyAssistantRunCommandToolName,
		agentcapabilities.LegacyAssistantSetResourceURLToolName,
		agentcapabilities.ResolveFindingCapabilityName,
		agentcapabilities.DismissFindingCapabilityName,
	} {
		if projected[name] {
			t.Fatalf("read-only legacy projection exposed mutating alias %q", name)
		}
		result, execution := svc.executeTool(context.Background(), ExecuteRequest{}, providers.ToolCall{Name: name})
		if execution.Success || !strings.Contains(result, "Invocation blocked") {
			t.Fatalf("read-only legacy runtime did not block %q: success=%v result=%q", name, execution.Success, result)
		}
	}
}

func TestService_GetToolInputDisplay(t *testing.T) {
	svc := NewService(nil, nil)

	tests := []struct {
		name     string
		tc       providers.ToolCall
		expected string
	}{
		{
			name: "run_command",
			tc: providers.ToolCall{
				Name: agentcapabilities.LegacyAssistantRunCommandToolName,
				Input: map[string]interface{}{
					agentcapabilities.LegacyAssistantCommandArgumentName: "uptime",
				},
			},
			expected: "uptime",
		},
		{
			name: "run_command on host",
			tc: providers.ToolCall{
				Name: agentcapabilities.LegacyAssistantRunCommandToolName,
				Input: map[string]interface{}{
					agentcapabilities.LegacyAssistantCommandArgumentName:   "uptime",
					agentcapabilities.LegacyAssistantRunOnHostArgumentName: true,
				},
			},
			expected: "[host] uptime",
		},
		{
			name: "fetch_url",
			tc: providers.ToolCall{
				Name: agentcapabilities.LegacyAssistantFetchURLToolName,
				Input: map[string]interface{}{
					agentcapabilities.LegacyAssistantURLArgumentName: "https://google.com",
				},
			},
			expected: "https://google.com",
		},
		{
			name: "set_resource_url",
			tc: providers.ToolCall{
				Name: agentcapabilities.LegacyAssistantSetResourceURLToolName,
				Input: map[string]interface{}{
					agentcapabilities.LegacyAssistantResourceTypeArgumentName: "vm",
					agentcapabilities.LegacyAssistantURLArgumentName:          "http://1.2.3.4",
				},
			},
			expected: "Set vm URL: http://1.2.3.4",
		},
		{
			name: "unknown tool",
			tc: providers.ToolCall{
				Name: "unknown",
				Input: map[string]interface{}{
					"foo": "bar",
				},
			},
			expected: "map[foo:bar]",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := svc.getToolInputDisplay(tt.tc)
			if got != tt.expected {
				t.Errorf("getToolInputDisplay() = %v, want %v", got, tt.expected)
			}
		})
	}
}

func TestService_GetTools(t *testing.T) {
	svc := NewService(nil, nil)
	svc.cfg = &config.AIConfig{Enabled: true, ControlLevel: config.ControlLevelControlled}

	tools := svc.getTools()
	if len(tools) == 0 {
		t.Error("Expected tools")
	}

	// The retired raw-command alias must not be projected even when the legacy
	// control level is configured to allow governed actions.
	for _, tool := range tools {
		if tool.Name == agentcapabilities.LegacyAssistantRunCommandToolName {
			t.Fatal("retired run_command alias was projected to the provider")
		}
	}
}

func TestService_GetToolsUsesSharedLegacyUtilitySchemas(t *testing.T) {
	svc := NewService(nil, nil)
	svc.cfg = &config.AIConfig{ControlLevel: config.ControlLevelControlled}
	tools := svc.getTools()
	byName := map[string]providers.Tool{}
	for _, tool := range tools {
		byName[tool.Name] = tool
	}

	for _, shared := range agentcapabilities.LegacyAssistantUtilityProviderTools() {
		if shared.Name == agentcapabilities.LegacyAssistantSetResourceURLToolName {
			if _, ok := byName[shared.Name]; ok {
				t.Fatalf("legacy Assistant projection exposed Pulse-state mutation %s", shared.Name)
			}
			continue
		}
		assistantTool, ok := byName[shared.Name]
		if !ok {
			t.Fatalf("legacy Assistant tools missing %s", shared.Name)
		}
		if !providerSchemaRequiredEqual(assistantTool.InputSchema, shared.InputSchema) {
			t.Fatalf("%s Assistant provider schema required = %#v, want shared required %#v",
				shared.Name, assistantTool.InputSchema["required"], shared.InputSchema["required"])
		}
		gotProps, ok := assistantTool.InputSchema["properties"].(map[string]interface{})
		if !ok {
			t.Fatalf("%s Assistant provider schema properties = %T, want map", shared.Name, assistantTool.InputSchema["properties"])
		}
		wantProps, ok := shared.InputSchema["properties"].(map[string]interface{})
		if !ok {
			t.Fatalf("%s shared provider schema properties = %T, want map", shared.Name, shared.InputSchema["properties"])
		}
		for field := range wantProps {
			if _, ok := gotProps[field]; !ok {
				t.Fatalf("%s Assistant provider schema missing shared field %q: %#v", shared.Name, field, gotProps)
			}
		}
	}
}

func TestService_GetToolsExcludesFindingLifecycleMutations(t *testing.T) {
	svc := NewService(nil, nil)
	svc.cfg = &config.AIConfig{ControlLevel: config.ControlLevelControlled}
	tools := svc.getTools()
	byName := map[string]providers.Tool{}
	for _, tool := range tools {
		byName[tool.Name] = tool
	}

	for _, name := range []string{
		agentcapabilities.ResolveFindingCapabilityName,
		agentcapabilities.DismissFindingCapabilityName,
	} {
		if _, ok := byName[name]; ok {
			t.Fatalf("legacy Assistant projection exposed finding lifecycle mutation %s", name)
		}
	}
}

func providerSchemaRequiredEqual(got map[string]interface{}, want map[string]interface{}) bool {
	gotRequired := providerSchemaRequiredValues(got)
	wantRequired := providerSchemaRequiredValues(want)
	if len(gotRequired) != len(wantRequired) {
		return false
	}
	for i := range gotRequired {
		if gotRequired[i] != wantRequired[i] {
			return false
		}
	}
	return true
}

func providerSchemaRequiredContains(schema map[string]interface{}, want string) bool {
	for _, value := range providerSchemaRequiredValues(schema) {
		if value == want {
			return true
		}
	}
	return false
}

func providerSchemaRequiredValues(schema map[string]interface{}) []string {
	switch required := schema["required"].(type) {
	case []string:
		return append([]string(nil), required...)
	case []interface{}:
		values := make([]string, 0, len(required))
		for _, value := range required {
			if text, ok := value.(string); ok {
				values = append(values, text)
			}
		}
		return values
	default:
		return nil
	}
}

func TestService_AcquireExecutionSlot_Blocked(t *testing.T) {
	svc := NewService(nil, nil)

	// Fill all slots (4 by default)
	for i := 0; i < 4; i++ {
		_, err := svc.acquireExecutionSlot(context.Background(), "chat")
		if err != nil {
			t.Fatalf("Failed to fill slots: %v", err)
		}
	}

	// Try to acquire one more with a canceled context - should fail via ctx.Done()
	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	_, err := svc.acquireExecutionSlot(ctx, "chat")
	if err == nil {
		t.Error("Expected error when acquiring slot with canceled context")
	}

	// Try to acquire one more with a timeout - should fail via timeout case
	shortCtx, cancel2 := context.WithTimeout(context.Background(), 10*time.Millisecond)
	defer cancel2()

	// We need to wait slightly more than the shortCtx but less than the 5s hardcoded timeout
	// But wait, the hardcoded timeout in acquireExecutionSlot is the 3rd case.
	// We want to hit the second case.
	_, err = svc.acquireExecutionSlot(shortCtx, "chat")
	if err == nil {
		t.Error("Expected error when no slots available and context times out")
	}
}

func TestService_SetResourceURL(t *testing.T) {
	svc := NewService(nil, nil)
	mockMP := &mockMetadataProvider{}
	svc.SetMetadataProvider(mockMP)

	// Valid VM URL
	err := svc.SetResourceURL("vm", "pve-node-150", "http://192.168.1.10")
	if err != nil {
		t.Errorf("SetResourceURL failed: %v", err)
	}
	if mockMP.lastGuestID != "pve-node-150" || mockMP.lastGuestURL != "http://192.168.1.10" {
		t.Error("Mock did not receive correct guest data")
	}

	// URL without scheme (should auto-add http://)
	err = svc.SetResourceURL("app-container", "host:ct:123", "192.168.1.20:8080")
	if err != nil {
		t.Errorf("SetResourceURL failed: %v", err)
	}
	if mockMP.lastDockerID != "host:ct:123" || mockMP.lastDockerURL != "http://192.168.1.20:8080" {
		t.Errorf("Mock did not receive correct docker data, got %s", mockMP.lastDockerURL)
	}

	// Invalid URL
	err = svc.SetResourceURL("agent", "host-1", "not a url")
	if err == nil {
		t.Error("Expected error for invalid URL")
	}

	// Unknown resource type
	err = svc.SetResourceURL("unknown", "id", "http://test")
	if err == nil {
		t.Error("Expected error for unknown resource type")
	}
}

// TestConvertMetricPoints tests the metric conversion logic

func TestConvertMetricPoints(t *testing.T) {
	// Since MetricsHistoryAdapter is just a wrapper, we test the conversion functions
	now := time.Now()
	monitoringPoints := []monitoring.MetricPoint{
		{Value: 1.2, Timestamp: now},
	}

	aiPoints := convertMetricPoints(monitoringPoints)
	if len(aiPoints) != 1 || aiPoints[0].Value != 1.2 || !aiPoints[0].Timestamp.Equal(now) {
		t.Error("Conversion failed")
	}

	if convertMetricPoints(nil) != nil {
		t.Error("Should return nil for nil input")
	}
}

func TestNewMetricsHistoryAdapter(t *testing.T) {
	if NewMetricsHistoryAdapter(nil) != nil {
		t.Error("Expected nil for nil history")
	}
}

func TestService_HasAgentForTarget(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
	}
	svc := NewService(nil, mockServer)

	// Host target with no context (should match any agent)
	if !svc.hasAgentForTarget(ExecuteRequest{TargetType: "agent"}) {
		t.Error("Should have agent for host with no context")
	}

	// Target matching agent hostname
	if !svc.hasAgentForTarget(ExecuteRequest{
		TargetType: "vm",
		Context:    map[string]interface{}{"node": "node-1"},
	}) {
		t.Error("Should have agent for matching hostname")
	}

	// Target not matching
	if svc.hasAgentForTarget(ExecuteRequest{
		TargetType: "vm",
		Context:    map[string]interface{}{"node": "other-node"},
	}) {
		t.Error("Should not have agent for non-matching node")
	}

	// Empty agents
	svc.agentServer = &mockAgentServer{agents: []agentexec.ConnectedAgent{}}
	if svc.hasAgentForTarget(ExecuteRequest{TargetType: "agent"}) {
		t.Error("Should not have agent when none connected")
	}
}

func TestService_ExecuteOnAgent(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			if agentID != "agent-1" {
				return nil, fmt.Errorf("wrong agent")
			}
			return &agentexec.CommandResultPayload{
				Success: true,
				Stdout:  "ok",
			}, nil
		},
	}
	svc := NewService(nil, mockServer)

	// Basic execution
	output, err := svc.executeOnAgent(context.Background(), ExecuteRequest{
		TargetType: "agent",
		Context:    map[string]interface{}{"node": "node-1"},
	}, "uptime")
	if err != nil {
		t.Fatalf("ExecuteOnAgent failed: %v", err)
	}
	if output != "ok" {
		t.Errorf("Unexpected output: %s", output)
	}

	// Routing failure
	_, err = svc.executeOnAgent(context.Background(), ExecuteRequest{
		TargetType: "vm",
		Context:    map[string]interface{}{"node": "unknown"},
	}, "uptime")
	if err == nil {
		t.Error("Expected routing error")
	}
}

func TestService_RunCommandExtended(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}
	var executed agentexec.ExecuteCommandPayload
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			executed = cmd
			return &agentexec.CommandResultPayload{Success: true, Stdout: "Mock output"}, nil
		},
	}
	svc := NewService(nil, mockServer)

	// Successful run
	resp, err := svc.RunCommand(context.Background(), RunCommandRequest{
		Command:    "uptime",
		ApprovalID: "approval-1",
		TargetType: "agent",
		TargetHost: "node-1",
	})
	if err != nil {
		t.Fatalf("RunCommand failed: %v", err)
	}
	if !resp.Success {
		t.Errorf("RunCommand reported failure: %s", resp.Error)
	}
	if resp.Output != "Mock output" {
		t.Errorf("Unexpected output: %s", resp.Output)
	}
	if executed.ApprovalID != "approval-1" {
		t.Errorf("expected approval id to propagate, got %q", executed.ApprovalID)
	}

	// Failure (routing)
	resp, err = svc.RunCommand(context.Background(), RunCommandRequest{
		Command:    "uptime",
		TargetType: "agent",
		TargetHost: "unknown",
	})
	if err != nil {
		t.Fatalf("RunCommand failed with error: %v", err)
	}
	if resp.Success {
		t.Error("RunCommand should have failed")
	}
}

func TestService_ExecuteStreamExtended(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}
	mockAgentServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
	}

	callCount := 0
	mockProv := &mockProvider{
		chatFunc: func(ctx context.Context, req providers.ChatRequest) (*providers.ChatResponse, error) {
			callCount++
			if callCount == 1 {
				// First call: return a tool call
				return &providers.ChatResponse{
					ToolCalls: []providers.ToolCall{
						{
							ID:   "call-1",
							Name: "run_command",
							Input: map[string]interface{}{
								"command": "uptime",
							},
						},
					},
					StopReason: "tool_use",
				}, nil
			}
			// Second call: return final response
			return &providers.ChatResponse{
				Content:    "All systems clear.",
				StopReason: "end_turn",
			}, nil
		},
	}

	svc := NewService(nil, mockAgentServer)
	// Initialize persistence to avoid nil pointer dereference in buildSystemPrompt
	tmpDir := t.TempDir()
	svc.persistence = config.NewConfigPersistence(tmpDir)

	svc.provider = mockProv
	svc.cfg = &config.AIConfig{Enabled: true}
	// Initialize limits so acquireExecutionSlot works
	svc.limits = executionLimits{
		chatSlots:   make(chan struct{}, 10),
		patrolSlots: make(chan struct{}, 10),
	}

	events := []StreamEvent{}
	callback := func(ev StreamEvent) {
		events = append(events, ev)
	}

	req := ExecuteRequest{
		Prompt:     "Check status",
		Model:      "anthropic:test-model",
		TargetType: "agent",
		Context:    map[string]interface{}{"node": "node-1"},
	}

	resp, err := svc.ExecuteStream(context.Background(), req, callback)
	if err != nil {
		t.Fatalf("ExecuteStream failed: %v", err)
	}

	if resp.Content != "All systems clear." {
		t.Errorf("Unexpected content: %s", resp.Content)
	}

	if callCount != 2 {
		t.Errorf("Expected 2 AI calls, got %d", callCount)
	}

	// Verify events
	hasToolStart := false
	hasToolEnd := false
	for _, ev := range events {
		if ev.Type == "tool_start" {
			hasToolStart = true
		}
		if ev.Type == "tool_end" {
			hasToolEnd = true
		}
	}

	if !hasToolStart {
		t.Error("Missing tool_start event")
	}
	if !hasToolEnd {
		t.Error("Missing tool_end event")
	}
}

func TestApprovalNeededFromToolCall(t *testing.T) {
	req := ExecuteRequest{
		Context: map[string]interface{}{"node": "node-1"},
	}
	tc := providers.ToolCall{
		ID:   "call-1",
		Name: "run_command",
		Input: map[string]interface{}{
			"command": "uptime",
		},
	}
	result := formatApprovalNeededToolResult("uptime", "tool-1", "needs approval", "approval-1")

	data, needed := approvalNeededFromToolCall(req, tc, result)
	if !needed {
		t.Fatal("Expected approval needed")
	}
	if data.Command != "uptime" || data.TargetHost != "node-1" {
		t.Errorf("Unexpected data: %+v", data)
	}
	if data.ToolID != "tool-1" {
		t.Errorf("Expected parsed tool id, got %q", data.ToolID)
	}
	if data.ApprovalID != "approval-1" {
		t.Errorf("Expected parsed approval id, got %q", data.ApprovalID)
	}

	// Not a run_command
	tc.Name = "fetch_url"
	_, needed = approvalNeededFromToolCall(req, tc, result)
	if needed {
		t.Error("Should not need approval for fetch_url")
	}

	// No prefix
	tc.Name = "run_command"
	_, needed = approvalNeededFromToolCall(req, tc, "ok")
	if needed {
		t.Error("Should not need approval for normal result")
	}
}

func TestService_ExecuteTool_FetchURL(t *testing.T) {
	svc := NewService(nil, nil)
	// We need to mock fetchURL or just let it fail and check the error handling

	tc := providers.ToolCall{
		Name: "fetch_url",
		Input: map[string]interface{}{
			"url": "http://example.com",
		},
	}

	ctx := context.Background()
	req := ExecuteRequest{}

	result, exec := svc.executeTool(ctx, req, tc)
	if exec.Name != "fetch_url" {
		t.Errorf("Unexpected tool name: %s", exec.Name)
	}

	// Since we are in a limited environment, fetch might fail or be blocked.
	// But we want to see that executeTool handled it.
	if result == "" {
		t.Error("Expected non-empty result (either content or error)")
	}
}

func TestFormatContextKey(t *testing.T) {
	tests := []struct {
		key      string
		expected string
	}{
		{"guestName", "Guest Name"},
		{"vmid", "VMID"},
		{"node", "Host Node"},
		{"unknown_key", "unknown_key"},
	}

	for _, tt := range tests {
		if got := formatContextKey(tt.key); got != tt.expected {
			t.Errorf("formatContextKey(%q) = %q, want %q", tt.key, got, tt.expected)
		}
	}
}

func TestProviderDisplayName(t *testing.T) {
	tests := []struct {
		provider string
		expected string
	}{
		{config.AIProviderAnthropic, "Anthropic"},
		{config.AIProviderOpenAI, "OpenAI"},
		{config.AIProviderOpenRouter, "OpenRouter"},
		{"unknown", "unknown"},
	}

	for _, tt := range tests {
		if got := providerDisplayName(tt.provider); got != tt.expected {
			t.Errorf("providerDisplayName(%q) = %q, want %q", tt.provider, got, tt.expected)
		}
	}
}

func TestService_SetBaselineStore(t *testing.T) {
	svc := NewService(nil, nil)
	// Just verify it doesn't panic
	svc.SetBaselineStore(nil)
}

func TestService_GetDebugContext(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)
	svc.cfg = &config.AIConfig{Enabled: true, CustomContext: "Test context"}

	snapshot := models.StateSnapshot{
		Nodes: []models.Node{
			{ID: "node/node-1", Name: "node-1", Instance: "node-1", Status: "online"},
		},
		VMs: []models.VM{{Name: "vm-1", VMID: 100, Node: "node-1", Instance: "node-1"}},
	}
	registry := unifiedresources.NewRegistry(nil)
	registry.IngestSnapshot(snapshot)
	svc.SetReadState(registry)

	req := ExecuteRequest{Prompt: "test"}
	debug := svc.GetDebugContext(req)

	if debug["has_state_provider"] != true {
		t.Error("Expected has_state_provider to be true")
	}
	if debug["custom_context_preview"] != "Test context" {
		t.Errorf("Unexpected custom_context_preview: %v", debug["custom_context_preview"])
	}
	if debug["system_prompt"] == "" {
		t.Error("Expected non-empty system_prompt")
	}
}

func TestService_LoadConfig(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// 1. Initial state (no config file)
	err := svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}
	if svc.provider != nil {
		t.Error("Expected nil provider when no config exists")
	}

	// 2. Disabled config
	cfgV := config.AIConfig{Enabled: false}
	_ = persistence.SaveAIConfig(cfgV)
	err = svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}
	if svc.provider != nil {
		t.Error("Expected nil provider when AI is disabled")
	}

	// 3. Explicit route mismatch fails closed instead of silently switching providers.
	cfgV = config.AIConfig{
		Enabled:      true,
		Model:        "anthropic:claude-3-opus-20240229",
		OpenAIAPIKey: "sk-test",
	}
	_ = persistence.SaveAIConfig(cfgV)
	err = svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}
	if svc.provider != nil {
		t.Fatalf("expected no provider after explicit unconfigured route, got %s", svc.provider.Name())
	}
}

func TestService_EnforceBudget(t *testing.T) {
	svc := NewService(nil, nil)
	svc.cfg = &config.AIConfig{
		CostBudgetUSD30d: 1.0,
	}
	svc.costStore = cost.NewStore(30)

	// No usage yet - should pass
	if err := svc.enforceBudget("chat"); err != nil {
		t.Errorf("Expected no error, got %v", err)
	}

	// Record significant usage (e.g. 10 million tokens to exceed $1 budget)
	svc.costStore.Record(cost.UsageEvent{
		Provider:      "anthropic",
		RequestModel:  "claude-opus-20240229",
		ResponseModel: "claude-opus-20240229",
		InputTokens:   1000000,
		OutputTokens:  1000000,
	})

	// Budget should now be exceeded
	if err := svc.enforceBudget("chat"); err == nil {
		t.Error("Expected budget limit error")
	} else if !strings.Contains(err.Error(), "budget exceeded") {
		t.Errorf("Expected budget exceeded error, got: %v", err)
	}
}

func TestService_GetModelForRequest(t *testing.T) {
	svc := NewService(nil, nil)
	svc.cfg = &config.AIConfig{
		Enabled:     true,
		Model:       "default-model",
		ChatModel:   "chat-model",
		PatrolModel: "patrol-model",
	}

	// 1. Explicit override
	req := ExecuteRequest{Model: "override-model"}
	if got := svc.getModelForRequest(req); got != "override-model" {
		t.Errorf("Expected override-model, got %s", got)
	}

	// 2. Use case: patrol
	req = ExecuteRequest{UseCase: "patrol"}
	if got := svc.getModelForRequest(req); got != "patrol-model" {
		t.Errorf("Expected patrol-model, got %s", got)
	}

	// 3. Use case: chat
	req = ExecuteRequest{UseCase: "chat"}
	if got := svc.getModelForRequest(req); got != "chat-model" {
		t.Errorf("Expected chat-model, got %s", got)
	}

	// 4. Default
	req = ExecuteRequest{}
	if got := svc.getModelForRequest(req); got != "chat-model" {
		t.Errorf("Expected chat-model by default, got %s", got)
	}
}

func TestService_ExecuteTool_RunCommand(t *testing.T) {
	dispatched := false
	mockAgentServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{
			{Hostname: "node-1", AgentID: "agent-1"},
		},
		executeFunc: func(context.Context, string, agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			dispatched = true
			return &agentexec.CommandResultPayload{Success: true}, nil
		},
	}
	svc := NewService(nil, mockAgentServer)
	svc.cfg = &config.AIConfig{ControlLevel: config.ControlLevelControlled}

	// Mock policy
	mockPolicy := &mockPolicy{
		decision: agentexec.PolicyAllow,
	}
	svc.policy = mockPolicy

	tc := providers.ToolCall{
		Name: "run_command",
		Input: map[string]interface{}{
			"command": "uptime",
		},
	}

	ctx := context.Background()
	req := ExecuteRequest{
		Context: map[string]interface{}{"node": "node-1"},
	}

	result, exec := svc.executeTool(ctx, req, tc)
	if exec.Success || !strings.Contains(result, "Invocation blocked") {
		t.Fatalf("retired run_command did not fail closed: success=%v result=%q", exec.Success, result)
	}
	if dispatched {
		t.Fatal("retired run_command reached the agent transport")
	}
}

func TestService_ExecuteTool_SetResourceURLBlockedBeforeStore(t *testing.T) {
	svc := NewService(nil, nil)

	// Mock metadata provider
	mockMeta := &mockMetadataProvider{}
	svc.metadataProvider = mockMeta

	tc := providers.ToolCall{
		Name: "set_resource_url",
		Input: map[string]interface{}{
			"resource_type": "vm",
			"resource_id":   "instance-101",
			"url":           "http://example.com:8080",
		},
	}

	ctx := context.Background()
	req := ExecuteRequest{}

	result, exec := svc.executeTool(ctx, req, tc)
	if exec.Success || !strings.Contains(result, "Invocation blocked") {
		t.Fatalf("expected direct metadata mutation to be blocked, got success=%v result=%q", exec.Success, result)
	}
	if mockMeta.lastGuestID != "" || mockMeta.lastGuestURL != "" {
		t.Fatalf("metadata provider was called despite policy block: %+v", mockMeta)
	}
}

func TestService_PatrolManagement(t *testing.T) {
	svc := NewService(nil, nil)

	// Mock components
	patrol := NewPatrolService(svc, nil)
	svc.patrolService = patrol

	alertAnalyzer := &mockAlertAnalyzer{}
	svc.alertTriggeredAnalyzer = alertAnalyzer

	mockLicense := &mockLicenseStore{
		features: map[string]bool{
			FeatureAIPatrol: true,
			FeatureAIAlerts: true,
		},
	}
	svc.licenseChecker = mockLicense

	svc.cfg = &config.AIConfig{
		Enabled:                true,
		PatrolEnabled:          true,
		PatrolIntervalMinutes:  30,
		AlertTriggeredAnalysis: true,
	}

	ctx := context.Background()

	// 1. Start Patrol
	svc.StartPatrol(ctx)

	// Community installs enforce a minimum patrol interval unless licensed for auto-fix.
	expectedInterval := 30 * time.Minute
	if !mockLicense.features[FeatureAIAutoFix] && expectedInterval < minCommunityPatrolInterval {
		expectedInterval = minCommunityPatrolInterval
	}
	if patrol.GetConfig().Interval != expectedInterval {
		t.Errorf("Patrol interval not set correctly: %v", patrol.GetConfig().Interval)
	}
	if !alertAnalyzer.IsEnabled() {
		t.Error("Alert analyzer should be enabled")
	}

	// 2. Reconfigure Patrol
	svc.cfg.PatrolIntervalMinutes = 60
	svc.cfg.AlertTriggeredAnalysis = false
	svc.ReconfigurePatrol()

	if patrol.GetConfig().Interval != 60*time.Minute {
		t.Errorf("Patrol interval not updated: %v", patrol.GetConfig().Interval)
	}
	if alertAnalyzer.IsEnabled() {
		t.Error("Alert analyzer should be disabled")
	}

	// 3. License constraint
	mockLicense.features[FeatureAIAlerts] = false
	svc.cfg.AlertTriggeredAnalysis = true
	svc.ReconfigurePatrol()
	if alertAnalyzer.IsEnabled() {
		t.Error("Alert analyzer should be disabled due to lack of license")
	}
}

func TestService_StartPatrolHonorsDevBackgroundAIGuard(t *testing.T) {
	t.Setenv("PULSE_DEV", "true")
	t.Setenv(DevDisableBackgroundAIEnv, "true")

	svc := NewService(nil, nil)
	patrol := NewPatrolService(svc, nil)
	patrol.SetTriggerManager(NewTriggerManager(DefaultTriggerManagerConfig()))
	svc.patrolService = patrol

	alertAnalyzer := &mockAlertAnalyzer{enabled: true}
	svc.alertTriggeredAnalyzer = alertAnalyzer
	svc.licenseChecker = &mockLicenseStore{
		features: map[string]bool{
			FeatureAIPatrol: true,
			FeatureAIAlerts: true,
		},
	}
	svc.cfg = &config.AIConfig{
		Enabled:                      true,
		PatrolEnabled:                true,
		PatrolIntervalMinutes:        30,
		AlertTriggeredAnalysis:       true,
		PatrolEventTriggersEnabled:   true,
		PatrolAlertTriggersEnabled:   true,
		PatrolAnomalyTriggersEnabled: true,
	}

	svc.StartPatrol(context.Background())

	if alertAnalyzer.IsEnabled() {
		t.Fatal("expected dev background AI guard to keep alert analyzer disabled")
	}
	if status := patrol.GetStatus(); status.NextPatrolAt != nil {
		t.Fatalf("expected dev background AI guard to avoid scheduling patrol, got %v", status.NextPatrolAt)
	} else if status.TriggerStatus == nil {
		t.Fatal("expected dev background AI guard to expose trigger status")
	} else if !status.TriggerStatus.EventTriggersBlocked {
		t.Fatal("expected dev background AI guard to expose event trigger runtime block")
	} else if status.TriggerStatus.EventTriggersBlockedReason != EventTriggerBlockReasonBackgroundAutomationDisabled {
		t.Fatalf("unexpected event trigger block reason: %q", status.TriggerStatus.EventTriggersBlockedReason)
	} else if !status.TriggerStatus.AlertTriggersEnabled || !status.TriggerStatus.AnomalyTriggersEnabled {
		t.Fatal("expected dev background AI guard not to rewrite configured trigger preferences")
	}
}

func TestService_LookupNodeForVMID_Extended(t *testing.T) {
	svc := NewService(nil, nil)

	snapshot := models.StateSnapshot{
		Nodes: []models.Node{
			{ID: "node/node-1", Name: "node-1", Instance: "pve-1", Status: "online"},
			{ID: "node/node-2", Name: "node-2", Instance: "pve-1", Status: "online"},
		},
		VMs: []models.VM{
			{ID: "qemu/101", VMID: 101, Node: "node-1", Name: "vm-101", Instance: "pve-1"},
		},
		Containers: []models.Container{
			{ID: "lxc/201", VMID: 201, Node: "node-2", Name: "ct-201", Instance: "pve-1"},
		},
	}
	registry := unifiedresources.NewRegistry(nil)
	registry.IngestSnapshot(snapshot)
	svc.SetReadState(registry)

	// 1. Find VM
	node, name, gType := svc.lookupNodeForVMID(101)
	if node != "node-1" || name != "vm-101" || gType != "vm" {
		t.Errorf("VM lookup failed: %s, %s, %s", node, name, gType)
	}

	// 2. Find Container
	node, name, gType = svc.lookupNodeForVMID(201)
	if node != "node-2" || name != "ct-201" || gType != "system-container" {
		t.Errorf("Container lookup failed: %s, %s, %s", node, name, gType)
	}

	// 3. Not found
	node, name, gType = svc.lookupNodeForVMID(999)
	if node != "" || name != "" {
		t.Error("Should not have found non-existent VMID")
	}

	// 4. Collision — re-ingest with duplicate VMID across instances
	snapshot.Nodes = append(snapshot.Nodes, models.Node{
		ID: "node/node-3", Name: "node-3", Instance: "pve-2", Status: "online",
	})
	snapshot.VMs = append(snapshot.VMs, models.VM{
		ID: "qemu/101-dup", VMID: 101, Node: "node-3", Name: "vm-101-dup", Instance: "pve-2",
	})
	registry2 := unifiedresources.NewRegistry(nil)
	registry2.IngestSnapshot(snapshot)
	svc.SetReadState(registry2)

	node, _, _ = svc.lookupNodeForVMID(101)
	if node == "" {
		t.Error("Should return first match on collision")
	}
}

func TestService_BuildUserAnnotationsContext(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// 1. Empty metadata
	if ctx := svc.buildUserAnnotationsContext(); ctx != "" {
		t.Errorf("Expected empty context, got: %s", ctx)
	}

	// 2. Guest metadata
	guestMeta := map[string]*config.GuestMetadata{
		"guest-1": {
			ID:            "guest-1",
			LastKnownName: "ServerA",
			Notes:         []string{"Primary database"},
		},
	}
	data, _ := json.Marshal(guestMeta)
	_ = os.WriteFile(filepath.Join(tmpDir, "guest_metadata.json"), data, 0644)

	// 3. Docker metadata
	dockerMeta := map[string]*config.DockerMetadata{
		"host1:container:id1": {
			ID:    "host1:container:id1",
			Notes: []string{"Web portal"},
		},
	}
	data, _ = json.Marshal(dockerMeta)
	_ = os.WriteFile(filepath.Join(tmpDir, "docker_metadata.json"), data, 0644)

	ctx := svc.buildUserAnnotationsContext()
	if !strings.Contains(ctx, "ServerA") || !strings.Contains(ctx, "Primary database") {
		t.Error("Guest notes missing from context")
	}
	if !strings.Contains(ctx, "Web portal") || !strings.Contains(ctx, "host1") {
		t.Error("Docker notes missing from context")
	}
}

func TestService_TestConnection_Extended(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// 1. Not configured
	err := svc.TestConnection(context.Background())
	if err == nil || !strings.Contains(err.Error(), "no provider configured") {
		t.Errorf("Expected 'no provider configured' error, got: %v", err)
	}

}

func TestService_ExecuteTool_ResolveFindingBlockedBeforeStore(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// Set up patrol service with findings store
	stateProvider := &mockStateProvider{}
	svc.SetStateProvider(stateProvider)

	patrol := svc.GetPatrolService()
	if patrol == nil {
		t.Fatal("Expected patrol service to be initialized")
	}

	// Add a finding
	finding := &Finding{
		ID:           "test-finding-1",
		Severity:     FindingSeverityWarning,
		ResourceID:   "vm-100",
		ResourceName: "test-vm",
		Title:        "High CPU",
	}
	patrol.GetFindings().Add(finding)

	ctx := context.Background()
	req := ExecuteRequest{FindingID: "test-finding-1"}

	// 1. Successful resolution
	tc := providers.ToolCall{
		Name: agentcapabilities.ResolveFindingCapabilityName,
		Input: map[string]interface{}{
			agentcapabilities.FindingIDArgumentName:      "test-finding-1",
			agentcapabilities.ResolutionNoteArgumentName: "Restarted the service",
		},
	}

	result, exec := svc.executeTool(ctx, req, tc)
	if exec.Success || !strings.Contains(result, "Invocation blocked") {
		t.Fatalf("expected direct finding resolution to be blocked, got success=%v result=%q", exec.Success, result)
	}
	if got := patrol.GetFindings().Get("test-finding-1"); got == nil || got.ResolvedAt != nil {
		t.Fatalf("finding store changed despite policy block: %+v", got)
	}
}

func TestService_ExecuteTool_SetResourceURLFailsClosedBeforeValidation(t *testing.T) {
	svc := NewService(nil, nil)
	mockMeta := &mockMetadataProvider{}
	svc.metadataProvider = mockMeta

	ctx := context.Background()

	// 1. Missing resource_type
	tc := providers.ToolCall{
		Name: "set_resource_url",
		Input: map[string]interface{}{
			"resource_id": "test-id",
			"url":         "http://example.com",
		},
	}
	result, exec := svc.executeTool(ctx, ExecuteRequest{}, tc)
	if exec.Success {
		t.Error("Expected failure for missing resource_type")
	}
	if !strings.Contains(result, "Invocation blocked") {
		t.Errorf("expected policy block before argument validation, got: %s", result)
	}
	if mockMeta.lastGuestID != "" || mockMeta.lastGuestURL != "" {
		t.Fatalf("metadata provider was called despite policy block: %+v", mockMeta)
	}
}

func TestService_ExecuteTool_UnknownTool(t *testing.T) {
	svc := NewService(nil, nil)

	tc := providers.ToolCall{
		Name: "unknown_tool",
		Input: map[string]interface{}{
			"foo": "bar",
		},
	}

	result, exec := svc.executeTool(context.Background(), ExecuteRequest{}, tc)
	if exec.Success {
		t.Error("Expected failure for unknown tool")
	}
	if !strings.Contains(result, "Invocation blocked") {
		t.Errorf("expected unknown alias to fail closed, got: %s", result)
	}
}

func TestService_ExecuteTool_FetchURL_EmptyURL(t *testing.T) {
	svc := NewService(nil, nil)

	tc := providers.ToolCall{
		Name: "fetch_url",
		Input: map[string]interface{}{
			"url": "",
		},
	}

	result, exec := svc.executeTool(context.Background(), ExecuteRequest{}, tc)
	if exec.Success {
		t.Error("Expected failure for empty URL")
	}
	if !strings.Contains(result, "url is required") {
		t.Errorf("Expected 'url is required' error, got: %s", result)
	}
}

func TestService_ExecuteTool_RunCommand_WithTargetHost(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "target-node",
	}
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
	}
	svc := NewService(nil, mockServer)
	svc.cfg = &config.AIConfig{ControlLevel: config.ControlLevelControlled}
	svc.policy = &mockPolicy{decision: agentexec.PolicyAllow}
	canonicalStore := unifiedresources.NewMemoryStore()
	svc.resourceExportStore = canonicalStore
	svc.resourceExportStoreOrgID = svc.orgID

	tc := providers.ToolCall{
		Name: "run_command",
		Input: map[string]interface{}{
			"command":     "uptime",
			"run_on_host": true,
			"target_host": "target-node",
		},
	}

	req := ExecuteRequest{
		TargetType: "vm",
		TargetID:   "vm-100",
		Context: map[string]interface{}{
			"node":            "original-node",
			"alertIdentifier": "alert-123",
		},
	}

	result, exec := svc.executeTool(context.Background(), req, tc)
	if exec.Success || !strings.Contains(result, "Invocation blocked") {
		t.Fatalf("retired run_command did not fail closed: success=%v result=%q", exec.Success, result)
	}

	changes, err := canonicalStore.GetRecentChanges("vm-100", time.Time{}, 10)
	if err != nil {
		t.Fatalf("GetRecentChanges: %v", err)
	}
	if len(changes) != 0 {
		t.Fatalf("retired run_command wrote canonical change history: %#v", changes)
	}
}

func TestService_HasAgentForTarget_WithUnifiedResourceProvider(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "host-from-provider",
	}
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
	}
	svc := NewService(nil, mockServer)

	// Mock unified resource provider that returns host for container
	mockURP := &mockUnifiedResourceProvider{}
	svc.unifiedResourceProvider = mockURP

	// Overwrite FindContainerHost behavior
	// The mock by default returns empty string, so this should fail
	// But with containerName context, it will try the resource provider

	req := ExecuteRequest{
		TargetType: "docker",
		Context: map[string]interface{}{
			"containerName": "some-container",
		},
	}

	// Without provider returning anything, should still return true (at least one agent)
	if !svc.hasAgentForTarget(req) {
		t.Error("Expected true when at least one agent is available")
	}

	// With name context
	req2 := ExecuteRequest{
		TargetType: "docker",
		Context: map[string]interface{}{
			"name": "my-container",
		},
	}
	if !svc.hasAgentForTarget(req2) {
		t.Error("Expected true with name context")
	}

	// With guestName context
	req3 := ExecuteRequest{
		TargetType: "vm",
		Context: map[string]interface{}{
			"guestName": "my-vm",
		},
	}
	if !svc.hasAgentForTarget(req3) {
		t.Error("Expected true with guestName context")
	}
}

func TestService_HasAgentForTarget_HostFields(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "myhost",
	}
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
	}
	svc := NewService(nil, mockServer)

	hostFields := []string{"node", "host", "guest_node", "hostname", "host_name", "target_host"}

	for _, field := range hostFields {
		t.Run(field, func(t *testing.T) {
			req := ExecuteRequest{
				TargetType: "vm",
				Context: map[string]interface{}{
					field: "MYHOST", // Test case-insensitive matching
				},
			}
			if !svc.hasAgentForTarget(req) {
				t.Errorf("Expected true for host field %s", field)
			}
		})
	}
}

func TestService_ListModelsWithCache_CacheHit(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// Save a config
	cfg := config.AIConfig{
		Enabled:      true,
		OpenAIAPIKey: "test-key",
	}
	_ = persistence.SaveAIConfig(cfg)

	// Get the cache key that persistence would generate
	loadedCfg, _ := persistence.LoadAIConfig()
	cacheKey := buildModelsCacheKey(loadedCfg)

	// Pre-populate cache before the first call
	svc.modelsCache.mu.Lock()
	svc.modelsCache.key = cacheKey
	svc.modelsCache.ttl = 5 * time.Minute
	svc.modelsCache.providers = map[string]providerModelsEntry{
		"openai": {
			at:     time.Now(),
			models: []providers.ModelInfo{{ID: "test-model", Name: "Test Model"}},
		},
	}
	svc.modelsCache.mu.Unlock()

	// Call should hit cache since we pre-populated it
	models, cached, err := svc.ListModelsWithCache(context.Background())
	if err != nil {
		t.Fatalf("ListModelsWithCache failed: %v", err)
	}
	if !cached {
		t.Error("Expected cache hit")
	}
	if len(models) != 1 || models[0].ID != "test-model" {
		t.Errorf("Expected cached model, got: %v", models)
	}
}

func TestBuildModelsCacheKey_OllamaAuthFingerprint(t *testing.T) {
	cfgA := &config.AIConfig{
		Enabled:        true,
		OllamaBaseURL:  "http://localhost:11434",
		OllamaUsername: "unai",
		OllamaPassword: "secret-a",
	}
	cfgB := &config.AIConfig{
		Enabled:        true,
		OllamaBaseURL:  "http://localhost:11434",
		OllamaUsername: "unai",
		OllamaPassword: "secret-b",
	}

	keyA := buildModelsCacheKey(cfgA)
	keyB := buildModelsCacheKey(cfgB)

	if keyA == keyB {
		t.Fatal("expected different cache keys when Ollama credentials change")
	}
	if strings.Contains(keyA, "secret-a") || strings.Contains(keyB, "secret-b") {
		t.Fatal("expected cache keys to avoid embedding raw Ollama passwords")
	}
}

func TestBuildModelsCacheKey_UsesKeyedCredentialIdentity(t *testing.T) {
	cfg := &config.AIConfig{Enabled: true, OpenAIAPIKey: "provider-secret"}
	first := buildModelsCacheKey(cfg)
	second := buildModelsCacheKey(cfg)
	if first != second {
		t.Fatal("expected unchanged credentials to retain one cache identity")
	}
	if strings.Contains(first, cfg.OpenAIAPIKey) {
		t.Fatal("cache key must not contain raw provider credentials")
	}

	cfg.OpenAIAPIKey = "rotated-secret"
	if rotated := buildModelsCacheKey(cfg); rotated == first {
		t.Fatal("expected credential rotation to invalidate the models cache")
	}
}

// Note: ListModelsWithCache does not handle nil persistence gracefully (panics)
// This is acceptable as NewService should always be called with a valid persistence

func TestProviderDisplayName_AllProviders(t *testing.T) {
	tests := []struct {
		provider string
		expected string
	}{
		{config.AIProviderAnthropic, "Anthropic"},
		{config.AIProviderOpenAI, "OpenAI"},
		{config.AIProviderOpenRouter, "OpenRouter"},
		{config.AIProviderDeepSeek, "DeepSeek"},
		{config.AIProviderGemini, "Google Gemini"},
		{config.AIProviderOllama, "Ollama"},
		{"custom_provider", "custom_provider"},
	}

	for _, tt := range tests {
		t.Run(tt.provider, func(t *testing.T) {
			got := providerDisplayName(tt.provider)
			if got != tt.expected {
				t.Errorf("providerDisplayName(%q) = %q, want %q", tt.provider, got, tt.expected)
			}
		})
	}
}

func TestService_ExecuteOnAgent_VMIDExtraction(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}

	var capturedCmd agentexec.ExecuteCommandPayload
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			capturedCmd = cmd
			return &agentexec.CommandResultPayload{
				Success: true,
				Stdout:  "ok",
			}, nil
		},
	}
	svc := NewService(nil, mockServer)

	// Test with VMID in context as float64 (common from JSON)
	req := ExecuteRequest{
		TargetType: "system-container",
		TargetID:   "instance-123",
		Context: map[string]interface{}{
			"node": "node-1",
			"vmid": float64(123),
		},
	}

	_, err := svc.executeOnAgent(context.Background(), req, "uptime")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	if capturedCmd.TargetID != "123" {
		t.Errorf("Expected TargetID '123', got '%s'", capturedCmd.TargetID)
	}

	// Test with VMID as int
	req.Context["vmid"] = 456
	_, err = svc.executeOnAgent(context.Background(), req, "uptime")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	if capturedCmd.TargetID != "456" {
		t.Errorf("Expected TargetID '456', got '%s'", capturedCmd.TargetID)
	}

	// Test with VMID as string
	req.Context["vmid"] = "789"
	_, err = svc.executeOnAgent(context.Background(), req, "uptime")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	if capturedCmd.TargetID != "789" {
		t.Errorf("Expected TargetID '789', got '%s'", capturedCmd.TargetID)
	}
}

func TestService_ExecuteOnAgent_RejectsLegacyContainerTargetTypeAlias(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}

	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			return &agentexec.CommandResultPayload{
				Success: true,
				Stdout:  "ok",
			}, nil
		},
	}
	svc := NewService(nil, mockServer)

	req := ExecuteRequest{
		TargetType: "CONTAINER",
		TargetID:   "pve-node:minipc:112",
		Context: map[string]interface{}{
			"node": "node-1",
		},
	}

	_, err := svc.executeOnAgent(context.Background(), req, "uptime")
	if err == nil {
		t.Fatal("expected error for legacy container target type alias")
	}
	if !strings.Contains(err.Error(), "unsupported target_type") {
		t.Fatalf("expected unsupported target_type error, got %v", err)
	}
}

func TestService_NormalizeExecuteTargetTypeUsesSharedActionTargetVocabulary(t *testing.T) {
	valid, err := normalizeExecuteTargetType(" SYSTEM-CONTAINER ", "101", nil)
	if err != nil {
		t.Fatalf("normalizeExecuteTargetType returned error: %v", err)
	}
	if valid != agentcapabilities.ActionTargetTypeSystemContainer {
		t.Fatalf("normalizeExecuteTargetType returned %q, want %q", valid, agentcapabilities.ActionTargetTypeSystemContainer)
	}

	hostRouted, err := normalizeExecuteTargetType("", "", map[string]interface{}{"node": "pve-a"})
	if err != nil {
		t.Fatalf("normalizeExecuteTargetType with host routing returned error: %v", err)
	}
	if hostRouted != agentcapabilities.ActionTargetTypeAgent {
		t.Fatalf("normalizeExecuteTargetType host-routed target = %q, want %q", hostRouted, agentcapabilities.ActionTargetTypeAgent)
	}

	_, err = normalizeExecuteTargetType("container", "101", nil)
	if err == nil || !strings.Contains(err.Error(), agentcapabilities.ActionTargetTypeAllowedDescription()) {
		t.Fatalf("expected shared allowed-target description in error, got %v", err)
	}
}

func TestService_ExecuteOnAgent_AcceptsSystemContainerTargetType(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}

	var capturedCmd agentexec.ExecuteCommandPayload
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			capturedCmd = cmd
			return &agentexec.CommandResultPayload{
				Success: true,
				Stdout:  "ok",
			}, nil
		},
	}
	svc := NewService(nil, mockServer)

	req := ExecuteRequest{
		TargetType: "system-container",
		TargetID:   "pve-node:minipc:113",
		Context: map[string]interface{}{
			"node": "node-1",
		},
	}

	_, err := svc.executeOnAgent(context.Background(), req, "uptime")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}

	if capturedCmd.TargetType != "container" {
		t.Fatalf("Expected normalized TargetType 'container', got '%s'", capturedCmd.TargetType)
	}
	if capturedCmd.TargetID != "113" {
		t.Fatalf("Expected extracted TargetID '113', got '%s'", capturedCmd.TargetID)
	}
}

func TestService_ExecuteOnAgent_RejectsLegacyGuestTargetType(t *testing.T) {
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{
			{AgentID: "agent-1", Hostname: "node-1"},
		},
	}
	svc := NewService(nil, mockServer)

	_, err := svc.executeOnAgent(context.Background(), ExecuteRequest{
		TargetType: "guest",
		TargetID:   "pve-node:minipc:101",
		Context:    map[string]interface{}{"node": "node-1"},
	}, "uptime")
	if err == nil || !strings.Contains(err.Error(), "unsupported target_type") {
		t.Fatalf("expected unsupported target_type error, got: %v", err)
	}
}

func TestService_ExecuteOnAgent_RejectsLegacyTargetTypeAliases(t *testing.T) {
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{
			{AgentID: "agent-1", Hostname: "node-1"},
		},
	}
	svc := NewService(nil, mockServer)

	for _, legacyType := range []string{"lxc", "ct", "qemu", "container", "system_container", "guest", "node", "docker-host", "k8s"} {
		_, err := svc.executeOnAgent(context.Background(), ExecuteRequest{
			TargetType: legacyType,
			TargetID:   "101",
			Context:    map[string]interface{}{"node": "node-1"},
		}, "uptime")
		if err == nil || !strings.Contains(err.Error(), "unsupported target_type") {
			t.Fatalf("expected unsupported target_type error for %q, got %v", legacyType, err)
		}
	}
}

func TestService_ExecuteOnAgent_RejectsContainerWithoutNumericVMID(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}

	executeCalls := 0
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			executeCalls++
			return &agentexec.CommandResultPayload{Success: true, Stdout: "ok"}, nil
		},
	}
	svc := NewService(nil, mockServer)

	_, err := svc.executeOnAgent(context.Background(), ExecuteRequest{
		TargetType: "system-container",
		TargetID:   "mycontainer",
		Context:    map[string]interface{}{"node": "node-1"},
	}, "uptime")
	if err == nil {
		t.Fatal("expected error for missing numeric VMID")
	}
	if !strings.Contains(err.Error(), "requires numeric VMID") {
		t.Fatalf("expected numeric VMID error, got: %v", err)
	}
	if executeCalls != 0 {
		t.Fatalf("expected command dispatch to be blocked, executeCalls=%d", executeCalls)
	}
}

func TestService_ExecuteOnAgent_AptNonInteractive(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}

	var capturedCmd agentexec.ExecuteCommandPayload
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			capturedCmd = cmd
			return &agentexec.CommandResultPayload{Success: true, Stdout: "ok"}, nil
		},
	}
	svc := NewService(nil, mockServer)

	req := ExecuteRequest{
		TargetType: "agent",
		Context:    map[string]interface{}{"node": "node-1"},
	}

	// apt command should get DEBIAN_FRONTEND prefix
	_, err := svc.executeOnAgent(context.Background(), req, "apt update")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	if !strings.Contains(capturedCmd.Command, "DEBIAN_FRONTEND=noninteractive") {
		t.Errorf("Expected DEBIAN_FRONTEND prefix for apt, got: %s", capturedCmd.Command)
	}

	// dpkg command should also get prefix
	_, err = svc.executeOnAgent(context.Background(), req, "dpkg --configure -a")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	if !strings.Contains(capturedCmd.Command, "DEBIAN_FRONTEND=noninteractive") {
		t.Errorf("Expected DEBIAN_FRONTEND prefix for dpkg, got: %s", capturedCmd.Command)
	}

	// If already has DEBIAN_FRONTEND, don't add again
	_, err = svc.executeOnAgent(context.Background(), req, "DEBIAN_FRONTEND=noninteractive apt update")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	if strings.Count(capturedCmd.Command, "DEBIAN_FRONTEND") > 1 {
		t.Error("Should not duplicate DEBIAN_FRONTEND")
	}
}

func TestService_ExecuteOnAgent_ResultHandling(t *testing.T) {
	mockAgent := agentexec.ConnectedAgent{
		AgentID:  "agent-1",
		Hostname: "node-1",
	}

	svc := NewService(nil, nil)
	req := ExecuteRequest{
		TargetType: "agent",
		Context:    map[string]interface{}{"node": "node-1"},
	}

	// Test with both stdout and stderr
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{mockAgent},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			return &agentexec.CommandResultPayload{
				Success: true,
				Stdout:  "stdout content",
				Stderr:  "stderr content",
			}, nil
		},
	}
	svc.agentServer = mockServer

	output, err := svc.executeOnAgent(context.Background(), req, "ls")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	if !strings.Contains(output, "stdout content") || !strings.Contains(output, "STDERR") || !strings.Contains(output, "stderr content") {
		t.Errorf("Expected combined output, got: %s", output)
	}

	// Test with only stderr (failure case)
	mockServer.executeFunc = func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
		return &agentexec.CommandResultPayload{
			Success: false,
			Stderr:  "error message",
		}, nil
	}

	output, err = svc.executeOnAgent(context.Background(), req, "bad-command")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	if output != "error message" {
		t.Errorf("Expected stderr as output, got: %s", output)
	}

	// Test with error
	mockServer.executeFunc = func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
		return &agentexec.CommandResultPayload{
			Success: false,
			Error:   "command failed",
		}, nil
	}

	_, err = svc.executeOnAgent(context.Background(), req, "failing-command")
	if err == nil {
		t.Error("Expected error")
	}
	if !strings.Contains(err.Error(), "command failed") {
		t.Errorf("Expected error message, got: %v", err)
	}
}

func TestService_ExecuteOnAgent_RoutingClarification(t *testing.T) {
	svc := NewService(nil, &mockAgentServer{
		agents: []agentexec.ConnectedAgent{
			{AgentID: "agent-1", Hostname: "host-1"},
			{AgentID: "agent-2", Hostname: "host-2"},
		},
	})

	// No target node in context, multiple agents available -> clarification needed
	req := ExecuteRequest{
		TargetType: "agent",
	}

	output, err := svc.executeOnAgent(context.Background(), req, "hostname")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}
	t.Logf("Output: %s", output)

	if !strings.Contains(output, "ROUTING_CLARIFICATION_NEEDED") {
		t.Errorf("Expected clarification needed response, got: %s", output)
	}
}

func TestService_ExecuteOnAgent_TargetIDExtractionOnly(t *testing.T) {
	var capturedCmd agentexec.ExecuteCommandPayload
	mockServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{{AgentID: "agent-1", Hostname: "host-1"}},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			capturedCmd = cmd
			return &agentexec.CommandResultPayload{Success: true, Stdout: "ok"}, nil
		},
	}
	svc := NewService(nil, mockServer)

	// No vmid in context, but TargetID has a number
	req := ExecuteRequest{
		TargetType: "system-container",
		TargetID:   "pve-node-135",
		Context: map[string]interface{}{
			"node": "host-1", // Force routing
		},
	}

	_, err := svc.executeOnAgent(context.Background(), req, "uptime")
	if err != nil {
		t.Fatalf("executeOnAgent failed: %v", err)
	}

	// Should have extracted 135 from pve-node-135
	if capturedCmd.TargetID != "135" {
		t.Errorf("Expected extracted TargetID '135', got '%s'", capturedCmd.TargetID)
	}
}

// ============================================================================
// approvalNeededFromToolCall Tests
// ============================================================================

func TestApprovalNeededFromToolCall_Extended(t *testing.T) {
	req := ExecuteRequest{
		Context: map[string]interface{}{
			"node": "node-1",
		},
	}

	tc := providers.ToolCall{
		ID:   "call-1",
		Name: "run_command",
		Input: map[string]interface{}{
			"command": "reboot",
		},
	}

	// Case 1: Result doesn't have APPROVAL_REQUIRED prefix
	_, ok := approvalNeededFromToolCall(req, tc, "regular result")
	if ok {
		t.Error("Expected false for regular result")
	}

	// Case 2: Wrong tool name
	tc2 := tc
	tc2.Name = "fetch_url"
	_, ok = approvalNeededFromToolCall(req, tc2, "APPROVAL_REQUIRED: ...")
	if ok {
		t.Error("Expected false for non-run_command tool")
	}

	// Case 3: Success with node from context
	data, ok := approvalNeededFromToolCall(req, tc, "APPROVAL_REQUIRED: reason")
	if !ok {
		t.Error("Expected true for approval required")
	}
	if data.TargetHost != "node-1" {
		t.Errorf("Expected TargetHost node-1, got %s", data.TargetHost)
	}

	// Case 4: Other context fields
	req2 := ExecuteRequest{Context: map[string]interface{}{"hostname": "host-2"}}
	data, _ = approvalNeededFromToolCall(req2, tc, "APPROVAL_REQUIRED: reason")
	if data.TargetHost != "host-2" {
		t.Errorf("Expected host-2, got %s", data.TargetHost)
	}

	req3 := ExecuteRequest{Context: map[string]interface{}{"host_name": "host-3"}}
	data, _ = approvalNeededFromToolCall(req3, tc, "APPROVAL_REQUIRED: reason")
	if data.TargetHost != "host-3" {
		t.Errorf("Expected host-3, got %s", data.TargetHost)
	}
}

// ============================================================================
// getTools Tests
// ============================================================================

func TestService_getTools_Variants(t *testing.T) {
	svc := NewService(nil, nil)

	// Case 1: Generic provider
	tools := svc.getTools()
	foundWebSearch := false
	for _, tool := range tools {
		if tool.Name == "web_search" {
			foundWebSearch = true
		}
	}
	if foundWebSearch {
		t.Error("Did not expect web_search tool for generic provider")
	}

	// Case 2: Anthropic provider
	svc.provider = &mockProvider{nameFunc: func() string { return "anthropic" }}
	tools = svc.getTools()
	foundWebSearch = false
	for _, tool := range tools {
		if tool.Name == "web_search" || tool.Type == "web_search_20250305" {
			foundWebSearch = true
		}
	}
	if !foundWebSearch {
		t.Error("Expected web_search tool for Anthropic provider")
	}
}

// ============================================================================
// ExecuteStream Tests - Continued
// ============================================================================

func TestService_ExecuteStream_BudgetExceeded(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)
	svc.mu.Lock()
	svc.cfg = &config.AIConfig{
		Enabled:          true,
		CostBudgetUSD30d: 0.0001,                // Very low budget
		Model:            "anthropic:forbidden", // Force fallback to mock
	}
	svc.provider = &mockProvider{}
	svc.mu.Unlock()

	// We need costStore to have some usage
	costStore := cost.NewStore(30)
	costStore.Record(cost.UsageEvent{
		Timestamp:    time.Now(),
		Provider:     "openai",
		RequestModel: "gpt-4o",
		UseCase:      "chat",
		InputTokens:  1000000,
		OutputTokens: 1000000,
	})
	svc.costStore = costStore

	events := []StreamEvent{}
	callback := func(e StreamEvent) {
		events = append(events, e)
	}

	// First call should fail synchronously with error
	_, err := svc.ExecuteStream(context.Background(), ExecuteRequest{UseCase: "chat"}, callback)
	if err == nil {
		t.Error("Expected error due to budget")
	}
	if !strings.Contains(err.Error(), "budget") {
		t.Errorf("Expected budget error, got %v", err)
	}
}

func TestService_ExecuteStream_ThinkingContent(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)
	mock := &mockProvider{
		chatFunc: func(ctx context.Context, req providers.ChatRequest) (*providers.ChatResponse, error) {
			return &providers.ChatResponse{
				Content:          "Final response",
				ReasoningContent: "Thinking...",
				StopReason:       "end_turn",
			}, nil
		},
	}
	svc.provider = mock
	svc.cfg = &config.AIConfig{Enabled: true, Model: "anthropic:test"}

	events := []StreamEvent{}
	callback := func(e StreamEvent) {
		events = append(events, e)
	}

	_, err := svc.ExecuteStream(context.Background(), ExecuteRequest{}, callback)
	if err != nil {
		t.Fatalf("ExecuteStream failed: %v", err)
	}

	foundThinking := false
	for _, e := range events {
		if e.Type == "thinking" && e.Data == "Thinking..." {
			foundThinking = true
		}
	}
	if !foundThinking {
		t.Error("Expected thinking event in stream")
	}
}

func TestService_ExecuteStream_PolicyBlock(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, &mockAgentServer{})
	svc.policy = &mockPolicy{decision: agentexec.PolicyBlock}
	svc.cfg = &config.AIConfig{Enabled: true, Model: "anthropic:test"}

	iteration := 0
	mock := &mockProvider{
		chatFunc: func(ctx context.Context, req providers.ChatRequest) (*providers.ChatResponse, error) {
			iteration++
			if iteration == 1 {
				return &providers.ChatResponse{
					ToolCalls: []providers.ToolCall{
						{ID: "call-1", Name: "run_command", Input: map[string]interface{}{"command": "rm -rf /"}},
					},
					StopReason: "tool_use",
				}, nil
			}
			return &providers.ChatResponse{
				Content:    "The command was blocked.",
				StopReason: "end_turn",
			}, nil
		},
	}
	svc.provider = mock

	events := []StreamEvent{}
	callback := func(e StreamEvent) {
		events = append(events, e)
	}

	_, err := svc.ExecuteStream(context.Background(), ExecuteRequest{}, callback)
	if err != nil {
		t.Fatalf("ExecuteStream failed: %v", err)
	}

	foundBlocked := false
	for _, e := range events {
		if e.Type == "tool_end" {
			data := e.Data.(ToolEndData)
			if !data.Success && strings.Contains(data.Output, "blocked") {
				foundBlocked = true
			}
		}
	}
	if !foundBlocked {
		t.Error("Expected blocked tool result in stream")
	}
}

func TestService_ExecuteStream_AutonomousRawCommandRequiresApproval(t *testing.T) {
	tmpDir := t.TempDir()
	store := installEmptyServiceToolLoopApprovalStore(t)
	mutationPath := filepath.Join(tmpDir, "autonomous-raw-command")
	persistence := config.NewConfigPersistence(tmpDir)
	dispatches := 0
	svc := NewService(persistence, &mockAgentServer{
		agents: []agentexec.ConnectedAgent{{AgentID: "agent-1", Hostname: "agent-1"}},
		executeFunc: func(context.Context, string, agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			dispatches++
			return &agentexec.CommandResultPayload{Success: true}, nil
		},
	})
	svc.cfg = &config.AIConfig{Enabled: true, ControlLevel: config.ControlLevelAutonomous, Model: "anthropic:test"}

	iteration := 0
	mock := &mockProvider{
		chatFunc: func(ctx context.Context, req providers.ChatRequest) (*providers.ChatResponse, error) {
			iteration++
			return &providers.ChatResponse{
				ToolCalls: []providers.ToolCall{{ID: fmt.Sprintf("call-%d", iteration), Name: "run_command", Input: map[string]interface{}{
					"command": "touch " + mutationPath, "target_host": "agent-1",
				}}},
				StopReason: "tool_use",
			}, nil
		},
	}
	svc.provider = mock

	approvalEvents := 0
	loopFailureEvents := 0
	_, err := svc.ExecuteStream(context.Background(), ExecuteRequest{TargetType: "agent"}, func(event StreamEvent) {
		if event.Type == "approval_needed" {
			approvalEvents++
		}
		if event.Type == "error" {
			if data, ok := event.Data.(ServiceToolLoopFailureData); ok && data.Code == ServiceToolLoopFailureCode {
				loopFailureEvents++
			}
		}
	})
	_ = requireServiceToolLoopFailure(t, err, ServiceToolLoopFailureRepeatedDenied)
	if dispatches != 0 {
		t.Fatalf("agent dispatches = %d, want 0", dispatches)
	}
	if iteration != 2 {
		t.Fatalf("provider iterations = %d, want 2", iteration)
	}
	if approvalEvents != 0 {
		t.Fatalf("approval events = %d, want 0", approvalEvents)
	}
	if loopFailureEvents != 1 {
		t.Fatalf("typed loop failure events = %d, want 1", loopFailureEvents)
	}
	if got := len(store.GetPendingApprovals()); got != 0 {
		t.Fatalf("persisted approvals = %d, want 0", got)
	}
	if _, statErr := os.Stat(mutationPath); !os.IsNotExist(statErr) {
		t.Fatalf("external mutation path exists or stat failed unexpectedly: %v", statErr)
	}
}

func TestService_GetCostSummary_NoStore_Truncated(t *testing.T) {
	svc := &Service{} // Store is nil
	summary := svc.GetCostSummary(30)
	if summary.Days != 30 {
		t.Errorf("Expected 30 days, got %d", summary.Days)
	}
	if len(summary.ProviderModels) != 0 {
		t.Error("Expected 0 provider models")
	}

	// Test truncation branch
	summary = svc.GetCostSummary(cost.DefaultMaxDays + 1)
	if !summary.Truncated {
		t.Error("Expected summary to be truncated")
	}
}

func TestService_PatrolManagement_NilPatrol(t *testing.T) {
	svc := &Service{}

	// These should not panic when patrol is nil
	svc.StopPatrol()
	svc.SetMetricsHistoryProvider(nil)
	svc.SetBaselineStore(nil)
}

func TestSanitizeError_Extended(t *testing.T) {
	tests := []struct {
		input    error
		contains string
	}{
		{nil, ""},
		{fmt.Errorf("failed to send command: i/o timeout"), "timed out"},
		{fmt.Errorf("something i/o timeout"), "timeout"},
		{fmt.Errorf("connection refused"), "not be running"},
		{fmt.Errorf("no such host"), "host not found"},
		{fmt.Errorf("context deadline exceeded"), "timed out"},
		{fmt.Errorf("some other error"), "some other error"},
	}

	for _, tt := range tests {
		t.Run(tt.contains, func(t *testing.T) {
			result := sanitizeError(tt.input)
			if tt.input == nil {
				if result != nil {
					t.Error("Expected nil for nil input")
				}
				return
			}
			if !strings.Contains(result.Error(), tt.contains) {
				t.Errorf("sanitizeError(%v) = %v, expected to contain %q", tt.input, result, tt.contains)
			}
		})
	}
}

func TestService_GetGuestID(t *testing.T) {
	svc := NewService(nil, nil)

	tests := []struct {
		req      ExecuteRequest
		expected string
	}{
		{ExecuteRequest{TargetType: "", TargetID: ""}, ""},
		{ExecuteRequest{TargetType: "vm", TargetID: ""}, ""},
		{ExecuteRequest{TargetType: "", TargetID: "100"}, ""},
		{ExecuteRequest{TargetType: "vm", TargetID: "100"}, "vm-100"},
		{ExecuteRequest{TargetType: "container", TargetID: "host:ct:abc"}, "container-host:ct:abc"},
	}

	for _, tt := range tests {
		result := svc.getGuestID(tt.req)
		if result != tt.expected {
			t.Errorf("getGuestID(%+v) = %q, expected %q", tt.req, result, tt.expected)
		}
	}
}

func TestService_LogRemediation_WithPatrolService(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-log-rem-patrol-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// Set up patrol service
	stateProvider := &mockStateProvider{}
	svc.SetStateProvider(stateProvider)

	patrol := svc.GetPatrolService()
	if patrol == nil {
		t.Fatal("Expected patrol service")
	}

	// Set up remediation log
	remLog := NewRemediationLog(RemediationLogConfig{DataDir: tmpDir})
	patrol.remediationLog = remLog

	// Test logging with context name
	req := ExecuteRequest{
		TargetID:   "vm-100-with-patrol",
		TargetType: "vm",
		Prompt:     "High CPU usage detected",
		Context: map[string]interface{}{
			"name": "web-server",
		},
		UseCase: "patrol",
	}

	svc.logRemediation(req, "systemctl restart nginx", "output data", true)

	// Verify the log was created
	history := remLog.GetForResource("vm-100-with-patrol", 10)
	if len(history) != 1 {
		t.Fatalf("Expected 1 record, got %d", len(history))
	}
	if history[0].ResourceName != "web-server" {
		t.Errorf("Expected resource name 'web-server', got '%s'", history[0].ResourceName)
	}
	if history[0].Outcome != OutcomeResolved {
		t.Errorf("Expected outcome Resolved, got %v", history[0].Outcome)
	}
	if !history[0].Automatic {
		t.Error("Expected Automatic=true for patrol use case")
	}
}

func TestService_LogRemediation_LongPromptTruncation(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-log-rem-truncate-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	stateProvider := &mockStateProvider{}
	svc.SetStateProvider(stateProvider)

	patrol := svc.GetPatrolService()
	remLog := NewRemediationLog(RemediationLogConfig{DataDir: tmpDir})
	patrol.remediationLog = remLog

	// Create a very long prompt
	longPrompt := strings.Repeat("a", 300)

	req := ExecuteRequest{
		TargetID:   "vm-100-truncation-test",
		TargetType: "vm",
		Prompt:     longPrompt,
	}

	svc.logRemediation(req, "docker restart app", "output", false)

	history := remLog.GetForResource("vm-100-truncation-test", 10)
	if len(history) != 1 {
		t.Fatalf("Expected 1 record, got %d", len(history))
	}
	if len(history[0].Problem) > 205 { // 200 + "..."
		t.Errorf("Problem should be truncated, got length %d", len(history[0].Problem))
	}
	if history[0].Outcome != OutcomeFailed {
		t.Errorf("Expected outcome Failed for success=false, got %v", history[0].Outcome)
	}
}

// ============================================================================
// Knowledge Store Tests
// ============================================================================

func TestService_KnowledgeStore_NotConfigured(t *testing.T) {
	svc := NewService(nil, nil)
	// knowledgeStore is nil

	_, err := svc.GetGuestKnowledge("test-guest")
	if err == nil {
		t.Error("Expected error when knowledge store not available")
	}

	err = svc.SaveGuestNote("guest-1", "name", "vm", "cat", "title", "content")
	if err == nil {
		t.Error("Expected error when knowledge store not available")
	}

	err = svc.DeleteGuestNote("guest-1", "note-1")
	if err == nil {
		t.Error("Expected error when knowledge store not available")
	}
}

// ============================================================================
// LoadConfig Advanced Tests
// ============================================================================

func TestService_LoadConfig_WithDisabledAI(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-loadconfig-disabled-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)

	// Save a disabled config
	cfg := config.AIConfig{
		Enabled: false,
	}
	_ = persistence.SaveAIConfig(cfg)

	svc := NewService(persistence, nil)
	err = svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}

	if svc.IsEnabled() {
		t.Error("Expected AI to be disabled")
	}
}

func TestService_LoadConfig_ExplicitRouteMismatchLeavesProviderNil(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-loadconfig-explicit-route-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)

	// Config with Anthropic model selected but only OpenAI configured.
	// Pulse must not silently switch the saved route to a configured provider.
	cfg := config.AIConfig{
		Enabled:      true,
		Model:        "anthropic:claude-3-opus",
		OpenAIAPIKey: "test-openai-key",
	}
	_ = persistence.SaveAIConfig(cfg)

	svc := NewService(persistence, nil)
	err = svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}

	if svc.provider != nil {
		t.Fatalf("expected provider to remain nil for explicit unconfigured route, got %s", svc.provider.Name())
	}
}

func TestService_LoadConfig_WithoutConfiguredProviderLeavesNil(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-loadconfig-unconfigured-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)

	// Config selects Anthropic model but has no provider credentials.
	cfg := config.AIConfig{
		Enabled: true,
		Model:   "anthropic:claude-3-5-sonnet",
	}
	_ = persistence.SaveAIConfig(cfg)

	svc := NewService(persistence, nil)
	err = svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}

	if svc.provider != nil {
		t.Error("Expected provider to remain nil when no provider credentials are configured")
	}
}

func TestService_LoadConfig_UnknownModelWithOllamaConfigured(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-loadconfig-unknown-model-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)

	// Unknown model names should resolve to ollama when ollama is configured.
	cfg := config.AIConfig{
		Enabled:       true,
		Model:         "totally-unknown-model",
		OllamaBaseURL: "http://localhost:11434",
	}
	_ = persistence.SaveAIConfig(cfg)

	svc := NewService(persistence, nil)
	err = svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}

	if svc.provider == nil {
		t.Fatal("Expected provider to be initialized")
	}
	if svc.provider.Name() != "ollama" {
		t.Errorf("Expected ollama provider for unknown model, got %s", svc.provider.Name())
	}
}

func TestService_LoadConfig_ExplicitRouteRequiresMatchingProvider(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-loadconfig-explicit-route-variants-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)

	providers := []struct {
		name         string
		wantProvider string
	}{
		{name: "openai", wantProvider: "openai"},
		{name: "anthropic"},
		{name: "openrouter"},
		{name: "gemini"},
		{name: "deepseek"},
		{name: "ollama"},
	}

	for _, p := range providers {
		t.Run(p.name, func(t *testing.T) {
			cfg := config.AIConfig{
				Enabled: true,
				Model:   "openai:gpt-4", // selected
			}

			// Set the specific key
			switch p.name {
			case "openai":
				cfg.OpenAIAPIKey = "key"
			case "anthropic":
				cfg.AnthropicAPIKey = "key"
			case "openrouter":
				cfg.OpenRouterAPIKey = "key"
			case "gemini":
				cfg.GeminiAPIKey = "key"
			case "deepseek":
				cfg.DeepSeekAPIKey = "key"
			case "ollama":
				cfg.OllamaBaseURL = "http://localhost:11434"
			}

			_ = persistence.SaveAIConfig(cfg)
			svc := NewService(persistence, nil)
			err = svc.LoadConfig()
			if err != nil {
				t.Fatalf("LoadConfig failed: %v", err)
			}

			if p.wantProvider == "" {
				if svc.provider != nil {
					t.Fatalf("expected no provider for openai route with only %s configured, got %s", p.name, svc.provider.Name())
				}
				return
			}
			if svc.provider == nil || svc.provider.Name() != p.wantProvider {
				t.Errorf("expected %s provider for matching explicit route, got %v", p.wantProvider, svc.provider)
			}
		})
	}
}

func TestService_LoadConfig_NoProviders(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-loadconfig-none-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)

	// Enabled but no providers configured
	cfg := config.AIConfig{
		Enabled: true,
	}
	_ = persistence.SaveAIConfig(cfg)

	svc := NewService(persistence, nil)
	err = svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}

	if svc.provider != nil {
		t.Error("Expected provider to be nil when no credentials configured")
	}
}

func TestService_LoadConfig_PersistenceError(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)

	// Write invalid JSON to ai.enc (this is tricky because it's encrypted)
	// Actually, we can just make the directory unreadable or use a non-directory for the path
	aiFilePath := filepath.Join(tmpDir, "ai.enc")
	_ = os.MkdirAll(aiFilePath, 0755) // Create directory where file should be

	svc := NewService(persistence, nil)
	err := svc.LoadConfig()
	if err == nil {
		t.Error("Expected error when LoadAIConfig fails")
	}
}

func TestService_LoadConfig_FallbackFailure(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)

	// Create a bit of a weird situation: Ollama is configured (which always "succeeds" to create client)
	// but we want providers.NewForModel to fail for the fallback model.
	// Actually, NewForModel only fails if provider is unknown or key is missing.

	// Selected model is unknown provider, triggers fallback.
	// Fallback provider is Ollama.
	cfg := config.AIConfig{
		Enabled:       true,
		Model:         "unknown:model",
		OllamaBaseURL: "http://localhost:11434",
	}
	_ = persistence.SaveAIConfig(cfg)

	svc := NewService(persistence, nil)
	// We need providers.NewForModel to fail for Ollama fallback model?
	// That's hard because Ollama NewForProvider always succeeds.

	err := svc.LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig failed: %v", err)
	}
	// It should fall back to Ollama
	if svc.provider.Name() != "ollama" {
		t.Errorf("Expected ollama provider, got %s", svc.provider.Name())
	}
}

// ============================================================================
// GetConfig Tests
// ============================================================================

func TestService_GetConfig_DefaultsWhenNil(t *testing.T) {
	svc := NewService(nil, nil)
	svc.cfg = nil

	cfg := svc.GetConfig()
	if cfg != nil {
		t.Error("Expected nil config when not configured")
	}
}

func TestService_GetConfig_ReturnsCopy(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-getconfig-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)
	_ = persistence.SaveAIConfig(config.AIConfig{
		Enabled: true,
		Model:   "test:model",
	})

	svc := NewService(persistence, nil)
	_ = svc.LoadConfig()

	cfg := svc.GetConfig()
	if cfg == nil {
		t.Fatal("Expected config to be returned")
	}

	if cfg.Model != "test:model" {
		t.Errorf("Expected model 'test:model', got '%s'", cfg.Model)
	}
}

// ============================================================================
// IsAutonomous Tests
// ============================================================================

func TestService_IsAutonomous_Variations(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-autonomous-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)

	// Test with read_only control level
	cfg := config.AIConfig{
		Enabled:      true,
		ControlLevel: config.ControlLevelReadOnly,
	}
	_ = persistence.SaveAIConfig(cfg)

	svc := NewService(persistence, nil)
	_ = svc.LoadConfig()

	if svc.IsAutonomous() {
		t.Error("Expected not autonomous when mode is false")
	}

	// Test with autonomous control level
	cfg.ControlLevel = config.ControlLevelAutonomous
	_ = persistence.SaveAIConfig(cfg)
	_ = svc.LoadConfig()

	if !svc.IsAutonomous() {
		t.Error("Expected autonomous when mode is true")
	}
}

// ============================================================================
// Knowledge Store Tests - Extended
// ============================================================================

func TestService_KnowledgeStore_Success(t *testing.T) {
	tmpDir := t.TempDir()
	store, _ := knowledge.NewStore(tmpDir)

	svc := NewService(nil, nil)
	svc.knowledgeStore = store

	_, err := svc.GetGuestKnowledge("vm-100")
	if err != nil {
		t.Errorf("GetGuestKnowledge failed: %v", err)
	}

	err = svc.SaveGuestNote("vm-100", "test", "vm", "general", "title", "content")
	if err != nil {
		t.Errorf("SaveGuestNote failed: %v", err)
	}

	err = svc.DeleteGuestNote("vm-100", "general-1")
	if err != nil {
		t.Errorf("DeleteGuestNote failed: %v", err)
	}
}

// ============================================================================
// ListModelsWithCache - Extended
// ============================================================================

func TestService_ListModelsWithCache_ProviderErrors(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "pulse-listmodels-err-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	persistence := config.NewConfigPersistence(tmpDir)
	_ = persistence.SaveAIConfig(config.AIConfig{
		Enabled:      true,
		OpenAIAPIKey: "test-key",
	})

	svc := NewService(persistence, nil)

	// The provider will fail because it's a real OpenAI provider with dummy key
	_, cached, err := svc.ListModelsWithCache(context.Background())
	if err != nil {
		t.Fatalf("ListModelsWithCache should not fail even if providers fail: %v", err)
	}
	if cached {
		t.Error("Expected no cache hit")
	}
}

func TestService_ListModelsWithCache_DeepSeekCatalogFallback(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	if err := persistence.SaveAIConfig(config.AIConfig{
		Enabled:        true,
		Model:          config.DefaultModelForProvider(config.AIProviderDeepSeek),
		PatrolModel:    config.FormatModelString(config.AIProviderDeepSeek, config.DeepSeekModelV4Flash),
		DeepSeekAPIKey: "test-key",
	}); err != nil {
		t.Fatalf("SaveAIConfig: %v", err)
	}

	svc := NewService(persistence, nil)
	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	models, cached, err := svc.ListModelsWithCache(ctx)
	if err != nil {
		t.Fatalf("ListModelsWithCache should not fail when DeepSeek catalog fetch fails: %v", err)
	}
	if cached {
		t.Fatal("expected fallback catalog response to be uncached")
	}

	ids := make(map[string]providers.ModelInfo, len(models))
	for _, model := range models {
		ids[model.ID] = model
	}
	for _, want := range []string{
		config.FormatModelString(config.AIProviderDeepSeek, config.DeepSeekModelV4Flash),
		config.FormatModelString(config.AIProviderDeepSeek, config.DeepSeekModelV4Pro),
		config.FormatModelString(config.AIProviderDeepSeek, config.DeepSeekModelLegacyChat),
		config.FormatModelString(config.AIProviderDeepSeek, config.DeepSeekModelLegacyReasoner),
	} {
		if _, ok := ids[want]; !ok {
			t.Fatalf("expected DeepSeek fallback model %q in %+v", want, models)
		}
	}
	if got := ids[config.FormatModelString(config.AIProviderDeepSeek, config.DeepSeekModelV4Flash)].Name; got != "DeepSeek V4 Flash" {
		t.Fatalf("unexpected DeepSeek V4 Flash display name %q", got)
	}
}

// ============================================================================
// GetDebugContext - Truncation
// ============================================================================

func TestService_GetDebugContext_Truncation(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// Large custom context
	svc.cfg = &config.AIConfig{
		CustomContext: strings.Repeat("x", 300),
	}

	// Add many VMs to trigger truncation (unique IDs required for registry)
	snapshot := models.StateSnapshot{
		Nodes: []models.Node{
			{ID: "node/node", Name: "node", Instance: "node", Status: "online"},
		},
	}
	for i := 0; i < 15; i++ {
		snapshot.VMs = append(snapshot.VMs, models.VM{ID: fmt.Sprintf("qemu/%d", i), VMID: i, Name: fmt.Sprintf("vm-%d", i), Node: "node", Instance: "node"})
		snapshot.Containers = append(snapshot.Containers, models.Container{ID: fmt.Sprintf("lxc/%d", i+100), VMID: i + 100, Name: fmt.Sprintf("ct-%d", i), Node: "node", Instance: "node"})
	}
	registry := unifiedresources.NewRegistry(nil)
	registry.IngestSnapshot(snapshot)
	svc.SetReadState(registry)

	result := svc.GetDebugContext(ExecuteRequest{})

	preview := result["custom_context_preview"].(string)
	if !strings.HasSuffix(preview, "...") || len(preview) != 203 {
		t.Errorf("Expected truncated preview, got length %d", len(preview))
	}

	sampleVMs := result["sample_vms"].([]string)
	if len(sampleVMs) != 10 {
		t.Errorf("Expected 10 sample VMs, got %d", len(sampleVMs))
	}

	sampleCTs := result["sample_containers"].([]string)
	if len(sampleCTs) != 10 {
		t.Errorf("Expected 10 sample containers, got %d", len(sampleCTs))
	}
}

func TestService_GetDebugContext_ShortContext(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)
	svc.cfg = &config.AIConfig{
		CustomContext: "short context",
	}

	result := svc.GetDebugContext(ExecuteRequest{})
	if result["custom_context_preview"] != "short context" {
		t.Errorf("Expected 'short context', got %v", result["custom_context_preview"])
	}
}

func TestService_ListModelsWithCache_ConfigErrors(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)

	// Force LoadAIConfig failure
	aiFilePath := filepath.Join(tmpDir, "ai.enc")
	_ = os.MkdirAll(aiFilePath, 0755)

	svc := NewService(persistence, nil)
	_, _, err := svc.ListModelsWithCache(context.Background())
	if err == nil {
		t.Error("Expected error when LoadAIConfig fails")
	}
}

// ============================================================================
// SetResourceURL Tests - Extended
// ============================================================================

func TestService_SetResourceURL_AppContainerType(t *testing.T) {
	svc := NewService(nil, nil)
	mockMeta := &mockMetadataProvider{}
	svc.metadataProvider = mockMeta

	err := svc.SetResourceURL("app-container", "host:container:abc123", "http://example.com:8080")
	if err != nil {
		t.Errorf("SetResourceURL failed: %v", err)
	}
	if mockMeta.lastDockerID != "host:container:abc123" {
		t.Errorf("Expected docker ID 'host:container:abc123', got '%s'", mockMeta.lastDockerID)
	}
}

func TestService_SetResourceURL_AgentType(t *testing.T) {
	svc := NewService(nil, nil)
	mockMeta := &mockMetadataProvider{}
	svc.metadataProvider = mockMeta

	err := svc.SetResourceURL("agent", "my-host", "http://host.local:9090")
	if err != nil {
		t.Errorf("SetResourceURL failed: %v", err)
	}
	if mockMeta.lastHostID != "my-host" {
		t.Errorf("Expected host ID 'my-host', got '%s'", mockMeta.lastHostID)
	}
}

func TestService_SetResourceURL_UnknownType(t *testing.T) {
	svc := NewService(nil, nil)
	mockMeta := &mockMetadataProvider{}
	svc.metadataProvider = mockMeta

	err := svc.SetResourceURL("unknown", "id", "http://example.com")
	if err == nil {
		t.Error("Expected error for unknown resource type")
	}
}

func TestService_SetResourceURL_NoMetadataProvider(t *testing.T) {
	svc := NewService(nil, nil)
	svc.metadataProvider = nil

	err := svc.SetResourceURL("vm", "vm-100", "http://example.com")
	if err == nil {
		t.Error("Expected error when metadata provider not available")
	}
}

func TestService_BuildUserAnnotationsContext_Variants(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// Guest metadata with no name
	guestMeta := map[string]*config.GuestMetadata{
		"guest-no-name": {
			ID:    "guest-no-name",
			Notes: []string{"Note1"},
		},
	}
	data, _ := json.Marshal(guestMeta)
	_ = os.WriteFile(filepath.Join(tmpDir, "guest_metadata.json"), data, 0644)

	// Docker metadata with long ID and simple ID (no host part)
	dockerMeta := map[string]*config.DockerMetadata{
		"host:container:verylongcontainerid123456": {
			ID:    "host:container:verylongcontainerid123456",
			Notes: []string{"DockerNote1"},
		},
		"simple-id": {
			ID:    "simple-id",
			Notes: []string{"SimpleDockerNote"},
		},
	}
	data, _ = json.Marshal(dockerMeta)
	_ = os.WriteFile(filepath.Join(tmpDir, "docker_metadata.json"), data, 0644)

	ctx := svc.buildUserAnnotationsContext()

	// Check guest ID fallback
	if !strings.Contains(ctx, "guest-no-name") {
		t.Error("Expected guest ID when LastKnownName is missing")
	}

	// Check long container ID truncation
	if !strings.Contains(ctx, "verylongcont") {
		t.Error("Container name should contain partial ID")
	}

	// Check simple docker ID
	if !strings.Contains(ctx, "simple-id") {
		t.Error("Should handle simple docker ID")
	}
}

func TestService_GetDebugContext_Extended(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)

	// Build snapshot with many VMs/containers (unique IDs required for registry)
	snapshot := models.StateSnapshot{
		Nodes: []models.Node{
			{ID: "node/node", Name: "node", Instance: "node", Status: "online"},
		},
	}
	for i := 0; i < 15; i++ {
		snapshot.VMs = append(snapshot.VMs, models.VM{ID: fmt.Sprintf("qemu/%d", i), Name: fmt.Sprintf("VM-%d", i), VMID: i, Node: "node", Instance: "node"})
		snapshot.Containers = append(snapshot.Containers, models.Container{ID: fmt.Sprintf("lxc/%d", i+100), Name: fmt.Sprintf("CT-%d", i), VMID: i + 100, Node: "node", Instance: "node"})
	}
	registry := unifiedresources.NewRegistry(nil)
	registry.IngestSnapshot(snapshot)
	svc.SetReadState(registry)

	svc.cfg = &config.AIConfig{
		Enabled:       true,
		CustomContext: strings.Repeat("x", 300),
	}

	debug := svc.GetDebugContext(ExecuteRequest{})

	if len(debug["sample_vms"].([]string)) != 10 {
		t.Errorf("Expected 10 sample VMs, got %d", len(debug["sample_vms"].([]string)))
	}
	if len(debug["sample_containers"].([]string)) != 10 {
		t.Errorf("Expected 10 sample containers, got %d", len(debug["sample_containers"].([]string)))
	}
	if !strings.HasSuffix(debug["custom_context_preview"].(string), "...") {
		t.Error("Expected custom context preview to be truncated")
	}
}

func TestService_EnrichRequestFromFinding(t *testing.T) {
	svc := NewService(nil, nil)

	// Setup patrol service with a mock finding
	mockState := &mockStateProvider{
		state: models.StateSnapshot{},
	}
	svc.stateProvider = mockState
	svc.patrolService = NewPatrolService(svc, mockState)

	// Add a finding to the store
	finding := &Finding{
		ID:           "test-finding-123",
		Node:         "minipc",
		ResourceID:   "pve-node:minipc:112",
		ResourceName: "debian-go",
		ResourceType: "system-container",
		Title:        "Test Finding",
		Description:  "Test description",
		Severity:     FindingSeverityWarning,
		Category:     FindingCategoryCapacity,
	}
	svc.patrolService.GetFindings().Add(finding)

	// Test 1: Enrich request with finding context
	req := ExecuteRequest{
		FindingID: "test-finding-123",
		Prompt:    "Help me fix this",
	}
	svc.enrichRequestFromFinding(&req)

	if req.Context["node"] != "minipc" {
		t.Errorf("Expected node 'minipc', got %v", req.Context["node"])
	}
	if req.Context["guestName"] != "debian-go" {
		t.Errorf("Expected guestName 'debian-go', got %v", req.Context["guestName"])
	}
	if req.TargetID != "pve-node:minipc:112" {
		t.Errorf("Expected TargetID 'pve-node:minipc:112', got %s", req.TargetID)
	}
	if req.TargetType != "system-container" {
		t.Errorf("Expected TargetType 'system-container', got %s", req.TargetType)
	}
	if req.Context["finding_node"] != "minipc" {
		t.Errorf("Expected finding_node 'minipc', got %v", req.Context["finding_node"])
	}

	// Test 2: Don't overwrite existing context
	req2 := ExecuteRequest{
		FindingID:  "test-finding-123",
		TargetID:   "existing-target",
		TargetType: "existing-type",
		Context: map[string]interface{}{
			"node":      "existing-node",
			"guestName": "existing-name",
		},
	}
	svc.enrichRequestFromFinding(&req2)

	if req2.Context["node"] != "existing-node" {
		t.Errorf("Should not overwrite existing node, got %v", req2.Context["node"])
	}
	if req2.Context["guestName"] != "existing-name" {
		t.Errorf("Should not overwrite existing guestName, got %v", req2.Context["guestName"])
	}
	if req2.TargetID != "existing-target" {
		t.Errorf("Should not overwrite existing TargetID, got %s", req2.TargetID)
	}
	// But finding_* fields should still be added
	if req2.Context["finding_node"] != "minipc" {
		t.Errorf("Expected finding_node 'minipc', got %v", req2.Context["finding_node"])
	}

	// Test 3: No finding ID - should be a no-op
	req3 := ExecuteRequest{
		Prompt: "Just a question",
	}
	svc.enrichRequestFromFinding(&req3)
	if len(req3.Context) > 0 {
		t.Error("Should not add context when no FindingID")
	}

	// Test 4: Non-existent finding ID - should be a no-op
	req4 := ExecuteRequest{
		FindingID: "non-existent",
		Prompt:    "Help",
	}
	svc.enrichRequestFromFinding(&req4)
	if len(req4.Context) > 0 {
		t.Error("Should not add context when finding not found")
	}
}

// TestService_FindingContextInSystemPrompt verifies that when a FindingID is provided,
// the system prompt includes proper routing instructions derived from the finding's node.
// This is the integration test that would have caught the original bug.
func TestService_FindingContextInSystemPrompt(t *testing.T) {
	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, nil)
	svc.cfg = &config.AIConfig{Enabled: true}

	// Setup patrol service with a finding that has node info
	mockState := &mockStateProvider{
		state: models.StateSnapshot{
			Containers: []models.Container{
				{VMID: 112, Node: "minipc", Name: "debian-go", Instance: "pve-node"},
			},
		},
	}
	svc.stateProvider = mockState
	svc.patrolService = NewPatrolService(svc, mockState)

	// Add a finding with node context
	finding := &Finding{
		ID:           "disk-growth-finding",
		Node:         "minipc",
		ResourceID:   "pve-node:minipc:112",
		ResourceName: "debian-go",
		ResourceType: "system-container",
		Title:        "Container disk usage growing",
		Description:  "Disk growing at 4% per day",
		Severity:     FindingSeverityWarning,
		Category:     FindingCategoryCapacity,
	}
	svc.patrolService.GetFindings().Add(finding)

	// Create a request like "Get Help" would - only FindingID provided
	req := ExecuteRequest{
		FindingID: "disk-growth-finding",
		Prompt:    "Help me fix this disk issue",
	}

	// Enrich the request (this is what Execute() does now)
	svc.enrichRequestFromFinding(&req)

	// Build the system prompt
	prompt := svc.buildSystemPrompt(req, "")

	// Verify the prompt includes routing context
	if !strings.Contains(prompt, "minipc") {
		t.Error("System prompt should include the node name 'minipc' for routing")
	}
	if !strings.Contains(prompt, "debian-go") {
		t.Error("System prompt should include the resource name 'debian-go'")
	}
	if !strings.Contains(prompt, "target_host") || !strings.Contains(prompt, "minipc") {
		t.Error("System prompt should include ROUTING instructions mentioning target_host=minipc")
	}
}

func TestService_BuildSystemPrompt_ApprovalBoundCommandHandoff(t *testing.T) {
	svc := NewService(nil, nil)
	prompt := svc.buildSystemPrompt(ExecuteRequest{RequireCommandApproval: true}, "")

	if !strings.Contains(prompt, "This handoff is approval-bound") {
		t.Fatalf("expected approval-bound command guidance, got: %s", prompt)
	}
	if !strings.Contains(prompt, "Any run_command tool call will pause for explicit operator approval") {
		t.Fatalf("expected all command tool calls to require approval, got: %s", prompt)
	}
	if strings.Contains(prompt, "Safe commands (read-only: ls, df, cat, ps) execute immediately") {
		t.Fatalf("approval-bound prompt must not say safe commands execute immediately: %s", prompt)
	}
}

// TestService_FindingContextCommandRouting verifies that commands route correctly
// when ExecuteStream is called with a FindingID. This is an end-to-end test.
func TestService_FindingContextCommandRouting(t *testing.T) {
	// Track which agent the command was routed to
	routedToAgent := ""

	mockAgentServer := &mockAgentServer{
		agents: []agentexec.ConnectedAgent{
			{AgentID: "agent-pve-node", Hostname: "pve-node"},
			{AgentID: "agent-minipc", Hostname: "minipc"},
		},
		executeFunc: func(ctx context.Context, agentID string, cmd agentexec.ExecuteCommandPayload) (*agentexec.CommandResultPayload, error) {
			routedToAgent = agentID
			return &agentexec.CommandResultPayload{
				Success: true,
				Stdout:  "Command output",
			}, nil
		},
	}

	tmpDir := t.TempDir()
	persistence := config.NewConfigPersistence(tmpDir)
	svc := NewService(persistence, mockAgentServer)
	svc.cfg = &config.AIConfig{Enabled: true, ControlLevel: config.ControlLevelControlled}
	svc.limits = executionLimits{
		chatSlots:   make(chan struct{}, 10),
		patrolSlots: make(chan struct{}, 10),
	}
	svc.policy = &mockPolicy{decision: agentexec.PolicyAllow}

	// Setup patrol service with finding
	mockState := &mockStateProvider{
		state: models.StateSnapshot{
			Containers: []models.Container{
				{VMID: 112, Node: "minipc", Name: "debian-go", Instance: "pve-node"},
			},
		},
	}
	svc.stateProvider = mockState
	svc.patrolService = NewPatrolService(svc, mockState)

	// Add finding on node "minipc"
	finding := &Finding{
		ID:           "test-routing-finding",
		Node:         "minipc",
		ResourceID:   "pve-node:minipc:112",
		ResourceName: "debian-go",
		ResourceType: "system-container",
	}
	svc.patrolService.GetFindings().Add(finding)

	// Create request with finding ID (like "Get Help" does)
	req := ExecuteRequest{
		FindingID: "test-routing-finding",
		Prompt:    "Check disk usage",
	}

	// Enrich the request
	svc.enrichRequestFromFinding(&req)

	// Now execute a command tool call - should route to minipc
	tc := providers.ToolCall{
		Name: "run_command",
		Input: map[string]interface{}{
			"command": "df -h",
		},
	}

	result, exec := svc.executeTool(context.Background(), req, tc)

	if exec.Success || !strings.Contains(result, "Invocation blocked") {
		t.Fatalf("retired run_command did not fail closed: success=%v result=%q", exec.Success, result)
	}

	if routedToAgent != "" {
		t.Fatalf("retired run_command reached agent routing: %s", routedToAgent)
	}
}