Vanguard

Delegate codebase searches to GLM-5 via background subagent. You remain free to do other work and receive automatic notification when complete.

When to Use

• Finding code patterns across the codebase
• Locating implementations of specific features
• Searching for function/class/variable definitions
• Exploring unfamiliar codebases
• Any search that might require multiple grep/rg commands

When NOT to Use

• You already know the file path (use Read directly)
• Simple single-file search (use Grep directly)
• Quick lookups that take < 5 seconds

Workflow

1. User requests a search (e.g., "find where authentication is implemented")
2. Launch background subagent with GLM delegation
3. Continue with other tasks or conversation
4. Receive notification when search completes
5. Subagent verifies GLM results and adds Reviewer's Note
6. Report results with verification notes to main agent
7. Main agent discusses any discrepancies with user

Implementation

Use the Task tool with these parameters:

Task(
    description="GLM quick search: {brief description}",
    subagent_type="general-purpose",
    run_in_background=true,
    max_turns=30,  # GLM call + verification reads + summarization
    prompt="""
Call the delegate_to_glm MCP tool with:

task: "{search_instructions}"
working_dir: "{project_root}"

Search instructions should include:
- Use rg (ripgrep) for fast searching
- Specific patterns or keywords to find
- File types or directories to focus on
- Output format: file:line with brief context

IMPORTANT: After GLM returns results, you MUST verify them and add Reviewer's Note:

1. For each reported file:line, use Read tool to check the actual content
2. Confirm the code/pattern GLM described actually exists at that location
3. DO NOT exclude incorrect findings - flag them in Reviewer's Note instead

Report format:

Search Results

[GLM's findings with file:line references]

Reviewer's Note

Verified ✓

• file.go:42 - Confirmed: AuthMiddleware exists here
• handler.go:15 - Confirmed: Login handler implementation

Issues Found ⚠️

• service.go:88 - GLM reported AuthService but actual is UserService
• utils.go:20 - File exists but function is at line 45, not line 20

Not Verified

• [Any items not checked due to time/scope]

Main agent will discuss discrepancies with user and decide on follow-up.
"""
)

Example Prompts

Find feature implementation

Task(
    description="GLM search: authentication",
    subagent_type="general-purpose",
    run_in_background=true,
    max_turns=30,
    prompt="""
Call delegate_to_glm MCP tool:

task: "Find where user authentication is implemented in this Go project.
Use rg to search for:
- rg -n 'func.*Auth|func.*Login|func.*Verify' --type go
- rg -n 'middleware.*auth' --type go -i

Return file:line for each match."

working_dir: {project_root}

After GLM returns, verify the top 3-5 results and add Reviewer's Note:
- Read each file at the reported line
- Confirm the authentication logic exists there
- Flag any discrepancies in Reviewer's Note (don't exclude them)

Include Reviewer's Note section with Verified/Issues Found/Not Verified.
"""
)

Find Clean Architecture violations

Task(
    description="GLM search: architecture violations",
    subagent_type="general-purpose",
    run_in_background=true,
    max_turns=30,
    prompt="""
Call delegate_to_glm MCP tool:

task: "Check for Clean Architecture violations.
Use rg to find domain layer importing infrastructure:
- rg -n 'import.*infrastructure|protocol|data' internal/feature/*/domain/ --type go

Report any violations as file:line, or 'No violations found'."

working_dir: {project_root}

If GLM reports violations, verify each one and add Reviewer's Note:
- Read the import block of each reported file
- Confirm it actually imports from infrastructure/protocol/data
- Flag false positives (comments, string literals) in Issues Found section
- Don't exclude anything - let main agent decide with user
"""
)

Find TODO/FIXME comments

Task(
    description="GLM search: TODOs",
    subagent_type="general-purpose",
    run_in_background=true,
    max_turns=30,
    prompt="""
Call delegate_to_glm MCP tool:

task: "Find all TODO and FIXME comments in the codebase.
Use: rg -n 'TODO|FIXME' --type go --type proto

Return file:line for each match."

working_dir: {project_root}

Verify a sample of results (at least 3-5) and add Reviewer's Note:
- Read the actual lines to confirm they are real TODO/FIXME comments
- Flag any false positives in Issues Found section
- Include Not Verified section for items not checked
"""
)

Tips

• Always use rg (ripgrep) instead of grep for speed
• Specify --type to limit search scope
• Use -n flag to include line numbers
• For large results, ask GLM to summarize top findings

Configuration

Notes

• Results come via automatic notification (no polling needed)
• GLM uses bash, readfile, writefile internally
• For sync (blocking) searches, use delegatetoglm directly without subagent
• Verification is critical: GLM may hallucinate or misinterpret results
• Always add Reviewer's Note: Flag issues instead of excluding them
• Main agent can discuss discrepancies with user and decide on follow-up searches
• Consistent with 17th-task-architect verification approach