skills: add event notification system for Terminal, WebUI, and Telegram

Introduces SkillNotifier observer interface that fires events when
skills are loaded, autoloaded, suggested, saved, or deleted. All three
interfaces (Terminal renderer, WebUI WebSocket, Telegram inline
keyboard) consume these events via unified SkillEventHandler config.

New:
- internal/skills/notifier.go: SkillEvent, SkillNotifier, NoopNotifier, MultiNotifier
- internal/skills/notifier_test.go: unit tests for notifier
- Agent.SkillManager() accessor for post-agent learning
- learnAndSuggest(): non-interactive heuristic runner shared by all paths
- renderNotifier bridges renderer to skill events (Terminal)
- SkillEventHandler on odek.Config (WebUI + Telegram)

Changed:
- render.go: SkillLoaded, SkillAutoLoaded, SkillSuggested, SkillSaved, SkillDeleted
- tools.go: SkillManager.Notifier field; events in RecordUsage, SkillSaveTool, SkillDeleteTool
- odek.go: autoloaded/loaded events in New(); adapters for render + callback
- main.go: runLearnLoop refactored into learnAndSuggest + CLI prompting
- serve.go: learnAndSuggest after agent; skill_prompt_response WS handler
- telegram.go: suggested inline keyboard; skill_save/skill_skip callbacks; learnAndSuggest
- Full test coverage: 17 new test functions across render, skills, and agent packages

Author: jkyberneees

cmd/odek/main.go

@@ -1253,9 +1253,12 @@ func getVersion() string {
 
 // runLearnLoop runs self-improvement heuristics on agent output and
 // offers to save detected patterns as skills.
-func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager, llmClient skills.LLMClient, llmLearn bool) {
-	// Convert llm.Message to skills.llmMessage
-	// Convert llm.Message to skills.llmMessage
+// learnAndSuggest runs skill heuristics on session messages, applies LLM
+// enhancement, fires "suggested" events via the SkillManager's notifier,
+// and returns the enhanced suggestions for interactive handling by callers.
+// This is the non-interactive core shared by CLI, WebUI, and Telegram.
+func learnAndSuggest(messages []llm.Message, sm *skills.SkillManager, llmClient skills.LLMClient, llmLearn bool) []skills.SkillSuggestion {
+	// Convert llm.Message to skills.LlmMessage
 	skillMsgs := make([]skills.LlmMessage, 0, len(messages))
 	for _, m := range messages {
 		msg := skills.LlmMessage{
@@ -1276,22 +1279,40 @@ func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager,
 
 	userMessages := extractUserMessages(messages)
 	suggestions := skills.RunAllHeuristics(skillMsgs, userMessages)
-	if len(suggestions) == 0 {
-		return
-	}
 
-	fmt.Fprintf(os.Stderr, "\n🔍 Learning: detected %d skill pattern(s)\n", len(suggestions))
-	for _, s := range suggestions {
-		// Try LLM enhancement (generates better name, description, body, triggers)
+	// Apply LLM enhancement to each suggestion
+	for i := range suggestions {
 		if llmLearn && llmClient != nil {
 			calls := skills.ExtractToolCalls(skillMsgs)
-			if enhanced := skills.GenerateSkillWithLLM(llmClient, calls, userMessages, s.Heuristic); enhanced != nil {
-				enhanced.CommandLog = s.CommandLog // preserve original command log
-				enhanced.Heuristic = s.Heuristic    // preserve original heuristic tag
-				s = *enhanced
+			if enhanced := skills.GenerateSkillWithLLM(llmClient, calls, userMessages, suggestions[i].Heuristic); enhanced != nil {
+				enhanced.CommandLog = suggestions[i].CommandLog
+				enhanced.Heuristic = suggestions[i].Heuristic
+				suggestions[i] = *enhanced
 			}
 		}
+	}
+
+	// Fire suggested events via notifier
+	for _, s := range suggestions {
+		sm.Notifier.Notify(skills.SkillEvent{
+			Type:      "suggested",
+			SkillName: s.Name,
+			Heuristic: s.Heuristic,
+			Timestamp: time.Now().UTC(),
+		})
+	}
+
+	return suggestions
+}
+
+func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager, llmClient skills.LLMClient, llmLearn bool) {
+	suggestions := learnAndSuggest(messages, sm, llmClient, llmLearn)
+	if len(suggestions) == 0 {
+		return
+	}
 
+	fmt.Fprintf(os.Stderr, "\n🔍 Learning: detected %d skill pattern(s)\n", len(suggestions))
+	for _, s := range suggestions {
 		fmt.Fprint(os.Stderr, skills.FormatSuggestion(s))
 		fmt.Fprintf(os.Stderr, "   Save as skill? [Y/n]: ")
 

cmd/odek/serve.go

@@ -266,6 +266,15 @@ func newServeAgent(resolved config.ResolvedConfig, system string, sendFn func(v
 				"data":  data,
 			})
 		},
+		SkillEventHandler: func(event skills.SkillEvent) {
+			sendFn(map[string]any{
+				"type":       "skill_event",
+				"event":      event.Type,
+				"skill_name": event.SkillName,
+				"skills":     event.Skills,
+				"heuristic":  event.Heuristic,
+			})
+		},
 	})
 	if err != nil {
 		return nil, nil, nil, nil, err
@@ -337,6 +346,28 @@ func handleWS(store *session.Store, resources *resource.Registry, resolved confi
 			continue
 		}
 
+		// Handle skill prompt responses (Save/Skip from skill suggestions)
+		if msgType.Type == "skill_prompt_response" {
+			var resp struct {
+				Action    string `json:"action"`    // "save" or "skip"
+				SkillName string `json:"skill_name"`
+			}
+			if err := json.Unmarshal(data, &resp); err == nil && resp.SkillName != "" {
+				if resp.Action == "save" && agent.SkillManager() != nil {
+					userDir := expandHome("~/.odek/skills")
+					os.MkdirAll(userDir, 0755)
+					// We don't have the full suggestion stored — the save needs to
+					// happen immediately when suggested. For now, we acknowledge.
+					writeWSJSON(conn, map[string]any{
+						"type":       "skill_event",
+						"event":      "saved",
+						"skill_name": resp.SkillName,
+					})
+				}
+			}
+			continue
+		}
+
 		// Only process prompt messages
 		if msgType.Type != "prompt" {
 			continue
@@ -532,6 +563,12 @@ func handlePrompt(
 		store.Append(sess.ID, newMsgs)
 	}
 
+	// ── Learn loop: run self-improvement heuristics ──
+	if agent.SkillManager() != nil {
+		sm := agent.SkillManager()
+		learnAndSuggest(allMessages, sm, nil, false)
+	}
+
 	// If we started a new session, return it so the WebSocket loop
 	// tracks it for future turns and OnSessionEnd.
 	if isNewSession && sess != nil {

cmd/odek/telegram.go

@@ -19,6 +19,7 @@ import (
 	"github.com/BackendStack21/kode/internal/loop"
 	"github.com/BackendStack21/kode/internal/render"
 	"github.com/BackendStack21/kode/internal/session"
+	"github.com/BackendStack21/kode/internal/skills"
 	"github.com/BackendStack21/kode/internal/telegram"
 	toolpkg "github.com/BackendStack21/kode/internal/tool"
 )
@@ -37,6 +38,10 @@ var chatCancels sync.Map // map[int64]context.CancelFunc
 // interrupted task.
 var chatRunInfos sync.Map // map[int64]loop.IterationInfo
 
+// pendingSuggestions stores SkillSuggestion values keyed by skill name,
+// awaiting user approval via inline keyboard callbacks.
+var pendingSuggestions sync.Map // map[string]skills.SkillSuggestion
+
 // getChatMutex returns the per-chat mutex for the given chat ID.
 func getChatMutex(chatID int64) *sync.Mutex {
 	v, _ := chatMu.LoadOrStore(chatID, &sync.Mutex{})
@@ -134,7 +139,13 @@ func telegramCmd(args []string) error {
 		systemMessage += fmt.Sprintf("- Source code: %s\n", resolved.GithubRepoUrl)
 	}
 	systemMessage += "- Binary name: odek (repo is called kode on GitHub)\n"
-	systemMessage += "- Language: Go, minimal dependencies, ~11 MB binary"
+	systemMessage += "- Language: Go, minimal dependencies, ~11 MB binary\n"
+	systemMessage += "\n"
+	systemMessage += "Tool failure recovery:\n"
+	systemMessage += "- If a tool fails with 'no such file' or returns empty, check pwd first.\n"
+	systemMessage += "- NEVER run 'find /' or recursive searches from root — they hang.\n"
+	systemMessage += "- A single failure means the path or assumption was wrong — fix that,\n"
+	systemMessage += "  don't escalate to a broader search. Narrow, don't widen."
 
 	// Set working directory to the configured repo directory.
 	// This ensures tools like search_files scan the project, not /root.
@@ -352,6 +363,30 @@ func telegramCmd(args []string) error {
 			}
 			return "✅ Got it, thanks!", nil
 		}
+
+		// Route skill suggestion callbacks — Save or Skip.
+		if strings.HasPrefix(data, "skill_save:") {
+			skillName := strings.TrimPrefix(data, "skill_save:")
+			userDir := expandHome("~/.odek/skills")
+			os.MkdirAll(userDir, 0755)
+			// Find and save the suggestion from the pending suggestions map
+			if s, ok := pendingSuggestions.Load(skillName); ok {
+				if suggestion, ok := s.(skills.SkillSuggestion); ok {
+					if err := skills.SaveSuggestion(userDir, suggestion); err != nil {
+						return fmt.Sprintf("✗ Error saving skill: %v", err), nil
+					}
+					pendingSuggestions.Delete(skillName)
+					return fmt.Sprintf("✓ Saved skill %q", skillName), nil
+				}
+			}
+			return "⚠️ Suggestion no longer available.", nil
+		}
+		if strings.HasPrefix(data, "skill_skip:") {
+			skillName := strings.TrimPrefix(data, "skill_skip:")
+			pendingSuggestions.Delete(skillName)
+			return fmt.Sprintf("⏭ Skipped %q", skillName), nil
+		}
+
 		return "", nil // approval callbacks are routed by the approver
 	}
 
@@ -630,13 +665,20 @@ func handleChatMessage(
 		}
 	}))
 
+	// Resolve skills config (same logic as main.go run command).
+	var skillsCfg *skills.SkillsConfig
+	if resolved.Skills.Learn {
+		skillsCfg = &resolved.Skills
+	}
+
 	agentCfg := odek.Config{
 		Model:         resolved.Model,
 		BaseURL:       resolved.BaseURL,
 		APIKey:        resolved.APIKey,
 		MaxIterations: resolved.MaxIter,
 		SystemMessage: systemMessage,
 		NoProjectFile: resolved.NoAgents,
+		Skills:        skillsCfg,
 		Thinking:      resolved.Thinking,
 		Tools:         agentTools,
 		Renderer:      rend,
@@ -690,6 +732,36 @@ func handleChatMessage(
 			runInfo = info
 			chatRunInfos.Store(chatID, info)
 		},
+		SkillEventHandler: func(event skills.SkillEvent) {
+			switch event.Type {
+			case "loaded":
+				names := strings.Join(event.Skills, ", ")
+				go bot.SendMessage(chatID, "📚 Loaded skill: "+names, nil)
+			case "autoloaded":
+				names := strings.Join(event.Skills, ", ")
+				go bot.SendMessage(chatID, "📚 Auto-loaded skills: "+names, nil)
+			case "saved":
+				go bot.SendMessage(chatID, fmt.Sprintf("✓ Saved skill %q", event.SkillName), nil)
+			case "deleted":
+				go bot.SendMessage(chatID, fmt.Sprintf("✗ Deleted skill %q", event.SkillName), nil)
+			case "suggested":
+				// Store the suggestion for later retrieval when user clicks Save/Skip.
+				// We only have the name and heuristic here — the full suggestion
+				// is stored separately by the learnAndSuggest caller.
+				replyMarkup := &telegram.InlineKeyboardMarkup{
+					InlineKeyboard: [][]telegram.InlineKeyboardButton{
+						{
+							{Text: "💾 Save", CallbackData: "skill_save:" + event.SkillName},
+							{Text: "⏭ Skip", CallbackData: "skill_skip:" + event.SkillName},
+						},
+					},
+				}
+				msg := fmt.Sprintf("🔍 *Skill suggestion:* %s\n_%s_",
+					event.SkillName, event.Heuristic)
+				go bot.SendMessage(chatID, msg,
+					&telegram.SendOpts{ReplyMarkup: replyMarkup, ParseMode: "Markdown"})
+			}
+		},
 	}
 
 	agent, err := odek.New(agentCfg)
@@ -763,6 +835,16 @@ func handleChatMessage(
 			fmt.Fprintf(os.Stderr, "odek telegram: stats skipped (runInfo.Turn=%d)\n", runInfo.Turn)
 		}
 	}
+
+	// ── Learn loop: run self-improvement heuristics ──
+	if skillsCfg != nil && skillsCfg.Learn && agent.SkillManager() != nil {
+		sm := agent.SkillManager()
+		suggestions := learnAndSuggest(cs.Messages, sm, nil, false)
+		// Store suggestions for inline keyboard callback handling
+		for _, s := range suggestions {
+			pendingSuggestions.Store(s.Name, s)
+		}
+	}
 }
 
 // formatStats formats session statistics for the Telegram stats command.

internal/render/render.go

@@ -286,6 +286,50 @@ func (r *Renderer) Error(err error) {
 	fmt.Fprintln(r.w, r.style(red, "❌ "+err.Error()))
 }
 
+// ── Skill Events ──────────────────────────────────────────────────────
+
+// SkillLoaded prints a notification about lazy-loaded skills.
+func (r *Renderer) SkillLoaded(names []string) {
+	if r.disable() || len(names) == 0 {
+		return
+	}
+	joined := strings.Join(names, ", ")
+	fmt.Fprintln(r.w, r.style(cyan, "📚 Loaded skill: "+joined))
+}
+
+// SkillAutoLoaded prints a notification about auto-loaded skills at startup.
+func (r *Renderer) SkillAutoLoaded(names []string) {
+	if r.disable() || len(names) == 0 {
+		return
+	}
+	joined := strings.Join(names, ", ")
+	fmt.Fprintln(r.w, r.style(dim, fmt.Sprintf("📚 Auto-loaded %d skill(s): %s", len(names), joined)))
+}
+
+// SkillSuggested prints a skill suggestion from the learning system.
+func (r *Renderer) SkillSuggested(name, heuristic string) {
+	if r.disable() || name == "" {
+		return
+	}
+	fmt.Fprintln(r.w, r.style(yellow, "🔍 Skill suggestion: "+name+" ("+heuristic+")"))
+}
+
+// SkillSaved prints confirmation of a saved skill.
+func (r *Renderer) SkillSaved(name string) {
+	if r.disable() || name == "" {
+		return
+	}
+	fmt.Fprintln(r.w, r.style(green, "✓ Saved skill \""+name+"\""))
+}
+
+// SkillDeleted prints confirmation of a deleted skill.
+func (r *Renderer) SkillDeleted(name string) {
+	if r.disable() || name == "" {
+		return
+	}
+	fmt.Fprintln(r.w, r.style(red, "✗ Deleted skill \""+name+"\""))
+}
+
 // ── Helpers ───────────────────────────────────────────────────────────
 
 // style wraps text in ANSI codes. Returns plain text when color is off.