Girder

Answer a question about this codebase by traversing the semantic graph: what calls a function, what it calls, what a change to it would affect, and what a node is. No code is generated and no model is consulted — this is graph traversal, so it finds callers that grep cannot (and does not invent ones that do not exist). Prefer it over grepping for call sites.

Locate the declarations of an exact identifier: every function or type with that name, and nothing else. This is not a substring or full-text search — it will not match call sites, comments, or strings, which is why it is drastically cheaper than grep for the question "where is X defined?" (measured 97.98% fewer bytes across ten identifiers, docs/names-cost.md). Use `search_code` instead when you only know roughly what you are after.

Return the source of specific functions without the surrounding file. Pin exact node paths with `nodes`, or describe what you want in `intent` to let concept search choose. Measured 97.85% fewer bytes than reading the whole file across ten nodes, and cheaper on all ten (docs/context-vs-read-cost.md). Prefer this over opening a file to read one function. Use `find_definition` or `search_code` first if you do not know the node path.

Name the tests that can reach what changed, detected from the git diff or from explicit node paths. One test name per line, ready to pass to a test runner. Per the frozen classification policy's own wording, empty output WITH Unknown boundaries never means nothing needs running — set `classified: true` or check stderr for boundary count before trusting an empty result; it does NOT mean run everything regardless. This selection is a conservative union: it is known to over-select unrelated tests and, for any test not backed by a resolved call, to include it rather than risk missing one reached only through dynamic dispatch — so a full run remains the authority before you claim a change is safe. Set `classified: true` to see *why* each test was selected instead of one flat list: which tests are reachable through a resolved call with no alternate target (`must`), which are reachable only through an unresolved alternative like a trait object, interface, or override (`may`), and which are reachable only through a boundary this graph could not resolve at all — reflection, an unexpanded macro, an unproven dispatch — and are therefore included solely to avoid a silent miss (`unknown`).

Answer "what am I about to touch and what does it reach" for one starting point in a single round trip: its source, direct callers and callees (to `depth`, default 1, capped at 2), the tests that cover it, and its impact set — everything `get_source` + `ask_codebase` (callers, callees, and impact questions) + `impacted_tests` would answer across several separate calls, bundled into one. Prefer this over chaining those tools when orienting in unfamiliar code. Pin `nodes` when you know the exact path; use `intent` only when you do not, and check the returned `confidence` — a `"low"` value means the match is a guess (natural-language search on this codebase resolves correctly only part of the time, see docs/description-search-accuracy.md), not a verified answer, and `find_definition` or `search_code` first is the safer path. Large caller/callee/test/impact sections report a true count and are capped rather than silently dropped. Each node also carries `classification`: the same tests as `tests`, split into `must` (reachable through a resolved call with no alternate target), `may` (reachable only through an unresolved alternative like a trait object, interface, or override), and `unknown` (reachable only through a boundary this graph could not resolve at all), plus the unresolved `boundaries` that produced any `may`/`unknown` result — see docs/call-classification-policy.md.

Report what changed in this working tree as semantics rather than text: which functions and types were added, modified, or removed, and (in full mode) what they affect and which changes lack test coverage. Complements a text diff instead of replacing it — use it to see the blast radius of a change you or someone else just made. Coverage gaps it reports are advisory.

Rank functions and types by relevance to a natural-language description, returning the top matches as scores with node paths. Use this when you do not know the name of what you want; use `find_definition` when you do. Feed the node paths it returns to `get_source`.