glpi-neural-brain/internal/config/config_test.go

package config

import (
	"testing"
)

func TestLoadOllamaPoolAndGLPIKB(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("OLLAMA_URLS", "http://gpu-a:11434,http://gpu-b:11434")
	t.Setenv("OLLAMA_NODE_NAMES", "a,b")
	t.Setenv("OLLAMA_NODE_WEIGHTS", "1,3")
	t.Setenv("OLLAMA_ROUTING_MODE", "weighted")
	t.Setenv("GLPI_KB_ENABLED", "true")
	t.Setenv("GLPI_URL", "http://glpi.test")
	t.Setenv("GLPI_ALLOW_INSECURE_HTTP", "true")
	t.Setenv("GLPI_CLIENT_ID", "id")
	t.Setenv("GLPI_CLIENT_SECRET", "secret")
	t.Setenv("GLPI_USERNAME", "user")
	t.Setenv("GLPI_PASSWORD", "password")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if len(cfg.OllamaURLs) != 2 || cfg.OllamaNodeNames[1] != "b" || cfg.OllamaNodeWeights[1] != 3 || cfg.OllamaRoutingMode != "weighted" {
		t.Fatalf("unexpected pool config: %+v", cfg)
	}
	if !cfg.GLPIKBEnabled || cfg.GLPIURL != "http://glpi.test" {
		t.Fatalf("unexpected GLPI config: %+v", cfg)
	}
}

func TestLoadRejectsMismatchedPoolMetadata(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("OLLAMA_URLS", "http://gpu-a:11434,http://gpu-b:11434")
	t.Setenv("OLLAMA_NODE_NAMES", "only-one")
	if _, err := Load(); err == nil {
		t.Fatal("expected pool metadata validation error")
	}
}

func TestLoadRuntimeControlDefaultsAndFilters(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_LEARNING_ENABLED", "false")
	t.Setenv("BRAIN_THINKING_ENABLED", "false")
	t.Setenv("BRAIN_LEARNING_SOURCES", "GLPI Knowledge Base,internal-kb")
	t.Setenv("BRAIN_DISPLAY_SOURCES", "GLPI Knowledge Base")
	t.Setenv("BRAIN_THINKING_SOURCES", "internal-kb")
	t.Setenv("BRAIN_DEFAULT_VIEW", "constellation")
	t.Setenv("BRAIN_MAX_DISPLAY_NODES", "12000")
	t.Setenv("BRAIN_LOW_POWER_MODE", "true")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if cfg.LearningEnabled || cfg.ThinkingEnabled || cfg.DefaultView != "constellation" || cfg.MaxDisplayNodes != 12000 || !cfg.LowPowerMode {
		t.Fatalf("unexpected runtime defaults: %+v", cfg)
	}
	if len(cfg.LearningSources) != 2 || len(cfg.DisplaySources) != 1 || len(cfg.ThinkingSources) != 1 {
		t.Fatalf("unexpected source defaults: %+v", cfg)
	}
}

func TestLoadRejectsInvalidMaxDisplayNodes(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_MAX_DISPLAY_NODES", "500001")
	if _, err := Load(); err == nil {
		t.Fatal("expected max display nodes validation error")
	}
}

func TestLoadArticleSynthesisQualitySettings(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_ARTICLE_SYNTHESIS_ENABLED", "true")
	t.Setenv("BRAIN_ARTICLE_MIN_SOURCES", "4")
	t.Setenv("BRAIN_ARTICLE_MAX_SOURCES", "7")
	t.Setenv("BRAIN_ARTICLE_MIN_PRODUCTION_RATIO", "0.8")
	t.Setenv("BRAIN_ARTICLE_MAX_GENERATION_DEPTH", "2")
	t.Setenv("BRAIN_ARTICLE_MIN_CONFIDENCE", "0.81")
	t.Setenv("BRAIN_ARTICLE_MIN_TEXT_CHARS", "220")
	t.Setenv("BRAIN_ARTICLE_MIN_ANSWER_CHARS", "500")
	t.Setenv("BRAIN_ARTICLE_LANGUAGE", "en-US")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if !cfg.ArticleSynthesisEnabled || cfg.ArticleMinSources != 4 || cfg.ArticleMaxSources != 7 || cfg.ArticleMinProductionRatio != 0.8 || cfg.ArticleMaxGenerationDepth != 2 || cfg.ArticleMinConfidence != 0.81 || cfg.ArticleMinTextChars != 220 || cfg.ArticleMinAnswerChars != 500 || cfg.ArticleLanguage != "en-US" {
		t.Fatalf("unexpected article synthesis config: %+v", cfg)
	}
}

func TestLoadIterativeResearchSettings(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_ARTICLE_MAX_RESEARCH_QUERIES", "5")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_RESULTS", "10")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_ROUNDS", "4")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_FETCH_RESULTS", "3")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_EXPLORATION_RESULTS", "2")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_PREFETCH_MIN_RELEVANCE", "0.3")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_MIN_RELEVANCE", "0.7")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_MIN_QUALITY", "0.6")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_PAGE_MAX_BYTES", "1048576")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_PAGE_MAX_CHARS", "9000")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_FETCH_TIMEOUT", "15s")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_ALLOW_PRIVATE", "true")
	t.Setenv("BRAIN_RESEARCH_DEDUPE_THRESHOLD", "0.94")
	t.Setenv("BRAIN_RESEARCH_DEDUPE_TTL", "30m")
	t.Setenv("BRAIN_RESEARCH_OLLAMA_MAX_INFLIGHT", "3")
	t.Setenv("BRAIN_RESEARCH_OLLAMA_QUEUE_SIZE", "24")
	t.Setenv("BRAIN_ARTICLE_RESEARCH_STRATEGY", "adaptive")
	t.Setenv("BRAIN_ARTICLE_ADAPTIVE_INITIAL_QUERIES", "2")
	t.Setenv("BRAIN_ARTICLE_ADAPTIVE_INITIAL_FETCH", "2")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if cfg.ArticleMaxResearchQueries != 5 || cfg.ArticleResearchResults != 10 || cfg.ArticleResearchRounds != 4 || cfg.ArticleResearchFetchResults != 3 || cfg.ArticleResearchExplorationResults != 2 || cfg.ArticleResearchPrefetchMinRelevance != .3 || cfg.ArticleResearchMinRelevance != .7 || cfg.ArticleResearchMinQuality != .6 || cfg.ArticleResearchPageMaxBytes != 1048576 || cfg.ArticleResearchPageMaxChars != 9000 || cfg.ArticleResearchFetchTimeout.String() != "15s" || !cfg.ArticleResearchAllowPrivate || cfg.ResearchDedupeThreshold != .94 || cfg.ResearchDedupeTTL.String() != "30m0s" || cfg.ResearchOllamaMaxInflight != 3 || cfg.ResearchOllamaQueueSize != 24 || cfg.ArticleResearchStrategy != "adaptive" || cfg.ArticleAdaptiveInitialQueries != 2 || cfg.ArticleAdaptiveInitialFetch != 2 {
		t.Fatalf("unexpected iterative research config: %+v", cfg)
	}
}

func TestLoadAutonomousResearchSettings(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("SEARXNG_URL", "http://searxng:8080")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_ENABLED", "true")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_IDLE_ONLY", "false")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_INTERVAL", "12m")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_TASKS_PER_CYCLE", "2")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_MAX_TASKS_PER_DAY", "18")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_MAX_QUERIES_PER_TASK", "7")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_MAX_PAGES_PER_TASK", "9")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_MAX_ROUNDS", "4")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_MIN_PRIORITY", "0.72")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_COOLDOWN", "120h")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_LEASE", "35m")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_MAX_ATTEMPTS", "4")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_QUERY_TRIGGERS", "false")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_OPPORTUNITY_LIMIT", "11")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if !cfg.AutonomousResearchEnabled || cfg.AutonomousResearchIdleOnly || cfg.AutonomousResearchInterval.String() != "12m0s" || cfg.AutonomousResearchTasksPerCycle != 2 || cfg.AutonomousResearchMaxTasksPerDay != 18 || cfg.AutonomousResearchMaxQueriesPerTask != 7 || cfg.AutonomousResearchMaxPagesPerTask != 9 || cfg.AutonomousResearchMaxRounds != 4 || cfg.AutonomousResearchMinPriority != .72 || cfg.AutonomousResearchCooldown.String() != "120h0m0s" || cfg.AutonomousResearchLease.String() != "35m0s" || cfg.AutonomousResearchMaxAttempts != 4 || cfg.AutonomousResearchQueryTriggers || cfg.AutonomousResearchOpportunityLimit != 11 {
		t.Fatalf("unexpected autonomous research config: %+v", cfg)
	}
}

func TestLoadRejectsAutonomousResearchWithoutSearXNG(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_ENABLED", "true")
	t.Setenv("SEARXNG_URL", "")
	if _, err := Load(); err == nil {
		t.Fatal("expected SEARXNG_URL validation error")
	}
}

func TestLoadClusterProcessingMode(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_PROCESSING_MODE", "clustered")
	t.Setenv("BRAIN_CLUSTER_HASH_BITS", "20")
	t.Setenv("BRAIN_CLUSTER_HASH_TABLES", "3")
	t.Setenv("BRAIN_CLUSTER_CANDIDATES_PER_ANCHOR", "80")
	t.Setenv("BRAIN_CLUSTER_ARTICLE_CANDIDATES", "160")
	t.Setenv("BRAIN_CLUSTER_REVIEW_EVIDENCE", "7")
	t.Setenv("BRAIN_CLUSTER_REVIEW_CONTEXT_CHARS", "7000")
	t.Setenv("BRAIN_CLUSTER_ARTICLE_BATCHING", "false")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if cfg.ProcessingMode != "clustered" || cfg.ClusterHashBits != 20 || cfg.ClusterHashTables != 3 || cfg.ClusterCandidatesPerAnchor != 80 || cfg.ClusterArticleCandidates != 160 || cfg.ClusterReviewEvidence != 7 || cfg.ClusterReviewContextChars != 7000 || cfg.ClusterArticleBatching {
		t.Fatalf("unexpected cluster config: %+v", cfg)
	}
}

func TestLoadRejectsInvalidProcessingMode(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_PROCESSING_MODE", "turbo")
	if _, err := Load(); err == nil {
		t.Fatal("expected invalid processing mode error")
	}
}

func TestLoadRejectsInvalidArticleResearchStrategy(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_ARTICLE_RESEARCH_STRATEGY", "spray-and-pray")
	if _, err := Load(); err == nil {
		t.Fatal("expected invalid article research strategy error")
	}
}

func TestLoadAgentModeDoesNotRequireBrainDependencies(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_MODE", "agent")
	t.Setenv("BRAIN_AGENT_BRAIN_URL", "http://brain:8090")
	t.Setenv("BRAIN_AGENT_ID", "poller-1")
	t.Setenv("BRAIN_AGENT_TOKEN", "brain_agent_test")
	t.Setenv("OLLAMA_URLS", "not-a-url")
	t.Setenv("BRAIN_AUTONOMOUS_RESEARCH_ENABLED", "true")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if cfg.Mode != "agent" || cfg.AgentID != "poller-1" || cfg.AgentBrainURL != "http://brain:8090" {
		t.Fatalf("unexpected agent config: %+v", cfg)
	}
}

func TestLoadAgentModeRequiresBootstrapConnection(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_MODE", "agent")
	t.Setenv("BRAIN_AGENT_BRAIN_URL", "")
	t.Setenv("BRAIN_AGENT_ID", "")
	t.Setenv("BRAIN_AGENT_TOKEN", "")
	t.Setenv("BRAIN_AGENT_CONFIG_FILE", "")
	if _, err := Load(); err == nil {
		t.Fatal("expected missing agent bootstrap configuration error")
	}
}

func TestLoadBrainPublicURL(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_PUBLIC_URL", "https://brain.example.org/")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if cfg.BrainPublicURL != "https://brain.example.org" {
		t.Fatalf("unexpected public URL: %q", cfg.BrainPublicURL)
	}
}

func TestLoadRejectsInvalidBrainPublicURL(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_PUBLIC_URL", "brain.example.org")
	if _, err := Load(); err == nil {
		t.Fatal("expected invalid BRAIN_PUBLIC_URL error")
	}
}

func TestLoadSourceInboxPriorityClassifierSettings(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_SOURCE_INBOX_MIN_SIMILARITY", "0.58")
	t.Setenv("BRAIN_SOURCE_INBOX_MIN_PRIORITY", "0.61")
	t.Setenv("BRAIN_SOURCE_INBOX_NOVELTY_FLOOR", "0.33")
	t.Setenv("BRAIN_SOURCE_INBOX_SECURITY_PROACTIVE", "true")
	t.Setenv("BRAIN_SOURCE_INBOX_SECURITY_BATCH_SIZE", "3")
	t.Setenv("BRAIN_SOURCE_INBOX_SECURITY_MIN_PRIORITY", "0.63")
	t.Setenv("BRAIN_SOURCE_INBOX_SECURITY_MIN_CONFIDENCE", "0.78")
	t.Setenv("BRAIN_SOURCE_INBOX_SECURITY_FETCH_MIN_CHARS", "2200")
	t.Setenv("BRAIN_SOURCE_INBOX_SECURITY_RESEARCH_RESULTS", "4")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if cfg.SourceInboxMinSimilarity != .58 || cfg.SourceInboxMinPriority != .61 || cfg.SourceInboxNoveltyFloor != .33 || !cfg.SourceInboxSecurityProactiveEnabled || cfg.SourceInboxSecurityBatchSize != 3 || cfg.SourceInboxSecurityMinPriority != .63 || cfg.SourceInboxSecurityMinConfidence != .78 || cfg.SourceInboxSecurityFetchMinChars != 2200 || cfg.SourceInboxSecurityResearchResults != 4 {
		t.Fatalf("unexpected source inbox classifier config: %+v", cfg)
	}
}

func TestLoadKnowledgeFullVerifyInterval(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_KNOWLEDGE_FULL_VERIFY_INTERVAL", "2h")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if cfg.KnowledgeFullVerifyInterval.String() != "2h0m0s" {
		t.Fatalf("unexpected full verify interval: %s", cfg.KnowledgeFullVerifyInterval)
	}
}

func TestLoadRejectsTooFrequentKnowledgeFullVerify(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_KNOWLEDGE_FULL_VERIFY_INTERVAL", "1m")
	if _, err := Load(); err == nil {
		t.Fatal("expected knowledge full verify interval validation error")
	}
}

func TestLoadVectorGraphAgentAndOrphanSettings(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_VECTOR_GRAPH_ENABLED", "true")
	t.Setenv("BRAIN_VECTOR_GRAPH_ORPHAN_PASS", "true")
	t.Setenv("BRAIN_VECTOR_GRAPH_ORPHAN_NEIGHBORS", "2")
	t.Setenv("BRAIN_VECTOR_GRAPH_ORPHAN_CANDIDATES", "224")
	t.Setenv("BRAIN_VECTOR_GRAPH_ORPHAN_MIN_SIMILARITY", "0.81")
	t.Setenv("BRAIN_VECTOR_GRAPH_ORPHAN_MIN_AFFINITY", "0.31")
	t.Setenv("BRAIN_VECTOR_GRAPH_AGENT_OFFLOAD", "true")
	t.Setenv("BRAIN_VECTOR_GRAPH_AGENT_REQUIRED", "false")
	t.Setenv("BRAIN_VECTOR_GRAPH_AGENT_WAIT", "90s")
	t.Setenv("BRAIN_THINKING_VECTOR_GUIDED", "true")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if !cfg.VectorGraphEnabled || !cfg.VectorGraphOrphanPass || cfg.VectorGraphOrphanNeighbors != 2 || cfg.VectorGraphOrphanCandidates != 224 || cfg.VectorGraphOrphanMinSimilarity != .81 || cfg.VectorGraphOrphanMinAffinity != .31 || !cfg.VectorGraphAgentOffload || cfg.VectorGraphAgentRequired || cfg.VectorGraphAgentWait.String() != "1m30s" || !cfg.ThinkingVectorGuided {
		t.Fatalf("unexpected vector graph distributed settings: %+v", cfg)
	}
}

func TestLoadAgentComputeSettings(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_MODE", "agent")
	t.Setenv("BRAIN_AGENT_BRAIN_URL", "http://brain:8090")
	t.Setenv("BRAIN_AGENT_ID", "cpu-1")
	t.Setenv("BRAIN_AGENT_TOKEN", "brain_agent_test")
	t.Setenv("BRAIN_AGENT_COMPUTE_ENABLED", "true")
	t.Setenv("BRAIN_AGENT_COMPUTE_POLL_INTERVAL", "3s")
	t.Setenv("BRAIN_AGENT_COMPUTE_MAX_BYTES", "100663296")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if !cfg.AgentComputeEnabled || cfg.AgentComputePollInterval.String() != "3s" || cfg.AgentComputeMaxBytes != 100663296 {
		t.Fatalf("unexpected agent compute settings: %+v", cfg)
	}
}

func TestLoadRejectsRequiredVectorAgentWithoutOffload(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_VECTOR_GRAPH_AGENT_OFFLOAD", "false")
	t.Setenv("BRAIN_VECTOR_GRAPH_AGENT_REQUIRED", "true")
	if _, err := Load(); err == nil {
		t.Fatal("expected required vector agent to require offload")
	}
}

func TestLoadArticleCPUQualityAndVectorRelaxationSettings(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_ARTICLE_CPU_QUALITY_ENABLED", "true")
	t.Setenv("BRAIN_ARTICLE_CPU_QUALITY_AGENT_OFFLOAD", "true")
	t.Setenv("BRAIN_ARTICLE_CPU_QUALITY_AGENT_REQUIRED", "false")
	t.Setenv("BRAIN_ARTICLE_CPU_QUALITY_AGENT_WAIT", "25s")
	t.Setenv("BRAIN_VECTOR_GRAPH_REEVALUATE_INTERVAL", "20m")
	t.Setenv("BRAIN_VECTOR_GRAPH_RELAX_LAYOUT", "true")
	t.Setenv("BRAIN_VECTOR_GRAPH_LAYOUT_RELAX_INTERVAL", "90m")
	t.Setenv("BRAIN_VECTOR_GRAPH_LAYOUT_BLEND", "0.10")
	t.Setenv("BRAIN_VECTOR_GRAPH_LAYOUT_MAX_SHIFT", "0.04")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if !cfg.ArticleCPUQualityEnabled || !cfg.ArticleCPUQualityAgentOffload || cfg.ArticleCPUQualityAgentRequired || cfg.ArticleCPUQualityAgentWait.String() != "25s" {
		t.Fatalf("unexpected article CPU quality config: %+v", cfg)
	}
	if cfg.VectorGraphReevaluateInterval.String() != "20m0s" || !cfg.VectorGraphRelaxLayout || cfg.VectorGraphLayoutRelaxInterval.String() != "1h30m0s" || cfg.VectorGraphLayoutBlend != .10 || cfg.VectorGraphLayoutMaxShift != .04 {
		t.Fatalf("unexpected vector relaxation config: %+v", cfg)
	}
}

func TestLoadSpeedModeSettings(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_SPEED_MODE", "true")
	t.Setenv("BRAIN_SPEED_CPU_TASKS", "24")
	t.Setenv("BRAIN_SPEED_GPU_TASKS", "6")
	cfg, err := Load()
	if err != nil {
		t.Fatal(err)
	}
	if !cfg.SpeedMode || cfg.SpeedCPUWorkers != 24 || cfg.SpeedGPUInflight != 6 {
		t.Fatalf("unexpected speed settings: enabled=%v cpu=%d gpu=%d", cfg.SpeedMode, cfg.SpeedCPUWorkers, cfg.SpeedGPUInflight)
	}
}

func TestLoadRejectsInvalidSpeedLimits(t *testing.T) {
	t.Setenv("BRAIN_DATA_DIR", t.TempDir())
	t.Setenv("BRAIN_SPEED_CPU_TASKS", "257")
	if _, err := Load(); err == nil {
		t.Fatal("expected invalid speed CPU limit")
	}
}