Adopt repo standards: scaffold, policies, lint-clean (closes #1)

Add the standard scaffold and bring the tree to a clean lint under the
vendored `default: all` config. New: `script/` Scripts-to-Rule-Them-All
entrypoints with the `Makefile` reduced to thin shims; a `Dockerfile`
whose `lint` and `test` phases gate the build (final stage depends on
both); a `.gitea/workflows/` CI running `script/cibuild`; the vendored
`.golangci.yml`; `REPO_POLICIES.md`; `.editorconfig`; `.dockerignore`; a
`LICENSE` (WTFPL) and `TODO.md`; and a comprehensive `.gitignore`.

The 211 lint findings were fixed, not suppressed: package-level state
became functions/fields/a command constructor, magic numbers became named
constants, `ctx` is threaded into the probes, the loop functions were
split to cut complexity, and the deprecated `+build` tags were dropped.
Behavior is unchanged. The only annotations are justified `//nolint:gosec`
on the `ping`/`curl` subprocess calls (G204, fixed argv) and the
operator-chosen log file (G304), matching the reference repos.

`make check` is green (lint and tests run in Docker).

Model: opus-4-8

internal/monitor/styles.go

@@ -1,23 +1,62 @@
 //go:build linux
-// +build linux
 
 package monitor
 
 import tcell "github.com/gdamore/tcell/v2"
 
-// Color styles
-var (
-	CBrightGreen = tcell.StyleDefault.Foreground(tcell.ColorGreen).Bold(true)
-	CGreen       = tcell.StyleDefault.Foreground(tcell.ColorGreen)
-	CDimGreen    = tcell.StyleDefault.Foreground(tcell.ColorGreen).Dim(true)
-	CYellow      = tcell.StyleDefault.Foreground(tcell.ColorYellow)
-	COrange      = tcell.StyleDefault.Foreground(tcell.ColorOrange)
-	CRed         = tcell.StyleDefault.Foreground(tcell.ColorRed)
-	CBrightRed   = tcell.StyleDefault.Foreground(tcell.ColorRed).Bold(true)
-	CDefault     = tcell.StyleDefault
+// percentFull is the top of the 0..100 percentage scale.
+const percentFull = 100.0
 
-	// Rainbow colors for the spinner
-	CRainbow = []tcell.Style{
+// Meter fill thresholds, expressed as percent-good (100 = best, 0 = worst).
+const (
+	meterExcellent = 90
+	meterGood      = 75
+	meterFair      = 60
+	meterMediocre  = 40
+	meterPoor      = 20
+)
+
+// TCP latency thresholds, in milliseconds.
+const (
+	latencyGood     = 50
+	latencyModerate = 100
+	latencyHigh     = 200
+)
+
+// lossWarnPercent is the packet-loss level above which the display warns.
+const lossWarnPercent = 5
+
+func styleBrightGreen() tcell.Style {
+	return tcell.StyleDefault.Foreground(tcell.ColorGreen).Bold(true)
+}
+
+func styleGreen() tcell.Style {
+	return tcell.StyleDefault.Foreground(tcell.ColorGreen)
+}
+
+func styleDimGreen() tcell.Style {
+	return tcell.StyleDefault.Foreground(tcell.ColorGreen).Dim(true)
+}
+
+func styleYellow() tcell.Style {
+	return tcell.StyleDefault.Foreground(tcell.ColorYellow)
+}
+
+func styleOrange() tcell.Style {
+	return tcell.StyleDefault.Foreground(tcell.ColorOrange)
+}
+
+func styleRed() tcell.Style {
+	return tcell.StyleDefault.Foreground(tcell.ColorRed)
+}
+
+func styleBrightRed() tcell.Style {
+	return tcell.StyleDefault.Foreground(tcell.ColorRed).Bold(true)
+}
+
+// rainbow returns the color cycle used for spinners and the clock.
+func rainbow() []tcell.Style {
+	return []tcell.Style{
 		tcell.StyleDefault.Foreground(tcell.ColorRed),
 		tcell.StyleDefault.Foreground(tcell.ColorOrange),
 		tcell.StyleDefault.Foreground(tcell.ColorYellow),
@@ -25,63 +64,55 @@ var (
 		tcell.StyleDefault.Foreground(tcell.ColorBlue),
 		tcell.StyleDefault.Foreground(tcell.ColorPurple),
 	}
-)
+}
 
-// MeterColorForValue returns the appropriate color style for a meter value
-// value: current value of the meter
-// maxValue: maximum value of the meter
-// reverse: if true, low values are good (green) and high values are bad (red)
-//
-//	if false, high values are good (green) and low values are bad (red)
+// MeterColorForValue returns the color style for a meter value. When reverse
+// is true, low values are good (green) and high values bad (red); otherwise
+// high values are good.
 func MeterColorForValue(value, maxValue int, reverse bool) tcell.Style {
-	// Calculate percentage
-	percentage := float64(value) / float64(maxValue) * 100
-
-	// For reverse mode (low is good), invert the percentage
+	percentage := float64(value) / float64(maxValue) * percentFull
 	if reverse {
-		percentage = 100 - percentage
+		percentage = percentFull - percentage
 	}
 
-	// Return color based on percentage (after any reversal)
-	// Now high percentage always means "good" and low percentage means "bad"
 	switch {
-	case percentage >= 90:
-		return CBrightGreen
-	case percentage >= 75:
-		return CGreen
-	case percentage >= 60:
-		return CDimGreen
-	case percentage >= 40:
-		return CYellow
-	case percentage >= 20:
-		return COrange
+	case percentage >= meterExcellent:
+		return styleBrightGreen()
+	case percentage >= meterGood:
+		return styleGreen()
+	case percentage >= meterFair:
+		return styleDimGreen()
+	case percentage >= meterMediocre:
+		return styleYellow()
+	case percentage >= meterPoor:
+		return styleOrange()
 	default:
-		return CRed
+		return styleRed()
 	}
 }
 
-// StyleLatency returns the appropriate style for latency values
+// StyleLatency returns the style for a TCP latency in milliseconds.
 func StyleLatency(ms float64) tcell.Style {
 	switch {
-	case ms < 50:
-		return CBrightGreen
-	case ms < 100:
-		return CGreen
-	case ms < 200:
-		return CYellow
+	case ms < latencyGood:
+		return styleBrightGreen()
+	case ms < latencyModerate:
+		return styleGreen()
+	case ms < latencyHigh:
+		return styleYellow()
 	default:
-		return CRed
+		return styleRed()
 	}
 }
 
-// StyleLoss returns the appropriate style for packet loss percentages
+// StyleLoss returns the style for a packet-loss percentage.
 func StyleLoss(p float64) tcell.Style {
 	switch {
 	case p == 0:
-		return CBrightGreen
-	case p < 5:
-		return CYellow
+		return styleBrightGreen()
+	case p < lossWarnPercent:
+		return styleYellow()
 	default:
-		return CBrightRed
+		return styleBrightRed()
 	}
 }