1package subagents
2
3import (
4 "fmt"
5 "os"
6 "path/filepath"
7 "strings"
8 "testing"
9)
10
11func TestDiscoverLoadsGlobalAgentsProfilesAndIgnoresPiProfiles(t *testing.T) {
12 t.Setenv("ZUT_AGENT_PROFILES", "")
13 home := t.TempDir()
14 agentsDir := filepath.Join(home, ".agents", "agents")
15 piDir := filepath.Join(home, ".pi", "agent", "agents")
16 if err := os.MkdirAll(agentsDir, 0o755); err != nil {
17 t.Fatal(err)
18 }
19 if err := os.MkdirAll(piDir, 0o755); err != nil {
20 t.Fatal(err)
21 }
22 writeProfile(t, filepath.Join(agentsDir, "reviewer.md"), `---
23name: reviewer
24description: Read-only code reviewer
25tools: read
26model: openai-codex/gpt-5.6-luna
27thinking: max
28systemPromptMode: replace
29inheritProjectContext: false
30inheritSkills: false
31fastMode: false
32---
33Review the requested scope without editing it.
34`)
35 writeProfile(t, filepath.Join(piDir, "implementer.md"), `---
36name: implementer
37description: Primary implementation agent
38tools: [read, bash, edit, write]
39model: openai-codex/gpt-5.6-luna
40thinking: xhigh
41---
42Implement the requested change.
43`)
44
45 profiles, errs := Discover("", home)
46 if len(errs) != 0 {
47 t.Fatalf("Discover errors = %v", errs)
48 }
49 if len(profiles) != 1 {
50 t.Fatalf("profiles = %d, want 1: %#v", len(profiles), profiles)
51 }
52 if profiles[0].Name != "reviewer" {
53 t.Fatalf("profile = %q, want reviewer", profiles[0].Name)
54 }
55 reviewer := Find(profiles, "reviewer")
56 if reviewer == nil {
57 t.Fatal("reviewer profile missing")
58 }
59 if reviewer.SystemPromptMode != "replace" {
60 t.Fatalf("system prompt mode = %q, want replace", reviewer.SystemPromptMode)
61 }
62 if reviewer.Model != "openai-codex/gpt-5.6-luna" || reviewer.Thinking != "max" {
63 t.Fatalf("profile metadata = %#v", reviewer)
64 }
65 if reviewer.InheritProjectContext == nil || *reviewer.InheritProjectContext {
66 t.Fatalf("inherit project context = %#v, want false", reviewer.InheritProjectContext)
67 }
68 if reviewer.InheritSkills == nil || *reviewer.InheritSkills {
69 t.Fatalf("inherit skills = %#v, want false", reviewer.InheritSkills)
70 }
71 if reviewer.FastMode == nil || *reviewer.FastMode {
72 t.Fatalf("fast mode = %#v, want false", reviewer.FastMode)
73 }
74 if implementer := Find(profiles, "implementer"); implementer != nil {
75 t.Fatalf("Pi profile was discovered: %#v", implementer)
76 }
77}
78
79func TestDiscoverResolvesConfiguredRelativePathAgainstCWD(t *testing.T) {
80 first := t.TempDir()
81 second := t.TempDir()
82 t.Setenv("ZUT_AGENT_PROFILES", ".agents")
83 writeProfile(t, filepath.Join(first, ".agents", "reviewer.md"), `---
84name: reviewer
85description: First session profile
86---
87First.
88`)
89 writeProfile(t, filepath.Join(second, ".agents", "reviewer.md"), `---
90name: reviewer
91description: Second session profile
92---
93Second.
94`)
95
96 for _, tc := range []struct {
97 cwd string
98 description string
99 }{
100 {cwd: first, description: "First session profile"},
101 {cwd: second, description: "Second session profile"},
102 } {
103 profiles, errs := Discover(tc.cwd, t.TempDir())
104 if len(errs) != 0 {
105 t.Fatalf("Discover(%q) errors = %v", tc.cwd, errs)
106 }
107 if len(profiles) != 1 || profiles[0].Description != tc.description {
108 t.Fatalf("Discover(%q) = %#v, want %q", tc.cwd, profiles, tc.description)
109 }
110 }
111}
112
113func TestDiscoverConfiguredDirectoryWinsAndRejectsUnsafeNames(t *testing.T) {
114 configured := t.TempDir()
115 home := t.TempDir()
116 t.Setenv("ZUT_AGENT_PROFILES", configured)
117 writeProfile(t, filepath.Join(configured, "reviewer.md"), `---
118name: reviewer
119description: Configured reviewer
120---
121Configured instructions.
122`)
123 writeProfile(t, filepath.Join(filepath.Join(home, ".agents", "agents"), "reviewer.md"), `---
124name: reviewer
125description: Global reviewer
126---
127Global instructions.
128`)
129 writeProfile(t, filepath.Join(configured, "unsafe.md"), `---
130name: ../unsafe
131description: Should not load
132---
133No.
134`)
135
136 profiles, errs := Discover("", home)
137 if len(errs) != 0 {
138 t.Fatalf("Discover errors = %v", errs)
139 }
140 if len(profiles) != 1 || profiles[0].Description != "Configured reviewer" {
141 t.Fatalf("configured precedence = %#v", profiles)
142 }
143}
144
145func TestLoadRejectsUnclosedFrontmatter(t *testing.T) {
146 path := filepath.Join(t.TempDir(), "profile.md")
147 if err := os.WriteFile(path, []byte("---\nname: reviewer\nInstructions without a closing delimiter.\n"), 0o600); err != nil {
148 t.Fatal(err)
149 }
150 if _, err := load(path, "test"); err == nil || !strings.Contains(err.Error(), "missing closing delimiter") {
151 t.Fatalf("load error = %v, want missing closing delimiter", err)
152 }
153}
154
155func TestLoadRejectsInvalidClosedSchemaMetadata(t *testing.T) {
156 cases := []struct {
157 name string
158 field string
159 }{
160 {name: "invalid-thinking", field: "thinking: extreme"},
161 {name: "invalid-reasoning", field: "reasoning: extreme"},
162 {name: "qualified-model-with-provider", field: "provider: openai\nmodel: openai-codex/gpt-5"},
163 {name: "invalid-prompt-mode", field: "systemPromptMode: merge"},
164 {name: "invalid-project-context", field: "inheritProjectContext: sometimes"},
165 {name: "invalid-skills", field: "inheritSkills: sometimes"},
166 {name: "invalid-fast-mode", field: "fastMode: sometimes"},
167 }
168 for _, tc := range cases {
169 t.Run(tc.name, func(t *testing.T) {
170 path := filepath.Join(t.TempDir(), "profile.md")
171 writeProfile(t, path, fmt.Sprintf("---\nname: test\n%s\n---\nInstructions.\n", tc.field))
172 if _, err := load(path, "test"); err == nil {
173 t.Fatalf("load succeeded for invalid metadata %q", tc.field)
174 }
175 })
176 }
177}
178
179func TestLoadIgnoresRemovedBudgetMetadata(t *testing.T) {
180 path := filepath.Join(t.TempDir(), "profile.md")
181 writeProfile(t, path, "---\nname: reviewer\nbudgetRatio: 0.6\nbudgetTokens: 20000\n---\nInstructions.\n")
182 if _, err := load(path, "test"); err != nil {
183 t.Fatalf("load removed budget metadata: %v", err)
184 }
185}
186
187func TestProfileModelSelection(t *testing.T) {
188 profile := &Profile{Model: "openrouter/anthropic/claude-sonnet"}
189 provider, model := profile.ModelSelection()
190 if provider != "openrouter" || model != "anthropic/claude-sonnet" {
191 t.Fatalf("selection = (%q, %q)", provider, model)
192 }
193
194 profile = &Profile{Provider: "openai", Model: "gpt-5"}
195 provider, model = profile.ModelSelection()
196 if provider != "openai" || model != "gpt-5" {
197 t.Fatalf("explicit selection = (%q, %q)", provider, model)
198 }
199}
200
201func TestProfileToolsPreserveDeclarationAndResolve(t *testing.T) {
202 dir := t.TempDir()
203 writeProfile(t, filepath.Join(dir, "absent.md"), "---\nname: absent\n---\nInstructions.\n")
204 writeProfile(t, filepath.Join(dir, "empty.md"), "---\nname: empty\ntools: []\n---\nInstructions.\n")
205 writeProfile(t, filepath.Join(dir, "listed.md"), "---\nname: listed\ntools: [read, bash]\n---\nInstructions.\n")
206
207 for _, tc := range []struct {
208 name string
209 declared bool
210 want []string
211 }{
212 {name: "absent", declared: false, want: []string{"read", "bash", "lsp"}},
213 {name: "empty", declared: true, want: []string{}},
214 {name: "listed", declared: true, want: []string{"read", "bash"}},
215 } {
216 t.Run(tc.name, func(t *testing.T) {
217 profile, err := load(filepath.Join(dir, tc.name+".md"), "test")
218 if err != nil {
219 t.Fatal(err)
220 }
221 if profile.ToolsDeclared != tc.declared {
222 t.Fatalf("ToolsDeclared = %v, want %v", profile.ToolsDeclared, tc.declared)
223 }
224 got, err := ResolveProfileTools(profile, []string{"read", "bash", "lsp"}, func(name string) bool { return name != "lsp" })
225 if err != nil {
226 t.Fatal(err)
227 }
228 if strings.Join(got, ",") != strings.Join(tc.want, ",") {
229 t.Fatalf("resolved tools = %#v, want %#v", got, tc.want)
230 }
231 })
232 }
233}
234
235func TestResolveProfileToolsIgnoresUnknownAndDeniedNames(t *testing.T) {
236 profile := &Profile{Name: "reviewer", ToolsDeclared: true, Tools: []string{"read", "grep", "bash", "tasked_phases"}}
237 got, err := ResolveProfileTools(profile, []string{"read", "bash"}, func(name string) bool { return name != "bash" })
238 if err != nil {
239 t.Fatal(err)
240 }
241 if want := []string{"read"}; strings.Join(got, ",") != strings.Join(want, ",") {
242 t.Fatalf("resolved tools = %#v, want %#v", got, want)
243 }
244}
245
246func TestSystemPromptAddendumIsCompactAndDoesNotExposeBodyOrPath(t *testing.T) {
247 profiles := []*Profile{{
248 Name: "reviewer",
249 Description: "Read-only\nreviewer",
250 SystemPrompt: "secret instructions that belong only to the child",
251 Model: "openai-codex/gpt-5",
252 Thinking: "max",
253 FastMode: boolPtr(false),
254 Tools: []string{"read", "bash"},
255 Path: "/private/profile.md",
256 }}
257 got := SystemPromptAddendum(profiles)
258 for _, want := range []string{"[subagents_list]", "[/subagents_list]", "reviewer", "Read-only reviewer", "model=openai-codex/gpt-5", "thinking=max", "fastMode=false"} {
259 if !strings.Contains(got, want) {
260 t.Fatalf("addendum missing %q:\n%s", want, got)
261 }
262 }
263 for _, unwanted := range []string{"secret instructions", "/private/profile.md", "\nreviewer"} {
264 if strings.Contains(got, unwanted) {
265 t.Fatalf("addendum contains %q:\n%s", unwanted, got)
266 }
267 }
268}
269
270func boolPtr(value bool) *bool { return &value }
271
272func writeProfile(t *testing.T, path, content string) {
273 t.Helper()
274 if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
275 t.Fatal(err)
276 }
277 if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
278 t.Fatal(err)
279 }
280}