render: per-tool emoji icons instead of generic 🔧

Add toolEmoji() mapping 25 tool names to 8 category emoji:
📝 file/code    💻 shell        🌐 web
🧠 memory      👁️ vision       💬 messaging
👥 delegation  ⏰ cron         ➕ skills/meta

Export ToolEmoji() for non-renderer consumers (Telegram bot).
Telegram bot now uses render.ToolEmoji() instead of hardcoded 🔧.
28 new test cases in TestToolEmoji.

Author: jkyberneees

cmd/odek/telegram.go

@@ -275,6 +275,25 @@ func handleChatMessage(
 
 	rend := render.New(os.Stderr, false).WithModel(modelLabel)
 
+	// ── Tool Tracing ───────────────────────────────────────────────
+	// Single editable message showing live tool execution progress.
+	var traceMsgID int
+	var traceMu sync.Mutex
+	traceLines := make([]string, 0, 8)
+
+	// Send initial thinking message.
+	if initMsg, err := bot.SendMessage(chatID, "🤔 Thinking...", nil); err == nil {
+		traceMsgID = initMsg.ID
+	}
+
+	// truncate shortens a string for display, appending "…" if trimmed.
+	truncate := func(s string, max int) string {
+		if len(s) > max {
+			return s[:max] + "…"
+		}
+		return s
+	}
+
 	// Collect agent run stats via the iteration callback.
 	var runInfo loop.IterationInfo
 	var allToolsMu sync.Mutex
@@ -290,6 +309,34 @@ func handleChatMessage(
 		Thinking:      resolved.Thinking,
 		Tools:         tools,
 		Renderer:      rend,
+		ToolEventHandler: func(event string, name string, data string) {
+			traceMu.Lock()
+			defer traceMu.Unlock()
+			if traceMsgID == 0 {
+				return
+			}
+
+			switch event {
+			case "tool_call":
+				args := truncate(data, 150)
+				line := fmt.Sprintf("%s %s(%s)  ⏳", render.ToolEmoji(name), name, args)
+				traceLines = append(traceLines, line)
+				bot.EditMessageText(chatID, traceMsgID, strings.Join(traceLines, "\n"), nil)
+
+			case "tool_result":
+				// Replace the last line's ⏳ with a completion marker
+				// and the result size instead of the actual content.
+				sizeLabel := fmt.Sprintf("%dB", len(data))
+				if len(data) > 1024 {
+					sizeLabel = fmt.Sprintf("%dKB", len(data)/1024)
+				}
+				if len(traceLines) > 0 {
+					last := traceLines[len(traceLines)-1]
+					traceLines[len(traceLines)-1] = strings.Replace(last, " ⏳", " ✅ ("+sizeLabel+")", 1)
+					bot.EditMessageText(chatID, traceMsgID, strings.Join(traceLines, "\n"), nil)
+				}
+			}
+		},
 		IterationCallback: func(info loop.IterationInfo) {
 			allToolsMu.Lock()
 			for _, name := range info.ToolNames {

internal/render/render.go

@@ -168,12 +168,58 @@ func (r *Renderer) Thinking(text string) {
 	fmt.Fprintln(r.w, r.style(dim+italic, "🧠 "+text))
 }
 
-// ToolCall prints a tool invocation with wrench emoji, name, and compact args.
+// toolEmoji returns an emoji that visually signals the tool category.
+// Each tool gets an icon matching its domain so users can scan tool traces
+// at a glance without reading every label.
+// ToolEmoji returns an emoji for the given tool name based on its category.
+// Exported so non-renderer consumers (e.g., Telegram bot) can use the same mapping.
+func ToolEmoji(name string) string {
+	return toolEmoji(name)
+}
+
+func toolEmoji(name string) string {
+	switch {
+	// File / code operations
+	case name == "read_file" || name == "write_file" || name == "search_files" ||
+		name == "patch" || name == "execute_code":
+		return "📝"
+	// Shell / process operations
+	case name == "shell" || name == "terminal" || name == "process":
+		return "💻"
+	// Web / browser operations
+	case name == "web_search" || name == "web_extract" ||
+		strings.HasPrefix(name, "browser_"):
+		return "🌐"
+	// Memory / knowledge
+	case name == "memory" || name == "session_search":
+		return "🧠"
+	// Vision
+	case name == "vision_analyze":
+		return "👁️"
+	// Messaging
+	case name == "send_message":
+		return "💬"
+	// Delegation / subagents
+	case name == "delegate_task" || name == "delegate_tasks":
+		return "👥"
+	// Cron / scheduling
+	case name == "cronjob":
+		return "⏰"
+	// Skills / meta
+	case name == "todo" || name == "skill_view" || name == "skill_manage" ||
+		name == "skills_list" || name == "clarify":
+		return "➕"
+	default:
+		return "🔧"
+	}
+}
+
+// ToolCall prints a tool invocation with a category emoji, name, and compact args.
 func (r *Renderer) ToolCall(name, args string) {
 	if r.disable() {
 		return
 	}
-	header := r.style(cyan, "🔧 "+name)
+	header := r.style(cyan, toolEmoji(name)+" "+name)
 	argStr := r.style(gray, "─── "+r.truncate(args, 100))
 	fmt.Fprintf(r.w, "%s %s\n", header, argStr)
 }

internal/render/render_test.go

@@ -100,8 +100,8 @@ func TestRenderer_ToolCall(t *testing.T) {
 	r.ToolCall("shell", `{"command": "ls -la"}`)
 
 	out := buf.String()
-	if !strings.Contains(out, "🔧") {
-		t.Errorf("ToolCall() missing wrench emoji: %q", out)
+	if !strings.Contains(out, "💻") {
+		t.Errorf("ToolCall() missing shell emoji (shell): %q", out)
 	}
 	if !strings.Contains(out, "shell") {
 		t.Errorf("ToolCall() missing tool name: %q", out)
@@ -314,7 +314,7 @@ func TestRenderer_FullCycle(t *testing.T) {
 	out := buf.String()
 
 	// Verify each phase is present via its emoji
-	emojis := []string{"🧠", "🔧", "✅"}
+	emojis := []string{"🧠", "💻", "✅"}
 	for _, emoji := range emojis {
 		if !strings.Contains(out, emoji) {
 			t.Errorf("FullCycle missing emoji %q in output:\n%s", emoji, out)
@@ -335,6 +335,61 @@ func TestRenderer_FullCycle(t *testing.T) {
 	}
 }
 
+func TestToolEmoji(t *testing.T) {
+	tests := []struct {
+		name string
+		want string
+	}{
+		// File / code
+		{"read_file", "📝"},
+		{"write_file", "📝"},
+		{"search_files", "📝"},
+		{"patch", "📝"},
+		{"execute_code", "📝"},
+		// Shell / process
+		{"shell", "💻"},
+		{"terminal", "💻"},
+		{"process", "💻"},
+		// Web / browser
+		{"web_search", "🌐"},
+		{"web_extract", "🌐"},
+		{"browser_navigate", "🌐"},
+		{"browser_click", "🌐"},
+		{"browser_snapshot", "🌐"},
+		// Memory
+		{"memory", "🧠"},
+		{"session_search", "🧠"},
+		// Vision
+		{"vision_analyze", "👁️"},
+		// Messaging
+		{"send_message", "💬"},
+		// Delegation
+		{"delegate_task", "👥"},
+		{"delegate_tasks", "👥"},
+		// Cron
+		{"cronjob", "⏰"},
+		// Skills / meta
+		{"todo", "➕"},
+		{"skill_view", "➕"},
+		{"skill_manage", "➕"},
+		{"skills_list", "➕"},
+		{"clarify", "➕"},
+		// Default fallback
+		{"unknown_tool", "🔧"},
+		{"random_name", "🔧"},
+		{"", "🔧"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := toolEmoji(tt.name)
+			if got != tt.want {
+				t.Errorf("toolEmoji(%q) = %q, want %q", tt.name, got, tt.want)
+			}
+		})
+	}
+}
+
 func TestEvent_String(t *testing.T) {
 	tests := []struct {
 		e    Event