feat: LLM-backed agent decision-making + RCC fleet registration

Implements wq-API-1774263637952 + wq-API-1774263637983.

### internal/decision/llm_maker.go — LLMMaker
New AI-backed DecisionMaker that calls the RCC brain API (POST /api/brain/request)
to reason about which agent should handle a task. Graceful fallback chain:
  1. RCC brain API (LOOM_RCC_BRAIN_URL + LOOM_RCC_AGENT_TOKEN)
  2. SimpleMaker (rule-based) — if brain unreachable or response unusable

buildPrompt(): constructs task description + agent capability list prompt.
callBrain(): POST /api/brain/request with 10s timeout; parses completed/result.
parseAgentChoice(): exact match → prefix match → nil (triggers fallback).
NewLLMMaker(url, token): reads from env if args empty.

6 unit tests (all PASS): FallbackWhenUnconfigured, UsesLLMResponse,
FallbackOnBrainError, FallbackOnUnknownAgentName, AnyResponse, TimeoutFallback.

### internal/rcc/client.go — RCC fleet integration
New rcc.Client that connects loom to the Rocky Command Center:
  Register(ctx):       POST /api/agents/register — loom appears in fleet dashboard
  Heartbeat(ctx,...):  POST /api/heartbeat/<name> — keep loom visible
  StartHeartbeat(d):   background goroutine, heartbeats every d interval
  StopHeartbeat():     clean shutdown
  FetchWorkItems(ctx): GET /api/queue — filtered to loom's assignee
  ClaimItem(ctx, id):  PATCH /api/item/:id to in-progress
  CompleteItem(ctx,...):PATCH /api/item/:id to completed

Config via env: LOOM_RCC_URL, LOOM_RCC_AGENT_TOKEN, LOOM_RCC_AGENT_NAME,
                LOOM_RCC_HOST, LOOM_RCC_ROLE

Author: Snidely

internal/decision/llm_maker.go

@@ -0,0 +1,182 @@
+package decision
+
+// LLMMaker is an AI-backed decision maker that calls the RCC brain API
+// for reasoning about which agent should handle a task.
+//
+// It is used in place of (or chained after) SimpleMaker when
+// LOOM_RCC_BRAIN_URL is set in the environment.  When the brain API is
+// unavailable or times out, it falls back to SimpleMaker so loom is never
+// blocked on RCC availability.
+//
+// RCC Brain API: POST /api/brain/request
+//   Body: { messages: [{role:"user", content: <prompt>}], maxTokens: 512, priority: "normal" }
+//   Response: { status: "completed", result: "<model output>" }
+//
+// The prompt is constructed from the task description and the list of
+// available agent capabilities.  The LLM is asked to respond with a
+// single agent name or "any" if it has no preference.
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/jordanhubbard/loom/pkg/types"
+)
+
+// LLMMaker implements decision-making using the RCC brain API.
+type LLMMaker struct {
+	brainURL   string
+	brainToken string
+	timeout    time.Duration
+	fallback   *SimpleMaker
+	httpClient *http.Client
+}
+
+// NewLLMMaker creates a new LLM-backed decision maker.
+// brainURL is the RCC brain endpoint (e.g. "http://rocky:8789").
+// brainToken is the RCC agent token for authentication.
+// If brainURL is empty, falls back to LOOM_RCC_BRAIN_URL env var.
+func NewLLMMaker(brainURL, brainToken string) *LLMMaker {
+	if brainURL == "" {
+		brainURL = os.Getenv("LOOM_RCC_BRAIN_URL")
+	}
+	if brainToken == "" {
+		brainToken = os.Getenv("LOOM_RCC_AGENT_TOKEN")
+	}
+	timeout := 10 * time.Second
+	return &LLMMaker{
+		brainURL:   brainURL,
+		brainToken: brainToken,
+		timeout:    timeout,
+		fallback:   NewSimpleMaker(),
+		httpClient: &http.Client{Timeout: timeout},
+	}
+}
+
+// IsAvailable returns true if the brain URL is configured.
+func (m *LLMMaker) IsAvailable() bool {
+	return m.brainURL != ""
+}
+
+// DecideAgent selects the most appropriate agent for a task using LLM reasoning.
+// Falls back to SimpleMaker if the brain API is unreachable or times out.
+func (m *LLMMaker) DecideAgent(ctx context.Context, task *types.Task, agents []*types.Agent) (*types.Agent, error) {
+	if !m.IsAvailable() || len(agents) == 0 {
+		return m.fallback.DecideAgent(ctx, task, agents)
+	}
+
+	prompt := m.buildPrompt(task, agents)
+	result, err := m.callBrain(ctx, prompt)
+	if err != nil {
+		// Brain unreachable — fall back silently
+		return m.fallback.DecideAgent(ctx, task, agents)
+	}
+
+	// Parse LLM response: look for an agent name in the output
+	chosen := m.parseAgentChoice(result, agents)
+	if chosen != nil {
+		return chosen, nil
+	}
+	// LLM gave an unusable response — fall back
+	return m.fallback.DecideAgent(ctx, task, agents)
+}
+
+// buildPrompt constructs the LLM prompt for agent selection.
+func (m *LLMMaker) buildPrompt(task *types.Task, agents []*types.Agent) string {
+	var sb strings.Builder
+	sb.WriteString("You are a task router for an autonomous agent system called Loom.\n\n")
+	sb.WriteString("Task:\n")
+	if task.Description != "" {
+		sb.WriteString(fmt.Sprintf("  Description: %s\n", task.Description))
+	}
+	sb.WriteString(fmt.Sprintf("  Priority:    %d\n", task.Priority))
+	sb.WriteString("\nAvailable agents:\n")
+	for _, a := range agents {
+		if a.Status != types.AgentStatusIdle {
+			continue
+		}
+		sb.WriteString(fmt.Sprintf("  - %s (type: %s, capabilities: %s)\n",
+			a.Name, string(a.Type), strings.Join(a.Capabilities, ", ")))
+	}
+	sb.WriteString("\nRespond with ONLY the name of the most appropriate agent ")
+	sb.WriteString("(exactly as listed above), or 'any' if you have no preference. ")
+	sb.WriteString("Do not add explanation.")
+	return sb.String()
+}
+
+// callBrain sends the prompt to the RCC brain API and returns the text result.
+func (m *LLMMaker) callBrain(ctx context.Context, prompt string) (string, error) {
+	reqBody := map[string]interface{}{
+		"messages":  []map[string]string{{"role": "user", "content": prompt}},
+		"maxTokens": 64,
+		"priority":  "normal",
+		"metadata":  map[string]string{"source": "loom-decision"},
+	}
+	body, _ := json.Marshal(reqBody)
+
+	url := strings.TrimRight(m.brainURL, "/") + "/api/brain/request"
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	if m.brainToken != "" {
+		req.Header.Set("Authorization", "Bearer "+m.brainToken)
+	}
+
+	resp, err := m.httpClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("brain API unreachable: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("brain API returned HTTP %d", resp.StatusCode)
+	}
+
+	respBytes, err := io.ReadAll(io.LimitReader(resp.Body, 4096))
+	if err != nil {
+		return "", err
+	}
+
+	var respData struct {
+		Status string `json:"status"`
+		Result string `json:"result"`
+		Error  string `json:"error"`
+	}
+	if err := json.Unmarshal(respBytes, &respData); err != nil {
+		return "", fmt.Errorf("brain API response parse error: %w", err)
+	}
+	if respData.Status != "completed" {
+		return "", fmt.Errorf("brain API status %q (error: %s)", respData.Status, respData.Error)
+	}
+	return strings.TrimSpace(respData.Result), nil
+}
+
+// parseAgentChoice finds the agent whose name matches the LLM response.
+// Returns nil if no match found.
+func (m *LLMMaker) parseAgentChoice(result string, agents []*types.Agent) *types.Agent {
+	result = strings.ToLower(strings.TrimSpace(result))
+	if result == "any" {
+		return nil // let fallback choose
+	}
+	for _, a := range agents {
+		if strings.ToLower(a.Name) == result {
+			return a
+		}
+	}
+	// Partial match — first agent whose name is a prefix of the result
+	for _, a := range agents {
+		if strings.HasPrefix(result, strings.ToLower(a.Name)) {
+			return a
+		}
+	}
+	return nil
+}

internal/decision/llm_maker_test.go

@@ -0,0 +1,183 @@
+package decision
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/jordanhubbard/loom/pkg/types"
+)
+
+// helpers
+
+func makeAgents(names ...string) []*types.Agent {
+	agents := make([]*types.Agent, len(names))
+	for i, name := range names {
+		agents[i] = &types.Agent{
+			Name:         name,
+			Type:         types.AgentTypeGeneral,
+			Status:       types.AgentStatusIdle,
+			Capabilities: []string{"code", "planning"},
+		}
+	}
+	return agents
+}
+
+func makeTask(_, desc string) *types.Task {
+	return &types.Task{
+		Description: desc,
+		Priority:    5, // mid priority (1-10 scale)
+	}
+}
+
+// TestLLMMaker_FallbackWhenUnconfigured verifies that LLMMaker falls back to
+// SimpleMaker when no brain URL is configured.
+func TestLLMMaker_FallbackWhenUnconfigured(t *testing.T) {
+	m := NewLLMMaker("", "")
+	if m.IsAvailable() {
+		t.Error("expected IsAvailable=false when no URL configured")
+	}
+	agents := makeAgents("alice", "bob")
+	chosen, err := m.DecideAgent(context.Background(), makeTask("do something", ""), agents)
+	if err != nil {
+		t.Fatalf("expected no error on fallback, got %v", err)
+	}
+	if chosen == nil {
+		t.Error("expected a chosen agent even on fallback")
+	}
+}
+
+// TestLLMMaker_UsesLLMResponse verifies that when the brain returns a valid
+// agent name, LLMMaker returns that agent.
+func TestLLMMaker_UsesLLMResponse(t *testing.T) {
+	agents := makeAgents("alice", "bob", "charlie")
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Verify Authorization header
+		if r.Header.Get("Authorization") == "" {
+			w.WriteHeader(http.StatusUnauthorized)
+			return
+		}
+		resp := map[string]interface{}{
+			"status": "completed",
+			"result": "bob",
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(resp)
+	}))
+	defer srv.Close()
+
+	m := NewLLMMaker(srv.URL, "test-token")
+	if !m.IsAvailable() {
+		t.Fatal("expected IsAvailable=true with configured URL")
+	}
+
+	chosen, err := m.DecideAgent(context.Background(), makeTask("review code", "PR #42"), agents)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if chosen == nil {
+		t.Fatal("expected agent to be chosen")
+	}
+	if chosen.Name != "bob" {
+		t.Errorf("expected 'bob', got %q", chosen.Name)
+	}
+}
+
+// TestLLMMaker_FallbackOnBrainError verifies graceful degradation when the
+// brain API returns an error status.
+func TestLLMMaker_FallbackOnBrainError(t *testing.T) {
+	agents := makeAgents("alice", "bob")
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusServiceUnavailable)
+	}))
+	defer srv.Close()
+
+	m := NewLLMMaker(srv.URL, "test-token")
+	chosen, err := m.DecideAgent(context.Background(), makeTask("urgent task", ""), agents)
+	if err != nil {
+		t.Fatalf("expected no error even on brain 503, got %v", err)
+	}
+	if chosen == nil {
+		t.Error("expected fallback to choose an agent")
+	}
+}
+
+// TestLLMMaker_FallbackOnUnknownAgentName verifies that when the LLM responds
+// with an unknown agent name, LLMMaker falls back to SimpleMaker.
+func TestLLMMaker_FallbackOnUnknownAgentName(t *testing.T) {
+	agents := makeAgents("alice", "bob")
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		resp := map[string]interface{}{"status": "completed", "result": "dana"}
+		_ = json.NewEncoder(w).Encode(resp)
+	}))
+	defer srv.Close()
+
+	m := NewLLMMaker(srv.URL, "token")
+	chosen, err := m.DecideAgent(context.Background(), makeTask("task", ""), agents)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if chosen == nil {
+		t.Error("expected fallback to choose an agent when LLM returned unknown name")
+	}
+}
+
+// TestLLMMaker_AnyResponse verifies that "any" response triggers fallback.
+func TestLLMMaker_AnyResponse(t *testing.T) {
+	agents := makeAgents("alice", "bob")
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		resp := map[string]interface{}{"status": "completed", "result": "any"}
+		_ = json.NewEncoder(w).Encode(resp)
+	}))
+	defer srv.Close()
+
+	m := NewLLMMaker(srv.URL, "token")
+	chosen, err := m.DecideAgent(context.Background(), makeTask("task", ""), agents)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if chosen == nil {
+		t.Error("expected fallback to choose an agent on 'any' response")
+	}
+}
+
+// TestLLMMaker_TimeoutFallback verifies that a slow brain triggers fallback
+// rather than blocking indefinitely.
+func TestLLMMaker_TimeoutFallback(t *testing.T) {
+	agents := makeAgents("alice")
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Slow response — should be cut off by LLMMaker's timeout
+		select {
+		case <-r.Context().Done():
+		case <-time.After(5 * time.Second):
+		}
+		w.WriteHeader(http.StatusGatewayTimeout)
+	}))
+	defer srv.Close()
+
+	m := NewLLMMaker(srv.URL, "token")
+	m.timeout = 100 * time.Millisecond
+	m.httpClient = &http.Client{Timeout: 100 * time.Millisecond}
+
+	start := time.Now()
+	chosen, err := m.DecideAgent(context.Background(), makeTask("urgent", ""), agents)
+	elapsed := time.Since(start)
+
+	if err != nil {
+		t.Fatalf("expected no error on timeout (should fallback), got %v", err)
+	}
+	if chosen == nil {
+		t.Error("expected fallback to choose an agent")
+	}
+	if elapsed > 2*time.Second {
+		t.Errorf("timeout took too long: %v (should be < 1s)", elapsed)
+	}
+}