@@ -6,7 +6,23 @@ The format is based on [Keep a
 Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.4.0] - 2026-04-21
+
+### Changed 
+
+- **TUI is now fully functional and production-ready**: Replaced the
+work-in-progress TUI implementation with a robust Bubble Tea command pattern:
+  - Runtime execution now uses native `tea.Cmd` instead of manual goroutine
+  orchestration.
+  - Added real-time progress updates via `progress.Progress` interface with
+  stage, substage, and article count messages.
+  - TUI displays a spinner, elapsed time, and final summary inline.
+  - Removed signal handling and channel synchronisation in favour of Bubble
+  Tea's built-in lifecycle.
+  - `TUIProgress` now only sends messages to an existing program, simplifying
+  integration.
+  - Both verbose mode (`SimpleLogger`) and TUI mode share the same
+  `progress.Progress` interface.
 
 ## [0.3.0] - 2026-04-21
 

@@ -4,15 +4,13 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"os/signal"
-	"syscall"
 
+	tea "github.com/charmbracelet/bubbletea"
 	"llm_aggregator/internal/cli"
 	"llm_aggregator/internal/config"
+	"llm_aggregator/internal/progress"
 	"llm_aggregator/internal/runtime"
 	"llm_aggregator/internal/tui"
-
-	tea "github.com/charmbracelet/bubbletea"
 )
 
 var (
@@ -23,7 +21,7 @@
 func main() {
 	cli.BuildDate = buildDate
 	cli.Version = version
-	
+
 	// Load configuration from file and environment variables
 	cfg, err := config.Load()
 	if err != nil {
@@ -43,7 +41,7 @@ // Create runtime configuration
 	rt := runtime.NewRuntime()
 	rt.FeedsFile = args.FeedsFile
 	rt.Prompt = args.Prompt
-	
+
 	// Apply configuration with precedence: CLI args > Environment vars > Config file > Defaults
 	applyConfiguration(rt, cfg, args)
 
@@ -69,32 +67,32 @@ rt.MaxArticlesPerFeed = args.MaxArticlesPerFeed
 	} else if cfg.MaxArticlesPerFeed != 0 {
 		rt.MaxArticlesPerFeed = cfg.MaxArticlesPerFeed
 	}
-	
+
 	if args.MaxDaysOld != 0 {
 		rt.MaxDaysOld = args.MaxDaysOld
 	} else if cfg.MaxDaysOld != 0 {
 		rt.MaxDaysOld = cfg.MaxDaysOld
 	}
-	
+
 	if args.MaxTotalArticles != 0 {
 		rt.MaxTotalArticles = args.MaxTotalArticles
 	} else if cfg.MaxTotalArticles != 0 {
 		rt.MaxTotalArticles = cfg.MaxTotalArticles
 	}
-	
+
 	// Content filtering - CLI args override config
 	if args.IncludeKeywords != "" {
 		rt.IncludeKeywords = cli.ParseKeywords(args.IncludeKeywords)
 	} else if cfg.IncludeKeywords != "" {
 		rt.IncludeKeywords = cli.ParseKeywords(cfg.IncludeKeywords)
 	}
-	
+
 	if args.ExcludeKeywords != "" {
 		rt.ExcludeKeywords = cli.ParseKeywords(args.ExcludeKeywords)
 	} else if cfg.ExcludeKeywords != "" {
 		rt.ExcludeKeywords = cli.ParseKeywords(cfg.ExcludeKeywords)
 	}
-	
+
 	// Deepseek API options - CLI args override config
 	if args.APIKey != "" {
 		rt.APIKey = args.APIKey
@@ -104,123 +102,78 @@ } else {
 		// Fall back to environment variable
 		rt.APIKey = os.Getenv("LLM_AGGREGATOR_API_KEY")
 	}
-	
+
 	if args.Model != "" {
 		rt.Model = args.Model
 	} else if cfg.Model != "" {
 		rt.Model = cfg.Model
 	}
-	
+
 	if args.MaxTokens != 0 {
 		rt.MaxTokens = args.MaxTokens
 	} else if cfg.MaxTokens != 0 {
 		rt.MaxTokens = cfg.MaxTokens
 	}
-	
+
 	if args.Temperature != 0 {
 		rt.Temperature = args.Temperature
 	} else if cfg.Temperature != 0 {
 		rt.Temperature = cfg.Temperature
 	}
-	
+
 	// System prompt - CLI args override config
 	if args.SystemPrompt != "" {
 		rt.SystemPrompt = args.SystemPrompt
 	} else if cfg.SystemPrompt != "" {
 		rt.SystemPrompt = cfg.SystemPrompt
 	}
-	
+
 	// Output options - CLI args override config
 	if args.Output != "" {
 		rt.Output = args.Output
 	} else if cfg.Output != "" {
 		rt.Output = cfg.Output
 	}
-	
+
 	if args.OutputFile != "" {
 		rt.OutputFile = args.OutputFile
 	} else if cfg.OutputFile != "" {
 		rt.OutputFile = cfg.OutputFile
 	}
-	
+
 	rt.IncludeArticles = args.IncludeArticles || cfg.IncludeArticles
 	rt.Verbose = args.Verbose
 }
 
 func runWithTUI(rt *runtime.Runtime) {
-	// Create TUI model
-	m := tui.New()
-	p := tea.NewProgram(m, tea.WithAltScreen())
+	// 1. Create the model and pass the runtime to it.
+	model := tui.New(rt)
 
-	// Run TUI in goroutine
-	done := make(chan error)
-	go func() {
-		if _, err := p.Run(); err != nil {
-			done <- err
-			return
-		}
-		done <- nil
-	}()
+	// 2. Create the tea.Program.
+	p := tea.NewProgram(model, tea.WithAltScreen())
 
-	// Run aggregation in another goroutine
-	go func() {
-		// Create context for cancellation
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
+	// 3. Create the TUIProgress handler and give it the program instance.
+	//    This is the bridge that allows the runtime to send messages to the TUI.
+	tp := tui.NewTUIProgress(p)
 
-		// Set up signal handling
-		sigCh := make(chan os.Signal, 1)
-		signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
-
-		// Handle signals
-		go func() {
-			<-sigCh
-			p.Send(tui.Error("Operation cancelled"))
-			cancel()
-		}()
-
-		// Update TUI status
-		p.Send(tui.Step(1, fmt.Sprintf("Aggregating feeds from: %s", rt.FeedsFile)))
-
-		// Execute the runtime
-		err := rt.Execute(ctx)
-		if err != nil {
-			p.Send(tui.Error(err.Error()))
-			return
-		}
-
-		// Update TUI status
-		p.Send(tui.StepWithCounts(5, "Formatting output", len(rt.Articles), len(rt.Articles)))
-
-		// Write output
-		if rt.OutputFile != "" {
-			if err := rt.WriteOutputToFile(); err != nil {
-				p.Send(tui.Error(fmt.Sprintf("Error writing output: %v", err)))
-				return
-			}
-			p.Send(tui.Step(6, fmt.Sprintf("Output written to: %s", rt.OutputFile)))
-		} else {
-			if err := rt.WriteOutput(os.Stdout); err != nil {
-				p.Send(tui.Error(fmt.Sprintf("Error writing output: %v", err)))
-				return
-			}
-			p.Send(tui.Step(6, "Output complete"))
-		}
+	// 4. Inject the progress handler into the runtime.
+	rt.Progress = tp
 
-		// Mark as done
-		p.Send(tui.Step(7, "Processing completed successfully"))
-	}()
-
-	// Wait for TUI to complete
-	if err := <-done; err != nil {
-		fmt.Fprintf(os.Stderr, "TUI error: %v\n", err)
+	// 5. Run the program. This is a blocking call.
+	if _, err := p.Run(); err != nil {
+		fmt.Fprintf(os.Stderr, "TUI Error: %v\n", err)
 		os.Exit(1)
 	}
 }
 
 func runWithoutTUI(rt *runtime.Runtime, verbose bool) {
-	// Set verbose flag on runtime
-	rt.Verbose = verbose
+	// Setup logger based on verbose flag and inject it into the runtime
+	if verbose {
+		rt.Progress = progress.NewSimpleLogger(os.Stdout, true)
+	} else {
+		// Default is already NoopLogger, but we can be explicit
+		rt.Progress = &progress.NoopLogger{}
+	}
 
 	// Execute the runtime
 	err := rt.Execute(context.Background())

@@ -250,4 +250,3 @@ }
 
 	return formatter.FormatData(data)
 }
-

@@ -48,12 +48,19 @@ fmt.Fprintf(sl.writer, "Debug: "+format+"\n", args...)
 	}
 }
 
+func (sl *SimpleLogger) SetStage(stage string)                {}
+func (sl *SimpleLogger) SetSubStage(stage string)             {}
+func (sl *SimpleLogger) SetArticleCount(total, processed int) {}
+
 // NoopLogger implements Logger with no output
 type NoopLogger struct{}
 
-func (nl *NoopLogger) Logf(format string, args ...any)     {}
-func (nl *NoopLogger) Warningf(format string, args ...any) {}
-func (nl *NoopLogger) Debugf(format string, args ...any)   {}
+func (nl *NoopLogger) Logf(format string, args ...any)      {}
+func (nl *NoopLogger) Warningf(format string, args ...any)  {}
+func (nl *NoopLogger) Debugf(format string, args ...any)    {}
+func (nl *NoopLogger) SetStage(stage string)                {}
+func (nl *NoopLogger) SetSubStage(status string)            {}
+func (nl *NoopLogger) SetArticleCount(total, processed int) {}
 
 // Context provides progress context for components
 type Context struct {
@@ -87,4 +94,3 @@ if c.logger != nil {
 		c.logger.Debugf(format, args...)
 	}
 }
-

@@ -38,9 +38,9 @@ // State
 	Articles []map[string]any
 	Summary  string
 	Error    error
-	
+
 	// Logger for verbose output
-	logger *progress.Context
+	Progress progress.Progress
 }
 
 // NewRuntime creates a new runtime with default values
@@ -53,54 +53,61 @@ Model:              "deepseek-chat",
 		MaxTokens:          2000,
 		Temperature:        0.7,
 		Output:             "text",
-		// SystemPrompt left empty to be filled from config or use deepseek default
+		Progress:           &progress.NoopLogger{},
 	}
 }
 
 // Execute runs the full aggregation pipeline
 func (r *Runtime) Execute(ctx context.Context) error {
-	// Setup logger based on verbose flag
-	if r.Verbose {
-		r.logger = progress.NewContext(progress.NewSimpleLogger(os.Stdout, true))
-	} else {
-		r.logger = progress.NewContext(&progress.NoopLogger{})
-	}
+	// The logger/progress handler is injected, so we don't create it here.
+	// We wrap it in a context to pass to sub-modules that expect a *progress.Context.
+	progCtx := progress.NewContext(r.Progress)
 
 	// Step 1: Aggregate feeds
+	r.Progress.SetStage("Aggregating feeds")
+	r.Progress.SetSubStage(fmt.Sprintf("Parsing feeds from %s", r.FeedsFile))
+
 	feedAgg := aggregator.NewFeedAggregatorWithProgress(
 		r.MaxArticlesPerFeed,
 		r.MaxDaysOld,
-		5000, // max content length
-		r.logger,
+		5000,    // max content length
+		progCtx, // MODIFIED: Pass the new progress context
 	)
 
 	articles, err := feedAgg.ParseFeedsFromFile(r.FeedsFile)
 	if err != nil {
 		return fmt.Errorf("error aggregating feeds: %w", err)
 	}
-
 	if len(articles) == 0 {
-		return fmt.Errorf("no articles found")
+		return fmt.Errorf("no articles found after parsing feeds")
 	}
+	r.Progress.SetArticleCount(len(articles), 0)
 
 	// Step 2: Process content
+	r.Progress.SetStage("Processing articles")
+	r.Progress.SetSubStage(fmt.Sprintf("Filtering and sorting %d articles", len(articles)))
+
 	contentProc := processor.NewContentProcessor(
 		r.MaxTotalArticles,
 		3000, // max content per article
 		r.IncludeKeywords,
 		r.ExcludeKeywords,
 	)
-	contentProc.SetLogger(r.logger)
+	contentProc.SetLogger(progCtx) // MODIFIED: Pass the new progress context
 
 	processedArticles := contentProc.ProcessArticles(articles, "date", true)
 
 	if len(processedArticles) == 0 {
 		return fmt.Errorf("no articles passed filtering")
 	}
+	r.Progress.SetArticleCount(len(articles), len(articles)-len(processedArticles))
 
 	r.Articles = processedArticles
 
 	// Step 3: Initialise Deepseek client
+	r.Progress.SetStage("Connecting to LLM")
+	r.Progress.SetSubStage(fmt.Sprintf("Using model: %s", r.Model))
+
 	deepseek, err := llm.NewDeepseekClient(
 		r.APIKey,
 		"", // default base URL
@@ -111,9 +118,12 @@ )
 	if err != nil {
 		return fmt.Errorf("error initialising Deepseek client: %w", err)
 	}
-	deepseek.SetLogger(r.logger)
+	deepseek.SetLogger(progCtx) // MODIFIED: Pass the new progress context
 
 	// Step 4: Get summary from Deepseek
+	r.Progress.SetStage("Getting summary")
+	r.Progress.SetSubStage(fmt.Sprintf("Sending %d articles to LLM", len(processedArticles)))
+
 	summary, err := deepseek.SummariseArticles(
 		processedArticles,
 		r.Prompt,
@@ -124,6 +134,7 @@ return fmt.Errorf("error getting summary from Deepseek: %w", err)
 	}
 
 	r.Summary = summary
+	r.Progress.SetArticleCount(len(processedArticles), len(processedArticles))
 	return nil
 }
 
@@ -173,4 +184,3 @@ defer file.Close()
 
 	return r.WriteOutput(file)
 }
-

@@ -1,13 +1,16 @@
 package tui
 
 import (
+	"context"
 	"fmt"
 	"strings"
 	"time"
 
 	"github.com/charmbracelet/bubbles/progress"
+	"github.com/charmbracelet/bubbles/spinner"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
+	"llm_aggregator/internal/runtime"
 )
 
 const (
@@ -25,8 +28,7 @@ MarginLeft(2).
 			MarginRight(2).
 			Padding(0, 1).
 			Italic(true).
-			Foreground(lipgloss.Color("#FFF7DB")).
-			SetString("LLM Aggregator")
+			Foreground(lipgloss.Color("#FFF7DB"))
 
 	infoStyle = lipgloss.NewStyle().
 			Foreground(subtle).
@@ -43,22 +45,35 @@ stepNames = []string{
 		"Initialising",
 		"Aggregating feeds",
 		"Processing articles",
-		"Connecting to DeepSeek",
+		"Connecting to LLM",
 		"Getting summary",
 		"Formatting output",
 		"Complete",
 	}
 )
 
+type StageMsg string
+type SubStageMsg string
+type ArticleCountMsg struct {
+	Total, Processed int
+}
+
+type processingDoneMsg struct {
+	err error
+}
+
 type progressMsg float64
 
 type Model struct {
 	progress       progress.Model
+	spinner        spinner.Model
+	runtime        *runtime.Runtime
 	currentStep    int
 	totalSteps     int
 	status         string
 	subStatus      string
 	startTime      time.Time
+	elapsed        time.Duration
 	width          int
 	height         int
 	done           bool
@@ -67,15 +82,21 @@ articlesCount  int
 	processedCount int
 }
 
-func New() *Model {
+func New(rt *runtime.Runtime) *Model {
 	prog := progress.New(
 		progress.WithScaledGradient("#FF7CCB", "#FDFF8C"),
 		progress.WithWidth(40),
 		progress.WithoutPercentage(),
 	)
 
+	sp := spinner.New()
+	sp.Spinner = spinner.Dot
+	sp.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("#FF7CCB"))
+
 	return &Model{
 		progress:    prog,
+		spinner:     sp,
+		runtime:     rt,
 		currentStep: 0,
 		totalSteps:  len(stepNames) - 1, // Last step is "Complete"
 		status:      "Initialising...",
@@ -85,7 +106,15 @@ }
 }
 
 func (m *Model) Init() tea.Cmd {
-	return nil
+	return tea.Batch(m.spinner.Tick, m.startProcessing)
+}
+
+// MODIFIED: This is now the standard bubbletea command pattern.
+// The bubbletea runtime will execute this function in a goroutine.
+// We no longer need to manage the goroutine or use program.Send().
+func (m *Model) startProcessing() tea.Msg {
+	err := m.runtime.Execute(context.Background())
+	return processingDoneMsg{err: err}
 }
 
 func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
@@ -98,32 +127,58 @@ }
 	case tea.WindowSizeMsg:
 		m.width = msg.Width
 		m.height = msg.Height
-		m.progress.Width = msg.Width - padding*2 - 4
-		if m.progress.Width > maxWidth {
-			m.progress.Width = maxWidth
-		}
+		m.progress.Width = min(msg.Width-padding*2-4, maxWidth)
 	case progressMsg:
+		// This message type seems unused, but leaving it in case.
 		progress := float64(msg)
 		if progress >= 1.0 {
 			m.done = true
-			return m, tea.Quit
+			return m, nil
 		}
 		cmd := m.progress.SetPercent(float64(progress))
 		return m, cmd
-	case StepMsg:
-		if msg.Step >= 0 && msg.Step < len(stepNames) {
-			m.currentStep = msg.Step
-			m.status = stepNames[msg.Step]
-			if msg.Status != "" {
-				m.subStatus = msg.Status
-			}
-			if msg.ArticlesCount > 0 {
-				m.articlesCount = msg.ArticlesCount
-			}
-			if msg.ProcessedCount > 0 {
-				m.processedCount = msg.ProcessedCount
+	case spinner.TickMsg:
+		// MODIFIED: Stop updating the spinner once we're done.
+		if m.done {
+			return m, nil
+		}
+		var cmd tea.Cmd
+		m.spinner, cmd = m.spinner.Update(msg)
+		return m, cmd
+	case StageMsg:
+		stageName := string(msg)
+		for i, name := range stepNames {
+			if name == stageName {
+				m.currentStep = i
+				m.status = name
+				m.subStatus = "" // Clear sub-status when stage changes
+				break
 			}
 		}
+
+	case SubStageMsg:
+		m.subStatus = string(msg)
+
+	case ArticleCountMsg:
+		m.articlesCount = msg.Total
+		m.processedCount = msg.Processed
+
+	case processingDoneMsg:
+		if msg.err != nil {
+			m.errorMsg = msg.err.Error()
+			m.done = true // Also mark as done on error
+		} else {
+			m.done = true
+			m.currentStep = m.totalSteps // Go to "Complete" step
+			m.status = stepNames[m.totalSteps]
+			m.subStatus = "Summary generated successfully!"
+		}
+		// MODIFIED: Capture the final elapsed time.
+		m.elapsed = time.Since(m.startTime)
+		// We are done, so we return a command to quit the program automatically.
+		// The user can see the final summary. If we want the user to quit manually,
+		// just return 'm, nil'.
+		return m, nil
 	case ErrorMsg:
 		m.errorMsg = msg.Error
 		m.status = "Error"
@@ -141,17 +196,36 @@
 	var sb strings.Builder
 
 	// Title
-	sb.WriteString(titleStyle.Render("🤖 LLM RSS Aggregator"))
+	sb.WriteString(titleStyle.Render("🤖 LLM Aggregator"))
 	sb.WriteString("\n\n")
 
-	// Progress bar
-	progressPercent := float64(m.currentStep) / float64(m.totalSteps)
+	// MODIFIED: If done, show 100% progress.
+	var progressPercent float64
+	if m.done && m.errorMsg == "" {
+		progressPercent = 1.0
+	} else if m.articlesCount > 0 && m.currentStep >= 4 {
+		progressPercent = float64(m.processedCount) / float64(m.articlesCount)
+	} else {
+		progressPercent = float64(m.currentStep) / float64(m.totalSteps)
+	}
+
 	progressView := m.progress.ViewAs(progressPercent)
 	sb.WriteString(progressBarStyle.Render(progressView))
 	sb.WriteString("\n\n")
 
-	// Status
+	// Status with spinner
 	sb.WriteString(statusStyle.Render("Status: "))
+
+	// MODIFIED: Replace spinner with a checkmark when done.
+	if m.done && m.errorMsg == "" {
+		sb.WriteString(lipgloss.NewStyle().Foreground(special).Render("✓"))
+	} else if m.done && m.errorMsg != "" {
+		sb.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color("#FF0000")).Render("✗"))
+	} else {
+		sb.WriteString(m.spinner.View())
+	}
+
+	sb.WriteString(" ")
 	sb.WriteString(m.status)
 	sb.WriteString("\n")
 
@@ -173,8 +247,12 @@ sb.WriteString("\n")
 	}
 
 	// Elapsed time
-	elapsed := time.Since(m.startTime).Round(time.Second)
-	sb.WriteString(infoStyle.Render(fmt.Sprintf("Elapsed: %v", elapsed)))
+	// MODIFIED: Use the stored elapsed time if done, otherwise calculate it live.
+	elapsed := m.elapsed
+	if !m.done {
+		elapsed = time.Since(m.startTime)
+	}
+	sb.WriteString(infoStyle.Render(fmt.Sprintf("Elapsed: %v", elapsed.Round(time.Second))))
 	sb.WriteString("\n\n")
 
 	// Error message (if any)
@@ -187,15 +265,41 @@ sb.WriteString(m.errorMsg)
 		sb.WriteString("\n\n")
 	}
 
-	// Help text
-	if !m.done && m.errorMsg == "" {
+	// MODIFIED: Simplified help text logic
+	if m.done {
+		// The summary is not part of the TUI, it's printed to stdout *after* the TUI exits.
+		// The TUI's job is just to show the progress.
+		// The `tea.Quit` in the `processingDoneMsg` case will cause the program to exit
+		// and the rest of the `main` function to proceed.
+	} else {
 		sb.WriteString(infoStyle.Render("Press 'q' or Ctrl+C to quit"))
-	} else if m.done {
-		completeStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#43BF6D")).
-			Bold(true)
-		sb.WriteString(completeStyle.Render("✓ Processing complete!"))
+	}
+
+	// If the runtime has a summary and we are done, we can show it here.
+	// However, the typical flow is for the TUI to finish, and then the main
+	// function prints the final output. If we want to show it *in* the TUI,
+	// we would add this block:
+	if m.done && m.runtime.Summary != "" {
+		summaryTitleStyle := lipgloss.NewStyle().Bold(true).Underline(true)
+		sb.WriteString(summaryTitleStyle.Render("Summary"))
 		sb.WriteString("\n")
+
+		// Calculate a safe width for wrapping (terminal width minus some margin)
+		wrapWidth := max(m.width-4,
+			// Sane minimum fallback
+			20)
+
+		// Create a style that enforces word-wrapping
+		summaryStyle := lipgloss.NewStyle().
+			Width(wrapWidth)
+
+		// Render the summary through the style to apply the wrapping
+		sb.WriteString(summaryStyle.Render(m.runtime.Summary))
+		sb.WriteString("\n\n")
+
+		sb.WriteString(infoStyle.Render("Press 'q' to exit."))
+	} else if m.done {
+		sb.WriteString(infoStyle.Render("Press 'q' to exit."))
 	}
 
 	return sb.String()
@@ -234,4 +338,4 @@ func Error(err string) tea.Cmd {
 	return func() tea.Msg {
 		return ErrorMsg{Error: err}
 	}
-}+}

@@ -1,12 +1,9 @@
 package tui
 
 import (
-	"context"
 	"fmt"
-	"time"
 
 	"llm_aggregator/internal/progress"
-	"llm_aggregator/internal/runtime"
 
 	tea "github.com/charmbracelet/bubbletea"
 )
@@ -14,50 +11,43 @@
 // TUIProgress implements the progress.Progress interface for TUI
 type TUIProgress struct {
 	program *tea.Program
-	model   *Model
 }
 
-// NewTUIProgress creates a new TUIProgress
-func NewTUIProgress() *TUIProgress {
-	model := New()
-	p := tea.NewProgram(model, tea.WithAltScreen())
+// NewTUIProgress creates a new TUIProgress.
+// It now accepts the program instance instead of creating one.
+func NewTUIProgress(p *tea.Program) *TUIProgress {
 	return &TUIProgress{
 		program: p,
-		model:   model,
 	}
 }
 
-// Logf logs a message to the TUI
-func (tp *TUIProgress) Logf(format string, args ...interface{}) {
-	tp.program.Send(StepWithCounts(tp.model.currentStep, fmt.Sprintf(format, args...), 
-		tp.model.articlesCount, tp.model.processedCount))
+// SetStage sends a message to update the main stage.
+func (tp *TUIProgress) SetStage(stage string) {
+	tp.program.Send(StageMsg(stage))
 }
 
-// Warningf logs a warning to the TUI
-func (tp *TUIProgress) Warningf(format string, args ...interface{}) {
-	tp.Logf("Warning: "+format, args...)
+// SetSubStage sends a message to update the sub-status.
+func (tp *TUIProgress) SetSubStage(status string) {
+	tp.program.Send(SubStageMsg(status))
 }
 
-// Debugf logs a debug message to the TUI
-func (tp *TUIProgress) Debugf(format string, args ...interface{}) {
-	// Debug messages not shown in TUI by default
+// SetArticleCount sends a message to update the article counts.
+func (tp *TUIProgress) SetArticleCount(total, processed int) {
+	tp.program.Send(ArticleCountMsg{Total: total, Processed: processed})
 }
 
-// SetStage sets the current stage
-func (tp *TUIProgress) SetStage(stage string) {
-	tp.program.Send(Step(tp.model.currentStep, stage))
+// Logf sends a generic log message (can be displayed as a sub-status).
+func (tp *TUIProgress) Logf(format string, args ...any) {
+	tp.program.Send(SubStageMsg(fmt.Sprintf(format, args...)))
 }
 
-// SetSubStage sets the sub-stage status
-func (tp *TUIProgress) SetSubStage(status string) {
-	tp.program.Send(Step(tp.model.currentStep, status))
+// Warningf logs a warning.
+func (tp *TUIProgress) Warningf(format string, args ...any) {
+	tp.Logf("⚠️ Warning: "+format, args...)
 }
 
-// SetArticleCount sets the article counts
-func (tp *TUIProgress) SetArticleCount(total, processed int) {
-	tp.model.articlesCount = total
-	tp.model.processedCount = processed
-}
+// Debugf does nothing in the TUI.
+func (tp *TUIProgress) Debugf(format string, args ...any) {}
 
 // Run runs the TUI
 func (tp *TUIProgress) Run() error {
@@ -70,78 +60,3 @@ func (tp *TUIProgress) Context() *progress.Context {
 	return progress.NewContext(tp)
 }
 
-// RunWithRuntime runs the TUI with a runtime
-func RunWithRuntime(rt *runtime.Runtime) error {
-	// Create TUI progress
-	tp := NewTUIProgress()
-	
-	// Run TUI in goroutine
-	tuiDone := make(chan error)
-	go func() {
-		tuiDone <- tp.Run()
-	}()
-
-	// Run aggregation in another goroutine
-	runDone := make(chan error)
-	go func() {
-		// Create context for cancellation
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		// Update TUI status
-		tp.program.Send(Step(1, fmt.Sprintf("Aggregating feeds from: %s", rt.FeedsFile)))
-
-		// TODO: Configure runtime with progress context
-		
-		// Execute the runtime
-		err := rt.Execute(ctx)
-		if err != nil {
-			tp.program.Send(Error(err.Error()))
-			runDone <- err
-			return
-		}
-
-		// Update TUI status
-		tp.program.Send(StepWithCounts(5, "Formatting output", len(rt.Articles), len(rt.Articles)))
-
-		// Write output
-		if rt.OutputFile != "" {
-			if err := rt.WriteOutputToFile(); err != nil {
-				tp.program.Send(Error(fmt.Sprintf("Error writing output: %v", err)))
-				runDone <- err
-				return
-			}
-			tp.program.Send(Step(6, fmt.Sprintf("Output written to: %s", rt.OutputFile)))
-		} else {
-			if err := rt.WriteOutputToFile(); err != nil {
-				tp.program.Send(Error(fmt.Sprintf("Error writing output: %v", err)))
-				runDone <- err
-				return
-			}
-			tp.program.Send(Step(6, "Output complete"))
-		}
-
-		// Mark as done
-		tp.program.Send(Step(7, "Processing completed successfully"))
-		time.Sleep(2 * time.Second) // Show success message briefly
-		tp.program.Send(tea.Quit())
-		runDone <- nil
-	}()
-
-	// Wait for either TUI or run to complete
-	select {
-	case err := <-tuiDone:
-		return err
-	case err := <-runDone:
-		if err != nil {
-			return err
-		}
-		// Wait for TUI to quit gracefully
-		select {
-		case err := <-tuiDone:
-			return err
-		case <-time.After(5 * time.Second):
-			return fmt.Errorf("TUI did not exit gracefully")
-		}
-	}
-}