1package tools
2
3import (
4 "context"
5 "encoding/json"
6 "errors"
7 "fmt"
8 "path/filepath"
9 "strings"
10 "testing"
11
12 "github.com/bnema/zut/packages/agent/subagents"
13)
14
15func TestRequiredSubagentSpawnReturnsWhileWorkerRuns(t *testing.T) {
16 root := t.TempDir()
17 started := make(chan struct{})
18 release := make(chan struct{})
19 manager := subagents.New(subagents.Config{
20 Root: filepath.Join(root, "subagents"),
21 RepoRoot: root,
22 NewRunner: func(*subagents.Agent) subagents.Runner {
23 return subagents.RunnerFunc(func(ctx context.Context, _ subagents.Sink) error {
24 close(started)
25 select {
26 case <-release:
27 return nil
28 case <-ctx.Done():
29 return ctx.Err()
30 }
31 })
32 },
33 })
34 t.Cleanup(manager.StopAll)
35
36 spawned := make(chan bool, 1)
37 tool := &SubagentSpawnTool{
38 Supervisor: manager,
39 Enabled: func() bool { return true },
40 OnSpawned: func(_ *subagents.Agent, _ string, required bool) {
41 spawned <- required
42 },
43 }
44 got, err := tool.Execute(context.Background(), json.RawMessage(`{"task":"finish the release","required":true}`), nil)
45 if err != nil {
46 t.Fatal(err)
47 }
48 <-started
49 text := textResult(got.Content)
50 if got.IsError || !strings.Contains(text, "required: pending") || !strings.Contains(text, "manager remains free") {
51 t.Fatalf("required spawn result = %#v\n%s", got, text)
52 }
53 if details, ok := got.Details.(map[string]any); !ok || details["required"] != true || details["requirement_state"] != "pending" {
54 t.Fatalf("required details = %#v", got.Details)
55 }
56 select {
57 case required := <-spawned:
58 if !required {
59 t.Fatal("required callback was reported as optional")
60 }
61 default:
62 t.Fatal("required spawn callback was not delivered")
63 }
64
65 close(release)
66 manager.List()[0].Wait()
67}
68
69func TestRequiredSubagentResumeRetriesUnmetWorkWithoutBlocking(t *testing.T) {
70 root := t.TempDir()
71 attempt := 0
72 retryStarted := make(chan struct{})
73 releaseRetry := make(chan struct{})
74 manager := subagents.New(subagents.Config{
75 Root: filepath.Join(root, "subagents"),
76 RepoRoot: root,
77 NewRunner: func(*subagents.Agent) subagents.Runner {
78 attempt++
79 current := attempt
80 return subagents.RunnerFunc(func(ctx context.Context, _ subagents.Sink) error {
81 if current == 1 {
82 return errors.New("first review failed")
83 }
84 close(retryStarted)
85 select {
86 case <-releaseRetry:
87 return nil
88 case <-ctx.Done():
89 return ctx.Err()
90 }
91 })
92 },
93 })
94 t.Cleanup(manager.StopAll)
95 spawn := &SubagentSpawnTool{Supervisor: manager, Enabled: func() bool { return true }}
96 first, err := spawn.Execute(context.Background(), json.RawMessage(`{"task":"review","required":true}`), nil)
97 if err != nil || first.IsError {
98 t.Fatalf("required spawn = (%+v, %v), want asynchronous success", first, err)
99 }
100 worker := manager.List()[0]
101 worker.Wait()
102 if !worker.Snapshot().Requirement.Unmet() {
103 t.Fatal("failed required worker was not retained as unmet")
104 }
105
106 var callbackRequired bool
107 resume := &SubagentResumeTool{
108 Supervisor: manager,
109 Enabled: func() bool { return true },
110 BeforeResumed: func(_ *subagents.Agent, _ string, required bool) func() {
111 callbackRequired = required
112 return nil
113 },
114 }
115 got, err := resume.Execute(context.Background(), json.RawMessage(fmt.Sprintf(`{"agent_id":%q,"prompt":"retry"}`, worker.ID)), nil)
116 if err != nil {
117 t.Fatal(err)
118 }
119 <-retryStarted
120 if got.IsError || !callbackRequired || !strings.Contains(textResult(got.Content), `"requirement":{"state":"pending"`) {
121 t.Fatalf("required retry = %#v callback_required=%v\n%s", got, callbackRequired, textResult(got.Content))
122 }
123 close(releaseRetry)
124 manager.List()[0].Wait()
125 if state := manager.List()[0].Snapshot().Requirement.State; state != subagents.RequirementSatisfied {
126 t.Fatalf("required retry state = %s, want satisfied", state)
127 }
128}
129
130func TestIndeterminateRequiredWorkNeedsExplicitUserReconciliation(t *testing.T) {
131 root := t.TempDir()
132 started := make(chan struct{})
133 first := subagents.New(subagents.Config{
134 Root: filepath.Join(root, "subagents"), RepoRoot: root,
135 NewRunner: func(*subagents.Agent) subagents.Runner {
136 return subagents.RunnerFunc(func(ctx context.Context, _ subagents.Sink) error {
137 close(started)
138 <-ctx.Done()
139 return ctx.Err()
140 })
141 },
142 })
143 a, err := first.SpawnReq(context.Background(), subagents.SpawnRequest{Task: "non-idempotent release action", Required: true})
144 if err != nil {
145 t.Fatal(err)
146 }
147 <-started
148 t.Cleanup(first.StopAll)
149
150 runs := 0
151 second := subagents.New(subagents.Config{
152 Root: filepath.Join(root, "subagents"), RepoRoot: root,
153 NewRunner: func(*subagents.Agent) subagents.Runner {
154 runs++
155 return subagents.RunnerFunc(func(context.Context, subagents.Sink) error { return nil })
156 },
157 })
158 t.Cleanup(second.StopAll)
159 if _, errs := second.Reload(); len(errs) != 0 {
160 t.Fatalf("reload errors: %v", errs)
161 }
162 resume := &SubagentResumeTool{Supervisor: second, Enabled: func() bool { return true }}
163 got, err := resume.Execute(context.Background(), json.RawMessage(fmt.Sprintf(`{"agent_id":%q,"prompt":"retry"}`, a.ID)), nil)
164 if err != nil {
165 t.Fatal(err)
166 }
167 if !got.IsError || runs != 0 || !strings.Contains(textResult(got.Content), "user must inspect") {
168 t.Fatalf("automatic indeterminate retry = %#v runs=%d\n%s", got, runs, textResult(got.Content))
169 }
170 first.StopAll()
171
172 confirmed, err := second.RestartTask(context.Background(), a.ID)
173 if err != nil {
174 t.Fatalf("explicit user restart: %v", err)
175 }
176 confirmed.Wait()
177 if runs != 1 || confirmed.Snapshot().Requirement.State != subagents.RequirementSatisfied {
178 t.Fatalf("explicit reconciliation runs=%d requirement=%+v", runs, confirmed.Snapshot().Requirement)
179 }
180}
181
182func TestRequiredSubagentFailureStaysUnmet(t *testing.T) {
183 root := t.TempDir()
184 manager := subagents.New(subagents.Config{
185 Root: filepath.Join(root, "subagents"),
186 RepoRoot: root,
187 NewRunner: func(*subagents.Agent) subagents.Runner {
188 return subagents.RunnerFunc(func(context.Context, subagents.Sink) error {
189 return errors.New("finalizer failed")
190 })
191 },
192 })
193 t.Cleanup(manager.StopAll)
194 tool := &SubagentSpawnTool{Supervisor: manager, Enabled: func() bool { return true }}
195
196 got, err := tool.Execute(context.Background(), json.RawMessage(`{"task":"finish the release","required":true}`), nil)
197 if err != nil || got.IsError || !strings.Contains(textResult(got.Content), "required: pending") {
198 t.Fatalf("required spawn = (%+v, %v), want asynchronous pending result", got, err)
199 }
200 agents := manager.List()
201 if len(agents) != 1 {
202 t.Fatalf("spawned agents = %d, want 1", len(agents))
203 }
204 agents[0].Wait()
205 if !agents[0].Snapshot().Requirement.Unmet() {
206 t.Fatalf("failed required worker was not retained as unmet: %#v", agents)
207 }
208 status := &SubagentStatusTool{Supervisor: manager, Enabled: func() bool { return true }}
209 public, err := status.Execute(context.Background(), json.RawMessage(`{}`), nil)
210 if err != nil {
211 t.Fatal(err)
212 }
213 publicText := textResult(public.Content)
214 if !strings.Contains(publicText, `"error_code":"failed"`) || strings.Contains(publicText, "finalizer failed") {
215 t.Fatalf("public requirement status exposed raw diagnostics: %s", publicText)
216 }
217}