cmd/codeaf: TestHostedWelcomeCarriesUnreadProfileKeysToSurface fails under load — the conversation writes into its temp folder after the host closes

[AbirAbbas]

What happened

cmd/codeaf TestHostedWelcomeCarriesUnreadProfileKeysToSurface fails under load because the conversation it opens keeps writing into its temp folder after the test has closed it:

--- FAIL: TestHostedWelcomeCarriesUnreadProfileKeysToSurface (0.00s)
    testing.go:1464: TempDir RemoveAll cleanup: unlinkat /tmp/TestHostedWelcomeCarriesUnreadProfileKeysToSurface3740933646/002/574f9f6350df202f: directory not empty

It was seen once in a make pr-ready run for #1410 (santos/dev2 at 19a5a77c5, 2026-09-24). It passed 200 of 200 runs alone and passed a full go test -count=1 ./cmd/codeaf rerun. The late write reproduces on the untouched santos/dev2 head 008363c98, so the merge that surfaced it did not cause it.

The test builds its agent with v3TrackedAgent(t, workspace), serves it through remote.Loopback and closes the loop in t.Cleanup, but it never closes the agent itself. A probe (below) found a write into the agent's place directory (002/<hash>) about 50 µs after loop.Close() returned. On a quiet box that write finishes before t.TempDir's RemoveAll. On a loaded box it lands during the removal.

Replication

Deterministic (no model). Drop this probe into cmd/codeaf as zz_hostprobe_test.go and run go test -count=1 -run TestProbeHostedWelcomeLateWrites -v ./cmd/codeaf. It prints LATE <path> <duration> after end for every file written after the close. There should be none, and today there is at least one under the place directory.

package main

import (
	"io/fs"
	"path/filepath"
	"testing"
	"time"

	"github.com/Agent-Field/codeaf/internal/remote"
)

func TestProbeHostedWelcomeLateWrites(t *testing.T) {
	workspace := t.TempDir()
	agent := v3TrackedAgent(t, workspace)
	loop, err := remote.Loopback(remote.Hello{Version: remote.Version, Workspace: workspace}, remote.Options{
		Boot: func(remote.Hello) (*remote.Engine, error) {
			return &remote.Engine{Agent: agent, Workspace: workspace, UnreadProfileKeys: []string{"models"}}, nil
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	_, _ = hostOptions(onePipeFleet("devbox", loop.Client), loop.Client.Welcome(), false)
	_ = loop.Close()
	end := time.Now()
	time.Sleep(3 * time.Second)
	_ = filepath.WalkDir(filepath.Dir(workspace), func(p string, d fs.DirEntry, err error) error {
		if err != nil {
			return nil
		}
		if info, _ := d.Info(); info != nil && info.ModTime().After(end) {
			t.Logf("LATE %s %v after end", p, info.ModTime().Sub(end))
		}
		return nil
	})
}

The probe shows the late write on every run. The failure itself needs load, and how often it fails under load has not been measured. The recipe: with one busy loop per core (for i in $(seq "$(nproc)"); do yes >/dev/null & done), run GOMAXPROCS=2 go test -count=200 -run '^TestHostedWelcomeCarriesUnreadProfileKeysToSurface$' ./cmd/codeaf.

Field. Not needed. No model is involved.

Where

• cmd/codeaf/chatv3_host_test.go, TestHostedWelcomeCarriesUnreadProfileKeysToSurface: no agent.Close() in its cleanup.
• v3TrackedAgent (the test helper), and whatever the agent or remote.Loopback's engine still writes into the place directory after the loop closes. That is the product half: a closed host should not write.

The fix

Closing the loopback host leaves nothing writing under the agent's place, or the host's Close waits for those writes. The test closes the agent it opened, before its temp folders are removed. Fixing only the test would hide the product half, so both are wanted.

Acceptance

• Unit: the probe above prints no LATE line.
• Unit (under load): the -count=200 loop above is green with one busy loop per core, three times in a row.
• Sibling tests that build an agent with v3TrackedAgent close it; a grep for v3TrackedAgent( in cmd/codeaf shows a matching close for each one.