johannSoCodeyPublic

Phase 2: glob and grep

Given only read_file, the agent had no way to answer "what does main.go
do?" in a repo with no main.go at the root except to guess paths. A live
run spent three turns and nine reads, six of them misses, on exactly that.
glob("main.go") answers it in one call.

grep shells out to ripgrep when present and walks in pure Go otherwise.
Matches stay structured until output and are sorted by path and line, so
both engines return byte-identical results: ripgrep walks in parallel and
its file order is nondeterministic, which would otherwise surface as eval
noise and as prompt cache misses depending on whether the machine has rg.

Both prune .git, node_modules and friends, cap at 100 results with a count
of what was suppressed, and skip binary files. A bare glob pattern with no
slash matches the file name at any depth, since that is what "*.go" is
always meant to mean.

The system prompt now says not to guess paths, which is only honest advice
now that there is something to guess with.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Browse Files

Jjonicommitted last month1 parent ad96f09commitdb315e4

Showing 8 changed files with 663 additions and 8 deletions.

+2−0cmd/harness/main.goView File

@@ -74,6 +74,8 @@ func run() error {
74	74	state := agent.NewState()
75	75	reg := tools.NewRegistry(log).Register(
76	76	tools.NewRead(root, state),
	77	+ tools.NewGlob(root),
	78	+ tools.NewGrep(root),
77	79	)
78	80
79	81	render := &ui.Renderer{W: os.Stdout, Verbose: *verbose}

+1−0go.modView File

@@ -6,6 +6,7 @@ require github.com/invopop/jsonschema v0.14.0
6	6
7	7	require (
8	8	github.com/bahlo/generic-list-go v0.2.0 // indirect
	9	+ github.com/bmatcuk/doublestar/v4 v4.10.0 // indirect
9	10	github.com/buger/jsonparser v1.1.2 // indirect
10	11	github.com/pb33f/ordered-map/v2 v2.3.1 // indirect
11	12	go.yaml.in/yaml/v4 v4.0.0-rc.2 // indirect

+2−0go.sumView File

@@ -1,5 +1,7 @@
1	1	github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
2	2	github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
	3	+ github.com/bmatcuk/doublestar/v4 v4.10.0 h1:zU9WiOla1YA122oLM6i4EXvGW62DvKZVxIe6TYWexEs=
	4	+ github.com/bmatcuk/doublestar/v4 v4.10.0/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
3	5	github.com/buger/jsonparser v1.1.2 h1:frqHqw7otoVbk5M8LlE/L7HTnIq2v9RX6EJ48i9AxJk=
4	6	github.com/buger/jsonparser v1.1.2/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
5	7	github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

+8−3internal/agent/loop.goView File

@@ -24,9 +24,14 @@ var ErrMaxTurns = errors.New("turn limit reached")
24	24	// every single request.
25	25	const defaultSystem = `You are a coding agent operating on a local repository through tools.
26	26
27		- Work by reading before you act. Prefer reading the specific file or region you
28		- need over dumping whole directories. When you change something, verify it by
29		- running the project's own tests rather than asserting that it works.
	27	+ Never guess at file paths. If you do not know where something lives, find it
	28	+ with glob or grep first — one search costs less than a run of wrong guesses,
	29	+ and a wrong guess tells you nothing about where the file actually is. Once you
	30	+ know the path, read the specific file or region you need rather than dumping
	31	+ whole directories.
	32	+
	33	+ When you change something, verify it by running the project's own tests rather
	34	+ than asserting that it works.
30	35
31	36	If a tool returns an error, read it: the error text usually says exactly what to
32	37	do differently. Do not repeat a failing call unchanged.

+150−0internal/tools/glob.goaddedView File

++ package tools
++ import (
++ 	"context"
++ 	"fmt"
++ 	"io/fs"
++ 	"os"
++ 	"path/filepath"
++ 	"sort"
++ 	"strings"
++ 	"github.com/bmatcuk/doublestar/v4"
++ )
++ // maxResults caps how many paths or matches a search tool returns. The count of
++ // what was suppressed goes back too, so the model knows to narrow the pattern
++ // rather than assume it has seen everything.
++ const maxResults = 100
++ // skipDirs are never descended into. They are where a repo keeps things the
++ // agent did not write and should not be reading by accident.
++ var skipDirs = map[string]bool{
++ 	".git": true, ".hg": true, ".svn": true,
++ 	"node_modules": true, "vendor": true, "target": true,
++ 	".venv": true, "venv": true, "__pycache__": true,
++ 	".harness": true, ".next": true, ".cache": true,
++ }
++ // GlobArgs is the glob input.
++ type GlobArgs struct {
++ 	Pattern string `json:"pattern" jsonschema:"description=Glob pattern. ** matches across directories; a pattern with no slash is matched against the file name at any depth"`
++ 	Path    string `json:"path,omitempty" jsonschema:"description=Directory to search under; defaults to the working root"`
++ }
++ // NewGlob builds the glob tool.
++ func NewGlob(root string) Tool {
++ 	return New("glob", strings.TrimSpace(`
++ Find files by name. Returns paths relative to the working root, most recently
++ modified first. "*.go" matches Go files at any depth; "internal/**/*_test.go"
++ matches within a subtree. Use this instead of guessing where a file lives.`),
++ 		func(ctx context.Context, in GlobArgs) (string, error) {
++ 			if in.Pattern == "" {
++ 				return "", fmt.Errorf("pattern is required")
++ 			}
++ 			base := resolveBase(root, in.Path)
++ 			if info, err := os.Stat(base); err != nil || !info.IsDir() {
++ 				return "", fmt.Errorf("no such directory: %s", displayPath(root, base))
++ 			}
++ 			type hit struct {
++ 				path string
++ 				mod  int64
++ 			}
++ 			var hits []hit
++ 			var scanned int
++ 			err := filepath.WalkDir(base, func(p string, d fs.DirEntry, err error) error {
++ 				if err != nil {
++ 					return nil // unreadable entries are skipped, not fatal
++ 				}
++ 				if ctx.Err() != nil {
++ 					return ctx.Err()
++ 				}
++ 				if d.IsDir() {
++ 					if p != base && shouldSkip(d.Name(), in.Pattern) {
++ 						return fs.SkipDir
++ 					}
++ 					return nil
++ 				}
++ 				scanned++
++ 				rel, relErr := filepath.Rel(base, p)
++ 				if relErr != nil {
++ 					return nil
++ 				}
++ 				if !matchPath(in.Pattern, rel) {
++ 					return nil
++ 				}
++ 				var mod int64
++ 				if info, statErr := d.Info(); statErr == nil {
++ 					mod = info.ModTime().UnixNano()
++ 				}
++ 				hits = append(hits, hit{path: displayPath(root, p), mod: mod})
++ 				return nil
++ 			})
++ 			if err != nil {
++ 				return "", err
++ 			}
++ 			if len(hits) == 0 {
++ 				return fmt.Sprintf("No files match %q under %s (%d files scanned).",
++ 					in.Pattern, displayPath(root, base), scanned), nil
++ 			}
++ 			// Most recently modified first: in a repo being worked on, that is
++ 			// usually the file the task is about.
++ 			sort.Slice(hits, func(i, j int) bool {
++ 				if hits[i].mod != hits[j].mod {
++ 					return hits[i].mod > hits[j].mod
++ 				}
++ 				return hits[i].path < hits[j].path
++ 			})
++ 			var b strings.Builder
++ 			shown := hits
++ 			if len(shown) > maxResults {
++ 				shown = shown[:maxResults]
++ 			}
++ 			for _, h := range shown {
++ 				b.WriteString(h.path)
++ 				b.WriteByte('\n')
++ 			}
++ 			if len(hits) > len(shown) {
++ 				fmt.Fprintf(&b, "\n(%d of %d shown; narrow the pattern to see the rest)", len(shown), len(hits))
++ 			}
++ 			return b.String(), nil
++ 		})
++ }
++ // matchPath applies the pattern to the relative path, and — when the pattern
++ // names no directory — also to the bare file name, so "*.go" finds Go files at
++ // any depth rather than only at the top level.
++ func matchPath(pattern, rel string) bool {
++ 	rel = filepath.ToSlash(rel)
++ 	if ok, err := doublestar.Match(pattern, rel); err == nil && ok {
++ 		return true
++ 	}
++ 	if !strings.Contains(pattern, "/") {
++ 		if ok, err := doublestar.Match(pattern, filepath.Base(rel)); err == nil && ok {
++ 			return true
++ 		}
++ 	}
++ 	return false
++ }
++ // shouldSkip prunes noise directories, unless the pattern explicitly names one.
++ func shouldSkip(name, pattern string) bool {
++ 	return skipDirs[name] && !strings.Contains(pattern, name)
++ }
++ // displayPath prefers a path relative to the working root: shorter to read and
++ // shorter in the context window.
++ func displayPath(root, p string) string {
++ 	if root == "" {
++ 		return p
++ 	}
++ 	rel, err := filepath.Rel(root, p)
++ 	if err != nil || strings.HasPrefix(rel, "..") {
++ 		return p
++ 	}
++ 	return filepath.ToSlash(rel)
++ }

+234−0internal/tools/grep.goaddedView File

++ package tools
++ import (
++ 	"bufio"
++ 	"bytes"
++ 	"context"
++ 	"fmt"
++ 	"io/fs"
++ 	"os"
++ 	"os/exec"
++ 	"path/filepath"
++ 	"regexp"
++ 	"sort"
++ 	"strconv"
++ 	"strings"
++ )
++ // ripgrep is the path to rg, or empty when it is not installed. It is a
++ // variable so tests can exercise the pure-Go fallback on a machine that has rg.
++ var ripgrep = func() string {
++ 	p, err := exec.LookPath("rg")
++ 	if err != nil {
++ 		return ""
++ 	}
++ 	return p
++ }()
++ // match is one hit, kept structured until output so results from either engine
++ // can be sorted the same way. ripgrep walks in parallel and returns files in a
++ // nondeterministic order; without this, the same search would produce different
++ // bytes on different machines, which would show up as eval noise and as prompt
++ // cache misses.
++ type match struct {
++ 	path string
++ 	line int
++ 	text string
++ }
++ func (m match) String() string { return fmt.Sprintf("%s:%d: %s", m.path, m.line, m.text) }
++ func sortMatches(ms []match) {
++ 	sort.Slice(ms, func(i, j int) bool {
++ 		if ms[i].path != ms[j].path {
++ 			return ms[i].path < ms[j].path
++ 		}
++ 		return ms[i].line < ms[j].line
++ 	})
++ }
++ // GrepArgs is the grep input.
++ type GrepArgs struct {
++ 	Pattern    string `json:"pattern" jsonschema:"description=Regular expression to search for"`
++ 	Path       string `json:"path,omitempty" jsonschema:"description=File or directory to search; defaults to the working root"`
++ 	Glob       string `json:"glob,omitempty" jsonschema:"description=Only search files matching this glob, e.g. *.go"`
++ 	IgnoreCase bool   `json:"ignore_case,omitempty" jsonschema:"description=Match case-insensitively"`
++ }
++ // NewGrep builds the grep tool. It shells out to ripgrep when available and
++ // falls back to a pure-Go walk otherwise; the output format is the same either
++ // way, so the model cannot tell which ran.
++ func NewGrep(root string) Tool {
++ 	return New("grep", strings.TrimSpace(`
++ Search file contents by regular expression. Returns "path:line: text" for each
++ match. Narrow with glob (e.g. "*.go") or path. This is how you find code you
++ have not been shown — reach for it before guessing at file names.`),
++ 		func(ctx context.Context, in GrepArgs) (string, error) {
++ 			if in.Pattern == "" {
++ 				return "", fmt.Errorf("pattern is required")
++ 			}
++ 			re, err := compile(in.Pattern, in.IgnoreCase)
++ 			if err != nil {
++ 				return "", err
++ 			}
++ 			base := resolveBase(root, in.Path)
++ 			if _, err := os.Stat(base); err != nil {
++ 				return "", fmt.Errorf("no such file or directory: %s", displayPath(root, base))
++ 			}
++ 			var matches []match
++ 			if ripgrep != "" {
++ 				matches, err = grepRipgrep(ctx, root, base, in)
++ 			} else {
++ 				matches, err = grepWalk(ctx, root, base, in, re)
++ 			}
++ 			if err != nil {
++ 				return "", err
++ 			}
++ 			if len(matches) == 0 {
++ 				where := displayPath(root, base)
++ 				if in.Glob != "" {
++ 					where += " matching " + in.Glob
++ 				}
++ 				return fmt.Sprintf("No matches for %q in %s.", in.Pattern, where), nil
++ 			}
++ 			sortMatches(matches)
++ 			shown := matches
++ 			if len(shown) > maxResults {
++ 				shown = shown[:maxResults]
++ 			}
++ 			lines := make([]string, 0, len(shown))
++ 			for _, m := range shown {
++ 				lines = append(lines, m.String())
++ 			}
++ 			out := strings.Join(lines, "\n")
++ 			if len(matches) > len(shown) {
++ 				out += fmt.Sprintf("\n\n(%d of %d matches shown; narrow the pattern, path or glob to see the rest)",
++ 					len(shown), len(matches))
++ 			}
++ 			return out, nil
++ 		})
++ }
++ // compile validates the pattern up front so a bad regex comes back as a clear
++ // error the model can fix, rather than as ripgrep's exit status.
++ func compile(pattern string, ignoreCase bool) (*regexp.Regexp, error) {
++ 	if ignoreCase {
++ 		pattern = "(?i)" + pattern
++ 	}
++ 	re, err := regexp.Compile(pattern)
++ 	if err != nil {
++ 		return nil, fmt.Errorf("invalid regular expression: %w", err)
++ 	}
++ 	return re, nil
++ }
++ func grepRipgrep(ctx context.Context, root, base string, in GrepArgs) ([]match, error) {
++ 	args := []string{"--line-number", "--no-heading", "--color=never", "--no-messages"}
++ 	if in.IgnoreCase {
++ 		args = append(args, "--ignore-case")
++ 	}
++ 	if in.Glob != "" {
++ 		args = append(args, "--glob", in.Glob)
++ 	}
++ 	for dir := range skipDirs {
++ 		args = append(args, "--glob", "!"+dir+"/")
++ 	}
++ 	args = append(args, "--regexp", in.Pattern, base)
++ 	cmd := exec.CommandContext(ctx, ripgrep, args...)
++ 	out, err := cmd.Output()
++ 	if err != nil {
++ 		// rg exits 1 when there are simply no matches; that is not a failure.
++ 		var exitErr *exec.ExitError
++ 		if !bytes.Contains(out, []byte(":")) && errorsAs(err, &exitErr) && exitErr.ExitCode() == 1 {
++ 			return nil, nil
++ 		}
++ 		if ctx.Err() != nil {
++ 			return nil, ctx.Err()
++ 		}
++ 		if !errorsAs(err, &exitErr) {
++ 			return nil, fmt.Errorf("grep: %w", err)
++ 		}
++ 	}
++ 	var matches []match
++ 	sc := bufio.NewScanner(bytes.NewReader(out))
++ 	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
++ 	for sc.Scan() {
++ 		if m, ok := parseRipgrepLine(root, sc.Text()); ok {
++ 			matches = append(matches, m)
++ 		}
++ 	}
++ 	return matches, nil
++ }
++ // parseRipgrepLine splits "abs/path:12:text" into a match.
++ func parseRipgrepLine(root, line string) (match, bool) {
++ 	parts := strings.SplitN(line, ":", 3)
++ 	if len(parts) < 3 {
++ 		return match{}, false
++ 	}
++ 	n, err := strconv.Atoi(parts[1])
++ 	if err != nil {
++ 		return match{}, false
++ 	}
++ 	return match{path: displayPath(root, parts[0]), line: n, text: capLine(strings.TrimSpace(parts[2]))}, true
++ }
++ func grepWalk(ctx context.Context, root, base string, in GrepArgs, re *regexp.Regexp) ([]match, error) {
++ 	var matches []match
++ 	err := filepath.WalkDir(base, func(p string, d fs.DirEntry, err error) error {
++ 		if err != nil {
++ 			return nil
++ 		}
++ 		if ctx.Err() != nil {
++ 			return ctx.Err()
++ 		}
++ 		if d.IsDir() {
++ 			if p != base && shouldSkip(d.Name(), in.Glob) {
++ 				return fs.SkipDir
++ 			}
++ 			return nil
++ 		}
++ 		if in.Glob != "" {
++ 			rel, relErr := filepath.Rel(base, p)
++ 			if relErr != nil || !matchPath(in.Glob, rel) {
++ 				return nil
++ 			}
++ 		}
++ 		data, readErr := os.ReadFile(p)
++ 		if readErr != nil || isBinary(data) {
++ 			return nil
++ 		}
++ 		for i, line := range strings.Split(string(data), "\n") {
++ 			if re.MatchString(line) {
++ 				matches = append(matches, match{
++ 					path: displayPath(root, p),
++ 					line: i + 1,
++ 					text: capLine(strings.TrimSpace(line)),
++ 				})
++ 			}
++ 		}
++ 		return nil
++ 	})
++ 	return matches, err
++ }
++ // isBinary treats a NUL byte in the first block as the signal, which is what
++ // grep and ripgrep both do.
++ func isBinary(data []byte) bool {
++ 	if len(data) > 8000 {
++ 		data = data[:8000]
++ 	}
++ 	return bytes.IndexByte(data, 0) >= 0
++ }
++ func errorsAs(err error, target **exec.ExitError) bool {
++ 	e, ok := err.(*exec.ExitError)
++ 	if ok {
++ 		*target = e
++ 	}
++ 	return ok
++ }

+15−5internal/tools/read.goView File

@@ -98,16 +98,26 @@ func splitLines(s string) []string {
98	98	return lines
99	99	}
100	100
101		- // resolve anchors a relative path to root. The real path jail lands in Phase 6.
	101	+ // resolve anchors a relative path to root, requiring one. The real path jail
	102	+ // lands in Phase 6.
102	103	func resolve(root, path string) (string, error) {
103	104	if path == "" {
104	105	return "", fmt.Errorf("path is required")
105	106	}
106		- if filepath.IsAbs(path) {
107		- return filepath.Clean(path), nil
108		- }
	107	+ return resolveBase(root, path), nil
	108	+ }
	109	+
	110	+ // resolveBase is resolve for the search tools, where an omitted path means the
	111	+ // working root rather than an error.
	112	+ func resolveBase(root, path string) string {
109	113	if root == "" {
110	114	root = "."
111	115	}
112		- return filepath.Join(root, path), nil
	116	+ if path == "" {
	117	+ return root
	118	+ }
	119	+ if filepath.IsAbs(path) {
	120	+ return filepath.Clean(path)
	121	+ }
	122	+ return filepath.Join(root, path)
113	123	}

+251−0internal/tools/search_test.goaddedView File

++ package tools
++ import (
++ 	"context"
++ 	"encoding/json"
++ 	"os"
++ 	"path/filepath"
++ 	"strings"
++ 	"testing"
++ 	"time"
++ )
++ // searchRepo builds a small tree with the shapes that matter: nesting, a
++ // pruned directory, and a binary file.
++ func searchRepo(t *testing.T) string {
++ 	t.Helper()
++ 	dir := t.TempDir()
++ 	writeFile(t, dir, "go.mod", "module harness\n")
++ 	writeFile(t, dir, "cmd/harness/main.go", "package main\n\nfunc main() { run() }\n")
++ 	writeFile(t, dir, "internal/agent/loop.go", "package agent\n\nfunc Run() {}\n")
++ 	writeFile(t, dir, "internal/agent/loop_test.go", "package agent\n\nfunc TestRun(t *testing.T) {}\n")
++ 	writeFile(t, dir, "README.md", "# harness\n\nRun it.\n")
++ 	writeFile(t, dir, "node_modules/junk/index.js", "function run() {}\n")
++ 	writeFile(t, dir, ".git/config", "[core]\n\trun = true\n")
++ 	if err := os.WriteFile(filepath.Join(dir, "bin.dat"), []byte{0x00, 0x01, 'r', 'u', 'n'}, 0o644); err != nil {
++ 		t.Fatal(err)
++ 	}
++ 	return dir
++ }
++ func call(t *testing.T, tool Tool, args any) string {
++ 	t.Helper()
++ 	raw, err := json.Marshal(args)
++ 	if err != nil {
++ 		t.Fatal(err)
++ 	}
++ 	out, err := tool.Execute(context.Background(), raw)
++ 	if err != nil {
++ 		t.Fatalf("%s: %v", tool.Name(), err)
++ 	}
++ 	return out
++ }
++ func TestGlob(t *testing.T) {
++ 	dir := searchRepo(t)
++ 	tool := NewGlob(dir)
++ 	tests := []struct {
++ 		name     string
++ 		args     GlobArgs
++ 		want     []string
++ 		unwanted []string
++ 	}{
++ 		{
++ 			name:     "bare pattern matches at any depth",
++ 			args:     GlobArgs{Pattern: "*.go"},
++ 			want:     []string{"cmd/harness/main.go", "internal/agent/loop.go", "internal/agent/loop_test.go"},
++ 			unwanted: []string{"go.mod", "README.md"},
++ 		},
++ 		{
++ 			name:     "pattern with a slash is anchored to the subtree",
++ 			args:     GlobArgs{Pattern: "internal/**/*_test.go"},
++ 			want:     []string{"internal/agent/loop_test.go"},
++ 			unwanted: []string{"cmd/harness/main.go"},
++ 		},
++ 		{
++ 			name:     "path narrows the search",
++ 			args:     GlobArgs{Pattern: "*.go", Path: "cmd"},
++ 			want:     []string{"cmd/harness/main.go"},
++ 			unwanted: []string{"internal/agent/loop.go"},
++ 		},
++ 		{
++ 			name:     "noise directories are pruned",
++ 			args:     GlobArgs{Pattern: "*.js"},
++ 			unwanted: []string{"node_modules"},
++ 		},
++ 		{
++ 			name: "exact name",
++ 			args: GlobArgs{Pattern: "go.mod"},
++ 			want: []string{"go.mod"},
++ 		},
++ 	}
++ 	for _, tc := range tests {
++ 		t.Run(tc.name, func(t *testing.T) {
++ 			out := call(t, tool, tc.args)
++ 			for _, w := range tc.want {
++ 				if !strings.Contains(out, w) {
++ 					t.Errorf("missing %q in:\n%s", w, out)
++ 				}
++ 			}
++ 			for _, u := range tc.unwanted {
++ 				if strings.Contains(out, u) {
++ 					t.Errorf("unexpected %q in:\n%s", u, out)
++ 				}
++ 			}
++ 		})
++ 	}
++ }
++ func TestGlobNoMatchesSaysSoUsefully(t *testing.T) {
++ 	out := call(t, NewGlob(searchRepo(t)), GlobArgs{Pattern: "*.rs"})
++ 	if !strings.Contains(out, "No files match") || !strings.Contains(out, "files scanned") {
++ 		t.Errorf("a miss should report the scan, got: %s", out)
++ 	}
++ }
++ func TestGlobSortsNewestFirst(t *testing.T) {
++ 	dir := searchRepo(t)
++ 	newest := filepath.Join(dir, "internal/agent/loop.go")
++ 	if err := os.Chtimes(newest, timeNow(), timeNow()); err != nil {
++ 		t.Fatal(err)
++ 	}
++ 	out := call(t, NewGlob(dir), GlobArgs{Pattern: "*.go"})
++ 	if first := strings.SplitN(out, "\n", 2)[0]; first != "internal/agent/loop.go" {
++ 		t.Errorf("first result = %q, want the most recently modified file", first)
++ 	}
++ }
++ func TestGlobErrors(t *testing.T) {
++ 	tool := NewGlob(searchRepo(t))
++ 	for _, tc := range []struct {
++ 		name, want string
++ 		args       GlobArgs
++ 	}{
++ 		{name: "no pattern", want: "pattern is required", args: GlobArgs{}},
++ 		{name: "bad path", want: "no such directory", args: GlobArgs{Pattern: "*.go", Path: "nowhere"}},
++ 	} {
++ 		t.Run(tc.name, func(t *testing.T) {
++ 			raw, _ := json.Marshal(tc.args)
++ 			if _, err := tool.Execute(context.Background(), raw); err == nil || !strings.Contains(err.Error(), tc.want) {
++ 				t.Errorf("error = %v, want %q", err, tc.want)
++ 			}
++ 		})
++ 	}
++ }
++ func TestGrep(t *testing.T) {
++ 	dir := searchRepo(t)
++ 	tests := []struct {
++ 		name     string
++ 		args     GrepArgs
++ 		want     []string
++ 		unwanted []string
++ 	}{
++ 		{
++ 			name: "finds a symbol with path and line number",
++ 			args: GrepArgs{Pattern: `func Run\(\)`},
++ 			want: []string{"internal/agent/loop.go:3: func Run() {}"},
++ 		},
++ 		{
++ 			name:     "glob narrows to a file type",
++ 			args:     GrepArgs{Pattern: "Run", Glob: "*.md"},
++ 			want:     []string{"README.md"},
++ 			unwanted: []string{".go:"},
++ 		},
++ 		{
++ 			name:     "case sensitive by default",
++ 			args:     GrepArgs{Pattern: "RUN"},
++ 			unwanted: []string{".go:", ".md:"},
++ 		},
++ 		{
++ 			name: "ignore_case",
++ 			args: GrepArgs{Pattern: "RUN", IgnoreCase: true},
++ 			want: []string{"README.md"},
++ 		},
++ 		{
++ 			name:     "noise directories and binaries are skipped",
++ 			args:     GrepArgs{Pattern: "run"},
++ 			unwanted: []string{"node_modules", ".git/config", "bin.dat"},
++ 		},
++ 		{
++ 			name: "path narrows the search",
++ 			args: GrepArgs{Pattern: "package", Path: "cmd"},
++ 			want: []string{"cmd/harness/main.go"},
++ 		},
++ 	}
++ 	// Both engines must produce identical output, or eval numbers would depend
++ 	// on whether the machine has ripgrep installed.
++ 	for _, engine := range []string{"ripgrep", "walk"} {
++ 		t.Run(engine, func(t *testing.T) {
++ 			if engine == "walk" {
++ 				saved := ripgrep
++ 				ripgrep = ""
++ 				t.Cleanup(func() { ripgrep = saved })
++ 			} else if ripgrep == "" {
++ 				t.Skip("ripgrep not installed")
++ 			}
++ 			tool := NewGrep(dir)
++ 			for _, tc := range tests {
++ 				t.Run(tc.name, func(t *testing.T) {
++ 					out := call(t, tool, tc.args)
++ 					for _, w := range tc.want {
++ 						if !strings.Contains(out, w) {
++ 							t.Errorf("missing %q in:\n%s", w, out)
++ 						}
++ 					}
++ 					for _, u := range tc.unwanted {
++ 						if strings.Contains(out, u) {
++ 							t.Errorf("unexpected %q in:\n%s", u, out)
++ 						}
++ 					}
++ 				})
++ 			}
++ 		})
++ 	}
++ }
++ func TestGrepEnginesAgree(t *testing.T) {
++ 	if ripgrep == "" {
++ 		t.Skip("ripgrep not installed")
++ 	}
++ 	dir := searchRepo(t)
++ 	withRG := call(t, NewGrep(dir), GrepArgs{Pattern: "func"})
++ 	saved := ripgrep
++ 	ripgrep = ""
++ 	defer func() { ripgrep = saved }()
++ 	withWalk := call(t, NewGrep(dir), GrepArgs{Pattern: "func"})
++ 	if withRG != withWalk {
++ 		t.Errorf("engines disagree:\nripgrep:\n%s\nwalk:\n%s", withRG, withWalk)
++ 	}
++ }
++ func TestGrepNoMatchIsNotAnError(t *testing.T) {
++ 	for _, engine := range []string{"ripgrep", "walk"} {
++ 		t.Run(engine, func(t *testing.T) {
++ 			if engine == "walk" {
++ 				saved := ripgrep
++ 				ripgrep = ""
++ 				t.Cleanup(func() { ripgrep = saved })
++ 			} else if ripgrep == "" {
++ 				t.Skip("ripgrep not installed")
++ 			}
++ 			out := call(t, NewGrep(searchRepo(t)), GrepArgs{Pattern: "zzzznotpresent"})
++ 			if !strings.Contains(out, "No matches") {
++ 				t.Errorf("want an explicit no-match message, got %q", out)
++ 			}
++ 		})
++ 	}
++ }
++ func TestGrepInvalidRegexIsReported(t *testing.T) {
++ 	raw, _ := json.Marshal(GrepArgs{Pattern: "func ("})
++ 	_, err := NewGrep(searchRepo(t)).Execute(context.Background(), raw)
++ 	if err == nil || !strings.Contains(err.Error(), "invalid regular expression") {
++ 		t.Errorf("error = %v, want a regex error the model can fix", err)
++ 	}
++ }
++ func timeNow() time.Time { return time.Now().Add(time.Hour) }