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

Standard scaffold: script/ entrypoints with the Makefile as thin shims, a Dockerfile whose lint and test phases gate the build, a Gitea CI workflow running script/cibuild, REPO_POLICIES.md, TODO.md, .editorconfig, .dockerignore, LICENSE, wider .gitignore. .golangci.yml is byte-identical to the canonical copy in the prompts repo.

211 lint findings fixed in code: package globals became functions/fields and a cobra command constructor, magic numbers became named constants, ctx is threaded into the probes, monitor loops split. Tests moved to external _test packages with export_test.go. Behavior unchanged.

Readers will trip over: make lint/test/check now need a Docker daemon; the personal rsync copy/run targets are gone and make run runs locally.
Disclosure: four //nolint:gosec remain on the fixed-argv ping/curl calls and the operator-chosen log file, as the reference repo annotates the same class.
Disclosure: module path left as-is.

Model: opus-4-8 (implementation); fable-5-1 (merge)

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()
 	}
 }