feat(memory): proactive engagement core - follow-up capture, open loops, nudges engine

- recall-time predicted intents are now captured (>=0.6 confidence, cap 3)
  instead of discarded, exposed via ExtendedMemory.LastFollowUps and
  MemoryManager.FollowUpSuggestions - zero extra LLM cost
- the extractor now emits 'question' atoms (unanswered user questions)
  and 'goal' atoms (stated intentions); new OpenLoops query surfaces
  them as the blind-spot data source
- new ProactiveNudges engine: one LLM call synthesizes concise nudges
  from open loops, stale goals, and user-model focus; persisted
  anti-annoyance ledger (nudges.json) enforces an opt-in master switch
  (default off), a daily cap (1), and a per-kind cooldown (24h);
  preview (ProactiveNudges) never consumes the budget; all failures
  degrade to empty so proactivity can never break a turn
- config: 6 new memory.extended keys with env plumbing

Author: jkyberneees

internal/config/loader.go

@@ -1103,6 +1103,48 @@ func LoadConfig(cli CLIFlags) ResolvedConfig {
 		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
 		cfg.Memory.Extended.FollowUpAnticipationEnabled = v
 	}
+	if v := envBool("MEMORY_EXTENDED_FOLLOW_UP_SUGGESTIONS_ENABLED"); v != nil {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.FollowUpSuggestionsEnabled = v
+	}
+	if v := envFloat("MEMORY_EXTENDED_FOLLOW_UP_SUGGESTION_MIN_CONFIDENCE"); v > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.FollowUpSuggestionMinConfidence = float32(v)
+	}
+	if v := envBool("MEMORY_EXTENDED_PROACTIVE_NUDGES_ENABLED"); v != nil {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.ProactiveNudgesEnabled = v
+	}
+	if v := envInt("MEMORY_EXTENDED_NUDGE_MAX_PER_DAY"); v > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.NudgeMaxPerDay = v
+	}
+	if v := envInt("MEMORY_EXTENDED_NUDGE_COOLDOWN_HOURS"); v > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.NudgeCooldownHours = v
+	}
+	if v := envInt("MEMORY_EXTENDED_NUDGE_STALE_GOAL_DAYS"); v > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.NudgeStaleGoalDays = v
+	}
 
 	// Guard env overrides
 	if v := envString("GUARD_PROVIDER"); v != "" {

internal/config/loader_test.go

@@ -1557,6 +1557,39 @@ func TestLoadConfig_ExtendedMemoryEnv(t *testing.T) {
 	}
 }
 
+func TestLoadConfig_ExtendedMemoryProactiveEnv(t *testing.T) {
+	t.Setenv("HOME", t.TempDir())
+	t.Setenv("ODEK_MEMORY_EXTENDED_FOLLOW_UP_SUGGESTIONS_ENABLED", "false")
+	t.Setenv("ODEK_MEMORY_EXTENDED_FOLLOW_UP_SUGGESTION_MIN_CONFIDENCE", "0.75")
+	t.Setenv("ODEK_MEMORY_EXTENDED_PROACTIVE_NUDGES_ENABLED", "true")
+	t.Setenv("ODEK_MEMORY_EXTENDED_NUDGE_MAX_PER_DAY", "3")
+	t.Setenv("ODEK_MEMORY_EXTENDED_NUDGE_COOLDOWN_HOURS", "12")
+	t.Setenv("ODEK_MEMORY_EXTENDED_NUDGE_STALE_GOAL_DAYS", "14")
+	cfg := LoadConfig(CLIFlags{})
+	if cfg.Memory.Extended == nil {
+		t.Fatal("Extended memory config not loaded from env")
+	}
+	ext := cfg.Memory.Extended
+	if ext.FollowUpSuggestionsEnabled == nil || *ext.FollowUpSuggestionsEnabled {
+		t.Error("FollowUpSuggestionsEnabled should be false")
+	}
+	if ext.FollowUpSuggestionMinConfidence != 0.75 {
+		t.Errorf("FollowUpSuggestionMinConfidence = %v, want 0.75", ext.FollowUpSuggestionMinConfidence)
+	}
+	if ext.ProactiveNudgesEnabled == nil || !*ext.ProactiveNudgesEnabled {
+		t.Error("ProactiveNudgesEnabled should be true")
+	}
+	if ext.NudgeMaxPerDay != 3 {
+		t.Errorf("NudgeMaxPerDay = %d, want 3", ext.NudgeMaxPerDay)
+	}
+	if ext.NudgeCooldownHours != 12 {
+		t.Errorf("NudgeCooldownHours = %d, want 12", ext.NudgeCooldownHours)
+	}
+	if ext.NudgeStaleGoalDays != 14 {
+		t.Errorf("NudgeStaleGoalDays = %d, want 14", ext.NudgeStaleGoalDays)
+	}
+}
+
 func TestLoadConfig_ExtendedMemoryCLIOverridesEnv(t *testing.T) {
 	t.Setenv("HOME", t.TempDir())
 	t.Setenv("ODEK_MEMORY_EXTENDED_MAX_SIZE_MB", "200")

internal/memory/extended/config.go

@@ -16,32 +16,38 @@ import (
 
 // Config controls the Extended Memory subsystem.
 type Config struct {
-	Enabled                        *bool             `json:"enabled,omitempty"`
-	MaxSizeMB                      int               `json:"max_size_mb,omitempty"`
-	SemanticSearchTopK             int               `json:"semantic_search_top_k,omitempty"`
-	SemanticSearchOverfetch        int               `json:"semantic_search_overfetch,omitempty"`
-	SemanticSearchMinScore         float32           `json:"semantic_search_min_score,omitempty"`
-	SemanticSearchRerank           *bool             `json:"semantic_search_rerank,omitempty"`
-	AtomMaxChars                   int               `json:"atom_max_chars,omitempty"`
-	MemoryBudgetChars              int               `json:"memory_budget_chars,omitempty"`
-	DecayHalfLifeDays              int               `json:"decay_half_life_days,omitempty"`
-	QuarantineTTLDays              int               `json:"quarantine_ttl_days,omitempty"`
-	EvictionPolicy                 string            `json:"eviction_policy,omitempty"`
-	PredictiveIntents              int               `json:"predictive_intents,omitempty"`
-	AutoExtractPerTurn             *bool             `json:"auto_extract_per_turn,omitempty"`
-	InferUserState                 *bool             `json:"infer_user_state,omitempty"`
-	UserStateTurnInterval          int               `json:"user_state_turn_interval,omitempty"`
-	UserStateMaxPending            int               `json:"user_state_max_pending,omitempty"`
-	AssociationsEnabled            *bool             `json:"associations_enabled,omitempty"`
-	AssociationSemanticTopK        int               `json:"association_semantic_top_k,omitempty"`
-	SemanticDedupThreshold         *float32          `json:"semantic_dedup_threshold,omitempty"`
-	ConsolidateSimilarityThreshold float32           `json:"consolidate_similarity_threshold,omitempty"`
-	ProactiveReturnAfterBreak      *bool             `json:"proactive_return_after_break,omitempty"`
-	StyleMirroringEnabled          *bool             `json:"style_mirroring_enabled,omitempty"`
-	AnaphoraResolutionEnabled      *bool             `json:"anaphora_resolution_enabled,omitempty"`
-	FollowUpAnticipationEnabled    *bool             `json:"follow_up_anticipation_enabled,omitempty"`
-	LLM                            *LLMConfig        `json:"llm,omitempty"`
-	Embedding                      *embedding.Config `json:"embedding,omitempty"`
+	Enabled                         *bool             `json:"enabled,omitempty"`
+	MaxSizeMB                       int               `json:"max_size_mb,omitempty"`
+	SemanticSearchTopK              int               `json:"semantic_search_top_k,omitempty"`
+	SemanticSearchOverfetch         int               `json:"semantic_search_overfetch,omitempty"`
+	SemanticSearchMinScore          float32           `json:"semantic_search_min_score,omitempty"`
+	SemanticSearchRerank            *bool             `json:"semantic_search_rerank,omitempty"`
+	AtomMaxChars                    int               `json:"atom_max_chars,omitempty"`
+	MemoryBudgetChars               int               `json:"memory_budget_chars,omitempty"`
+	DecayHalfLifeDays               int               `json:"decay_half_life_days,omitempty"`
+	QuarantineTTLDays               int               `json:"quarantine_ttl_days,omitempty"`
+	EvictionPolicy                  string            `json:"eviction_policy,omitempty"`
+	PredictiveIntents               int               `json:"predictive_intents,omitempty"`
+	AutoExtractPerTurn              *bool             `json:"auto_extract_per_turn,omitempty"`
+	InferUserState                  *bool             `json:"infer_user_state,omitempty"`
+	UserStateTurnInterval           int               `json:"user_state_turn_interval,omitempty"`
+	UserStateMaxPending             int               `json:"user_state_max_pending,omitempty"`
+	AssociationsEnabled             *bool             `json:"associations_enabled,omitempty"`
+	AssociationSemanticTopK         int               `json:"association_semantic_top_k,omitempty"`
+	SemanticDedupThreshold          *float32          `json:"semantic_dedup_threshold,omitempty"`
+	ConsolidateSimilarityThreshold  float32           `json:"consolidate_similarity_threshold,omitempty"`
+	ProactiveReturnAfterBreak       *bool             `json:"proactive_return_after_break,omitempty"`
+	StyleMirroringEnabled           *bool             `json:"style_mirroring_enabled,omitempty"`
+	AnaphoraResolutionEnabled       *bool             `json:"anaphora_resolution_enabled,omitempty"`
+	FollowUpAnticipationEnabled     *bool             `json:"follow_up_anticipation_enabled,omitempty"`
+	FollowUpSuggestionsEnabled      *bool             `json:"follow_up_suggestions_enabled,omitempty"`
+	FollowUpSuggestionMinConfidence float32           `json:"follow_up_suggestion_min_confidence,omitempty"`
+	ProactiveNudgesEnabled          *bool             `json:"proactive_nudges_enabled,omitempty"`
+	NudgeMaxPerDay                  int               `json:"nudge_max_per_day,omitempty"`
+	NudgeCooldownHours              int               `json:"nudge_cooldown_hours,omitempty"`
+	NudgeStaleGoalDays              int               `json:"nudge_stale_goal_days,omitempty"`
+	LLM                             *LLMConfig        `json:"llm,omitempty"`
+	Embedding                       *embedding.Config `json:"embedding,omitempty"`
 }
 
 // LLMConfig selects a dedicated LLM for Extended Memory extraction and
@@ -66,30 +72,36 @@ func floatPtr(f float32) *float32 { return &f }
 // Extended Memory is opt-in: Enabled defaults to false.
 func DefaultConfig() Config {
 	return Config{
-		Enabled:                        boolPtr(false),
-		MaxSizeMB:                      100,
-		SemanticSearchTopK:             10,
-		SemanticSearchOverfetch:        4,
-		SemanticSearchMinScore:         0.55,
-		SemanticSearchRerank:           boolPtr(true),
-		AtomMaxChars:                   300,
-		MemoryBudgetChars:              2000,
-		DecayHalfLifeDays:              30,
-		QuarantineTTLDays:              7,
-		EvictionPolicy:                 "retention_decay",
-		PredictiveIntents:              3,
-		AutoExtractPerTurn:             boolPtr(true),
-		InferUserState:                 boolPtr(true),
-		UserStateTurnInterval:          5,
-		UserStateMaxPending:            20,
-		AssociationsEnabled:            boolPtr(true),
-		AssociationSemanticTopK:        3,
-		SemanticDedupThreshold:         floatPtr(0.92),
-		ConsolidateSimilarityThreshold: 0.9,
-		ProactiveReturnAfterBreak:      boolPtr(true),
-		StyleMirroringEnabled:          boolPtr(true),
-		AnaphoraResolutionEnabled:      boolPtr(true),
-		FollowUpAnticipationEnabled:    boolPtr(true),
+		Enabled:                         boolPtr(false),
+		MaxSizeMB:                       100,
+		SemanticSearchTopK:              10,
+		SemanticSearchOverfetch:         4,
+		SemanticSearchMinScore:          0.55,
+		SemanticSearchRerank:            boolPtr(true),
+		AtomMaxChars:                    300,
+		MemoryBudgetChars:               2000,
+		DecayHalfLifeDays:               30,
+		QuarantineTTLDays:               7,
+		EvictionPolicy:                  "retention_decay",
+		PredictiveIntents:               3,
+		AutoExtractPerTurn:              boolPtr(true),
+		InferUserState:                  boolPtr(true),
+		UserStateTurnInterval:           5,
+		UserStateMaxPending:             20,
+		AssociationsEnabled:             boolPtr(true),
+		AssociationSemanticTopK:         3,
+		SemanticDedupThreshold:          floatPtr(0.92),
+		ConsolidateSimilarityThreshold:  0.9,
+		ProactiveReturnAfterBreak:       boolPtr(true),
+		StyleMirroringEnabled:           boolPtr(true),
+		AnaphoraResolutionEnabled:       boolPtr(true),
+		FollowUpAnticipationEnabled:     boolPtr(true),
+		FollowUpSuggestionsEnabled:      boolPtr(true),
+		FollowUpSuggestionMinConfidence: 0.6,
+		ProactiveNudgesEnabled:          boolPtr(false), // opt-in: proactive features never fire uninvited
+		NudgeMaxPerDay:                  1,
+		NudgeCooldownHours:              24,
+		NudgeStaleGoalDays:              7,
 	}
 }
 
@@ -168,6 +180,24 @@ func Resolve(cfg Config) Config {
 	if cfg.FollowUpAnticipationEnabled != nil {
 		def.FollowUpAnticipationEnabled = cfg.FollowUpAnticipationEnabled
 	}
+	if cfg.FollowUpSuggestionsEnabled != nil {
+		def.FollowUpSuggestionsEnabled = cfg.FollowUpSuggestionsEnabled
+	}
+	if cfg.FollowUpSuggestionMinConfidence > 0 && cfg.FollowUpSuggestionMinConfidence <= 1 {
+		def.FollowUpSuggestionMinConfidence = cfg.FollowUpSuggestionMinConfidence
+	}
+	if cfg.ProactiveNudgesEnabled != nil {
+		def.ProactiveNudgesEnabled = cfg.ProactiveNudgesEnabled
+	}
+	if cfg.NudgeMaxPerDay > 0 {
+		def.NudgeMaxPerDay = cfg.NudgeMaxPerDay
+	}
+	if cfg.NudgeCooldownHours > 0 {
+		def.NudgeCooldownHours = cfg.NudgeCooldownHours
+	}
+	if cfg.NudgeStaleGoalDays > 0 {
+		def.NudgeStaleGoalDays = cfg.NudgeStaleGoalDays
+	}
 	if cfg.LLM != nil {
 		def.LLM = cfg.LLM
 	}

internal/memory/extended/extended_memory.go

@@ -49,6 +49,15 @@ type ExtendedMemory struct {
 	recentUserMessages []string
 	recentMu           sync.Mutex
 
+	// lastFollowUps holds the high-confidence predicted intents captured
+	// during the most recent recall, surfaced as follow-up suggestions.
+	followUpsMu   sync.Mutex
+	lastFollowUps []PredictedIntent
+
+	// nudgeMu serializes TakeNudges so concurrent takers cannot both spend
+	// the same daily budget.
+	nudgeMu sync.Mutex
+
 	inferenceMu  sync.Mutex
 	closed       bool
 	inferRunning bool
@@ -84,6 +93,7 @@ func New(dir string, llm LLMClient, cfg Config) *ExtendedMemory {
 		llm:        llm,
 	}
 	em.recall.SetPredictor(em.predictor)
+	em.recall.SetFollowUpSink(em.setLastFollowUps)
 	em.recall.stats = &em.stats
 	_ = em.userModel.Load()
 	em.quarantine.SetTTLDays(cfg.QuarantineTTLDays)
@@ -137,6 +147,28 @@ func (em *ExtendedMemory) SetSessionContext(sessionID, project string) {
 	em.project = project
 }
 
+// setLastFollowUps replaces the captured follow-up suggestions. It is the
+// sink wired into Recall so every recall refreshes the list; a nil slice
+// clears it.
+func (em *ExtendedMemory) setLastFollowUps(intents []PredictedIntent) {
+	em.followUpsMu.Lock()
+	defer em.followUpsMu.Unlock()
+	em.lastFollowUps = intents
+}
+
+// LastFollowUps returns a copy of the predicted follow-up intents captured
+// during the most recent recall, or nil when none were captured.
+func (em *ExtendedMemory) LastFollowUps() []PredictedIntent {
+	if em == nil {
+		return nil
+	}
+	em.followUpsMu.Lock()
+	defer em.followUpsMu.Unlock()
+	out := make([]PredictedIntent, len(em.lastFollowUps))
+	copy(out, em.lastFollowUps)
+	return out
+}
+
 // AddAtom manually adds an atom. Manual adds are treated as user-approved.
 func (em *ExtendedMemory) AddAtom(ctx context.Context, atom MemoryAtom) error {
 	return em.addAtoms(ctx, []MemoryAtom{atom}, false)
@@ -600,6 +632,40 @@ func (em *ExtendedMemory) AnaphoraResolve(ctx context.Context, msg string) (stri
 	return resolved, true
 }
 
+// openLoopTypes are the atom types that represent unresolved threads: user
+// questions that went unanswered and stated goals/intentions.
+var openLoopTypes = map[string]bool{
+	TypeQuestion: true,
+	TypeGoal:     true,
+	TypeIntent:   true,
+}
+
+// OpenLoops returns trusted question/goal/intent atoms, newest first, capped
+// at limit (limit <= 0 returns all). It lists the store directly instead of
+// running a semantic query: open loops are a recency-ordered data view, so
+// the embedding search, min-score filtering, and LLM rerank of the recall
+// pipeline would only add cost without improving the answer.
+func (em *ExtendedMemory) OpenLoops(ctx context.Context, limit int) ([]MemoryAtom, error) {
+	if em == nil || !em.Enabled() {
+		return nil, nil
+	}
+	atoms, err := em.store.List() // newest first
+	if err != nil {
+		return nil, fmt.Errorf("extended memory: open loops list: %w", err)
+	}
+	out := make([]MemoryAtom, 0, len(atoms))
+	for _, atom := range atoms {
+		if !openLoopTypes[atom.Type] || IsTaintedSourceClass(atom.SourceClass) {
+			continue
+		}
+		out = append(out, atom)
+		if limit > 0 && len(out) >= limit {
+			break
+		}
+	}
+	return out, nil
+}
+
 // SearchAtoms performs an explicit semantic search and returns ranked atoms.
 func (em *ExtendedMemory) SearchAtoms(ctx context.Context, query string) ([]MemoryAtom, error) {
 	if em == nil {

internal/memory/extended/extractor.go

@@ -44,6 +44,8 @@ For each atom, output an object with:
 Rules:
 - Only extract stable information worth recalling in future sessions.
 - Do NOT extract instructions, commands, or requests to perform actions.
+- DO emit a "question" atom when the user asks a question that has not been answered yet, so it can be followed up on later.
+- DO emit a "goal" atom when the user states an intention or plan (e.g. "I want to…", "we should…", "next week I'll…").
 - Do NOT extract ephemeral details specific only to this message.
 - If nothing durable is present, return an empty array.