nomos+web: streaming, provider routing, event gap-fill, embedded UI; fix approval FK & session context

Agent (cmd/nomos):
- Stream LLM tokens via NewStreaming; emit text_delta then final text.
- OpenRouter provider routing: data_collection=deny (ZDR) + require_parameters;
  NOMOS_PROVIDER_SORT opt-in; Exacto via model suffix.
- Multi-turn: reload session history into context; UI passes session id.
- Fix agent_activity logging (agent_id/session_id) and mcpClient data race.

Events (live control-room feed):
- approval.created (mcp), approval.decided (api), execution.completed/failed
  (approved-action path), signal.raised/resolved + health.changed (scheduler,
  transition-gated).

Fixes:
- createApproval FK violation (reuse execution entity) — the agent's only
  write path; log the previously-swallowed errors.

Web UI:
- Embed web/dist via //go:embed (single binary); Dockerfile builds SPA into
  the Go stage; committed .gitkeep placeholder keeps backend-only builds green.
- Caddy: Authentik-gated /agent/* -> nomos so the UI reaches the agent
  same-origin in production.

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

internal/httpapi/api_test.go

@@ -93,7 +93,7 @@ func newTestHandler(t *testing.T, cfg config.Config) http.Handler {
 		}
 	}
 
-	return NewHandler(handlerCtx, pool, cfg)
+	return NewHandler(handlerCtx, pool, cfg, nil)
 }
 
 func get(t *testing.T, h http.Handler, path string, headers map[string]string) (*httptest.ResponseRecorder, map[string]any) {

internal/httpapi/phase3.go

@@ -122,6 +122,16 @@ func resolveHostSSH(ctx context.Context, pool *db.Pool, entitySlug string) (stri
 
 // executeApprovedAction runs a gated action after operator approval.
 // Runs in a background goroutine to not block the HTTP response.
+// emitExecutionEvent records an execution lifecycle event for SSE fan-out so
+// the control room can watch approved actions run to completion live.
+func emitExecutionEvent(ctx context.Context, pool *db.Pool, execID uuid.UUID, status string, detail map[string]any) {
+	severity := "info"
+	if status == "failed" {
+		severity = "warning"
+	}
+	_ = observability.Event(ctx, sqlcgen.New(pool), "execution."+status, &execID, severity, "actuator", "", detail)
+}
+
 func executeApprovedAction(ctx context.Context, pool *db.Pool, execID uuid.UUID, targetSlug string, actionStr string) {
 	slog.Info("httpapi: executing approved action", "execution_id", execID, "target", targetSlug, "action", actionStr)
 
@@ -130,6 +140,7 @@ func executeApprovedAction(ctx context.Context, pool *db.Pool, execID uuid.UUID,
 		slog.Error("httpapi: resolve host for approved execution", "error", err, "target", targetSlug)
 		pool.Exec(ctx, `UPDATE executions SET status='failed', result=$2::jsonb WHERE entity_id=$1`,
 			execID, fmt.Sprintf(`{"error":"%s"}`, err.Error()))
+		emitExecutionEvent(ctx, pool, execID, "failed", map[string]any{"target": targetSlug, "error": err.Error()})
 		return
 	}
 
@@ -186,6 +197,10 @@ func executeApprovedAction(ctx context.Context, pool *db.Pool, execID uuid.UUID,
 	pool.Exec(ctx, `UPDATE executions SET status=$2, result=$3::jsonb, duration_ms=$4, verified=$5, started_at=$6, completed_at=$7 WHERE entity_id=$1`,
 		execID, status, result, durationMs, verified, startedAt, time.Now())
 
+	emitExecutionEvent(ctx, pool, execID, status, map[string]any{
+		"action": action, "target": targetSlug, "duration_ms": durationMs,
+	})
+
 	slog.Info("httpapi: approved action executed",
 		"execution_id", execID, "action", action, "status", status, "duration_ms", durationMs)
 }
@@ -947,6 +962,12 @@ func (s *Server) DecideApproval(ctx context.Context, req gen.DecideApprovalReque
 		return nil, auditErr
 	}
 
+	// Emit for SSE fan-out (in-tx; NOTIFY fires post-commit).
+	if evErr := observability.Event(ctx, q, "approval.decided", &id, "info", "api", "",
+		map[string]any{"decision": status, "actor": actor}); evErr != nil {
+		return nil, evErr
+	}
+
 	// On approve: execute the linked gated command.
 	if status == "approved" {
 		var execID, targetID uuid.UUID

internal/httpapi/server.go

@@ -15,6 +15,9 @@ import (
 	"log/slog"
 	"math/big"
 	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
 	"strings"
 	"sync"
 	"time"
@@ -66,7 +69,7 @@ type secretsBackend interface {
 // holds a dedicated pooled connection for LISTEN. Callers MUST cancel ctx
 // before closing the pool — otherwise the held connection never releases
 // and pool.Close() deadlocks.
-func NewHandler(ctx context.Context, pool *db.Pool, cfg config.Config) http.Handler {
+func NewHandler(ctx context.Context, pool *db.Pool, cfg config.Config, uiHandler http.Handler) http.Handler {
 	s := &Server{
 		pool:      pool,
 		cfg:       cfg,
@@ -148,6 +151,24 @@ func NewHandler(ctx context.Context, pool *db.Pool, cfg config.Config) http.Hand
 	}
 	r.With(combinedAuth(cfg)).Handle("/mcp", mcphandler.NewHandler(pool, cfg.MCPBearerToken, nomosAgentID))
 
+	r.Get("/ui/*", func(w http.ResponseWriter, req *http.Request) {
+		if uiHandler != nil {
+			uiHandler.ServeHTTP(w, req)
+		}
+	})
+	r.Get("/ui", func(w http.ResponseWriter, req *http.Request) {
+		http.Redirect(w, req, "/ui/", http.StatusMovedPermanently)
+	})
+	r.Get("/", func(w http.ResponseWriter, req *http.Request) {
+		http.Redirect(w, req, "/ui/", http.StatusMovedPermanently)
+	})
+
+	if nomosURL := os.Getenv("NOMOS_PROXY_URL"); nomosURL != "" {
+		target, _ := url.Parse(nomosURL)
+		proxy := httputil.NewSingleHostReverseProxy(target)
+		r.Mount("/agent", http.StripPrefix("/agent", proxy))
+	}
+
 	return r
 }
 
@@ -484,10 +505,10 @@ func requestLogger(next http.Handler) http.Handler {
 
 // ListenAndServe runs the API server with graceful shutdown on ctx cancel
 // (SG4): stop accepting, drain in-flight for up to 30s, then exit.
-func ListenAndServe(ctx context.Context, pool *db.Pool, cfg config.Config) error {
+func ListenAndServe(ctx context.Context, pool *db.Pool, cfg config.Config, uiHandler http.Handler) error {
 	srv := &http.Server{
 		Addr:              cfg.APIListen,
-		Handler:           NewHandler(ctx, pool, cfg),
+		Handler:           NewHandler(ctx, pool, cfg, uiHandler),
 		ReadHeaderTimeout: 10 * time.Second,
 	}
 

internal/mcp/server.go

@@ -14,6 +14,8 @@ import (
 	"time"
 
 	"github.com/dtoro/oikos/internal/db"
+	"github.com/dtoro/oikos/internal/db/sqlcgen"
+	"github.com/dtoro/oikos/internal/observability"
 	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/google/uuid"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
@@ -968,13 +970,27 @@ func resolveHost(ctx context.Context, pool *db.Pool, entitySlug string) (hostIP
 }
 
 func createApproval(ctx context.Context, pool *db.Pool, execID, targetID uuid.UUID, action, params, riskClass string) {
-	approvalID, _ := uuid.NewV7()
 	payload := fmt.Sprintf(`{"action":"%s","params":"%s","execution_id":"%s"}`, action, params, execID)
-	pool.Exec(ctx, `
+	// approvals.entity_id is PK + FK to entities(id). Reuse the execution's
+	// entity (already inserted by request_execution) so the FK is satisfied —
+	// a fresh UUID here had no matching entities row, so the INSERT silently
+	// failed, orphaning the execution and never alerting the operator. One
+	// execution maps to at most one approval, so the 1:1 identity holds.
+	if _, err := pool.Exec(ctx, `
 		INSERT INTO approvals (entity_id, subject_entity_id, action, risk_class,
 			kind, payload, status, expires_at, created_at)
 		VALUES ($1, $2, $3, $4, 'execution', $5::jsonb, 'pending',
 			now() + interval '1 hour', now())`,
-		approvalID, targetID, action, riskClass, payload)
-	pool.Exec(ctx, `UPDATE executions SET approval_id = $2 WHERE entity_id = $1`, execID, approvalID)
+		execID, targetID, action, riskClass, payload); err != nil {
+		slog.Error("createApproval: insert approval", "error", err, "execution", execID)
+		return
+	}
+	if _, err := pool.Exec(ctx, `UPDATE executions SET approval_id = $1 WHERE entity_id = $1`, execID); err != nil {
+		slog.Error("createApproval: link approval to execution", "error", err, "execution", execID)
+	}
+
+	// Emit for SSE fan-out — the operator-facing moment: an agent-requested
+	// gated action is now awaiting a decision.
+	_ = observability.Event(ctx, sqlcgen.New(pool), "approval.created", &execID, "warning", "mcp", "",
+		map[string]any{"action": action, "params": params, "risk_class": riskClass})
 }

internal/scheduler/scheduler.go

@@ -16,6 +16,7 @@ import (
 	"github.com/dtoro/oikos/internal/config"
 	"github.com/dtoro/oikos/internal/db"
 	"github.com/dtoro/oikos/internal/db/sqlcgen"
+	"github.com/dtoro/oikos/internal/observability"
 	"github.com/google/uuid"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/sys/unix"
@@ -98,6 +99,8 @@ func runCheck(ctx context.Context, pool *db.Pool, cd sqlcgen.ListEnabledCheckDef
 			"entity", cd.EntitySlug, "kind", cd.Kind, "error", checkErr)
 	}
 
+	prevHealth := currentHealth(ctx, pool, cd.EntityID)
+
 	if signalKind == "" || health == "healthy" {
 		// Recovery: resolve any open signal for this check
 		resolveSignal(ctx, pool, cd.EntityID, cd.EntitySlug)
@@ -108,6 +111,10 @@ func runCheck(ctx context.Context, pool *db.Pool, cd sqlcgen.ListEnabledCheckDef
 			LastCheckAt: &[]time.Time{time.Now()}[0],
 			Details:     []byte(`{}`),
 		})
+		if prevHealth != "" && prevHealth != "healthy" {
+			emitSchedulerEvent(ctx, pool, "health.changed", cd.EntityID, "info",
+				map[string]any{"slug": cd.EntitySlug, "from": prevHealth, "to": "healthy"})
+		}
 		return
 	}
 
@@ -140,17 +147,47 @@ func runCheck(ctx context.Context, pool *db.Pool, cd sqlcgen.ListEnabledCheckDef
 		Details:     []byte(`{}`),
 	})
 	_ = sig // used for flap detection below
+
+	// Emit only on transition into failure so a persistently-down entity
+	// doesn't flood the stream every tick.
+	if prevHealth == "" || prevHealth == "healthy" {
+		emitSchedulerEvent(ctx, pool, "signal.raised", cd.EntityID, severity,
+			map[string]any{"slug": cd.EntitySlug, "kind": signalKind, "evidence": evidence})
+	}
+	if prevHealth != health {
+		emitSchedulerEvent(ctx, pool, "health.changed", cd.EntityID, severity,
+			map[string]any{"slug": cd.EntitySlug, "from": prevHealth, "to": health})
+	}
+}
+
+// currentHealth reads the last recorded health for an entity, or "" if none.
+func currentHealth(ctx context.Context, pool *db.Pool, entityID uuid.UUID) string {
+	var health string
+	if err := pool.QueryRow(ctx,
+		`SELECT health FROM entity_status WHERE entity_id = $1`, entityID).Scan(&health); err != nil {
+		return ""
+	}
+	return health
+}
+
+// emitSchedulerEvent records a scheduler-sourced event for SSE fan-out.
+func emitSchedulerEvent(ctx context.Context, pool *db.Pool, eventType string, entityID uuid.UUID, severity string, data map[string]any) {
+	_ = observability.Event(ctx, sqlcgen.New(pool), eventType, &entityID, severity, "scheduler", "", data)
 }
 
 // resolveSignal resolves any open signal for the given check entity.
 func resolveSignal(ctx context.Context, pool *db.Pool, entityID uuid.UUID, slug string) {
 	q := sqlcgen.New(pool)
 	// Check if there's an open signal on this entity
-	_, err := pool.Exec(ctx, `UPDATE signals SET state = 'resolved', updated_at = now()
+	tag, err := pool.Exec(ctx, `UPDATE signals SET state = 'resolved', updated_at = now()
 		WHERE entity_id = $1 AND state = 'raised'`, entityID)
 	if err != nil {
 		return
 	}
+	if tag.RowsAffected() > 0 {
+		emitSchedulerEvent(ctx, pool, "signal.resolved", entityID, "info",
+			map[string]any{"slug": slug})
+	}
 	_ = q.UpsertEntityStatus(ctx, sqlcgen.UpsertEntityStatusParams{
 		EntityID:    entityID,
 		Health:      "healthy",