bb1a57d test(agent): stabilize cross-platform CI · zut

M packages/agent/build_orchestrator_test.go +4 -2


@@ -13,13 +13,15 @@ import (
13	13		func TestResolveSeparatesInteractiveProactiveAndHeadlessStrictPolicies(t *testing.T) {
14	14		root := t.TempDir()
15	15		zutHome := filepath.Join(root, "zut-home")
	16	+	home := filepath.Join(root, "home")
16	17		project := filepath.Join(root, "project")
17	18		t.Setenv("ZUT_HOME", zutHome)
18		-	t.Setenv("HOME", filepath.Join(root, "home"))
	19	+	t.Setenv("HOME", home)
	20	+	t.Setenv("USERPROFILE", home)
19	21		if err := os.MkdirAll(project, 0o755); err != nil {
20	22		t.Fatal(err)
21	23		}
22		-	profilesDir := filepath.Join(root, "home", ".agents", "agents")
	24	+	profilesDir := filepath.Join(home, ".agents", "agents")
23	25		if err := os.MkdirAll(profilesDir, 0o755); err != nil {
24	26		t.Fatal(err)
25	27		}

 func TestResolveSeparatesInteractiveProactiveAndHeadlessStrictPolicies(t *testing.T) {
 	root := t.TempDir()
 	zutHome := filepath.Join(root, "zut-home")
+	home := filepath.Join(root, "home")
 	project := filepath.Join(root, "project")
 	t.Setenv("ZUT_HOME", zutHome)
-	t.Setenv("HOME", filepath.Join(root, "home"))
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
 	if err := os.MkdirAll(project, 0o755); err != nil {
 		t.Fatal(err)
 	}
-	profilesDir := filepath.Join(root, "home", ".agents", "agents")
+	profilesDir := filepath.Join(home, ".agents", "agents")
 	if err := os.MkdirAll(profilesDir, 0o755); err != nil {
 		t.Fatal(err)
 	}

M packages/agent/modes/theme_watch.go +32 -20


@@ -51,12 +51,12 @@ func watchThemeSource(ctx context.Context, home, preference string, accepted *tu
51	51		}
52	52		ticker := time.NewTicker(interval)
53	53		defer ticker.Stop()
54		-	watchThemeSourceTicks(ctx, home, preference, accepted, ticker.C, events)
	54	+	watchThemeSourceTicks(ctx, home, preference, accepted, ticker.C, events, nil)
55	55		}
56	56
57	57		// watchThemeSourceTicks is the test seam for polling: tests advance explicit
58		-	// timestamps rather than synchronizing with sleeps.
59		-	func watchThemeSourceTicks(ctx context.Context, home, preference string, accepted *tui.ThemeSource, ticks <-chan time.Time, events chan<- themeWatchEvent) {
	58	+	// timestamps and may receive a processed acknowledgement instead of sleeping.
	59	+	func watchThemeSourceTicks(ctx context.Context, home, preference string, accepted *tui.ThemeSource, ticks <-chan time.Time, events chan<- themeWatchEvent, processed chan<- struct{}) {
60	60		if accepted == nil \|\| accepted.Path == "" {
61	61		return
62	62		}

@@ -68,37 +68,49 @@ func watchThemeSourceTicks(ctx context.Context, home, preference string, accepte
68	68		case <-ctx.Done():
69	69		return
70	70		case now := <-ticks:
	71	+	stop := false
71	72		if _, statErr := os.Stat(accepted.Path); errors.Is(statErr, os.ErrNotExist) {
72	73		if missingSince.IsZero() {
73	74		missingSince = now
74	75		}
75	76		if now.Sub(missingSince) >= themeMissingGrace {
76	77		sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, deleted: true})
77		-	return
	78	+	stop = true
78	79		}
79		-	continue
80		-	}
81		-	// A present-but-invalid revision remains watchable and must restart
82		-	// the deletion grace period just like a valid replacement does.
83		-	missingSince = time.Time{}
84		-	source, err := tui.LoadThemeSource(home, preference)
85		-	if err == nil && source != nil {
86		-	lastError = ""
87		-	if source.Path != accepted.Path \|\| source.Digest == lastDigest {
88		-	continue
	80	+	} else {
	81	+	// A present-but-invalid revision remains watchable and must restart
	82	+	// the deletion grace period just like a valid replacement does.
	83	+	missingSince = time.Time{}
	84	+	source, err := tui.LoadThemeSource(home, preference)
	85	+	if err == nil && source != nil {
	86	+	lastError = ""
	87	+	if source.Path == accepted.Path && source.Digest != lastDigest {
	88	+	lastDigest = source.Digest
	89	+	sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, source: source})
	90	+	}
	91	+	} else if err != nil && err.Error() != lastError {
	92	+	lastError = err.Error()
	93	+	sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, err: err})
89	94		}
90		-	lastDigest = source.Digest
91		-	sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, source: source})
92		-	continue
93	95		}
94		-	if err != nil && err.Error() != lastError {
95		-	lastError = err.Error()
96		-	sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, err: err})
	96	+	acknowledgeThemeWatchTick(ctx, processed)
	97	+	if stop {
	98	+	return
97	99		}
98	100		}
99	101		}
100	102		}
101	103
	104	+	func acknowledgeThemeWatchTick(ctx context.Context, processed chan<- struct{}) {
	105	+	if processed == nil {
	106	+	return
	107	+	}
	108	+	select {
	109	+	case processed <- struct{}{}:
	110	+	case <-ctx.Done():
	111	+	}
	112	+	}
	113	+
102	114		func sendThemeWatchEvent(ctx context.Context, events chan<- themeWatchEvent, event themeWatchEvent) {
103	115		select {
104	116		case events <- event:

 	}
 	ticker := time.NewTicker(interval)
 	defer ticker.Stop()
-	watchThemeSourceTicks(ctx, home, preference, accepted, ticker.C, events)
+	watchThemeSourceTicks(ctx, home, preference, accepted, ticker.C, events, nil)
 }
 // watchThemeSourceTicks is the test seam for polling: tests advance explicit
-// timestamps rather than synchronizing with sleeps.
+// timestamps and may receive a processed acknowledgement instead of sleeping.
-func watchThemeSourceTicks(ctx context.Context, home, preference string, accepted *tui.ThemeSource, ticks <-chan time.Time, events chan<- themeWatchEvent) {
+func watchThemeSourceTicks(ctx context.Context, home, preference string, accepted *tui.ThemeSource, ticks <-chan time.Time, events chan<- themeWatchEvent, processed chan<- struct{}) {
 	if accepted == nil || accepted.Path == "" {
 		return
 	}
 		case <-ctx.Done():
 			return
 		case now := <-ticks:
+			stop := false
 			if _, statErr := os.Stat(accepted.Path); errors.Is(statErr, os.ErrNotExist) {
 				if missingSince.IsZero() {
 					missingSince = now
 				}
 				if now.Sub(missingSince) >= themeMissingGrace {
 					sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, deleted: true})
-					return
+					stop = true
 				}
-				continue
+			} else {
-			}
+				// A present-but-invalid revision remains watchable and must restart
-			// A present-but-invalid revision remains watchable and must restart
+				// the deletion grace period just like a valid replacement does.
-			// the deletion grace period just like a valid replacement does.
+				missingSince = time.Time{}
-			missingSince = time.Time{}
+				source, err := tui.LoadThemeSource(home, preference)
-			source, err := tui.LoadThemeSource(home, preference)
+				if err == nil && source != nil {
-			if err == nil && source != nil {
+					lastError = ""
-				lastError = ""
+					if source.Path == accepted.Path && source.Digest != lastDigest {
-				if source.Path != accepted.Path || source.Digest == lastDigest {
+						lastDigest = source.Digest
-					continue
+						sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, source: source})
+					}
+				} else if err != nil && err.Error() != lastError {
+					lastError = err.Error()
+					sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, err: err})
 				}
-				lastDigest = source.Digest
-				sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, source: source})
-				continue
 			}
-			if err != nil && err.Error() != lastError {
+			acknowledgeThemeWatchTick(ctx, processed)
-				lastError = err.Error()
+			if stop {
-				sendThemeWatchEvent(ctx, events, themeWatchEvent{path: accepted.Path, err: err})
+				return
 			}
 		}
 	}
 }
+func acknowledgeThemeWatchTick(ctx context.Context, processed chan<- struct{}) {
+	if processed == nil {
+		return
+	}
+	select {
+	case processed <- struct{}{}:
+	case <-ctx.Done():
+	}
+}
 func sendThemeWatchEvent(ctx context.Context, events chan<- themeWatchEvent, event themeWatchEvent) {
 	select {
 	case events <- event:

M packages/agent/modes/theme_watch_test.go +21 -9


@@ -22,6 +22,16 @@ func writeWatchedTheme(t *testing.T, home, body string) string {
22	22		return path
23	23		}
24	24
	25	+	func advanceThemeWatch(t *testing.T, ticks chan<- time.Time, processed <-chan struct{}, now time.Time) {
	26	+	t.Helper()
	27	+	ticks <- now
	28	+	select {
	29	+	case <-processed:
	30	+	case <-time.After(time.Second):
	31	+	t.Fatal("watcher did not process tick")
	32	+	}
	33	+	}
	34	+
25	35		func TestWatchThemeSourceTicksPublishesOnlyValidRevisions(t *testing.T) {
26	36		home := t.TempDir()
27	37		path := writeWatchedTheme(t, home, `{"colors":{"accent":20}}`)

@@ -32,13 +42,14 @@ func TestWatchThemeSourceTicksPublishesOnlyValidRevisions(t *testing.T) {
32	42		ctx, cancel := context.WithCancel(context.Background())
33	43		defer cancel()
34	44		ticks := make(chan time.Time)
	45	+	processed := make(chan struct{})
35	46		events := make(chan themeWatchEvent, 3)
36		-	go watchThemeSourceTicks(ctx, home, "live", accepted, ticks, events)
	47	+	go watchThemeSourceTicks(ctx, home, "live", accepted, ticks, events, processed)
37	48
38	49		if err := os.WriteFile(path, []byte(`{"colors":{"accent":21}}`), 0o644); err != nil {
39	50		t.Fatal(err)
40	51		}
41		-	ticks <- time.Unix(1, 0)
	52	+	advanceThemeWatch(t, ticks, processed, time.Unix(1, 0))
42	53		select {
43	54		case event := <-events:
44	55		if event.source == nil \|\| event.source.File.Colors.Base.Accent == nil \|\| event.source.File.Colors.Base.Accent.Index != 21 {

@@ -51,7 +62,7 @@ func TestWatchThemeSourceTicksPublishesOnlyValidRevisions(t *testing.T) {
51	62		if err := os.WriteFile(path, []byte(`{"colors":{"accent":999}}`), 0o644); err != nil {
52	63		t.Fatal(err)
53	64		}
54		-	ticks <- time.Unix(2, 0)
	65	+	advanceThemeWatch(t, ticks, processed, time.Unix(2, 0))
55	66		select {
56	67		case event := <-events:
57	68		if event.err == nil \|\| event.source != nil {

@@ -72,17 +83,18 @@ func TestWatchThemeSourceTicksRestartsDeletionGraceAfterInvalidReappearance(t *t
72	83		ctx, cancel := context.WithCancel(context.Background())
73	84		defer cancel()
74	85		ticks := make(chan time.Time)
	86	+	processed := make(chan struct{})
75	87		events := make(chan themeWatchEvent, 1)
76		-	go watchThemeSourceTicks(ctx, home, "live", accepted, ticks, events)
	88	+	go watchThemeSourceTicks(ctx, home, "live", accepted, ticks, events, processed)
77	89
78	90		if err := os.Remove(path); err != nil {
79	91		t.Fatal(err)
80	92		}
81		-	ticks <- time.Unix(1, 0)
	93	+	advanceThemeWatch(t, ticks, processed, time.Unix(1, 0))
82	94		if err := os.WriteFile(path, []byte(`{"colors":{"accent":999}}`), 0o644); err != nil {
83	95		t.Fatal(err)
84	96		}
85		-	ticks <- time.Unix(2, 0)
	97	+	advanceThemeWatch(t, ticks, processed, time.Unix(2, 0))
86	98		select {
87	99		case event := <-events:
88	100		if event.err == nil {

@@ -95,14 +107,14 @@ func TestWatchThemeSourceTicksRestartsDeletionGraceAfterInvalidReappearance(t *t
95	107		if err := os.Remove(path); err != nil {
96	108		t.Fatal(err)
97	109		}
98		-	ticks <- time.Unix(3, 0)
99		-	ticks <- time.Unix(4, 0)
	110	+	advanceThemeWatch(t, ticks, processed, time.Unix(3, 0))
	111	+	advanceThemeWatch(t, ticks, processed, time.Unix(4, 0))
100	112		select {
101	113		case event := <-events:
102	114		t.Fatalf("deletion happened before restarted grace period: %#v", event)
103	115		default:
104	116		}
105		-	ticks <- time.Unix(6, 0)
	117	+	advanceThemeWatch(t, ticks, processed, time.Unix(6, 0))
106	118		select {
107	119		case event := <-events:
108	120		if !event.deleted {

 	return path
 }
+func advanceThemeWatch(t *testing.T, ticks chan<- time.Time, processed <-chan struct{}, now time.Time) {
+	t.Helper()
+	ticks <- now
+	select {
+	case <-processed:
+	case <-time.After(time.Second):
+		t.Fatal("watcher did not process tick")
+	}
+}
 func TestWatchThemeSourceTicksPublishesOnlyValidRevisions(t *testing.T) {
 	home := t.TempDir()
 	path := writeWatchedTheme(t, home, `{"colors":{"accent":20}}`)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	ticks := make(chan time.Time)
+	processed := make(chan struct{})
 	events := make(chan themeWatchEvent, 3)
-	go watchThemeSourceTicks(ctx, home, "live", accepted, ticks, events)
+	go watchThemeSourceTicks(ctx, home, "live", accepted, ticks, events, processed)
 	if err := os.WriteFile(path, []byte(`{"colors":{"accent":21}}`), 0o644); err != nil {
 		t.Fatal(err)
 	}
-	ticks <- time.Unix(1, 0)
+	advanceThemeWatch(t, ticks, processed, time.Unix(1, 0))
 	select {
 	case event := <-events:
 		if event.source == nil || event.source.File.Colors.Base.Accent == nil || event.source.File.Colors.Base.Accent.Index != 21 {
 	if err := os.WriteFile(path, []byte(`{"colors":{"accent":999}}`), 0o644); err != nil {
 		t.Fatal(err)
 	}
-	ticks <- time.Unix(2, 0)
+	advanceThemeWatch(t, ticks, processed, time.Unix(2, 0))
 	select {
 	case event := <-events:
 		if event.err == nil || event.source != nil {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	ticks := make(chan time.Time)
+	processed := make(chan struct{})
 	events := make(chan themeWatchEvent, 1)
-	go watchThemeSourceTicks(ctx, home, "live", accepted, ticks, events)
+	go watchThemeSourceTicks(ctx, home, "live", accepted, ticks, events, processed)
 	if err := os.Remove(path); err != nil {
 		t.Fatal(err)
 	}
-	ticks <- time.Unix(1, 0)
+	advanceThemeWatch(t, ticks, processed, time.Unix(1, 0))
 	if err := os.WriteFile(path, []byte(`{"colors":{"accent":999}}`), 0o644); err != nil {
 		t.Fatal(err)
 	}
-	ticks <- time.Unix(2, 0)
+	advanceThemeWatch(t, ticks, processed, time.Unix(2, 0))
 	select {
 	case event := <-events:
 		if event.err == nil {
 	if err := os.Remove(path); err != nil {
 		t.Fatal(err)
 	}
-	ticks <- time.Unix(3, 0)
+	advanceThemeWatch(t, ticks, processed, time.Unix(3, 0))
-	ticks <- time.Unix(4, 0)
+	advanceThemeWatch(t, ticks, processed, time.Unix(4, 0))
 	select {
 	case event := <-events:
 		t.Fatalf("deletion happened before restarted grace period: %#v", event)
 	default:
 	}
-	ticks <- time.Unix(6, 0)
+	advanceThemeWatch(t, ticks, processed, time.Unix(6, 0))
 	select {
 	case event := <-events:
 		if !event.deleted {