test: ✅ Update flakey tests

cmd/agentop/tui/sessions_title_test.go

@@ -1216,20 +1216,14 @@ func TestLooksLikePath_AnyUnicodeSpaceSeparates(t *testing.T) {
 // 2.33s — four times the input for sixteen times the work. Reachable because the cwd tier was
 // uncapped, and the renderer redraws on every poll.
 //
-// Asserted as a RATIO rather than a wall-clock bound, so it says what it means on a loaded CI machine:
-// quadratic growth shows up as ~4x per doubling, linear as ~2x, and the ceiling sits between them.
-// Both ends are timed inside one test so the comparison is against the same machine at the same moment.
+// The cost is counted in allocations, so the assertion is about the work done and not about the
+// machine: the skip-ahead tries at most budget candidates whatever the input length, and the
+// one-at-a-time search allocates a candidate per dropped rune.
 func TestTrunc_ScalesLinearly(t *testing.T) {
 	const budget = 40
-	measure := func(f func(string, int) string, runes int) time.Duration {
+	measure := func(f func(string, int) string, runes int) float64 {
 		s := "/" + strings.Repeat("a", runes-1)
-		// Warm, so the first-call cost of anything lazy is not charged to the small input.
-		f(s, budget)
-		start := time.Now()
-		for i := 0; i < 20; i++ {
-			f(s, budget)
-		}
-		return time.Since(start)
+		return testing.AllocsPerRun(3, func() { f(s, budget) })
 	}
 	for _, tc := range []struct {
 		name string
@@ -1241,15 +1235,12 @@ func TestTrunc_ScalesLinearly(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			small := measure(tc.f, 4000)
 			large := measure(tc.f, 16000)
-			if small <= 0 {
-				t.Skip("timer resolution too coarse to compare")
-			}
-			// 4x the input. Linear predicts ~4x the time; quadratic predicts ~16x. A ceiling of 8x
-			// separates them with room for scheduling noise.
-			if ratio := float64(large) / float64(small); ratio > 8 {
-				t.Errorf("4x the input took %.1fx the time (%v -> %v) — that is the quadratic shape "+
+			// The allocation count is process-wide, so the ceiling leaves room for a stray
+			// allocation; the quadratic search makes thousands.
+			if large > 2*small {
+				t.Errorf("4x the input made %.0f allocations, up from %.0f — that is the quadratic shape "+
 					"back: the per-rune search must skip to the last/first n runes before measuring",
-					ratio, small, large)
+					large, small)
 			}
 		})
 	}

core/listener/forwardproxy/server_test.go

@@ -925,12 +925,20 @@ func TestForwardProxy_ResponseEventOmitsTtfbOnFailedExchange(t *testing.T) {
 	store := session.New(5*time.Minute, 100, 0)
 	defer store.Close()
 
-	// A server that is already closed: its port answers with a refusal, which
-	// is the fast half of the failure family. The 502 the proxy synthesizes is
-	// the same row shape a timed-out (black-holed) dial produces.
-	dead := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {}))
-	deadURL := dead.URL
-	dead.Close()
+	// An upstream that hangs up on every connection before answering. It keeps
+	// its port, so no other listener can take it. The 502 the proxy synthesizes
+	// is the same row shape a refused or black-holed dial produces.
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ln.Close()
+	go func() {
+		for c, err := ln.Accept(); err == nil; c, err = ln.Accept() {
+			_ = c.Close()
+		}
+	}()
+	deadURL := "http://" + ln.Addr().String()
 
 	p, err := pipeline.New([]pipeline.Plugin{})
 	if err != nil {

core/listener/forwardproxy/websocket_review_test.go

@@ -355,21 +355,15 @@ func TestResponsesWebSocket_UnansweredPrewarmIsNotFinishedTwice(t *testing.T) {
 	count := &finishCounter{}
 	logs := captureLogs(t)
 	h := newWSHarness(t, config.ResponsesWebSocketsParse, count)
+	received := make(chan bool, 1)
 	scriptedOrigin(h, func(read func() *wsframe.Frame, write func(string)) {
-		read() // the prewarm, never answered
+		received <- read() != nil // the prewarm, never answered
 	})
 	c := h.dial(t, nil)
 	c.send(`{"type":"response.create","generate":false,"model":"gpt-6-luna","input":[]}`)
-	// Wait until the origin has the prewarm, so the close lands while it is queued.
-	deadline := time.Now().Add(10 * time.Second)
-	for {
-		h.origin.mu.Lock()
-		n := len(h.origin.creates)
-		h.origin.mu.Unlock()
-		if n > 0 || time.Now().After(deadline) {
-			break
-		}
-		time.Sleep(10 * time.Millisecond)
+	// The close lands once the origin has the prewarm, while it is still queued.
+	if !<-received {
+		t.Fatal("the origin's socket closed before the prewarm reached it")
 	}
 	c.close()
 	events := h.events(t, codexSID, true)

core/plugins/script/internal/worker/env.go

@@ -90,6 +90,11 @@ var (
 	// exited or been killed. A process the profile backgrounds inherits stdout, and
 	// without this the probe would last as long as that process does.
 	loginPathWaitDelay = 100 * time.Millisecond
+	// loginPathContext is one probe's context, bounded by loginPathTimeout. A var
+	// so a test can end a probe itself.
+	loginPathContext = func() (context.Context, context.CancelFunc) {
+		return context.WithTimeout(context.Background(), loginPathTimeout)
+	}
 )
 
 // loginPath is the PATH a login shell of the user's own sets up. A successful
@@ -107,7 +112,7 @@ func loginPath() string {
 	if shell == "" {
 		return ""
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), loginPathTimeout)
+	ctx, cancel := loginPathContext()
 	defer cancel()
 	cmd := exec.CommandContext(ctx, shell, "-l", "-c", `printf '\n'"$0"'%s'"$0"'\n' "$PATH"`, pathMarker)
 	cmd.WaitDelay = loginPathWaitDelay

core/plugins/script/internal/worker/worker_test.go

@@ -647,30 +647,67 @@ func TestEnviron(t *testing.T) {
 }
 
 // A shell whose profile leaves a background process holding stdout still answers
-// within the probe's budget: with its PATH when it printed one, empty when it hung.
+// while that process lives: with its PATH when it printed one, empty when it hung
+// and its probe was ended. The process waits on a FIFO the test releases on
+// cleanup, so the exited shell's probe ends only through loginPathWaitDelay.
 func TestLoginPath_BackgroundChildHoldingStdout(t *testing.T) {
 	sh, err := exec.LookPath("sh")
 	if err != nil {
 		t.Skip("no sh")
 	}
-	for name, tc := range map[string]struct{ body, want string }{
-		"printed then exited": {"sleep 5 &\nshift\nPATH=/from/login exec " + sh + " \"$@\"\n", "/from/login"},
-		"hung":                {"sleep 5 &\nsleep 5\n", ""},
+	for name, tc := range map[string]struct {
+		body, want string
+		hangs      bool
+	}{
+		"printed then exited": {"read _ < \"$HOLD\" &\nshift\nPATH=/from/login exec " + sh + " \"$@\"\n", "/from/login", false},
+		"hung":                {"read _ < \"$HOLD\" &\necho > \"$STARTED\"\nread _ < \"$HOLD\"\n", "", true},
 	} {
 		t.Run(name, func(t *testing.T) {
-			shell := filepath.Join(t.TempDir(), "shell")
+			dir := t.TempDir()
+			// fifo makes a FIFO, opened read-write so opening it neither blocks nor
+			// sends EOF; closing it on cleanup does.
+			fifo := func(name string) (string, *os.File) {
+				path := filepath.Join(dir, name)
+				if err := syscall.Mkfifo(path, 0o600); err != nil {
+					t.Fatal(err)
+				}
+				f, err := os.OpenFile(path, os.O_RDWR, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				t.Cleanup(func() { f.Close() })
+				return path, f
+			}
+			hold, _ := fifo("hold")
+			started, startedR := fifo("started")
+			shell := filepath.Join(dir, "shell")
 			os.WriteFile(shell, []byte("#!"+sh+"\n"+tc.body), 0o700)
 			t.Setenv("SHELL", shell)
+			t.Setenv("HOLD", hold)
+			t.Setenv("STARTED", started)
+			ctx, cancel := context.WithCancel(context.Background())
+			t.Cleanup(cancel)
+			if tc.hangs {
+				// The probe ends once the shell is running and hung.
+				go func() {
+					if _, err := startedR.Read(make([]byte, 1)); err == nil {
+						cancel()
+					}
+				}()
+			}
 			loginPathMu.Lock()
 			loginPathVal, loginPathTried = "", time.Time{}
-			old := loginPathTimeout
-			loginPathTimeout = 500 * time.Millisecond
+			old := loginPathContext
+			loginPathContext = func() (context.Context, context.CancelFunc) { return ctx, func() {} }
 			loginPathMu.Unlock()
-			t.Cleanup(func() { loginPathVal, loginPathTried, loginPathTimeout = "", time.Now(), old })
-			t0 := time.Now()
+			t.Cleanup(func() {
+				loginPathMu.Lock()
+				defer loginPathMu.Unlock()
+				loginPathVal, loginPathTried, loginPathContext = "", time.Now(), old
+			})
 			got := loginPath()
-			if d := time.Since(t0); d > 2*time.Second {
-				t.Errorf("loginPath took %v against a %v budget", d, loginPathTimeout)
+			if tc.hangs && ctx.Err() == nil {
+				t.Error("loginPath returned before the shell signalled it was hung")
 			}
 			if got != tc.want {
 				t.Errorf("loginPath() = %q, want %q", got, tc.want)

core/reloader/reloader.go

@@ -112,6 +112,8 @@ type Reloader struct {
 	drainWindow  time.Duration
 	debounce     time.Duration
 	startTimeout time.Duration
+	// afterFunc arms the debounce timer: time.AfterFunc, or a test's own.
+	afterFunc func(time.Duration, func()) debounceTimer
 	// onCommit is run after a reload is accepted; see WithOnCommit.
 	onCommit func(*config.Config)
 	// extraDirs and fingerprint widen what a reload depends on; see WithExtraWatch.
@@ -160,6 +162,7 @@ func New(configPath string, inbound, outbound *pipeline.Holder, build PipelineBu
 		drainWindow:  10 * time.Minute,
 		debounce:     250 * time.Millisecond,
 		startTimeout: 60 * time.Second,
+		afterFunc:    func(d time.Duration, f func()) debounceTimer { return time.AfterFunc(d, f) },
 		closing:      make(chan struct{}),
 	}
 	for _, opt := range opts {
@@ -305,14 +308,20 @@ func (r *Reloader) ConfigProvider() func() *config.Config {
 	return func() *config.Config { return r.activeCfg.Load() }
 }
 
+// debounceTimer is the part of *time.Timer the debounce uses.
+type debounceTimer interface {
+	Reset(time.Duration) bool
+	Stop() bool
+}
+
 // watchLoop drains fsnotify events, debounces them, and dispatches
 // each debounced burst to reloadOnce. Exits when ctx is cancelled or
 // the watcher channel closes.
 func (r *Reloader) watchLoop(ctx context.Context, watcher *fsnotify.Watcher) {
 	defer watcher.Close()
 
 	base := filepath.Base(r.configPath)
-	var timer *time.Timer
+	var timer debounceTimer
 	defer func() {
 		if timer != nil {
 			timer.Stop()
@@ -355,7 +364,7 @@ func (r *Reloader) watchLoop(ctx context.Context, watcher *fsnotify.Watcher) {
 			// Debounce: reset the timer on every event. Fire once when
 			// the burst quiesces for `debounce`.
 			if timer == nil {
-				timer = time.AfterFunc(r.debounce, func() {
+				timer = r.afterFunc(r.debounce, func() {
 					select {
 					case trigger <- struct{}{}:
 					default: