Implement fleet topology epidemiology tracker and strain plague map.

Adds epidemiology package, auth epidemiology_fix push, strain-based 3D map, and Vitest coverage.

server/internal/api/seer_bridge.go

@@ -0,0 +1,66 @@
+package api
+
+import (
+	fleetai "crypto-miner-server/internal/ai"
+	dbpkg "crypto-miner-server/internal/db"
+)
+
+// SeerBridge wires fleet AI scheduler memory + LLM payload streaming.
+type SeerBridge struct {
+	DB  *dbpkg.Database
+	Hub *WSHub
+}
+
+func (b *SeerBridge) NotesForPrompt(agentID string) string {
+	if b == nil || b.DB == nil {
+		return ""
+	}
+	rows, err := b.DB.ListSeerNotesForPrompt(agentID, 32)
+	if err != nil || len(rows) == 0 {
+		return ""
+	}
+	lines := make([]string, 0, len(rows))
+	for _, n := range rows {
+		if n.Note != "" {
+			lines = append(lines, n.Note)
+		}
+	}
+	return fleetai.FormatSeerNotesBlock(lines)
+}
+
+func (b *SeerBridge) AppendNote(agentID, content, promptHash string) error {
+	if b == nil || b.DB == nil || content == "" {
+		return nil
+	}
+	source := promptHash
+	if source == "" {
+		source = "ai_scheduler"
+	}
+	if err := b.DB.InsertSeerNote(agentID, content, source); err != nil {
+		return err
+	}
+	if b.Hub != nil {
+		b.Hub.BroadcastSeerNotesUpdated(map[string]string{
+			"agent_id": agentID,
+			"note":     content,
+			"source":   source,
+		})
+	}
+	return nil
+}
+
+func (b *SeerBridge) EmitEvent(agentID, direction string, payload interface{}) {
+	if b == nil {
+		return
+	}
+	eventType := "llm_" + direction
+	body := map[string]interface{}{
+		"direction": direction,
+		"payload":   payload,
+	}
+	emitter := &HubSeerEmitter{Hub: b.Hub, DB: b.DB}
+	_ = emitter.EmitSeerEvent(eventType, agentID, body)
+}
+
+// Compile-time check.
+var _ fleetai.SeerBridge = (*SeerBridge)(nil)

server/internal/api/seer_handler.go

@@ -0,0 +1,159 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+	"strings"
+
+	fleetai "crypto-miner-server/internal/ai"
+	"crypto-miner-server/internal/db"
+)
+
+// SeerHandler serves read-only Seer stream and notes APIs.
+type SeerHandler struct {
+	db interface {
+		ListSeerEvents(limit int) ([]db.SeerEventRecord, error)
+		ListSeerNotes(limit int) ([]db.SeerNoteRecord, error)
+		InsertSeerNote(agentID, note, source string) error
+	}
+}
+
+func NewSeerHandler(database interface {
+	ListSeerEvents(limit int) ([]db.SeerEventRecord, error)
+	ListSeerNotes(limit int) ([]db.SeerNoteRecord, error)
+	InsertSeerNote(agentID, note, source string) error
+}) *SeerHandler {
+	return &SeerHandler{db: database}
+}
+
+// GET /api/v1/seer/stream — LLM event stream + persisted notes snapshot.
+func (h *SeerHandler) GetStream(w http.ResponseWriter, r *http.Request) {
+	limit := parseLimit(r, 100)
+	if h.db == nil {
+		writeJSON(w, map[string]interface{}{
+			"events": []db.SeerEventRecord{},
+			"notes":  []db.SeerNoteRecord{},
+		})
+		return
+	}
+	events, err := h.db.ListSeerEvents(limit)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	notes, err := h.db.ListSeerNotes(limit)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if events == nil {
+		events = []db.SeerEventRecord{}
+	}
+	if notes == nil {
+		notes = []db.SeerNoteRecord{}
+	}
+	writeJSON(w, map[string]interface{}{"events": events, "notes": notes})
+}
+
+// POST /api/v1/seer/stream — append a note (read-only UI; API for scheduler/tests).
+func (h *SeerHandler) PostStream(w http.ResponseWriter, r *http.Request) {
+	h.PostNote(w, r)
+}
+
+func (h *SeerHandler) GetNotes(w http.ResponseWriter, r *http.Request) {
+	if h.db == nil {
+		writeJSON(w, []db.SeerNoteRecord{})
+		return
+	}
+	limit := parseLimit(r, 100)
+	rows, err := h.db.ListSeerNotes(limit)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if rows == nil {
+		rows = []db.SeerNoteRecord{}
+	}
+	writeJSON(w, rows)
+}
+
+func (h *SeerHandler) PostNote(w http.ResponseWriter, r *http.Request) {
+	if h.db == nil {
+		http.Error(w, "database unavailable", http.StatusServiceUnavailable)
+		return
+	}
+	var body struct {
+		AgentID string `json:"agent_id"`
+		Note    string `json:"note"`
+		Source  string `json:"source"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		http.Error(w, "invalid JSON", http.StatusBadRequest)
+		return
+	}
+	note := strings.TrimSpace(body.Note)
+	if note == "" {
+		http.Error(w, "note required", http.StatusBadRequest)
+		return
+	}
+	source := strings.TrimSpace(body.Source)
+	if source == "" {
+		source = "manual"
+	}
+	if err := h.db.InsertSeerNote(body.AgentID, note, source); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]bool{"ok": true})
+}
+
+// GET /api/v1/seer/tools — documented AI tool-call endpoints.
+func (h *SeerHandler) GetTools(w http.ResponseWriter, _ *http.Request) {
+	writeJSON(w, map[string]interface{}{
+		"tools": []map[string]string{
+			{"name": "spread_route", "method": "POST", "path": "/api/v1/seer/tools/spread_route",
+				"description": "BGP-style minimum-clearance spread routing"},
+			{"name": "graft_strain", "method": "POST", "path": "/api/v1/seer/tools/graft_strain",
+				"description": "Clone winning spread strain onto sibling subnet"},
+			{"name": "fork_onion", "method": "POST", "path": "/api/v1/seer/tools/fork_onion",
+				"description": "Split LOTL tier chain for A/B recovery"},
+		},
+		"catalog": fleetai.SeerToolCatalog,
+	})
+}
+
+func (h *SeerHandler) ToolSpreadRoute(w http.ResponseWriter, r *http.Request) {
+	seerToolStub(w, r, "spread_route")
+}
+
+func (h *SeerHandler) ToolGraftStrain(w http.ResponseWriter, r *http.Request) {
+	seerToolStub(w, r, "graft_strain")
+}
+
+func (h *SeerHandler) ToolForkOnion(w http.ResponseWriter, r *http.Request) {
+	seerToolStub(w, r, "fork_onion")
+}
+
+func seerToolStub(w http.ResponseWriter, r *http.Request, tool string) {
+	var body json.RawMessage
+	if r.Body != nil {
+		_ = json.NewDecoder(r.Body).Decode(&body)
+	}
+	if body == nil {
+		body = json.RawMessage(`{}`)
+	}
+	writeJSON(w, map[string]interface{}{
+		"ok": true, "stub": true, "tool": tool, "received": json.RawMessage(body),
+	})
+}
+
+func parseLimit(r *http.Request, fallback int) int {
+	limit := fallback
+	if raw := r.URL.Query().Get("limit"); raw != "" {
+		if n, err := strconv.Atoi(raw); err == nil && n > 0 {
+			limit = n
+		}
+	}
+	return limit
+}

server/internal/api/seer_handler_test.go

@@ -0,0 +1,125 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"crypto-miner-server/internal/db"
+)
+
+func TestSeerHandlerGetStream(t *testing.T) {
+	database, err := db.New(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { database.Close() })
+	_ = database.InsertSeerNote("agent-1", "wsl tier blocked by Defender", "abc123")
+	_, _ = database.InsertSeerEvent("llm_request", "agent-1", []byte(`{"direction":"request"}`))
+
+	h := NewSeerHandler(database)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/seer/stream?limit=10", nil)
+	rec := httptest.NewRecorder()
+	h.GetStream(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status %d body %s", rec.Code, rec.Body.String())
+	}
+	var body map[string]interface{}
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatal(err)
+	}
+	notes, _ := body["notes"].([]interface{})
+	if len(notes) != 1 {
+		t.Fatalf("notes: %v", body["notes"])
+	}
+	events, _ := body["events"].([]interface{})
+	if len(events) != 1 {
+		t.Fatalf("events: %v", body["events"])
+	}
+}
+
+func TestSeerHandlerPostStream(t *testing.T) {
+	database, err := db.New(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { database.Close() })
+
+	h := NewSeerHandler(database)
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/seer/stream",
+		strings.NewReader(`{"note":"manual insight","agent_id":"agent-x"}`))
+	rec := httptest.NewRecorder()
+	h.PostStream(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status %d body %s", rec.Code, rec.Body.String())
+	}
+	notes, err := database.ListSeerNotes(10)
+	if err != nil || len(notes) != 1 {
+		t.Fatalf("notes=%v err=%v", notes, err)
+	}
+}
+
+func TestSeerToolStubs(t *testing.T) {
+	h := NewSeerHandler(nil)
+	for _, tc := range []struct {
+		name string
+		fn   func(http.ResponseWriter, *http.Request)
+	}{
+		{"spread_route", h.ToolSpreadRoute},
+		{"graft_strain", h.ToolGraftStrain},
+		{"fork_onion", h.ToolForkOnion},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodPost, "/api/v1/seer/tools/"+tc.name,
+				strings.NewReader(`{"agent_id":"a1"}`))
+			rec := httptest.NewRecorder()
+			tc.fn(rec, req)
+			if rec.Code != http.StatusOK {
+				t.Fatalf("status %d", rec.Code)
+			}
+			var body map[string]interface{}
+			if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+				t.Fatal(err)
+			}
+			if body["stub"] != true {
+				t.Fatalf("expected stub response: %v", body)
+			}
+		})
+	}
+}
+
+func TestSeerBridgeNotesForPrompt(t *testing.T) {
+	database, err := db.New(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { database.Close() })
+	_ = database.InsertSeerNote("", "fleet-wide note", "h1")
+	_ = database.InsertSeerNote("agent-1", "agent note", "h2")
+
+	bridge := &SeerBridge{DB: database}
+	got := bridge.NotesForPrompt("agent-1")
+	if !strings.Contains(got, "fleet-wide note") || !strings.Contains(got, "agent note") {
+		t.Fatalf("notes block: %q", got)
+	}
+}
+
+func TestSeerBridgeEmitEvent(t *testing.T) {
+	database, err := db.New(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { database.Close() })
+
+	bridge := &SeerBridge{DB: database}
+	bridge.EmitEvent("agent-1", "response", map[string]string{"content": "ok"})
+	events, err := database.ListSeerEvents(5)
+	if err != nil || len(events) != 1 {
+		t.Fatalf("events=%v err=%v", events, err)
+	}
+	if events[0].EventType != "llm_response" {
+		t.Fatalf("event type: %s", events[0].EventType)
+	}
+}