feat: quick wins + animations — spinner cycling, celebration sparkles, chime

- Raise subagent turn limit 15→25 for deeper research
- Persist session title across resume
- Add context_lines param to search_files (like grep -C)
- Enhanced write_file output with line diff (45→52 lines, +7)
- Rainbow celebration border cycling 6 colors over 3s
- Color-cycling tool spinner through accent palette
- Cascading sparkle animation on task completion
- Success chime — 3-note ascending arpeggio via PCM

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: halfaipg

audio.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"math"
 	"math/rand"
+	"os"
 	"os/exec"
 	"sync"
 )
@@ -422,3 +423,87 @@ func (ap *AudioPlayer) Stop() {
 	}
 	ap.cmd.Wait()
 }
+
+// ── Success chime ───────────────────────────────────────────
+
+// chimePattern is a short 3-note ascending arpeggio for task completion.
+var chimePattern = []patternRow{
+	{"C-5", "E-5", "---", "---"},
+	{"E-5", "G-5", "---", "---"},
+	{"G-5", "C-5", "---", "---"},
+}
+
+// PlayChime plays a short success chime (~0.3 seconds).
+// Runs in the background. Respects CODEBASE_NOBOOT / CODEBASE_NOSOUND env vars.
+func PlayChime() {
+	if os.Getenv("CODEBASE_NOBOOT") != "" || os.Getenv("CODEBASE_NOSOUND") != "" {
+		return
+	}
+
+	player := tryChimePlayer()
+	if player == nil {
+		return
+	}
+
+	go func() {
+		synth := &chipSynth{
+			pattern: chimePattern,
+			lead:    channel{envDecay: 0.9995},
+			arp:     channel{envDecay: 0.9996},
+			bass:    channel{envDecay: 0.9999},
+			noise:   channel{envDecay: 0.999},
+		}
+
+		totalSamples := len(chimePattern) * samplesPerRow
+		buf := make([]int16, 1024)
+		pcm := make([]byte, len(buf)*2)
+
+		generated := 0
+		for generated < totalSamples {
+			chunkSize := len(buf)
+			remaining := totalSamples - generated
+			if chunkSize > remaining {
+				chunkSize = remaining
+			}
+			synth.renderSamples(buf[:chunkSize])
+			for i := 0; i < chunkSize; i++ {
+				binary.LittleEndian.PutUint16(pcm[i*2:], uint16(buf[i]))
+			}
+			if _, err := player.writer.Write(pcm[:chunkSize*2]); err != nil {
+				break
+			}
+			generated += chunkSize
+		}
+		player.writer.Close()
+		player.cmd.Wait()
+	}()
+}
+
+// tryChimePlayer creates a raw PCM audio pipe for the chime.
+func tryChimePlayer() *AudioPlayer {
+	if _, err := exec.LookPath("aplay"); err == nil {
+		cmd := exec.Command("aplay", "-t", "raw", "-f", "S16_LE", "-r", "44100", "-c", "1", "-q")
+		stdin, err := cmd.StdinPipe()
+		if err == nil {
+			cmd.Stderr = nil
+			cmd.Stdout = nil
+			if err := cmd.Start(); err == nil {
+				return &AudioPlayer{cmd: cmd, writer: stdin, done: make(chan struct{})}
+			}
+			stdin.Close()
+		}
+	}
+	if _, err := exec.LookPath("paplay"); err == nil {
+		cmd := exec.Command("paplay", "--format=s16le", "--rate=44100", "--channels=1", "--raw")
+		stdin, err := cmd.StdinPipe()
+		if err == nil {
+			cmd.Stderr = nil
+			cmd.Stdout = nil
+			if err := cmd.Start(); err == nil {
+				return &AudioPlayer{cmd: cmd, writer: stdin, done: make(chan struct{})}
+			}
+			stdin.Close()
+		}
+	}
+	return nil
+}

chat.go

@@ -509,6 +509,8 @@ func (m chatModel) Update(msg tea.Msg) (chatModel, tea.Cmd) {
 		var cmd tea.Cmd
 		m.spinner, cmd = m.spinner.Update(msg)
 		cmds = append(cmds, cmd)
+		// Cycle spinner color through accent palette
+		m.spinner.Style = lipgloss.NewStyle().Foreground(spinnerColors[m.notify.frame%len(spinnerColors)])
 		// Only re-render for spinner if there are pending tools (avoids 80ms full rebuild)
 		if m.state == chatStreaming && m.toolsPending > 0 {
 			m.rebuildViewport()
@@ -630,6 +632,9 @@ func (m *chatModel) startAgent(prompt string) {
 			if session := LoadSession(m.config.WorkDir, m.config.Model); session != nil {
 				m.agent.history = session.History
 				m.tokens = session.Tokens
+				if session.Title != "" {
+					m.title = session.Title
+				}
 				m.segments = append(m.segments, segment{
 					kind: "text",
 					text: styleMuted.Render("  Session restored from previous conversation.\n\n"),
@@ -937,11 +942,12 @@ func (m *chatModel) handleAgentEvent(evt AgentEvent) tea.Cmd {
 		if m.agent != nil {
 			m.files = m.agent.FilesChanged()
 			// Persist session to disk
-			SaveSession(m.agent, m.tokens)
+			SaveSession(m.agent, m.tokens, m.title)
 		}
 		m.state = chatDoneFlash
-		m.flashFrames = 1
+		m.flashFrames = 6
 		m.rebuildViewport()
+		go PlayChime()
 
 		// Glue: celebration + follow-up suggestions (in background)
 		summary := evt.Text
@@ -1098,7 +1104,18 @@ func (m chatModel) View() string {
 	case chatStreaming, chatPermission:
 		frame = styleFrameActive.Width(m.width - 2)
 	case chatDoneFlash:
-		frame = styleFrameDone.Width(m.width - 2)
+		colorIdx := len(flashCycleColors) - m.flashFrames
+		if colorIdx < 0 {
+			colorIdx = 0
+		}
+		if colorIdx >= len(flashCycleColors) {
+			colorIdx = len(flashCycleColors) - 1
+		}
+		frame = lipgloss.NewStyle().
+			Border(lipgloss.RoundedBorder()).
+			BorderForeground(flashCycleColors[colorIdx]).
+			Padding(0, 1).
+			Width(m.width - 2)
 	case chatPlanning, chatPlanReview:
 		frame = styleFramePlan.Width(m.width - 2)
 	default:

notify.go

@@ -157,10 +157,12 @@ func (nm *notifyManager) renderOne(n Notification, width int) string {
 
 	content := fmt.Sprintf("  %s %s", icon, text)
 
-	// Celebrate gets sparkle animation
+	// Celebrate gets cascading sparkle animation
 	if n.Type == NotifyCelebrate {
-		sparkle := nm.sparkleFrame()
-		content = fmt.Sprintf("  %s %s %s", sparkle, style.Render(text), sparkle)
+		s1 := nm.sparkleFrameAt(nm.frame)
+		s2 := nm.sparkleFrameAt(nm.frame + 3)
+		s3 := nm.sparkleFrameAt(nm.frame + 6)
+		content = fmt.Sprintf("  %s %s %s %s %s", s1, s2, style.Render(text), s3, s1)
 		return content
 	}
 
@@ -174,7 +176,8 @@ func (nm *notifyManager) icon(t NotifyType) string {
 		return styleMuted.Render("›")
 	case NotifyProgress:
 		frames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-		return lipgloss.NewStyle().Foreground(colCyan).Render(frames[nm.frame%len(frames)])
+		progColor := spinnerColors[(nm.frame/3)%len(spinnerColors)]
+		return lipgloss.NewStyle().Foreground(progColor).Render(frames[nm.frame%len(frames)])
 	case NotifySuccess:
 		return styleOK.Render("✓")
 	case NotifyWarn:
@@ -186,11 +189,16 @@ func (nm *notifyManager) icon(t NotifyType) string {
 	}
 }
 
-// sparkleFrame returns an animated sparkle character.
+// sparkleFrame returns an animated sparkle character at the current frame.
 func (nm *notifyManager) sparkleFrame() string {
-	sparkles := []string{"✦", "✧", "⋆", "✦", "·", "✧", "✦", "⋆"}
+	return nm.sparkleFrameAt(nm.frame)
+}
+
+// sparkleFrameAt returns a sparkle character at a specific frame offset for cascading effects.
+func (nm *notifyManager) sparkleFrameAt(frame int) string {
+	sparkles := []string{"✦", "✧", "⋆", "★", "·", "✧", "✦", "⋆"}
 	colors := []lipgloss.Color{colPurple, colCyan, colAccent, colSuccess, colOrange, colPurple, colCyan, colAccent}
-	idx := nm.frame % len(sparkles)
+	idx := frame % len(sparkles)
 	return lipgloss.NewStyle().Foreground(colors[idx]).Bold(true).Render(sparkles[idx])
 }
 

session.go

@@ -21,6 +21,7 @@ const maxSessionAge = 7 * 24 * time.Hour // 7 days
 type SessionData struct {
 	WorkDir   string        `json:"work_dir"`
 	Model     string        `json:"model"`
+	Title     string        `json:"title,omitempty"`
 	History   []ChatMessage `json:"history"`
 	Tokens    TokenUsage    `json:"tokens"`
 	Files     int           `json:"files"`
@@ -53,7 +54,7 @@ func sessionFile(workDir string) (string, error) {
 }
 
 // SaveSession persists the agent's conversation to disk.
-func SaveSession(agent *Agent, tokens TokenUsage) error {
+func SaveSession(agent *Agent, tokens TokenUsage, title string) error {
 	if agent == nil || len(agent.history) <= 1 {
 		return nil // nothing to save (just system prompt)
 	}
@@ -66,6 +67,7 @@ func SaveSession(agent *Agent, tokens TokenUsage) error {
 	data := SessionData{
 		WorkDir:   agent.workDir,
 		Model:     agent.client.Model,
+		Title:     title,
 		History:   agent.history,
 		Tokens:    tokens,
 		Files:     agent.files,

subagent.go

@@ -15,7 +15,7 @@ import (
 //  Max depth 1 (subagents cannot spawn sub-subagents).
 // ──────────────────────────────────────────────────────────────
 
-const subagentMaxTurns = 15
+const subagentMaxTurns = 25
 
 const subagentSystemPrompt = `You are a focused research assistant. You help gather information by reading files, searching code, and listing directories.
 

theme.go

@@ -94,6 +94,11 @@ var (
 	colPurple    lipgloss.Color
 	colOrange    lipgloss.Color
 	colCyan      lipgloss.Color
+
+	// flashCycleColors is the rainbow border color sequence for completion flash.
+	flashCycleColors []lipgloss.Color
+	// spinnerColors is the color cycle for the tool execution spinner.
+	spinnerColors []lipgloss.Color
 )
 
 // ──────────────────────────────────────────────────────────────
@@ -172,6 +177,10 @@ func initStyles() {
 	colOrange = lipgloss.Color(t.Orange)
 	colCyan = lipgloss.Color(t.Cyan)
 
+	// Animation color cycles
+	flashCycleColors = []lipgloss.Color{colSuccess, colCyan, colAccent, colPurple, colOrange, colSuccess}
+	spinnerColors = []lipgloss.Color{colAccent, colCyan, colPurple, colSuccess, colOrange}
+
 	// Frame styles
 	styleFrame = lipgloss.NewStyle().
 		Border(lipgloss.RoundedBorder()).

tools.go

@@ -187,6 +187,10 @@ var toolDefs = []ToolDef{
 						"type":        "string",
 						"description": "Glob to filter which files to search (e.g. \"*.ts\", \"*.{js,jsx}\").",
 					},
+					"context_lines": map[string]interface{}{
+						"type":        "number",
+						"description": "Number of context lines before and after each match (like grep -C). Default 0.",
+					},
 				},
 				"required": []string{"pattern"},
 			},
@@ -482,16 +486,30 @@ func toolWriteFile(args map[string]interface{}, workDir string) (string, bool) {
 		return fmt.Sprintf("Error creating directory: %v", err), false
 	}
 
+	// Read old content for diff summary before overwriting
+	var oldLineCount int
+	if existed {
+		if oldData, readErr := os.ReadFile(absPath); readErr == nil {
+			oldLineCount = strings.Count(string(oldData), "\n") + 1
+		}
+	}
+
 	if err := os.WriteFile(absPath, []byte(content), perm); err != nil {
 		return fmt.Sprintf("Error: %v", err), false
 	}
 
 	lines := strings.Count(content, "\n") + 1
-	action := "Created"
 	if existed {
-		action = "Updated"
+		lineDiff := lines - oldLineCount
+		diffNote := ""
+		if lineDiff > 0 {
+			diffNote = fmt.Sprintf(", +%d", lineDiff)
+		} else if lineDiff < 0 {
+			diffNote = fmt.Sprintf(", %d", lineDiff)
+		}
+		return fmt.Sprintf("Updated %s (%d→%d lines, %d bytes%s)", relPath, oldLineCount, lines, len(content), diffNote), true
 	}
-	return fmt.Sprintf("%s %s (%d lines, %d bytes)", action, relPath, lines, len(content)), true
+	return fmt.Sprintf("Created %s (%d lines, %d bytes)", relPath, lines, len(content)), true
 }
 
 // ── edit_file ────────────────────────────────────────────────
@@ -881,17 +899,24 @@ func toolSearchFiles(args map[string]interface{}, workDir string) (string, bool)
 		dirPath = "."
 	}
 	include := getString(args, "include")
+	contextLines := 0
+	if cl, ok := getFloat(args, "context_lines"); ok && cl > 0 {
+		contextLines = int(cl)
+		if contextLines > 10 {
+			contextLines = 10
+		}
+	}
 
 	fullPath, err := safePath(workDir, dirPath)
 	if err != nil {
 		return fmt.Sprintf("Error: %v", err), false
 	}
 
 	// Try ripgrep first, fall back to grep
-	output, err := searchWithRg(pattern, fullPath, include, workDir)
+	output, err := searchWithRg(pattern, fullPath, include, workDir, contextLines)
 	if err != nil {
 		// rg not found — try grep
-		output, err = searchWithGrep(pattern, fullPath, include, workDir)
+		output, err = searchWithGrep(pattern, fullPath, include, workDir, contextLines)
 		if err != nil {
 			return fmt.Sprintf("Error: %v", err), false
 		}
@@ -910,7 +935,7 @@ func toolSearchFiles(args map[string]interface{}, workDir string) (string, bool)
 	return truncateOutput(fmt.Sprintf("%d matches for %q in %s:\n\n%s", len(lines), pattern, dirPath, output)), true
 }
 
-func searchWithRg(pattern, searchPath, include, workDir string) (string, error) {
+func searchWithRg(pattern, searchPath, include, workDir string, contextLines int) (string, error) {
 	args := []string{
 		"rg",
 		"--line-number",
@@ -934,6 +959,10 @@ func searchWithRg(pattern, searchPath, include, workDir string) (string, error)
 		args = append(args, "--glob", include)
 	}
 
+	if contextLines > 0 {
+		args = append(args, fmt.Sprintf("-C%d", contextLines))
+	}
+
 	args = append(args, "--", pattern, searchPath)
 
 	cmd := exec.Command(args[0], args[1:]...)
@@ -963,13 +992,18 @@ func searchWithRg(pattern, searchPath, include, workDir string) (string, error)
 	return strings.TrimRight(output, "\n"), nil
 }
 
-func searchWithGrep(pattern, searchPath, include, workDir string) (string, error) {
+func searchWithGrep(pattern, searchPath, include, workDir string, contextLines int) (string, error) {
 	incFlag := "*"
 	if include != "" {
 		incFlag = include
 	}
 
-	cmd := exec.Command("grep", "-rn", "--include="+incFlag, pattern, searchPath)
+	grepArgs := []string{"-rn", "--include=" + incFlag}
+	if contextLines > 0 {
+		grepArgs = append(grepArgs, fmt.Sprintf("-C%d", contextLines))
+	}
+	grepArgs = append(grepArgs, pattern, searchPath)
+	cmd := exec.Command("grep", grepArgs...)
 	cmd.Dir = workDir
 	out, err := cmd.CombinedOutput()