WHOOSH/internal/server/server.go

package server

import (
	"bytes"
	"context"
	"database/sql"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/chorus-services/whoosh/internal/agents"
	"github.com/chorus-services/whoosh/internal/auth"
	"github.com/chorus-services/whoosh/internal/backbeat"
	"github.com/chorus-services/whoosh/internal/composer"
	"github.com/chorus-services/whoosh/internal/config"
	"github.com/chorus-services/whoosh/internal/council"
	"github.com/chorus-services/whoosh/internal/database"
	"github.com/chorus-services/whoosh/internal/gitea"
	"github.com/chorus-services/whoosh/internal/monitor"
	"github.com/chorus-services/whoosh/internal/orchestrator"
	"github.com/chorus-services/whoosh/internal/p2p"
	"github.com/chorus-services/whoosh/internal/tasks"
	"github.com/chorus-services/whoosh/internal/tracing"
	"github.com/chorus-services/whoosh/internal/validation"
	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/go-chi/cors"
	"github.com/go-chi/render"
	"github.com/google/uuid"
	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgconn"
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
	"go.opentelemetry.io/otel/attribute"
)

// Global version variable set by main package
var version = "development"

var ucxlIdentSanitizer = regexp.MustCompile(`[^A-Za-z0-9_.-]`)

func sanitizeUCXLIdentifier(input string) string {
	lowered := strings.ToLower(input)
	return ucxlIdentSanitizer.ReplaceAllString(lowered, "-")
}

func truncateString(input string, limit int) string {
	if limit <= 0 || len(input) <= limit {
		return input
	}
	if limit <= 3 {
		return input[:limit]
	}
	return input[:limit-3] + "..."
}

// SetVersion sets the global version variable
func SetVersion(v string) {
	version = v
}

type Server struct {
	config            *config.Config
	db                *database.DB
	httpServer        *http.Server
	router            chi.Router
	giteaClient       *gitea.Client
	webhookHandler    *gitea.WebhookHandler
	authMiddleware    *auth.Middleware
	rateLimiter       *auth.RateLimiter
	p2pDiscovery      *p2p.Discovery
	p2pBroadcaster    *p2p.Broadcaster
	agentRegistry     *agents.Registry
	backbeat          *backbeat.Integration
	teamComposer      *composer.Service
	councilComposer   *council.CouncilComposer
	taskService       *tasks.Service
	giteaIntegration  *tasks.GiteaIntegration
	repoMonitor       *monitor.Monitor
	swarmManager      *orchestrator.SwarmManager
	agentDeployer     *orchestrator.AgentDeployer
	scalingController *orchestrator.ScalingController
	healthGates       *orchestrator.HealthGates
	assignmentBroker  *orchestrator.AssignmentBroker
	bootstrapManager  *orchestrator.BootstrapPoolManager
	metricsCollector  *orchestrator.ScalingMetricsCollector
	scalingAPI        *orchestrator.ScalingAPI
	validator         *validation.Validator
	constraintMu      sync.Mutex
	rebroadcastMu     sync.Mutex
    activeBroadcasts  map[uuid.UUID]context.CancelFunc
    roleProfiles      map[string]RoleProfile
    startTime         time.Time
}

func NewServer(cfg *config.Config, db *database.DB) (*Server, error) {
	// Initialize core services
	taskService := tasks.NewService(db.Pool)
	giteaIntegration := tasks.NewGiteaIntegration(taskService, gitea.NewClient(cfg.GITEA), nil)

	// Initialize P2P discovery and agent registry
	p2pDiscovery := p2p.NewDiscovery()
	p2pBroadcaster := p2p.NewBroadcaster(p2pDiscovery)
	agentRegistry := agents.NewRegistry(db.Pool, p2pDiscovery)

	// Initialize team composer
	teamComposer := composer.NewService(db.Pool, nil) // Use default config

	// Initialize council composer for project kickoffs
	councilComposer := council.NewCouncilComposer(db.Pool)

	// Initialize Docker Swarm orchestrator services conditionally
	var swarmManager *orchestrator.SwarmManager
	var agentDeployer *orchestrator.AgentDeployer
	var scalingController *orchestrator.ScalingController
	var healthGates *orchestrator.HealthGates
	var assignmentBroker *orchestrator.AssignmentBroker
	var bootstrapManager *orchestrator.BootstrapPoolManager
	var metricsCollector *orchestrator.ScalingMetricsCollector
	var scalingAPI *orchestrator.ScalingAPI

	if cfg.Docker.Enabled {
		var err error
		swarmManager, err = orchestrator.NewSwarmManager("", "registry.home.deepblack.cloud")
		if err != nil {
			return nil, fmt.Errorf("failed to create swarm manager: %w", err)
		}

		agentDeployer = orchestrator.NewAgentDeployer(swarmManager, db.Pool, "registry.home.deepblack.cloud")

		// Initialize scaling system components
		log.Info().Msg("🌊 Initializing wave-based scaling system")

		// Initialize health gates for scaling decisions
		healthGates = orchestrator.NewHealthGates(
			"http://localhost:8081", // KACHING URL - will be configurable
			"http://localhost:8082", // BACKBEAT URL - will be configurable
			"http://localhost:8080", // Self for CHORUS health
		)

		// Initialize bootstrap pool manager
		bootstrapConfig := orchestrator.BootstrapPoolConfig{
			MinPoolSize:         5,
			MaxPoolSize:         30,
			HealthCheckInterval: 2 * time.Minute,
			StaleThreshold:      10 * time.Minute,
			PreferredRoles:      []string{"admin", "coordinator", "stable"},
		}
		bootstrapManager = orchestrator.NewBootstrapPoolManager(bootstrapConfig)

		// Initialize assignment broker
		assignmentBroker = orchestrator.NewAssignmentBroker(bootstrapManager)

		// Initialize metrics collector
		metricsCollector = orchestrator.NewScalingMetricsCollector(1000) // Keep 1000 operations

		// Initialize scaling controller
		scalingController = orchestrator.NewScalingController(
			swarmManager,
			healthGates,
			assignmentBroker,
			bootstrapManager,
			metricsCollector,
		)

		// Initialize scaling API
		scalingAPI = orchestrator.NewScalingAPI(scalingController, metricsCollector)

		log.Info().Msg("✅ Wave-based scaling system initialized")
	} else {
		log.Warn().Msg("🐳 Docker integration disabled - scaling system and council agent deployment unavailable")
	}

	// Initialize repository monitor with team composer, council composer, and agent deployer
	repoMonitor := monitor.NewMonitor(db.Pool, cfg.GITEA, teamComposer, councilComposer, agentDeployer)

	s := &Server{
		config:            cfg,
		db:                db,
		giteaClient:       gitea.NewClient(cfg.GITEA),
		webhookHandler:    gitea.NewWebhookHandler(cfg.GITEA.WebhookToken),
		authMiddleware:    auth.NewMiddleware(cfg.Auth.JWTSecret, cfg.Auth.ServiceTokens),
		rateLimiter:       auth.NewRateLimiter(100, time.Minute),
		p2pDiscovery:      p2pDiscovery,
		p2pBroadcaster:    p2pBroadcaster,
		agentRegistry:     agentRegistry,
		teamComposer:      teamComposer,
		councilComposer:   councilComposer,
		taskService:       taskService,
		giteaIntegration:  giteaIntegration,
		repoMonitor:       repoMonitor,
		swarmManager:      swarmManager,
		agentDeployer:     agentDeployer,
		scalingController: scalingController,
		healthGates:       healthGates,
		assignmentBroker:  assignmentBroker,
		bootstrapManager:  bootstrapManager,
		metricsCollector:  metricsCollector,
		scalingAPI:        scalingAPI,
		validator:         validation.NewValidator(),
		roleProfiles:      defaultRoleProfiles(),
	}
    s.activeBroadcasts = make(map[uuid.UUID]context.CancelFunc)
    s.startTime = time.Now()

	// Initialize BACKBEAT integration if enabled
	if cfg.BACKBEAT.Enabled {
		backbeatIntegration, err := backbeat.NewIntegration(&cfg.BACKBEAT)
		if err != nil {
			return nil, fmt.Errorf("failed to create BACKBEAT integration: %w", err)
		}
		s.backbeat = backbeatIntegration
	}

	s.setupRouter()
	s.setupRoutes()

	s.httpServer = &http.Server{
		Addr:         cfg.Server.ListenAddr,
		Handler:      s.router,
		ReadTimeout:  cfg.Server.ReadTimeout,
		WriteTimeout: cfg.Server.WriteTimeout,
	}

	return s, nil
}

func (s *Server) setupRouter() {
	r := chi.NewRouter()

	// Middleware
	r.Use(middleware.RequestID)
	r.Use(middleware.RealIP)
	r.Use(middleware.Logger)
	r.Use(middleware.Recoverer)
	r.Use(middleware.Timeout(30 * time.Second))
	r.Use(validation.SecurityHeaders)
	r.Use(s.rateLimiter.RateLimitMiddleware)

	// CORS configuration - restrict origins to configured values
	r.Use(cors.Handler(cors.Options{
		AllowedOrigins:   s.config.Server.AllowedOrigins,
		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token", "X-Gitea-Signature"},
		ExposedHeaders:   []string{"Link"},
		AllowCredentials: true,
		MaxAge:           300,
	}))

	// Content-Type handling
	r.Use(render.SetContentType(render.ContentTypeJSON))

	s.router = r
}

func (s *Server) setupRoutes() {
    // Static file serving for UI assets
    uiDir := resolveUIDir()
    log.Info().Str("ui_dir", uiDir).Msg("📦 WHOOSH serving UI static files")
    s.router.Handle("/ui/*", http.StripPrefix("/ui/", http.FileServer(http.Dir(uiDir))))

    // Root-path static files to avoid '/ui' prefix in URLs
    s.router.Get("/styles.css", func(w http.ResponseWriter, r *http.Request) {
        http.ServeFile(w, r, filepath.Join(resolveUIDir(), "styles.css"))
    })
    s.router.Get("/script.js", func(w http.ResponseWriter, r *http.Request) {
        http.ServeFile(w, r, filepath.Join(resolveUIDir(), "script.js"))
    })
    // Optional: serve assets at root as well
    s.router.Handle("/assets/*", http.StripPrefix("/", http.FileServer(http.Dir(resolveUIDir()))))

	// Root route - serve basic dashboard
	s.router.Get("/", s.dashboardHandler)

	// Health check endpoints
	s.router.Get("/health", s.healthHandler)
	s.router.Get("/health/ready", s.readinessHandler)
    // Metrics endpoint (Prometheus text format)
    s.router.Get("/metrics", s.metricsHandler)

	// Back-compat alias for admin health details under /api
	// Some UIs or external monitors may call /api/admin/health/details
	// even though the canonical route is /admin/health/details
	s.router.Get("/api/admin/health/details", s.healthDetailsHandler)

	// Admin health endpoint with detailed information
	s.router.Get("/admin/health/details", s.healthDetailsHandler)

	// API v1 routes
	s.router.Route("/api/v1", func(r chi.Router) {
		// MVP endpoints - minimal team management
		r.Route("/teams", func(r chi.Router) {
			r.Get("/", s.listTeamsHandler)
			r.With(s.authMiddleware.AdminRequired).Post("/", s.createTeamHandler)
			r.Get("/{teamID}", s.getTeamHandler)
			r.With(s.authMiddleware.AdminRequired).Put("/{teamID}/status", s.updateTeamStatusHandler)
			r.Post("/analyze", s.analyzeTeamCompositionHandler)
		})

		// Task ingestion from GITEA
		r.Route("/tasks", func(r chi.Router) {
			r.Get("/", s.listTasksHandler)
			r.With(s.authMiddleware.ServiceTokenRequired).Post("/ingest", s.ingestTaskHandler)
			r.Get("/{taskID}", s.getTaskHandler)
		})

		// Project management endpoints
		r.Route("/projects", func(r chi.Router) {
			r.Get("/", s.listProjectsHandler)
			r.Post("/", s.createProjectHandler)

			r.Route("/{projectID}", func(r chi.Router) {
				r.Get("/", s.getProjectHandler)
				r.Delete("/", s.deleteProjectHandler)
				r.Get("/tasks", s.listProjectTasksHandler)
				r.Get("/tasks/available", s.listAvailableTasksHandler)
				r.Get("/repository", s.getProjectRepositoryHandler)
				r.Post("/analyze", s.analyzeProjectHandler)

				r.Route("/tasks/{taskNumber}", func(r chi.Router) {
					r.Get("/", s.getProjectTaskHandler)
					r.Post("/claim", s.claimTaskHandler)
					r.Put("/status", s.updateTaskStatusHandler)
					r.Post("/complete", s.completeTaskHandler)
				})
			})
		})

		// Agent registration endpoints
		r.Route("/agents", func(r chi.Router) {
			r.Get("/", s.listAgentsHandler)
			r.Post("/register", s.registerAgentHandler)
			r.Put("/{agentID}/status", s.updateAgentStatusHandler)
		})

		// SLURP proxy endpoints
		r.Route("/slurp", func(r chi.Router) {
			r.Post("/submit", s.slurpSubmitHandler)
			r.Get("/artifacts/{ucxlAddr}", s.slurpRetrieveHandler)
		})

		// Repository monitoring endpoints
		r.Route("/repositories", func(r chi.Router) {
			r.Get("/", s.listRepositoriesHandler)
			r.With(s.authMiddleware.AdminRequired).Post("/", s.createRepositoryHandler)
			r.Get("/{repoID}", s.getRepositoryHandler)
			r.With(s.authMiddleware.AdminRequired).Put("/{repoID}", s.updateRepositoryHandler)
			r.With(s.authMiddleware.AdminRequired).Delete("/{repoID}", s.deleteRepositoryHandler)
			r.With(s.authMiddleware.AdminRequired).Post("/{repoID}/sync", s.syncRepositoryHandler)
			r.With(s.authMiddleware.AdminRequired).Post("/{repoID}/ensure-labels", s.ensureRepositoryLabelsHandler)
			r.Get("/{repoID}/logs", s.getRepositorySyncLogsHandler)
		})

		// Council management endpoints
		r.Route("/councils", func(r chi.Router) {
			r.Get("/", s.listCouncilsHandler)
			r.Get("/{councilID}", s.getCouncilHandler)

			r.Route("/{councilID}/artifacts", func(r chi.Router) {
				r.Get("/", s.getCouncilArtifactsHandler)
				r.With(s.authMiddleware.AdminRequired).Post("/", s.createCouncilArtifactHandler)
			})

			// Agent role claiming endpoint
			r.Post("/{councilID}/claims", s.handleCouncilRoleClaim)

			// Persona status acknowledgment from CHORUS agents
			r.Post("/{councilID}/roles/{roleName}/personas", s.handleCouncilPersonaAck)
		})

		// Scaling system endpoints
		if s.scalingAPI != nil {
			log.Info().Msg("🌊 Registering wave-based scaling API routes")
			s.scalingAPI.RegisterRoutes(r)
		}

		// Assignment broker endpoints (if Docker enabled)
		if s.assignmentBroker != nil {
			r.Route("/assignments", func(r chi.Router) {
				s.assignmentBroker.RegisterRoutes(r)
			})
		}

		// BACKBEAT monitoring endpoints
		r.Route("/backbeat", func(r chi.Router) {
			r.Get("/status", s.backbeatStatusHandler)
		})
	})

	// GITEA webhook endpoint
	s.router.Post(s.config.GITEA.WebhookPath, s.giteaWebhookHandler)
}

func (s *Server) Start(ctx context.Context) error {
	// Start BACKBEAT integration if enabled
	if s.backbeat != nil {
		if err := s.backbeat.Start(ctx); err != nil {
			return fmt.Errorf("failed to start BACKBEAT integration: %w", err)
		}
	}

	// Start bootstrap pool manager if available
	if s.bootstrapManager != nil {
		log.Info().Msg("🔄 Starting bootstrap pool manager")
		go s.bootstrapManager.Start(ctx)
	}

	// Start P2P discovery service
	if err := s.p2pDiscovery.Start(); err != nil {
		return fmt.Errorf("failed to start P2P discovery: %w", err)
	}

	// Start agent registry service
	if err := s.agentRegistry.Start(); err != nil {
		return fmt.Errorf("failed to start agent registry: %w", err)
	}

	// Start repository monitoring service
	if s.repoMonitor != nil {
		go func() {
			if err := s.repoMonitor.Start(ctx); err != nil && err != context.Canceled {
				log.Error().Err(err).Msg("Repository monitoring service failed")
			}
		}()
		log.Info().Msg("🔍 Repository monitoring service started")
	}

	log.Info().
		Str("addr", s.httpServer.Addr).
		Msg("HTTP server starting")

	if err := s.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		return fmt.Errorf("server failed to start: %w", err)
	}

	return nil
}

func (s *Server) Shutdown(ctx context.Context) error {
	log.Info().Msg("HTTP server shutting down")

	// Stop BACKBEAT integration
	if s.backbeat != nil {
		if err := s.backbeat.Stop(); err != nil {
			log.Error().Err(err).Msg("Failed to stop BACKBEAT integration")
		}
	}

	// Stop agent registry service
	if err := s.agentRegistry.Stop(); err != nil {
		log.Error().Err(err).Msg("Failed to stop agent registry service")
	}

	// Stop P2P discovery service
	if err := s.p2pDiscovery.Stop(); err != nil {
		log.Error().Err(err).Msg("Failed to stop P2P discovery service")
	}

	// Stop repository monitoring service
	if s.repoMonitor != nil {
		s.repoMonitor.Stop()
		log.Info().Msg("🛑 Repository monitoring service stopped")
	}

	// Stop scaling controller and related services
	if s.scalingController != nil {
		if err := s.scalingController.Close(); err != nil {
			log.Error().Err(err).Msg("Failed to stop scaling controller")
		} else {
			log.Info().Msg("🌊 Wave-based scaling controller stopped")
		}
	}

	if err := s.httpServer.Shutdown(ctx); err != nil {
		return fmt.Errorf("server shutdown failed: %w", err)
	}

	return nil
}

// Health check handlers
func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) {
	response := map[string]interface{}{
		"status":  "ok",
		"service": "whoosh",
		"version": "0.1.0-mvp",
	}

	// Include BACKBEAT health information if available
	if s.backbeat != nil {
		response["backbeat"] = s.backbeat.GetHealth()
	}

	render.JSON(w, r, response)
}

func (s *Server) readinessHandler(w http.ResponseWriter, r *http.Request) {
	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
	defer cancel()

	// Check database connection
	if err := s.db.Health(ctx); err != nil {
		log.Error().Err(err).Msg("Database health check failed")
		render.Status(r, http.StatusServiceUnavailable)
		render.JSON(w, r, map[string]string{
			"status": "unavailable",
			"error":  "database connection failed",
		})
		return
	}

	render.JSON(w, r, map[string]string{
		"status":   "ready",
		"database": "connected",
	})
}

// metricsHandler exposes a minimal Prometheus text format so the UI
// dashboard can render metrics and external scrapers can poll it.
func (s *Server) metricsHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/plain; version=0.0.4; charset=utf-8")

    uptime := time.Since(s.startTime).Seconds()

    ctx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond)
    defer cancel()
    dbHealthy := 0
    if err := s.db.Health(ctx); err == nil {
        dbHealthy = 1
    }

    var buf bytes.Buffer
    // Service info
    fmt.Fprintf(&buf, "# HELP whoosh_info Service information.\n")
    fmt.Fprintf(&buf, "# TYPE whoosh_info gauge\n")
    fmt.Fprintf(&buf, "whoosh_info{version=\"%s\"} 1\n", version)

    // Uptime
    fmt.Fprintf(&buf, "# HELP whoosh_uptime_seconds Uptime of the WHOOSH server.\n")
    fmt.Fprintf(&buf, "# TYPE whoosh_uptime_seconds counter\n")
    fmt.Fprintf(&buf, "whoosh_uptime_seconds %.0f\n", uptime)

    // Database health
    fmt.Fprintf(&buf, "# HELP whoosh_database_healthy Database health status (1=healthy,0=unhealthy).\n")
    fmt.Fprintf(&buf, "# TYPE whoosh_database_healthy gauge\n")
    fmt.Fprintf(&buf, "whoosh_database_healthy %d\n", dbHealthy)

    _, _ = w.Write(buf.Bytes())
}

// healthDetailsHandler provides comprehensive system health information
func (s *Server) healthDetailsHandler(w http.ResponseWriter, r *http.Request) {
	ctx, span := tracing.StartSpan(r.Context(), "health_check_details")
	defer span.End()

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

    response := map[string]interface{}{
        "service":    "whoosh",
        "version":    version,
        "timestamp":  time.Now().Unix(),
        "uptime":     time.Since(s.startTime).Seconds(),
        "status":     "healthy",
        "components": make(map[string]interface{}),
    }

	overallHealthy := true
	components := make(map[string]interface{})

	// Database Health Check
	dbHealth := map[string]interface{}{
		"name": "database",
		"type": "postgresql",
	}

	if err := s.db.Health(ctx); err != nil {
		dbHealth["status"] = "unhealthy"
		dbHealth["error"] = err.Error()
		dbHealth["last_checked"] = time.Now().Unix()
		overallHealthy = false
		span.SetAttributes(attribute.Bool("health.database.healthy", false))
	} else {
		dbHealth["status"] = "healthy"
		dbHealth["last_checked"] = time.Now().Unix()

		// Get database statistics
		var dbStats map[string]interface{}
		if stats := s.db.Pool.Stat(); stats != nil {
			dbStats = map[string]interface{}{
				"max_conns":          stats.MaxConns(),
				"acquired_conns":     stats.AcquiredConns(),
				"idle_conns":         stats.IdleConns(),
				"constructing_conns": stats.ConstructingConns(),
			}
		}
		dbHealth["statistics"] = dbStats
		span.SetAttributes(attribute.Bool("health.database.healthy", true))
	}
	components["database"] = dbHealth

	// Gitea Health Check
	giteaHealth := map[string]interface{}{
		"name": "gitea",
		"type": "external_service",
	}

	if s.giteaClient != nil {
		if err := s.giteaClient.TestConnection(ctx); err != nil {
			giteaHealth["status"] = "unhealthy"
			giteaHealth["error"] = err.Error()
			giteaHealth["endpoint"] = s.config.GITEA.BaseURL
			overallHealthy = false
			span.SetAttributes(attribute.Bool("health.gitea.healthy", false))
		} else {
			giteaHealth["status"] = "healthy"
			giteaHealth["endpoint"] = s.config.GITEA.BaseURL
			giteaHealth["webhook_path"] = s.config.GITEA.WebhookPath
			span.SetAttributes(attribute.Bool("health.gitea.healthy", true))
		}
	} else {
		giteaHealth["status"] = "not_configured"
		span.SetAttributes(attribute.Bool("health.gitea.healthy", false))
	}
	giteaHealth["last_checked"] = time.Now().Unix()
	components["gitea"] = giteaHealth

	// BackBeat Health Check
	backbeatHealth := map[string]interface{}{
		"name": "backbeat",
		"type": "internal_service",
	}

	if s.backbeat != nil {
		bbHealth := s.backbeat.GetHealth()
		if connected, ok := bbHealth["connected"].(bool); ok && connected {
			backbeatHealth["status"] = "healthy"
			backbeatHealth["details"] = bbHealth
			span.SetAttributes(attribute.Bool("health.backbeat.healthy", true))
		} else {
			backbeatHealth["status"] = "unhealthy"
			backbeatHealth["details"] = bbHealth
			backbeatHealth["error"] = "not connected to NATS cluster"
			overallHealthy = false
			span.SetAttributes(attribute.Bool("health.backbeat.healthy", false))
		}
	} else {
		backbeatHealth["status"] = "not_configured"
		span.SetAttributes(attribute.Bool("health.backbeat.healthy", false))
	}
	backbeatHealth["last_checked"] = time.Now().Unix()
	components["backbeat"] = backbeatHealth

	// Docker Swarm Health Check (if enabled)
	swarmHealth := map[string]interface{}{
		"name": "docker_swarm",
		"type": "orchestration",
	}

	if s.config.Docker.Enabled {
		// Basic Docker connection check - actual swarm health would need Docker client
		swarmHealth["status"] = "unknown"
		swarmHealth["note"] = "Docker integration enabled but health check not implemented"
		swarmHealth["socket_path"] = s.config.Docker.Host
	} else {
		swarmHealth["status"] = "disabled"
	}
	swarmHealth["last_checked"] = time.Now().Unix()
	components["docker_swarm"] = swarmHealth

	// Repository Monitor Health
	monitorHealth := map[string]interface{}{
		"name": "repository_monitor",
		"type": "internal_service",
	}

	if s.repoMonitor != nil {
		// Get repository monitoring statistics
		query := `SELECT 
			COUNT(*) as total_repos,
			COUNT(*) FILTER (WHERE sync_status = 'active') as active_repos,
			COUNT(*) FILTER (WHERE sync_status = 'error') as error_repos,
			COUNT(*) FILTER (WHERE monitor_issues = true) as monitored_repos
		FROM repositories`

		var totalRepos, activeRepos, errorRepos, monitoredRepos int
		err := s.db.Pool.QueryRow(ctx, query).Scan(&totalRepos, &activeRepos, &errorRepos, &monitoredRepos)

		if err != nil {
			monitorHealth["status"] = "unhealthy"
			monitorHealth["error"] = err.Error()
			overallHealthy = false
		} else {
			monitorHealth["status"] = "healthy"
			monitorHealth["statistics"] = map[string]interface{}{
				"total_repositories":     totalRepos,
				"active_repositories":    activeRepos,
				"error_repositories":     errorRepos,
				"monitored_repositories": monitoredRepos,
			}
		}
		span.SetAttributes(attribute.Bool("health.repository_monitor.healthy", err == nil))
	} else {
		monitorHealth["status"] = "not_configured"
		span.SetAttributes(attribute.Bool("health.repository_monitor.healthy", false))
	}
	monitorHealth["last_checked"] = time.Now().Unix()
	components["repository_monitor"] = monitorHealth

	// Overall system status
	if !overallHealthy {
		response["status"] = "unhealthy"
		span.SetAttributes(
			attribute.String("health.overall_status", "unhealthy"),
			attribute.Bool("health.overall_healthy", false),
		)
	} else {
		span.SetAttributes(
			attribute.String("health.overall_status", "healthy"),
			attribute.Bool("health.overall_healthy", true),
		)
	}

	response["components"] = components
	response["healthy"] = overallHealthy

	// Set appropriate HTTP status
	if !overallHealthy {
		render.Status(r, http.StatusServiceUnavailable)
	}

	render.JSON(w, r, response)
}

// MVP handlers for team and task management
func (s *Server) listTeamsHandler(w http.ResponseWriter, r *http.Request) {
	// Parse pagination parameters
	limitStr := r.URL.Query().Get("limit")
	offsetStr := r.URL.Query().Get("offset")

	limit := 20 // Default limit
	offset := 0 // Default offset

	if limitStr != "" {
		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {
			limit = l
		}
	}

	if offsetStr != "" {
		if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
			offset = o
		}
	}

	// Get teams from database
	teams, total, err := s.teamComposer.ListTeams(r.Context(), limit, offset)
	if err != nil {
		log.Error().Err(err).Msg("Failed to list teams")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to retrieve teams"})
		return
	}

	render.JSON(w, r, map[string]interface{}{
		"teams":  teams,
		"total":  total,
		"limit":  limit,
		"offset": offset,
	})
}

func (s *Server) createTeamHandler(w http.ResponseWriter, r *http.Request) {
	var taskInput composer.TaskAnalysisInput

	if err := json.NewDecoder(r.Body).Decode(&taskInput); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	// Validate required fields
	if taskInput.Title == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "title is required"})
		return
	}

	if taskInput.Description == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "description is required"})
		return
	}

	// Set defaults if not provided
	if taskInput.Priority == "" {
		taskInput.Priority = composer.PriorityMedium
	}

	log.Info().
		Str("task_title", taskInput.Title).
		Str("priority", string(taskInput.Priority)).
		Msg("Starting team composition for new task")

	// Analyze task and compose team
	result, err := s.teamComposer.AnalyzeAndComposeTeam(r.Context(), &taskInput)
	if err != nil {
		log.Error().Err(err).Msg("Team composition failed")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "team composition failed"})
		return
	}

	// Create the team in database
	team, err := s.teamComposer.CreateTeam(r.Context(), result.TeamComposition, &taskInput)
	if err != nil {
		log.Error().Err(err).Msg("Failed to create team")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to create team"})
		return
	}

	log.Info().
		Str("team_id", team.ID.String()).
		Str("team_name", team.Name).
		Float64("confidence_score", result.TeamComposition.ConfidenceScore).
		Msg("Team created successfully")

	// Return both the team and the composition analysis
	response := map[string]interface{}{
		"team":               team,
		"composition_result": result,
		"message":            "Team created successfully",
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, response)
}

func (s *Server) getTeamHandler(w http.ResponseWriter, r *http.Request) {
	teamIDStr := chi.URLParam(r, "teamID")
	teamID, err := uuid.Parse(teamIDStr)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid team ID"})
		return
	}

	team, assignments, err := s.teamComposer.GetTeam(r.Context(), teamID)
	if err != nil {
		if err.Error() == "team not found" {
			render.Status(r, http.StatusNotFound)
			render.JSON(w, r, map[string]string{"error": "team not found"})
			return
		}

		log.Error().Err(err).Str("team_id", teamIDStr).Msg("Failed to get team")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to retrieve team"})
		return
	}

	response := map[string]interface{}{
		"team":        team,
		"assignments": assignments,
	}

	render.JSON(w, r, response)
}

func (s *Server) updateTeamStatusHandler(w http.ResponseWriter, r *http.Request) {
	teamIDStr := chi.URLParam(r, "teamID")
	teamID, err := uuid.Parse(teamIDStr)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid team ID"})
		return
	}

	var statusUpdate struct {
		Status string `json:"status"`
		Reason string `json:"reason,omitempty"`
	}

	if err := json.NewDecoder(r.Body).Decode(&statusUpdate); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	// Validate status values
	validStatuses := map[string]bool{
		"forming":   true,
		"active":    true,
		"completed": true,
		"disbanded": true,
	}

	if !validStatuses[statusUpdate.Status] {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid status. Valid values: forming, active, completed, disbanded"})
		return
	}

	// Update team status in database
	updateQuery := `UPDATE teams SET status = $1, updated_at = $2 WHERE id = $3`

	if statusUpdate.Status == "completed" {
		updateQuery = `UPDATE teams SET status = $1, updated_at = $2, completed_at = $2 WHERE id = $3`
	}

	_, err = s.db.Pool.Exec(r.Context(), updateQuery, statusUpdate.Status, time.Now(), teamID)
	if err != nil {
		log.Error().Err(err).
			Str("team_id", teamIDStr).
			Str("status", statusUpdate.Status).
			Msg("Failed to update team status")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to update team status"})
		return
	}

	log.Info().
		Str("team_id", teamIDStr).
		Str("status", statusUpdate.Status).
		Str("reason", statusUpdate.Reason).
		Msg("Team status updated")

	render.JSON(w, r, map[string]interface{}{
		"team_id": teamIDStr,
		"status":  statusUpdate.Status,
		"message": "Team status updated successfully",
	})
}

func (s *Server) analyzeTeamCompositionHandler(w http.ResponseWriter, r *http.Request) {
	var taskInput composer.TaskAnalysisInput

	if err := json.NewDecoder(r.Body).Decode(&taskInput); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	// Validate required fields
	if taskInput.Title == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "title is required"})
		return
	}

	if taskInput.Description == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "description is required"})
		return
	}

	// Set defaults if not provided
	if taskInput.Priority == "" {
		taskInput.Priority = composer.PriorityMedium
	}

	log.Info().
		Str("task_title", taskInput.Title).
		Str("priority", string(taskInput.Priority)).
		Msg("Analyzing team composition requirements")

	// Analyze task and compose team (without creating it)
	result, err := s.teamComposer.AnalyzeAndComposeTeam(r.Context(), &taskInput)
	if err != nil {
		log.Error().Err(err).Msg("Team composition analysis failed")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "team composition analysis failed"})
		return
	}

	log.Info().
		Str("analysis_id", result.AnalysisID.String()).
		Float64("confidence_score", result.TeamComposition.ConfidenceScore).
		Int("recommended_team_size", result.TeamComposition.EstimatedSize).
		Msg("Team composition analysis completed")

	render.JSON(w, r, result)
}

func (s *Server) listTasksHandler(w http.ResponseWriter, r *http.Request) {
	// Parse query parameters
	statusParam := r.URL.Query().Get("status")
	priorityParam := r.URL.Query().Get("priority")
	repositoryParam := r.URL.Query().Get("repository")
	limitStr := r.URL.Query().Get("limit")
	offsetStr := r.URL.Query().Get("offset")

	// Build filter
	filter := &tasks.TaskFilter{}

	if statusParam != "" && statusParam != "all" {
		filter.Status = []tasks.TaskStatus{tasks.TaskStatus(statusParam)}
	}

	if priorityParam != "" {
		filter.Priority = []tasks.TaskPriority{tasks.TaskPriority(priorityParam)}
	}

	if repositoryParam != "" {
		filter.Repository = repositoryParam
	}

	if limitStr != "" {
		if limit, err := strconv.Atoi(limitStr); err == nil && limit > 0 && limit <= 100 {
			filter.Limit = limit
		}
	}

	if offsetStr != "" {
		if offset, err := strconv.Atoi(offsetStr); err == nil && offset >= 0 {
			filter.Offset = offset
		}
	}

	// Get tasks from database
	taskList, total, err := s.taskService.ListTasks(r.Context(), filter)
	if err != nil {
		log.Error().Err(err).Msg("Failed to list tasks")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to retrieve tasks"})
		return
	}

	render.JSON(w, r, map[string]interface{}{
		"tasks":  taskList,
		"total":  total,
		"filter": filter,
	})
}

func (s *Server) ingestTaskHandler(w http.ResponseWriter, r *http.Request) {
	var taskData struct {
		Title       string   `json:"title"`
		Description string   `json:"description"`
		Repository  string   `json:"repository"`
		IssueURL    string   `json:"issue_url,omitempty"`
		Priority    string   `json:"priority,omitempty"`
		Labels      []string `json:"labels,omitempty"`
		Source      string   `json:"source,omitempty"` // "manual", "gitea", "webhook"
	}

	if err := json.NewDecoder(r.Body).Decode(&taskData); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	// Validate required fields
	if taskData.Title == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "title is required"})
		return
	}

	if taskData.Description == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "description is required"})
		return
	}

	// Set defaults
	if taskData.Priority == "" {
		taskData.Priority = "medium"
	}

	if taskData.Source == "" {
		taskData.Source = "manual"
	}

	// Create task ID
	taskID := uuid.New().String()

	log.Info().
		Str("task_id", taskID).
		Str("title", taskData.Title).
		Str("repository", taskData.Repository).
		Str("source", taskData.Source).
		Msg("Ingesting new task")

	// For MVP, we'll create the task record and attempt team composition
	// In production, this would persist to a tasks table and queue for processing

	// Create task in database first
	createInput := &tasks.CreateTaskInput{
		ExternalID:  taskID, // Use generated ID as external ID for manual tasks
		ExternalURL: taskData.IssueURL,
		SourceType:  tasks.SourceType(taskData.Source),
		Title:       taskData.Title,
		Description: taskData.Description,
		Priority:    tasks.TaskPriority(taskData.Priority),
		Repository:  taskData.Repository,
		Labels:      taskData.Labels,
	}

	createdTask, err := s.taskService.CreateTask(r.Context(), createInput)
	if err != nil {
		log.Error().Err(err).Str("task_id", taskID).Msg("Failed to create task")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to create task"})
		return
	}

	// Convert to TaskAnalysisInput for team composition
	taskInput := &composer.TaskAnalysisInput{
		Title:        createdTask.Title,
		Description:  createdTask.Description,
		Repository:   createdTask.Repository,
		Requirements: createdTask.Requirements,
		Priority:     composer.TaskPriority(createdTask.Priority),
		TechStack:    createdTask.TechStack,
		Metadata: map[string]interface{}{
			"task_id":   createdTask.ID.String(),
			"source":    taskData.Source,
			"issue_url": taskData.IssueURL,
			"labels":    createdTask.Labels,
		},
	}

	// Start team composition analysis in background for complex tasks
	// For simple tasks, we can process synchronously
	isComplex := len(taskData.Description) > 200 ||
		len(taskData.Labels) > 3 ||
		taskData.Priority == "high" ||
		taskData.Priority == "critical"

	if isComplex {
		// For complex tasks, start async team composition
		go s.processTaskAsync(taskID, taskInput)

		// Return immediate response
		render.Status(r, http.StatusAccepted)
		render.JSON(w, r, map[string]interface{}{
			"task_id": taskID,
			"status":  "queued",
			"message": "Task queued for team composition analysis",
		})
	} else {
		// For simple tasks, process synchronously
		result, err := s.teamComposer.AnalyzeAndComposeTeam(r.Context(), taskInput)
		if err != nil {
			log.Error().Err(err).Str("task_id", taskID).Msg("Task analysis failed")
			render.Status(r, http.StatusInternalServerError)
			render.JSON(w, r, map[string]string{"error": "task analysis failed"})
			return
		}

		// Create the team
		team, err := s.teamComposer.CreateTeam(r.Context(), result.TeamComposition, taskInput)
		if err != nil {
			log.Error().Err(err).Str("task_id", taskID).Msg("Team creation failed")
			render.Status(r, http.StatusInternalServerError)
			render.JSON(w, r, map[string]string{"error": "team creation failed"})
			return
		}

		log.Info().
			Str("task_id", taskID).
			Str("team_id", team.ID.String()).
			Msg("Task ingested and team created")

		render.Status(r, http.StatusCreated)
		render.JSON(w, r, map[string]interface{}{
			"task_id":            taskID,
			"team":               team,
			"composition_result": result,
			"status":             "completed",
			"message":            "Task ingested and team created successfully",
		})
	}
}

func (s *Server) getTaskHandler(w http.ResponseWriter, r *http.Request) {
	taskIDStr := chi.URLParam(r, "taskID")
	taskID, err := uuid.Parse(taskIDStr)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid task ID format"})
		return
	}

	// Get task from database
	task, err := s.taskService.GetTask(r.Context(), taskID)
	if err != nil {
		if strings.Contains(err.Error(), "not found") {
			render.Status(r, http.StatusNotFound)
			render.JSON(w, r, map[string]string{"error": "task not found"})
			return
		}

		log.Error().Err(err).Str("task_id", taskIDStr).Msg("Failed to get task")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to retrieve task"})
		return
	}

	render.JSON(w, r, map[string]interface{}{
		"task": task,
	})
}

func (s *Server) slurpSubmitHandler(w http.ResponseWriter, r *http.Request) {
	// Parse the submission request
	var submission struct {
		TeamID       string                 `json:"team_id"`
		ArtifactType string                 `json:"artifact_type"`
		Content      map[string]interface{} `json:"content"`
		Metadata     map[string]interface{} `json:"metadata,omitempty"`
	}

	if err := json.NewDecoder(r.Body).Decode(&submission); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	// Validate required fields
	if submission.TeamID == "" || submission.ArtifactType == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "team_id and artifact_type are required"})
		return
	}

	// Generate UCXL address for the submission
	ucxlAddr := fmt.Sprintf("ucxl://%s/%s/%d",
		submission.TeamID,
		submission.ArtifactType,
		time.Now().Unix())

	// For MVP, we'll store basic metadata in the database
	// In production, this would proxy to actual SLURP service
	teamUUID, err := uuid.Parse(submission.TeamID)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid team_id format"})
		return
	}

	// Store submission record
	submissionID := uuid.New()
	metadataJSON, _ := json.Marshal(submission.Metadata)

	insertQuery := `
		INSERT INTO slurp_submissions (id, team_id, ucxl_address, artifact_type, metadata, submitted_at, status)
		VALUES ($1, $2, $3, $4, $5, $6, $7)
	`

	_, err = s.db.Pool.Exec(r.Context(), insertQuery,
		submissionID, teamUUID, ucxlAddr, submission.ArtifactType,
		metadataJSON, time.Now(), "submitted")

	if err != nil {
		log.Error().Err(err).
			Str("team_id", submission.TeamID).
			Str("artifact_type", submission.ArtifactType).
			Msg("Failed to store SLURP submission")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to store submission"})
		return
	}

	log.Info().
		Str("team_id", submission.TeamID).
		Str("artifact_type", submission.ArtifactType).
		Str("ucxl_address", ucxlAddr).
		Msg("SLURP submission stored")

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, map[string]interface{}{
		"submission_id": submissionID,
		"ucxl_address":  ucxlAddr,
		"status":        "submitted",
		"message":       "Artifact submitted to SLURP successfully (MVP mode)",
	})
}

func (s *Server) slurpRetrieveHandler(w http.ResponseWriter, r *http.Request) {
	ucxlAddress := r.URL.Query().Get("ucxl_address")
	if ucxlAddress == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "ucxl_address query parameter is required"})
		return
	}

	log.Info().
		Str("ucxl_address", ucxlAddress).
		Msg("Retrieving SLURP submission")

	// Query the submission from database
	query := `
		SELECT id, team_id, ucxl_address, artifact_type, metadata, submitted_at, status
		FROM slurp_submissions 
		WHERE ucxl_address = $1
	`

	row := s.db.Pool.QueryRow(r.Context(), query, ucxlAddress)

	var (
		id            uuid.UUID
		teamID        uuid.UUID
		retrievedAddr string
		artifactType  string
		metadataJSON  []byte
		submittedAt   time.Time
		status        string
	)

	err := row.Scan(&id, &teamID, &retrievedAddr, &artifactType, &metadataJSON, &submittedAt, &status)
	if err != nil {
		if err.Error() == "no rows in result set" {
			render.Status(r, http.StatusNotFound)
			render.JSON(w, r, map[string]string{"error": "SLURP submission not found"})
			return
		}

		log.Error().Err(err).
			Str("ucxl_address", ucxlAddress).
			Msg("Failed to retrieve SLURP submission")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to retrieve submission"})
		return
	}

	// Parse metadata
	var metadata map[string]interface{}
	if len(metadataJSON) > 0 {
		json.Unmarshal(metadataJSON, &metadata)
	}

	submission := map[string]interface{}{
		"id":            id,
		"team_id":       teamID,
		"ucxl_address":  retrievedAddr,
		"artifact_type": artifactType,
		"metadata":      metadata,
		"submitted_at":  submittedAt.Format(time.RFC3339),
		"status":        status,
	}

	// For MVP, we return the metadata. In production, this would
	// proxy to SLURP service to retrieve actual artifact content
	render.JSON(w, r, map[string]interface{}{
		"submission": submission,
		"message":    "SLURP submission retrieved (MVP mode - metadata only)",
	})
}

// CHORUS Integration Handlers

func (s *Server) listProjectTasksHandler(w http.ResponseWriter, r *http.Request) {
	projectID := chi.URLParam(r, "projectID")

	log.Info().
		Str("project_id", projectID).
		Msg("Listing tasks for project")

	// For MVP, return mock tasks associated with the project
	// In production, this would query actual tasks from database
	tasks := []map[string]interface{}{
		{
			"id":            "task-001",
			"project_id":    projectID,
			"title":         "Setup project infrastructure",
			"description":   "Initialize Docker, CI/CD, and database setup",
			"status":        "completed",
			"priority":      "high",
			"assigned_team": nil,
			"created_at":    time.Now().Add(-48 * time.Hour).Format(time.RFC3339),
			"completed_at":  time.Now().Add(-12 * time.Hour).Format(time.RFC3339),
		},
		{
			"id":            "task-002",
			"project_id":    projectID,
			"title":         "Implement authentication system",
			"description":   "JWT-based authentication with user management",
			"status":        "active",
			"priority":      "high",
			"assigned_team": "team-001",
			"created_at":    time.Now().Add(-24 * time.Hour).Format(time.RFC3339),
			"updated_at":    time.Now().Add(-2 * time.Hour).Format(time.RFC3339),
		},
		{
			"id":            "task-003",
			"project_id":    projectID,
			"title":         "Create API documentation",
			"description":   "OpenAPI/Swagger documentation for all endpoints",
			"status":        "queued",
			"priority":      "medium",
			"assigned_team": nil,
			"created_at":    time.Now().Add(-6 * time.Hour).Format(time.RFC3339),
		},
	}

	render.JSON(w, r, map[string]interface{}{
		"project_id": projectID,
		"tasks":      tasks,
		"total":      len(tasks),
		"message":    "Project tasks retrieved (MVP mock data)",
	})
}

func (s *Server) listAvailableTasksHandler(w http.ResponseWriter, r *http.Request) {
	// Get query parameters for filtering
	skillFilter := r.URL.Query().Get("skills")
	priorityFilter := r.URL.Query().Get("priority")

	log.Info().
		Str("skill_filter", skillFilter).
		Str("priority_filter", priorityFilter).
		Msg("Listing available tasks")

	// For MVP, return mock available tasks that agents can claim
	// In production, this would query unassigned tasks from database
	availableTasks := []map[string]interface{}{
		{
			"id":              "task-004",
			"title":           "Fix memory leak in user service",
			"description":     "Investigate and fix memory leak causing high memory usage",
			"status":          "available",
			"priority":        "high",
			"skills_required": []string{"go", "debugging", "performance"},
			"estimated_hours": 8,
			"repository":      "example/user-service",
			"created_at":      time.Now().Add(-3 * time.Hour).Format(time.RFC3339),
		},
		{
			"id":              "task-005",
			"title":           "Add rate limiting to API",
			"description":     "Implement rate limiting middleware for API endpoints",
			"status":          "available",
			"priority":        "medium",
			"skills_required": []string{"go", "middleware", "api"},
			"estimated_hours": 4,
			"repository":      "example/api-gateway",
			"created_at":      time.Now().Add(-1 * time.Hour).Format(time.RFC3339),
		},
		{
			"id":              "task-006",
			"title":           "Update React components",
			"description":     "Migrate legacy class components to functional components",
			"status":          "available",
			"priority":        "low",
			"skills_required": []string{"react", "javascript", "frontend"},
			"estimated_hours": 12,
			"repository":      "example/web-ui",
			"created_at":      time.Now().Add(-30 * time.Minute).Format(time.RFC3339),
		},
	}

	// Apply filtering if specified
	filteredTasks := availableTasks

	if priorityFilter != "" {
		filtered := []map[string]interface{}{}
		for _, task := range availableTasks {
			if task["priority"] == priorityFilter {
				filtered = append(filtered, task)
			}
		}
		filteredTasks = filtered
	}

	render.JSON(w, r, map[string]interface{}{
		"available_tasks": filteredTasks,
		"total":           len(filteredTasks),
		"filters": map[string]string{
			"skills":   skillFilter,
			"priority": priorityFilter,
		},
		"message": "Available tasks retrieved (MVP mock data)",
	})
}

func (s *Server) getProjectRepositoryHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) getProjectTaskHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) claimTaskHandler(w http.ResponseWriter, r *http.Request) {
	taskIDStr := chi.URLParam(r, "taskID")
	taskID, err := uuid.Parse(taskIDStr)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid task ID format"})
		return
	}

	var claimData struct {
		TeamID  string `json:"team_id"`
		AgentID string `json:"agent_id,omitempty"`
		Reason  string `json:"reason,omitempty"`
	}

	if err := json.NewDecoder(r.Body).Decode(&claimData); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	if claimData.TeamID == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "team_id is required"})
		return
	}

	// Validate team exists
	teamUUID, err := uuid.Parse(claimData.TeamID)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid team_id format"})
		return
	}

	// Check if team exists
	_, _, err = s.teamComposer.GetTeam(r.Context(), teamUUID)
	if err != nil {
		if strings.Contains(err.Error(), "not found") {
			render.Status(r, http.StatusNotFound)
			render.JSON(w, r, map[string]string{"error": "team not found"})
			return
		}

		log.Error().Err(err).Str("team_id", claimData.TeamID).Msg("Failed to validate team")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to validate team"})
		return
	}

	// Parse agent ID if provided
	var agentUUID *uuid.UUID
	if claimData.AgentID != "" {
		agentID, err := uuid.Parse(claimData.AgentID)
		if err != nil {
			render.Status(r, http.StatusBadRequest)
			render.JSON(w, r, map[string]string{"error": "invalid agent_id format"})
			return
		}
		agentUUID = &agentID
	}

	// Assign task to team/agent
	assignment := &tasks.TaskAssignment{
		TaskID:  taskID,
		TeamID:  &teamUUID,
		AgentID: agentUUID,
		Reason:  claimData.Reason,
	}

	err = s.taskService.AssignTask(r.Context(), assignment)
	if err != nil {
		log.Error().Err(err).Str("task_id", taskIDStr).Msg("Failed to assign task")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to assign task"})
		return
	}

	log.Info().
		Str("task_id", taskIDStr).
		Str("team_id", claimData.TeamID).
		Str("agent_id", claimData.AgentID).
		Msg("Task assigned to team")

	render.JSON(w, r, map[string]interface{}{
		"task_id":    taskIDStr,
		"team_id":    claimData.TeamID,
		"agent_id":   claimData.AgentID,
		"status":     "claimed",
		"claimed_at": time.Now().Format(time.RFC3339),
		"message":    "Task assigned successfully",
	})
}

func (s *Server) updateTaskStatusHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) completeTaskHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) listAgentsHandler(w http.ResponseWriter, r *http.Request) {
	// Get discovered CHORUS agents from P2P discovery
	discoveredAgents := s.p2pDiscovery.GetAgents()

	// Convert to API format
	agents := make([]map[string]interface{}, 0, len(discoveredAgents))
	onlineCount := 0
	idleCount := 0
	offlineCount := 0

	for _, agent := range discoveredAgents {
		agentData := map[string]interface{}{
			"id":              agent.ID,
			"name":            agent.Name,
			"status":          agent.Status,
			"capabilities":    agent.Capabilities,
			"model":           agent.Model,
			"endpoint":        agent.Endpoint,
			"last_seen":       agent.LastSeen.Format(time.RFC3339),
			"tasks_completed": agent.TasksCompleted,
			"p2p_addr":        agent.P2PAddr,
			"cluster_id":      agent.ClusterID,
		}

		// Add current team if present
		if agent.CurrentTeam != "" {
			agentData["current_team"] = agent.CurrentTeam
		} else {
			agentData["current_team"] = nil
		}

		agents = append(agents, agentData)

		// Count status
		switch agent.Status {
		case "online":
			onlineCount++
		case "idle":
			idleCount++
		case "working":
			onlineCount++ // Working agents are considered online
		default:
			offlineCount++
		}
	}

	render.JSON(w, r, map[string]interface{}{
		"agents":  agents,
		"total":   len(agents),
		"online":  onlineCount,
		"idle":    idleCount,
		"offline": offlineCount,
	})
}

func (s *Server) registerAgentHandler(w http.ResponseWriter, r *http.Request) {
	var agentData struct {
		Name         string                 `json:"name"`
		EndpointURL  string                 `json:"endpoint_url"`
		Capabilities map[string]interface{} `json:"capabilities"`
	}

	if err := json.NewDecoder(r.Body).Decode(&agentData); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	// Validate required fields
	if agentData.Name == "" || agentData.EndpointURL == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "name and endpoint_url are required"})
		return
	}

	// Create agent record
	agent := &composer.Agent{
		ID:                 uuid.New(),
		Name:               agentData.Name,
		EndpointURL:        agentData.EndpointURL,
		Capabilities:       agentData.Capabilities,
		Status:             composer.AgentStatusAvailable,
		LastSeen:           time.Now(),
		PerformanceMetrics: make(map[string]interface{}),
		CreatedAt:          time.Now(),
		UpdatedAt:          time.Now(),
	}

	// Initialize empty capabilities if none provided
	if agent.Capabilities == nil {
		agent.Capabilities = make(map[string]interface{})
	}

	// Insert into database
	capabilitiesJSON, _ := json.Marshal(agent.Capabilities)
	metricsJSON, _ := json.Marshal(agent.PerformanceMetrics)

	query := `
		INSERT INTO agents (id, name, endpoint_url, capabilities, status, last_seen, performance_metrics, created_at, updated_at)
		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
	`

	_, err := s.db.Pool.Exec(r.Context(), query,
		agent.ID, agent.Name, agent.EndpointURL, capabilitiesJSON,
		agent.Status, agent.LastSeen, metricsJSON,
		agent.CreatedAt, agent.UpdatedAt)

	if err != nil {
		log.Error().Err(err).Str("agent_name", agent.Name).Msg("Failed to register agent")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to register agent"})
		return
	}

	log.Info().
		Str("agent_id", agent.ID.String()).
		Str("agent_name", agent.Name).
		Str("endpoint", agent.EndpointURL).
		Msg("Agent registered successfully")

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, map[string]interface{}{
		"agent":   agent,
		"message": "Agent registered successfully",
	})
}

func (s *Server) updateAgentStatusHandler(w http.ResponseWriter, r *http.Request) {
	agentIDStr := chi.URLParam(r, "agentID")
	agentID, err := uuid.Parse(agentIDStr)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid agent ID"})
		return
	}

	var statusUpdate struct {
		Status             string                 `json:"status"`
		PerformanceMetrics map[string]interface{} `json:"performance_metrics,omitempty"`
		Reason             string                 `json:"reason,omitempty"`
	}

	if err := json.NewDecoder(r.Body).Decode(&statusUpdate); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	// Validate status values
	validStatuses := map[string]bool{
		"available": true,
		"busy":      true,
		"idle":      true,
		"offline":   true,
	}

	if !validStatuses[statusUpdate.Status] {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid status. Valid values: available, busy, idle, offline"})
		return
	}

	// Update agent status and last_seen timestamp
	updateQuery := `
		UPDATE agents 
		SET status = $1, last_seen = $2, updated_at = $2
		WHERE id = $3
	`

	_, err = s.db.Pool.Exec(r.Context(), updateQuery, statusUpdate.Status, time.Now(), agentID)
	if err != nil {
		log.Error().Err(err).
			Str("agent_id", agentIDStr).
			Str("status", statusUpdate.Status).
			Msg("Failed to update agent status")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to update agent status"})
		return
	}

	// Update performance metrics if provided
	if statusUpdate.PerformanceMetrics != nil {
		metricsJSON, _ := json.Marshal(statusUpdate.PerformanceMetrics)
		_, err = s.db.Pool.Exec(r.Context(),
			`UPDATE agents SET performance_metrics = $1 WHERE id = $2`,
			metricsJSON, agentID)

		if err != nil {
			log.Warn().Err(err).
				Str("agent_id", agentIDStr).
				Msg("Failed to update agent performance metrics")
		}
	}

	log.Info().
		Str("agent_id", agentIDStr).
		Str("status", statusUpdate.Status).
		Str("reason", statusUpdate.Reason).
		Msg("Agent status updated")

	render.JSON(w, r, map[string]interface{}{
		"agent_id": agentIDStr,
		"status":   statusUpdate.Status,
		"message":  "Agent status updated successfully",
	})
}

// Project Management Handlers

func (s *Server) listProjectsHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	// Query councils table (which stores project data)
	rows, err := s.db.Pool.Query(ctx, `
		SELECT id, project_name, repository, project_brief, status, created_at, metadata
		FROM councils
		ORDER BY created_at DESC
	`)
	if err != nil {
		log.Error().Err(err).Msg("Failed to query councils")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to fetch projects"})
		return
	}
	defer rows.Close()

	projects := []map[string]interface{}{}
	for rows.Next() {
		var id string
		var name, repo, description, status string
		var createdAt time.Time
		var metadata []byte

		if err := rows.Scan(&id, &name, &repo, &description, &status, &createdAt, &metadata); err != nil {
			log.Error().Err(err).Msg("Failed to scan council row")
			continue
		}

		project := map[string]interface{}{
			"id":          id,
			"name":        name,
			"repo_url":    repo,
			"description": description,
			"status":      status,
			"created_at":  createdAt.Format(time.RFC3339),
		}

		// Parse metadata if available
		if metadata != nil {
			var meta map[string]interface{}
			if err := json.Unmarshal(metadata, &meta); err == nil {
				if lang, ok := meta["language"].(string); ok {
					project["language"] = lang
				}
				if owner, ok := meta["owner"].(string); ok {
					project["owner"] = owner
				}
			}
		}

		projects = append(projects, project)
	}

	render.JSON(w, r, map[string]interface{}{
		"projects": projects,
		"total":    len(projects),
	})
}

// createProjectHandler handles POST /api/projects requests to add new GITEA repositories
// for team composition analysis. This is the core MVP functionality that allows users
// to register repositories that will be analyzed by the N8N workflow.
//
// Implementation decision: We use an anonymous struct for the request payload rather than
// a named struct because this is a simple, internal API that doesn't need to be shared
// across packages. This reduces complexity while maintaining type safety.
//
// TODO: In production, this would persist to PostgreSQL database rather than just
// returning in-memory data. The database integration is prepared in the docker-compose
// but not yet implemented in the handlers.
func (s *Server) createProjectHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	// Parse request - now only requires repository_url
	var reqData struct {
		RepositoryURL string `json:"repository_url"`
	}

	if err := s.validator.DecodeAndValidateJSON(r, &reqData); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid JSON payload"})
		return
	}

	// Validate repository URL
	if reqData.RepositoryURL == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "repository_url is required"})
		return
	}

	// Parse repository URL to extract owner and repo name
	// Expected format: https://gitea.chorus.services/owner/repo
	repoURL := validation.SanitizeString(reqData.RepositoryURL)
	parts := strings.Split(strings.TrimSuffix(repoURL, ".git"), "/")
	if len(parts) < 2 {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid repository URL format"})
		return
	}

	repoName := parts[len(parts)-1]
	owner := parts[len(parts)-2]

	// Fetch repository metadata from GITEA
	log.Info().
		Str("owner", owner).
		Str("repo", repoName).
		Msg("Fetching repository metadata from GITEA")

	repo, err := s.giteaClient.GetRepository(ctx, owner, repoName)
	if err != nil {
		log.Error().
			Err(err).
			Str("owner", owner).
			Str("repo", repoName).
			Msg("Failed to fetch repository from GITEA")
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": fmt.Sprintf("failed to fetch repository: %v", err)})
		return
	}

	log.Info().
		Str("repo_url", repoURL).
		Str("title", repo.Name).
		Str("description", repo.Description).
		Msg("Creating new council from GITEA repository")

	// Prepare metadata with owner and language info
	metadata := map[string]interface{}{
		"owner":    repo.Owner.Login,
		"language": repo.Language,
	}

	// Create council formation request
	formationRequest := &council.CouncilFormationRequest{
		ProjectName:  repo.Name,
		Repository:   repoURL,
		ProjectBrief: repo.Description,
		Metadata:     metadata,
	}

	log.Info().
		Str("project", repo.Name).
		Msg("🎭 Triggering council formation workflow")

	// Form council (this creates the council record and agents)
	composition, err := s.councilComposer.FormCouncil(ctx, formationRequest)
	if err != nil {
		log.Error().
			Err(err).
			Str("project", repo.Name).
			Msg("Failed to form council")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": fmt.Sprintf("failed to form council: %v", err)})
		return
	}

	log.Info().
		Str("council_id", composition.CouncilID.String()).
		Str("project", repo.Name).
		Msg("✅ Council formation completed successfully")

	// Broadcast council opportunity to CHORUS agents via P2P
	go func() {
		broadcastCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cancel()

		// Prepare council roles for broadcasting
		coreRoles := make([]p2p.CouncilRole, len(composition.CoreAgents))
		for i, agent := range composition.CoreAgents {
			coreRoles[i] = p2p.CouncilRole{
				RoleName:    agent.RoleName,
				AgentName:   agent.AgentName,
				Required:    agent.Required,
				Description: fmt.Sprintf("Core council role: %s", agent.AgentName),
			}
		}

		optionalRoles := make([]p2p.CouncilRole, len(composition.OptionalAgents))
		for i, agent := range composition.OptionalAgents {
			optionalRoles[i] = p2p.CouncilRole{
				RoleName:    agent.RoleName,
				AgentName:   agent.AgentName,
				Required:    agent.Required,
				Description: fmt.Sprintf("Optional council role: %s", agent.AgentName),
			}
		}

		// Create opportunity broadcast
		opportunity := &p2p.CouncilOpportunity{
			CouncilID:         composition.CouncilID,
			ProjectName:       repo.Name,
			Repository:        repoURL,
			ProjectBrief:      repo.Description,
			CoreRoles:         coreRoles,
			OptionalRoles:     optionalRoles,
			UCXLAddress:       fmt.Sprintf("ucxl://team:council@project:%s:council/councils/%s", sanitizeUCXLIdentifier(repo.Name), composition.CouncilID.String()),
			FormationDeadline: time.Now().Add(24 * time.Hour), // 24 hours to form council
			CreatedAt:         composition.CreatedAt,
			Metadata:          metadata,
		}

		// Broadcast to all CHORUS agents
		err := s.p2pBroadcaster.BroadcastCouncilOpportunity(broadcastCtx, opportunity)
		if err != nil {
			log.Error().
				Err(err).
				Str("council_id", composition.CouncilID.String()).
				Msg("Failed to broadcast council opportunity to CHORUS agents")
		} else {
			log.Info().
				Str("council_id", composition.CouncilID.String()).
				Int("core_roles", len(coreRoles)).
				Int("optional_roles", len(optionalRoles)).
				Msg("📡 Successfully broadcast council opportunity to CHORUS agents")

			s.startCouncilRebroadcastMonitor(opportunity)
		}
	}()

	// Create response project object
	project := map[string]interface{}{
		"id":          composition.CouncilID.String(),
		"name":        repo.Name,
		"repo_url":    repoURL,
		"description": repo.Description,
		"owner":       repo.Owner.Login,
		"language":    repo.Language,
		"status":      "forming",
		"created_at":  time.Now().Format(time.RFC3339),
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, project)
}

// deleteProjectHandler handles DELETE /api/projects/{projectID} requests to remove
// repositories from management. This allows users to clean up their project list
// and stop monitoring repositories that are no longer relevant.
//
// Implementation decision: We use chi.URLParam to extract the project ID from the
// URL path rather than query parameters, following REST conventions where the
// resource identifier is part of the path structure.
func (s *Server) deleteProjectHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	// Extract project ID from URL path parameter
	projectID := chi.URLParam(r, "projectID")

	// Parse UUID
	councilID, err := uuid.Parse(projectID)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid project ID"})
		return
	}

	// Delete from councils table
	result, err := s.db.Pool.Exec(ctx, `
		DELETE FROM councils WHERE id = $1
	`, councilID)

	if err != nil {
		log.Error().
			Err(err).
			Str("council_id", councilID.String()).
			Msg("Failed to delete council from database")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to delete project"})
		return
	}

	// Check if council was found and deleted
	if result.RowsAffected() == 0 {
		render.Status(r, http.StatusNotFound)
		render.JSON(w, r, map[string]string{"error": "project not found"})
		return
	}

	log.Info().
		Str("council_id", councilID.String()).
		Msg("Deleted council")

	render.JSON(w, r, map[string]string{"message": "project deleted"})
}

// getProjectHandler handles GET /api/projects/{projectID} requests to retrieve
// detailed information about a specific project, including its analysis results
// and team formation recommendations from the N8N workflow.
func (s *Server) getProjectHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	projectID := chi.URLParam(r, "projectID")

	// Parse UUID
	councilID, err := uuid.Parse(projectID)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid project ID"})
		return
	}

	// Query councils table
	var id string
	var name, repo, description, status string
	var createdAt time.Time
	var metadata []byte

	err = s.db.Pool.QueryRow(ctx, `
		SELECT id, project_name, repository, project_brief, status, created_at, metadata
		FROM councils
		WHERE id = $1
	`, councilID).Scan(&id, &name, &repo, &description, &status, &createdAt, &metadata)

	if err != nil {
		if err == pgx.ErrNoRows {
			render.Status(r, http.StatusNotFound)
			render.JSON(w, r, map[string]string{"error": "project not found"})
			return
		}
		log.Error().Err(err).Str("council_id", councilID.String()).Msg("Failed to query council")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "internal server error"})
		return
	}

	// Build project response
	project := map[string]interface{}{
		"id":          id,
		"name":        name,
		"repo_url":    repo,
		"description": description,
		"status":      status,
		"created_at":  createdAt.Format(time.RFC3339),
	}

	// Parse metadata for additional fields
	if metadata != nil {
		var meta map[string]interface{}
		if err := json.Unmarshal(metadata, &meta); err == nil {
			if lang, ok := meta["language"].(string); ok {
				project["language"] = lang
			}
			if owner, ok := meta["owner"].(string); ok {
				project["owner"] = owner
			}
			if techStack, ok := meta["tech_stack"].([]interface{}); ok {
				project["tech_stack"] = techStack
			}
			if teamSize, ok := meta["team_size"].(float64); ok {
				project["team_size"] = int(teamSize)
			}
		}
	}

	render.JSON(w, r, project)
}

// analyzeProjectHandler handles POST /api/projects/{projectID}/analyze requests to
// trigger the N8N Team Formation Analysis workflow. This is the core integration point
// that connects WHOOSH to the AI-powered repository analysis system.
//
// Implementation decisions:
// 1. 60-second timeout for N8N requests because LLM analysis can be slow
// 2. Direct HTTP client rather than a service layer for simplicity in MVP
// 3. Graceful fallback to mock data when request body is empty
// 4. Comprehensive error handling with structured logging for debugging
//
// This handler represents the "missing link" that was identified as the core need:
// WHOOSH UI → N8N workflow → LLM analysis → team formation recommendations
func (s *Server) analyzeProjectHandler(w http.ResponseWriter, r *http.Request) {
	projectID := chi.URLParam(r, "projectID")

	// Project data structure for N8N payload. In production, this would be fetched
	// from the database using the projectID, but for MVP we allow it to be provided
	// in the request body or fall back to predictable mock data.
	var projectData struct {
		RepoURL string `json:"repo_url"`
		Name    string `json:"name"`
	}

	// Handle both scenarios: explicit project data in request body (for testing)
	// and implicit data fetching (for production UI). This flexibility makes the
	// API easier to test manually while supporting the intended UI workflow.
	if r.Body != http.NoBody {
		if err := json.NewDecoder(r.Body).Decode(&projectData); err != nil {
			// Try to fetch from database first, fallback to mock data if not found
			if err := s.lookupProjectData(r.Context(), projectID, &projectData); err != nil {
				// Fallback to predictable mock data based on projectID for testing
				projectData.RepoURL = "https://gitea.chorus.services/tony/" + projectID
				projectData.Name = projectID
			}
		}
	} else {
		// No body provided - try database lookup first, fallback to mock data
		if err := s.lookupProjectData(r.Context(), projectID, &projectData); err != nil {
			// Fallback to mock data if database lookup fails
			projectData.RepoURL = "https://gitea.chorus.services/tony/" + projectID
			projectData.Name = projectID
		}
	}

	// Start BACKBEAT search tracking if available
	searchID := fmt.Sprintf("analyze-%s", projectID)
	if s.backbeat != nil {
		if err := s.backbeat.StartSearch(searchID, fmt.Sprintf("Analyzing project %s (%s)", projectID, projectData.RepoURL), 4); err != nil {
			log.Warn().Err(err).Msg("Failed to start BACKBEAT search tracking")
		}
	}

	// Log the analysis initiation for debugging and audit trails. Repository URL
	// is crucial for troubleshooting N8N workflow issues.
	log.Info().
		Str("project_id", projectID).
		Str("repo_url", projectData.RepoURL).
		Msg("🔍 Starting project analysis via N8N workflow with BACKBEAT tracking")

	// Execute analysis within BACKBEAT beat budget (4 beats = 2 minutes at 2 BPM)
	var analysisResult map[string]interface{}
	analysisFunc := func() error {
		// Update BACKBEAT phase to querying
		if s.backbeat != nil {
			s.backbeat.UpdateSearchPhase(searchID, backbeat.PhaseQuerying, 0)
		}

		// HTTP client with generous timeout because:
		// 1. N8N workflow fetches multiple files from repository
		// 2. LLM analysis (Ollama) can take 10-30 seconds depending on model size
		// 3. Network latency between services in Docker Swarm
		// 60 seconds provides buffer while still failing fast for real issues
		client := &http.Client{Timeout: 60 * time.Second}

		// Payload structure matches the N8N workflow webhook expectations.
		// The workflow expects these exact field names to properly route data
		// through the file fetching and analysis nodes.
		payload := map[string]interface{}{
			"repo_url":     projectData.RepoURL, // Primary input for file fetching
			"project_name": projectData.Name,    // Used in LLM analysis context
		}

		// JSON marshaling without error checking is acceptable here because we control
		// the payload structure and know it will always be valid JSON.
		payloadBytes, _ := json.Marshal(payload)

		// Call to configurable N8N instance for team formation workflow
		// The webhook URL is constructed from the base URL in configuration
		n8nWebhookURL := s.config.N8N.BaseURL + "/webhook/team-formation"
		resp, err := client.Post(
			n8nWebhookURL,
			"application/json",
			bytes.NewBuffer(payloadBytes),
		)

		// Network-level error handling (connection refused, timeout, DNS issues)
		if err != nil {
			log.Error().Err(err).Msg("Failed to trigger N8N workflow")
			return fmt.Errorf("failed to trigger N8N workflow: %w", err)
		}
		defer resp.Body.Close()

		// HTTP-level error handling (N8N returned an error status)
		if resp.StatusCode != http.StatusOK {
			log.Error().
				Int("status", resp.StatusCode).
				Msg("N8N workflow returned error")
			return fmt.Errorf("N8N workflow returned status %d", resp.StatusCode)
		}

		// Update BACKBEAT phase to ranking
		if s.backbeat != nil {
			s.backbeat.UpdateSearchPhase(searchID, backbeat.PhaseRanking, 0)
		}

		// Read the N8N workflow response, which contains the team formation analysis
		// results including detected technologies, complexity scores, and agent assignments.
		body, err := io.ReadAll(resp.Body)
		if err != nil {
			log.Error().Err(err).Msg("Failed to read N8N response")
			return fmt.Errorf("failed to read N8N response: %w", err)
		}

		// Parse and return N8N response
		if err := json.Unmarshal(body, &analysisResult); err != nil {
			log.Error().Err(err).Msg("Failed to parse N8N response")
			return fmt.Errorf("failed to parse N8N response: %w", err)
		}

		return nil
	}

	// Execute analysis with BACKBEAT beat budget or fallback to direct execution
	var analysisErr error
	if s.backbeat != nil {
		analysisErr = s.backbeat.ExecuteWithBeatBudget(4, analysisFunc)
		if analysisErr != nil {
			s.backbeat.FailSearch(searchID, analysisErr.Error())
		}
	} else {
		analysisErr = analysisFunc()
	}

	if analysisErr != nil {
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": analysisErr.Error()})
		return
	}

	// Complete BACKBEAT search tracking
	if s.backbeat != nil {
		s.backbeat.CompleteSearch(searchID, 1)
	}

	log.Info().
		Str("project_id", projectID).
		Msg("🔍 Project analysis completed successfully with BACKBEAT tracking")

	render.JSON(w, r, analysisResult)
}

func (s *Server) giteaWebhookHandler(w http.ResponseWriter, r *http.Request) {
	ctx, span := tracing.StartWebhookSpan(r.Context(), "gitea_webhook", "gitea")
	defer span.End()

	// Parse webhook payload
	payload, err := s.webhookHandler.ParsePayload(r)
	if err != nil {
		tracing.SetSpanError(span, err)
		log.Error().Err(err).Msg("Failed to parse webhook payload")
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid payload"})
		return
	}

	span.SetAttributes(
		attribute.String("webhook.action", payload.Action),
		attribute.String("webhook.repository", payload.Repository.FullName),
		attribute.String("webhook.sender", payload.Sender.Login),
	)

	log.Info().
		Str("action", payload.Action).
		Str("repository", payload.Repository.FullName).
		Str("sender", payload.Sender.Login).
		Msg("Received GITEA webhook")

	// Process webhook event
	event := s.webhookHandler.ProcessWebhook(payload)

	// Handle task-related webhooks
	if event.TaskInfo != nil {
		span.SetAttributes(
			attribute.Bool("webhook.has_task_info", true),
			attribute.String("webhook.task_type", event.TaskInfo["task_type"].(string)),
		)

		log.Info().
			Interface("task_info", event.TaskInfo).
			Msg("Processing task issue")

		// MVP: Store basic task info for future team assignment
		// In full implementation, this would trigger Team Composer
		s.handleTaskWebhook(ctx, event)
	} else {
		span.SetAttributes(attribute.Bool("webhook.has_task_info", false))
	}

	span.SetAttributes(
		attribute.String("webhook.status", "processed"),
		attribute.Int64("webhook.timestamp", event.Timestamp),
	)

	render.JSON(w, r, map[string]interface{}{
		"status":    "received",
		"event_id":  event.Timestamp,
		"processed": event.TaskInfo != nil,
	})
}

func (s *Server) handleTaskWebhook(ctx context.Context, event *gitea.WebhookEvent) {
	// MVP implementation: Log task details
	// In full version, this would:
	// 1. Analyze task complexity
	// 2. Determine required team composition
	// 3. Create team and assign agents
	// 4. Set up P2P communication channels

	log.Info().
		Str("action", event.Action).
		Str("repository", event.Repository).
		Interface("task_info", event.TaskInfo).
		Msg("Task webhook received - MVP logging")

	// For MVP, we'll just acknowledge task detection
	if event.Action == "opened" || event.Action == "reopened" {
		taskType := event.TaskInfo["task_type"].(string)
		priority := event.TaskInfo["priority"].(string)

		log.Info().
			Str("task_type", taskType).
			Str("priority", priority).
			Msg("New task detected - ready for team assignment")
	}
}

// staticFileHandler serves static files from the UI directory

func (s *Server) dashboardHandler(w http.ResponseWriter, r *http.Request) {
    // Serve the external index.html file
    uiDir := resolveUIDir()
    indexPath := filepath.Join(uiDir, "index.html")

	// Check if the UI directory and index.html exist
	if _, err := os.Stat(indexPath); os.IsNotExist(err) {
		// Fallback to embedded HTML if external files don't exist
		log.Warn().Msg("External UI files not found, using fallback message")
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		w.Write([]byte(`<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WHOOSH - Setup Required</title>
</head>
<body style="font-family: Arial, sans-serif; margin: 40px; background: #1a1a1a; color: #f0f0f0;">
    <h1>WHOOSH Setup Required</h1>
    <p>External UI files not found. Please ensure the ui/ directory is mounted and contains:</p>
    <ul>
        <li>index.html</li>
        <li>styles.css</li>
        <li>script.js</li>
    </ul>
    <p>Current working directory: ` + getCurrentDir() + `</p>
</body>
</html>`))
		return
	}

	// Serve the external index.html file
	http.ServeFile(w, r, indexPath)
}

// getCurrentDir returns the current working directory for debugging
func getCurrentDir() string {
    dir, err := os.Getwd()
    if err != nil {
        return "unknown"
    }
    return dir
}

// resolveUIDir determines the directory to serve the UI from.
// It uses WHOOSH_UI_DIR if set, otherwise falls back to ./ui.
func resolveUIDir() string {
    if v := strings.TrimSpace(os.Getenv("WHOOSH_UI_DIR")); v != "" {
        return v
    }
    return "./ui"
}

// backbeatStatusHandler provides real-time BACKBEAT pulse data
func (s *Server) backbeatStatusHandler(w http.ResponseWriter, r *http.Request) {
	now := time.Now()

	// Get real BACKBEAT data if integration is available and started
	if s.backbeat != nil {
		health := s.backbeat.GetHealth()

		// Extract real BACKBEAT data
		currentBeat := int64(0)
		if beatVal, ok := health["current_beat"]; ok {
			if beat, ok := beatVal.(int64); ok {
				currentBeat = beat
			}
		}

		currentTempo := 2 // Default fallback
		if tempoVal, ok := health["current_tempo"]; ok {
			if tempo, ok := tempoVal.(int); ok {
				currentTempo = tempo
			}
		}

		connected := false
		if connVal, ok := health["connected"]; ok {
			if conn, ok := connVal.(bool); ok {
				connected = conn
			}
		}

		// Determine phase based on BACKBEAT health
		phase := "normal"
		if degradationVal, ok := health["local_degradation"]; ok {
			if degraded, ok := degradationVal.(bool); ok && degraded {
				phase = "degraded"
			}
		}

		// Calculate average interval based on tempo (BPM to milliseconds)
		averageInterval := 60000 / currentTempo // Convert BPM to milliseconds between beats

		// Determine if current beat is a downbeat (every 4th beat)
		isDownbeat := currentBeat%4 == 1
		currentDownbeat := (currentBeat / 4) + 1

		response := map[string]interface{}{
			"current_beat":     currentBeat,
			"current_downbeat": currentDownbeat,
			"average_interval": averageInterval,
			"phase":            phase,
			"is_downbeat":      isDownbeat,
			"tempo":            currentTempo,
			"connected":        connected,
			"timestamp":        now.Unix(),
			"status":           "live",
			"backbeat_health":  health,
		}

		w.Header().Set("Content-Type", "application/json")
		if err := json.NewEncoder(w).Encode(response); err != nil {
			http.Error(w, "Failed to encode response", http.StatusInternalServerError)
			return
		}
		return
	}

	// Fallback to basic data if BACKBEAT integration is not available
	response := map[string]interface{}{
		"current_beat":     0,
		"current_downbeat": 0,
		"average_interval": 0,
		"phase":            "disconnected",
		"is_downbeat":      false,
		"tempo":            0,
		"connected":        false,
		"timestamp":        now.Unix(),
		"status":           "no_backbeat",
		"error":            "BACKBEAT integration not available",
	}

	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(response); err != nil {
		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
		return
	}
}

// Repository Management Handlers

// listRepositoriesHandler returns all monitored repositories
func (s *Server) listRepositoriesHandler(w http.ResponseWriter, r *http.Request) {
	log.Info().Msg("Listing monitored repositories")

	query := `
		SELECT id, name, owner, full_name, url, clone_url, ssh_url, source_type, 
		       monitor_issues, monitor_pull_requests, enable_chorus_integration,
		       description, default_branch, is_private, language, topics,
		       last_sync_at, sync_status, sync_error, open_issues_count, 
		       closed_issues_count, total_tasks_created, created_at, updated_at
		FROM repositories 
		ORDER BY created_at DESC`

	rows, err := s.db.Pool.Query(context.Background(), query)
	if err != nil {
		log.Error().Err(err).Msg("Failed to query repositories")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to query repositories"})
		return
	}
	defer rows.Close()

	repositories := []map[string]interface{}{}
	for rows.Next() {
		var id, name, owner, fullName, url, sourceType, defaultBranch, syncStatus string
		var cloneURL, sshURL, description, syncError, language *string
		var monitorIssues, monitorPRs, enableChorus, isPrivate bool
		var topicsJSON []byte
		var lastSyncAt *time.Time
		var createdAt, updatedAt time.Time
		var openIssues, closedIssues, totalTasks int

		err := rows.Scan(&id, &name, &owner, &fullName, &url, &cloneURL, &sshURL, &sourceType,
			&monitorIssues, &monitorPRs, &enableChorus, &description, &defaultBranch,
			&isPrivate, &language, &topicsJSON, &lastSyncAt, &syncStatus, &syncError,
			&openIssues, &closedIssues, &totalTasks, &createdAt, &updatedAt)
		if err != nil {
			log.Error().Err(err).Msg("Failed to scan repository row")
			continue
		}

		// Parse topics from JSONB
		var topics []string
		if err := json.Unmarshal(topicsJSON, &topics); err != nil {
			log.Error().Err(err).Msg("Failed to unmarshal topics")
			topics = []string{} // Default to empty slice
		}

		// Handle nullable lastSyncAt
		var lastSyncFormatted *string
		if lastSyncAt != nil {
			formatted := lastSyncAt.Format(time.RFC3339)
			lastSyncFormatted = &formatted
		}

		repo := map[string]interface{}{
			"id":                        id,
			"name":                      name,
			"owner":                     owner,
			"full_name":                 fullName,
			"url":                       url,
			"clone_url":                 cloneURL,
			"ssh_url":                   sshURL,
			"source_type":               sourceType,
			"monitor_issues":            monitorIssues,
			"monitor_pull_requests":     monitorPRs,
			"enable_chorus_integration": enableChorus,
			"description":               description,
			"default_branch":            defaultBranch,
			"is_private":                isPrivate,
			"language":                  language,
			"topics":                    topics,
			"last_sync_at":              lastSyncFormatted,
			"sync_status":               syncStatus,
			"sync_error":                syncError,
			"open_issues_count":         openIssues,
			"closed_issues_count":       closedIssues,
			"total_tasks_created":       totalTasks,
			"created_at":                createdAt.Format(time.RFC3339),
			"updated_at":                updatedAt.Format(time.RFC3339),
		}
		repositories = append(repositories, repo)
	}

	render.JSON(w, r, map[string]interface{}{
		"repositories": repositories,
		"count":        len(repositories),
	})
}

// createRepositoryHandler adds a new repository to monitor
func (s *Server) createRepositoryHandler(w http.ResponseWriter, r *http.Request) {
	var req struct {
		Name                    string   `json:"name"`
		Owner                   string   `json:"owner"`
		URL                     string   `json:"url"`
		SourceType              string   `json:"source_type"`
		MonitorIssues           bool     `json:"monitor_issues"`
		MonitorPullRequests     bool     `json:"monitor_pull_requests"`
		EnableChorusIntegration bool     `json:"enable_chorus_integration"`
		Description             *string  `json:"description"`
		DefaultBranch           string   `json:"default_branch"`
		IsPrivate               bool     `json:"is_private"`
		Language                *string  `json:"language"`
		Topics                  []string `json:"topics"`
	}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	// Validate required fields
	if req.Name == "" || req.Owner == "" || req.URL == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "name, owner, and url are required"})
		return
	}

	// Set defaults
	if req.SourceType == "" {
		req.SourceType = "gitea"
	}
	if req.DefaultBranch == "" {
		req.DefaultBranch = "main"
	}
	if req.Topics == nil {
		req.Topics = []string{}
	}

	fullName := req.Owner + "/" + req.Name

	log.Info().
		Str("repository", fullName).
		Str("url", req.URL).
		Msg("Creating new repository monitor")

	query := `
		INSERT INTO repositories (
			name, owner, full_name, url, source_type, monitor_issues, 
			monitor_pull_requests, enable_chorus_integration, description, 
			default_branch, is_private, language, topics
		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
		RETURNING id, created_at`

	// Convert topics slice to JSON for JSONB column
	topicsJSON, err := json.Marshal(req.Topics)
	if err != nil {
		log.Error().Err(err).Msg("Failed to marshal topics")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to process topics"})
		return
	}

	var id string
	var createdAt time.Time
	err = s.db.Pool.QueryRow(context.Background(), query,
		req.Name, req.Owner, fullName, req.URL, req.SourceType,
		req.MonitorIssues, req.MonitorPullRequests, req.EnableChorusIntegration,
		req.Description, req.DefaultBranch, req.IsPrivate, req.Language, topicsJSON).
		Scan(&id, &createdAt)

	if err != nil {
		log.Error().Err(err).Msg("Failed to create repository")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to create repository"})
		return
	}

	// Automatically create required labels in the Gitea repository
	// @goal: WHOOSH-LABELS-004 - Automatic label creation on repository addition
	// WHY: Ensures standardized ecosystem labels are available immediately for issue categorization
	if req.SourceType == "gitea" && s.repoMonitor != nil && s.repoMonitor.GetGiteaClient() != nil {
		log.Info().
			Str("repository", fullName).
			Msg("Creating required labels in Gitea repository")

		// @goal: WHOOSH-LABELS-004 - Apply standardized label set to new repository
		err := s.repoMonitor.GetGiteaClient().EnsureRequiredLabels(context.Background(), req.Owner, req.Name)
		if err != nil {
			log.Warn().
				Err(err).
				Str("repository", fullName).
				Msg("Failed to create labels in Gitea repository - repository monitoring will still work")
			// Don't fail the entire request if label creation fails
		} else {
			log.Info().
				Str("repository", fullName).
				Msg("Successfully created required labels in Gitea repository")
		}
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, map[string]interface{}{
		"id":         id,
		"full_name":  fullName,
		"created_at": createdAt.Format(time.RFC3339),
		"message":    "Repository monitor created successfully",
	})
}

// getRepositoryHandler returns a specific repository
func (s *Server) getRepositoryHandler(w http.ResponseWriter, r *http.Request) {
	repoID := chi.URLParam(r, "repoID")

	log.Info().Str("repository_id", repoID).Msg("Getting repository details")

	query := `
		SELECT id, name, owner, full_name, url, clone_url, ssh_url, source_type,
		       source_config, monitor_issues, monitor_pull_requests, monitor_releases,
		       enable_chorus_integration, chorus_task_labels, auto_assign_teams,
		       description, default_branch, is_private, language, topics,
		       last_sync_at, last_issue_sync, sync_status, sync_error,
		       open_issues_count, closed_issues_count, total_tasks_created,
		       created_at, updated_at
		FROM repositories WHERE id = $1`

	var repo struct {
		ID                      string     `json:"id"`
		Name                    string     `json:"name"`
		Owner                   string     `json:"owner"`
		FullName                string     `json:"full_name"`
		URL                     string     `json:"url"`
		CloneURL                *string    `json:"clone_url"`
		SSHURL                  *string    `json:"ssh_url"`
		SourceType              string     `json:"source_type"`
		SourceConfig            []byte     `json:"source_config"`
		MonitorIssues           bool       `json:"monitor_issues"`
		MonitorPullRequests     bool       `json:"monitor_pull_requests"`
		MonitorReleases         bool       `json:"monitor_releases"`
		EnableChorusIntegration bool       `json:"enable_chorus_integration"`
		ChorusTaskLabels        []string   `json:"chorus_task_labels"`
		AutoAssignTeams         bool       `json:"auto_assign_teams"`
		Description             *string    `json:"description"`
		DefaultBranch           string     `json:"default_branch"`
		IsPrivate               bool       `json:"is_private"`
		Language                *string    `json:"language"`
		Topics                  []string   `json:"topics"`
		LastSyncAt              *time.Time `json:"last_sync_at"`
		LastIssueSyncAt         *time.Time `json:"last_issue_sync"`
		SyncStatus              string     `json:"sync_status"`
		SyncError               *string    `json:"sync_error"`
		OpenIssuesCount         int        `json:"open_issues_count"`
		ClosedIssuesCount       int        `json:"closed_issues_count"`
		TotalTasksCreated       int        `json:"total_tasks_created"`
		CreatedAt               time.Time  `json:"created_at"`
		UpdatedAt               time.Time  `json:"updated_at"`
	}

	err := s.db.Pool.QueryRow(context.Background(), query, repoID).Scan(
		&repo.ID, &repo.Name, &repo.Owner, &repo.FullName, &repo.URL,
		&repo.CloneURL, &repo.SSHURL, &repo.SourceType, &repo.SourceConfig,
		&repo.MonitorIssues, &repo.MonitorPullRequests, &repo.MonitorReleases,
		&repo.EnableChorusIntegration, &repo.ChorusTaskLabels, &repo.AutoAssignTeams,
		&repo.Description, &repo.DefaultBranch, &repo.IsPrivate, &repo.Language,
		&repo.Topics, &repo.LastSyncAt, &repo.LastIssueSyncAt, &repo.SyncStatus,
		&repo.SyncError, &repo.OpenIssuesCount, &repo.ClosedIssuesCount,
		&repo.TotalTasksCreated, &repo.CreatedAt, &repo.UpdatedAt)

	if err != nil {
		if err.Error() == "no rows in result set" {
			render.Status(r, http.StatusNotFound)
			render.JSON(w, r, map[string]string{"error": "repository not found"})
			return
		}
		log.Error().Err(err).Msg("Failed to get repository")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to get repository"})
		return
	}

	render.JSON(w, r, repo)
}

// updateRepositoryHandler updates repository settings
func (s *Server) updateRepositoryHandler(w http.ResponseWriter, r *http.Request) {
	repoID := chi.URLParam(r, "repoID")

	var req struct {
		MonitorIssues           *bool    `json:"monitor_issues"`
		MonitorPullRequests     *bool    `json:"monitor_pull_requests"`
		MonitorReleases         *bool    `json:"monitor_releases"`
		EnableChorusIntegration *bool    `json:"enable_chorus_integration"`
		AutoAssignTeams         *bool    `json:"auto_assign_teams"`
		Description             *string  `json:"description"`
		DefaultBranch           *string  `json:"default_branch"`
		Language                *string  `json:"language"`
		Topics                  []string `json:"topics"`
	}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request body"})
		return
	}

	log.Info().Str("repository_id", repoID).Msg("Updating repository settings")

	// Build dynamic update query
	updates := []string{}
	args := []interface{}{repoID}
	argIndex := 2

	if req.MonitorIssues != nil {
		updates = append(updates, fmt.Sprintf("monitor_issues = $%d", argIndex))
		args = append(args, *req.MonitorIssues)
		argIndex++
	}
	if req.MonitorPullRequests != nil {
		updates = append(updates, fmt.Sprintf("monitor_pull_requests = $%d", argIndex))
		args = append(args, *req.MonitorPullRequests)
		argIndex++
	}
	if req.MonitorReleases != nil {
		updates = append(updates, fmt.Sprintf("monitor_releases = $%d", argIndex))
		args = append(args, *req.MonitorReleases)
		argIndex++
	}
	if req.EnableChorusIntegration != nil {
		updates = append(updates, fmt.Sprintf("enable_chorus_integration = $%d", argIndex))
		args = append(args, *req.EnableChorusIntegration)
		argIndex++
	}
	if req.AutoAssignTeams != nil {
		updates = append(updates, fmt.Sprintf("auto_assign_teams = $%d", argIndex))
		args = append(args, *req.AutoAssignTeams)
		argIndex++
	}
	if req.Description != nil {
		updates = append(updates, fmt.Sprintf("description = $%d", argIndex))
		args = append(args, *req.Description)
		argIndex++
	}
	if req.DefaultBranch != nil {
		updates = append(updates, fmt.Sprintf("default_branch = $%d", argIndex))
		args = append(args, *req.DefaultBranch)
		argIndex++
	}
	if req.Language != nil {
		updates = append(updates, fmt.Sprintf("language = $%d", argIndex))
		args = append(args, *req.Language)
		argIndex++
	}
	if req.Topics != nil {
		updates = append(updates, fmt.Sprintf("topics = $%d", argIndex))
		args = append(args, req.Topics)
		argIndex++
	}

	if len(updates) == 0 {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "no fields to update"})
		return
	}

	updates = append(updates, fmt.Sprintf("updated_at = $%d", argIndex))
	args = append(args, time.Now())

	query := fmt.Sprintf("UPDATE repositories SET %s WHERE id = $1", strings.Join(updates, ", "))

	_, err := s.db.Pool.Exec(context.Background(), query, args...)
	if err != nil {
		log.Error().Err(err).Msg("Failed to update repository")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to update repository"})
		return
	}

	render.JSON(w, r, map[string]string{"message": "Repository updated successfully"})
}

// deleteRepositoryHandler removes a repository from monitoring
func (s *Server) deleteRepositoryHandler(w http.ResponseWriter, r *http.Request) {
	repoID := chi.URLParam(r, "repoID")

	log.Info().Str("repository_id", repoID).Msg("Deleting repository monitor")

	query := "DELETE FROM repositories WHERE id = $1"
	result, err := s.db.Pool.Exec(context.Background(), query, repoID)
	if err != nil {
		log.Error().Err(err).Msg("Failed to delete repository")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to delete repository"})
		return
	}

	if result.RowsAffected() == 0 {
		render.Status(r, http.StatusNotFound)
		render.JSON(w, r, map[string]string{"error": "repository not found"})
		return
	}

	render.JSON(w, r, map[string]string{"message": "Repository deleted successfully"})
}

// syncRepositoryHandler triggers a manual sync of repository issues
func (s *Server) syncRepositoryHandler(w http.ResponseWriter, r *http.Request) {
	repoID := chi.URLParam(r, "repoID")

	log.Info().Str("repository_id", repoID).Msg("Manual repository sync triggered")

	if s.repoMonitor == nil {
		render.Status(r, http.StatusServiceUnavailable)
		render.JSON(w, r, map[string]string{"error": "repository monitoring service not available"})
		return
	}

	// Trigger repository sync in background
	go func() {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
		defer cancel()

		if err := s.repoMonitor.SyncRepository(ctx, repoID); err != nil {
			log.Error().
				Err(err).
				Str("repository_id", repoID).
				Msg("Manual repository sync failed")
		}
	}()

	render.JSON(w, r, map[string]interface{}{
		"message":       "Repository sync triggered",
		"repository_id": repoID,
		"status":        "started",
	})
}

// ensureRepositoryLabelsHandler ensures required labels exist in the Gitea repository
func (s *Server) ensureRepositoryLabelsHandler(w http.ResponseWriter, r *http.Request) {
	repoID := chi.URLParam(r, "repoID")

	log.Info().Str("repository_id", repoID).Msg("Ensuring repository labels")

	if s.repoMonitor == nil || s.repoMonitor.GetGiteaClient() == nil {
		render.Status(r, http.StatusServiceUnavailable)
		render.JSON(w, r, map[string]string{"error": "repository monitoring service not available"})
		return
	}

	// Get repository details first
	query := "SELECT owner, name FROM repositories WHERE id = $1"
	var owner, name string
	err := s.db.Pool.QueryRow(context.Background(), query, repoID).Scan(&owner, &name)
	if err != nil {
		if err.Error() == "no rows in result set" {
			render.Status(r, http.StatusNotFound)
			render.JSON(w, r, map[string]string{"error": "repository not found"})
			return
		}
		log.Error().Err(err).Msg("Failed to get repository")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to get repository"})
		return
	}

	// @goal: WHOOSH-LABELS-004 - Manual label synchronization endpoint
	// WHY: Allows updating existing repositories to standardized label set
	err = s.repoMonitor.GetGiteaClient().EnsureRequiredLabels(context.Background(), owner, name)
	if err != nil {
		log.Error().
			Err(err).
			Str("repository_id", repoID).
			Str("owner", owner).
			Str("name", name).
			Msg("Failed to ensure repository labels")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to create labels: " + err.Error()})
		return
	}

	log.Info().
		Str("repository_id", repoID).
		Str("owner", owner).
		Str("name", name).
		Msg("Successfully ensured repository labels")

	render.JSON(w, r, map[string]interface{}{
		"message":       "Repository labels ensured successfully",
		"repository_id": repoID,
		"owner":         owner,
		"name":          name,
	})
}

// getRepositorySyncLogsHandler returns sync logs for a repository
func (s *Server) getRepositorySyncLogsHandler(w http.ResponseWriter, r *http.Request) {
	repoID := chi.URLParam(r, "repoID")
	limit := 50

	if limitParam := r.URL.Query().Get("limit"); limitParam != "" {
		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 1000 {
			limit = l
		}
	}

	log.Info().Str("repository_id", repoID).Int("limit", limit).Msg("Getting repository sync logs")

	query := `
		SELECT id, sync_type, operation, status, message, error_details,
		       items_processed, items_created, items_updated, duration_ms,
		       external_id, external_url, created_at
		FROM repository_sync_logs 
		WHERE repository_id = $1 
		ORDER BY created_at DESC 
		LIMIT $2`

	rows, err := s.db.Pool.Query(context.Background(), query, repoID, limit)
	if err != nil {
		log.Error().Err(err).Msg("Failed to query sync logs")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to query sync logs"})
		return
	}
	defer rows.Close()

	logs := []map[string]interface{}{}
	for rows.Next() {
		var id, syncType, operation, status, message string
		var errorDetails []byte
		var itemsProcessed, itemsCreated, itemsUpdated, durationMs int
		var externalID, externalURL *string
		var createdAt time.Time

		err := rows.Scan(&id, &syncType, &operation, &status, &message, &errorDetails,
			&itemsProcessed, &itemsCreated, &itemsUpdated, &durationMs,
			&externalID, &externalURL, &createdAt)
		if err != nil {
			log.Error().Err(err).Msg("Failed to scan sync log row")
			continue
		}

		logEntry := map[string]interface{}{
			"id":              id,
			"sync_type":       syncType,
			"operation":       operation,
			"status":          status,
			"message":         message,
			"error_details":   string(errorDetails),
			"items_processed": itemsProcessed,
			"items_created":   itemsCreated,
			"items_updated":   itemsUpdated,
			"duration_ms":     durationMs,
			"external_id":     externalID,
			"external_url":    externalURL,
			"created_at":      createdAt.Format(time.RFC3339),
		}
		logs = append(logs, logEntry)
	}

	render.JSON(w, r, map[string]interface{}{
		"logs":  logs,
		"count": len(logs),
	})
}

// Council management handlers

func (s *Server) listCouncilsHandler(w http.ResponseWriter, r *http.Request) {
	// Query all councils with basic info
	query := `
		SELECT c.id, c.project_name, c.repository, c.status, c.created_at,
		       COUNT(DISTINCT ca.id) as agent_count,
		       COUNT(DISTINCT car.id) as artifacts_count
		FROM councils c
		LEFT JOIN council_agents ca ON c.id = ca.council_id
		LEFT JOIN council_artifacts car ON c.id = car.council_id
		GROUP BY c.id, c.project_name, c.repository, c.status, c.created_at
		ORDER BY c.created_at DESC
		LIMIT 100
	`

	rows, err := s.db.Pool.Query(r.Context(), query)
	if err != nil {
		log.Error().Err(err).Msg("Failed to query councils")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to retrieve councils"})
		return
	}
	defer rows.Close()

	var councils []map[string]interface{}
	for rows.Next() {
		var id uuid.UUID
		var projectName, repository, status string
		var createdAt time.Time
		var agentCount, artifactsCount int

		err := rows.Scan(&id, &projectName, &repository, &status, &createdAt, &agentCount, &artifactsCount)
		if err != nil {
			log.Error().Err(err).Msg("Failed to scan council row")
			continue
		}

		council := map[string]interface{}{
			"id":              id,
			"project_name":    projectName,
			"repository":      repository,
			"status":          status,
			"created_at":      createdAt.Format(time.RFC3339),
			"agent_count":     agentCount,
			"artifacts_count": artifactsCount,
		}

		councils = append(councils, council)
	}

	if err = rows.Err(); err != nil {
		log.Error().Err(err).Msg("Error iterating council rows")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to process councils"})
		return
	}

	render.JSON(w, r, map[string]interface{}{
		"councils": councils,
		"total":    len(councils),
	})
}

func (s *Server) getCouncilHandler(w http.ResponseWriter, r *http.Request) {
	councilIDStr := chi.URLParam(r, "councilID")
	councilID, err := uuid.Parse(councilIDStr)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid council ID"})
		return
	}

	composition, err := s.councilComposer.GetCouncilComposition(r.Context(), councilID)
	if err != nil {
		if strings.Contains(err.Error(), "no rows in result set") {
			render.Status(r, http.StatusNotFound)
			render.JSON(w, r, map[string]string{"error": "council not found"})
			return
		}

		log.Error().Err(err).Str("council_id", councilIDStr).Msg("Failed to get council composition")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to retrieve council"})
		return
	}

	render.JSON(w, r, composition)
}

func (s *Server) getCouncilArtifactsHandler(w http.ResponseWriter, r *http.Request) {
	councilIDStr := chi.URLParam(r, "councilID")
	councilID, err := uuid.Parse(councilIDStr)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid council ID"})
		return
	}

	// Query all artifacts for this council
	query := `
		SELECT id, artifact_type, artifact_name, content, content_json, produced_at, produced_by, status
		FROM council_artifacts
		WHERE council_id = $1
		ORDER BY produced_at DESC
	`

	rows, err := s.db.Pool.Query(r.Context(), query, councilID)
	if err != nil {
		log.Error().Err(err).Str("council_id", councilIDStr).Msg("Failed to query council artifacts")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to retrieve artifacts"})
		return
	}
	defer rows.Close()

	var artifacts []map[string]interface{}
	for rows.Next() {
		var id uuid.UUID
		var artifactType, artifactName, status string
		var content *string
		var contentJSON []byte
		var producedAt time.Time
		var producedBy *string

		err := rows.Scan(&id, &artifactType, &artifactName, &content, &contentJSON, &producedAt, &producedBy, &status)
		if err != nil {
			log.Error().Err(err).Msg("Failed to scan artifact row")
			continue
		}

		artifact := map[string]interface{}{
			"id":            id,
			"artifact_type": artifactType,
			"artifact_name": artifactName,
			"content":       content,
			"produced_at":   producedAt.Format(time.RFC3339),
			"produced_by":   producedBy,
			"status":        status,
		}

		// Parse JSON content if available
		if contentJSON != nil {
			var jsonData interface{}
			if err := json.Unmarshal(contentJSON, &jsonData); err == nil {
				artifact["content_json"] = jsonData
			}
		}

		artifacts = append(artifacts, artifact)
	}

	if err = rows.Err(); err != nil {
		log.Error().Err(err).Msg("Error iterating artifact rows")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to process artifacts"})
		return
	}

	render.JSON(w, r, map[string]interface{}{
		"council_id": councilID,
		"artifacts":  artifacts,
		"count":      len(artifacts),
	})
}

func (s *Server) createCouncilArtifactHandler(w http.ResponseWriter, r *http.Request) {
	councilIDStr := chi.URLParam(r, "councilID")
	councilID, err := uuid.Parse(councilIDStr)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid council ID"})
		return
	}

	var req struct {
		ArtifactType string      `json:"artifact_type"`
		ArtifactName string      `json:"artifact_name"`
		Content      *string     `json:"content,omitempty"`
		ContentJSON  interface{} `json:"content_json,omitempty"`
		ProducedBy   *string     `json:"produced_by,omitempty"`
		Status       *string     `json:"status,omitempty"`
	}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid JSON body"})
		return
	}

	if req.ArtifactType == "" || req.ArtifactName == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "artifact_type and artifact_name are required"})
		return
	}

	// Set default status if not provided
	status := "draft"
	if req.Status != nil {
		status = *req.Status
	}

	// Validate artifact type (based on the constraint in the migration)
	validTypes := map[string]bool{
		"kickoff_manifest": true,
		"seminal_dr":       true,
		"scaffold_plan":    true,
		"gate_tests":       true,
		"hmmm_thread":      true,
		"slurp_sources":    true,
		"shhh_policy":      true,
		"ucxl_root":        true,
	}

	if !validTypes[req.ArtifactType] {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid artifact_type"})
		return
	}

	// Prepare JSON content
	var contentJSONBytes []byte
	if req.ContentJSON != nil {
		contentJSONBytes, err = json.Marshal(req.ContentJSON)
		if err != nil {
			render.Status(r, http.StatusBadRequest)
			render.JSON(w, r, map[string]string{"error": "invalid content_json"})
			return
		}
	}

	// Insert artifact
	insertQuery := `
		INSERT INTO council_artifacts (council_id, artifact_type, artifact_name, content, content_json, produced_by, status)
		VALUES ($1, $2, $3, $4, $5, $6, $7)
		RETURNING id, produced_at
	`

	var artifactID uuid.UUID
	var producedAt time.Time

	err = s.db.Pool.QueryRow(r.Context(), insertQuery, councilID, req.ArtifactType, req.ArtifactName,
		req.Content, contentJSONBytes, req.ProducedBy, status).Scan(&artifactID, &producedAt)

	if err != nil {
		log.Error().Err(err).Str("council_id", councilIDStr).Msg("Failed to create council artifact")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to create artifact"})
		return
	}

	response := map[string]interface{}{
		"id":            artifactID,
		"council_id":    councilID,
		"artifact_type": req.ArtifactType,
		"artifact_name": req.ArtifactName,
		"content":       req.Content,
		"content_json":  req.ContentJSON,
		"produced_by":   req.ProducedBy,
		"status":        status,
		"produced_at":   producedAt.Format(time.RFC3339),
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, response)
}

// Helper methods for task processing

// lookupProjectData queries the repositories table to find project data by name
func (s *Server) lookupProjectData(ctx context.Context, projectID string, projectData *struct {
	RepoURL string `json:"repo_url"`
	Name    string `json:"name"`
}) error {
	// Query the repositories table to find the repository by name
	// We assume projectID corresponds to the repository name
	query := `
		SELECT name, url 
		FROM repositories 
		WHERE name = $1 OR full_name LIKE '%/' || $1
		LIMIT 1
	`

	var name, url string
	err := s.db.Pool.QueryRow(ctx, query, projectID).Scan(&name, &url)
	if err != nil {
		if strings.Contains(err.Error(), "no rows in result set") {
			return fmt.Errorf("project %s not found in repositories", projectID)
		}
		log.Error().Err(err).Str("project_id", projectID).Msg("Failed to query repository")
		return fmt.Errorf("database error: %w", err)
	}

	// Populate the project data
	projectData.Name = name
	projectData.RepoURL = url

	log.Info().
		Str("project_id", projectID).
		Str("name", name).
		Str("repo_url", url).
		Msg("Found project data in repositories table")

	return nil
}

// inferTechStackFromLabels extracts technology information from labels
func (s *Server) inferTechStackFromLabels(labels []string) []string {
	techMap := map[string]bool{
		"go":         true,
		"golang":     true,
		"javascript": true,
		"react":      true,
		"node":       true,
		"python":     true,
		"java":       true,
		"rust":       true,
		"docker":     true,
		"postgres":   true,
		"mysql":      true,
		"api":        true,
		"backend":    true,
		"frontend":   true,
		"database":   true,
	}

	var techStack []string
	for _, label := range labels {
		if techMap[strings.ToLower(label)] {
			techStack = append(techStack, strings.ToLower(label))
		}
	}

	return techStack
}

// processTaskAsync handles complex task processing in background
func (s *Server) processTaskAsync(taskID string, taskInput *composer.TaskAnalysisInput) {
	ctx := context.Background()

	log.Info().
		Str("task_id", taskID).
		Msg("Starting async task processing")

	result, err := s.teamComposer.AnalyzeAndComposeTeam(ctx, taskInput)
	if err != nil {
		log.Error().Err(err).
			Str("task_id", taskID).
			Msg("Async task analysis failed")
		return
	}

	team, err := s.teamComposer.CreateTeam(ctx, result.TeamComposition, taskInput)
	if err != nil {
		log.Error().Err(err).
			Str("task_id", taskID).
			Msg("Async team creation failed")
		return
	}

	log.Info().
		Str("task_id", taskID).
		Str("team_id", team.ID.String()).
		Float64("confidence", result.TeamComposition.ConfidenceScore).
		Msg("Async task processing completed")

	// In production, this would update task status in database
	// and potentially notify clients via websockets or webhooks
}

func (s *Server) startCouncilRebroadcastMonitor(opportunity *p2p.CouncilOpportunity) {
	s.rebroadcastMu.Lock()
	if cancel, ok := s.activeBroadcasts[opportunity.CouncilID]; ok {
		delete(s.activeBroadcasts, opportunity.CouncilID)
		cancel()
	}
	ctx, cancel := context.WithCancel(context.Background())
	s.activeBroadcasts[opportunity.CouncilID] = cancel
	s.rebroadcastMu.Unlock()

	go s.councilRebroadcastLoop(ctx, opportunity)
}

func (s *Server) stopCouncilRebroadcast(councilID uuid.UUID) {
	s.rebroadcastMu.Lock()
	cancel, ok := s.activeBroadcasts[councilID]
	if ok {
		delete(s.activeBroadcasts, councilID)
	}
	s.rebroadcastMu.Unlock()

	if ok {
		cancel()
	}
}

func (s *Server) clearCouncilBroadcast(councilID uuid.UUID) {
	s.rebroadcastMu.Lock()
	delete(s.activeBroadcasts, councilID)
	s.rebroadcastMu.Unlock()
}

func (s *Server) councilRebroadcastLoop(ctx context.Context, opportunity *p2p.CouncilOpportunity) {
	defer s.clearCouncilBroadcast(opportunity.CouncilID)

	interval := 10 * time.Second
	maxInterval := 2 * time.Minute

	for {
		select {
		case <-ctx.Done():
			log.Info().Str("council_id", opportunity.CouncilID.String()).Msg("🛑 Stopping council rebroadcast monitor")
			return
		case <-time.After(interval):
		}

		pending, err := s.hasUnfilledCoreRoles(ctx, opportunity.CouncilID)
		if err != nil {
			log.Warn().Err(err).Str("council_id", opportunity.CouncilID.String()).Msg("Failed to evaluate council staffing status")
			continue
		}

		if !pending {
			log.Info().Str("council_id", opportunity.CouncilID.String()).Msg("🎯 Council fully staffed; stopping rebroadcasts")
			return
		}

		log.Info().
			Str("council_id", opportunity.CouncilID.String()).
			Dur("interval", interval).
			Msg("📡 Re-broadcasting council opportunity to fill remaining roles")

		broadcastCtx, cancel := context.WithTimeout(ctx, 20*time.Second)
		if err := s.p2pBroadcaster.BroadcastCouncilOpportunity(broadcastCtx, opportunity); err != nil {
			log.Warn().Err(err).Str("council_id", opportunity.CouncilID.String()).Msg("Council rebroadcast failed")
		}
		cancel()

		if interval < maxInterval {
			interval *= 2
			if interval > maxInterval {
				interval = maxInterval
			}
		}
	}
}

func (s *Server) hasUnfilledCoreRoles(ctx context.Context, councilID uuid.UUID) (bool, error) {
	query := `
		SELECT COUNT(*)
		FROM council_agents
		WHERE council_id = $1
			AND required = true
			AND (deployed = false OR status NOT IN ('assigned', 'active'))
	`

	var remaining int
	if err := s.db.Pool.QueryRow(ctx, query, councilID).Scan(&remaining); err != nil {
		return false, err
	}

	return remaining > 0, nil
}

// handleCouncilRoleClaim handles POST /api/v1/councils/{councilID}/claims
// This endpoint receives role claim requests from CHORUS agents
func (s *Server) handleCouncilRoleClaim(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	councilID := chi.URLParam(r, "councilID")
	if councilID == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "council_id is required"})
		return
	}

	// Parse UUID
	councilUUID, err := uuid.Parse(councilID)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid council_id format"})
		return
	}

	// Parse claim request
	var claim struct {
		AgentID      string   `json:"agent_id"`
		AgentName    string   `json:"agent_name"`
		RoleName     string   `json:"role_name"`
		Capabilities []string `json:"capabilities"`
		Confidence   float64  `json:"confidence"`
		Reasoning    string   `json:"reasoning"`
		Endpoint     string   `json:"endpoint"`
		P2PAddr      string   `json:"p2p_addr"`
	}

	if err := s.validator.DecodeAndValidateJSON(r, &claim); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid JSON payload"})
		return
	}

	log.Info().
		Str("council_id", councilID).
		Str("agent_id", claim.AgentID).
		Str("role_name", claim.RoleName).
		Float64("confidence", claim.Confidence).
		Msg("🤖 Agent claiming council role")

	// Verify council exists and get current state
	councilQuery := `
		SELECT id, project_name, status, project_brief, repository, external_url, issue_id, brief_dispatched_at, brief_owner_role
		FROM councils
		WHERE id = $1
	`

	var existingCouncil struct {
		ID                uuid.UUID
		ProjectName       string
		Status            string
		ProjectBrief      string
		Repository        string
		ExternalURL       sql.NullString
		IssueID           sql.NullInt64
		BriefDispatchedAt sql.NullTime
		BriefOwnerRole    sql.NullString
	}

	err = s.db.Pool.QueryRow(ctx, councilQuery, councilUUID).Scan(
		&existingCouncil.ID,
		&existingCouncil.ProjectName,
		&existingCouncil.Status,
		&existingCouncil.ProjectBrief,
		&existingCouncil.Repository,
		&existingCouncil.ExternalURL,
		&existingCouncil.IssueID,
		&existingCouncil.BriefDispatchedAt,
		&existingCouncil.BriefOwnerRole,
	)

	if err != nil {
		log.Error().
			Err(err).
			Str("council_id", councilID).
			Msg("Council not found")
		render.Status(r, http.StatusNotFound)
		render.JSON(w, r, map[string]string{"error": "council not found"})
		return
	}

	// Check if council is still forming (not already active/completed)
	if existingCouncil.Status != "forming" && existingCouncil.Status != "active" {
		render.Status(r, http.StatusConflict)
		render.JSON(w, r, map[string]string{"error": fmt.Sprintf("council is %s, not accepting claims", existingCouncil.Status)})
		return
	}

	// Check if role exists and is unclaimed
	roleCheckQuery := `
		SELECT agent_id, agent_name, role_name, required, deployed, status, persona_status, endpoint_url
		FROM council_agents
		WHERE council_id = $1 AND role_name = $2
	`

	var existingRole struct {
		AgentID       string
		AgentName     string
		RoleName      string
		Required      bool
		Deployed      bool
		Status        string
		PersonaStatus string
		EndpointURL   sql.NullString
	}

	err = s.db.Pool.QueryRow(ctx, roleCheckQuery, councilUUID, claim.RoleName).Scan(
		&existingRole.AgentID,
		&existingRole.AgentName,
		&existingRole.RoleName,
		&existingRole.Required,
		&existingRole.Deployed,
		&existingRole.Status,
		&existingRole.PersonaStatus,
		&existingRole.EndpointURL,
	)

	if err != nil {
		log.Error().
			Err(err).
			Str("role_name", claim.RoleName).
			Msg("Role not found in council")
		render.Status(r, http.StatusNotFound)
		render.JSON(w, r, map[string]string{"error": "role not found in council"})
		return
	}

	// Check if role is already claimed
	if existingRole.Deployed || existingRole.Status == "assigned" || existingRole.Status == "active" {
		log.Warn().
			Str("role_name", claim.RoleName).
			Str("current_agent", existingRole.AgentID).
			Msg("Role already claimed by another agent")
		render.Status(r, http.StatusConflict)
		render.JSON(w, r, map[string]string{"error": "role already claimed"})
		return
	}

	// Assign role to agent
	updateQuery := `
		UPDATE council_agents
		SET
			deployed = true,
			status = 'assigned',
			service_id = $1,
			endpoint_url = $2,
			persona_status = 'pending',
			persona_loaded_at = NULL,
			deployed_at = NOW(),
			updated_at = NOW()
		WHERE council_id = $3 AND role_name = $4
	`

	retry := false
	_, err = s.db.Pool.Exec(ctx, updateQuery, claim.AgentID, claim.Endpoint, councilUUID, claim.RoleName)
	if err != nil {
		if pgErr, ok := err.(*pgconn.PgError); ok && pgErr.Code == "23514" {
			retry = true
			log.Warn().
				Str("council_id", councilID).
				Str("role_name", claim.RoleName).
				Str("agent_id", claim.AgentID).
				Msg("Council role assignment hit legacy status constraint – attempting remediation")

			if ensureErr := s.ensureCouncilAgentStatusConstraint(ctx); ensureErr != nil {
				log.Error().
					Err(ensureErr).
					Str("council_id", councilID).
					Msg("Failed to reconcile council agent status constraint")
				// keep original error to return below
			} else {
				_, err = s.db.Pool.Exec(ctx, updateQuery, claim.AgentID, claim.Endpoint, councilUUID, claim.RoleName)
			}
		}
	}

	if err != nil {
		log.Error().
			Err(err).
			Str("council_id", councilID).
			Str("role_name", claim.RoleName).
			Msg("Failed to assign role to agent")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to assign role"})
		return
	}

	if retry {
		log.Info().
			Str("council_id", councilID).
			Str("role_name", claim.RoleName).
			Msg("Council agent status constraint updated to allow 'assigned'")
	}

	log.Info().
		Str("council_id", councilID).
		Str("agent_id", claim.AgentID).
		Str("role_name", claim.RoleName).
		Msg("✅ Successfully assigned council role to agent")

	roleProfile := s.lookupRoleProfile(claim.RoleName, existingRole.AgentName)
	ucxlCouncilAddress := fmt.Sprintf("ucxl://team:council@project:%s:council/councils/%s", sanitizeUCXLIdentifier(existingCouncil.ProjectName), councilID)

	briefSummary := map[string]interface{}{
		"project_name": existingCouncil.ProjectName,
		"repository":   existingCouncil.Repository,
		"ucxl_address": ucxlCouncilAddress,
	}

	if trimmed := strings.TrimSpace(existingCouncil.ProjectBrief); trimmed != "" {
		briefSummary["summary"] = truncateString(trimmed, 2000)
	}

	if existingCouncil.ExternalURL.Valid {
		briefSummary["external_url"] = existingCouncil.ExternalURL.String
	}

	if existingCouncil.IssueID.Valid {
		briefSummary["issue_id"] = existingCouncil.IssueID.Int64
	}

	if existingCouncil.BriefOwnerRole.Valid {
		briefSummary["brief_owner_role"] = existingCouncil.BriefOwnerRole.String
	}

	// Check if all core roles are now claimed
	roleCountsQuery := `
		SELECT
			COUNT(*) FILTER (WHERE required = true) AS total_core,
			COUNT(*) FILTER (WHERE required = true AND deployed = true AND status IN ('assigned', 'active')) AS claimed_core,
			COUNT(*) FILTER (WHERE required = false) AS total_optional,
			COUNT(*) FILTER (WHERE required = false AND deployed = true AND status IN ('assigned', 'active')) AS claimed_optional
		FROM council_agents
		WHERE council_id = $1
	`

	var roleCounts struct {
		TotalCore       int
		ClaimedCore     int
		TotalOptional   int
		ClaimedOptional int
	}

	err = s.db.Pool.QueryRow(ctx, roleCountsQuery, councilUUID).Scan(
		&roleCounts.TotalCore,
		&roleCounts.ClaimedCore,
		&roleCounts.TotalOptional,
		&roleCounts.ClaimedOptional,
	)
	if err != nil {
		log.Error().Err(err).Msg("Failed to check core role status")
	} else if roleCounts.TotalCore > 0 && roleCounts.ClaimedCore == roleCounts.TotalCore {
		// All core roles claimed - activate council
		_, err = s.db.Pool.Exec(ctx, "UPDATE councils SET status = 'active', updated_at = NOW() WHERE id = $1", councilUUID)
		if err == nil {
			log.Info().
				Str("council_id", councilID).
				Int("core_roles", roleCounts.TotalCore).
				Msg("🎉 All core roles claimed - Council activated!")
			// Stop any ongoing rebroadcast loop now that the council is fully staffed
			s.stopCouncilRebroadcast(councilUUID)

			go func() {
				broadcastCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
				defer cancel()

				statusUpdate, buildErr := s.buildCouncilStatusUpdate(broadcastCtx, councilUUID, "active", fmt.Sprintf("All %d core roles claimed", roleCounts.TotalCore))
				if buildErr != nil {
					log.Warn().Err(buildErr).Str("council_id", councilID).Msg("Failed to build council status update snapshot")
				} else {
					if err := s.p2pBroadcaster.BroadcastCouncilStatusUpdate(broadcastCtx, statusUpdate); err != nil {
						log.Warn().Err(err).Str("council_id", councilID).Msg("Failed to broadcast council status update")
					}
				}

				// Trigger team composition for the associated task once council is active
				if err := s.triggerTeamCompositionForCouncil(broadcastCtx, existingCouncil.ID); err != nil {
					log.Warn().Err(err).
						Str("council_id", councilID).
						Msg("Failed to trigger team composition after council activation")
				}
			}()
		}
	}

	// Return success response
	response := map[string]interface{}{
		"status":         "accepted",
		"council_id":     councilID,
		"role_name":      claim.RoleName,
		"ucxl_address":   fmt.Sprintf("%s/roles/%s", ucxlCouncilAddress, sanitizeUCXLIdentifier(claim.RoleName)),
		"assigned_at":    time.Now().Format(time.RFC3339),
		"role_profile":   roleProfile,
		"council_brief":  briefSummary,
		"persona_status": "pending",
	}

	render.Status(r, http.StatusCreated)
	render.JSON(w, r, response)
}

func (s *Server) ensureCouncilAgentStatusConstraint(ctx context.Context) error {
	s.constraintMu.Lock()
	defer s.constraintMu.Unlock()

	tx, err := s.db.Pool.BeginTx(ctx, pgx.TxOptions{})
	if err != nil {
		return fmt.Errorf("begin council agent status constraint update: %w", err)
	}

	dropStmt := `ALTER TABLE council_agents DROP CONSTRAINT IF EXISTS council_agents_status_check`
	if _, err := tx.Exec(ctx, dropStmt); err != nil {
		tx.Rollback(ctx)
		return fmt.Errorf("drop council agent status constraint: %w", err)
	}

	addStmt := `ALTER TABLE council_agents ADD CONSTRAINT council_agents_status_check CHECK (status IN ('pending', 'deploying', 'assigned', 'active', 'failed', 'removed'))`
	if _, err := tx.Exec(ctx, addStmt); err != nil {
		tx.Rollback(ctx)

		if pgErr, ok := err.(*pgconn.PgError); ok && pgErr.Code == "42710" {
			return nil
		}

		return fmt.Errorf("add council agent status constraint: %w", err)
	}

	if err := tx.Commit(ctx); err != nil {
		return fmt.Errorf("commit council agent status constraint update: %w", err)
	}

	return nil
}

// triggerTeamCompositionForCouncil starts team composition for the task linked to the council
func (s *Server) triggerTeamCompositionForCouncil(ctx context.Context, councilID uuid.UUID) error {
	// Look up the task associated with this council. For now we assume the task ID matches the council ID.
	// Future work could store an explicit mapping in the database.
	taskID := councilID.String()

	log := zerolog.Ctx(ctx).With().Str("council_id", councilID.String()).Str("task_id", taskID).Logger()
	log.Info().Msg("🔁 Triggering team composition for council-linked task")

	// Reuse the monitor's capability to run team composition if available.
	// During server initialization the monitor reference is optional; guard against nil.
	if s.repoMonitor == nil {
		return fmt.Errorf("monitor not initialized; cannot trigger team composition")
	}

	// Use the monitor's helper so the same logic runs as for bzzz-task issues.
	go s.repoMonitor.TriggerTeamCompositionForCouncil(ctx, taskID)

	return nil
}

// handleCouncilPersonaAck receives persona readiness status from CHORUS agents.
func (s *Server) handleCouncilPersonaAck(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	councilIDParam := chi.URLParam(r, "councilID")
	if councilIDParam == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "council_id is required"})
		return
	}

	roleName := chi.URLParam(r, "roleName")
	if roleName == "" {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "roleName is required"})
		return
	}

	councilUUID, err := uuid.Parse(councilIDParam)
	if err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid council_id format"})
		return
	}

	type personaAckPayload struct {
		AgentID          string                 `json:"agent_id"`
		Status           string                 `json:"status"`
		ModelProvider    string                 `json:"model_provider"`
		ModelName        string                 `json:"model_name,omitempty"`
		SystemPromptHash string                 `json:"system_prompt_hash,omitempty"`
		Capabilities     []string               `json:"capabilities,omitempty"`
		Errors           []string               `json:"errors,omitempty"`
		Metadata         map[string]interface{} `json:"metadata,omitempty"`
		EndpointOverride string                 `json:"endpoint_override,omitempty"`
	}

	var payload personaAckPayload
	if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid JSON payload"})
		return
	}

	status := strings.TrimSpace(strings.ToLower(payload.Status))
	if status == "" {
		status = "pending"
	}

	ackRecord := map[string]interface{}{
		"agent_id":           payload.AgentID,
		"status":             status,
		"model_provider":     payload.ModelProvider,
		"model_name":         payload.ModelName,
		"system_prompt_hash": payload.SystemPromptHash,
		"capabilities":       payload.Capabilities,
		"metadata":           payload.Metadata,
		"errors":             payload.Errors,
		"endpoint_override":  payload.EndpointOverride,
		"acknowledged_at":    time.Now().UTC().Format(time.RFC3339),
	}

	ackPayloadJSON, err := json.Marshal(ackRecord)
	if err != nil {
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to marshal persona ack payload"})
		return
	}

	updateQuery := `
		UPDATE council_agents
		SET
			persona_status = $1::text,
			persona_loaded_at = CASE WHEN $1::text = 'loaded' THEN NOW() ELSE persona_loaded_at END,
			persona_ack_payload = COALESCE($2::jsonb, persona_ack_payload),
			endpoint_url = COALESCE(NULLIF($3, '')::text, endpoint_url),
			updated_at = NOW()
		WHERE council_id = $4 AND role_name = $5
	`

	var ackJSON interface{}
	if len(ackPayloadJSON) > 0 {
		ackJSON = string(ackPayloadJSON)
	}

	commandTag, err := s.db.Pool.Exec(ctx, updateQuery, status, ackJSON, payload.EndpointOverride, councilUUID, roleName)
	if err != nil {
		log.Error().Err(err).
			Str("council_id", councilIDParam).
			Str("role_name", roleName).
			Msg("Failed to update persona status")
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": "failed to update persona status"})
		return
	}

	if commandTag.RowsAffected() == 0 {
		render.Status(r, http.StatusNotFound)
		render.JSON(w, r, map[string]string{"error": "council role not found"})
		return
	}

	log.Info().
		Str("council_id", councilIDParam).
		Str("role_name", roleName).
		Str("agent_id", payload.AgentID).
		Str("status", status).
		Msg("📩 Persona status acknowledged")

	go s.onPersonaAcknowledged(context.Background(), councilUUID)

	render.Status(r, http.StatusAccepted)
	render.JSON(w, r, map[string]interface{}{
		"status":    status,
		"timestamp": time.Now().Unix(),
	})
}

func (s *Server) onPersonaAcknowledged(ctx context.Context, councilID uuid.UUID) {
	if ctx == nil {
		ctx = context.Background()
	}

	statusUpdate, err := s.buildCouncilStatusUpdate(ctx, councilID, "", "Persona status updated")
	if err != nil {
		log.Warn().Err(err).Str("council_id", councilID.String()).Msg("Failed to build council status snapshot after persona ack")
	} else if statusUpdate != nil && s.p2pBroadcaster != nil {
		txCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
		defer cancel()
		if err := s.p2pBroadcaster.BroadcastCouncilStatusUpdate(txCtx, statusUpdate); err != nil {
			log.Warn().Err(err).Str("council_id", councilID.String()).Msg("Failed to broadcast persona status update")
		}
	}

	ready, err := s.allCorePersonasLoaded(ctx, councilID)
	if err != nil {
		log.Warn().Err(err).Str("council_id", councilID.String()).Msg("Failed to evaluate core persona readiness")
		return
	}

	if ready {
		if err := s.dispatchCouncilBrief(ctx, councilID); err != nil {
			log.Warn().Err(err).Str("council_id", councilID.String()).Msg("Failed to dispatch council design brief")
		}
	}
}

func (s *Server) allCorePersonasLoaded(ctx context.Context, councilID uuid.UUID) (bool, error) {
	query := `
		SELECT
			COUNT(*) FILTER (WHERE required = true) AS total_core,
			COUNT(*) FILTER (WHERE required = true AND persona_status = 'loaded') AS loaded_core
		FROM council_agents
		WHERE council_id = $1
	`

	var totals struct {
		TotalCore  int
		LoadedCore int
	}

	if err := s.db.Pool.QueryRow(ctx, query, councilID).Scan(&totals.TotalCore, &totals.LoadedCore); err != nil {
		return false, err
	}

	if totals.TotalCore == 0 {
		return false, nil
	}

	return totals.TotalCore == totals.LoadedCore, nil
}

func (s *Server) buildCouncilStatusUpdate(ctx context.Context, councilID uuid.UUID, statusOverride, message string) (*p2p.CouncilStatusUpdate, error) {
	councilQuery := `
		SELECT project_name, status, brief_dispatched_at
		FROM councils
		WHERE id = $1
	`

	var councilRow struct {
		ProjectName       string
		Status            string
		BriefDispatchedAt sql.NullTime
	}

	if err := s.db.Pool.QueryRow(ctx, councilQuery, councilID).Scan(&councilRow.ProjectName, &councilRow.Status, &councilRow.BriefDispatchedAt); err != nil {
		return nil, err
	}

	rolesQuery := `
		SELECT required, deployed, status, persona_status
		FROM council_agents
		WHERE council_id = $1
	`

	rows, err := s.db.Pool.Query(ctx, rolesQuery, councilID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var (
		totalCore, claimedCore         int
		totalOptional, claimedOptional int
		totalPersonas, loadedPersonas  int
		corePersonasLoaded             int
	)

	for rows.Next() {
		var required, deployed bool
		var status, personaStatus string
		if err := rows.Scan(&required, &deployed, &status, &personaStatus); err != nil {
			return nil, err
		}

		if required {
			totalCore++
			if deployed && (status == "assigned" || status == "active") {
				claimedCore++
			}
		} else {
			totalOptional++
			if deployed && (status == "assigned" || status == "active") {
				claimedOptional++
			}
		}

		if deployed {
			totalPersonas++
			if personaStatus == "loaded" {
				loadedPersonas++
				if required {
					corePersonasLoaded++
				}
			}
		}
	}

	if err := rows.Err(); err != nil {
		return nil, err
	}

	status := councilRow.Status
	if statusOverride != "" {
		status = statusOverride
	}

	if message == "" {
		message = fmt.Sprintf("Core roles %d/%d claimed", claimedCore, totalCore)
	}

	return &p2p.CouncilStatusUpdate{
		CouncilID:   councilID,
		ProjectName: councilRow.ProjectName,
		Status:      status,
		Message:     message,
		Timestamp:   time.Now(),
		CoreRoles: p2p.RoleCounts{
			Total:   totalCore,
			Claimed: claimedCore,
		},
		Optional: p2p.RoleCounts{
			Total:   totalOptional,
			Claimed: claimedOptional,
		},
		Personas: p2p.PersonaCounts{
			Total:      totalPersonas,
			Loaded:     loadedPersonas,
			CoreLoaded: corePersonasLoaded,
		},
		BriefDispatched: councilRow.BriefDispatchedAt.Valid,
	}, nil
}

func (s *Server) dispatchCouncilBrief(ctx context.Context, councilID uuid.UUID) error {
	const leadRole = "tpm"

	councilQuery := `
		SELECT project_name, project_brief, repository, external_url, issue_id, brief_dispatched_at
		FROM councils
		WHERE id = $1
	`

	var councilRow struct {
		ProjectName       string
		ProjectBrief      string
		Repository        string
		ExternalURL       sql.NullString
		IssueID           sql.NullInt64
		BriefDispatchedAt sql.NullTime
	}

	if err := s.db.Pool.QueryRow(ctx, councilQuery, councilID).Scan(
		&councilRow.ProjectName,
		&councilRow.ProjectBrief,
		&councilRow.Repository,
		&councilRow.ExternalURL,
		&councilRow.IssueID,
		&councilRow.BriefDispatchedAt,
	); err != nil {
		return err
	}

	if councilRow.BriefDispatchedAt.Valid {
		log.Debug().Str("council_id", councilID.String()).Msg("Council brief already dispatched")
		return nil
	}

	agentQuery := `
		SELECT agent_id, endpoint_url
		FROM council_agents
		WHERE council_id = $1 AND role_name = $2 AND deployed = true
	`

	var agentRow struct {
		AgentID  string
		Endpoint sql.NullString
	}

	if err := s.db.Pool.QueryRow(ctx, agentQuery, councilID, leadRole).Scan(&agentRow.AgentID, &agentRow.Endpoint); err != nil {
		return fmt.Errorf("failed to load project lead agent: %w", err)
	}

	if !agentRow.Endpoint.Valid || strings.TrimSpace(agentRow.Endpoint.String) == "" {
		return fmt.Errorf("project lead endpoint not available")
	}

	briefPayload := map[string]interface{}{
		"council_id":   councilID.String(),
		"project_name": councilRow.ProjectName,
		"repository":   councilRow.Repository,
		"ucxl_address": fmt.Sprintf("ucxl://team:council@project:%s:council/councils/%s", sanitizeUCXLIdentifier(councilRow.ProjectName), councilID.String()),
		"hmmm_topic":   fmt.Sprintf("council:%s", councilID.String()),
		"expected_artifacts": []string{
			"kickoff_manifest",
			"seminal_dr",
			"scaffold_plan",
			"gate_tests",
		},
	}

	if trimmed := strings.TrimSpace(councilRow.ProjectBrief); trimmed != "" {
		briefPayload["summary"] = trimmed
	}

	if councilRow.ExternalURL.Valid {
		briefPayload["brief_url"] = councilRow.ExternalURL.String
	}

	if councilRow.IssueID.Valid {
		briefPayload["issue_id"] = councilRow.IssueID.Int64
	}

	payloadBytes, err := json.Marshal(briefPayload)
	if err != nil {
		return fmt.Errorf("failed to marshal brief payload: %w", err)
	}

	requestURL := fmt.Sprintf("%s/api/v1/councils/%s/roles/%s/brief", strings.TrimRight(agentRow.Endpoint.String, "/"), councilID.String(), leadRole)
	log.Info().
		Str("council_id", councilID.String()).
		Str("role", leadRole).
		Str("endpoint", requestURL).
		Msg("📦 Dispatching design brief to council project lead")

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, requestURL, bytes.NewBuffer(payloadBytes))
	if err != nil {
		return fmt.Errorf("failed to create brief dispatch request: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-WHOOSH-Broadcast", "council-brief")

	client := &http.Client{Timeout: 15 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("failed to send brief to project lead: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusAccepted {
		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
		return fmt.Errorf("project lead returned non-success status %d: %s", resp.StatusCode, string(body))
	}

	updateQuery := `
		UPDATE councils
		SET brief_dispatched_at = NOW(), brief_owner_role = $2, updated_at = NOW()
		WHERE id = $1 AND brief_dispatched_at IS NULL
	`

	if _, err := s.db.Pool.Exec(ctx, updateQuery, councilID, leadRole); err != nil {
		log.Warn().Err(err).
			Str("council_id", councilID.String()).
			Msg("Brief delivered but failed to update dispatch timestamp")
	} else {
		log.Info().
			Str("council_id", councilID.String()).
			Str("role", leadRole).
			Msg("🎯 Council brief dispatched to project lead")
	}

	statusUpdate, err := s.buildCouncilStatusUpdate(ctx, councilID, "active", "Brief dispatched to project lead")
	if err == nil && statusUpdate != nil && s.p2pBroadcaster != nil {
		statusUpdate.BriefDispatched = true
		txCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
		defer cancel()
		if err := s.p2pBroadcaster.BroadcastCouncilStatusUpdate(txCtx, statusUpdate); err != nil {
			log.Warn().Err(err).Str("council_id", councilID.String()).Msg("Failed to broadcast brief dispatch update")
		}
	}

	return nil
}