feat: Implement council brief processing loop for task execution

Add processBriefs() polling loop that checks for assigned council briefs
and executes them using the ExecutionEngine infrastructure.

Changes:
- Add GetCurrentAssignment() public method to council.Manager
- Make HTTPServer.CouncilManager public for brief access
- Add processBriefs() 15-second polling loop in agent_support.go
- Add executeBrief() to initialize and run ExecutionEngine
- Add buildExecutionRequest() to convert briefs to execution requests
- Add uploadResults() to send completed work to WHOOSH
- Wire processBriefs() into StartAgentMode() as background goroutine

This addresses the root cause of task execution not happening: briefs
were being stored but never polled or executed. The execution
infrastructure (ExecutionEngine, AI providers, prompt system) was
complete but not connected to the council workflow.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

api/http_server.go

@@ -4,10 +4,15 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"os"
 	"strconv"
+	"strings"
 	"time"
 
+	"chorus/internal/council"
 	"chorus/internal/logging"
+	"chorus/p2p"
+	"chorus/pkg/config"
 	"chorus/pubsub"
 
 	"github.com/gorilla/mux"
@@ -15,19 +20,96 @@ import (
 
 // HTTPServer provides HTTP API endpoints for CHORUS
 type HTTPServer struct {
-	port         int
-	hypercoreLog *logging.HypercoreLog
-	pubsub       *pubsub.PubSub
-	server       *http.Server
+	port           int
+	hypercoreLog   *logging.HypercoreLog
+	pubsub         *pubsub.PubSub
+	server         *http.Server
+	CouncilManager *council.Manager // Exported for brief processing
+	whooshEndpoint string
 }
 
 // NewHTTPServer creates a new HTTP server for CHORUS API
-func NewHTTPServer(port int, hlog *logging.HypercoreLog, ps *pubsub.PubSub) *HTTPServer {
-	return &HTTPServer{
-		port:         port,
-		hypercoreLog: hlog,
-		pubsub:       ps,
+func NewHTTPServer(cfg *config.Config, node *p2p.Node, hlog *logging.HypercoreLog, ps *pubsub.PubSub) *HTTPServer {
+	agentID := cfg.Agent.ID
+	agentName := deriveAgentName(cfg)
+	endpoint := deriveAgentEndpoint(cfg)
+	p2pAddr := deriveAgentP2PAddress(cfg, node)
+	capabilities := cfg.Agent.Capabilities
+	if len(capabilities) == 0 {
+		capabilities = []string{"general_development", "task_coordination"}
 	}
+
+	councilMgr := council.NewManager(agentID, agentName, endpoint, p2pAddr, capabilities)
+
+	whooshEndpoint := overrideWhooshEndpoint(cfg)
+
+	return &HTTPServer{
+		port:           cfg.Network.APIPort,
+		hypercoreLog:   hlog,
+		pubsub:         ps,
+		CouncilManager: councilMgr,
+		whooshEndpoint: strings.TrimRight(whooshEndpoint, "/"),
+	}
+}
+
+func deriveAgentName(cfg *config.Config) string {
+	if v := strings.TrimSpace(os.Getenv("CHORUS_AGENT_NAME")); v != "" {
+		return v
+	}
+	if cfg.Agent.Specialization != "" {
+		return cfg.Agent.Specialization
+	}
+	return cfg.Agent.ID
+}
+
+func deriveAgentEndpoint(cfg *config.Config) string {
+	if v := strings.TrimSpace(os.Getenv("CHORUS_AGENT_ENDPOINT")); v != "" {
+		return strings.TrimRight(v, "/")
+	}
+	host := strings.TrimSpace(os.Getenv("CHORUS_AGENT_SERVICE_HOST"))
+	if host == "" {
+		host = "chorus"
+	}
+	scheme := strings.TrimSpace(os.Getenv("CHORUS_AGENT_ENDPOINT_SCHEME"))
+	if scheme == "" {
+		scheme = "http"
+	}
+	return fmt.Sprintf("%s://%s:%d", scheme, host, cfg.Network.APIPort)
+}
+
+func deriveAgentP2PAddress(cfg *config.Config, node *p2p.Node) string {
+	if v := strings.TrimSpace(os.Getenv("CHORUS_AGENT_P2P_ENDPOINT")); v != "" {
+		return v
+	}
+	if node != nil {
+		addrs := node.Addresses()
+		if len(addrs) > 0 {
+			return fmt.Sprintf("%s/p2p/%s", addrs[0], node.ID())
+		}
+	}
+	host := strings.TrimSpace(os.Getenv("CHORUS_AGENT_SERVICE_HOST"))
+	if host == "" {
+		host = "chorus"
+	}
+	return fmt.Sprintf("%s:%d", host, cfg.Network.P2PPort)
+}
+
+func overrideWhooshEndpoint(cfg *config.Config) string {
+	if v := strings.TrimSpace(os.Getenv("CHORUS_WHOOSH_ENDPOINT")); v != "" {
+		return strings.TrimRight(v, "/")
+	}
+	candidate := cfg.WHOOSHAPI.BaseURL
+	if candidate == "" {
+		candidate = cfg.WHOOSHAPI.URL
+	}
+	if candidate == "" {
+		return "http://whoosh:8080"
+	}
+	trimmed := strings.TrimRight(candidate, "/")
+	if strings.Contains(trimmed, "localhost") || strings.Contains(trimmed, "127.0.0.1") {
+		return "http://whoosh:8080"
+	}
+	return trimmed
 }
 
 // Start starts the HTTP server
@@ -65,6 +147,12 @@ func (h *HTTPServer) Start() error {
 	// Status endpoint
 	api.HandleFunc("/status", h.handleStatus).Methods("GET")
 
+	// Council opportunity endpoints (v1)
+	v1 := api.PathPrefix("/v1").Subrouter()
+	v1.HandleFunc("/opportunities/council", h.handleCouncilOpportunity).Methods("POST")
+	v1.HandleFunc("/councils/status", h.handleCouncilStatusUpdate).Methods("POST")
+	v1.HandleFunc("/councils/{councilID}/roles/{roleName}/brief", h.handleCouncilBrief).Methods("POST")
+
 	h.server = &http.Server{
 		Addr:         fmt.Sprintf(":%d", h.port),
 		Handler:      router,
@@ -242,3 +330,209 @@ func (h *HTTPServer) handleStatus(w http.ResponseWriter, r *http.Request) {
 
 	json.NewEncoder(w).Encode(status)
 }
+
+// handleCouncilOpportunity receives council formation opportunities from WHOOSH
+func (h *HTTPServer) handleCouncilOpportunity(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+
+	var opportunity council.CouncilOpportunity
+	if err := json.NewDecoder(r.Body).Decode(&opportunity); err != nil {
+		http.Error(w, fmt.Sprintf("Invalid JSON payload: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	// Log the received opportunity to hypercore
+	logData := map[string]interface{}{
+		"event":          "council_opportunity_received",
+		"council_id":     opportunity.CouncilID,
+		"project_name":   opportunity.ProjectName,
+		"repository":     opportunity.Repository,
+		"core_roles":     len(opportunity.CoreRoles),
+		"optional_roles": len(opportunity.OptionalRoles),
+		"ucxl_address":   opportunity.UCXLAddress,
+		"message":        fmt.Sprintf("📡 Received council opportunity for project: %s", opportunity.ProjectName),
+	}
+
+	if _, err := h.hypercoreLog.Append(logging.NetworkEvent, logData); err != nil {
+		fmt.Printf("Failed to log council opportunity: %v\n", err)
+	}
+
+	// Log to console for immediate visibility
+	fmt.Printf("\n📡 COUNCIL OPPORTUNITY RECEIVED\n")
+	fmt.Printf("   Council ID: %s\n", opportunity.CouncilID)
+	fmt.Printf("   Project: %s\n", opportunity.ProjectName)
+	fmt.Printf("   Repository: %s\n", opportunity.Repository)
+	fmt.Printf("   Core Roles: %d\n", len(opportunity.CoreRoles))
+	fmt.Printf("   Optional Roles: %d\n", len(opportunity.OptionalRoles))
+	fmt.Printf("   UCXL: %s\n", opportunity.UCXLAddress)
+	fmt.Printf("\n   Available Roles:\n")
+	for _, role := range opportunity.CoreRoles {
+		fmt.Printf("      - %s (%s) [CORE]\n", role.AgentName, role.RoleName)
+	}
+	for _, role := range opportunity.OptionalRoles {
+		fmt.Printf("      - %s (%s) [OPTIONAL]\n", role.AgentName, role.RoleName)
+	}
+	fmt.Printf("\n")
+
+	// Evaluate the opportunity and claim a role if suitable
+	go func() {
+		if err := h.CouncilManager.EvaluateOpportunity(&opportunity, h.whooshEndpoint); err != nil {
+			fmt.Printf("Failed to evaluate/claim council role: %v\n", err)
+		}
+	}()
+
+	response := map[string]interface{}{
+		"status":     "received",
+		"council_id": opportunity.CouncilID,
+		"message":    "Council opportunity received and being evaluated",
+		"timestamp":  time.Now().Unix(),
+		"agent_id":   h.CouncilManager.AgentID(),
+	}
+
+	w.WriteHeader(http.StatusAccepted)
+	json.NewEncoder(w).Encode(response)
+}
+
+// handleCouncilStatusUpdate receives council staffing updates from WHOOSH
+func (h *HTTPServer) handleCouncilStatusUpdate(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+
+	type roleCountsPayload struct {
+		Total   int `json:"total"`
+		Claimed int `json:"claimed"`
+	}
+
+	type councilStatusPayload struct {
+		CouncilID   string            `json:"council_id"`
+		ProjectName string            `json:"project_name"`
+		Status      string            `json:"status"`
+		Message     string            `json:"message"`
+		Timestamp   time.Time         `json:"timestamp"`
+		CoreRoles   roleCountsPayload `json:"core_roles"`
+		Optional    roleCountsPayload `json:"optional_roles"`
+	}
+
+	var payload councilStatusPayload
+	if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
+		http.Error(w, fmt.Sprintf("Invalid JSON payload: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	if payload.CouncilID == "" {
+		http.Error(w, "council_id is required", http.StatusBadRequest)
+		return
+	}
+
+	if payload.Status == "" {
+		payload.Status = "unknown"
+	}
+
+	if payload.Timestamp.IsZero() {
+		payload.Timestamp = time.Now()
+	}
+
+	if payload.Message == "" {
+		payload.Message = fmt.Sprintf("Council status update: %s (core %d/%d, optional %d/%d)",
+			payload.Status,
+			payload.CoreRoles.Claimed, payload.CoreRoles.Total,
+			payload.Optional.Claimed, payload.Optional.Total,
+		)
+	}
+
+	logData := map[string]interface{}{
+		"event":                  "council_status_update",
+		"council_id":             payload.CouncilID,
+		"project_name":           payload.ProjectName,
+		"status":                 payload.Status,
+		"message":                payload.Message,
+		"timestamp":              payload.Timestamp.Format(time.RFC3339),
+		"core_roles_total":       payload.CoreRoles.Total,
+		"core_roles_claimed":     payload.CoreRoles.Claimed,
+		"optional_roles_total":   payload.Optional.Total,
+		"optional_roles_claimed": payload.Optional.Claimed,
+	}
+
+	if _, err := h.hypercoreLog.Append(logging.NetworkEvent, logData); err != nil {
+		fmt.Printf("Failed to log council status update: %v\n", err)
+	}
+
+	fmt.Printf("\n🏁 COUNCIL STATUS UPDATE\n")
+	fmt.Printf("   Council ID: %s\n", payload.CouncilID)
+	if payload.ProjectName != "" {
+		fmt.Printf("   Project: %s\n", payload.ProjectName)
+	}
+	fmt.Printf("   Status: %s\n", payload.Status)
+	fmt.Printf("   Core Roles: %d/%d claimed\n", payload.CoreRoles.Claimed, payload.CoreRoles.Total)
+	fmt.Printf("   Optional Roles: %d/%d claimed\n", payload.Optional.Claimed, payload.Optional.Total)
+	fmt.Printf("   Message: %s\n\n", payload.Message)
+
+	response := map[string]interface{}{
+		"status":     "received",
+		"council_id": payload.CouncilID,
+		"timestamp":  payload.Timestamp.Unix(),
+	}
+
+	w.WriteHeader(http.StatusAccepted)
+	json.NewEncoder(w).Encode(response)
+}
+
+func (h *HTTPServer) handleCouncilBrief(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+
+	vars := mux.Vars(r)
+	councilID := vars["councilID"]
+	roleName := vars["roleName"]
+
+	if councilID == "" || roleName == "" {
+		http.Error(w, "councilID and roleName are required", http.StatusBadRequest)
+		return
+	}
+
+	var brief council.CouncilBrief
+	if err := json.NewDecoder(r.Body).Decode(&brief); err != nil {
+		http.Error(w, fmt.Sprintf("Invalid JSON payload: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	brief.CouncilID = councilID
+	brief.RoleName = roleName
+
+	fmt.Printf("\n📦 Received council brief for %s (%s)\n", councilID, roleName)
+	if brief.BriefURL != "" {
+		fmt.Printf("   Brief URL: %s\n", brief.BriefURL)
+	}
+	if brief.Summary != "" {
+		fmt.Printf("   Summary: %s\n", brief.Summary)
+	}
+
+	if h.CouncilManager != nil {
+		h.CouncilManager.HandleCouncilBrief(councilID, roleName, &brief)
+	}
+
+	logData := map[string]interface{}{
+		"event":              "council_brief_received",
+		"council_id":         councilID,
+		"role_name":          roleName,
+		"project_name":       brief.ProjectName,
+		"repository":         brief.Repository,
+		"brief_url":          brief.BriefURL,
+		"ucxl_address":       brief.UCXLAddress,
+		"hmmm_topic":         brief.HMMMTopic,
+		"expected_artifacts": brief.ExpectedArtifacts,
+		"timestamp":          time.Now().Format(time.RFC3339),
+	}
+
+	if _, err := h.hypercoreLog.Append(logging.NetworkEvent, logData); err != nil {
+		fmt.Printf("Failed to log council brief: %v\n", err)
+	}
+
+	response := map[string]interface{}{
+		"status":     "received",
+		"council_id": councilID,
+		"role_name":  roleName,
+		"timestamp":  time.Now().Unix(),
+	}
+
+	w.WriteHeader(http.StatusAccepted)
+	json.NewEncoder(w).Encode(response)
+}