1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
package executor
import (
"context"
"errors"
"testing"
"github.com/thepeterstone/claudomator/internal/event"
"github.com/thepeterstone/claudomator/internal/task"
)
type fakeChannelStore struct {
createdTasks []*task.Task
createdEvents []*event.Event
createTaskErr error
}
func (f *fakeChannelStore) CreateTask(t *task.Task) error {
if f.createTaskErr != nil {
return f.createTaskErr
}
f.createdTasks = append(f.createdTasks, t)
return nil
}
func (f *fakeChannelStore) CreateEvent(e *event.Event) error {
f.createdEvents = append(f.createdEvents, e)
return nil
}
func TestStoreChannel_AskUser_BuffersAndBlocks(t *testing.T) {
ch := newStoreChannel(&fakeChannelStore{}, "task-1")
answer, err := ch.AskUser(context.Background(), `{"text":"q"}`)
if !errors.Is(err, ErrAgentBlocked) {
t.Errorf("expected ErrAgentBlocked, got %v", err)
}
if answer != "" {
t.Errorf("expected empty answer, got %q", answer)
}
q, blocked := ch.PendingQuestion()
if !blocked || q != `{"text":"q"}` {
t.Errorf("expected buffered question, got q=%q blocked=%v", q, blocked)
}
}
func TestStoreChannel_PendingQuestion_DefaultNotBlocked(t *testing.T) {
ch := newStoreChannel(&fakeChannelStore{}, "task-1")
if q, blocked := ch.PendingQuestion(); blocked || q != "" {
t.Errorf("expected no pending question, got q=%q blocked=%v", q, blocked)
}
}
func TestStoreChannel_ReportSummary_Buffers(t *testing.T) {
ch := newStoreChannel(&fakeChannelStore{}, "task-1")
if _, ok := ch.ReportedSummary(); ok {
t.Error("expected no summary before report")
}
if err := ch.ReportSummary(context.Background(), "did the thing"); err != nil {
t.Fatalf("ReportSummary: %v", err)
}
sum, ok := ch.ReportedSummary()
if !ok || sum != "did the thing" {
t.Errorf("expected buffered summary, got %q ok=%v", sum, ok)
}
}
func TestStoreChannel_SpawnSubtask_CreatesChildWithParent(t *testing.T) {
store := &fakeChannelStore{}
ch := newStoreChannel(store, "parent-1")
id, err := ch.SpawnSubtask(context.Background(), SubtaskSpec{
Name: "child",
Instructions: "do it",
Model: "sonnet",
MaxBudgetUSD: 1.5,
})
if err != nil {
t.Fatalf("SpawnSubtask: %v", err)
}
if id == "" {
t.Error("expected non-empty subtask ID")
}
if len(store.createdTasks) != 1 {
t.Fatalf("expected 1 created task, got %d", len(store.createdTasks))
}
ct := store.createdTasks[0]
if ct.ParentTaskID != "parent-1" {
t.Errorf("ParentTaskID: got %q want parent-1", ct.ParentTaskID)
}
if ct.ID != id {
t.Errorf("returned id %q != created task id %q", id, ct.ID)
}
if ct.Agent.Instructions != "do it" || ct.Agent.Model != "sonnet" || ct.Agent.MaxBudgetUSD != 1.5 {
t.Errorf("agent config not propagated: %+v", ct.Agent)
}
if ct.State != task.StatePending {
t.Errorf("expected PENDING child, got %s", ct.State)
}
}
// TestStoreChannel_SpawnSubtask_RoleSet verifies that when spec.Role is set,
// the child task gets Agent.Role populated and Agent.Type/Model left empty
// so executor.Pool.execute()'s role-based dispatch (Phase 5) resolves them
// from the role's escalation ladder, exactly like any other role-typed task.
func TestStoreChannel_SpawnSubtask_RoleSet(t *testing.T) {
store := &fakeChannelStore{}
ch := newStoreChannel(store, "parent-1")
id, err := ch.SpawnSubtask(context.Background(), SubtaskSpec{
Name: "evaluator",
Instructions: "evaluate the change",
Model: "should-be-ignored",
MaxBudgetUSD: 2.0,
Role: "evaluator_quality",
})
if err != nil {
t.Fatalf("SpawnSubtask: %v", err)
}
if len(store.createdTasks) != 1 {
t.Fatalf("expected 1 created task, got %d", len(store.createdTasks))
}
ct := store.createdTasks[0]
if ct.ID != id {
t.Errorf("returned id %q != created task id %q", id, ct.ID)
}
if ct.Agent.Role != "evaluator_quality" {
t.Errorf("Agent.Role: want evaluator_quality, got %q", ct.Agent.Role)
}
if ct.Agent.Type != "" {
t.Errorf("Agent.Type: want empty (resolved later by role dispatch), got %q", ct.Agent.Type)
}
if ct.Agent.Model != "" {
t.Errorf("Agent.Model: want empty (resolved later by role dispatch), got %q", ct.Agent.Model)
}
if ct.Agent.Instructions != "evaluate the change" || ct.Agent.MaxBudgetUSD != 2.0 {
t.Errorf("non-role fields not propagated: %+v", ct.Agent)
}
}
// TestStoreChannel_SpawnSubtask_NoRole_RegressionUnchanged is a regression
// test proving that spec.Role == "" (every pre-Phase-6 caller) still
// produces exactly today's behavior: Agent.Type hardcoded to "claude" and
// Agent.Model set from spec.Model. This must keep passing unmodified by any
// future change to role-typed spawning.
func TestStoreChannel_SpawnSubtask_NoRole_RegressionUnchanged(t *testing.T) {
store := &fakeChannelStore{}
ch := newStoreChannel(store, "parent-1")
id, err := ch.SpawnSubtask(context.Background(), SubtaskSpec{
Name: "child",
Instructions: "do it",
Model: "sonnet",
MaxBudgetUSD: 1.5,
})
if err != nil {
t.Fatalf("SpawnSubtask: %v", err)
}
if len(store.createdTasks) != 1 {
t.Fatalf("expected 1 created task, got %d", len(store.createdTasks))
}
ct := store.createdTasks[0]
if ct.ID != id {
t.Errorf("returned id %q != created task id %q", id, ct.ID)
}
if ct.ParentTaskID != "parent-1" {
t.Errorf("ParentTaskID: got %q want parent-1", ct.ParentTaskID)
}
if ct.Agent.Type != "claude" {
t.Errorf("Agent.Type: want claude (unchanged backward-compat default), got %q", ct.Agent.Type)
}
if ct.Agent.Model != "sonnet" {
t.Errorf("Agent.Model: want sonnet, got %q", ct.Agent.Model)
}
if ct.Agent.Role != "" {
t.Errorf("Agent.Role: want empty, got %q", ct.Agent.Role)
}
if ct.Agent.Instructions != "do it" || ct.Agent.MaxBudgetUSD != 1.5 {
t.Errorf("agent config not propagated: %+v", ct.Agent)
}
if ct.State != task.StatePending {
t.Errorf("expected PENDING child, got %s", ct.State)
}
}
func TestStoreChannel_SpawnSubtask_PropagatesError(t *testing.T) {
store := &fakeChannelStore{createTaskErr: errors.New("boom")}
ch := newStoreChannel(store, "parent-1")
if _, err := ch.SpawnSubtask(context.Background(), SubtaskSpec{Name: "x"}); err == nil {
t.Error("expected error from CreateTask")
}
}
func TestStoreChannel_RecordProgress_EmitsAgentMessage(t *testing.T) {
store := &fakeChannelStore{}
ch := newStoreChannel(store, "task-1")
if err := ch.RecordProgress(context.Background(), "halfway done"); err != nil {
t.Fatalf("RecordProgress: %v", err)
}
if len(store.createdEvents) != 1 {
t.Fatalf("expected 1 event, got %d", len(store.createdEvents))
}
e := store.createdEvents[0]
if e.Kind != event.KindAgentMessage || e.Actor != event.ActorAgent {
t.Errorf("got kind=%v actor=%v want agent_message/agent", e.Kind, e.Actor)
}
if e.TaskID != "task-1" {
t.Errorf("TaskID: got %q want task-1", e.TaskID)
}
}
|
