feat: emoji-driven terminal UI — 🧠 🔧 ✅ ❌ icon anchors for each phase

Rendering overhaul:
- ⚡ Start header with kode brand, model name, task preview
- ═══ Iter N/M · model ═══ iteration divider (double-line Unicode)
- 🧠 Thinking text (dim italic, no label)
- 🔧 Tool call with ─── separator to args
- Tool results stay compact: gray, 1 line + …
- ✅ Final answer (bold green)
- ❌ Error (red)

Removed old label()-based rendering. Each method is self-contained.
Added render.Start(task) called from CLI before agent.Run.

Author: jkyberneees

cmd/kode/main.go

@@ -166,6 +166,7 @@ func run(args []string) error {
 	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
 	defer cancel()
 
+	rend.Start(f.Task)
 	result, err := agent.Run(ctx, f.Task)
 	if err != nil {
 		return err

internal/render/render.go

@@ -1,4 +1,4 @@
-// Package render provides colored terminal rendering for the kode agent loop.
+// Package render provides emoji-driven terminal rendering for the kode agent loop.
 //
 // It produces structured output for each phase of the ReAct cycle:
 // thinking, tool calls, tool results, and the final answer. When a Renderer
@@ -8,8 +8,10 @@
 // # Design
 //
 //   - Zero dependencies. Uses ANSI escape codes directly.
+//   - Emoji icons as visual anchors (🧠 🔧 ✅ ❌).
 //   - Color detection: respects NO_COLOR env var and tty detection.
-//   - Truncation: tool output is truncated to prevent flooding the terminal.
+//   - Truncation: tool output is collapsed to one line to keep the
+//     terminal scannable during multi-step tool chains.
 //   - Maintainable: each rendering method is self-contained; adding a new
 //     event type requires one constant + one method.
 package render
@@ -63,8 +65,6 @@ func (e Event) String() string {
 
 // ── ANSI Styles ───────────────────────────────────────────────────────
 
-// Style constants. Use the method form (e.g., r.dim(...)) so we can
-// skip codes when color is disabled.
 const (
 	reset   = "\033[0m"
 	bold    = "\033[1m"
@@ -81,19 +81,13 @@ const (
 
 // ── Renderer ──────────────────────────────────────────────────────────
 
-// MaxToolOutput is the maximum number of characters to print from tool results.
-// Output longer than this is truncated with an ellipsis.
-const MaxToolOutput = 2000
-
 // Renderer writes formatted agent loop output to an io.Writer.
 // The zero value is usable but won't produce any output — call New()
 // to create a properly initialized Renderer.
 type Renderer struct {
 	w     io.Writer
 	color bool
 	model string
-	iter  int // current iteration number, set by Iteration()
-	maxN  int // max iterations, set by Iteration()
 }
 
 // New creates a Renderer that writes to w. If color is false, ANSI escape
@@ -121,44 +115,55 @@ func (r *Renderer) disable() bool {
 
 // ── Rendering methods ─────────────────────────────────────────────────
 
-// Iteration prints the cycle header: "━━ iter 3/90 · deepseek-chat ━━".
+// Start prints the session header with task preview.
+func (r *Renderer) Start(task string) {
+	if r.disable() {
+		return
+	}
+	preview := r.truncate(strings.ReplaceAll(task, "\n", " "), 80)
+	prefix := "⚡ kode"
+	if r.model != "" {
+		prefix += " · " + r.model
+	}
+	fmt.Fprintln(r.w, r.style(bold+blue, prefix))
+	fmt.Fprintln(r.w, r.style(gray, "   "+preview))
+	fmt.Fprintln(r.w)
+}
+
+// Iteration prints the cycle header.
 func (r *Renderer) Iteration(n, maxN int) {
 	if r.disable() {
 		return
 	}
-	r.iter, r.maxN = n, maxN
-	// Build prefix: iter N/M · model
 	var prefix string
 	if r.model != "" {
-		prefix = fmt.Sprintf("iter %d/%d · %s", n, maxN, r.model)
+		prefix = fmt.Sprintf("Iter %d/%d · %s", n, maxN, r.model)
 	} else {
-		prefix = fmt.Sprintf("iter %d/%d", n, maxN)
+		prefix = fmt.Sprintf("Iter %d/%d", n, maxN)
 	}
-
-	// Horizontal rule framing
-	bar := strings.Repeat("━", 4)
-	line := fmt.Sprintf("%s %s %s", bar, prefix, bar)
+	// Double-line rule framing
+	rule := strings.Repeat("═", 3)
+	line := fmt.Sprintf("%s %s %s", rule, prefix, rule)
 	fmt.Fprintln(r.w)
 	fmt.Fprintln(r.w, r.style(bold+blue, line))
 }
 
-// Thinking prints the model's reasoning text in a dimmed, italic style.
-// This is the "thinking aloud" before the model decides on tool calls.
+// Thinking prints the model's reasoning text with a brain emoji.
 func (r *Renderer) Thinking(text string) {
 	if r.disable() || text == "" {
 		return
 	}
-	r.label("thinking", dim+italic, text)
+	fmt.Fprintln(r.w, r.style(dim+italic, "🧠 "+text))
 }
 
-// ToolCall prints a tool invocation with name and arguments.
-// Arguments are JSON — we pretty-print the name and show a compact arg summary.
+// ToolCall prints a tool invocation with wrench emoji, name, and compact args.
 func (r *Renderer) ToolCall(name, args string) {
 	if r.disable() {
 		return
 	}
-	label := r.style(cyan+bold, "⚙ "+name)
-	fmt.Fprintf(r.w, "%s %s\n", label, r.style(gray, r.truncate(args, 120)))
+	header := r.style(cyan+bold, "🔧 "+name)
+	argStr := r.style(gray, "─── "+r.truncate(args, 100))
+	fmt.Fprintf(r.w, "%s %s\n", header, argStr)
 }
 
 // ToolResult prints a one-line summary of the tool output in gray.
@@ -177,40 +182,26 @@ func (r *Renderer) ToolResult(output string) {
 	fmt.Fprintf(r.w, "%s\n", r.style(gray, "   "+summary))
 }
 
-// FinalAnswer prints the model's concluding response.
+// FinalAnswer prints the model's concluding response with a checkmark emoji.
 func (r *Renderer) FinalAnswer(text string) {
 	if r.disable() || text == "" {
 		return
 	}
 	fmt.Fprintln(r.w)
-	r.label("answer", bold, text)
+	fmt.Fprintln(r.w, r.style(bold+green, "✅ "+text))
 	fmt.Fprintln(r.w)
 }
 
-// Error prints a non-fatal loop error.
+// Error prints a non-fatal loop error with a cross emoji.
 func (r *Renderer) Error(err error) {
 	if r.disable() || err == nil {
 		return
 	}
-	msg := r.style(red, "error: "+err.Error())
-	fmt.Fprintln(r.w, msg)
+	fmt.Fprintln(r.w, r.style(red, "❌ "+err.Error()))
 }
 
 // ── Helpers ───────────────────────────────────────────────────────────
 
-// label prints a labeled block: "─label──" followed by indented text.
-func (r *Renderer) label(name, style, text string) {
-	header := r.style(style, "── "+name+" ──")
-	fmt.Fprintln(r.w, header)
-	// Indent each line of text
-	for _, line := range strings.Split(text, "\n") {
-		if strings.TrimSpace(line) == "" {
-			continue
-		}
-		fmt.Fprintln(r.w, " "+r.truncate(line, MaxToolOutput))
-	}
-}
-
 // style wraps text in ANSI codes. Returns plain text when color is off.
 func (r *Renderer) style(code, text string) string {
 	if !r.color {

internal/render/render_test.go

@@ -7,14 +7,46 @@ import (
 	"testing"
 )
 
+func TestRenderer_Start(t *testing.T) {
+	var buf bytes.Buffer
+	r := New(&buf, true).WithModel("deepseek-chat")
+
+	r.Start("list all files in this directory")
+
+	out := buf.String()
+	if !strings.Contains(out, "kode") {
+		t.Errorf("Start() missing kode brand: %q", out)
+	}
+	if !strings.Contains(out, "deepseek-chat") {
+		t.Errorf("Start() missing model name: %q", out)
+	}
+	if !strings.Contains(out, "list all files") {
+		t.Errorf("Start() missing task preview: %q", out)
+	}
+}
+
+func TestRenderer_Start_LongTask(t *testing.T) {
+	var buf bytes.Buffer
+	r := New(&buf, true).WithModel("deepseek-chat")
+
+	longTask := strings.Repeat("explain this code in great detail ", 10)
+	r.Start(longTask)
+
+	out := buf.String()
+	// Task preview should be truncated to ~80 chars
+	if strings.Count(out, "explain") > 6 {
+		t.Errorf("Start() should truncate long task: %q", out)
+	}
+}
+
 func TestRenderer_Iteration(t *testing.T) {
 	var buf bytes.Buffer
 	r := New(&buf, true).WithModel("deepseek-chat")
 
 	r.Iteration(3, 90)
 
 	out := buf.String()
-	if !strings.Contains(out, "iter 3/90") {
+	if !strings.Contains(out, "Iter 3/90") {
 		t.Errorf("Iteration() missing iteration info: %q", out)
 	}
 	if !strings.Contains(out, "deepseek-chat") {
@@ -29,7 +61,7 @@ func TestRenderer_Iteration_NoModel(t *testing.T) {
 	r.Iteration(1, 10)
 
 	out := buf.String()
-	if !strings.Contains(out, "iter 1/10") {
+	if !strings.Contains(out, "Iter 1/10") {
 		t.Errorf("Iteration() missing iteration info: %q", out)
 	}
 }
@@ -41,12 +73,12 @@ func TestRenderer_Thinking(t *testing.T) {
 	r.Thinking("Let me check the file contents first.")
 
 	out := buf.String()
+	if !strings.Contains(out, "🧠") {
+		t.Errorf("Thinking() missing brain emoji: %q", out)
+	}
 	if !strings.Contains(out, "Let me check the file contents first.") {
 		t.Errorf("Thinking() missing content: %q", out)
 	}
-	if !strings.Contains(out, "thinking") {
-		t.Errorf("Thinking() missing label: %q", out)
-	}
 }
 
 func TestRenderer_Thinking_Empty(t *testing.T) {
@@ -67,6 +99,9 @@ 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, "shell") {
 		t.Errorf("ToolCall() missing tool name: %q", out)
 	}
@@ -83,8 +118,9 @@ func TestRenderer_ToolCall_TruncatedArgs(t *testing.T) {
 	r.ToolCall("read", longArgs)
 
 	out := buf.String()
-	if len(out) > len(longArgs)+100 {
-		t.Errorf("ToolCall() should truncate long args, got %d chars", len(out))
+	// Args truncated to 100 chars
+	if strings.Count(out, "x") >= 200 {
+		t.Errorf("ToolCall() should truncate long args, got %d x chars", strings.Count(out, "x"))
 	}
 	if !strings.Contains(out, "…") {
 		t.Errorf("ToolCall() missing truncation ellipsis: %q", out)
@@ -134,7 +170,7 @@ func TestRenderer_ToolResult_GrayColor(t *testing.T) {
 	r.ToolResult("result text")
 
 	out := buf.String()
-	// Should use gray (dim), not green
+	// Should use gray, not green
 	if strings.Contains(out, green) {
 		t.Errorf("ToolResult() should use gray, not green: %q", out)
 	}
@@ -175,12 +211,12 @@ func TestRenderer_FinalAnswer(t *testing.T) {
 	r.FinalAnswer("The answer is 42.")
 
 	out := buf.String()
+	if !strings.Contains(out, "✅") {
+		t.Errorf("FinalAnswer() missing check emoji: %q", out)
+	}
 	if !strings.Contains(out, "The answer is 42.") {
 		t.Errorf("FinalAnswer() missing content: %q", out)
 	}
-	if !strings.Contains(out, "answer") {
-		t.Errorf("FinalAnswer() missing label: %q", out)
-	}
 }
 
 func TestRenderer_FinalAnswer_Empty(t *testing.T) {
@@ -201,6 +237,9 @@ func TestRenderer_Error(t *testing.T) {
 	r.Error(errors.New("something went wrong"))
 
 	out := buf.String()
+	if !strings.Contains(out, "❌") {
+		t.Errorf("Error() missing cross emoji: %q", out)
+	}
 	if !strings.Contains(out, "something went wrong") {
 		t.Errorf("Error() missing message: %q", out)
 	}
@@ -227,7 +266,7 @@ func TestRenderer_NoColor(t *testing.T) {
 	if strings.Contains(out, "\033[") {
 		t.Errorf("NoColor should strip ANSI codes, got: %q", out)
 	}
-	if !strings.Contains(out, "iter 1/5") {
+	if !strings.Contains(out, "Iter 1/5") {
 		t.Errorf("NoColor should still render text: %q", out)
 	}
 }
@@ -236,6 +275,7 @@ func TestRenderer_NilWriter(t *testing.T) {
 	r := New(nil, true)
 
 	// None of these should panic
+	r.Start("task")
 	r.Iteration(1, 5)
 	r.Thinking("hello")
 	r.ToolCall("shell", "{}")
@@ -248,6 +288,7 @@ func TestRenderer_NilRenderer(t *testing.T) {
 	var r *Renderer
 
 	// None of these should panic on nil receiver
+	r.Start("task")
 	r.Iteration(1, 5)
 	r.Thinking("hello")
 	r.ToolCall("shell", "{}")
@@ -260,7 +301,8 @@ func TestRenderer_FullCycle(t *testing.T) {
 	var buf bytes.Buffer
 	r := New(&buf, true).WithModel("deepseek-chat")
 
-	// Simulate one full iteration
+	// Simulate one full session
+	r.Start("what files are here?")
 	r.Iteration(1, 90)
 	r.Thinking("I need to read the file to understand its contents.")
 	r.ToolCall("shell", `{"command": "cat main.go"}`)
@@ -270,11 +312,19 @@ func TestRenderer_FullCycle(t *testing.T) {
 
 	out := buf.String()
 
-	// Verify each phase is present
-	phases := []string{"iter 1/90", "thinking", "shell", "package main", "iter 2/90", "answer"}
-	for _, phase := range phases {
-		if !strings.Contains(strings.ToLower(out), phase) {
-			t.Errorf("FullCycle missing phase %q in output:\n%s", phase, out)
+	// Verify each phase is present via its emoji
+	emojis := []string{"🧠", "🔧", "✅"}
+	for _, emoji := range emojis {
+		if !strings.Contains(out, emoji) {
+			t.Errorf("FullCycle missing emoji %q in output:\n%s", emoji, out)
+		}
+	}
+
+	// Verify key text
+	texts := []string{"Iter 1/90", "shell", "package main", "Iter 2/90"}
+	for _, text := range texts {
+		if !strings.Contains(out, text) {
+			t.Errorf("FullCycle missing text %q in output:\n%s", text, out)
 		}
 	}