feat: add metacognition, reflection, consolidation, narrative and notifications

Phase 10. Metacognition is a cognitive process with deterministic self-checks (insufficient evidence, single-source reliance, model output without evidence, repeated failed hypotheses, stale contradictions, calibration overconfidence); its warnings compete for attention and, when admitted, add counter-evidence or open an investigation goal. Reflection reviews the period since the last run (prediction errors, rejected beliefs, corrections, status changes, completed goals, contradictions, calibration), turns repeated failures into procedural lessons written once, and records a reflection event; a model may only word the prose within the mind's budget. Consolidation clusters unconsolidated episodes by shared stemmed terms, creates a belief whose confidence is computed from the episodes as evidence and a semantic memory linked to each episode by derived_from, and records jobs with inputs and outputs. Wording may come from the consolidate prompt within a per-run model budget; the job says which. Operators can run, pause and reject; originals are never touched. The narrative hook keeps a five-part first-person narrative built from state and stored with narrative_updated events. The notification hook applies explicit thresholded rules, aggregates repeats within a cooldown and records suppressions with reasons. A scheduled job runs consolidation and reflection per mind, switching the runtime mode while it works. API, Background tab, notifications page with unread badge, overview narrative and warnings, CLI commands, docs/cognition.md.
2026-06-28 22:19:38 +01:00
parent 9eb873cbe6
commit 703d080d13
38 changed files with 2321 additions and 26 deletions
@@ -16,6 +16,7 @@ import (
 	"github.com/andydixon/noema/internal/beliefs"
 	"github.com/andydixon/noema/internal/brain"
 	"github.com/andydixon/noema/internal/config"
+	"github.com/andydixon/noema/internal/consolidation"
 	"github.com/andydixon/noema/internal/conversation"
 	evstore "github.com/andydixon/noema/internal/events"
 	"github.com/andydixon/noema/internal/goals"
@@ -24,8 +25,11 @@ import (
 	"github.com/andydixon/noema/internal/memory"
 	"github.com/andydixon/noema/internal/minds"
 	"github.com/andydixon/noema/internal/motivation"
+	"github.com/andydixon/noema/internal/narrative"
+	"github.com/andydixon/noema/internal/notifications"
 	"github.com/andydixon/noema/internal/observability"
 	"github.com/andydixon/noema/internal/predictions"
+	"github.com/andydixon/noema/internal/reflection"
 	"github.com/andydixon/noema/internal/scheduler"
 	"github.com/andydixon/noema/internal/security/secrets"
 	"github.com/andydixon/noema/internal/storage"
@@ -45,6 +49,10 @@ func testServer(t *testing.T) (*httptest.Server, string) {
 		Audit: audit.New(pool, log), Metrics: observability.NewMetrics(), Minds: minds.NewStore(pool), Conversations: conversation.NewStore(pool), Goals: goals.NewStore(pool), Motivation: motivation.NewStore(pool), Predictions: predictions.NewStore(pool), Beliefs: beliefs.NewStore(pool), Memory: memory.NewStore(context.Background(), pool, nil), Events: evstore.NewStore(pool, evstore.NewBus(50), nil), Migrations: migrations.FS, Started: time.Now()}
 	ctx := context.Background()
 	deps.Resolver = &predictions.Resolver{Store: deps.Predictions, Events: deps.Events, Beliefs: deps.Beliefs, Log: log}
+	deps.Narrative = narrative.NewStore(pool)
+	deps.Notifications = notifications.NewStore(pool)
+	deps.Consolidation = &consolidation.Service{DB: pool, Memory: deps.Memory, Beliefs: deps.Beliefs, Events: deps.Events, Minds: deps.Minds, Log: log}
+	deps.Reflection = &reflection.Service{DB: pool, Events: deps.Events, Beliefs: deps.Beliefs, Goals: deps.Goals, Memory: deps.Memory, Predictions: deps.Predictions, Log: log}
 	group := scheduler.NewGroup(ctx, log)
 	t.Cleanup(func() { group.Stop() })
 	deps.Brain = brain.NewManager(brain.Config{DB: pool, Events: deps.Events, Minds: deps.Minds, Registry: brain.NewRegistry(), Pool: scheduler.NewPool(2), Log: log, Metrics: deps.Metrics}, group)
@@ -0,0 +1,205 @@
+package api
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/andydixon/noema/internal/auth"
+	"github.com/andydixon/noema/internal/consolidation"
+	"github.com/andydixon/noema/internal/notifications"
+	"github.com/andydixon/noema/internal/reflection"
+	"github.com/andydixon/noema/pkg/events"
+	"github.com/andydixon/noema/pkg/ids"
+)
+
+func (s *Server) cognitionRoutes() {
+	m := s.mux
+	m.Handle("GET /api/v1/minds/{mind}/narrative", require(auth.RoleObserver, s.narrativeGet))
+	m.Handle("GET /api/v1/minds/{mind}/consolidation", require(auth.RoleObserver, s.consolidationJobs))
+	m.Handle("POST /api/v1/minds/{mind}/consolidation/run", require(auth.RoleOperator, s.consolidationRun))
+	m.Handle("POST /api/v1/minds/{mind}/consolidation/reject", require(auth.RoleOperator, s.consolidationReject))
+	m.Handle("POST /api/v1/consolidation/pause", require(auth.RoleAdministrator, s.consolidationPause))
+	m.Handle("GET /api/v1/minds/{mind}/reflections", require(auth.RoleObserver, s.reflectionsList))
+	m.Handle("POST /api/v1/minds/{mind}/reflections/run", require(auth.RoleOperator, s.reflectionRun))
+	m.Handle("GET /api/v1/notifications", require(auth.RoleObserver, s.notificationsList))
+	m.Handle("GET /api/v1/minds/{mind}/notifications", require(auth.RoleObserver, s.notificationsList))
+	m.Handle("POST /api/v1/notifications/{id}/read", require(auth.RoleObserver, s.notificationRead))
+	m.Handle("POST /api/v1/notifications/read-all", require(auth.RoleObserver, s.notificationsReadAll))
+}
+
+func (s *Server) narrativeGet(w http.ResponseWriter, r *http.Request) {
+	m, ok := s.mind(w, r)
+	if !ok {
+		return
+	}
+	n, err := s.deps.Narrative.Get(r.Context(), m.ID)
+	if err != nil {
+		fail(w, r, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, n)
+}
+
+func (s *Server) consolidationJobs(w http.ResponseWriter, r *http.Request) {
+	m, ok := s.mind(w, r)
+	if !ok {
+		return
+	}
+	jobs, err := s.deps.Consolidation.Jobs(r.Context(), m.ID, 20)
+	if err != nil {
+		fail(w, r, err)
+		return
+	}
+	if jobs == nil {
+		jobs = []consolidation.Job{}
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"items": jobs, "paused": consolidation.IsPaused(), "settings": map[string]any{"enabled": m.Config.ConsolidationEnabled, "interval": m.Config.ConsolidationInterval, "min_episodes": m.Config.ConsolidationMinEpisodes, "llm_calls": m.Config.ConsolidationLLMCalls}})
+}
+
+// RunConsolidation runs a job now for a mind; shared with the UI.
+func (s *Server) RunConsolidation(r *http.Request, mindID ids.ID) (consolidation.Job, error) {
+	m, err := s.deps.Minds.Get(r.Context(), mindID)
+	if err != nil {
+		return consolidation.Job{}, err
+	}
+	s.deps.Brain.Command(r.Context(), m.ID, "setmode", map[string]bool{"consolidating": true}) //nolint:errcheck
+	defer s.deps.Brain.Command(r.Context(), m.ID, "setmode", map[string]bool{"awake": true})   //nolint:errcheck
+	job, err := s.deps.Consolidation.Run(r.Context(), m, "operator", actor(r))
+	s.deps.Audit.Log(r.Context(), "consolidation.run", "mind", m.ID.String(), map[string]any{"job": job.ID, "status": job.Status, "produced": job.Produced})
+	return job, err
+}
+
+func (s *Server) consolidationRun(w http.ResponseWriter, r *http.Request) {
+	m, ok := s.mind(w, r)
+	if !ok {
+		return
+	}
+	job, err := s.RunConsolidation(r, m.ID)
+	if err != nil {
+		fail(w, r, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, job)
+}
+
+func (s *Server) consolidationReject(w http.ResponseWriter, r *http.Request) {
+	m, ok := s.mind(w, r)
+	if !ok {
+		return
+	}
+	var in struct {
+		MemoryID ids.ID `json:"memory_id"`
+		Reason   string `json:"reason"`
+	}
+	if err := decode(r, &in); err != nil {
+		fail(w, r, err)
+		return
+	}
+	if err := s.deps.Consolidation.Reject(r.Context(), m, in.MemoryID, in.Reason, actor(r)); err != nil {
+		fail(w, r, err)
+		return
+	}
+	s.deps.Audit.Log(r.Context(), "consolidation.reject", "memory", in.MemoryID.String(), map[string]any{"reason": in.Reason})
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func (s *Server) consolidationPause(w http.ResponseWriter, r *http.Request) {
+	var in struct {
+		Paused bool `json:"paused"`
+	}
+	if err := decode(r, &in); err != nil {
+		fail(w, r, err)
+		return
+	}
+	consolidation.SetPaused(in.Paused)
+	s.deps.Audit.Log(r.Context(), "consolidation.pause", "system", "", map[string]any{"paused": in.Paused})
+	writeJSON(w, http.StatusOK, map[string]bool{"paused": in.Paused})
+}
+
+func (s *Server) reflectionsList(w http.ResponseWriter, r *http.Request) {
+	m, ok := s.mind(w, r)
+	if !ok {
+		return
+	}
+	list, err := s.deps.Reflection.List(r.Context(), m.ID, 20)
+	if err != nil {
+		fail(w, r, err)
+		return
+	}
+	if list == nil {
+		list = []reflection.Reflection{}
+	}
+	writeJSON(w, http.StatusOK, page[reflection.Reflection]{Items: list})
+}
+
+// RunReflection runs a reflection now; shared with the UI.
+func (s *Server) RunReflection(r *http.Request, mindID ids.ID) (reflection.Reflection, error) {
+	m, err := s.deps.Minds.Get(r.Context(), mindID)
+	if err != nil {
+		return reflection.Reflection{}, err
+	}
+	s.deps.Brain.Command(r.Context(), m.ID, "setmode", map[string]bool{"reflecting": true})  //nolint:errcheck
+	defer s.deps.Brain.Command(r.Context(), m.ID, "setmode", map[string]bool{"awake": true}) //nolint:errcheck
+	ref, err := s.deps.Reflection.Run(r.Context(), m, "operator", actor(r))
+	s.deps.Audit.Log(r.Context(), "reflection.run", "mind", m.ID.String(), map[string]any{"reflection": ref.ID})
+	return ref, err
+}
+
+func (s *Server) reflectionRun(w http.ResponseWriter, r *http.Request) {
+	m, ok := s.mind(w, r)
+	if !ok {
+		return
+	}
+	ref, err := s.RunReflection(r, m.ID)
+	if err != nil {
+		fail(w, r, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, ref)
+}
+
+func (s *Server) notificationsList(w http.ResponseWriter, r *http.Request) {
+	var mind ids.ID
+	if r.PathValue("mind") != "" {
+		m, ok := s.mind(w, r)
+		if !ok {
+			return
+		}
+		mind = m.ID
+	}
+	limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
+	list, err := s.deps.Notifications.List(r.Context(), mind, r.URL.Query().Get("status"), limit)
+	if err != nil {
+		fail(w, r, err)
+		return
+	}
+	if list == nil {
+		list = []notifications.Notification{}
+	}
+	unread, _ := s.deps.Notifications.CountNew(r.Context(), mind)
+	writeJSON(w, http.StatusOK, map[string]any{"items": list, "unread": unread})
+}
+
+func (s *Server) notificationRead(w http.ResponseWriter, r *http.Request) {
+	id, err := ids.Parse(r.PathValue("id"))
+	if err != nil {
+		fail(w, r, ValidationError("bad id"))
+		return
+	}
+	if err := s.deps.Notifications.MarkRead(r.Context(), ids.Nil, id); err != nil {
+		fail(w, r, err)
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func (s *Server) notificationsReadAll(w http.ResponseWriter, r *http.Request) {
+	n, err := s.deps.Notifications.MarkAllRead(r.Context(), ids.Nil)
+	if err != nil {
+		fail(w, r, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]int64{"marked": n})
+}
+
+var _ = events.NotificationCreated
@@ -61,6 +61,7 @@ func (s *Server) routes() {
 	s.conversationRoutes()
 	s.importRoutes()
 	s.motivationRoutes()
+	s.cognitionRoutes()

 	m.HandleFunc("/api/", func(w http.ResponseWriter, r *http.Request) {
 		writeError(w, r, http.StatusNotFound, "not_found", "no such endpoint")