Add project tracking picker

.gitignore

@@ -2,3 +2,4 @@
 app.log
 test/taskchampion.sqlite3
 tasksquire
+test/*.sqlite3*

AGENTS.md

@@ -0,0 +1,207 @@
+# Agent Development Guide for TaskSquire
+
+This guide is for AI coding agents working on TaskSquire, a Go-based TUI (Terminal User Interface) for Taskwarrior.
+
+## Project Overview
+
+- **Language**: Go 1.22.2
+- **Architecture**: Model-View-Update (MVU) pattern using Bubble Tea framework
+- **Module**: `tasksquire`
+- **Main Dependencies**: Bubble Tea, Lip Gloss, Huh, Bubbles (Charm ecosystem)
+
+## Build, Test, and Lint Commands
+
+### Building and Running
+```bash
+# Run directly
+go run main.go
+
+# Build binary
+go build -o tasksquire main.go
+
+# Run tests
+go test ./...
+
+# Run tests for a specific package
+go test ./taskwarrior
+
+# Run a single test
+go test ./taskwarrior -run TestTaskSquire_GetContext
+
+# Run tests with verbose output
+go test -v ./taskwarrior
+
+# Run tests with coverage
+go test -cover ./...
+```
+
+### Linting and Formatting
+```bash
+# Format code (always run before committing)
+go fmt ./...
+
+# Lint with golangci-lint (available via nix-shell)
+golangci-lint run
+
+# Vet code for suspicious constructs
+go vet ./...
+
+# Tidy dependencies
+go mod tidy
+```
+
+### Development Environment
+```bash
+# Enter Nix development shell (provides all tools)
+nix develop
+
+# Or use direnv (automatically loads .envrc)
+direnv allow
+```
+
+## Project Structure
+
+```
+tasksquire/
+├── main.go              # Entry point: initializes TaskSquire, TimeSquire, and Bubble Tea
+├── common/              # Shared state, components interface, keymaps, styles, utilities
+├── pages/               # UI pages/views (report, taskEditor, timePage, pickers, etc.)
+├── components/          # Reusable UI components (input, table, timetable, picker)
+├── taskwarrior/         # Taskwarrior CLI wrapper, models, config
+├── timewarrior/         # Timewarrior integration, models, config
+└── test/                # Test fixtures and data
+```
+
+## Code Style Guidelines
+
+### Imports
+- **Standard Library First**: Group standard library imports, then third-party, then local
+- **Local Import Pattern**: Use `tasksquire/<package>` for internal imports
+```go
+import (
+    "context"
+    "fmt"
+    "log/slog"
+    
+    tea "github.com/charmbracelet/bubbletea"
+    "github.com/charmbracelet/lipgloss"
+    
+    "tasksquire/common"
+    "tasksquire/taskwarrior"
+)
+```
+
+### Naming Conventions
+- **Exported Types**: PascalCase (e.g., `TaskSquire`, `ReportPage`, `Common`)
+- **Unexported Fields**: camelCase (e.g., `configLocation`, `activeReport`, `pageStack`)
+- **Interfaces**: Follow Go convention, often ending in 'er' (e.g., `TaskWarrior`, `TimeWarrior`, `Component`)
+- **Constants**: PascalCase or SCREAMING_SNAKE_CASE for exported constants
+- **Test Functions**: `TestFunctionName` or `TestType_Method`
+
+### Types and Interfaces
+- **Interface-Based Design**: Use interfaces for main abstractions (see `TaskWarrior`, `TimeWarrior`, `Component`)
+- **Struct Composition**: Embed common state (e.g., pages embed or reference `*common.Common`)
+- **Pointer Receivers**: Use pointer receivers for methods that modify state or for consistency
+- **Generic Types**: Use generics where appropriate (e.g., `Stack[T]` in `common/stack.go`)
+
+### Error Handling
+- **Logging Over Panicking**: Use `log/slog` for structured logging, typically continue execution
+- **Error Returns**: Return errors from functions, don't log and return
+- **Context**: Errors are often logged with `slog.Error()` or `slog.Warn()` and execution continues
+```go
+// Typical pattern
+if err != nil {
+    slog.Error("Failed to get tasks", "error", err)
+    return nil // or continue with default behavior
+}
+```
+
+### Concurrency and Thread Safety
+- **Mutex Protection**: Use `sync.Mutex` to protect shared state (see `TaskSquire.mu`)
+- **Lock Pattern**: Lock before operations, defer unlock
+```go
+ts.mu.Lock()
+defer ts.mu.Unlock()
+```
+
+### Configuration and Environment
+- **Environment Variables**: Respect `TASKRC` and `TIMEWARRIORDB`
+- **Fallback Paths**: Check standard locations (`~/.taskrc`, `~/.config/task/taskrc`)
+- **Config Parsing**: Parse Taskwarrior config format manually (see `taskwarrior/config.go`)
+
+### MVU Pattern (Bubble Tea)
+- **Components Implement**: `Init() tea.Cmd`, `Update(tea.Msg) (tea.Model, tea.Cmd)`, `View() string`
+- **Custom Messages**: Define custom message types for inter-component communication
+- **Cmd Chaining**: Return commands from Init/Update to trigger async operations
+```go
+type MyMsg struct {
+    data string
+}
+
+func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+    switch msg := msg.(type) {
+    case MyMsg:
+        // Handle custom message
+        return m, nil
+    }
+    return m, nil
+}
+```
+
+### Styling with Lip Gloss
+- **Centralized Styles**: Define styles in `common/styles.go`
+- **Theme Colors**: Parse colors from Taskwarrior config
+- **Reusable Styles**: Create style functions, not inline styles
+
+### Testing
+- **Table-Driven Tests**: Use struct slices for test cases
+- **Test Setup**: Create helper functions like `TaskWarriorTestSetup()`
+- **Temp Directories**: Use `t.TempDir()` for isolated test environments
+- **Prep Functions**: Include `prep func()` in test cases for setup
+
+### Documentation
+- **TODO Comments**: Mark future improvements with `// TODO: description`
+- **Package Comments**: Document package purpose at the top of main files
+- **Exported Functions**: Document exported functions, types, and methods
+
+## Common Patterns
+
+### Page Navigation
+- Pages pushed onto stack via `common.PushPage()`
+- Pop pages with `common.PopPage()`
+- Check for subpages with `common.HasSubpages()`
+
+### Task Operations
+```go
+// Get tasks for a report
+tasks := ts.GetTasks(report, "filter", "args")
+
+// Import/create task
+ts.ImportTask(&task)
+
+// Mark task done
+ts.SetTaskDone(&task)
+
+// Start/stop task
+ts.StartTask(&task)
+ts.StopTask(&task)
+```
+
+### JSON Handling
+- Custom Marshal/Unmarshal for Task struct to handle UDAs (User Defined Attributes)
+- Use `json.RawMessage` for flexible field handling
+
+## Key Files to Reference
+
+- `common/component.go` - Component interface definition
+- `common/common.go` - Shared state container
+- `taskwarrior/taskwarrior.go` - TaskWarrior interface and implementation
+- `pages/main.go` - Main page router pattern
+- `taskwarrior/models.go` - Data model examples
+
+## Development Notes
+
+- **Logging**: Application logs to `app.log` in current directory
+- **Virtual Tags**: Filter out Taskwarrior virtual tags (see `virtualTags` map)
+- **Color Parsing**: Custom color parsing from Taskwarrior config format
+- **Debugging**: VSCode launch.json configured for remote debugging on port 43000

common/common.go

@@ -65,3 +65,7 @@ func (c *Common) PopPage() (Component, error) {
 	component.SetSize(c.width, c.height)
 	return component, nil
 }
+
+func (c *Common) HasSubpages() bool {
+	return !c.pageStack.IsEmpty()
+}

common/keymap.go

@@ -24,11 +24,14 @@ type Keymap struct {
 	SetReport  key.Binding
 	SetContext key.Binding
 	SetProject key.Binding
+	PickProjectTask key.Binding
 	Select     key.Binding
 	Insert     key.Binding
 	Tag        key.Binding
 	Undo       key.Binding
+	Fill       key.Binding
 	StartStop  key.Binding
+	Join       key.Binding
 }
 
 // TODO: use config values for key bindings
@@ -125,6 +128,11 @@ func NewKeymap() *Keymap {
 			key.WithHelp("p", "Set project"),
 		),
 
+		PickProjectTask: key.NewBinding(
+			key.WithKeys("P"),
+			key.WithHelp("P", "Pick project task"),
+		),
+
 		Select: key.NewBinding(
 			key.WithKeys(" "),
 			key.WithHelp("space", "Select"),
@@ -145,9 +153,19 @@ func NewKeymap() *Keymap {
 			key.WithHelp("undo", "Undo"),
 		),
 
+		Fill: key.NewBinding(
+			key.WithKeys("f"),
+			key.WithHelp("fill", "Fill gaps"),
+		),
+
 		StartStop: key.NewBinding(
 			key.WithKeys("s"),
 			key.WithHelp("start/stop", "Start/Stop"),
 		),
+
+		Join: key.NewBinding(
+			key.WithKeys("J"),
+			key.WithHelp("J", "Join with previous"),
+		),
 	}
 }

common/stack.go

@@ -38,3 +38,10 @@ func (s *Stack[T]) Pop() (T, error) {
 
 	return item, nil
 }
+
+func (s *Stack[T]) IsEmpty() bool {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	return len(s.items) == 0
+}

common/styles.go

@@ -27,6 +27,10 @@ type Styles struct {
 	Form       *huh.Theme
 	TableStyle TableStyle
 
+	Tab       lipgloss.Style
+	ActiveTab lipgloss.Style
+	TabBar    lipgloss.Style
+
 	ColumnFocused lipgloss.Style
 	ColumnBlurred lipgloss.Style
 	ColumnInsert  lipgloss.Style
@@ -71,6 +75,19 @@ func NewStyles(config *taskwarrior.TWConfig) *Styles {
 
 	styles.Form = formTheme
 
+	styles.Tab = lipgloss.NewStyle().
+		Padding(0, 1).
+		Foreground(lipgloss.Color("240"))
+
+	styles.ActiveTab = styles.Tab.
+		Foreground(lipgloss.Color("252")).
+		Bold(true)
+
+	styles.TabBar = lipgloss.NewStyle().
+		Border(lipgloss.NormalBorder(), false, false, true, false).
+		BorderForeground(lipgloss.Color("240")).
+		MarginBottom(1)
+
 	styles.ColumnFocused = lipgloss.NewStyle().Border(lipgloss.RoundedBorder(), true).Padding(1)
 	styles.ColumnBlurred = lipgloss.NewStyle().Border(lipgloss.HiddenBorder(), true).Padding(1)
 	styles.ColumnInsert = lipgloss.NewStyle().Border(lipgloss.RoundedBorder(), true).Padding(1)

common/sync.go

@@ -0,0 +1,85 @@
+package common
+
+import (
+	"log/slog"
+
+	"tasksquire/taskwarrior"
+	"tasksquire/timewarrior"
+)
+
+// FindTaskByUUID queries Taskwarrior for a task with the given UUID.
+// Returns nil if not found.
+func FindTaskByUUID(tw taskwarrior.TaskWarrior, uuid string) *taskwarrior.Task {
+	if uuid == "" {
+		return nil
+	}
+
+	// Use empty report to query by UUID filter
+	report := &taskwarrior.Report{Name: ""}
+	tasks := tw.GetTasks(report, "uuid:"+uuid)
+
+	if len(tasks) > 0 {
+		return tasks[0]
+	}
+
+	return nil
+}
+
+// SyncIntervalToTask synchronizes a Timewarrior interval's state to the corresponding Taskwarrior task.
+// Action should be "start" or "stop".
+// This function is idempotent and handles edge cases gracefully.
+func SyncIntervalToTask(interval *timewarrior.Interval, tw taskwarrior.TaskWarrior, action string) {
+	if interval == nil {
+		return
+	}
+
+	// Extract UUID from interval tags
+	uuid := timewarrior.ExtractUUID(interval.Tags)
+	if uuid == "" {
+		slog.Debug("Interval has no UUID tag, skipping task sync",
+			"intervalID", interval.ID)
+		return
+	}
+
+	// Find corresponding task
+	task := FindTaskByUUID(tw, uuid)
+	if task == nil {
+		slog.Warn("Task not found for UUID, skipping sync",
+			"uuid", uuid)
+		return
+	}
+
+	// Perform sync action
+	switch action {
+	case "start":
+		// Start task if it's pending (idempotent - taskwarrior handles already-started tasks)
+		if task.Status == "pending" {
+			slog.Info("Starting Taskwarrior task from interval",
+				"uuid", uuid,
+				"description", task.Description,
+				"alreadyStarted", task.Start != "")
+			tw.StartTask(task)
+		} else {
+			slog.Debug("Task not pending, skipping start",
+				"uuid", uuid,
+				"status", task.Status)
+		}
+
+	case "stop":
+		// Only stop if task is pending and currently started
+		if task.Status == "pending" && task.Start != "" {
+			slog.Info("Stopping Taskwarrior task from interval",
+				"uuid", uuid,
+				"description", task.Description)
+			tw.StopTask(task)
+		} else {
+			slog.Debug("Task not started or not pending, skipping stop",
+				"uuid", uuid,
+				"status", task.Status,
+				"hasStart", task.Start != "")
+		}
+
+	default:
+		slog.Error("Unknown sync action", "action", action)
+	}
+}

components/autocomplete/autocomplete.go

@@ -0,0 +1,293 @@
+package autocomplete
+
+import (
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/sahilm/fuzzy"
+)
+
+type Autocomplete struct {
+	input               textinput.Model
+	allSuggestions      []string // All available suggestions (newest first)
+	filteredSuggestions []string // Currently matching suggestions
+	matchedIndexes      [][]int  // Matched character positions for each suggestion
+	selectedIndex       int      // -1 = input focused, 0+ = suggestion selected
+	showSuggestions     bool     // Whether to display suggestion box
+	maxVisible          int      // Max suggestions to show
+	minChars            int      // Min chars before showing suggestions
+	focused             bool
+	width               int
+	placeholder         string
+}
+
+// New creates a new autocomplete component
+func New(suggestions []string, minChars int, maxVisible int) *Autocomplete {
+	ti := textinput.New()
+	ti.Width = 50
+
+	return &Autocomplete{
+		input:          ti,
+		allSuggestions: suggestions,
+		selectedIndex:  -1,
+		maxVisible:     maxVisible,
+		minChars:       minChars,
+		width:          50,
+	}
+}
+
+// SetValue sets the input value
+func (a *Autocomplete) SetValue(value string) {
+	a.input.SetValue(value)
+	a.updateFilteredSuggestions()
+}
+
+// GetValue returns the current input value
+func (a *Autocomplete) GetValue() string {
+	return a.input.Value()
+}
+
+// Focus focuses the autocomplete input
+func (a *Autocomplete) Focus() {
+	a.focused = true
+	a.input.Focus()
+}
+
+// Blur blurs the autocomplete input
+func (a *Autocomplete) Blur() {
+	a.focused = false
+	a.input.Blur()
+	a.showSuggestions = false
+}
+
+// SetPlaceholder sets the placeholder text
+func (a *Autocomplete) SetPlaceholder(placeholder string) {
+	a.placeholder = placeholder
+	a.input.Placeholder = placeholder
+}
+
+// SetWidth sets the width of the autocomplete
+func (a *Autocomplete) SetWidth(width int) {
+	a.width = width
+	a.input.Width = width
+}
+
+// SetMaxVisible sets the maximum number of visible suggestions
+func (a *Autocomplete) SetMaxVisible(max int) {
+	a.maxVisible = max
+}
+
+// SetMinChars sets the minimum characters required before showing suggestions
+func (a *Autocomplete) SetMinChars(min int) {
+	a.minChars = min
+}
+
+// SetSuggestions updates the available suggestions
+func (a *Autocomplete) SetSuggestions(suggestions []string) {
+	a.allSuggestions = suggestions
+	a.updateFilteredSuggestions()
+}
+
+// HasSuggestions returns true if the autocomplete is currently showing suggestions
+func (a *Autocomplete) HasSuggestions() bool {
+	return a.showSuggestions && len(a.filteredSuggestions) > 0
+}
+
+// Init initializes the autocomplete
+func (a *Autocomplete) Init() tea.Cmd {
+	return textinput.Blink
+}
+
+// Update handles messages for the autocomplete
+func (a *Autocomplete) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	if !a.focused {
+		return a, nil
+	}
+
+	var cmd tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch {
+		case key.Matches(msg, key.NewBinding(key.WithKeys("down"))):
+			if a.showSuggestions && len(a.filteredSuggestions) > 0 {
+				a.selectedIndex++
+				if a.selectedIndex >= len(a.filteredSuggestions) {
+					a.selectedIndex = 0
+				}
+				return a, nil
+			}
+
+		case key.Matches(msg, key.NewBinding(key.WithKeys("up"))):
+			if a.showSuggestions && len(a.filteredSuggestions) > 0 {
+				a.selectedIndex--
+				if a.selectedIndex < 0 {
+					a.selectedIndex = len(a.filteredSuggestions) - 1
+				}
+				return a, nil
+			}
+
+		case key.Matches(msg, key.NewBinding(key.WithKeys("enter"))):
+			if a.showSuggestions && a.selectedIndex >= 0 && a.selectedIndex < len(a.filteredSuggestions) {
+				// Accept selected suggestion
+				a.input.SetValue(a.filteredSuggestions[a.selectedIndex])
+				a.showSuggestions = false
+				a.selectedIndex = -1
+				return a, nil
+			}
+
+		case key.Matches(msg, key.NewBinding(key.WithKeys("tab"))):
+			if a.showSuggestions && len(a.filteredSuggestions) > 0 {
+				// Accept first or selected suggestion
+				if a.selectedIndex >= 0 && a.selectedIndex < len(a.filteredSuggestions) {
+					a.input.SetValue(a.filteredSuggestions[a.selectedIndex])
+				} else {
+					a.input.SetValue(a.filteredSuggestions[0])
+				}
+				a.showSuggestions = false
+				a.selectedIndex = -1
+				return a, nil
+			}
+
+		case key.Matches(msg, key.NewBinding(key.WithKeys("esc"))):
+			if a.showSuggestions {
+				a.showSuggestions = false
+				a.selectedIndex = -1
+				return a, nil
+			}
+
+		default:
+			// Handle regular text input
+			prevValue := a.input.Value()
+			a.input, cmd = a.input.Update(msg)
+
+			// Update suggestions if value changed
+			if a.input.Value() != prevValue {
+				a.updateFilteredSuggestions()
+			}
+
+			return a, cmd
+		}
+	}
+
+	a.input, cmd = a.input.Update(msg)
+	return a, cmd
+}
+
+// View renders the autocomplete
+func (a *Autocomplete) View() string {
+	// Input field
+	inputView := a.input.View()
+
+	if !a.showSuggestions || len(a.filteredSuggestions) == 0 {
+		return inputView
+	}
+
+	// Suggestion box
+	var suggestionViews []string
+	for i, suggestion := range a.filteredSuggestions {
+		if i >= a.maxVisible {
+			break
+		}
+
+		prefix := "  "
+		baseStyle := lipgloss.NewStyle().Padding(0, 1)
+
+		if i == a.selectedIndex {
+			// Highlight selected suggestion
+			baseStyle = baseStyle.Bold(true).Foreground(lipgloss.Color("12"))
+			prefix = "→ "
+		}
+
+		// Build suggestion with highlighted matched characters
+		var rendered string
+		if i < len(a.matchedIndexes) {
+			rendered = a.renderWithHighlights(suggestion, a.matchedIndexes[i], i == a.selectedIndex)
+		} else {
+			rendered = suggestion
+		}
+
+		suggestionViews = append(suggestionViews, baseStyle.Render(prefix+rendered))
+	}
+
+	// Box style
+	boxStyle := lipgloss.NewStyle().
+		Border(lipgloss.RoundedBorder()).
+		BorderForeground(lipgloss.Color("8")).
+		Width(a.width)
+
+	suggestionsBox := boxStyle.Render(
+		lipgloss.JoinVertical(lipgloss.Left, suggestionViews...),
+	)
+
+	return lipgloss.JoinVertical(lipgloss.Left, inputView, suggestionsBox)
+}
+
+// renderWithHighlights renders a suggestion with matched characters highlighted
+func (a *Autocomplete) renderWithHighlights(str string, matchedIndexes []int, isSelected bool) string {
+	if len(matchedIndexes) == 0 {
+		return str
+	}
+
+	// Create a map for quick lookup
+	matchedMap := make(map[int]bool)
+	for _, idx := range matchedIndexes {
+		matchedMap[idx] = true
+	}
+
+	// Choose highlight style based on selection state
+	var highlightStyle lipgloss.Style
+	if isSelected {
+		// When selected, use underline to distinguish from selection bold
+		highlightStyle = lipgloss.NewStyle().Underline(true)
+	} else {
+		// When not selected, use bold and accent color
+		highlightStyle = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("12"))
+	}
+
+	// Build the string with highlights
+	var result string
+	runes := []rune(str)
+	for i, r := range runes {
+		if matchedMap[i] {
+			result += highlightStyle.Render(string(r))
+		} else {
+			result += string(r)
+		}
+	}
+
+	return result
+}
+
+// updateFilteredSuggestions filters suggestions based on current input
+func (a *Autocomplete) updateFilteredSuggestions() {
+	value := a.input.Value()
+
+	// Only show if >= minChars
+	if len(value) < a.minChars {
+		a.showSuggestions = false
+		a.filteredSuggestions = nil
+		a.matchedIndexes = nil
+		a.selectedIndex = -1
+		return
+	}
+
+	// Fuzzy match using sahilm/fuzzy
+	matches := fuzzy.Find(value, a.allSuggestions)
+
+	var filtered []string
+	var indexes [][]int
+	for _, match := range matches {
+		filtered = append(filtered, match.Str)
+		indexes = append(indexes, match.MatchedIndexes)
+		if len(filtered) >= a.maxVisible {
+			break
+		}
+	}
+
+	a.filteredSuggestions = filtered
+	a.matchedIndexes = indexes
+	a.showSuggestions = len(filtered) > 0 && a.focused
+	a.selectedIndex = -1 // Reset to input
+}

components/input/multiselect.go

@@ -637,6 +637,11 @@ func (m *MultiSelect) GetValue() any {
 	return *m.value
 }
 
+// IsFiltering returns true if the multi-select is currently filtering.
+func (m *MultiSelect) IsFiltering() bool {
+	return m.filtering
+}
+
 func min(a, b int) int {
 	if a < b {
 		return a

components/picker/picker.go

@@ -36,7 +36,9 @@ type Picker struct {
 	onCreate        func(string) tea.Cmd
 	title           string
 	filterByDefault bool
+	defaultValue    string
 	baseItems       []list.Item
+	focused         bool
 }
 
 type PickerOption func(*Picker)
@@ -53,6 +55,30 @@ func WithOnCreate(onCreate func(string) tea.Cmd) PickerOption {
 	}
 }
 
+func WithDefaultValue(value string) PickerOption {
+	return func(p *Picker) {
+		p.defaultValue = value
+	}
+}
+
+func (p *Picker) Focus() tea.Cmd {
+	p.focused = true
+	return nil
+}
+
+func (p *Picker) Blur() tea.Cmd {
+	p.focused = false
+	return nil
+}
+
+func (p *Picker) GetValue() string {
+	item := p.list.SelectedItem()
+	if item == nil {
+		return ""
+	}
+	return item.FilterValue()
+}
+
 func New(
 	c *common.Common,
 	title string,
@@ -69,6 +95,7 @@ func New(
 	l.SetShowHelp(false)
 	l.SetShowStatusBar(false)
 	l.SetFilteringEnabled(true)
+	l.Filter = list.UnsortedFilter // Preserve item order, don't rank by match quality
 
 	// Custom key for filtering (insert mode)
 	l.KeyMap.Filter = key.NewBinding(
@@ -82,6 +109,7 @@ func New(
 		itemProvider: itemProvider,
 		onSelect:     onSelect,
 		title:        title,
+		focused:      true,
 	}
 
 	if c.TW.GetConfig().Get("uda.tasksquire.picker.filter_by_default") == "yes" {
@@ -92,8 +120,24 @@ func New(
 		opt(p)
 	}
 
+	// If a default value is provided, don't start in filter mode
+	if p.defaultValue != "" {
+		p.filterByDefault = false
+	}
+
+	if p.filterByDefault {
+		// Manually trigger filter mode on the list so it doesn't require a global key press
+		p.list, _ = p.list.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'i'}})
+	}
+
+	// Refresh items after entering filter mode to ensure they're visible
 	p.Refresh()
 
+	// If a default value is provided, select the corresponding item
+	if p.defaultValue != "" {
+		p.SelectItemByFilterValue(p.defaultValue)
+	}
+
 	return p
 }
 
@@ -103,18 +147,22 @@ func (p *Picker) Refresh() tea.Cmd {
 }
 
 func (p *Picker) updateListItems() tea.Cmd {
-	items := p.baseItems
-	filterVal := p.list.FilterValue()
+	return p.updateListItemsWithFilter(p.list.FilterValue())
+}
+
+func (p *Picker) updateListItemsWithFilter(filterVal string) tea.Cmd {
+	items := make([]list.Item, 0, len(p.baseItems)+1)
+
+	// First add all base items
+	items = append(items, p.baseItems...)
 
 	if p.onCreate != nil && filterVal != "" {
+		// Add the creation item at the end (bottom of the list)
 		newItem := creationItem{
 			text:   "(new) " + filterVal,
 			filter: filterVal,
 		}
-		newItems := make([]list.Item, len(items)+1)
-		copy(newItems, items)
-		newItems[len(items)] = newItem
-		items = newItems
+		items = append(items, newItem)
 	}
 
 	return p.list.SetItems(items)
@@ -134,27 +182,42 @@ func (p *Picker) SetSize(width, height int) {
 }
 
 func (p *Picker) Init() tea.Cmd {
-	if p.filterByDefault {
-		return func() tea.Msg {
-			return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'i'}}
-		}
-	}
-	return nil
+	// Trigger list item update to ensure items are properly displayed,
+	// especially when in filter mode with an empty filter
+	return p.updateListItems()
 }
 
 func (p *Picker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	if !p.focused {
+		return p, nil
+	}
+
 	var cmd tea.Cmd
+	var cmds []tea.Cmd
 
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
-		// If filtering, let the list handle keys (including Enter to stop filtering)
+		// If filtering, update items with predicted filter before list processes the key
 		if p.list.FilterState() == list.Filtering {
-			if key.Matches(msg, p.common.Keymap.Ok) {
-				items := p.list.VisibleItems()
-				if len(items) == 1 {
-					return p, p.handleSelect(items[0])
+			currentFilter := p.list.FilterValue()
+			predictedFilter := currentFilter
+
+			// Predict what the filter will be after this key
+			switch msg.Type {
+			case tea.KeyRunes:
+				predictedFilter = currentFilter + string(msg.Runes)
+			case tea.KeyBackspace:
+				if len(currentFilter) > 0 {
+					predictedFilter = currentFilter[:len(currentFilter)-1]
 				}
 			}
+
+			// Update items with predicted filter before list processes the message
+			if predictedFilter != currentFilter {
+				preCmd := p.updateListItemsWithFilter(predictedFilter)
+				cmds = append(cmds, preCmd)
+			}
+
 			break // Pass to list.Update
 		}
 
@@ -168,15 +231,10 @@ func (p *Picker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 	}
 
-	prevFilter := p.list.FilterValue()
 	p.list, cmd = p.list.Update(msg)
+	cmds = append(cmds, cmd)
 
-	if p.list.FilterValue() != prevFilter {
-		updateCmd := p.updateListItems()
-		return p, tea.Batch(cmd, updateCmd)
-	}
-
-	return p, cmd
+	return p, tea.Batch(cmds...)
 }
 
 func (p *Picker) handleSelect(item list.Item) tea.Cmd {
@@ -189,7 +247,12 @@ func (p *Picker) handleSelect(item list.Item) tea.Cmd {
 }
 
 func (p *Picker) View() string {
-	title := p.common.Styles.Form.Focused.Title.Render(p.title)
+	var title string
+	if p.focused {
+		title = p.common.Styles.Form.Focused.Title.Render(p.title)
+	} else {
+		title = p.common.Styles.Form.Blurred.Title.Render(p.title)
+	}
 	return lipgloss.JoinVertical(lipgloss.Left, title, p.list.View())
 }
 

components/timestampeditor/timestampeditor.go

@@ -0,0 +1,409 @@
+package timestampeditor
+
+import (
+	"log/slog"
+	"strings"
+	"tasksquire/common"
+	"time"
+
+	"github.com/charmbracelet/bubbles/key"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+const (
+	timeFormat = "20060102T150405Z" // Timewarrior format
+)
+
+// Field represents which field is currently focused
+type Field int
+
+const (
+	TimeField Field = iota
+	DateField
+)
+
+// TimestampEditor is a component for editing timestamps with separate time and date fields
+type TimestampEditor struct {
+	common *common.Common
+
+	// Current timestamp value
+	timestamp time.Time
+	isEmpty   bool // Track if timestamp is unset
+
+	// UI state
+	focused      bool
+	currentField Field
+
+	// Dimensions
+	width  int
+	height int
+
+	// Title and description
+	title       string
+	description string
+
+	// Validation
+	validate func(time.Time) error
+	err      error
+}
+
+// New creates a new TimestampEditor with no initial timestamp
+func New(com *common.Common) *TimestampEditor {
+	return &TimestampEditor{
+		common:       com,
+		timestamp:    time.Time{}, // Zero time
+		isEmpty:      true,        // Start empty
+		focused:      false,
+		currentField: TimeField,
+		validate:     func(time.Time) error { return nil },
+	}
+}
+
+// Title sets the title of the timestamp editor
+func (t *TimestampEditor) Title(title string) *TimestampEditor {
+	t.title = title
+	return t
+}
+
+// Description sets the description of the timestamp editor
+func (t *TimestampEditor) Description(description string) *TimestampEditor {
+	t.description = description
+	return t
+}
+
+// Value sets the initial timestamp value
+func (t *TimestampEditor) Value(timestamp time.Time) *TimestampEditor {
+	t.timestamp = timestamp
+	t.isEmpty = timestamp.IsZero()
+	return t
+}
+
+// ValueFromString sets the initial timestamp from a timewarrior format string
+func (t *TimestampEditor) ValueFromString(s string) *TimestampEditor {
+	if s == "" {
+		t.timestamp = time.Time{}
+		t.isEmpty = true
+		return t
+	}
+
+	parsed, err := time.Parse(timeFormat, s)
+	if err != nil {
+		slog.Error("Failed to parse timestamp", "error", err)
+		t.timestamp = time.Time{}
+		t.isEmpty = true
+		return t
+	}
+
+	t.timestamp = parsed.Local()
+	t.isEmpty = false
+	return t
+}
+
+// GetValue returns the current timestamp
+func (t *TimestampEditor) GetValue() time.Time {
+	return t.timestamp
+}
+
+// GetValueString returns the timestamp in timewarrior format, or empty string if unset
+func (t *TimestampEditor) GetValueString() string {
+	if t.isEmpty {
+		return ""
+	}
+	return t.timestamp.UTC().Format(timeFormat)
+}
+
+// Validate sets the validation function
+func (t *TimestampEditor) Validate(validate func(time.Time) error) *TimestampEditor {
+	t.validate = validate
+	return t
+}
+
+// Error returns the validation error
+func (t *TimestampEditor) Error() error {
+	return t.err
+}
+
+// Focus focuses the timestamp editor
+func (t *TimestampEditor) Focus() tea.Cmd {
+	t.focused = true
+	return nil
+}
+
+// Blur blurs the timestamp editor
+func (t *TimestampEditor) Blur() tea.Cmd {
+	t.focused = false
+	t.err = t.validate(t.timestamp)
+	return nil
+}
+
+// SetSize sets the size of the timestamp editor
+func (t *TimestampEditor) SetSize(width, height int) {
+	t.width = width
+	t.height = height
+}
+
+// Init initializes the timestamp editor
+func (t *TimestampEditor) Init() tea.Cmd {
+	return nil
+}
+
+// Update handles messages for the timestamp editor
+func (t *TimestampEditor) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	if !t.focused {
+		return t, nil
+	}
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		t.err = nil
+
+		switch msg.String() {
+		// Navigation between fields
+		case "h", "left":
+			t.currentField = TimeField
+		case "l", "right":
+			t.currentField = DateField
+
+		// Time field adjustments (lowercase - 5 minutes)
+		case "j":
+			// Set current time on first edit if empty
+			if t.isEmpty {
+				t.setCurrentTime()
+			}
+			if t.currentField == TimeField {
+				t.adjustTime(-5)
+			} else {
+				t.adjustDate(-1)
+			}
+		case "k":
+			// Set current time on first edit if empty
+			if t.isEmpty {
+				t.setCurrentTime()
+			}
+			if t.currentField == TimeField {
+				t.adjustTime(5)
+			} else {
+				t.adjustDate(1)
+			}
+
+		// Time field adjustments (uppercase - 30 minutes) or date adjustments (week)
+		case "J":
+			// Set current time on first edit if empty
+			if t.isEmpty {
+				t.setCurrentTime()
+			}
+			if t.currentField == TimeField {
+				t.adjustTime(-30)
+			} else {
+				t.adjustDate(-7)
+			}
+		case "K":
+			// Set current time on first edit if empty
+			if t.isEmpty {
+				t.setCurrentTime()
+			}
+			if t.currentField == TimeField {
+				t.adjustTime(30)
+			} else {
+				t.adjustDate(7)
+			}
+
+		// Remove timestamp
+		case "d":
+			t.timestamp = time.Time{}
+			t.isEmpty = true
+		}
+	}
+
+	return t, nil
+}
+
+// setCurrentTime sets the timestamp to the current time and marks it as not empty
+func (t *TimestampEditor) setCurrentTime() {
+	now := time.Now()
+	// Snap to nearest 5 minutes
+	minute := now.Minute()
+	remainder := minute % 5
+	if remainder != 0 {
+		if remainder < 3 {
+			// Round down
+			now = now.Add(-time.Duration(remainder) * time.Minute)
+		} else {
+			// Round up
+			now = now.Add(time.Duration(5-remainder) * time.Minute)
+		}
+	}
+	// Zero out seconds and nanoseconds
+	t.timestamp = time.Date(
+		now.Year(),
+		now.Month(),
+		now.Day(),
+		now.Hour(),
+		now.Minute(),
+		0, 0,
+		now.Location(),
+	)
+	t.isEmpty = false
+}
+
+// adjustTime adjusts the time by the given number of minutes and snaps to nearest 5 minutes
+func (t *TimestampEditor) adjustTime(minutes int) {
+	// Add the minutes
+	t.timestamp = t.timestamp.Add(time.Duration(minutes) * time.Minute)
+
+	// Snap to nearest 5 minutes
+	minute := t.timestamp.Minute()
+	remainder := minute % 5
+	if remainder != 0 {
+		if remainder < 3 {
+			// Round down
+			t.timestamp = t.timestamp.Add(-time.Duration(remainder) * time.Minute)
+		} else {
+			// Round up
+			t.timestamp = t.timestamp.Add(time.Duration(5-remainder) * time.Minute)
+		}
+	}
+
+	// Zero out seconds and nanoseconds
+	t.timestamp = time.Date(
+		t.timestamp.Year(),
+		t.timestamp.Month(),
+		t.timestamp.Day(),
+		t.timestamp.Hour(),
+		t.timestamp.Minute(),
+		0, 0,
+		t.timestamp.Location(),
+	)
+}
+
+// adjustDate adjusts the date by the given number of days
+func (t *TimestampEditor) adjustDate(days int) {
+	t.timestamp = t.timestamp.AddDate(0, 0, days)
+}
+
+// View renders the timestamp editor
+func (t *TimestampEditor) View() string {
+	var sb strings.Builder
+
+	styles := t.getStyles()
+
+	// Render title if present
+	if t.title != "" {
+		sb.WriteString(styles.title.Render(t.title))
+		if t.err != nil {
+			sb.WriteString(styles.errorIndicator.String())
+		}
+		sb.WriteString("\n")
+	}
+
+	// Render description if present
+	if t.description != "" {
+		sb.WriteString(styles.description.Render(t.description))
+		sb.WriteString("\n")
+	}
+
+	// Render the time and date fields side by side
+	var timeStr, dateStr string
+	if t.isEmpty {
+		timeStr = "--:--"
+		dateStr = "--- ----------"
+	} else {
+		timeStr = t.timestamp.Format("15:04")
+		dateStr = t.timestamp.Format("Mon 2006-01-02")
+	}
+
+	var timeField, dateField string
+	if t.currentField == TimeField {
+		timeField = styles.selectedField.Render(timeStr)
+		dateField = styles.unselectedField.Render(dateStr)
+	} else {
+		timeField = styles.unselectedField.Render(timeStr)
+		dateField = styles.selectedField.Render(dateStr)
+	}
+
+	fieldsRow := lipgloss.JoinHorizontal(lipgloss.Top, timeField, "  ", dateField)
+	sb.WriteString(fieldsRow)
+
+	return styles.base.Render(sb.String())
+}
+
+// getHelpText returns the help text based on the current field
+func (t *TimestampEditor) getHelpText() string {
+	if t.currentField == TimeField {
+		return "h/l: switch field • j/k: ±5min • J/K: ±30min • d: remove"
+	}
+	return "h/l: switch field • j/k: ±1day • J/K: ±1week • d: remove"
+}
+
+// Styles for the timestamp editor
+type timestampEditorStyles struct {
+	base            lipgloss.Style
+	title           lipgloss.Style
+	description     lipgloss.Style
+	errorIndicator  lipgloss.Style
+	selectedField   lipgloss.Style
+	unselectedField lipgloss.Style
+	help            lipgloss.Style
+}
+
+// getStyles returns the styles for the timestamp editor
+func (t *TimestampEditor) getStyles() timestampEditorStyles {
+	theme := t.common.Styles.Form
+	var styles timestampEditorStyles
+
+	if t.focused {
+		styles.base = lipgloss.NewStyle()
+		styles.title = theme.Focused.Title
+		styles.description = theme.Focused.Description
+		styles.errorIndicator = theme.Focused.ErrorIndicator
+		styles.selectedField = lipgloss.NewStyle().
+			Bold(true).
+			Padding(0, 2).
+			Border(lipgloss.RoundedBorder()).
+			BorderForeground(lipgloss.Color("12"))
+		styles.unselectedField = lipgloss.NewStyle().
+			Padding(0, 2).
+			Border(lipgloss.RoundedBorder()).
+			BorderForeground(lipgloss.Color("8"))
+		styles.help = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("8")).
+			Italic(true)
+	} else {
+		styles.base = lipgloss.NewStyle()
+		styles.title = theme.Blurred.Title
+		styles.description = theme.Blurred.Description
+		styles.errorIndicator = theme.Blurred.ErrorIndicator
+		styles.selectedField = lipgloss.NewStyle().
+			Padding(0, 2).
+			Border(lipgloss.RoundedBorder()).
+			BorderForeground(lipgloss.Color("8"))
+		styles.unselectedField = lipgloss.NewStyle().
+			Padding(0, 2).
+			Border(lipgloss.HiddenBorder())
+		styles.help = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("8"))
+	}
+
+	return styles
+}
+
+// Skip returns whether the timestamp editor should be skipped
+func (t *TimestampEditor) Skip() bool {
+	return false
+}
+
+// Zoom returns whether the timestamp editor should be zoomed
+func (t *TimestampEditor) Zoom() bool {
+	return false
+}
+
+// KeyBinds returns the key bindings for the timestamp editor
+func (t *TimestampEditor) KeyBinds() []key.Binding {
+	return []key.Binding{
+		t.common.Keymap.Left,
+		t.common.Keymap.Right,
+		t.common.Keymap.Up,
+		t.common.Keymap.Down,
+	}
+}

components/timetable/table.go

@@ -330,11 +330,17 @@ func (m *Model) UpdateViewport() {
 }
 
 // SelectedRow returns the selected row.
+// Returns nil if cursor is on a gap row or out of bounds.
 func (m Model) SelectedRow() Row {
 	if m.cursor < 0 || m.cursor >= len(m.rows) {
 		return nil
 	}
 
+	// Don't return gap rows as selected
+	if m.rows[m.cursor].IsGap {
+		return nil
+	}
+
 	return m.rows[m.cursor]
 }
 
@@ -388,15 +394,61 @@ func (m Model) Cursor() int {
 }
 
 // SetCursor sets the cursor position in the table.
+// Skips gap rows by moving to the nearest non-gap row.
 func (m *Model) SetCursor(n int) {
 	m.cursor = clamp(n, 0, len(m.rows)-1)
+
+	// Skip gap rows - try moving down first, then up
+	if m.cursor < len(m.rows) && m.rows[m.cursor].IsGap {
+		// Try moving down to find non-gap
+		found := false
+		for i := m.cursor; i < len(m.rows); i++ {
+			if !m.rows[i].IsGap {
+				m.cursor = i
+				found = true
+				break
+			}
+		}
+		// If not found down, try moving up
+		if !found {
+			for i := m.cursor; i >= 0; i-- {
+				if !m.rows[i].IsGap {
+					m.cursor = i
+					break
+				}
+			}
+		}
+	}
+
 	m.UpdateViewport()
 }
 
 // MoveUp moves the selection up by any number of rows.
-// It can not go above the first row.
+// It can not go above the first row. Skips gap rows.
 func (m *Model) MoveUp(n int) {
+	originalCursor := m.cursor
 	m.cursor = clamp(m.cursor-n, 0, len(m.rows)-1)
+
+	// Skip gap rows
+	for m.cursor >= 0 && m.cursor < len(m.rows) && m.rows[m.cursor].IsGap {
+		m.cursor--
+	}
+
+	// If we went past the beginning, find the first non-gap row
+	if m.cursor < 0 {
+		for i := 0; i < len(m.rows); i++ {
+			if !m.rows[i].IsGap {
+				m.cursor = i
+				break
+			}
+		}
+	}
+
+	// If no non-gap row found, restore original cursor
+	if m.cursor < 0 || (m.cursor < len(m.rows) && m.rows[m.cursor].IsGap) {
+		m.cursor = originalCursor
+	}
+
 	switch {
 	case m.start == 0:
 		m.viewport.SetYOffset(clamp(m.viewport.YOffset, 0, m.cursor))
@@ -409,9 +461,31 @@ func (m *Model) MoveUp(n int) {
 }
 
 // MoveDown moves the selection down by any number of rows.
-// It can not go below the last row.
+// It can not go below the last row. Skips gap rows.
 func (m *Model) MoveDown(n int) {
+	originalCursor := m.cursor
 	m.cursor = clamp(m.cursor+n, 0, len(m.rows)-1)
+
+	// Skip gap rows
+	for m.cursor >= 0 && m.cursor < len(m.rows) && m.rows[m.cursor].IsGap {
+		m.cursor++
+	}
+
+	// If we went past the end, find the last non-gap row
+	if m.cursor >= len(m.rows) {
+		for i := len(m.rows) - 1; i >= 0; i-- {
+			if !m.rows[i].IsGap {
+				m.cursor = i
+				break
+			}
+		}
+	}
+
+	// If no non-gap row found, restore original cursor
+	if m.cursor >= len(m.rows) || (m.cursor >= 0 && m.rows[m.cursor].IsGap) {
+		m.cursor = originalCursor
+	}
+
 	m.UpdateViewport()
 
 	switch {
@@ -452,6 +526,16 @@ func (m Model) headersView() string {
 }
 
 func (m *Model) renderRow(r int) string {
+	// Special rendering for gap rows
+	if m.rows[r].IsGap {
+		gapText := m.rows[r].GetString("gap_display")
+		gapStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("240")).
+			Align(lipgloss.Center).
+			Width(m.Width())
+		return gapStyle.Render(gapText)
+	}
+
 	var s = make([]string, 0, len(m.cols))
 	for i, col := range m.cols {
 		if m.cols[i].Width <= 0 {

on-modify.timewarrior

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+
+###############################################################################
+#
+# Copyright 2016 - 2021, 2023, Gothenburg Bit Factory
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# https://www.opensource.org/licenses/mit-license.php
+#
+###############################################################################
+
+import json
+import subprocess
+import sys
+
+# Hook should extract all the following for use as Timewarrior tags:
+#   UUID
+#   Project
+#   Tags
+#   Description
+#   UDAs
+
+try:
+    input_stream = sys.stdin.buffer
+except AttributeError:
+    input_stream = sys.stdin
+
+
+def extract_tags_from(json_obj):
+    # Extract attributes for use as tags.
+    tags = [json_obj['description']]
+
+    # Add UUID with prefix for reliable task linking
+    if 'uuid' in json_obj:
+        tags.append('uuid:' + json_obj['uuid'])
+
+    # Add project with prefix for separate column display
+    if 'project' in json_obj:
+        tags.append('project:' + json_obj['project'])
+
+    if 'tags' in json_obj:
+        if type(json_obj['tags']) is str:
+            # Usage of tasklib (e.g. in taskpirate) converts the tag list into a string
+            # If this is the case, convert it back into a list first
+            # See https://github.com/tbabej/taskpirate/issues/11
+            task_tags = [tag for tag in json_obj['tags'].split(',') if tag != 'next']
+            tags.extend(task_tags)
+        else:
+            # Filter out the 'next' tag
+            task_tags = [tag for tag in json_obj['tags'] if tag != 'next']
+            tags.extend(task_tags)
+
+    return tags
+
+
+def extract_annotation_from(json_obj):
+
+    if 'annotations' not in json_obj:
+        return '\'\''
+
+    return json_obj['annotations'][0]['description']
+
+
+def main(old, new):
+
+    start_or_stop = ''
+
+    # Started task.
+    if 'start' in new and 'start' not in old:
+        start_or_stop = 'start'
+
+    # Stopped task.
+    elif ('start' not in new or 'end' in new) and 'start' in old:
+        start_or_stop = 'stop'
+
+    if start_or_stop:
+        tags = extract_tags_from(new)
+
+        subprocess.call(['timew', start_or_stop] + tags + [':yes'])
+
+    # Modifications to task other than start/stop
+    elif 'start' in new and 'start' in old:
+        old_tags = extract_tags_from(old)
+        new_tags = extract_tags_from(new)
+
+        if old_tags != new_tags:
+            subprocess.call(['timew', 'untag', '@1'] + old_tags + [':yes'])
+            subprocess.call(['timew', 'tag', '@1'] + new_tags + [':yes'])
+
+        old_annotation = extract_annotation_from(old)
+        new_annotation = extract_annotation_from(new)
+
+        if old_annotation != new_annotation:
+            subprocess.call(['timew', 'annotate', '@1', new_annotation])
+
+
+if __name__ == "__main__":
+    old = json.loads(input_stream.readline().decode("utf-8", errors="replace"))
+    new = json.loads(input_stream.readline().decode("utf-8", errors="replace"))
+    print(json.dumps(new))
+    main(old, new)

pages/main.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/charmbracelet/bubbles/key"
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 )
 
 type MainPage struct {
@@ -13,6 +14,9 @@ type MainPage struct {
 
 	taskPage   common.Component
 	timePage   common.Component
+	currentTab int
+	width      int
+	height     int
 }
 
 func NewMainPage(common *common.Common) *MainPage {
@@ -24,6 +28,7 @@ func NewMainPage(common *common.Common) *MainPage {
 	m.timePage = NewTimePage(common)
 
 	m.activePage = m.taskPage
+	m.currentTab = 0
 
 	return m
 }
@@ -37,16 +42,39 @@ func (m *MainPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
+		m.width = msg.Width
+		m.height = msg.Height
 		m.common.SetSize(msg.Width, msg.Height)
+
+		tabHeight := lipgloss.Height(m.renderTabBar())
+		contentHeight := msg.Height - tabHeight
+		if contentHeight < 0 {
+			contentHeight = 0
+		}
+
+		newMsg := tea.WindowSizeMsg{Width: msg.Width, Height: contentHeight}
+		activePage, cmd := m.activePage.Update(newMsg)
+		m.activePage = activePage.(common.Component)
+		return m, cmd
+
 	case tea.KeyMsg:
-		if key.Matches(msg, m.common.Keymap.Next) {
+		// Only handle tab key for page switching when at the top level (no subpages active)
+		if key.Matches(msg, m.common.Keymap.Next) && !m.common.HasSubpages() {
 			if m.activePage == m.taskPage {
 				m.activePage = m.timePage
+				m.currentTab = 1
 			} else {
 				m.activePage = m.taskPage
+				m.currentTab = 0
 			}
-			// Re-size the new active page just in case
-			m.activePage.SetSize(m.common.Width(), m.common.Height())
+
+			tabHeight := lipgloss.Height(m.renderTabBar())
+			contentHeight := m.height - tabHeight
+			if contentHeight < 0 {
+				contentHeight = 0
+			}
+			m.activePage.SetSize(m.width, contentHeight)
+
 			// Trigger a refresh/init on switch? Maybe not needed if we keep state.
 			// But we might want to refresh data.
 			return m, m.activePage.Init()
@@ -59,6 +87,22 @@ func (m *MainPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, cmd
 }
 
-func (m *MainPage) View() string {
-	return m.activePage.View()
+func (m *MainPage) renderTabBar() string {
+	var tabs []string
+	headers := []string{"Tasks", "Time"}
+
+	for i, header := range headers {
+		style := m.common.Styles.Tab
+		if m.currentTab == i {
+			style = m.common.Styles.ActiveTab
+		}
+		tabs = append(tabs, style.Render(header))
+	}
+
+	row := lipgloss.JoinHorizontal(lipgloss.Top, tabs...)
+	return m.common.Styles.TabBar.Width(m.common.Width()).Render(row)
+}
+
+func (m *MainPage) View() string {
+	return lipgloss.JoinVertical(lipgloss.Left, m.renderTabBar(), m.activePage.View())
 }

pages/report.go

@@ -45,10 +45,6 @@ func NewReportPage(com *common.Common, report *taskwarrior.Report) *ReportPage {
 		taskTable:     table.New(com),
 	}
 
-	p.subpage = NewTaskEditorPage(p.common, taskwarrior.Task{})
-	p.subpage.Init()
-	p.common.PushPage(p)
-
 	return p
 }
 
@@ -86,6 +82,12 @@ func (p *ReportPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case UpdateProjectMsg:
 		p.activeProject = string(msg)
 		cmds = append(cmds, p.getTasks())
+	case TaskPickedMsg:
+		if msg.Task != nil && msg.Task.Status == "pending" {
+			p.common.TW.StopActiveTasks()
+			p.common.TW.StartTask(msg.Task)
+		}
+		cmds = append(cmds, p.getTasks())
 	case UpdatedTasksMsg:
 		cmds = append(cmds, p.getTasks())
 	case tea.KeyMsg:
@@ -123,6 +125,11 @@ func (p *ReportPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			cmd := p.subpage.Init()
 			p.common.PushPage(p)
 			return p.subpage, cmd
+		case key.Matches(msg, p.common.Keymap.PickProjectTask):
+			p.subpage = NewProjectTaskPickerPage(p.common)
+			cmd := p.subpage.Init()
+			p.common.PushPage(p)
+			return p.subpage, cmd
 		case key.Matches(msg, p.common.Keymap.Tag):
 			if p.selectedTask != nil {
 				tag := p.common.TW.GetConfig().Get("uda.tasksquire.tag.default")
@@ -141,6 +148,7 @@ func (p *ReportPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		case key.Matches(msg, p.common.Keymap.StartStop):
 			if p.selectedTask != nil && p.selectedTask.Status == "pending" {
 				if p.selectedTask.Start == "" {
+					p.common.TW.StopActiveTasks()
 					p.common.TW.StartTask(p.selectedTask)
 				} else {
 					p.common.TW.StopTask(p.selectedTask)

pages/taskEditor.go

@@ -8,6 +8,8 @@ import (
 	"time"
 
 	"tasksquire/components/input"
+	"tasksquire/components/picker"
+	"tasksquire/components/timestampeditor"
 	"tasksquire/taskwarrior"
 
 	"github.com/charmbracelet/bubbles/key"
@@ -40,6 +42,8 @@ type TaskEditorPage struct {
 	area       int
 	areaPicker *areaPicker
 	areas      []area
+
+	infoViewport viewport.Model
 }
 
 func NewTaskEditorPage(com *common.Common, task taskwarrior.Task) *TaskEditorPage {
@@ -55,7 +59,7 @@ func NewTaskEditorPage(com *common.Common, task taskwarrior.Task) *TaskEditorPag
 	tagOptions := p.common.TW.GetTags()
 
 	p.areas = []area{
-		NewTaskEdit(p.common, &p.task),
+		NewTaskEdit(p.common, &p.task, p.task.Uuid == ""),
 		NewTagEdit(p.common, &p.task.Tags, tagOptions),
 		NewTimeEdit(p.common, &p.task.Due, &p.task.Scheduled, &p.task.Wait, &p.task.Until),
 		NewDetailsEdit(p.common, &p.task),
@@ -67,6 +71,11 @@ func NewTaskEditorPage(com *common.Common, task taskwarrior.Task) *TaskEditorPag
 
 	p.areaPicker = NewAreaPicker(com, []string{"Task", "Tags", "Dates"})
 
+	p.infoViewport = viewport.New(0, 0)
+	if p.task.Uuid != "" {
+		p.infoViewport.SetContent(p.common.TW.GetInformation(&p.task))
+	}
+
 	p.columnCursor = 1
 	if p.task.Uuid == "" {
 		p.mode = modeInsert
@@ -93,10 +102,20 @@ func (p *TaskEditorPage) SetSize(width, height int) {
 	} else {
 		p.colHeight = height - p.common.Styles.ColumnFocused.GetVerticalFrameSize()
 	}
+
+	p.infoViewport.Width = width - p.colWidth - p.common.Styles.ColumnFocused.GetHorizontalFrameSize()*2 - 5
+	if p.infoViewport.Width < 0 {
+		p.infoViewport.Width = 0
+	}
+	p.infoViewport.Height = p.colHeight
 }
 
 func (p *TaskEditorPage) Init() tea.Cmd {
-	return nil
+	var cmds []tea.Cmd
+	for _, a := range p.areas {
+		cmds = append(cmds, a.Init())
+	}
+	return tea.Batch(cmds...)
 }
 
 func (p *TaskEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
@@ -109,12 +128,20 @@ func (p *TaskEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		p.mode = mode(msg)
 	case prevColumnMsg:
 		p.columnCursor--
+		maxCols := 2
+		if p.task.Uuid != "" {
+			maxCols = 3
+		}
 		if p.columnCursor < 0 {
-			p.columnCursor = len(p.areas) - 1
+			p.columnCursor = maxCols - 1
 		}
 	case nextColumnMsg:
 		p.columnCursor++
-		if p.columnCursor > len(p.areas)-1 {
+		maxCols := 2
+		if p.task.Uuid != "" {
+			maxCols = 3
+		}
+		if p.columnCursor >= maxCols {
 			p.columnCursor = 0
 		}
 	case prevAreaMsg:
@@ -165,20 +192,26 @@ func (p *TaskEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					picker, cmd := p.areaPicker.Update(msg)
 					p.areaPicker = picker.(*areaPicker)
 					return p, cmd
-				} else {
+				} else if p.columnCursor == 1 {
 					model, cmd := p.areas[p.area].Update(prevFieldMsg{})
 					p.areas[p.area] = model.(area)
 					return p, cmd
+				} else if p.columnCursor == 2 {
+					p.infoViewport.LineUp(1)
+					return p, nil
 				}
 			case key.Matches(msg, p.common.Keymap.Down):
 				if p.columnCursor == 0 {
 					picker, cmd := p.areaPicker.Update(msg)
 					p.areaPicker = picker.(*areaPicker)
 					return p, cmd
-				} else {
+				} else if p.columnCursor == 1 {
 					model, cmd := p.areas[p.area].Update(nextFieldMsg{})
 					p.areas[p.area] = model.(area)
 					return p, cmd
+				} else if p.columnCursor == 2 {
+					p.infoViewport.LineDown(1)
+					return p, nil
 				}
 			}
 		}
@@ -211,25 +244,31 @@ func (p *TaskEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					picker, cmd := p.areaPicker.Update(msg)
 					p.areaPicker = picker.(*areaPicker)
 					return p, cmd
-				} else {
+				} else if p.columnCursor == 1 {
 					model, cmd := p.areas[p.area].Update(prevFieldMsg{})
 					p.areas[p.area] = model.(area)
 					return p, cmd
 				}
+				return p, nil
 			case key.Matches(msg, p.common.Keymap.Next):
 				if p.columnCursor == 0 {
 					picker, cmd := p.areaPicker.Update(msg)
 					p.areaPicker = picker.(*areaPicker)
 					return p, cmd
-				} else {
+				} else if p.columnCursor == 1 {
 					model, cmd := p.areas[p.area].Update(nextFieldMsg{})
 					p.areas[p.area] = model.(area)
 					return p, cmd
 				}
+				return p, nil
 			case key.Matches(msg, p.common.Keymap.Ok):
+				isFiltering := p.areas[p.area].IsFiltering()
 				model, cmd := p.areas[p.area].Update(msg)
 				if p.area != 3 {
 					p.areas[p.area] = model.(area)
+					if isFiltering {
+						return p, cmd
+					}
 					return p, tea.Batch(cmd, nextField())
 				}
 				return p, cmd
@@ -240,6 +279,10 @@ func (p *TaskEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			picker, cmd := p.areaPicker.Update(msg)
 			p.areaPicker = picker.(*areaPicker)
 			return p, cmd
+		} else if p.columnCursor == 2 {
+			var cmd tea.Cmd
+			p.infoViewport, cmd = p.infoViewport.Update(msg)
+			return p, cmd
 		} else {
 			model, cmd := p.areas[p.area].Update(msg)
 			p.areas[p.area] = model.(area)
@@ -252,29 +295,31 @@ func (p *TaskEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 func (p *TaskEditorPage) View() string {
 	var focusedStyle, blurredStyle lipgloss.Style
 	if p.mode == modeInsert {
-		focusedStyle = p.common.Styles.ColumnInsert.Width(p.colWidth).Height(p.colHeight)
+		focusedStyle = p.common.Styles.ColumnInsert
 	} else {
-		focusedStyle = p.common.Styles.ColumnFocused.Width(p.colWidth).Height(p.colHeight)
+		focusedStyle = p.common.Styles.ColumnFocused
 	}
-	blurredStyle = p.common.Styles.ColumnBlurred.Width(p.colWidth).Height(p.colHeight)
-	// var picker, area string
-	var area string
-	if p.columnCursor == 0 {
-		// picker = focusedStyle.Render(p.areaPicker.View())
-		area = blurredStyle.Render(p.areas[p.area].View())
-	} else {
-		// picker = blurredStyle.Render(p.areaPicker.View())
-		area = focusedStyle.Render(p.areas[p.area].View())
+	blurredStyle = p.common.Styles.ColumnBlurred
 
+	var area string
+	if p.columnCursor == 1 {
+		area = focusedStyle.Copy().Width(p.colWidth).Height(p.colHeight).Render(p.areas[p.area].View())
+	} else {
+		area = blurredStyle.Copy().Width(p.colWidth).Height(p.colHeight).Render(p.areas[p.area].View())
 	}
 
 	if p.task.Uuid != "" {
+		var infoView string
+		if p.columnCursor == 2 {
+			infoView = focusedStyle.Copy().Width(p.infoViewport.Width).Height(p.infoViewport.Height).Render(p.infoViewport.View())
+		} else {
+			infoView = blurredStyle.Copy().Width(p.infoViewport.Width).Height(p.infoViewport.Height).Render(p.infoViewport.View())
+		}
 		area = lipgloss.JoinHorizontal(
 			lipgloss.Top,
 			area,
-			p.common.Styles.ColumnFocused.Render(p.common.TW.GetInformation(&p.task)),
+			infoView,
 		)
-
 	}
 
 	tabs := ""
@@ -304,8 +349,11 @@ type area interface {
 	tea.Model
 	SetCursor(c int)
 	GetName() string
+	IsFiltering() bool
 }
 
+type focusMsg struct{}
+
 type areaPicker struct {
 	common *common.Common
 	list   list.Model
@@ -377,26 +425,60 @@ func (a *areaPicker) View() string {
 	return a.list.View()
 }
 
+type EditableField interface {
+	tea.Model
+	Focus() tea.Cmd
+	Blur() tea.Cmd
+}
+
 type taskEdit struct {
 	common *common.Common
-	fields []huh.Field
+	fields []EditableField
 	cursor int
 
+	projectPicker *picker.Picker
 	// newProjectName *string
 	newAnnotation *string
 	udaValues     map[string]*string
 }
 
-func NewTaskEdit(com *common.Common, task *taskwarrior.Task) *taskEdit {
+func NewTaskEdit(com *common.Common, task *taskwarrior.Task, isNew bool) *taskEdit {
 	// newProject := ""
-	projectOptions := append([]string{"(none)"}, com.TW.GetProjects()...)
 	if task.Project == "" {
 		task.Project = "(none)"
 	}
 
+	itemProvider := func() []list.Item {
+		projects := com.TW.GetProjects()
+		items := []list.Item{picker.NewItem("(none)")}
+		for _, proj := range projects {
+			items = append(items, picker.NewItem(proj))
+		}
+		return items
+	}
+	onSelect := func(item list.Item) tea.Cmd {
+		return nil
+	}
+	onCreate := func(newProject string) tea.Cmd {
+		// The new project name will be used as the project value
+		// when the task is saved
+		return nil
+	}
+
+	opts := []picker.PickerOption{picker.WithOnCreate(onCreate)}
+	if isNew {
+		opts = append(opts, picker.WithFilterByDefault(true))
+	} else {
+		opts = append(opts, picker.WithDefaultValue(task.Project))
+	}
+
+	projPicker := picker.New(com, "Project", itemProvider, onSelect, opts...)
+	projPicker.SetSize(70, 8)
+	projPicker.Blur()
+
 	defaultKeymap := huh.NewDefaultKeyMap()
 
-	fields := []huh.Field{
+	fields := []EditableField{
 		huh.NewInput().
 			Title("Task").
 			Value(&task.Description).
@@ -410,12 +492,7 @@ func NewTaskEdit(com *common.Common, task *taskwarrior.Task) *taskEdit {
 			Prompt(": ").
 			WithTheme(com.Styles.Form),
 
-		input.NewSelect(com).
-			Options(true, input.NewOptions(projectOptions...)...).
-			Title("Project").
-			Value(&task.Project).
-			WithKeyMap(defaultKeymap).
-			WithTheme(com.Styles.Form),
+		projPicker,
 
 		// huh.NewInput().
 		// 	Title("New Project").
@@ -510,6 +587,7 @@ func NewTaskEdit(com *common.Common, task *taskwarrior.Task) *taskEdit {
 	t := taskEdit{
 		common:        com,
 		fields:        fields,
+		projectPicker: projPicker,
 
 		udaValues: udaValues,
 
@@ -526,6 +604,13 @@ func (t *taskEdit) GetName() string {
 	return "Task"
 }
 
+func (t *taskEdit) IsFiltering() bool {
+	if f, ok := t.fields[t.cursor].(interface{ IsFiltering() bool }); ok {
+		return f.IsFiltering()
+	}
+	return false
+}
+
 func (t *taskEdit) SetCursor(c int) {
 	t.fields[t.cursor].Blur()
 	if c < 0 {
@@ -537,11 +622,25 @@ func (t *taskEdit) SetCursor(c int) {
 }
 
 func (t *taskEdit) Init() tea.Cmd {
-	return nil
+	var cmds []tea.Cmd
+	// Ensure focus on the active field (especially for the first one)
+	if len(t.fields) > 0 {
+		cmds = append(cmds, func() tea.Msg {
+			return focusMsg{}
+		})
+	}
+	for _, f := range t.fields {
+		cmds = append(cmds, f.Init())
+	}
+	return tea.Batch(cmds...)
 }
 
 func (t *taskEdit) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg.(type) {
+	case focusMsg:
+		if len(t.fields) > 0 {
+			return t, t.fields[t.cursor].Focus()
+		}
 	case nextFieldMsg:
 		if t.cursor == len(t.fields)-1 {
 			t.fields[t.cursor].Blur()
@@ -560,7 +659,7 @@ func (t *taskEdit) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		t.fields[t.cursor].Focus()
 	default:
 		field, cmd := t.fields[t.cursor].Update(msg)
-		t.fields[t.cursor] = field.(huh.Field)
+		t.fields[t.cursor] = field.(EditableField)
 		return t, cmd
 	}
 
@@ -623,6 +722,13 @@ func (t *tagEdit) GetName() string {
 	return "Tags"
 }
 
+func (t *tagEdit) IsFiltering() bool {
+	if f, ok := t.fields[t.cursor].(interface{ IsFiltering() bool }); ok {
+		return f.IsFiltering()
+	}
+	return false
+}
+
 func (t *tagEdit) SetCursor(c int) {
 	t.fields[t.cursor].Blur()
 	if c < 0 {
@@ -676,45 +782,56 @@ func (t tagEdit) View() string {
 
 type timeEdit struct {
 	common *common.Common
-	fields []huh.Field
+	fields []*timestampeditor.TimestampEditor
 
 	cursor int
+
+	// Store task field pointers to update them
+	due       *string
+	scheduled *string
+	wait      *string
+	until     *string
 }
 
 func NewTimeEdit(common *common.Common, due *string, scheduled *string, wait *string, until *string) *timeEdit {
-	// defaultKeymap := huh.NewDefaultKeyMap()
+	// Create timestamp editors for each date field
+	dueEditor := timestampeditor.New(common).
+		Title("Due").
+		Description("When the task is due").
+		ValueFromString(*due)
+
+	scheduledEditor := timestampeditor.New(common).
+		Title("Scheduled").
+		Description("When to start working on the task").
+		ValueFromString(*scheduled)
+
+	waitEditor := timestampeditor.New(common).
+		Title("Wait").
+		Description("Hide task until this date").
+		ValueFromString(*wait)
+
+	untilEditor := timestampeditor.New(common).
+		Title("Until").
+		Description("Task expires after this date").
+		ValueFromString(*until)
+
 	t := timeEdit{
 		common: common,
-		fields: []huh.Field{
-			huh.NewInput().
-				Title("Due").
-				Value(due).
-				Validate(taskwarrior.ValidateDate).
-				Inline(true).
-				Prompt(": ").
-				WithTheme(common.Styles.Form),
-			huh.NewInput().
-				Title("Scheduled").
-				Value(scheduled).
-				Validate(taskwarrior.ValidateDate).
-				Inline(true).
-				Prompt(": ").
-				WithTheme(common.Styles.Form),
-			huh.NewInput().
-				Title("Wait").
-				Value(wait).
-				Validate(taskwarrior.ValidateDate).
-				Inline(true).
-				Prompt(": ").
-				WithTheme(common.Styles.Form),
-			huh.NewInput().
-				Title("Until").
-				Value(until).
-				Validate(taskwarrior.ValidateDate).
-				Inline(true).
-				Prompt(": ").
-				WithTheme(common.Styles.Form),
+		fields: []*timestampeditor.TimestampEditor{
+			dueEditor,
+			scheduledEditor,
+			waitEditor,
+			untilEditor,
 		},
+		due:       due,
+		scheduled: scheduled,
+		wait:      wait,
+		until:     until,
+	}
+
+	// Focus the first field
+	if len(t.fields) > 0 {
+		t.fields[0].Focus()
 	}
 
 	return &t
@@ -724,13 +841,26 @@ func (t *timeEdit) GetName() string {
 	return "Dates"
 }
 
+func (t *timeEdit) IsFiltering() bool {
+	return false
+}
+
 func (t *timeEdit) SetCursor(c int) {
+	if len(t.fields) == 0 {
+		return
+	}
+
+	// Blur the current field
 	t.fields[t.cursor].Blur()
+
+	// Set new cursor position
 	if c < 0 {
 		t.cursor = len(t.fields) - 1
 	} else {
 		t.cursor = c
 	}
+
+	// Focus the new field
 	t.fields[t.cursor].Focus()
 }
 
@@ -739,42 +869,71 @@ func (t *timeEdit) Init() tea.Cmd {
 }
 
 func (t *timeEdit) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg.(type) {
+	switch msg := msg.(type) {
 	case nextFieldMsg:
 		if t.cursor == len(t.fields)-1 {
+			// Update task field before moving to next area
+			t.syncToTaskFields()
 			t.fields[t.cursor].Blur()
 			return t, nextArea()
 		}
 		t.fields[t.cursor].Blur()
 		t.cursor++
 		t.fields[t.cursor].Focus()
+		return t, nil
 	case prevFieldMsg:
 		if t.cursor == 0 {
+			// Update task field before moving to previous area
+			t.syncToTaskFields()
 			t.fields[t.cursor].Blur()
 			return t, prevArea()
 		}
 		t.fields[t.cursor].Blur()
 		t.cursor--
 		t.fields[t.cursor].Focus()
+		return t, nil
 	default:
-		field, cmd := t.fields[t.cursor].Update(msg)
-		t.fields[t.cursor] = field.(huh.Field)
+		// Update the current timestamp editor
+		model, cmd := t.fields[t.cursor].Update(msg)
+		t.fields[t.cursor] = model.(*timestampeditor.TimestampEditor)
 		return t, cmd
 	}
-	return t, nil
 }
 
 func (t *timeEdit) View() string {
 	views := make([]string, len(t.fields))
+
 	for i, field := range t.fields {
 		views[i] = field.View()
+		if i < len(t.fields)-1 {
+			views[i] += "\n"
 		}
+	}
+
 	return lipgloss.JoinVertical(
 		lipgloss.Left,
 		views...,
 	)
 }
 
+// syncToTaskFields converts the timestamp editor values back to task field strings
+func (t *timeEdit) syncToTaskFields() {
+	// Update the task fields with values from the timestamp editors
+	// GetValueString() returns empty string for unset timestamps
+	if len(t.fields) > 0 {
+		*t.due = t.fields[0].GetValueString()
+	}
+	if len(t.fields) > 1 {
+		*t.scheduled = t.fields[1].GetValueString()
+	}
+	if len(t.fields) > 2 {
+		*t.wait = t.fields[2].GetValueString()
+	}
+	if len(t.fields) > 3 {
+		*t.until = t.fields[3].GetValueString()
+	}
+}
+
 type detailsEdit struct {
 	com     *common.Common
 	vp      viewport.Model
@@ -794,11 +953,12 @@ func NewDetailsEdit(com *common.Common, task *taskwarrior.Task) *detailsEdit {
 	// 	return nil
 	// }
 
-	vp := viewport.New(40, 30)
+	vp := viewport.New(com.Width(), 40-com.Styles.ColumnFocused.GetVerticalFrameSize())
 	ta := textarea.New()
-	ta.SetWidth(40)
-	ta.SetHeight(30)
+	ta.SetWidth(70)
+	ta.SetHeight(40 - com.Styles.ColumnFocused.GetVerticalFrameSize() - 2)
 	ta.ShowLineNumbers = false
+	ta.FocusedStyle.CursorLine = lipgloss.NewStyle()
 	ta.Focus()
 	if task.Udas["details"] != nil {
 		ta.SetValue(task.Udas["details"].(string))
@@ -817,6 +977,10 @@ func (d *detailsEdit) GetName() string {
 	return "Details"
 }
 
+func (d *detailsEdit) IsFiltering() bool {
+	return false
+}
+
 func (d *detailsEdit) SetCursor(c int) {
 }
 
@@ -984,6 +1148,8 @@ func (d *detailsEdit) View() string {
 // }
 
 func (p *TaskEditorPage) updateTasksCmd() tea.Msg {
+	p.task.Project = p.areas[0].(*taskEdit).projectPicker.GetValue()
+
 	if p.task.Project == "(none)" {
 		p.task.Project = ""
 	}
@@ -1008,6 +1174,9 @@ func (p *TaskEditorPage) updateTasksCmd() tea.Msg {
 		}
 	}
 
+	// Sync timestamp fields from the timeEdit area (area 2)
+	p.areas[2].(*timeEdit).syncToTaskFields()
+
 	if *(p.areas[0].(*taskEdit).newAnnotation) != "" {
 		p.task.Annotations = append(p.task.Annotations, taskwarrior.Annotation{
 			Entry:       time.Now().Format("20060102T150405Z"),

pages/timeEditor.go

@@ -0,0 +1,510 @@
+package pages
+
+import (
+	"log/slog"
+	"strings"
+	"tasksquire/common"
+	"tasksquire/components/autocomplete"
+	"tasksquire/components/picker"
+	"tasksquire/components/timestampeditor"
+	"tasksquire/timewarrior"
+
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/list"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+type TimeEditorPage struct {
+	common   *common.Common
+	interval *timewarrior.Interval
+
+	// Fields
+	projectPicker *picker.Picker
+	startEditor   *timestampeditor.TimestampEditor
+	endEditor     *timestampeditor.TimestampEditor
+	tagsInput     *autocomplete.Autocomplete
+	adjust        bool
+
+	// State
+	selectedProject string
+	currentField    int
+	totalFields     int
+}
+
+type timeEditorProjectSelectedMsg struct {
+	project string
+}
+
+func NewTimeEditorPage(com *common.Common, interval *timewarrior.Interval) *TimeEditorPage {
+	// Extract project from tags if it exists
+	projects := com.TW.GetProjects()
+	selectedProject, remainingTags := extractProjectFromTags(interval.Tags, projects)
+
+	// Create project picker with onCreate support for new projects
+	projectItemProvider := func() []list.Item {
+		projects := com.TW.GetProjects()
+		items := make([]list.Item, len(projects))
+		for i, proj := range projects {
+			items[i] = picker.NewItem(proj)
+		}
+		return items
+	}
+
+	projectOnSelect := func(item list.Item) tea.Cmd {
+		return func() tea.Msg {
+			return timeEditorProjectSelectedMsg{project: item.FilterValue()}
+		}
+	}
+
+	projectOnCreate := func(name string) tea.Cmd {
+		return func() tea.Msg {
+			return timeEditorProjectSelectedMsg{project: name}
+		}
+	}
+
+	opts := []picker.PickerOption{
+		picker.WithOnCreate(projectOnCreate),
+	}
+	if selectedProject != "" {
+		opts = append(opts, picker.WithDefaultValue(selectedProject))
+	} else {
+		opts = append(opts, picker.WithFilterByDefault(true))
+	}
+
+	projectPicker := picker.New(
+		com,
+		"Project",
+		projectItemProvider,
+		projectOnSelect,
+		opts...,
+	)
+	projectPicker.SetSize(50, 10) // Compact size for inline use
+
+	// Create start timestamp editor
+	startEditor := timestampeditor.New(com).
+		Title("Start").
+		ValueFromString(interval.Start)
+
+	// Create end timestamp editor
+	endEditor := timestampeditor.New(com).
+		Title("End").
+		ValueFromString(interval.End)
+
+	// Get tag combinations filtered by selected project
+	tagCombinations := filterTagCombinationsByProject(
+		com.TimeW.GetTagCombinations(),
+		selectedProject,
+	)
+
+	tagsInput := autocomplete.New(tagCombinations, 3, 10)
+	tagsInput.SetPlaceholder("Space separated, use \"\" for tags with spaces")
+	tagsInput.SetValue(formatTags(remainingTags)) // Use remaining tags (without project)
+	tagsInput.SetWidth(50)
+
+	p := &TimeEditorPage{
+		common:          com,
+		interval:        interval,
+		projectPicker:   projectPicker,
+		startEditor:     startEditor,
+		endEditor:       endEditor,
+		tagsInput:       tagsInput,
+		adjust:          true, // Enable :adjust by default
+		selectedProject: selectedProject,
+		currentField:    0,
+		totalFields:     5, // Now 5 fields: project, tags, start, end, adjust
+	}
+
+	return p
+}
+
+func (p *TimeEditorPage) Init() tea.Cmd {
+	// Focus the first field (project picker)
+	p.currentField = 0
+	return p.projectPicker.Init()
+}
+
+func (p *TimeEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmds []tea.Cmd
+
+	switch msg := msg.(type) {
+	case timeEditorProjectSelectedMsg:
+		// Update selected project
+		p.selectedProject = msg.project
+		// Blur current field (project picker)
+		p.blurCurrentField()
+		// Advance to tags field
+		p.currentField = 1
+		// Refresh tag autocomplete with filtered combinations
+		cmds = append(cmds, p.updateTagSuggestions())
+		// Focus tags input
+		cmds = append(cmds, p.focusCurrentField())
+		return p, tea.Batch(cmds...)
+
+	case tea.KeyMsg:
+		switch {
+		case key.Matches(msg, p.common.Keymap.Back):
+			model, err := p.common.PopPage()
+			if err != nil {
+				slog.Error("page stack empty")
+				return nil, tea.Quit
+			}
+			return model, BackCmd
+
+		case key.Matches(msg, p.common.Keymap.Ok):
+			// Handle Enter based on current field
+			if p.currentField == 0 {
+				// Project picker - let it handle Enter (will trigger projectSelectedMsg)
+				break
+			}
+
+			if p.currentField == 1 {
+				// Tags field
+				if p.tagsInput.HasSuggestions() {
+					// Let autocomplete handle suggestion selection
+					break
+				}
+				// Tags confirmed without suggestions - advance to start timestamp
+				p.blurCurrentField()
+				p.currentField = 2
+				cmds = append(cmds, p.focusCurrentField())
+				return p, tea.Batch(cmds...)
+			}
+
+			// For all other fields (2-4: start, end, adjust), save and exit
+			p.saveInterval()
+			model, err := p.common.PopPage()
+			if err != nil {
+				slog.Error("page stack empty")
+				return nil, tea.Quit
+			}
+			return model, tea.Batch(tea.Batch(cmds...), refreshIntervals)
+
+		case key.Matches(msg, p.common.Keymap.Next):
+			// Move to next field
+			p.blurCurrentField()
+			p.currentField = (p.currentField + 1) % p.totalFields
+			cmds = append(cmds, p.focusCurrentField())
+
+		case key.Matches(msg, p.common.Keymap.Prev):
+			// Move to previous field
+			p.blurCurrentField()
+			p.currentField = (p.currentField - 1 + p.totalFields) % p.totalFields
+			cmds = append(cmds, p.focusCurrentField())
+		}
+
+	case tea.WindowSizeMsg:
+		p.SetSize(msg.Width, msg.Height)
+	}
+
+	// Update the currently focused field
+	var cmd tea.Cmd
+	switch p.currentField {
+	case 0: // Project picker
+		var model tea.Model
+		model, cmd = p.projectPicker.Update(msg)
+		if pk, ok := model.(*picker.Picker); ok {
+			p.projectPicker = pk
+		}
+	case 1: // Tags (was 0)
+		var model tea.Model
+		model, cmd = p.tagsInput.Update(msg)
+		if ac, ok := model.(*autocomplete.Autocomplete); ok {
+			p.tagsInput = ac
+		}
+	case 2: // Start (was 1)
+		var model tea.Model
+		model, cmd = p.startEditor.Update(msg)
+		if editor, ok := model.(*timestampeditor.TimestampEditor); ok {
+			p.startEditor = editor
+		}
+	case 3: // End (was 2)
+		var model tea.Model
+		model, cmd = p.endEditor.Update(msg)
+		if editor, ok := model.(*timestampeditor.TimestampEditor); ok {
+			p.endEditor = editor
+		}
+	case 4: // Adjust (was 3)
+		// Handle adjust toggle with space/enter
+		if msg, ok := msg.(tea.KeyMsg); ok {
+			if msg.String() == " " || msg.String() == "enter" {
+				p.adjust = !p.adjust
+			}
+		}
+	}
+	cmds = append(cmds, cmd)
+
+	return p, tea.Batch(cmds...)
+}
+
+func (p *TimeEditorPage) focusCurrentField() tea.Cmd {
+	switch p.currentField {
+	case 0:
+		return p.projectPicker.Init() // Picker doesn't have explicit Focus()
+	case 1:
+		p.tagsInput.Focus()
+		return p.tagsInput.Init()
+	case 2:
+		return p.startEditor.Focus()
+	case 3:
+		return p.endEditor.Focus()
+	case 4:
+		// Adjust checkbox doesn't need focus action
+		return nil
+	}
+	return nil
+}
+
+func (p *TimeEditorPage) blurCurrentField() {
+	switch p.currentField {
+	case 0:
+		// Picker doesn't have explicit Blur(), state handled by Update
+	case 1:
+		p.tagsInput.Blur()
+	case 2:
+		p.startEditor.Blur()
+	case 3:
+		p.endEditor.Blur()
+	case 4:
+		// Adjust checkbox doesn't need blur action
+	}
+}
+
+func (p *TimeEditorPage) View() string {
+	var sections []string
+
+	// Title
+	titleStyle := p.common.Styles.Form.Focused.Title
+	sections = append(sections, titleStyle.Render("Edit Time Interval"))
+	sections = append(sections, "")
+
+	// Project picker (field 0)
+	if p.currentField == 0 {
+		sections = append(sections, p.projectPicker.View())
+	} else {
+		blurredLabelStyle := p.common.Styles.Form.Blurred.Title
+		sections = append(sections, blurredLabelStyle.Render("Project"))
+		sections = append(sections, lipgloss.NewStyle().Faint(true).Render(p.selectedProject))
+	}
+
+	sections = append(sections, "")
+	sections = append(sections, "")
+
+	// Tags input (now field 1, was first)
+	tagsLabelStyle := p.common.Styles.Form.Focused.Title
+	tagsLabel := tagsLabelStyle.Render("Tags")
+	if p.currentField == 1 { // Changed from 0
+		sections = append(sections, tagsLabel)
+		sections = append(sections, p.tagsInput.View())
+		descStyle := p.common.Styles.Form.Focused.Description
+		sections = append(sections, descStyle.Render("Space separated, use \"\" for tags with spaces"))
+	} else {
+		blurredLabelStyle := p.common.Styles.Form.Blurred.Title
+		sections = append(sections, blurredLabelStyle.Render("Tags"))
+		sections = append(sections, lipgloss.NewStyle().Faint(true).Render(p.tagsInput.GetValue()))
+	}
+
+	sections = append(sections, "")
+	sections = append(sections, "")
+
+	// Start editor
+	sections = append(sections, p.startEditor.View())
+	sections = append(sections, "")
+
+	// End editor
+	sections = append(sections, p.endEditor.View())
+	sections = append(sections, "")
+
+	// Adjust checkbox (now field 4, was 3)
+	adjustLabelStyle := p.common.Styles.Form.Focused.Title
+	adjustLabel := adjustLabelStyle.Render("Adjust overlaps")
+
+	var checkbox string
+	if p.adjust {
+		checkbox = "[X]"
+	} else {
+		checkbox = "[ ]"
+	}
+
+	if p.currentField == 4 { // Changed from 3
+		focusedStyle := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("12"))
+		sections = append(sections, adjustLabel)
+		sections = append(sections, focusedStyle.Render(checkbox+" Auto-adjust overlapping intervals"))
+		descStyle := p.common.Styles.Form.Focused.Description
+		sections = append(sections, descStyle.Render("Press space to toggle"))
+	} else {
+		blurredLabelStyle := p.common.Styles.Form.Blurred.Title
+		sections = append(sections, blurredLabelStyle.Render("Adjust overlaps"))
+		sections = append(sections, lipgloss.NewStyle().Faint(true).Render(checkbox+" Auto-adjust overlapping intervals"))
+	}
+
+	sections = append(sections, "")
+	sections = append(sections, "")
+
+	// Help text
+	helpStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
+	sections = append(sections, helpStyle.Render("tab/shift+tab: navigate • enter: save • esc: cancel"))
+
+	return lipgloss.JoinVertical(lipgloss.Left, sections...)
+}
+
+func (p *TimeEditorPage) SetSize(width, height int) {
+	p.common.SetSize(width, height)
+}
+
+func (p *TimeEditorPage) saveInterval() {
+	// If it's an existing interval (has ID), delete it first so we can replace it with the modified version
+	if p.interval.ID != 0 {
+		err := p.common.TimeW.DeleteInterval(p.interval.ID)
+		if err != nil {
+			slog.Error("Failed to delete old interval during edit", "err", err)
+			// Proceeding to import anyway, attempting to save user data
+		}
+	}
+
+	p.interval.Start = p.startEditor.GetValueString()
+	p.interval.End = p.endEditor.GetValueString()
+
+	// Parse tags from input
+	tags := parseTags(p.tagsInput.GetValue())
+
+	// Add project to tags if not already present
+	if p.selectedProject != "" {
+		projectTag := "project:" + p.selectedProject
+		projectExists := false
+		for _, tag := range tags {
+			if tag == projectTag {
+				projectExists = true
+				break
+			}
+		}
+		if !projectExists {
+			tags = append([]string{projectTag}, tags...) // Prepend project tag
+		}
+	}
+
+	p.interval.Tags = tags
+
+	err := p.common.TimeW.ModifyInterval(p.interval, p.adjust)
+	if err != nil {
+		slog.Error("Failed to modify interval", "err", err)
+	}
+}
+
+func parseTags(tagsStr string) []string {
+	var tags []string
+	var current strings.Builder
+	inQuotes := false
+
+	for _, r := range tagsStr {
+		switch {
+		case r == '"':
+			inQuotes = !inQuotes
+		case r == ' ' && !inQuotes:
+			if current.Len() > 0 {
+				tags = append(tags, current.String())
+				current.Reset()
+			}
+		default:
+			current.WriteRune(r)
+		}
+	}
+	if current.Len() > 0 {
+		tags = append(tags, current.String())
+	}
+	return tags
+}
+
+func formatTags(tags []string) string {
+	var formatted []string
+	for _, t := range tags {
+		if strings.Contains(t, " ") {
+			formatted = append(formatted, "\""+t+"\"")
+		} else {
+			formatted = append(formatted, t)
+		}
+	}
+	return strings.Join(formatted, " ")
+}
+
+// extractProjectFromTags finds and removes the first tag that matches a known project
+// Returns the found project (or empty string) and the remaining tags
+func extractProjectFromTags(tags []string, projects []string) (string, []string) {
+	projectSet := make(map[string]bool)
+	for _, p := range projects {
+		projectSet[p] = true
+	}
+
+	var foundProject string
+	var remaining []string
+
+	for _, tag := range tags {
+		// Check if this tag is a project tag (format: "project:projectname")
+		if strings.HasPrefix(tag, "project:") {
+			projectName := strings.TrimPrefix(tag, "project:")
+			if foundProject == "" && projectSet[projectName] {
+				foundProject = projectName // First matching project
+				continue                   // Don't add to remaining tags
+			}
+		}
+		remaining = append(remaining, tag)
+	}
+
+	return foundProject, remaining
+}
+
+// filterTagCombinationsByProject filters tag combinations to only show those
+// containing the exact project tag, and removes the project from the displayed combination
+func filterTagCombinationsByProject(combinations []string, project string) []string {
+	if project == "" {
+		return combinations
+	}
+
+	projectTag := "project:" + project
+
+	var filtered []string
+	for _, combo := range combinations {
+		// Parse the combination into individual tags
+		tags := parseTags(combo)
+
+		// Check if project exists in this combination
+		for _, tag := range tags {
+			if tag == projectTag {
+				// Found the project - now remove it from display
+				var displayTags []string
+				for _, t := range tags {
+					if t != projectTag {
+						displayTags = append(displayTags, t)
+					}
+				}
+				if len(displayTags) > 0 {
+					filtered = append(filtered, formatTags(displayTags))
+				}
+				break
+			}
+		}
+	}
+
+	return filtered
+}
+
+// updateTagSuggestions refreshes the tag autocomplete with filtered combinations
+func (p *TimeEditorPage) updateTagSuggestions() tea.Cmd {
+	combinations := filterTagCombinationsByProject(
+		p.common.TimeW.GetTagCombinations(),
+		p.selectedProject,
+	)
+
+	// Update autocomplete suggestions
+	currentValue := p.tagsInput.GetValue()
+	p.tagsInput.SetSuggestions(combinations)
+	p.tagsInput.SetValue(currentValue)
+
+	// If tags field is focused, refocus it
+	if p.currentField == 1 {
+		p.tagsInput.Focus()
+		return p.tagsInput.Init()
+	}
+
+	return nil
+}

pages/timePage.go

@@ -1,12 +1,17 @@
 package pages
 
 import (
+	"fmt"
+	"log/slog"
+	"time"
+
 	"tasksquire/common"
 	"tasksquire/components/timetable"
 	"tasksquire/timewarrior"
 
 	"github.com/charmbracelet/bubbles/key"
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 )
 
 type TimePage struct {
@@ -16,29 +21,170 @@ type TimePage struct {
 	data      timewarrior.Intervals
 
 	shouldSelectActive bool
+	pendingSyncAction  string // "start", "stop", or "" (empty means no pending action)
+
+	selectedTimespan string
+	subpage          common.Component
 }
 
 func NewTimePage(com *common.Common) *TimePage {
 	p := &TimePage{
 		common:           com,
+		selectedTimespan: ":day",
 	}
 
 	p.populateTable(timewarrior.Intervals{})
 	return p
 }
 
+func (p *TimePage) isMultiDayTimespan() bool {
+	switch p.selectedTimespan {
+	case ":day", ":yesterday":
+		return false
+	case ":week", ":lastweek", ":month", ":lastmonth", ":year":
+		return true
+	default:
+		return true
+	}
+}
+
+func (p *TimePage) getTimespanLabel() string {
+	switch p.selectedTimespan {
+	case ":day":
+		return "Today"
+	case ":yesterday":
+		return "Yesterday"
+	case ":week":
+		return "Week"
+	case ":lastweek":
+		return "Last Week"
+	case ":month":
+		return "Month"
+	case ":lastmonth":
+		return "Last Month"
+	case ":year":
+		return "Year"
+	default:
+		return p.selectedTimespan
+	}
+}
+
+func (p *TimePage) getTimespanDateRange() (start, end time.Time) {
+	now := time.Now()
+
+	switch p.selectedTimespan {
+	case ":day":
+		start = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+		end = start.AddDate(0, 0, 1)
+	case ":yesterday":
+		start = time.Date(now.Year(), now.Month(), now.Day()-1, 0, 0, 0, 0, now.Location())
+		end = start.AddDate(0, 0, 1)
+	case ":week":
+		// Find the start of the week (Monday)
+		offset := int(time.Monday - now.Weekday())
+		if offset > 0 {
+			offset = -6
+		}
+		start = time.Date(now.Year(), now.Month(), now.Day()+offset, 0, 0, 0, 0, now.Location())
+		end = start.AddDate(0, 0, 7)
+	case ":lastweek":
+		// Find the start of last week
+		offset := int(time.Monday - now.Weekday())
+		if offset > 0 {
+			offset = -6
+		}
+		start = time.Date(now.Year(), now.Month(), now.Day()+offset-7, 0, 0, 0, 0, now.Location())
+		end = start.AddDate(0, 0, 7)
+	case ":month":
+		start = time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
+		end = start.AddDate(0, 1, 0)
+	case ":lastmonth":
+		start = time.Date(now.Year(), now.Month()-1, 1, 0, 0, 0, 0, now.Location())
+		end = start.AddDate(0, 1, 0)
+	case ":year":
+		start = time.Date(now.Year(), 1, 1, 0, 0, 0, 0, now.Location())
+		end = start.AddDate(1, 0, 0)
+	default:
+		start = now
+		end = now
+	}
+
+	return start, end
+}
+
+func (p *TimePage) renderHeader() string {
+	label := p.getTimespanLabel()
+	start, end := p.getTimespanDateRange()
+
+	var headerText string
+	if p.isMultiDayTimespan() {
+		// Multi-day format: "Week: Feb 02 - Feb 08, 2026"
+		if start.Year() == end.AddDate(0, 0, -1).Year() {
+			headerText = fmt.Sprintf("%s: %s - %s, %d",
+				label,
+				start.Format("Jan 02"),
+				end.AddDate(0, 0, -1).Format("Jan 02"),
+				start.Year())
+		} else {
+			headerText = fmt.Sprintf("%s: %s, %d - %s, %d",
+				label,
+				start.Format("Jan 02"),
+				start.Year(),
+				end.AddDate(0, 0, -1).Format("Jan 02"),
+				end.AddDate(0, 0, -1).Year())
+		}
+	} else {
+		// Single-day format: "Today (Mon, Feb 02, 2026)"
+		headerText = fmt.Sprintf("%s (%s, %s, %d)",
+			label,
+			start.Format("Mon"),
+			start.Format("Jan 02"),
+			start.Year())
+	}
+
+	slog.Info("Rendering time page header", "text", headerText, "timespan", p.selectedTimespan)
+	// Make header bold and prominent
+	headerStyle := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("6"))
+	return headerStyle.Render(headerText)
+}
+
 func (p *TimePage) Init() tea.Cmd {
 	return tea.Batch(p.getIntervals(), doTick())
 }
 
 func (p *TimePage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	var cmds []tea.Cmd
+
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
 		p.SetSize(msg.Width, msg.Height)
+	case UpdateTimespanMsg:
+		p.selectedTimespan = string(msg)
+		cmds = append(cmds, p.getIntervals())
 	case intervalsMsg:
 		p.data = timewarrior.Intervals(msg)
 		p.populateTable(p.data)
+
+		// If we have a pending sync action (from continuing an interval),
+		// execute it now that intervals are refreshed
+		if p.pendingSyncAction != "" {
+			action := p.pendingSyncAction
+			p.pendingSyncAction = ""
+			cmds = append(cmds, p.syncActiveIntervalAfterRefresh(action))
+		}
+	case TaskPickedMsg:
+		if msg.Task != nil && msg.Task.Status == "pending" {
+			p.common.TW.StopActiveTasks()
+			p.common.TW.StartTask(msg.Task)
+			cmds = append(cmds, p.getIntervals())
+			cmds = append(cmds, doTick())
+		}
+	case RefreshIntervalsMsg:
+		cmds = append(cmds, p.getIntervals())
+		cmds = append(cmds, doTick())
+	case BackMsg:
+		// Restart tick loop when returning from subpage
+		cmds = append(cmds, doTick())
 	case tickMsg:
 		cmds = append(cmds, p.getIntervals())
 		cmds = append(cmds, doTick())
@@ -46,17 +192,48 @@ func (p *TimePage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		switch {
 		case key.Matches(msg, p.common.Keymap.Quit):
 			return p, tea.Quit
+		case key.Matches(msg, p.common.Keymap.SetReport):
+			// Use 'r' key to show timespan picker
+			p.subpage = NewTimespanPickerPage(p.common, p.selectedTimespan)
+			cmd := p.subpage.Init()
+			p.common.PushPage(p)
+			return p.subpage, cmd
+		case key.Matches(msg, p.common.Keymap.PickProjectTask):
+			p.subpage = NewProjectTaskPickerPage(p.common)
+			cmd := p.subpage.Init()
+			p.common.PushPage(p)
+			return p.subpage, cmd
 		case key.Matches(msg, p.common.Keymap.StartStop):
 			row := p.intervals.SelectedRow()
 			if row != nil {
 				interval := (*timewarrior.Interval)(row)
+
+				// Validate interval before proceeding
+				if interval.IsGap {
+					slog.Debug("Cannot start/stop gap interval")
+					return p, nil
+				}
+
 				if interval.IsActive() {
+					// Stop tracking
 					p.common.TimeW.StopTracking()
+					// Sync: stop corresponding Taskwarrior task immediately (interval has UUID)
+					common.SyncIntervalToTask(interval, p.common.TW, "stop")
 				} else {
+					// Continue tracking - creates a NEW interval
+					slog.Info("Continuing interval for task sync",
+						"intervalID", interval.ID,
+						"hasUUID", timewarrior.ExtractUUID(interval.Tags) != "",
+						"uuid", timewarrior.ExtractUUID(interval.Tags))
 					p.common.TimeW.ContinueInterval(interval.ID)
 					p.shouldSelectActive = true
+					// Set pending sync action instead of syncing immediately
+					// This ensures we sync AFTER intervals are refreshed
+					p.pendingSyncAction = "start"
 				}
-				return p, tea.Batch(p.getIntervals(), doTick())
+				cmds = append(cmds, p.getIntervals())
+				cmds = append(cmds, doTick())
+				return p, tea.Batch(cmds...)
 			}
 		case key.Matches(msg, p.common.Keymap.Delete):
 			row := p.intervals.SelectedRow()
@@ -65,6 +242,40 @@ func (p *TimePage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				p.common.TimeW.DeleteInterval(interval.ID)
 				return p, tea.Batch(p.getIntervals(), doTick())
 			}
+		case key.Matches(msg, p.common.Keymap.Edit):
+			row := p.intervals.SelectedRow()
+			if row != nil {
+				interval := (*timewarrior.Interval)(row)
+				editor := NewTimeEditorPage(p.common, interval)
+				p.common.PushPage(p)
+				return editor, editor.Init()
+			}
+		case key.Matches(msg, p.common.Keymap.Add):
+			interval := timewarrior.NewInterval()
+			interval.Start = time.Now().UTC().Format("20060102T150405Z")
+			editor := NewTimeEditorPage(p.common, interval)
+			p.common.PushPage(p)
+			return editor, editor.Init()
+		case key.Matches(msg, p.common.Keymap.Fill):
+			row := p.intervals.SelectedRow()
+			if row != nil {
+				interval := (*timewarrior.Interval)(row)
+				p.common.TimeW.FillInterval(interval.ID)
+				return p, tea.Batch(p.getIntervals(), doTick())
+			}
+		case key.Matches(msg, p.common.Keymap.Undo):
+			p.common.TimeW.Undo()
+			return p, tea.Batch(p.getIntervals(), doTick())
+		case key.Matches(msg, p.common.Keymap.Join):
+			row := p.intervals.SelectedRow()
+			if row != nil {
+				interval := (*timewarrior.Interval)(row)
+				// Don't join if this is the last (oldest) interval
+				if interval.ID < len(p.data) {
+					p.common.TimeW.JoinInterval(interval.ID)
+					return p, tea.Batch(p.getIntervals(), doTick())
+				}
+			}
 		}
 	}
 
@@ -75,50 +286,140 @@ func (p *TimePage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return p, tea.Batch(cmds...)
 }
 
+type RefreshIntervalsMsg struct{}
+
+func refreshIntervals() tea.Msg {
+	return RefreshIntervalsMsg{}
+}
+
 func (p *TimePage) View() string {
+	header := p.renderHeader()
 	if len(p.data) == 0 {
-		return p.common.Styles.Base.Render("No intervals found for today")
+		noDataMsg := p.common.Styles.Base.Render("No intervals found")
+		content := header + "\n\n" + noDataMsg
+		return lipgloss.Place(
+			p.common.Width(),
+			p.common.Height(),
+			lipgloss.Left,
+			lipgloss.Top,
+			content,
+		)
 	}
-	return p.intervals.View()
+
+	tableView := p.intervals.View()
+	content := header + "\n\n" + tableView
+
+	contentHeight := lipgloss.Height(content)
+	tableHeight := lipgloss.Height(tableView)
+	headerHeight := lipgloss.Height(header)
+
+	slog.Info("TimePage View rendered",
+		"headerLen", len(header),
+		"dataCount", len(p.data),
+		"headerHeight", headerHeight,
+		"tableHeight", tableHeight,
+		"contentHeight", contentHeight,
+		"termHeight", p.common.Height())
+
+	return content
 }
 
 func (p *TimePage) SetSize(width int, height int) {
 	p.common.SetSize(width, height)
+	frameSize := p.common.Styles.Base.GetVerticalFrameSize()
+	tableHeight := height - frameSize - 3
+	slog.Info("TimePage SetSize", "totalHeight", height, "frameSize", frameSize, "tableHeight", tableHeight)
 	p.intervals.SetWidth(width - p.common.Styles.Base.GetHorizontalFrameSize())
-	p.intervals.SetHeight(height - p.common.Styles.Base.GetVerticalFrameSize())
+	// Subtract 3: 1 for header line, 1 for empty line, 1 for safety margin
+	p.intervals.SetHeight(tableHeight)
+}
+
+// insertGaps inserts gap intervals between actual intervals where there is untracked time.
+// Gaps are not inserted before the first interval or after the last interval.
+// Note: intervals are in reverse chronological order (newest first), so we need to account for that.
+func insertGaps(intervals timewarrior.Intervals) timewarrior.Intervals {
+	if len(intervals) <= 1 {
+		return intervals
+	}
+
+	result := make(timewarrior.Intervals, 0, len(intervals)*2)
+
+	for i := 0; i < len(intervals); i++ {
+		result = append(result, intervals[i])
+
+		// Don't add gap after the last interval
+		if i < len(intervals)-1 {
+			// Since intervals are reversed (newest first), the gap is between
+			// the end of the NEXT interval and the start of the CURRENT interval
+			currentStart := intervals[i].GetStartTime()
+			nextEnd := intervals[i+1].GetEndTime()
+
+			// Calculate gap duration
+			gap := currentStart.Sub(nextEnd)
+
+			// Only insert gap if there is untracked time
+			if gap > 0 {
+				gapInterval := timewarrior.NewGapInterval(nextEnd, currentStart)
+				result = append(result, gapInterval)
+			}
+		}
+	}
+
+	return result
 }
 
 func (p *TimePage) populateTable(intervals timewarrior.Intervals) {
 	var selectedStart string
-	currentIdx := p.intervals.Cursor()
 	if row := p.intervals.SelectedRow(); row != nil {
 		selectedStart = row.Start
 	}
 
+	// Insert gap intervals between actual intervals
+	intervalsWithGaps := insertGaps(intervals)
+
+	// Determine column configuration based on timespan
+	var startEndWidth int
+	var startField, endField string
+	if p.isMultiDayTimespan() {
+		startEndWidth = 16 // "2006-01-02 15:04"
+		startField = "start"
+		endField = "end"
+	} else {
+		startEndWidth = 5 // "15:04"
+		startField = "start_time"
+		endField = "end_time"
+	}
+
 	columns := []timetable.Column{
 		{Title: "ID", Name: "id", Width: 4},
-		{Title: "Start", Name: "start", Width: 16},
-		{Title: "End", Name: "end", Width: 16},
+		{Title: "Weekday", Name: "weekday", Width: 9},
+		{Title: "Start", Name: startField, Width: startEndWidth},
+		{Title: "End", Name: endField, Width: startEndWidth},
 		{Title: "Duration", Name: "duration", Width: 10},
+		{Title: "Project", Name: "project", Width: 0}, // flexible width
 		{Title: "Tags", Name: "tags", Width: 0},       // flexible width
 	}
 
+	// Calculate table height: total height - header (1 line) - blank line (1) - safety (1)
+	frameSize := p.common.Styles.Base.GetVerticalFrameSize()
+	tableHeight := p.common.Height() - frameSize - 3
+
 	p.intervals = timetable.New(
 		p.common,
 		timetable.WithColumns(columns),
-		timetable.WithIntervals(intervals),
+		timetable.WithIntervals(intervalsWithGaps),
 		timetable.WithFocused(true),
-		timetable.WithWidth(p.common.Width()-p.common.Styles.Base.GetVerticalFrameSize()),
-		timetable.WithHeight(p.common.Height()-p.common.Styles.Base.GetHorizontalFrameSize()),
+		timetable.WithWidth(p.common.Width()-p.common.Styles.Base.GetHorizontalFrameSize()),
+		timetable.WithHeight(tableHeight),
 		timetable.WithStyles(p.common.Styles.TableStyle),
 	)
 
-	if len(intervals) > 0 {
+	if len(intervalsWithGaps) > 0 {
 		newIdx := -1
 
 		if p.shouldSelectActive {
-			for i, interval := range intervals {
-				if interval.IsActive() {
+			for i, interval := range intervalsWithGaps {
+				if !interval.IsGap && interval.IsActive() {
 					newIdx = i
 					break
 				}
@@ -127,8 +428,8 @@ func (p *TimePage) populateTable(intervals timewarrior.Intervals) {
 		}
 
 		if newIdx == -1 && selectedStart != "" {
-			for i, interval := range intervals {
-				if interval.Start == selectedStart {
+			for i, interval := range intervalsWithGaps {
+				if !interval.IsGap && interval.Start == selectedStart {
 					newIdx = i
 					break
 				}
@@ -136,11 +437,17 @@ func (p *TimePage) populateTable(intervals timewarrior.Intervals) {
 		}
 
 		if newIdx == -1 {
-			newIdx = currentIdx
+			// Default to first non-gap interval
+			for i, interval := range intervalsWithGaps {
+				if !interval.IsGap {
+					newIdx = i
+					break
+				}
+			}
 		}
 
-		if newIdx >= len(intervals) {
-			newIdx = len(intervals) - 1
+		if newIdx >= len(intervalsWithGaps) {
+			newIdx = len(intervalsWithGaps) - 1
 		}
 		if newIdx < 0 {
 			newIdx = 0
@@ -154,8 +461,38 @@ type intervalsMsg timewarrior.Intervals
 
 func (p *TimePage) getIntervals() tea.Cmd {
 	return func() tea.Msg {
-		// ":day" is a timewarrior hint for "today"
-		intervals := p.common.TimeW.GetIntervals(":day")
+		intervals := p.common.TimeW.GetIntervals(p.selectedTimespan)
 		return intervalsMsg(intervals)
 	}
 }
+
+// syncActiveInterval creates a command that syncs the currently active interval to Taskwarrior
+func (p *TimePage) syncActiveInterval(action string) tea.Cmd {
+	return func() tea.Msg {
+		// Get the currently active interval
+		activeInterval := p.common.TimeW.GetActive()
+		if activeInterval != nil {
+			common.SyncIntervalToTask(activeInterval, p.common.TW, action)
+		}
+		return nil
+	}
+}
+
+// syncActiveIntervalAfterRefresh is called AFTER intervals have been refreshed
+// to ensure we're working with current data
+func (p *TimePage) syncActiveIntervalAfterRefresh(action string) tea.Cmd {
+	return func() tea.Msg {
+		// At this point, intervals have been refreshed, so GetActive() will work
+		activeInterval := p.common.TimeW.GetActive()
+		if activeInterval != nil {
+			slog.Info("Syncing active interval to task after refresh",
+				"action", action,
+				"intervalID", activeInterval.ID,
+				"hasUUID", timewarrior.ExtractUUID(activeInterval.Tags) != "")
+			common.SyncIntervalToTask(activeInterval, p.common.TW, action)
+		} else {
+			slog.Warn("No active interval found after refresh, cannot sync to task")
+		}
+		return nil
+	}
+}

pages/timePage_test.go

@@ -0,0 +1,146 @@
+package pages
+
+import (
+	"testing"
+	"time"
+
+	"tasksquire/timewarrior"
+)
+
+func TestInsertGaps(t *testing.T) {
+	tests := []struct {
+		name          string
+		intervals     timewarrior.Intervals
+		expectedCount int
+		expectedGaps  int
+		description   string
+	}{
+		{
+			name:          "empty intervals",
+			intervals:     timewarrior.Intervals{},
+			expectedCount: 0,
+			expectedGaps:  0,
+			description:   "Should return empty list for empty input",
+		},
+		{
+			name: "single interval",
+			intervals: timewarrior.Intervals{
+				{
+					ID:    1,
+					Start: time.Now().Add(-1 * time.Hour).UTC().Format("20060102T150405Z"),
+					End:   time.Now().UTC().Format("20060102T150405Z"),
+					Tags:  []string{"test"},
+				},
+			},
+			expectedCount: 1,
+			expectedGaps:  0,
+			description:   "Should return single interval without gaps",
+		},
+		{
+			name: "two intervals with gap (reverse chronological)",
+			intervals: timewarrior.Intervals{
+				{
+					ID:    1,
+					Start: time.Now().Add(-1 * time.Hour).UTC().Format("20060102T150405Z"),
+					End:   time.Now().UTC().Format("20060102T150405Z"),
+					Tags:  []string{"test2"},
+				},
+				{
+					ID:    2,
+					Start: time.Now().Add(-3 * time.Hour).UTC().Format("20060102T150405Z"),
+					End:   time.Now().Add(-2 * time.Hour).UTC().Format("20060102T150405Z"),
+					Tags:  []string{"test1"},
+				},
+			},
+			expectedCount: 3,
+			expectedGaps:  1,
+			description:   "Should insert one gap between two intervals (newest first order)",
+		},
+		{
+			name: "three intervals with two gaps (reverse chronological)",
+			intervals: timewarrior.Intervals{
+				{
+					ID:    1,
+					Start: time.Now().Add(-1 * time.Hour).UTC().Format("20060102T150405Z"),
+					End:   time.Now().UTC().Format("20060102T150405Z"),
+					Tags:  []string{"test3"},
+				},
+				{
+					ID:    2,
+					Start: time.Now().Add(-3 * time.Hour).UTC().Format("20060102T150405Z"),
+					End:   time.Now().Add(-2 * time.Hour).UTC().Format("20060102T150405Z"),
+					Tags:  []string{"test2"},
+				},
+				{
+					ID:    3,
+					Start: time.Now().Add(-5 * time.Hour).UTC().Format("20060102T150405Z"),
+					End:   time.Now().Add(-4 * time.Hour).UTC().Format("20060102T150405Z"),
+					Tags:  []string{"test1"},
+				},
+			},
+			expectedCount: 5,
+			expectedGaps:  2,
+			description:   "Should insert two gaps between three intervals (newest first order)",
+		},
+		{
+			name: "consecutive intervals with no gap (reverse chronological)",
+			intervals: timewarrior.Intervals{
+				{
+					ID:    1,
+					Start: time.Now().Add(-1 * time.Hour).UTC().Format("20060102T150405Z"),
+					End:   time.Now().UTC().Format("20060102T150405Z"),
+					Tags:  []string{"test2"},
+				},
+				{
+					ID:    2,
+					Start: time.Now().Add(-2 * time.Hour).UTC().Format("20060102T150405Z"),
+					End:   time.Now().Add(-1 * time.Hour).UTC().Format("20060102T150405Z"),
+					Tags:  []string{"test1"},
+				},
+			},
+			expectedCount: 2,
+			expectedGaps:  0,
+			description:   "Should not insert gap when intervals are consecutive (newest first order)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := insertGaps(tt.intervals)
+
+			if len(result) != tt.expectedCount {
+				t.Errorf("insertGaps() returned %d intervals, expected %d. %s",
+					len(result), tt.expectedCount, tt.description)
+			}
+
+			gapCount := 0
+			for _, interval := range result {
+				if interval.IsGap {
+					gapCount++
+				}
+			}
+
+			if gapCount != tt.expectedGaps {
+				t.Errorf("insertGaps() created %d gaps, expected %d. %s",
+					gapCount, tt.expectedGaps, tt.description)
+			}
+
+			// Verify gaps are properly interleaved with intervals
+			for i := 0; i < len(result)-1; i++ {
+				if result[i].IsGap && result[i+1].IsGap {
+					t.Errorf("insertGaps() created consecutive gap rows at indices %d and %d", i, i+1)
+				}
+			}
+
+			// Verify first and last items are never gaps
+			if len(result) > 0 {
+				if result[0].IsGap {
+					t.Errorf("insertGaps() created gap as first item")
+				}
+				if result[len(result)-1].IsGap {
+					t.Errorf("insertGaps() created gap as last item")
+				}
+			}
+		})
+	}
+}

pages/timespanPicker.go

@@ -0,0 +1,128 @@
+package pages
+
+import (
+	"log/slog"
+	"tasksquire/common"
+	"tasksquire/components/picker"
+
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/list"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+type TimespanPickerPage struct {
+	common           *common.Common
+	picker           *picker.Picker
+	selectedTimespan string
+}
+
+func NewTimespanPickerPage(common *common.Common, currentTimespan string) *TimespanPickerPage {
+	p := &TimespanPickerPage{
+		common:           common,
+		selectedTimespan: currentTimespan,
+	}
+
+	timespanOptions := []list.Item{
+		picker.NewItem(":day"),
+		picker.NewItem(":yesterday"),
+		picker.NewItem(":week"),
+		picker.NewItem(":lastweek"),
+		picker.NewItem(":month"),
+		picker.NewItem(":lastmonth"),
+		picker.NewItem(":year"),
+	}
+
+	itemProvider := func() []list.Item {
+		return timespanOptions
+	}
+
+	onSelect := func(item list.Item) tea.Cmd {
+		return func() tea.Msg { return timespanSelectedMsg{item: item} }
+	}
+
+	p.picker = picker.New(common, "Select Timespan", itemProvider, onSelect)
+
+	// Select the current timespan in the picker
+	p.picker.SelectItemByFilterValue(currentTimespan)
+
+	p.SetSize(common.Width(), common.Height())
+
+	return p
+}
+
+func (p *TimespanPickerPage) SetSize(width, height int) {
+	p.common.SetSize(width, height)
+
+	// Set list size with some padding/limits to look like a picker
+	listWidth := width - 4
+	if listWidth > 40 {
+		listWidth = 40
+	}
+	listHeight := height - 6
+	if listHeight > 20 {
+		listHeight = 20
+	}
+	p.picker.SetSize(listWidth, listHeight)
+}
+
+func (p *TimespanPickerPage) Init() tea.Cmd {
+	return p.picker.Init()
+}
+
+type timespanSelectedMsg struct {
+	item list.Item
+}
+
+func (p *TimespanPickerPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		p.SetSize(msg.Width, msg.Height)
+	case timespanSelectedMsg:
+		timespan := msg.item.FilterValue()
+
+		model, err := p.common.PopPage()
+		if err != nil {
+			slog.Error("page stack empty")
+			return nil, tea.Quit
+		}
+		return model, func() tea.Msg { return UpdateTimespanMsg(timespan) }
+	case tea.KeyMsg:
+		if !p.picker.IsFiltering() {
+			switch {
+			case key.Matches(msg, p.common.Keymap.Back):
+				model, err := p.common.PopPage()
+				if err != nil {
+					slog.Error("page stack empty")
+					return nil, tea.Quit
+				}
+				return model, BackCmd
+			}
+		}
+	}
+
+	_, cmd = p.picker.Update(msg)
+	return p, cmd
+}
+
+func (p *TimespanPickerPage) View() string {
+	width := p.common.Width() - 4
+	if width > 40 {
+		width = 40
+	}
+
+	content := p.picker.View()
+	styledContent := lipgloss.NewStyle().Width(width).Render(content)
+
+	return lipgloss.Place(
+		p.common.Width(),
+		p.common.Height(),
+		lipgloss.Center,
+		lipgloss.Center,
+		p.common.Styles.Base.Render(styledContent),
+	)
+}
+
+type UpdateTimespanMsg string

taskwarrior/models.go

@@ -47,7 +47,7 @@ type Task struct {
 	Uuid        string `json:"uuid,omitempty"`
 	Description string `json:"description,omitempty"`
 	Project     string `json:"project"`
-	// Priority    string         `json:"priority"`
+	Priority    string `json:"priority,omitempty"`
 	Status      string `json:"status,omitempty"`
 	Tags        []string       `json:"tags"`
 	VirtualTags []string       `json:"-"`
@@ -120,19 +120,25 @@ func (t *Task) GetString(fieldWFormat string) string {
 			}
 		}
 
-		if len(t.Annotations) == 0 {
-			return t.Description
+		if t.Udas["details"] != nil && t.Udas["details"] != "" {
+			return fmt.Sprintf("%s [D]", t.Description)
 		} else {
-			// var annotations []string
-			// for _, a := range t.Annotations {
-			// 	annotations = append(annotations, a.String())
-			// }
-			// return fmt.Sprintf("%s\n%s", t.Description, strings.Join(annotations, "\n"))
-
-			// TODO enable support for multiline in table
-			return fmt.Sprintf("%s [%d]", t.Description, len(t.Annotations))
+			return t.Description
 		}
 
+		// if len(t.Annotations) == 0 {
+		// 	return t.Description
+		// } else {
+		// 	// var annotations []string
+		// 	// for _, a := range t.Annotations {
+		// 	// 	annotations = append(annotations, a.String())
+		// 	// }
+		// 	// return fmt.Sprintf("%s\n%s", t.Description, strings.Join(annotations, "\n"))
+
+		// 	// TODO enable support for multiline in table
+		// 	return fmt.Sprintf("%s [%d]", t.Description, len(t.Annotations))
+		// }
+
 	case "project":
 		switch format {
 		case "parent":
@@ -143,8 +149,8 @@ func (t *Task) GetString(fieldWFormat string) string {
 		}
 		return t.Project
 
-	// case "priority":
-	// 	return t.Priority
+	case "priority":
+		return t.Priority
 
 	case "status":
 		return t.Status
@@ -227,7 +233,33 @@ func (t *Task) GetString(fieldWFormat string) string {
 	return ""
 }
 
-func (t *Task) GetDate(dateString string) time.Time {
+func (t *Task) GetDate(field string) time.Time {
+	var dateString string
+	switch field {
+	case "due":
+		dateString = t.Due
+	case "wait":
+		dateString = t.Wait
+	case "scheduled":
+		dateString = t.Scheduled
+	case "until":
+		dateString = t.Until
+	case "start":
+		dateString = t.Start
+	case "end":
+		dateString = t.End
+	case "entry":
+		dateString = t.Entry
+	case "modified":
+		dateString = t.Modified
+	default:
+		return time.Time{}
+	}
+
+	if dateString == "" {
+		return time.Time{}
+	}
+
 	dt, err := time.Parse(dtformat, dateString)
 	if err != nil {
 		slog.Error("Failed to parse time:", err)

taskwarrior/models_test.go

@@ -0,0 +1,81 @@
+package taskwarrior
+
+import (
+	"testing"
+	"time"
+)
+
+func TestTask_GetString(t *testing.T) {
+	tests := []struct {
+		name         string
+		task         Task
+		fieldWFormat string
+		want         string
+	}{
+		{
+			name: "Priority",
+			task: Task{
+				Priority: "H",
+			},
+			fieldWFormat: "priority",
+			want:         "H",
+		},
+		{
+			name: "Description",
+			task: Task{
+				Description: "Buy milk",
+			},
+			fieldWFormat: "description.desc",
+			want:         "Buy milk",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.task.GetString(tt.fieldWFormat); got != tt.want {
+				t.Errorf("Task.GetString() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestTask_GetDate(t *testing.T) {
+	validDate := "20230101T120000Z"
+	parsedValid, _ := time.Parse("20060102T150405Z", validDate)
+
+	tests := []struct {
+		name  string
+		task  Task
+		field string
+		want  time.Time
+	}{
+		{
+			name: "Due date valid",
+			task: Task{
+				Due: validDate,
+			},
+			field: "due",
+			want:  parsedValid,
+		},
+		{
+			name: "Due date empty",
+			task: Task{},
+			field: "due",
+			want:  time.Time{},
+		},
+		{
+			name: "Unknown field",
+			task: Task{Due: validDate},
+			field: "unknown",
+			want:  time.Time{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.task.GetDate(tt.field); !got.Equal(tt.want) {
+				t.Errorf("Task.GetDate() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

taskwarrior/taskwarrior.go

@@ -98,6 +98,7 @@ type TaskWarrior interface {
 	DeleteTask(task *Task)
 	StartTask(task *Task)
 	StopTask(task *Task)
+	StopActiveTasks()
 	GetInformation(task *Task) string
 	AddTaskAnnotation(uuid string, annotation string)
 
@@ -146,7 +147,7 @@ func (ts *TaskSquire) GetTasks(report *Report, filter ...string) Tasks {
 
 	args := ts.defaultArgs
 
-	if report.Context {
+	if report != nil && report.Context {
 		for _, context := range ts.contexts {
 			if context.Active && context.Name != "none" {
 				args = append(args, context.ReadFilter)
@@ -159,7 +160,12 @@ func (ts *TaskSquire) GetTasks(report *Report, filter ...string) Tasks {
 		args = append(args, filter...)
 	}
 
-	cmd := exec.Command(twBinary, append(args, []string{"export", report.Name}...)...)
+	exportArgs := []string{"export"}
+	if report != nil && report.Name != "" {
+		exportArgs = append(exportArgs, report.Name)
+	}
+
+	cmd := exec.Command(twBinary, append(args, exportArgs...)...)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		slog.Error("Failed getting report:", err)
@@ -490,6 +496,33 @@ func (ts *TaskSquire) StopTask(task *Task) {
 	}
 }
 
+func (ts *TaskSquire) StopActiveTasks() {
+	ts.mutex.Lock()
+	defer ts.mutex.Unlock()
+
+	cmd := exec.Command(twBinary, append(ts.defaultArgs, []string{"+ACTIVE", "export"}...)...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		slog.Error("Failed getting active tasks:", "error", err, "output", string(output))
+		return
+	}
+
+	tasks := make(Tasks, 0)
+	err = json.Unmarshal(output, &tasks)
+	if err != nil {
+		slog.Error("Failed unmarshalling active tasks:", err)
+		return
+	}
+
+	for _, task := range tasks {
+		cmd := exec.Command(twBinary, append(ts.defaultArgs, []string{"stop", task.Uuid}...)...)
+		err := cmd.Run()
+		if err != nil {
+			slog.Error("Failed stopping task:", err)
+		}
+	}
+}
+
 func (ts *TaskSquire) GetInformation(task *Task) string {
 	ts.mutex.Lock()
 	defer ts.mutex.Unlock()

timewarrior/models.go

@@ -20,6 +20,7 @@ type Interval struct {
 	Start string   `json:"start,omitempty"`
 	End   string   `json:"end,omitempty"`
 	Tags  []string `json:"tags,omitempty"`
+	IsGap bool     `json:"-"` // True if this represents an untracked time gap
 }
 
 func NewInterval() *Interval {
@@ -28,7 +29,31 @@ func NewInterval() *Interval {
 	}
 }
 
+// NewGapInterval creates a new gap interval representing untracked time.
+// start and end are the times between which the gap occurred.
+func NewGapInterval(start, end time.Time) *Interval {
+	return &Interval{
+		ID:    -1, // Gap intervals have no real ID
+		Start: start.UTC().Format(dtformat),
+		End:   end.UTC().Format(dtformat),
+		Tags:  make([]string, 0),
+		IsGap: true,
+	}
+}
+
 func (i *Interval) GetString(field string) string {
+	// Special handling for gap intervals
+	if i.IsGap {
+		switch field {
+		case "duration":
+			return i.GetDuration()
+		case "gap_display":
+			return fmt.Sprintf("--- Untracked: %s ---", i.GetDuration())
+		default:
+			return ""
+		}
+	}
+
 	switch field {
 	case "id":
 		return strconv.Itoa(i.ID)
@@ -36,17 +61,38 @@ func (i *Interval) GetString(field string) string {
 	case "start":
 		return formatDate(i.Start, "formatted")
 
+	case "start_time":
+		return formatDate(i.Start, "time")
+
 	case "end":
 		if i.End == "" {
 			return "now"
 		}
 		return formatDate(i.End, "formatted")
 
+	case "end_time":
+		if i.End == "" {
+			return "now"
+		}
+		return formatDate(i.End, "time")
+
+	case "weekday":
+		return formatDate(i.Start, "weekday")
+
 	case "tags":
 		if len(i.Tags) == 0 {
 			return ""
 		}
-		return strings.Join(i.Tags, " ")
+		// Extract and filter special tags (uuid:, project:)
+		_, _, displayTags := ExtractSpecialTags(i.Tags)
+		return strings.Join(displayTags, " ")
+
+	case "project":
+		project := ExtractProject(i.Tags)
+		if project == "" {
+			return "(none)"
+		}
+		return project
 
 	case "duration":
 		return i.GetDuration()
@@ -145,6 +191,8 @@ func formatDate(date string, format string) string {
 		return ""
 	}
 
+	dt = dt.Local()
+
 	switch format {
 	case "formatted", "":
 		return dt.Format("2006-01-02 15:04")
@@ -152,6 +200,8 @@ func formatDate(date string, format string) string {
 		return dt.Format("15:04")
 	case "date":
 		return dt.Format("2006-01-02")
+	case "weekday":
+		return dt.Format("Mon")
 	case "iso":
 		return dt.Format("2006-01-02T150405Z")
 	case "epoch":
@@ -171,10 +221,7 @@ func formatDuration(d time.Duration) string {
 	minutes := int(d.Minutes()) % 60
 	seconds := int(d.Seconds()) % 60
 
-	if hours > 0 {
-		return fmt.Sprintf("%d:%02d:%02d", hours, minutes, seconds)
-	}
-	return fmt.Sprintf("%d:%02d", minutes, seconds)
+	return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
 }
 
 func parseDurationVague(d time.Duration) string {

timewarrior/tags.go

@@ -0,0 +1,51 @@
+package timewarrior
+
+import (
+	"strings"
+)
+
+// Special tag prefixes for metadata
+const (
+	UUIDPrefix    = "uuid:"
+	ProjectPrefix = "project:"
+)
+
+// ExtractSpecialTags parses tags and separates special prefixed tags from display tags.
+// Returns: uuid, project, and remaining display tags (description + user tags)
+func ExtractSpecialTags(tags []string) (uuid string, project string, displayTags []string) {
+	displayTags = make([]string, 0, len(tags))
+
+	for _, tag := range tags {
+		switch {
+		case strings.HasPrefix(tag, UUIDPrefix):
+			uuid = strings.TrimPrefix(tag, UUIDPrefix)
+		case strings.HasPrefix(tag, ProjectPrefix):
+			project = strings.TrimPrefix(tag, ProjectPrefix)
+		default:
+			// Regular tag (description or user tag)
+			displayTags = append(displayTags, tag)
+		}
+	}
+
+	return uuid, project, displayTags
+}
+
+// ExtractUUID extracts just the UUID from tags (for sync operations)
+func ExtractUUID(tags []string) string {
+	for _, tag := range tags {
+		if strings.HasPrefix(tag, UUIDPrefix) {
+			return strings.TrimPrefix(tag, UUIDPrefix)
+		}
+	}
+	return ""
+}
+
+// ExtractProject extracts just the project name from tags
+func ExtractProject(tags []string) string {
+	for _, tag := range tags {
+		if strings.HasPrefix(tag, ProjectPrefix) {
+			return strings.TrimPrefix(tag, ProjectPrefix)
+		}
+	}
+	return ""
+}

timewarrior/timewarrior.go

@@ -22,6 +22,7 @@ type TimeWarrior interface {
 	GetConfig() *TWConfig
 
 	GetTags() []string
+	GetTagCombinations() []string
 
 	GetIntervals(filter ...string) Intervals
 	StartTracking(tags []string) error
@@ -30,7 +31,9 @@ type TimeWarrior interface {
 	ContinueInterval(id int) error
 	CancelTracking() error
 	DeleteInterval(id int) error
-	ModifyInterval(interval *Interval) error
+	FillInterval(id int) error
+	JoinInterval(id int) error
+	ModifyInterval(interval *Interval, adjust bool) error
 	GetSummary(filter ...string) string
 	GetActive() *Interval
 
@@ -99,10 +102,49 @@ func (ts *TimeSquire) GetTags() []string {
 	return tags
 }
 
-func (ts *TimeSquire) GetIntervals(filter ...string) Intervals {
-	ts.mutex.Lock()
-	defer ts.mutex.Unlock()
+// GetTagCombinations returns unique tag combinations from intervals,
+// ordered newest first (most recent intervals' tags appear first).
+// Returns formatted strings like "dev client-work meeting".
+func (ts *TimeSquire) GetTagCombinations() []string {
+	intervals := ts.GetIntervals() // Already sorted newest first
 
+	// Track unique combinations while preserving order
+	seen := make(map[string]bool)
+	var combinations []string
+
+	for _, interval := range intervals {
+		if len(interval.Tags) == 0 {
+			continue // Skip intervals with no tags
+		}
+
+		// Format tags (handles spaces with quotes)
+		combo := formatTagsForCombination(interval.Tags)
+
+		if !seen[combo] {
+			seen[combo] = true
+			combinations = append(combinations, combo)
+		}
+	}
+
+	return combinations
+}
+
+// formatTagsForCombination formats tags consistently for display
+func formatTagsForCombination(tags []string) string {
+	var formatted []string
+	for _, t := range tags {
+		if strings.Contains(t, " ") {
+			formatted = append(formatted, "\""+t+"\"")
+		} else {
+			formatted = append(formatted, t)
+		}
+	}
+	return strings.Join(formatted, " ")
+}
+
+// getIntervalsUnlocked fetches intervals without acquiring mutex (for internal use only).
+// Caller must hold ts.mutex.
+func (ts *TimeSquire) getIntervalsUnlocked(filter ...string) Intervals {
 	args := append(ts.defaultArgs, "export")
 	if filter != nil {
 		args = append(args, filter...)
@@ -133,6 +175,14 @@ func (ts *TimeSquire) GetIntervals(filter ...string) Intervals {
 	return intervals
 }
 
+// GetIntervals fetches intervals with the given filter, acquiring mutex lock.
+func (ts *TimeSquire) GetIntervals(filter ...string) Intervals {
+	ts.mutex.Lock()
+	defer ts.mutex.Unlock()
+
+	return ts.getIntervalsUnlocked(filter...)
+}
+
 func (ts *TimeSquire) StartTracking(tags []string) error {
 	ts.mutex.Lock()
 	defer ts.mutex.Unlock()
@@ -218,7 +268,35 @@ func (ts *TimeSquire) DeleteInterval(id int) error {
 	return nil
 }
 
-func (ts *TimeSquire) ModifyInterval(interval *Interval) error {
+func (ts *TimeSquire) FillInterval(id int) error {
+	ts.mutex.Lock()
+	defer ts.mutex.Unlock()
+
+	cmd := exec.Command(twBinary, append(ts.defaultArgs, []string{"fill", fmt.Sprintf("@%d", id)}...)...)
+	if err := cmd.Run(); err != nil {
+		slog.Error("Failed filling interval:", err)
+		return err
+	}
+
+	return nil
+}
+
+func (ts *TimeSquire) JoinInterval(id int) error {
+	ts.mutex.Lock()
+	defer ts.mutex.Unlock()
+
+	// Join the current interval with the previous one
+	// The previous interval has id+1 (since intervals are ordered newest first)
+	cmd := exec.Command(twBinary, append(ts.defaultArgs, []string{"join", fmt.Sprintf("@%d", id+1), fmt.Sprintf("@%d", id)}...)...)
+	if err := cmd.Run(); err != nil {
+		slog.Error("Failed joining interval:", err)
+		return err
+	}
+
+	return nil
+}
+
+func (ts *TimeSquire) ModifyInterval(interval *Interval, adjust bool) error {
 	ts.mutex.Lock()
 	defer ts.mutex.Unlock()
 
@@ -229,8 +307,14 @@ func (ts *TimeSquire) ModifyInterval(interval *Interval) error {
 		return err
 	}
 
+	// Build import command with optional :adjust hint
+	args := append(ts.defaultArgs, "import")
+	if adjust {
+		args = append(args, ":adjust")
+	}
+
 	// Import the modified interval
-	cmd := exec.Command(twBinary, append(ts.defaultArgs, []string{"import"}...)...)
+	cmd := exec.Command(twBinary, args...)
 	cmd.Stdin = bytes.NewBuffer(intervals)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
@@ -270,8 +354,8 @@ func (ts *TimeSquire) GetActive() *Interval {
 		return nil
 	}
 
-	// Get the active interval
-	intervals := ts.GetIntervals()
+	// Get the active interval using unlocked version (we already hold the mutex)
+	intervals := ts.getIntervalsUnlocked()
 	for _, interval := range intervals {
 		if interval.End == "" {
 			return interval