Refactoring complete: v0.4.0 architectural milestone (#1)

## Summary

Completed Phase 5 refactoring and reached the target architecture.

**Architectural milestone achieved:**
- Service layer owns all state and is the sole writer
- UI is a thin Fyne view, all widget updates marshaled via `fyne.Do`
- Core engines are stateless and injectable
- Domain types are pure (no `yaml:"-"` fields)
- Full module builds and `go vet ./...` clean

## Changes

- Bump version: 0.3.6 → 0.4.0
- Update CHANGELOG with Phase 5 summary
- Add ROADMAP "Refactoring Follow-Ups" section

## Known follow-up work

1. **Linux test build broken** — `runner_test.go` needs `//go:build windows` tag
2. **File-size limits exceeded** — `operations.go` (486 lines), `jobs_view.go` (415 lines)

See ROADMAP.md for details.

---------

Co-authored-by: mixeme <mix.public@ya.ru>
Reviewed-on: #1

src/ui/history_view.go

@@ -0,0 +1,151 @@
+package ui
+
+import (
+	"sort"
+	"strings"
+	"time"
+
+	"gitea.mixdep.ru/mix/gosentry/src/domain"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+)
+
+func newEvent(jobID int, jobName string, state string, detail string) event {
+	// Use the same timestamp shape as command run records so the History tab is
+	// visually consistent across startup, UI actions, manual runs, and schedules.
+	return event{
+		Time:    time.Now().Format("2006-01-02 15:04:05"),
+		JobID:   jobID,
+		JobName: jobName,
+		Trigger: "UI",
+		State:   state,
+		Detail:  detail,
+	}
+}
+
+func collectActivity(jobs []job, runtimes map[int]*domain.JobRuntime) []event {
+	var events []event
+	for _, current := range jobs {
+		// At startup this is usually empty because jobs.yaml does not persist
+		// runtime logs. The function still centralizes the merge for future
+		// history loading from log metadata.
+		if rt := runtimes[current.ID]; rt != nil {
+			events = append(events, rt.Logs...)
+		}
+	}
+	sort.SliceStable(events, func(left int, right int) bool {
+		return events[left].Time < events[right].Time
+	})
+	return events
+}
+
+func newHistoryView(events *[]event) *fyne.Container {
+	descending := false
+	headerText := func(id widget.TableCellID) string {
+		headers := []string{"Time", "Trigger", "Job", "State", "Detail", "Log"}
+		if id.Row < 0 && id.Col == 0 {
+			if descending {
+				return "Time desc"
+			}
+			return "Time asc"
+		}
+		if id.Row < 0 && id.Col >= 0 && id.Col < len(headers) {
+			return headers[id.Col]
+		}
+		return ""
+	}
+	sortedEvents := func() []event {
+		result := append([]event(nil), (*events)...)
+		sort.SliceStable(result, func(left int, right int) bool {
+			if descending {
+				return result[left].Time > result[right].Time
+			}
+			return result[left].Time < result[right].Time
+		})
+		return result
+	}
+
+	table := widget.NewTable(
+		func() (int, int) {
+			return len(*events), 6
+		},
+		func() fyne.CanvasObject {
+			label := widget.NewLabel("")
+			label.Wrapping = fyne.TextTruncate
+			return label
+		},
+		func(id widget.TableCellID, item fyne.CanvasObject) {
+			label := item.(*widget.Label)
+			label.SetText(historyCellText(id, sortedEvents()))
+			label.TextStyle = fyne.TextStyle{}
+			label.Refresh()
+		},
+	)
+	table.ShowHeaderRow = true
+	table.CreateHeader = func() fyne.CanvasObject {
+		label := widget.NewLabel("")
+		label.Wrapping = fyne.TextTruncate
+		return label
+	}
+	table.UpdateHeader = func(id widget.TableCellID, item fyne.CanvasObject) {
+		label := item.(*widget.Label)
+		label.SetText(headerText(id))
+		label.TextStyle = fyne.TextStyle{Bold: true}
+		label.Refresh()
+	}
+	table.OnSelected = func(id widget.TableCellID) {
+		if id.Row < 0 && id.Col == 0 {
+			descending = !descending
+			table.Refresh()
+		}
+		table.Unselect(id)
+	}
+	table.SetColumnWidth(0, 150)
+	table.SetColumnWidth(1, 90)
+	table.SetColumnWidth(2, 170)
+	table.SetColumnWidth(3, 90)
+	table.SetColumnWidth(4, 260)
+	table.SetColumnWidth(5, 240)
+	return container.NewPadded(table)
+}
+
+func historyCellText(id widget.TableCellID, events []event) string {
+	if id.Row < 0 || id.Row >= len(events) {
+		return ""
+	}
+	current := events[id.Row]
+	trigger := current.Trigger
+	if trigger == "" {
+		trigger = "Unknown"
+	}
+	switch id.Col {
+	case 0:
+		return current.Time
+	case 1:
+		return trigger
+	case 2:
+		return current.JobName
+	case 3:
+		return current.State
+	case 4:
+		return current.Detail
+	case 5:
+		return logFileName(current.LogFile)
+	default:
+		return ""
+	}
+}
+
+func logFileName(path string) string {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return ""
+	}
+	path = strings.ReplaceAll(path, "\\", "/")
+	if slash := strings.LastIndex(path, "/"); slash >= 0 {
+		return path[slash+1:]
+	}
+	return path
+}

src/ui/job_dialog.go

@@ -0,0 +1,90 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+
+	"gitea.mixdep.ru/mix/gosentry/src/app"
+	"gitea.mixdep.ru/mix/gosentry/src/domain"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/dialog"
+	"fyne.io/fyne/v2/widget"
+)
+
+// showJobDialog opens a create/edit form for a single job. onSave is called
+// with the populated job only when the user clicks Save and all fields pass
+// validation.
+func showJobDialog(w fyne.Window, title string, current job, onSave func(job)) {
+	name := widget.NewEntry()
+	name.SetPlaceHolder("Nightly backup")
+	name.SetText(current.Name)
+	folderEntry := widget.NewEntry()
+	folderEntry.SetPlaceHolder("Maintenance")
+	folderEntry.SetText(current.Folder)
+	scheduleEntry := widget.NewEntry()
+	scheduleEntry.SetPlaceHolder("@every 1m")
+	scheduleEntry.SetText(current.Schedule)
+	commandEntry := widget.NewEntry()
+	commandEntry.SetPlaceHolder(`C:\Program Files\App\App.exe`)
+	commandEntry.SetText(current.Command)
+	argumentsEntry := widget.NewMultiLineEntry()
+	argumentsEntry.SetPlaceHolder(`D:\Local\Jobs\Auto.ffs_batch`)
+	argumentsEntry.SetText(current.Arguments)
+	successExitCodesEntry := widget.NewEntry()
+	successExitCodesEntry.SetPlaceHolder("0")
+	successExitCodesEntry.SetText(app.DisplaySuccessExitCodes(current.SuccessExitCodes))
+	startOnly := widget.NewCheck("Start only, do not wait for exit", nil)
+	startOnly.SetChecked(current.StartOnly)
+	enabled := widget.NewCheck("Enabled", nil)
+	enabled.SetChecked(current.Enabled)
+
+	form := dialog.NewForm(
+		title,
+		"Save",
+		"Cancel",
+		[]*widget.FormItem{
+			widget.NewFormItem("Name", name),
+			widget.NewFormItem("Folder", folderEntry),
+			widget.NewFormItem("Schedule", scheduleEntry),
+			widget.NewFormItem("Command", commandEntry),
+			widget.NewFormItem("Arguments", argumentsEntry),
+			widget.NewFormItem("Success exit codes", successExitCodesEntry),
+			widget.NewFormItem("", startOnly),
+			widget.NewFormItem("", enabled),
+		},
+		func(saved bool) {
+			if !saved {
+				return
+			}
+			if strings.TrimSpace(name.Text) == "" || strings.TrimSpace(scheduleEntry.Text) == "" || strings.TrimSpace(commandEntry.Text) == "" {
+				// These three fields are the minimum executable job definition.
+				// Folder is optional because ungrouped jobs are a supported workflow.
+				dialog.ShowError(fmt.Errorf("name, schedule, and command are required"), w)
+				return
+			}
+			if err := domain.Validate(strings.TrimSpace(scheduleEntry.Text)); err != nil {
+				dialog.ShowError(fmt.Errorf("invalid schedule: %w", err), w)
+				return
+			}
+			current.Name = strings.TrimSpace(name.Text)
+			current.Folder = strings.TrimSpace(folderEntry.Text)
+			current.Schedule = strings.TrimSpace(scheduleEntry.Text)
+			current.Command = strings.TrimSpace(commandEntry.Text)
+			current.Arguments = strings.TrimSpace(argumentsEntry.Text)
+			current.SuccessExitCodes = strings.TrimSpace(successExitCodesEntry.Text)
+			if current.SuccessExitCodes == "" {
+				current.SuccessExitCodes = "0"
+			}
+			current.StartOnly = startOnly.Checked
+			current.Enabled = enabled.Checked
+			// The dialog only edits durable configuration. Runtime status is
+			// initialized (new jobs) or updated (edits) by the caller against the
+			// runtime map, keyed by job ID.
+			onSave(current)
+		},
+		w,
+	)
+	form.Resize(fyne.NewSize(640, 460))
+	form.Show()
+}

src/ui/jobs_view.go

@@ -0,0 +1,415 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+
+	"gitea.mixdep.ru/mix/gosentry/src/app"
+	"gitea.mixdep.ru/mix/gosentry/src/domain"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/dialog"
+	"fyne.io/fyne/v2/layout"
+	"fyne.io/fyne/v2/theme"
+	"fyne.io/fyne/v2/widget"
+)
+
+const allFolders = "All"
+const noFolder = "No folder"
+const minJobsSidebarWidth float32 = 480
+
+// newJobsView builds the Jobs tab: list sidebar, details panel, and toolbar.
+// It returns the assembled panel and a refresh function the caller invokes
+// whenever the service state may have changed (e.g., from the event subscriber
+// in mainwindow.go). The refresh function re-reads the service snapshot and
+// redraws all widgets in the jobs view; it does NOT touch history or settings.
+func newJobsView(w fyne.Window, svc *app.Service) (fyne.CanvasObject, func()) {
+	jobs := svc.Jobs()
+	runtimes := make(map[int]*domain.JobRuntime, len(jobs))
+	syncFromService := func() {
+		jobs = svc.Jobs()
+		for id := range runtimes {
+			delete(runtimes, id)
+		}
+		for _, current := range jobs {
+			if rt := svc.Runtime(current.ID); rt != nil {
+				runtimes[current.ID] = rt
+			}
+		}
+	}
+	syncFromService()
+	runtimeFor := func(index int) *domain.JobRuntime {
+		if index < 0 || index >= len(jobs) {
+			return &domain.JobRuntime{}
+		}
+		if rt := runtimes[jobs[index].ID]; rt != nil {
+			return rt
+		}
+		return &domain.JobRuntime{}
+	}
+
+	selected := 0
+	selectedFolder := allFolders
+	schedulerPaused := false
+	filteredJobs := filteredJobIndexes(jobs, selectedFolder)
+
+	title := widget.NewLabelWithStyle(jobs[selected].Name, fyne.TextAlignLeading, fyne.TextStyle{Bold: true})
+	title.Wrapping = fyne.TextWrapBreak
+	folderLabel := newJobDetailLabel(jobs[selected].Folder)
+	scheduleLabel := newJobDetailLabel(jobs[selected].Schedule)
+	commandLabel := newJobDetailLabel(jobs[selected].Command)
+	argumentsLabel := newJobDetailLabel(jobs[selected].Arguments)
+	successExitCodesLabel := newJobDetailLabel(app.DisplaySuccessExitCodes(jobs[selected].SuccessExitCodes))
+	runModeLabel := newJobDetailLabel(app.DisplayRunMode(jobs[selected]))
+	selectedRuntime := runtimeFor(selected)
+	lastRunLabel := newJobDetailLabel(selectedRuntime.LastRun)
+	nextRunLabel := newJobDetailLabel(selectedRuntime.NextRun)
+	stateLabel := newJobDetailLabel(selectedRuntime.LastState)
+	schedulerState := widget.NewLabel("Scheduler running")
+	commandOutput := widget.NewTextGrid()
+	commandOutput.SetText(selectedRuntime.Output)
+	commandOutputScroll := container.NewScroll(commandOutput)
+	// Command output can contain long lines and preserved whitespace. TextGrid is
+	// used instead of Label so stdout/stderr remains readable and does not vanish
+	// against the theme when it is placed inside a scroll container.
+	commandOutputScroll.SetMinSize(fyne.NewSize(520, 160))
+
+	selectedLogs := append([]event(nil), selectedRuntime.Logs...)
+	jobLogs := widget.NewList(
+		func() int { return len(selectedLogs) },
+		func() fyne.CanvasObject { return widget.NewLabel("log") },
+		func(id widget.ListItemID, item fyne.CanvasObject) {
+			item.(*widget.Label).SetText(app.EventText(selectedLogs[id]))
+		},
+	)
+
+	updateDetails := func(index int) {
+		if index < 0 || index >= len(jobs) {
+			// A folder filter can temporarily leave no selectable rows. Clearing
+			// the details panel avoids showing stale information for a hidden job.
+			title.SetText("No job selected")
+			folderLabel.SetText("")
+			scheduleLabel.SetText("")
+			commandLabel.SetText("")
+			argumentsLabel.SetText("")
+			successExitCodesLabel.SetText("")
+			runModeLabel.SetText("")
+			lastRunLabel.SetText("")
+			nextRunLabel.SetText("")
+			stateLabel.SetText("")
+			commandOutput.SetText("")
+			selectedLogs = nil
+			return
+		}
+		selected = index
+		current := jobs[selected]
+		rt := runtimeFor(selected)
+		title.SetText(current.Name)
+		folderLabel.SetText(app.DisplayFolder(current.Folder))
+		scheduleLabel.SetText(current.Schedule)
+		commandLabel.SetText(current.Command)
+		argumentsLabel.SetText(app.DisplayArguments(current.Arguments))
+		successExitCodesLabel.SetText(app.DisplaySuccessExitCodes(current.SuccessExitCodes))
+		runModeLabel.SetText(app.DisplayRunMode(current))
+		lastRunLabel.SetText(rt.LastRun)
+		nextRunLabel.SetText(rt.NextRun)
+		stateLabel.SetText(rt.LastState)
+		commandOutput.SetText(rt.Output)
+		selectedLogs = append(selectedLogs[:0], rt.Logs...)
+	}
+
+	// list and folderSelect are declared early so closures below can reference
+	// them before the widget.NewList / widget.NewSelect calls assign the values.
+	var list *widget.List
+	var folderSelect *widget.Select
+
+	refreshView := func() {
+		syncFromService()
+		filteredJobs = filteredJobIndexes(jobs, selectedFolder)
+		updateDetails(selected)
+		jobLogs.Refresh()
+		if list != nil {
+			list.Refresh()
+		}
+	}
+
+	list = widget.NewList(
+		func() int { return len(filteredJobs) },
+		func() fyne.CanvasObject {
+			name := widget.NewLabelWithStyle("Job name", fyne.TextAlignLeading, fyne.TextStyle{Bold: true})
+			meta := widget.NewLabel("schedule")
+			status := widget.NewLabel("status")
+			return container.NewVBox(name, meta, status)
+		},
+		func(id widget.ListItemID, item fyne.CanvasObject) {
+			row := item.(*fyne.Container)
+			name := row.Objects[0].(*widget.Label)
+			meta := row.Objects[1].(*widget.Label)
+			status := row.Objects[2].(*widget.Label)
+
+			current := jobs[filteredJobs[id]]
+			name.SetText(current.Name)
+			// Keep each row compact: folder, schedule, and command are shown in one
+			// metadata line so the left pane stays useful even with many jobs.
+			meta.SetText(app.DisplayFolder(current.Folder) + "    " + current.Schedule + "    " + app.DisplayInvocation(current))
+			status.SetText(app.StatusText(current, runtimes[current.ID]))
+		},
+	)
+	list.OnSelected = func(id widget.ListItemID) {
+		if id < 0 || id >= len(filteredJobs) {
+			updateDetails(-1)
+			return
+		}
+		updateDetails(filteredJobs[id])
+	}
+	list.Select(selected)
+
+	folderSelect = widget.NewSelect(folderOptions(jobs), func(value string) {
+		if value == "" {
+			return
+		}
+		selectedFolder = value
+		filteredJobs = filteredJobIndexes(jobs, selectedFolder)
+		list.Refresh()
+		if len(filteredJobs) == 0 {
+			// The "No folder" filter is intentionally allowed to be empty. It is a
+			// real filter choice, not an error state, so the selection is cleared.
+			selected = -1
+			updateDetails(-1)
+			return
+		}
+		selected = filteredJobs[0]
+		list.Select(0)
+		refreshView()
+	})
+	folderSelect.SetSelected(selectedFolder)
+
+	addButton := widget.NewButtonWithIcon("New job", theme.ContentAddIcon(), func() {
+		showJobDialog(w, "New job", job{Schedule: "@every 1m", Command: "echo GoSentry job ran", Enabled: true}, func(saved job) {
+			// The Service assigns the ID, stores the job, records the "Created"
+			// activity, and emits events. The observer appends those to History; we
+			// only refresh the snapshot and move the selection to the new job.
+			created, err := svc.CreateJob(saved)
+			if err != nil {
+				dialog.ShowError(err, w)
+				return
+			}
+			syncFromService()
+			folderSelect.Options = folderOptions(jobs)
+			folderSelect.Refresh()
+			targetFolder := filterValue(created.Folder)
+			if selectedFolder != allFolders && selectedFolder != targetFolder {
+				selectedFolder = targetFolder
+				folderSelect.SetSelected(targetFolder)
+			}
+			selected = indexOfID(jobs, created.ID)
+			filteredJobs = filteredJobIndexes(jobs, selectedFolder)
+			list.Refresh()
+			list.Select(app.DisplayIndex(filteredJobs, selected))
+			refreshView()
+		})
+	})
+	editButton := widget.NewButtonWithIcon("Edit", theme.DocumentCreateIcon(), func() {
+		if selected < 0 || selected >= len(jobs) {
+			return
+		}
+		showJobDialog(w, "Edit job", jobs[selected], func(saved job) {
+			// The job keeps its ID, so the Service preserves the runtime (keyed by
+			// ID), reflects any enabled/disabled change, recomputes the next run, and
+			// emits the "Updated" activity the observer records.
+			saved.ID = jobs[selected].ID
+			if err := svc.UpdateJob(saved); err != nil {
+				dialog.ShowError(err, w)
+				return
+			}
+			syncFromService()
+			folderSelect.Options = folderOptions(jobs)
+			folderSelect.Refresh()
+			list.Refresh()
+			refreshView()
+		})
+	})
+	runButton := widget.NewButtonWithIcon("Run now", theme.MediaPlayIcon(), func() {
+		if selected < 0 || selected >= len(jobs) {
+			return
+		}
+		if schedulerPaused {
+			// The global pause is treated as an emergency stop for all execution,
+			// including manual "Run now", so the user has one reliable switch.
+			dialog.ShowInformation("Scheduler paused", "Global pause is active. Resume the scheduler before running jobs.", w)
+			return
+		}
+		// RunNow refuses an already-running job (it returns an error); the UI has
+		// always ignored that case silently, so the run simply does not start.
+		if err := svc.RunNow(jobs[selected].ID); err != nil {
+			return
+		}
+		list.Refresh()
+		refreshView()
+	})
+	stopAllButton := widget.NewButtonWithIcon("Pause all", theme.MediaStopIcon(), nil)
+	stopAllButton.OnTapped = func() {
+		// SetGlobalPause flips the Service's pause flag, updates every job's
+		// next-run text, and emits the activity record the observer logs. Mirror the
+		// new state into the local flag and the controls; revert it if the save fails.
+		schedulerPaused = !schedulerPaused
+		if err := svc.SetGlobalPause(schedulerPaused); err != nil {
+			schedulerPaused = !schedulerPaused
+			dialog.ShowError(err, w)
+			return
+		}
+		if schedulerPaused {
+			schedulerState.SetText("Scheduler paused")
+			stopAllButton.SetText("Resume all")
+			stopAllButton.SetIcon(theme.MediaPlayIcon())
+		} else {
+			schedulerState.SetText("Scheduler running")
+			stopAllButton.SetText("Pause all")
+			stopAllButton.SetIcon(theme.MediaStopIcon())
+		}
+		list.Refresh()
+		refreshView()
+	}
+	pauseButton := widget.NewButtonWithIcon("Pause", theme.MediaPauseIcon(), func() {
+		if selected < 0 || selected >= len(jobs) {
+			return
+		}
+		// SetEnabled toggles the job, updates its runtime/next-run, and records the
+		// "Resumed"/"Paused" activity the observer logs.
+		current := jobs[selected]
+		if err := svc.SetEnabled(current.ID, !current.Enabled); err != nil {
+			dialog.ShowError(err, w)
+			return
+		}
+		syncFromService()
+		list.Refresh()
+		refreshView()
+	})
+	deleteButton := widget.NewButtonWithIcon("Delete", theme.DeleteIcon(), func() {
+		if selected < 0 || selected >= len(jobs) {
+			return
+		}
+		deleted := jobs[selected]
+		// Deletion is confirmed because jobs can represent real system actions.
+		// There is no undo yet, so accidental removal should require one more click.
+		dialog.ShowConfirm("Delete job", fmt.Sprintf("Delete %q?", deleted.Name), func(confirm bool) {
+			if !confirm {
+				return
+			}
+			// The Service removes the job and its runtime, persists, and records the
+			// "Deleted" activity the observer logs; the UI re-reads the snapshot and
+			// fixes up the folder filter and selection.
+			if err := svc.DeleteJob(deleted.ID); err != nil {
+				dialog.ShowError(err, w)
+				return
+			}
+			syncFromService()
+			folderSelect.Options = folderOptions(jobs)
+			folderSelect.Refresh()
+			filteredJobs = filteredJobIndexes(jobs, selectedFolder)
+			if len(filteredJobs) == 0 && selectedFolder != allFolders {
+				selectedFolder = allFolders
+				folderSelect.SetSelected(allFolders)
+				filteredJobs = filteredJobIndexes(jobs, selectedFolder)
+			}
+			if len(filteredJobs) == 0 {
+				selected = -1
+			} else {
+				selected = filteredJobs[0]
+			}
+			list.Refresh()
+			if selected >= 0 {
+				list.Select(app.DisplayIndex(filteredJobs, selected))
+			}
+			refreshView()
+		}, w)
+	})
+
+	toolbar := container.NewHBox(addButton, editButton, runButton, pauseButton, deleteButton, layout.NewSpacer())
+	globalControls := container.NewHBox(stopAllButton, schedulerState, layout.NewSpacer())
+	sidebarHeader := container.NewVBox(globalControls, widget.NewSeparator(), widget.NewLabelWithStyle("Folder", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}), folderSelect, toolbar)
+	sidebar := container.NewBorder(sidebarHeader, nil, nil, nil, list)
+
+	details := container.NewVBox(
+		title,
+		widget.NewSeparator(),
+		detailRow("Folder", folderLabel),
+		detailRow("Schedule", scheduleLabel),
+		detailRow("Command", commandLabel),
+		detailRow("Arguments", argumentsLabel),
+		detailRow("Success exit codes", successExitCodesLabel),
+		detailRow("Run mode", runModeLabel),
+		detailRow("Last run", lastRunLabel),
+		detailRow("Next run", nextRunLabel),
+		detailRow("State", stateLabel),
+		widget.NewSeparator(),
+		widget.NewLabelWithStyle("Command output", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}),
+		commandOutputScroll,
+		widget.NewSeparator(),
+		widget.NewLabelWithStyle("Selected job activity", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}),
+		jobLogs,
+	)
+
+	fixedSidebar := container.New(minWidthLayout{width: minJobsSidebarWidth}, sidebar)
+	panel := container.NewBorder(nil, nil, fixedSidebar, nil, container.NewPadded(details))
+	return panel, refreshView
+}
+
+
+func filteredJobIndexes(jobs []job, folder string) []int {
+	indexes := make([]int, 0, len(jobs))
+	for index, current := range jobs {
+		if folder == allFolders || filterValue(current.Folder) == folder {
+			indexes = append(indexes, index)
+		}
+	}
+	return indexes
+}
+
+func folderOptions(jobs []job) []string {
+	// "All" and "No folder" are always present so the filter UI is stable even
+	// before the user creates folders.
+	options := []string{allFolders, noFolder}
+	seen := map[string]bool{allFolders: true, noFolder: true}
+	for _, current := range jobs {
+		folder := strings.TrimSpace(current.Folder)
+		if folder == "" || seen[folder] {
+			continue
+		}
+		seen[folder] = true
+		options = append(options, folder)
+	}
+	return options
+}
+
+func filterValue(folder string) string {
+	if strings.TrimSpace(folder) == "" {
+		return noFolder
+	}
+	return strings.TrimSpace(folder)
+}
+
+func indexOfID(jobs []job, id int) int {
+	for index, current := range jobs {
+		if current.ID == id {
+			return index
+		}
+	}
+	return 0
+}
+
+func detailRow(label string, value fyne.CanvasObject) fyne.CanvasObject {
+	caption := widget.NewLabelWithStyle(label, fyne.TextAlignLeading, fyne.TextStyle{Bold: true})
+	caption.Wrapping = fyne.TextTruncate
+	return container.NewGridWithColumns(2, caption, value)
+}
+
+func newJobDetailLabel(text string) *widget.Label {
+	label := widget.NewLabel(text)
+	// Job names, commands, and paths can be much wider than the details panel.
+	// Breaking long runs of text keeps Label.MinSize stable when the selection
+	// changes, so the right panel does not force the whole window to resize.
+	label.Wrapping = fyne.TextWrapBreak
+	return label
+}

src/ui/jobs_view_test.go

@@ -0,0 +1,95 @@
+package ui
+
+import (
+	"testing"
+
+	"gitea.mixdep.ru/mix/gosentry/src/domain"
+)
+
+func TestFilterValue(t *testing.T) {
+	cases := []struct{ input, want string }{
+		{"", noFolder},
+		{"   ", noFolder},
+		{"Maintenance", "Maintenance"},
+		{"  Reports  ", "Reports"},
+	}
+	for _, tc := range cases {
+		if got := filterValue(tc.input); got != tc.want {
+			t.Errorf("filterValue(%q) = %q, want %q", tc.input, got, tc.want)
+		}
+	}
+}
+
+func TestFolderOptionsAlwaysIncludesSentinels(t *testing.T) {
+	opts := folderOptions(nil)
+	if len(opts) < 2 || opts[0] != allFolders || opts[1] != noFolder {
+		t.Errorf("folderOptions(nil) = %v, want [%q %q ...]", opts, allFolders, noFolder)
+	}
+}
+
+func TestFolderOptionsAppendsUniqueFolders(t *testing.T) {
+	jobs := []domain.Job{
+		{Folder: "Maintenance"},
+		{Folder: ""},           // no folder → not a named folder
+		{Folder: "  Backups "}, // trimmed to "Backups"
+		{Folder: "Maintenance"}, // duplicate → not added again
+	}
+	opts := folderOptions(jobs)
+	// Expected: All, No folder, Maintenance, Backups — 4 entries, no duplicates.
+	if len(opts) != 4 {
+		t.Errorf("expected 4 options, got %v", opts)
+	}
+	has := map[string]bool{}
+	for _, o := range opts {
+		has[o] = true
+	}
+	for _, want := range []string{allFolders, noFolder, "Maintenance", "Backups"} {
+		if !has[want] {
+			t.Errorf("expected option %q in %v", want, opts)
+		}
+	}
+}
+
+func TestFilteredJobIndexesAll(t *testing.T) {
+	jobs := []domain.Job{
+		{Folder: "Maintenance"},
+		{Folder: ""},
+		{Folder: "Reports"},
+	}
+	got := filteredJobIndexes(jobs, allFolders)
+	if len(got) != 3 {
+		t.Errorf("allFolders filter: got %d indexes, want 3", len(got))
+	}
+}
+
+func TestFilteredJobIndexesByNamedFolder(t *testing.T) {
+	jobs := []domain.Job{
+		{Folder: "Maintenance"}, // index 0
+		{Folder: ""},            // index 1
+		{Folder: "Maintenance"}, // index 2
+		{Folder: "Reports"},     // index 3
+	}
+	got := filteredJobIndexes(jobs, "Maintenance")
+	if len(got) != 2 || got[0] != 0 || got[1] != 2 {
+		t.Errorf("Maintenance filter: got %v, want [0 2]", got)
+	}
+}
+
+func TestFilteredJobIndexesNoFolder(t *testing.T) {
+	jobs := []domain.Job{
+		{Folder: "Maintenance"}, // index 0 — excluded
+		{Folder: ""},            // index 1 — no folder → included
+		{Folder: "  "},          // index 2 — blank → included
+	}
+	got := filteredJobIndexes(jobs, noFolder)
+	if len(got) != 2 || got[0] != 1 || got[1] != 2 {
+		t.Errorf("noFolder filter: got %v, want [1 2]", got)
+	}
+}
+
+func TestFilteredJobIndexesEmptySlice(t *testing.T) {
+	got := filteredJobIndexes(nil, allFolders)
+	if len(got) != 0 {
+		t.Errorf("empty job list should return empty indexes, got %v", got)
+	}
+}

src/ui/layout.go

@@ -0,0 +1,37 @@
+package ui
+
+import (
+	"fyne.io/fyne/v2"
+)
+
+type minWidthLayout struct {
+	width float32
+}
+
+func (l minWidthLayout) MinSize(objects []fyne.CanvasObject) fyne.Size {
+	width := l.width
+	var height float32
+	for _, object := range objects {
+		if !object.Visible() {
+			continue
+		}
+		min := object.MinSize()
+		if min.Width > width {
+			width = min.Width
+		}
+		if min.Height > height {
+			height = min.Height
+		}
+	}
+	return fyne.NewSize(width, height)
+}
+
+func (l minWidthLayout) Layout(objects []fyne.CanvasObject, size fyne.Size) {
+	for _, object := range objects {
+		if !object.Visible() {
+			continue
+		}
+		object.Move(fyne.NewPos(0, 0))
+		object.Resize(size)
+	}
+}

src/ui/mainwindow.go

@@ -0,0 +1,92 @@
+package ui
+
+import (
+	"time"
+
+	"gitea.mixdep.ru/mix/gosentry/assets"
+	"gitea.mixdep.ru/mix/gosentry/src/app"
+	"gitea.mixdep.ru/mix/gosentry/src/domain"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/theme"
+	"fyne.io/fyne/v2/widget"
+)
+
+// The UI package aliases domain types to keep widget callbacks short. The actual
+// durable model still lives in src/domain, so UI code does not define a second
+// copy of the scheduler data.
+type job = domain.Job
+type event = domain.RunRecord
+
+func newMainView(w fyne.Window) (fyne.CanvasObject, func(time.Duration, bool)) {
+	svc, err := app.Open()
+	if err != nil {
+		return container.NewPadded(widget.NewLabel("Failed to load GoSentry configuration: " + err.Error())), func(time.Duration, bool) {}
+	}
+	svc.InstallDesktopIcon(appID, assets.IconBytes())
+
+	// Build the initial event history from the current runtime state. Jobs and
+	// runtimes are read here only for this one-time initialization; the jobs view
+	// owns all subsequent state via its own syncFromService closure.
+	initialJobs := svc.Jobs()
+	initialRuntimes := make(map[int]*domain.JobRuntime, len(initialJobs))
+	for _, j := range initialJobs {
+		if rt := svc.Runtime(j.ID); rt != nil {
+			initialRuntimes[j.ID] = rt
+		}
+	}
+	events := collectActivity(initialJobs, initialRuntimes)
+
+	jobsPanel, refreshJobsView := newJobsView(w, svc)
+
+	history := newHistoryView(&events)
+	recordStartup := func(duration time.Duration, windowShown bool) {
+		// Startup is recorded as an in-memory History event instead of being
+		// persisted into jobs.yaml. It is session diagnostics, not durable job
+		// state, and keeping it ephemeral avoids polluting the human-editable YAML
+		// file with process-lifetime bookkeeping.
+		detail := "Window shown in " + duration.Round(time.Millisecond).String()
+		if !windowShown {
+			detail = "Started in tray in " + duration.Round(time.Millisecond).String()
+		}
+		events = append(events, newEvent(0, "Application", "Started", detail))
+		history.Refresh()
+	}
+
+	refresh := func() {
+		refreshJobsView()
+		history.Refresh()
+	}
+
+	// The Service announces every change through events. This single listener is
+	// where the UI reacts: it appends run/activity records to History and redraws.
+	// Events fire from two contexts — UI button handlers call into the Service
+	// synchronously (main goroutine), while scheduled and manual run completions
+	// emit from the run goroutine. fyne.Do marshals all of this widget work onto
+	// the main thread in both cases, so the engine never mutates Fyne state off
+	// the UI thread. This is the sole place events touch widgets. (Resolves #4.)
+	svc.Subscribe(app.ObserverFunc(func(ev app.Event) {
+		recorded, isRecorded := ev.(app.RunRecorded)
+		errOccurred, isError := ev.(app.ErrorOccurred)
+		fyne.Do(func() {
+			if isRecorded {
+				events = append(events, recorded.Record)
+			}
+			if isError {
+				events = append(events, newEvent(0, "Service", "Error", errOccurred.Err.Error()))
+			}
+			refresh()
+		})
+	}))
+	svc.Start()
+
+	tabs := container.NewAppTabs(
+		container.NewTabItemWithIcon("Jobs", theme.ListIcon(), jobsPanel),
+		container.NewTabItemWithIcon("History", theme.HistoryIcon(), history),
+		container.NewTabItemWithIcon("Settings", theme.SettingsIcon(), settingsView(w, svc)),
+	)
+	tabs.SetTabLocation(container.TabLocationTop)
+
+	return tabs, recordStartup
+}

src/ui/run.go

@@ -0,0 +1,60 @@
+package ui
+
+import (
+	"time"
+
+	"gitea.mixdep.ru/mix/gosentry/assets"
+	"gitea.mixdep.ru/mix/gosentry/src/app"
+
+	"fyne.io/fyne/v2"
+	fyneapp "fyne.io/fyne/v2/app"
+)
+
+const appID = "ru.mixdep.gosentry.desktop"
+
+// Run is the application entry point. It owns the process lifecycle — single
+// instance arbitration, Fyne app + window construction, tray wiring, and the
+// startup-timing record — and delegates all view construction to newMainView in
+// mainwindow.go. Keeping lifecycle here and the view there is the run.go /
+// mainwindow.go split introduced in T4.1.
+func Run(startInTray bool) {
+	started := time.Now()
+	instanceListener, primary := acquireSingleInstance(!startInTray)
+	if !primary {
+		return
+	}
+	if instanceListener != nil {
+		defer instanceListener.Close()
+	}
+
+	// A stable app ID lets Fyne persist desktop preferences consistently across
+	// launches and gives tray/window integration a predictable identity.
+	a := fyneapp.NewWithID(appID)
+	a.SetIcon(loadAppIcon())
+
+	w := a.NewWindow("GoSentry " + app.Version)
+	configureSystemTray(a, w)
+	w.Resize(fyne.NewSize(1120, 720))
+	content, recordStartup := newMainView(w)
+	w.SetContent(content)
+	serveSingleInstance(instanceListener, w)
+	if startInTray {
+		// Autostart launches intentionally stay hidden, so "window shown" would be
+		// a misleading metric. Record a separate startup event for the tray path
+		// instead of forcing one timing definition onto two different UX flows.
+		recordStartup(time.Since(started), false)
+		a.Run()
+		return
+	}
+	// Show the window before recording startup time. Measuring earlier, during
+	// widget construction, looked cheaper in History than the user-perceived
+	// startup really was. The current point is less abstract: it ends when the
+	// window has actually been handed to the desktop for display.
+	w.Show()
+	recordStartup(time.Since(started), true)
+	a.Run()
+}
+
+func loadAppIcon() fyne.Resource {
+	return assets.Icon()
+}

src/ui/settings_view.go

@@ -0,0 +1,182 @@
+package ui
+
+import (
+	"net/url"
+	"runtime"
+	"runtime/debug"
+	"strconv"
+	"strings"
+
+	"gitea.mixdep.ru/mix/gosentry/src/app"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/dialog"
+	"fyne.io/fyne/v2/theme"
+	"fyne.io/fyne/v2/widget"
+)
+
+const settingsLabelWidth float32 = 140
+const settingsControlWidth float32 = 330
+const settingsStatusWidth float32 = 280
+const projectRepositoryURL = "https://gitea.mixdep.ru/mix/gosentry"
+
+func settingsView(w fyne.Window, svc *app.Service) fyne.CanvasObject {
+	store := svc.Store()
+	startOnLogin := widget.NewCheck("Start on login", nil)
+	startOnLogin.SetChecked(store.Config.StartOnLogin)
+	autostartStatus := widget.NewLabel("")
+	refreshAutostartStatus := func() {
+		ok, message := svc.AutostartStatus()
+		if ok {
+			autostartStatus.SetText("OK: " + message)
+			return
+		}
+		autostartStatus.SetText("Problem: " + message)
+	}
+	startOnLogin.OnChanged = func(bool) {
+		if startOnLogin.Checked != store.Config.StartOnLogin {
+			autostartStatus.SetText("Pending: save settings to apply")
+			return
+		}
+		refreshAutostartStatus()
+	}
+	refreshAutostartStatus()
+	minimizeToTray := widget.NewCheck("Keep running in the system tray", nil)
+	minimizeToTray.SetChecked(store.Config.KeepRunningInTray)
+	notifications := widget.NewCheck("Show desktop notifications for failed jobs", nil)
+	notifications.SetChecked(store.Config.NotifyOnFailure)
+	jobsDir := widget.NewEntry()
+	jobsDir.SetText(store.Config.JobsDir)
+	jobsDirBrowse := widget.NewButtonWithIcon("Browse", theme.FolderOpenIcon(), func() {
+		chooseFolder(w, jobsDir)
+	})
+	logsDir := widget.NewEntry()
+	logsDir.SetText(store.Config.LogsDir)
+	logsDirBrowse := widget.NewButtonWithIcon("Browse", theme.FolderOpenIcon(), func() {
+		chooseFolder(w, logsDir)
+	})
+	maxLogFiles := widget.NewEntry()
+	maxLogFiles.SetText(strconv.Itoa(store.Config.MaxLogFiles))
+	maxLogAgeDays := widget.NewEntry()
+	maxLogAgeDays.SetText(strconv.Itoa(store.Config.MaxLogAgeDays))
+	settingsStatus := widget.NewLabel("")
+
+	saveSettings := widget.NewButtonWithIcon("Save settings", theme.DocumentSaveIcon(), func() {
+		files, err := strconv.Atoi(strings.TrimSpace(maxLogFiles.Text))
+		if err != nil || files <= 0 {
+			settingsStatus.SetText("Max log files must be a positive number")
+			return
+		}
+		days, err := strconv.Atoi(strings.TrimSpace(maxLogAgeDays.Text))
+		if err != nil || days <= 0 {
+			settingsStatus.SetText("Max log age days must be a positive number")
+			return
+		}
+		if strings.TrimSpace(jobsDir.Text) == "" {
+			settingsStatus.SetText("Jobs directory is required")
+			return
+		}
+		if strings.TrimSpace(logsDir.Text) == "" {
+			settingsStatus.SetText("Logs directory is required")
+			return
+		}
+		// Build the new config from the form and hand it to the Service, which
+		// validates it, persists config and jobs to the (possibly new) directory,
+		// and runs log cleanup so tightened retention limits take effect at once.
+		config := store.Config
+		config.JobsDir = strings.TrimSpace(jobsDir.Text)
+		config.LogsDir = strings.TrimSpace(logsDir.Text)
+		config.MaxLogFiles = files
+		config.MaxLogAgeDays = days
+		config.StartOnLogin = startOnLogin.Checked
+		config.KeepRunningInTray = minimizeToTray.Checked
+		config.NotifyOnFailure = notifications.Checked
+		if err := svc.UpdateSettings(config); err != nil {
+			settingsStatus.SetText("Save failed: " + err.Error())
+			return
+		}
+		if err := svc.ApplyAutostart(); err != nil {
+			refreshAutostartStatus()
+			settingsStatus.SetText("Saved, autostart failed: " + err.Error())
+			return
+		}
+		refreshAutostartStatus()
+		settingsStatus.SetText("Saved")
+	})
+
+	return container.NewPadded(container.NewVBox(
+		widget.NewLabelWithStyle("Application", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}),
+		settingsRowWithStatus("Autostart", startOnLogin, autostartStatus),
+		settingsRow("Tray", container.New(minWidthLayout{width: settingsControlWidth}, minimizeToTray)),
+		settingsRow("Notifications", container.New(minWidthLayout{width: settingsControlWidth}, notifications)),
+		widget.NewSeparator(),
+		widget.NewLabelWithStyle("Storage", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}),
+		settingsRow("Config YAML", widget.NewLabel(store.Paths.ConfigPath)),
+		settingsRow("Jobs directory", container.NewBorder(nil, nil, nil, jobsDirBrowse, jobsDir)),
+		settingsRow("Logs directory", container.NewBorder(nil, nil, nil, logsDirBrowse, logsDir)),
+		settingsRow("Max log files", maxLogFiles),
+		settingsRow("Max log age days", maxLogAgeDays),
+		saveSettings,
+		settingsStatus,
+		widget.NewSeparator(),
+		widget.NewLabelWithStyle("About", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}),
+		settingsRow("GoSentry", widget.NewLabel(app.Version)),
+		settingsRow("Go", widget.NewLabel(runtime.Version())),
+		settingsRow("Fyne", widget.NewLabel(fyneVersion())),
+		settingsRow("Repository", widget.NewHyperlink(projectRepositoryURL, mustParseURL(projectRepositoryURL))),
+	))
+}
+
+func fyneVersion() string {
+	info, ok := debug.ReadBuildInfo()
+	if !ok {
+		return "unknown"
+	}
+	for _, dependency := range info.Deps {
+		if dependency.Path == "fyne.io/fyne/v2" {
+			if dependency.Replace != nil && dependency.Replace.Version != "" {
+				return dependency.Replace.Version
+			}
+			if dependency.Version != "" {
+				return dependency.Version
+			}
+			return "local"
+		}
+	}
+	return "unknown"
+}
+
+func mustParseURL(raw string) *url.URL {
+	parsed, err := url.Parse(raw)
+	if err != nil {
+		return &url.URL{}
+	}
+	return parsed
+}
+
+func chooseFolder(w fyne.Window, target *widget.Entry) {
+	folderDialog := dialog.NewFolderOpen(func(uri fyne.ListableURI, err error) {
+		if err != nil || uri == nil {
+			return
+		}
+		target.SetText(uri.Path())
+	}, w)
+	// The default folder picker can be cramped on Windows. A larger size makes
+	// long paths readable and avoids forcing the user to resize it every time.
+	folderDialog.Resize(fyne.NewSize(900, 640))
+	folderDialog.Show()
+}
+
+func settingsRow(label string, value fyne.CanvasObject) fyne.CanvasObject {
+	caption := widget.NewLabelWithStyle(label, fyne.TextAlignLeading, fyne.TextStyle{Bold: true})
+	caption.Wrapping = fyne.TextTruncate
+	captionBox := container.New(minWidthLayout{width: settingsLabelWidth}, caption)
+	return container.NewBorder(nil, nil, captionBox, nil, value)
+}
+
+func settingsRowWithStatus(label string, value fyne.CanvasObject, status fyne.CanvasObject) fyne.CanvasObject {
+	valueBox := container.New(minWidthLayout{width: settingsControlWidth}, value)
+	statusBox := container.New(minWidthLayout{width: settingsStatusWidth}, status)
+	return settingsRow(label, container.NewBorder(nil, nil, valueBox, nil, statusBox))
+}

src/ui/singleinstance.go

@@ -0,0 +1,64 @@
+package ui
+
+import (
+	"io"
+	"net"
+	"strings"
+	"time"
+
+	"fyne.io/fyne/v2"
+)
+
+const singleInstanceAddress = "127.0.0.1:37653"
+const singleInstanceShowCommand = "show"
+
+func acquireSingleInstance(showExisting bool) (net.Listener, bool) {
+	listener, err := net.Listen("tcp", singleInstanceAddress)
+	if err == nil {
+		return listener, true
+	}
+
+	connection, dialErr := net.DialTimeout("tcp", singleInstanceAddress, time.Second)
+	if dialErr == nil {
+		// The first instance listens only on localhost and understands one tiny
+		// command: "show". That keeps the implementation dependency-free and easy
+		// to inspect, which matters more here than introducing a named-pipe or
+		// platform-specific IPC abstraction just to focus an existing window.
+		if showExisting {
+			_, _ = io.WriteString(connection, singleInstanceShowCommand)
+		}
+		_ = connection.Close()
+		return nil, false
+	}
+
+	// If the port is unavailable but does not answer as GoSentry, continue
+	// startup instead of making the application impossible to open because of an
+	// unrelated local listener. In the normal duplicate-start case the dial above
+	// succeeds and this process exits after waking the first instance.
+	return nil, true
+}
+
+func serveSingleInstance(listener net.Listener, w fyne.Window) {
+	if listener == nil {
+		return
+	}
+	go func() {
+		for {
+			connection, err := listener.Accept()
+			if err != nil {
+				return
+			}
+			command, _ := io.ReadAll(io.LimitReader(connection, 32))
+			_ = connection.Close()
+			if strings.TrimSpace(string(command)) != singleInstanceShowCommand {
+				continue
+			}
+			// Accept runs on its own goroutine, so focusing the window must be
+			// marshaled onto the main thread like every other widget update.
+			fyne.Do(func() {
+				w.Show()
+				w.RequestFocus()
+			})
+		}
+	}()
+}

src/ui/tray.go

@@ -0,0 +1,40 @@
+package ui
+
+import (
+	"fyne.io/fyne/v2"
+	fynedesktop "fyne.io/fyne/v2/driver/desktop"
+)
+
+func configureSystemTray(a fyne.App, w fyne.Window) {
+	desk, ok := a.(fynedesktop.App)
+	if !ok {
+		// Not every Fyne driver exposes desktop tray features. Returning silently
+		// keeps the same binary usable on platforms or sessions without a tray.
+		return
+	}
+
+	// IsQuit marks this as the tray's quit item. Without it Fyne's
+	// addMissingQuitForMenu appends a second, localized Quit (e.g. "Выход" on a
+	// Russian system) because it only recognizes an existing quit by matching the
+	// localized label — which our literal "Quit" does not. Setting IsQuit makes
+	// Fyne reuse this item instead of adding a duplicate, regardless of locale.
+	quit := fyne.NewMenuItem("Quit", func() {
+		a.Quit()
+	})
+	quit.IsQuit = true
+	menu := fyne.NewMenu("GoSentry",
+		fyne.NewMenuItem("Show", func() {
+			w.Show()
+			w.RequestFocus()
+		}),
+		fyne.NewMenuItemSeparator(),
+		quit,
+	)
+	desk.SetSystemTrayMenu(menu)
+	w.SetCloseIntercept(func() {
+		// Closing hides the window instead of quitting because scheduler tools are
+		// expected to keep working in the background. The explicit Quit tray item
+		// remains the way to stop the process.
+		w.Hide()
+	})
+}