Search indexed source and docs. score is a blended relevance score combining BM25 lexical rank and (when an embedding model is installed) vector cosine similarity; pass explain=true for the per-component breakdown. Each hit carries retrieval_mode ('lexical', 'vector', or 'hybrid') so you can tell whether embeddings contributed without explain. Hits are validated against current source. Falls back to BM25-only (every hit 'lexical') when no embedding model is present. When a hit's symbol has a distilled decision record (the model's resolved root-cause / decision / outcome over the tracker thread that shaped it), it rides along as distilled_records — labeled unreviewed, capped at 2; empty for almost every hit.

Resolve a symbol name (or ref/id) to its definition(s) in Rust, TypeScript, Kotlin, C, C++, Python, or Swift — exact or fuzzy. Returns candidates with signatures, locations, logical-symbol grouping (cfg variants), and any bound repo memories. Use to disambiguate before a graph or read call. Generated bindings (codegen, ubrn FFI output) are excluded by default; pass include: ["generated"] to see them. A candidate whose symbol has distilled decision records carries them as distilled_records (labeled unreviewed, capped at 2; empty for almost every symbol).

Find what calls a symbol (reverse call graph), instead of grepping for call sites. Returns call sites with confidence + target verification, a completeness / false-positive risk summary, and repo memories crossing the call path. Includes synthesized dispatches edges for message/enum (actor-channel) dispatch — the sender that constructs the variant a handler's match arm handles. Resolve the symbol with symbol_lookup first when a name is ambiguous.

Find what a symbol calls (forward call graph). Same evidence shape as find_callers; unresolved std/common-method noise is filtered out by default (add common_methods / unresolved to the include array to keep it).

Cross-check a symbol's graph caller edges against a regex text search of indexed source — surfaces call sites the tree-sitter graph missed and flags likely false edges. Use when you suspect graph coverage gaps.

Cross-check the tree-sitter graph against the SCIP compiler oracle — report the edges where they DISAGREE on a callee's resolution (the compiler contradicts tree-sitter). A resolver-debugging diagnostic; requires rag-rat oracle run first to populate compiler verdicts. Reports nothing when no oracle data exists for this checkout.

Pre-edit blast radius for a symbol or path: graph callers/callees, tests, docs, git history, tracker papertrail, and the repo memories crossing it, with a completeness / risk summary. Run this before changing anything non-trivial. Distilled decision records for the symbol ride along as distilled_records (labeled unreviewed, capped at 2; the cap is signalled in completeness_and_caveats.truncated_sections when more exist).

Dependency-contract check for the code's EXTERNAL library calls, from the SCIP oracle's external symbol info. For each resolved-external call site it surfaces the dependency's CURRENT signature + docs as inline context (judge arity / misuse yourself) and ASSERTS a deprecated verdict when the docs mark it so. Filter by path, package, or deprecated_only. Requires an oracle run; returns a NoOracleRun / NoExternalSymbols status otherwise. Does NOT assert arity or removed/renamed drift (not instrumented / needs a cross-version baseline) — those stay context.

Orientation for an unfamiliar repo: ranked files by mode — spine (central coupling), churn, god_modules, or refactor_candidates — with size/coupling/churn/memory signals and suggested next tools. Start here when you don't know the codebase.

Map the repo into ownership clusters from path proximity, graph edges, and git co-touch — a cheap overview of subsystems and their representative files.

Rank the most load-bearing symbols by weighted PageRank over the call/type/import edge graph — what the rest of the code most depends on. Run before editing to see the spine you shouldn't reinvent or break. By DEFAULT (no personalize) it auto-seeds from your current git diff, returning importance relative to your current changes; pass personalize (names, refs, or sym_<hex> handles you're working on) to seed it explicitly, or a single "global" to force whole-repo PageRank. The result is a labeled object: mode (which scale), seed_source (seed provenance), and symbols.

Ranked candidate clone classes (unrefined; exact overlap metrics). Returns classes sorted by ROI (cross-module spread × member count × token length × load-bearing factor × cohesion), with a completeness provenance block. min_similarity (if set) must be in [0.5, 1.0] (default 0.7). A LIMITED query (limit: N) is capped at the refine budget (currently 50) — it returns at most 50 classes, all refined; pass limit: null/omit it to retrieve all classes (only the top 50 refined). completeness.refine_budget_clamped is true when a supplied limit hit that cap.

The clone class containing a symbol (by id / ref / path+line). Returns the candidate class if the symbol is fingerprinted and has clone siblings; null if it is unique or not fingerprinted.

Find the FFI surface: #[uniffi::export] items, exported impl members, and generated binding artifacts (detected by path). Empty in repos without FFI.

Find documentation related to a symbol — markdown chunks and doc comments, preferring local context before broad docs.

Read the current source text for one chunk id, validated against HEAD (relocates or flags stale/gone), with compact call-graph context and bound repo memories. Use to read exact text after a search returns a chunk_id. When the chunk's symbol has distilled decision records they attach as distilled_records (labeled unreviewed, capped at 2).

Full-text search over historical commit subjects and bodies — find when/why something changed by keyword.

List commits that touched a current path, newest first, with additions/deletions and subjects.

Resolve a symbol, then list commits touching its file — symbol-scoped history without needing the path.

Combine commit-message matches with current file-change evidence for a query — "what work relates to X?" across both messages and the files that changed.

Hash-bound git blame for one chunk: who last touched its lines, computed lazily and cached against the chunk hash.

The 'why' behind a chunk: its current text plus the cached tracker items (issues / change requests) and review comments that reference it.

Resolve a symbol, then return its current context plus the cached tracker rationale (issues / change requests / reviews) referencing it.

Cached tracker items (issues / change requests / reviews) related to a historical commit.

Full-text search across cached tracker issue and change-request titles and bodies. A hit whose thread has a distilled decision record carries it as record (the model's root-cause / decision / outcome over the whole thread); coalesced issue↔PR pairs answer as one result.

List cached tracker items discovered to reference a current path.

Search cached tracker rationale snippets (review comments, issue / change-request discussion) by keyword. A hit whose thread has a distilled decision record carries it as record (the model's root-cause / decision / outcome over the whole thread).

Embedding status (local or remote/Ollama-served): model, install state, and how many chunks are embedded / missing / skipped.

Re-index stale already-indexed files and refresh FTS — repair when reads report drift. Writes only to the index, never to source.

Papertrail cache status: counts of issues, change requests, comments, and refs, plus last sync time.

Index freshness vs HEAD: git/indexed head, per-language file counts, parser failures, FTS sync state, and schema version.

Record a durable, source-anchored repo memory (Invariant / Decision / Risk / BugPattern / …) bound to a symbol, chunk, path, edge/call-path, commit, or tracker ref — so the rationale resurfaces for the next agent editing that code. Capture non-obvious invariants and decisions as you discover them.

Re-anchor an existing repo memory to a different symbol, chunk, path, or other source location — use this after a symbol moves or is renamed rather than obsoleting and recreating the memory. Replaces the binding and refreshes the source_text_hash so the memory stays current.

Update a repo memory's text, status, confidence, kind, or tags by id.

Full-text search across active (or stale) repo memories by keyword.

Return repo memories bound to a symbol (or its logical-symbol group).

Return repo memories bound to a path.

Return repo memories bound to a specific call-path edge sequence.

Expand ONE repo memory to its FULL body by memory_id — the expand path for a compact summary. When [memory] surface = "summary" renders drive-by attachments (e.g. impact_surface) as the dream-compacted summary, call this with the attachment's memory_id to get the complete original. Surface-independent: always the full body.

Re-anchor every repo memory against current source and mark each current / relocated / stale / gone / pending. Runs automatically after indexing.

List repo memories whose anchor is stale, gone, or pending, each with suggested re-anchor targets (qualified names) — the actionable companion to memory_validate. A pending anchor is alive on an in-flight worktree branch: informational only — do NOT rebind or mark it obsolete; it re-anchors when that branch lands. Read-only; reports the last-validated status, so run memory_validate first for a fresh check. Rebind stale/gone entries with memory_rebind.

Mark a repo memory obsolete — kept for audit, hidden from active recall.

Add a typed graph edge from a source node to another node or a GitHub issue. Relations: depends_on (task DAG), relates_to (mind-map link), supersedes, derived_from, tracks (issue <- task). Give exactly ONE target: a target_node_id (with an optional target_repo_id for a cross-repo edge) or a full github ref (owner + repo + number).

Remove a graph edge by its stable edge_key.

List a node's typed edges: direction=from returns its outgoing edges (deps / links / tracks); direction=into is the reverse traversal (e.g. tasks that track an issue, or nodes that depend on this one).

Return the deterministic memory-maintenance worklist: coverage gaps (load-bearing symbols with no memory) + stale references (a memory citing a path that no longer resolves), ranked, each with a stable id to review. This is the pull surface for a strong agent to burn down the worklist. Recomputes the deterministic findings on each call (like rag-rat dream); it does NOT run the opt-in model verdict/compaction passes — those stay on the CLI/cron rag-rat dream --verify|--compact, and the findings they persist (e.g. memory_divergence) still surface here. Review a finding with dream_review.

Apply a human verdict to ONE dream finding by id (a full id or unambiguous prefix): accept (a real gap to act on), dismiss (noise), or reset (clear a prior verdict, back to open). Dream only proposes; this is how the reviewer confirms. The verdict survives future dream runs. Mirrors rag-rat dream <id> --accept|--dismiss|--reset.