fix: 5 corrections from code audit

- #5: Replace custom itoa() with strconv.Itoa() in scored_matcher (+ regression test)
- #7: Revert wrong emoji in curation report (📦 was correct, 🫠 was accidental)
- #4: Add sendAsync() helper with error logging — fire-and-forget goroutines no longer silently fail
- #6: Increase SkipThreshold default 1→3 — one accidental skip no longer permanently suppresses
- #2: Gate episode auto-search behind LLMSearch config — stops unconditional startup latency
- #3: Cache memory prompt block in BuildSystemPrompt — invalidate on Add/Replace/Remove/Append/Clear (+ regression test)

+ verbose gating: skill lifecycle output (load/save/suggest/delete) suppressed when verbose=false
  (notifier events still fire for Telegram/WebUI in all modes)

Author: molty3000

cmd/odek/main.go

@@ -845,6 +845,12 @@ func run(args []string) error {
 	color := !resolved.NoColor && render.ColorEnabled()
 	rend := render.New(os.Stderr, color).WithModel(modelLabel)
 
+	// Wire skill verbosity to the renderer so skill lifecycle
+	// notifications (save, suggest, delete) respect the config.
+	if resolved.Skills.Learn {
+		rend.WithSkillVerbose(resolved.Skills.Verbose)
+	}
+
 	// Resolve skills config pointer (only when learn mode is enabled)
 	var skillsCfg *skills.SkillsConfig
 	if resolved.Skills.Learn {
@@ -1331,7 +1337,7 @@ func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager,
 	// Filter out previously-skipped suggestions
 	filtered, skipped := skills.FilterSkipped(suggestions, userDir,
 		skillsCfg.Curation.SkipThreshold, skillsCfg.Curation.SkipResetDays)
-	if skipped > 0 {
+	if skipped > 0 && skillsCfg.Verbose {
 		fmt.Fprintf(os.Stderr, "   (%d suggestion(s) previously skipped, suppressed)\n", skipped)
 	}
 	if len(filtered) == 0 {
@@ -1342,23 +1348,28 @@ func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager,
 	if skillsCfg.AutoSave.Enabled {
 		if !skillsCfg.AutoSave.RequireLLM || skillsCfg.LLMLearn {
 			result := skills.AutoSaveSuggestions(filtered, userDir, skillsCfg)
-			for _, name := range result.Saved {
-				heuristic := result.Heuristics[name]
-				if heuristic != "" {
-					fmt.Fprintf(os.Stderr, "   ✓ Auto-saved skill %q (%s)\n", name, heuristic)
-				} else {
-					fmt.Fprintf(os.Stderr, "   ✓ Auto-saved skill %q\n", name)
+			if skillsCfg.Verbose {
+				for _, name := range result.Saved {
+					heuristic := result.Heuristics[name]
+					if heuristic != "" {
+						fmt.Fprintf(os.Stderr, "   ✓ Auto-saved skill %q (%s)\n", name, heuristic)
+					} else {
+						fmt.Fprintf(os.Stderr, "   ✓ Auto-saved skill %q\n", name)
+					}
+				}
+				if result.Skipped > 0 {
+					fmt.Fprintf(os.Stderr, "   (%d previously skipped, suppressed)\n", result.Skipped)
 				}
+				for _, name := range result.Failed {
+					fmt.Fprintf(os.Stderr, "   ⚠ Quality gate failed for %q (use --no-auto-save to review manually)\n", name)
+				}
+			}
+			// Fire notifier events even when silent so WebUI/Telegram get them
+			for _, name := range result.Saved {
 				sm.Notifier.Notify(skills.SkillEvent{
 					Type: "saved", SkillName: name, Timestamp: time.Now().UTC(),
 				})
 			}
-			if result.Skipped > 0 {
-				fmt.Fprintf(os.Stderr, "   (%d previously skipped, suppressed)\n", result.Skipped)
-			}
-			for _, name := range result.Failed {
-				fmt.Fprintf(os.Stderr, "   ⚠ Quality gate failed for %q (use --no-auto-save to review manually)\n", name)
-			}
 			if len(result.Saved) > 0 {
 				sm.Reload()
 				// Run micro-curation after auto-save
@@ -1369,6 +1380,9 @@ func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager,
 	}
 
 	// Interactive fallback: show preview and prompt
+	if !skillsCfg.Verbose {
+		return // silently skip interactive prompt in non-verbose mode
+	}
 	fmt.Fprintf(os.Stderr, "\n🔍 Learning: detected %d skill pattern(s)\n", len(filtered))
 	for _, s := range filtered {
 		fmt.Fprint(os.Stderr, skills.FormatSuggestionWithPreview(s, true, 400))
@@ -1407,7 +1421,7 @@ func runAutoCurate(userDir string, sm *skills.SkillManager, cfg skills.SkillsCon
 		}
 	}
 	msg := skills.RunAutoCurate(userDir, newSkills, allSkills, cfg, llmClient)
-	if msg != "" {
+	if msg != "" && cfg.Verbose {
 		fmt.Fprint(os.Stderr, msg)
 	}
 }

cmd/odek/main_test.go

@@ -1369,7 +1369,7 @@ func TestRunLearn_MultiStepProcedure(t *testing.T) {
 
 	// Create local odek.json with auto_save enabled, LLM enhancement disabled
 	// (mock server can't handle enhancement prompts)
-	configContent := `{"skills": {"auto_save": {"enabled": true, "require_llm": false}, "llm_learn": false}}`
+	configContent := `{"skills": {"verbose": true, "auto_save": {"enabled": true, "require_llm": false}, "llm_learn": false}}`
 	os.WriteFile("odek.json", []byte(configContent), 0644)
 	defer os.Remove("odek.json")
 
@@ -1426,7 +1426,7 @@ func TestRunLearn_InteractiveReject(t *testing.T) {
 	}()
 
 	// Create local odek.json with auto_save disabled and LLM enhancement disabled
-	configContent := `{"skills": {"auto_save": {"enabled": false}, "llm_learn": false}}`
+	configContent := `{"skills": {"verbose": true, "auto_save": {"enabled": false}, "llm_learn": false}}`
 	os.WriteFile("odek.json", []byte(configContent), 0644)
 	defer os.Remove("odek.json")
 

cmd/odek/telegram.go

@@ -745,16 +745,16 @@ func handleChatMessage(
 		},
 		SkillEventHandler: func(event skills.SkillEvent) {
 			switch event.Type {
-			case "loaded":
-				names := strings.Join(event.Skills, ", ")
-				go bot.SendMessage(chatID, "📚 Loaded skill: "+names, &telegram.SendOpts{ReplyToMessageID: messageID})
-			case "autoloaded":
-				names := strings.Join(event.Skills, ", ")
-				go bot.SendMessage(chatID, "📚 Auto-loaded skills: "+names, &telegram.SendOpts{ReplyToMessageID: messageID})
-			case "saved":
-				go bot.SendMessage(chatID, fmt.Sprintf("✓ Saved skill %q", event.SkillName), &telegram.SendOpts{ReplyToMessageID: messageID})
-			case "deleted":
-				go bot.SendMessage(chatID, fmt.Sprintf("✗ Deleted skill %q", event.SkillName), &telegram.SendOpts{ReplyToMessageID: messageID})
+		case "loaded":
+			names := strings.Join(event.Skills, ", ")
+			sendAsync(bot, chatID, "📚 Loaded skill: "+names, &telegram.SendOpts{ReplyToMessageID: messageID})
+		case "autoloaded":
+			names := strings.Join(event.Skills, ", ")
+			sendAsync(bot, chatID, "📚 Auto-loaded skills: "+names, &telegram.SendOpts{ReplyToMessageID: messageID})
+		case "saved":
+			sendAsync(bot, chatID, fmt.Sprintf("✓ Saved skill %q", event.SkillName), &telegram.SendOpts{ReplyToMessageID: messageID})
+		case "deleted":
+			sendAsync(bot, chatID, fmt.Sprintf("✗ Deleted skill %q", event.SkillName), &telegram.SendOpts{ReplyToMessageID: messageID})
 			case "suggested":
 				replyMarkup := &telegram.InlineKeyboardMarkup{
 					InlineKeyboard: [][]telegram.InlineKeyboardButton{
@@ -779,8 +779,8 @@ func handleChatMessage(
 					}
 					msg += fmt.Sprintf("\n\n```\n%s\n```", preview)
 				}
-				go bot.SendMessage(chatID, msg,
-					&telegram.SendOpts{ReplyMarkup: replyMarkup, ParseMode: "Markdown", ReplyToMessageID: messageID})
+			sendAsync(bot, chatID, msg,
+				&telegram.SendOpts{ReplyMarkup: replyMarkup, ParseMode: "Markdown", ReplyToMessageID: messageID})
 			}
 		},
 	}
@@ -890,9 +890,9 @@ func handleChatMessage(
 					}
 				}
 				msg := skills.RunAutoCurate(userDir, newSkills, allSkills, *skillsCfg, nil)
-				if msg != "" {
-					go bot.SendMessage(chatID, msg, nil)
-				}
+			if msg != "" {
+				sendAsync(bot, chatID, msg, nil)
+			}
 			}
 		} else {
 			// Store suggestions for inline keyboard callback handling
@@ -1002,6 +1002,17 @@ func reportError(bot *telegram.Bot, chatID int64, messageID int, msg string) {
 	}
 }
 
+// sendAsync sends a Telegram message in a background goroutine and logs
+// any errors to stderr. Use this instead of raw go bot.SendMessage() to
+// prevent silent delivery failures.
+func sendAsync(bot *telegram.Bot, chatID int64, text string, opts *telegram.SendOpts) {
+	go func() {
+		if _, err := bot.SendMessage(chatID, text, opts); err != nil {
+			fmt.Fprintf(os.Stderr, "odek telegram: async send failed: %v\n", err)
+		}
+	}()
+}
+
 // ── Singleton Lock ─────────────────────────────────────────────────────
 //
 // Prevents two bot instances from polling Telegram simultaneously (which

internal/memory/memory.go

@@ -75,6 +75,12 @@ type MemoryManager struct {
 	merge    *MergeDetector
 	llm      LLMClient
 	cfg      MemoryConfig
+
+	// prompt caching avoids rebuilding the system prompt block on every
+	// iteration when memory hasn't changed. The cache is invalidated
+	// whenever facts or buffer are modified.
+	promptCache string
+	promptDirty bool
 }
 
 // NewMemoryManager creates a fully wired MemoryManager.
@@ -222,6 +228,7 @@ func (m *MemoryManager) AddFact(target, content string) error {
 	if err := m.facts.Add(target, content); err != nil {
 		return err
 	}
+	m.promptDirty = true
 
 	// Incrementally update merge detector instead of re-reading + re-embedding all.
 	// Check dedup: if content already existed in the entries we read at the top,
@@ -260,6 +267,7 @@ func (m *MemoryManager) ReplaceFact(target, oldText, content string) error {
 	if err := m.facts.Replace(target, oldText, content); err != nil {
 		return err
 	}
+	m.promptDirty = true
 	// Re-fit merge detector
 	if m.cfg.MergeOnWrite != nil && *m.cfg.MergeOnWrite {
 		entries, _ := m.facts.Entries(target)
@@ -276,6 +284,7 @@ func (m *MemoryManager) RemoveFact(target, oldText string) error {
 	if err := m.facts.Remove(target, oldText); err != nil {
 		return err
 	}
+	m.promptDirty = true
 	// Re-fit merge detector
 	if m.cfg.MergeOnWrite != nil && *m.cfg.MergeOnWrite {
 		entries, _ := m.facts.Entries(target)
@@ -350,6 +359,7 @@ func (m *MemoryManager) AppendBuffer(role, message string) {
 	}
 	line := FormatBufferLine(role, message)
 	m.buffer.Append(line)
+	m.promptDirty = true
 }
 
 // GetBuffer returns the current buffer lines (for system prompt injection).
@@ -369,11 +379,13 @@ func (m *MemoryManager) RestoreBuffer(lines []string) {
 	for _, line := range lines {
 		m.buffer.Append(line)
 	}
+	m.promptDirty = true
 }
 
 // ClearBuffer resets the buffer for a new session.
 func (m *MemoryManager) ClearBuffer() {
 	m.buffer.Clear()
+	m.promptDirty = true
 }
 
 // ── Episode Operations ───────────────────────────────────────────────
@@ -427,6 +439,11 @@ func (m *MemoryManager) BuildSystemPrompt() string {
 		return ""
 	}
 
+	// Return cached prompt if memory hasn't changed since last build.
+	if !m.promptDirty && m.promptCache != "" {
+		return m.promptCache
+	}
+
 	userFact, _ := m.facts.Read("user")
 	envFact, _ := m.facts.Read("env")
 	bufferLines := m.GetBuffer()
@@ -497,7 +514,9 @@ func (m *MemoryManager) BuildSystemPrompt() string {
 	}
 
 	b.WriteString("───────────────────────────────\n")
-	return b.String()
+	m.promptCache = b.String()
+	m.promptDirty = false
+	return m.promptCache
 }
 
 // ── Private helpers ──────────────────────────────────────────────────

internal/memory/memory_test.go

@@ -484,3 +484,76 @@ func TestMin(t *testing.T) {
 		t.Errorf("min(0, 0) = %d, want 0", got)
 	}
 }
+
+// TestMemoryPromptCache verifies that BuildSystemPrompt returns a cached
+// result when memory hasn't changed, and invalidates the cache on mutation.
+func TestMemoryPromptCache(t *testing.T) {
+	dir := t.TempDir()
+	mm := NewMemoryManager(dir, nil, DefaultMemoryConfig())
+
+	// First call builds the prompt and caches it.
+	mm.AddFact("user", "User prefers Go")
+	p1 := mm.BuildSystemPrompt()
+	if !strings.Contains(p1, "User prefers Go") {
+		t.Fatal("expected fact in initial prompt")
+	}
+
+	// Cached result — same call returns identical prompt.
+	p1b := mm.BuildSystemPrompt()
+	if p1b != p1 {
+		t.Error("prompt should be cached when no mutation occurred")
+	}
+
+	// Add a DIFFERENT fact — should invalidate cache.
+	mm.AddFact("user", "User also likes Python")
+	p2 := mm.BuildSystemPrompt()
+	if p2 == p1 {
+		t.Error("prompt should differ after AddFact with new content")
+	}
+	if !strings.Contains(p2, "User also likes Python") {
+		t.Errorf("expected new fact in prompt, got %q", p2)
+	}
+
+	// AppendBuffer — should invalidate.
+	mm.AppendBuffer("user", "buffer entry")
+	p3 := mm.BuildSystemPrompt()
+	if p3 == p2 {
+		t.Error("prompt should differ after AppendBuffer")
+	}
+
+	// ReplaceFact — should invalidate.
+	mm.ReplaceFact("user", "Go", "User prefers Rust")
+	p4 := mm.BuildSystemPrompt()
+	if p4 == p3 {
+		t.Error("prompt should differ after ReplaceFact")
+	}
+	if !strings.Contains(p4, "Rust") {
+		t.Errorf("expected replaced fact in prompt, got %q", p4)
+	}
+	if strings.Contains(p4, "User prefers Go") {
+		t.Error("old fact should not appear after ReplaceFact")
+	}
+
+	// RemoveFact — should invalidate.
+	mm.RemoveFact("user", "Python")
+	p5 := mm.BuildSystemPrompt()
+	if p5 == p4 {
+		t.Error("prompt should differ after RemoveFact")
+	}
+	if strings.Contains(p5, "Python") {
+		t.Error("removed fact should not appear in prompt")
+	}
+
+	// Cached after no mutation.
+	p5b := mm.BuildSystemPrompt()
+	if p5b != p5 {
+		t.Error("prompt should be cached after no mutation")
+	}
+
+	// ClearBuffer — should invalidate.
+	mm.ClearBuffer()
+	p6 := mm.BuildSystemPrompt()
+	if p6 == p5b {
+		t.Error("prompt should differ after ClearBuffer")
+	}
+}