refactor(night_mode): Phase B language-advantage pass — dichotomy wave

src/go/night-mode/main.go

@@ -141,8 +141,21 @@ func envOr(key, def string) string {
 	return def
 }
 
-// trunc — Python s[:n] (character semantics, not bytes).
+// trunc — Python s[:n] (character semantics, not bytes). Phase B
+// (language advantage): the common case — an ASCII string no longer than
+// n bytes — slices in place with zero allocation; only longer or
+// non-ASCII input pays for the rune walk. Python's s[:n] is always a
+// char walk, so results are identical on every input.
 func trunc(s string, n int) string {
+	if len(s) <= n {
+		for i := 0; i < len(s); i++ {
+			if s[i] >= 0x80 {
+				goto runes
+			}
+		}
+		return s
+	}
+runes:
 	r := []rune(s)
 	if len(r) > n {
 		return string(r[:n])

src/go/night-mode/night_mode_test.go

@@ -455,6 +455,32 @@ func TestRunLoop(t *testing.T) {
 	}
 }
 
+// TestTruncPhaseB — the ASCII fast path returns identical results to the
+// rune walk on every shape: short ASCII, exact-length ASCII, long ASCII,
+// multi-byte at and across the cut point.
+func TestTruncPhaseB(t *testing.T) {
+	cases := []struct {
+		in   string
+		n    int
+		want string
+	}{
+		{"abc", 5, "abc"},      // short ASCII: zero-alloc path
+		{"abcde", 5, "abcde"},  // exact length: no cut
+		{"abcdef", 5, "abcde"}, // long ASCII: byte cut == rune cut
+		{"", 3, ""},
+		{"héllo", 3, "hél"},   // multi-byte before the cut
+		{"héllo", 5, "héllo"}, // multi-byte, no cut
+		{"abécd", 3, "abé"},   // cut lands right after multi-byte rune
+		{"ééé", 2, "éé"},      // all multi-byte
+		{"x" + strings.Repeat("é", 200), 100, "x" + strings.Repeat("é", 99)},
+	}
+	for _, c := range cases {
+		if got := trunc(c.in, c.n); got != c.want {
+			t.Errorf("trunc(%q, %d) = %q, want %q", c.in, c.n, got, c.want)
+		}
+	}
+}
+
 // TestStatusReportShapes — non-empty state through the shared status core
 // and the report view.
 func TestStatusReportShapes(t *testing.T) {