feat(ambient): evaluate loop, two-stage surfacing, snooze, config

internal/ambient/sentinel.go

@@ -150,6 +150,164 @@ func (s *Sentinel) recentForTest() []string {
 	return append([]string(nil), s.recent...)
 }
 
-// silence: keep log imported until evaluate (Task 6) uses it.
-var _ = log.Printf
-var _ = frame.MaxBriefBytes
+// Run drives the cadence loop: every cadence it evaluates, until ctx is
+// cancelled. It re-reads the cadence each cycle so SetConfig takes effect on the
+// next tick.
+func (s *Sentinel) Run(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(s.currentCadence()):
+			s.evaluate(ctx)
+		}
+	}
+}
+
+func (s *Sentinel) currentCadence() time.Duration {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.cadence
+}
+
+// SetConfig updates the cadence and mode live (next tick).
+func (s *Sentinel) SetConfig(cadence time.Duration, mode string) {
+	s.mu.Lock()
+	if cadence > 0 {
+		s.cadence = cadence
+	}
+	s.mode = normalizeMode(mode)
+	s.mu.Unlock()
+}
+
+// Snooze mutes the sentinel for d: it clears the current line and episode and
+// suppresses evaluation until the window elapses.
+func (s *Sentinel) Snooze(d time.Duration) {
+	s.mu.Lock()
+	s.snoozeUntil = s.deps.Clock().Add(d)
+	changed := s.line != ""
+	s.line = ""
+	s.drifting = false
+	s.committed = false
+	s.mu.Unlock()
+	if changed {
+		s.fireOnChange()
+	}
+}
+
+// evaluate runs one decision cycle. See the spec's "Trigger discipline."
+func (s *Sentinel) evaluate(ctx context.Context) {
+	s.mu.Lock()
+	if s.mode == modeOff {
+		s.mu.Unlock()
+		return
+	}
+	if s.deps.Clock().Before(s.snoozeUntil) {
+		s.mu.Unlock()
+		return
+	}
+	if s.activeModeLocked() != "" {
+		// A mode is coaching; stay silent and clear any stale line.
+		changed := s.clearLocked()
+		s.mu.Unlock()
+		if changed {
+			s.fireOnChange()
+		}
+		return
+	}
+	titles := append([]string(nil), s.recent...)
+	joined := strings.Join(titles, "\n")
+	// Cheap gate: nothing new to judge and we are on-track -> skip the brain call.
+	if joined == s.lastEvalTitles && s.line == "" {
+		s.mu.Unlock()
+		return
+	}
+	win := s.lastWindow
+	mode := s.mode
+	judge := s.deps.AI
+	s.mu.Unlock()
+
+	if judge == nil {
+		return
+	}
+	cctx, cancel := context.WithTimeout(ctx, evalTimeout)
+	fr := frame.Assemble(cctx, s.deps.Knowledge, s.deps.Tasks)
+	msg, err := judge.AmbientDrift(cctx, fr, titles)
+	cancel()
+
+	s.mu.Lock()
+	s.lastEvalTitles = joined
+	if err != nil {
+		s.mu.Unlock()
+		log.Printf("ambient: drift judge failed: %v", err)
+		return // never fabricate drift; leave the prior line intact
+	}
+
+	if msg == "" { // on-track
+		changed := s.clearLocked()
+		s.mu.Unlock()
+		if changed {
+			s.fireOnChange()
+		}
+		return
+	}
+
+	if !s.drifting { // new episode: show the line, no toast yet
+		s.line = msg
+		s.drifting = true
+		s.committed = false
+		s.mu.Unlock()
+		s.fireOnChange()
+		return
+	}
+
+	// Sustained drift. Commit once: record memory, and toast in notify mode.
+	changed := s.line != msg
+	s.line = msg
+	if s.committed {
+		s.mu.Unlock()
+		if changed {
+			s.fireOnChange()
+		}
+		return
+	}
+	s.committed = true
+	now := s.deps.Clock()
+	mem := s.deps.Memory
+	notifier := s.deps.Notifier
+	s.mu.Unlock()
+
+	if mem != nil {
+		ev := memory.Event{Kind: kindAmbientNudge, At: now, Data: map[string]any{
+			"message": msg, "title": win.Title, "class": win.Class,
+		}}
+		if e := mem.Record(ctx, ev); e != nil {
+			log.Printf("ambient: memory record: %v", e)
+		}
+	}
+	if mode == modeNotify && notifier != nil {
+		if e := notifier.Notify(ctx, "Keel — drift", msg); e != nil {
+			log.Printf("ambient: notify: %v", e)
+		}
+	}
+	s.fireOnChange()
+}
+
+// clearLocked resets line + episode state and reports whether the line changed.
+// Caller holds mu.
+func (s *Sentinel) clearLocked() bool {
+	changed := s.line != ""
+	s.line = ""
+	s.drifting = false
+	s.committed = false
+	return changed
+}
+
+// activeModeLocked reads the active-mode kind, treating a nil hook as idle.
+// Caller holds mu (the hook does no locking on the sentinel).
+func (s *Sentinel) activeModeLocked() string {
+	if s.deps.ActiveMode == nil {
+		return ""
+	}
+	return s.deps.ActiveMode()
+}