feat(tui): live 'Working' status row + completed-turn separator

Port of the codex turn-progress feedback (screenshot-confirmed format):

- StatusIndicatorWidget: while a turn runs the bottom pane shows
  '• Working (37m 16s • esc to interrupt)' above the composer — blinking
  bullet (600ms), shimmer sweep across 'Working' (shimmer.rs port: 2s
  gaussian-cosine band blending fg toward the detected terminal bg on
  truecolor, dim/plain/bold ladder otherwise), live elapsed via
  FmtElapsedCompact, 32ms tick loop driven by SpinnerTickMsg
- turn lifecycle wiring: TurnStarted starts the row + tick; TurnComplete /
  TurnAborted / Error / StreamError clear it
- Esc now interrupts the running turn (interrupt_turn default binding) when
  no overlay/popup/search owns the key
- FinalMessageSeparator port: turns that ran exec/MCP work append a dim
  full-width rule on completion, labeled '─ Worked for 11m 41s ─…' when the
  turn exceeded 60s (duration from TurnComplete.DurationMs, falling back to
  the local timer); gated on had_work_activity like turn_runtime.rs

The pre-existing RunningSpinner/FmtElapsedCompact ports are now actually
wired. Locked by working_status_test.go (lifecycle, esc interrupt, separator
gating/format); TUI suite + strict parity frames re-verified.

Author: SqlRush

VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

internal/tui/chat.go

@@ -3,6 +3,7 @@ package tui
 import (
 	"fmt"
 	"strings"
+	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
 
@@ -50,6 +51,12 @@ type ChatTranscript struct {
 	// codex's display_lines_for_history_insert in app/resize_reflow.rs).
 	scrollbackEmitted bool
 
+	// turnStartedAt anchors the elapsed time for the completed-turn separator;
+	// hadWorkActivity gates the separator to turns that ran exec/tool calls
+	// (port of turn_runtime.rs had_work_activity).
+	turnStartedAt   time.Time
+	hadWorkActivity bool
+
 	// header retains the session-header seed (version/model/directory) supplied to
 	// WithSessionHeader so a fresh session after /clear can re-seed the same
 	// welcome card. seeded records whether a header was ever attached, so
@@ -177,6 +184,12 @@ func (t ChatTranscript) AppendUserMessage(text string) TranscriptView {
 // applyEvent dispatches on the event's message type.
 func (t ChatTranscript) applyEvent(ev protocol.Event) ChatTranscript {
 	switch ev.Msg.Type {
+	case protocol.EventMsgKindTurnStarted:
+		// Anchor the turn duration and reset the work-activity flag that gates
+		// the completed-turn separator (turn_runtime.rs had_work_activity).
+		t.turnStartedAt = time.Now()
+		t.hadWorkActivity = false
+
 	case protocol.EventMsgKindUserMessage:
 		if ev.Msg.UserMessage != nil && strings.TrimSpace(ev.Msg.UserMessage.Message) != "" {
 			t = t.commitStream()
@@ -217,6 +230,7 @@ func (t ChatTranscript) applyEvent(ev protocol.Event) ChatTranscript {
 			t.cells = t.appendCell(cell)
 			t.execIndex = cloneIndex(t.execIndex)
 			t.execIndex[ev.Msg.ExecCommandBegin.CallID] = len(t.cells) - 1
+			t.hadWorkActivity = true
 		}
 
 	case protocol.EventMsgKindExecCommandOutputDelta:
@@ -236,6 +250,7 @@ func (t ChatTranscript) applyEvent(ev protocol.Event) ChatTranscript {
 			t.cells = t.appendCell(NewToolCallCell(t.theme, title))
 			t.toolIndex = cloneIndex(t.toolIndex)
 			t.toolIndex[ev.Msg.McpToolCallBegin.CallID] = len(t.cells) - 1
+			t.hadWorkActivity = true
 		}
 
 	case protocol.EventMsgKindMcpToolCallEnd:
@@ -273,6 +288,20 @@ func (t ChatTranscript) applyEvent(ev protocol.Event) ChatTranscript {
 
 	case protocol.EventMsgKindTurnComplete, protocol.EventMsgKindTurnAborted:
 		t = t.commitStream()
+		// Completed-turn separator (FinalMessageSeparator): only after a turn
+		// that performed real work (exec/tool calls), labeled with the elapsed
+		// time when over a minute.
+		if t.hadWorkActivity {
+			elapsed := int64(0)
+			if ev.Msg.Type == protocol.EventMsgKindTurnComplete &&
+				ev.Msg.TurnComplete != nil && ev.Msg.TurnComplete.DurationMs != nil {
+				elapsed = *ev.Msg.TurnComplete.DurationMs / 1000
+			} else if !t.turnStartedAt.IsZero() {
+				elapsed = int64(time.Since(t.turnStartedAt).Seconds())
+			}
+			t.cells = t.appendCell(NewWorkedForSeparatorCell(elapsed))
+		}
+		t.hadWorkActivity = false
 	}
 	return t
 }

internal/tui/chat_bottom.go

@@ -3,11 +3,14 @@ package tui
 import (
 	"fmt"
 	"strings"
+	"time"
 	"unicode/utf8"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/mattn/go-runewidth"
+
+	"github.com/sqlrush/codexgo/internal/protocol"
 )
 
 // ChatBottomPane is the bottom-pane implementation of [BottomPane]. It wraps a
@@ -39,6 +42,15 @@ type ChatBottomPane struct {
 	sender *AppEventSender
 	// models is the /model picker entry list supplied by the host.
 	models []ModelPickerEntry
+
+	// taskRunning tracks whether a turn is in flight; while true the pane
+	// renders the live "Working (…)" status row above the composer (port of
+	// StatusIndicatorWidget) and Esc interrupts the turn.
+	taskRunning bool
+	// taskStartedAt anchors the elapsed display.
+	taskStartedAt time.Time
+	// spinner is the working-status row state (blink frame + elapsed).
+	spinner RunningSpinner
 }
 
 // ChatBottomPaneConfig parameterizes a [ChatBottomPane].
@@ -86,6 +98,14 @@ func (p ChatBottomPane) Update(msg tea.Msg) (BottomPane, tea.Cmd) {
 	case StatusMsg:
 		p.status = string(m)
 		return p, nil
+	case CoreEventMsg:
+		return p.handleCoreEvent(m)
+	case SpinnerTickMsg:
+		if !p.taskRunning {
+			return p, nil // task ended; let the tick loop die
+		}
+		p.spinner = p.spinner.Tick().WithElapsed(time.Since(p.taskStartedAt))
+		return p, SpinnerTickCmd()
 	case OpenSlashOverlayEvent:
 		return p.handleSlashOverlay(m)
 	case ModelSelectedEvent:
@@ -98,11 +118,39 @@ func (p ChatBottomPane) Update(msg tea.Msg) (BottomPane, tea.Cmd) {
 			p.overlays = stack
 			return p, cmd
 		}
+		// Esc interrupts the running turn (codex's interrupt_turn default
+		// binding) when no popup/search owns the key.
+		if m.Type == tea.KeyEsc && p.taskRunning &&
+			!p.composer.PopupVisible() && !p.composer.SearchActive() {
+			return p, EventCmd(CodexOpEvent{Command: NewInterruptCommand()})
+		}
 		return p.handleKey(m)
 	}
 	return p, nil
 }
 
+// handleCoreEvent tracks turn lifecycle events to drive the working-status row
+// (the Rust ChatWidget flips its StatusIndicatorWidget on TaskStarted /
+// TaskComplete; errors and aborts also clear it).
+func (p ChatBottomPane) handleCoreEvent(ev CoreEventMsg) (BottomPane, tea.Cmd) {
+	switch ev.Event.Msg.Type {
+	case protocol.EventMsgKindTurnStarted:
+		p.taskRunning = true
+		p.taskStartedAt = time.Now()
+		p.spinner = NewRunningSpinner(true).WithTrueColor(p.colorLevel == ColorLevelTrueColor)
+		p.composer = p.composer.SetTaskRunning(true)
+		return p, SpinnerTickCmd()
+	case protocol.EventMsgKindTurnComplete,
+		protocol.EventMsgKindTurnAborted,
+		protocol.EventMsgKindError,
+		protocol.EventMsgKindStreamError:
+		p.taskRunning = false
+		p.composer = p.composer.SetTaskRunning(false)
+		return p, nil
+	}
+	return p, nil
+}
+
 // handleSlashOverlay opens the picker/overlay owned by a delegated slash
 // command. Commands without a wired overlay surface a status notice instead of
 // silently doing nothing.
@@ -205,6 +253,12 @@ func (p ChatBottomPane) View(area Rect) string {
 	}
 	var rows []string
 
+	// Live working-status row above the composer while a turn runs (port of
+	// the StatusIndicatorWidget placement: status row → composer → footer).
+	if p.taskRunning {
+		rows = append(rows, p.spinner.Line(p.theme))
+	}
+
 	if query, preview, active := p.composer.CurrentSearch(); active {
 		rows = append(rows, p.renderSearchBar(query, preview, area.Width))
 	} else {
@@ -455,6 +509,9 @@ func (p ChatBottomPane) DesiredHeight(width int) int {
 	}
 	// Composer block: top padding + textarea rows + bottom padding.
 	h := textRows + 2
+	if p.taskRunning {
+		h++ // live working-status row above the composer
+	}
 
 	if items, _, ok := p.composer.PopupRows(); ok {
 		n := len(items)

internal/tui/history_cell.go

@@ -450,3 +450,40 @@ func splitTrimmed(s string) []string {
 	}
 	return strings.Split(s, "\n")
 }
+
+// WorkedForSeparatorCell is the completed-turn separator inserted after a turn
+// that performed real work (port of history_cell/separators.rs
+// FinalMessageSeparator, minus the runtime-metrics label which codexgo does
+// not collect): a full-width dim rule, labeled "─ Worked for <elapsed> ─" when
+// the turn ran longer than 60 seconds.
+type WorkedForSeparatorCell struct {
+	// ElapsedSeconds is the turn duration; values <= 60 render an unlabeled rule.
+	ElapsedSeconds int64
+}
+
+// NewWorkedForSeparatorCell builds the separator for a completed turn.
+func NewWorkedForSeparatorCell(elapsedSeconds int64) WorkedForSeparatorCell {
+	return WorkedForSeparatorCell{ElapsedSeconds: elapsedSeconds}
+}
+
+// Lines implements HistoryCell.
+func (c WorkedForSeparatorCell) Lines(width int) []Line {
+	if width <= 0 {
+		return nil
+	}
+	dim := Style{Dim: true}
+	if c.ElapsedSeconds <= 60 {
+		return []Line{{Spans: []Span{StyledSpan(strings.Repeat("─", width), dim)}}}
+	}
+	label := fmt.Sprintf("─ Worked for %s ─", FmtElapsedCompact(c.ElapsedSeconds))
+	labelRunes := []rune(label)
+	if len(labelRunes) > width {
+		labelRunes = labelRunes[:width]
+	}
+	fill := width - len(labelRunes)
+	text := string(labelRunes)
+	if fill > 0 {
+		text += strings.Repeat("─", fill)
+	}
+	return []Line{{Spans: []Span{StyledSpan(text, dim)}}}
+}

internal/tui/shimmer.go

@@ -0,0 +1,84 @@
+package tui
+
+// Shimmer text effect for the live "Working" status header — a port of
+// codex-rs/tui/src/shimmer.rs shimmer_spans: a gaussian-cosine band sweeps
+// across the characters on a 2-second period (synchronized to process start),
+// blending each character's foreground toward the terminal background at the
+// band's center. On non-truecolor terminals it falls back to a dim/plain/bold
+// intensity ladder (color_for_level).
+
+import (
+	"math"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+// shimmerEpoch anchors the sweep to process start, mirroring the Rust
+// OnceLock<Instant> elapsed_since_start.
+var shimmerEpoch = time.Now()
+
+// shimmer tuning constants (verbatim from shimmer.rs).
+const (
+	shimmerPadding       = 10
+	shimmerSweepSeconds  = 2.0
+	shimmerBandHalfWidth = 5.0
+	shimmerHighlightMix  = 0.9
+)
+
+// ShimmerRender renders text with the moving-highlight effect. fg is the base
+// text color and bg the highlight target (the detected terminal background);
+// hasTrueColor selects the RGB blend path versus the modifier ladder.
+func ShimmerRender(text string, fg, bg RGB, hasTrueColor bool) string {
+	chars := []rune(text)
+	if len(chars) == 0 {
+		return ""
+	}
+
+	period := float64(len(chars) + shimmerPadding*2)
+	elapsed := time.Since(shimmerEpoch).Seconds()
+	pos := math.Mod(elapsed, shimmerSweepSeconds) / shimmerSweepSeconds * period
+
+	var b strings.Builder
+	for i, ch := range chars {
+		dist := math.Abs(float64(i+shimmerPadding) - pos)
+		t := 0.0
+		if dist <= shimmerBandHalfWidth {
+			x := math.Pi * (dist / shimmerBandHalfWidth)
+			t = 0.5 * (1.0 + math.Cos(x))
+		}
+		b.WriteString(shimmerCharStyle(t, fg, bg, hasTrueColor).Render(string(ch)))
+	}
+	return b.String()
+}
+
+// shimmerCharStyle resolves the style for one character at band intensity t.
+func shimmerCharStyle(t float64, fg, bg RGB, hasTrueColor bool) lipgloss.Style {
+	if hasTrueColor {
+		blended := Blend(bg, fg, clamp01(t)*shimmerHighlightMix)
+		return lipgloss.NewStyle().
+			Renderer(trueColorRenderer).
+			Foreground(lipgloss.Color(blended.Hex())).
+			Bold(true)
+	}
+	// color_for_level fallback: dim below 0.2, plain to 0.6, bold above.
+	switch {
+	case t < 0.2:
+		return lipgloss.NewStyle().Faint(true)
+	case t < 0.6:
+		return lipgloss.NewStyle()
+	default:
+		return lipgloss.NewStyle().Bold(true)
+	}
+}
+
+func clamp01(v float64) float64 {
+	if v < 0 {
+		return 0
+	}
+	if v > 1 {
+		return 1
+	}
+	return v
+}

internal/tui/status_render.go

@@ -5,6 +5,8 @@ import (
 	"strings"
 	"time"
 
+	tea "github.com/charmbracelet/bubbletea"
+
 	"github.com/sqlrush/codexgo/internal/protocol"
 )
 
@@ -239,6 +241,24 @@ type RunningSpinner struct {
 	InlineMessage string
 	// frame advances the blink animation.
 	frame int
+	// trueColor enables the RGB shimmer path on the header.
+	trueColor bool
+}
+
+// WithTrueColor returns a copy with the RGB shimmer path toggled.
+func (s RunningSpinner) WithTrueColor(on bool) RunningSpinner {
+	s.trueColor = on
+	return s
+}
+
+// SpinnerTickMsg drives the working-status animation; the bottom pane
+// reschedules it via SpinnerTickCmd while a task is running.
+type SpinnerTickMsg struct{}
+
+// SpinnerTickCmd schedules the next animation frame (32ms cadence, matching
+// the Rust schedule_frame_in).
+func SpinnerTickCmd() tea.Cmd {
+	return tea.Tick(SpinnerTickInterval, func(time.Time) tea.Msg { return SpinnerTickMsg{} })
 }
 
 // NewRunningSpinner returns a spinner with upstream defaults (port of
@@ -297,7 +317,13 @@ func (s RunningSpinner) Line(theme Theme) string {
 		b.WriteString(lipFg(theme.Primary).Render(ind))
 		b.WriteString(" ")
 	}
-	b.WriteString(lipFg(theme.Primary).Render(s.Header))
+	// The header carries codex's shimmer sweep (shimmer.rs): highlight toward
+	// the detected terminal background on truecolor, modifier ladder otherwise.
+	shimmerBg := theme.TerminalBgRGB
+	if !theme.HasTerminalBg {
+		shimmerBg = RGB{255, 255, 255}
+	}
+	b.WriteString(ShimmerRender(s.Header, theme.ForegroundRGB, shimmerBg, s.trueColor && theme.HasTerminalBg))
 	b.WriteString(" ")
 
 	pretty := FmtElapsedCompact(int64(s.Elapsed.Seconds()))