// what the agent sees

Ask digest

When you press ⌘K and ask a question, the agent doesn't read these pages — it reads this. It's committed as a .hev-ask/ tree — one markdown file per section — rendered here the way the ladder discloses it: titles you skim, details you open on demand.

version: 2
sections: 107
glossary: 10
generated: 2026-06-10
content hash: b5a2206dfc5d

level 1 · tree
The cheap rung: every section title, plus the glossary terms that widen a query. Titles only — bounded, safe to skim. This is the group/row map below.
level 2 · cat <section>
On demand, open a section to read its verbatim facts — and, for reference sections, the source text. That's what expanding a row reveals.

Expand a row to cat a section, the way an agent would.

Orientation

The compact product overview the build distills — context for the keyword/expansion path.

hev ask (@hevmind/ask) is a ⌘K search overlay and agent-readable docs distillation, documented at hevask.com, a site that searches itself with the package. The central artifact is the ask digest: a committed, offline-built markdown tree (.hev-ask/, one small file per section) holding section summaries, verbatim facts, source anchors, a glossary, and a site overview. The same tree serves three readers: the ⌘K overlay for humans, the ask CLI read verbs (tree, ls, head, cat, facts, grep) for agents, and the ask mcp server, which hydrates the tree to local disk so an agent reads it with its own file tools. The digest is host-neutral (built from markdown, not a renderer); Astro gets the turnkey hevAsk() integration, while Docusaurus, VitePress, MkDocs, and plain static sites use the drop-in static overlay plus an optional hostable endpoint. Two retrieval paths: instant keyless keyword search (token overlap widened by the digest glossary, deep-linking to /docs/page#anchor with anchors from github-slugger, gated in CI by ask digest verify) and an agentic answer on Enter (needs a server-side provider API key — ANTHROPIC_API_KEY by default; OpenAI and OpenRouter are supported via the provider option, with providerBaseUrl for any OpenAI-compatible endpoint — and streams SSE with inline citations to opened sections). The digest is hash-gated and incremental: rebuilds skip model work for unchanged sections, and it's buildable via the Claude Code skill (subscription, sharded), the one-shot CLI ask digest build, or the sharded flow for big sites. Everything degrades instead of hard-failing: no key means keyword mode, no tree means plain excerpts. The corpus is only the configured content collection(s) or globs, with no crawler. The POST /api/ask endpoint renders on demand, so the agentic path needs a server or hybrid adapter. The digest was formerly called the knowledge graph (kg) and was a digest.json; both are legacy names. Users compare hev ask against Pagefind, Algolia DocSearch, and Orama; the Tradeoffs and Limits pages answer that directly.

Glossary 10 terms

Aliases that widen a reader's query before retrieval — so k8s finds kubernetes. List the terms; open one for its aliases and definition.

agentic search 4 aliases

ask modeAI answersagentic loopask ai

The on-Enter path: a bounded tool-use loop that opens digest sections, then streams a grounded, deep-linked answer over SSE; requires a provider API key server-side.
anchor 3 aliases

deep linkslugheading anchor

The github-slugger heading id appended to a section URL so results land on the exact heading; ask digest verify gates anchors against the rendered HTML in CI.
ask CLI 3 aliases

cliask binaryask command

The ask binary: read verbs (tree, ls, head, cat, facts, grep) over the digest tree, plus producer commands under ask digest (build, corpus, assemble, verify, status, migrate).
ask digest 4 aliases

digestkgknowledge graph.hev-ask

The committed .hev-ask/ markdown tree — one distilled file per doc section with facts, anchors, glossary, and meta — built offline and read by the overlay, CLI, and MCP.
disclosure ladder 2 aliases

progressive disclosurefour-rung ladder

The cheap-to-expensive read order over the digest: tree/ls list titles only, then head, cat, and facts each open a larger slice of one section file.
hostable endpoint 3 aliases

standalone endpoint/api/asksearch endpoint

The /api/ask route contract — keyword JSON, agentic SSE, and keyless digest reads — served by the Astro integration or deployed standalone (Worker, Node, Vercel) for other frameworks.
keyword search 2 aliases

instant searchkeyword mode

The keyless instant path: glossary-widened token-overlap ranking over heading-level chunks, returning JSON results that deep-link to section anchors.
MCP server 3 aliases

mcpask mcpfetch_docs

A stdio Model Context Protocol server with one tool that hydrates the whole digest tree to local disk so a coding agent reads it with its own tree/cat/grep.
SearchOverlay 4 aliases

overlaycommand palettecmd-kask overlay

The ⌘K palette component — SearchOverlay.astro on Astro, or a drop-in script-tag web component on any other site — that runs both search paths.
sharded build 2 aliases

shardsshard

The large-site digest flow: the corpus splits into slug-prefix shards, each distilled in a fresh context, then assembled into the merged tree — no context-window bound.

Sections 107 sections

One file per section — the tree the agent navigates. Collapsed shows the title and summary it skims; open a section to cat its facts.

API

CLI reference
Overview of the ask binary's two command groups: read verbs that treat the committed digest as a directory (map, skim, open, pull facts, search, plus a synthesized answer command and an MCP server), and producer commands under the digest group for building, verifying, and migrating the tree.

facts · quoted verbatim
@hevmind/askasktreelsheadcatfactsgrepanswermcpask digestbuildcorpusassembleverifystatusmigrateCallout.astroCodeTabs.astro

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Building the digest reference
Lists the producer commands run from the site root and explains that only the build command calls a model (so only it needs a key, selectable per provider). Builds are incremental and hash-gated — only changed sections are re-distilled, a clean tree makes zero model calls — and the one-shot build fails past 600KB of new section text, pointing to the sharded flow. A migrate command converts a legacy digest.json to the tree with no model call.

facts · quoted verbatim
export ANTHROPIC_API_KEY=sk-ant-... ask digest build # claude-opus-4-8 by defaultexport OPENAI_API_KEY=sk-... ask digest build --provider openai # gpt-5.1 by defaultexport OPENROUTER_API_KEY=sk-or-... ask digest build --provider openrouter # anthropic/claude-opus-4.8 by defaultask digest build--providerask digest corpusask digest assemble.hev-ask/contextsummariessuggestions.hev-ask/digest.jsonask digest migratedigest.json

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Claude Code skill reference
The bundled build-digest skill builds the tree inside a Claude Code subscription instead of spending API tokens: it runs the deterministic producer seam sharded (corpus to per-shard inputs, one fresh-context distillation per shard, a synthesis pass, then assemble). Per-shard contexts mean corpus size never hits a context limit, and the output is identical in shape to a normal build with the same incremental hash gate.

facts · quoted verbatim
ask digest corpus --shards-dir .hev-ask/shards -> input-<id>.json + manifest.json ...one fresh-context distillation per shard -> distill-<id>.json... ...one synthesis pass over the shard notes -> global.json... ask digest assemble --input-dir .hev-ask/shards -> the .hev-ask/ treebuild-digestANTHROPIC_API_KEYask digest build

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Distribution reference
The npm package exposes a single bin whose launcher resolves an env-var override first, then a platform-specific optional binary package, then the checked-out Go source (the latter only for monorepo development).

facts · quoted verbatim
askHEV_ASK_BINARY

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Flags reference
Reference table of global CLI flags covering the digest directory, remote endpoint, JSON output, result caps, collection and path options for producer commands, chunking depth, model and provider selection, sharded-mode directories and sizing, and verify's build-command, skip-build, and strict options. Global flags come before the command.

facts · quoted verbatim
ask --digest-dir .hev-ask --json grep "openapi" ask --endpoint https://hevask.com/api/ask cat api/endpoint ask digest build --collection docs --collection guides --chunk-heading-depth 2 ask digest verify --skip-build--digest-dir <dir>.hev-ask--endpoint <url>/api/askanswer--json--max-results <n>grep--collection <name>docs--base-path <path>/docs/--content-glob <glob>--chunk-heading-depth <n>--digest-model <model>ask digest buildclaude-opus-4-8--provider <name>anthropicopenaiopenrouterANTHROPIC_API_KEYOPENAI_API_KEY

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Go library reference
The reusable Go API in pkg/ask offers pure helpers (loading the digest from a tree or embedded filesystem, listing summaries, getting sections, searching, an endpoint client, and serving MCP) or a dependency-free command group you can mount inside your own CLI.

facts · quoted verbatim
group := ask.NewCommandGroup(ask.CommandOptions{ DigestDir: ".hev-ask", }) err := group.Run(ctx, []string{"cat", "overview/quick-start"}, os.Stdin, os.Stdout, os.Stderr)pkg/askLoadDigestembed.FSListSectionSummariesGetSectionSearchDigestNewEndpointClientServeMCP

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
MCP reference
The mcp subcommand runs a stdio MCP server with one tool that downloads the whole digest tree to local disk and returns the title-tree inline, after which the agent uses its own file tools. It can point at a checked-out repo or a deployed endpoint via configuration.

facts · quoted verbatim
{ "mcpServers": { "hevask": { "command": "ask", "args": ["--endpoint", "https://hevask.com/api/ask", "mcp"] } } }ask mcptreecatgrep

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Reading the digest as a directory reference
Read verbs are path-addressed, mirroring doc URLs, and read the local tree by default or a deployed site's HTTP API with the endpoint flag. The four rungs go cheap to expensive: listings return titles only and are bounded by section count, while head, cat, and facts open progressively larger slices of one section file. The answer command needs a remote endpoint; grep plus cat is the keyless local path.

facts · quoted verbatim
ask.hev-ask/--endpoint <url>treelsheadcatfactsask answer--endpointask grepask cat

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Sharded builds for large sites reference
The sharded flow removes the first-build context bound: the corpus splits along slug-prefix boundaries, each shard is distilled in a fresh context, and assembly merges the tree. Sharding is stable and incremental — editing one doc re-pends only its shard, and stale distillations are detected by shard hash, skipped with a warning, and fall back to plain excerpts until re-distilled. Verify checks rendered anchors (always fatal on drift), coverage, literal fidelity, and tree integrity (warnings unless strict).

facts · quoted verbatim
ask digest corpus --shards-dir .hev-ask/shards # input-<id>.json per shard + manifest.json ask digest status --shards-dir .hev-ask/shards # distilled / pending / stale, per shard # ...one distillation per shard writes distill-<id>.json; a final pass writes global.json... ask digest assemble --input-dir .hev-ask/shards # merge + write the .hev-ask/ treeworkers/...pages/...corpusask digest verify--skip-build_meta.md--strict

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Where it runs reference
Producer commands run locally or in CI with filesystem access; the Astro integration also runs the digest build during the site build when a key is present, falling back to the committed tree. The deployed site reads the tree through a virtual module with no filesystem access, and running verify on every build is the mechanical check that anchors still match what Astro renders.

facts · quoted verbatim
ask digest buildastro buildANTHROPIC_API_KEYvirtual:hev-ask/digestask digest verify

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Configuration reference
The hevAsk() integration is the package's default export and takes one options object; only the collections option is effectively required, everything else defaults.

facts · quoted verbatim
// astro.config.mjs import hevAsk from "@hevmind/ask"; export default defineConfig({ integrations: [ hevAsk({ collections: ["docs"], basePath: "/docs/", model: "claude-haiku-4-5", maxResults: 6, }), ], });hevAsk()@hevmind/askcollectionsCallout.astroCodeTabs.astro

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Choosing a provider reference
The provider option selects who serves both the runtime loop and the offline digest build — behavior, digest format, and endpoint contract are identical; only the model defaults and key env var change. OpenRouter reaches any model it routes with one key, and a base-URL override makes any OpenAI-compatible endpoint work. Loop models must support tool calling; the digest builder also needs forced tool choice.

facts · quoted verbatim
// astro.config.mjs — the default; reads ANTHROPIC_API_KEY hevAsk({ collections: ["docs"], // model defaults to claude-haiku-4-5 });// astro.config.mjs — reads OPENAI_API_KEY hevAsk({ collections: ["docs"], provider: "openai", // model defaults to gpt-4.1-mini });// astro.config.mjs — reads OPENROUTER_API_KEY hevAsk({ collections: ["docs"], provider: "openrouter", model: "anthropic/claude-haiku-4.5", // or any OpenRouter model slug });hevAsk({ collections: ["docs"], provider: "openai", providerBaseUrl: "https://my-gateway.example.com/v1", model: "my-model", });providerOPENROUTER_API_KEYproviderBaseUrlprovider: "openai"endpoint/api/askSearchOverlay

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Options reference
Full options table for the integration: collections and basePath define the corpus and URLs; endpoint, provider, providerBaseUrl, model, and digestModel control routing and inference; maxResults, answerMaxTokens, maxIterations, chunkHeadingDepth, candidatePerSearch, and perDocCap tune retrieval and the loop; digestDir and digestContentGlobs locate the committed tree and build sources.

facts · quoted verbatim
collectionsstring[]basePathstring'/docs/'basePath + slug#anchorendpoint'/api/ask'provider'anthropic''openai''openrouter'ANTHROPIC_API_KEYOPENAI_API_KEYOPENROUTER_API_KEYproviderBaseUrlmodelclaude-haiku-4-5gpt-4.1-minianthropic/claude-haiku-4.5digestModelclaude-opus-4-8gpt-5.1

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Tuning notes reference
Practical tuning guidance: chunking depth trades finer anchors against too-small sections, the iteration cap trades latency against multi-part-question recall, the per-document cap controls result spread, and candidates-per-search trades recall against token cost.

facts · quoted verbatim
chunkHeadingDepth###maxIterationsperDocCapcandidatePerSearch

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
TypeScript reference
The integration's options type is exported for editor completion and typed configs.

facts · quoted verbatim
import type { HevAskOptions } from "@hevmind/ask";

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
What the integration does reference
At Astro config setup the integration injects the on-demand endpoint route, registers the config and digest virtual modules, watches the digest directory for dev reloads, and warns on empty collections. At build start it runs the hash-gated digest build when the provider key is present, otherwise warns and proceeds with the committed artifact — the build never fails for lack of a key.

facts · quoted verbatim
astro:config:setupendpoint@hevmind/ask/endpointprerender: falsevirtual:hev-ask/configvirtual:hev-ask/digestdigestDircollectionsastro:build:startANTHROPIC_API_KEY

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Digest format reference
The ask digest is a committed directory built offline and globbed into the build through a virtual module, so the running site reads it with no filesystem access. It is the agent's view of the docs — a distilled, source-grounded mirror read progressively, where every section carries a url and anchor back to the live page. Earlier versions used a single JSON file; before 0.1 it was called the knowledge graph.

facts · quoted verbatim
.hev-ask/ask digest builddigest.jsonkgvirtual:hev-ask/digesturlanchorCallout.astro0.1

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
_meta.md and _glossary/ reference
The meta file carries digest-level fields — version, generation time, and content hash in frontmatter, plus the orientation context, overview map, and the overlay's suggested questions in the body. The glossary directory holds one file per term with aliases in frontmatter and the definition in the body; aliases widen keyword queries before retrieval.

facts · quoted verbatim
_meta.md_glossary/versiongeneratedAtcontentHashcontextoverviewsuggestions_glossary/<term>.mdtermaliasesdefinitionk8skubernetes

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
A section file reference
Anatomy of one section file: frontmatter holds the title, heading, group, order, url, anchor, terms, hash, mode, verbatim facts, and sources; the first body paragraph is the summary served by head, the full body is served by cat, and the frontmatter facts are served by the facts verb — one file, three rungs of the disclosure ladder.

facts · quoted verbatim
headcatfacts

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Degradation reference
The tree is read defensively: a missing or malformed digest drops the agentic loop to keyword-style search, ranking to raw token overlap, and suggested questions to none — nothing hard-fails. Because the digest is markdown, each section's prose and facts change together in one PR diff, which is why it's a directory rather than a runtime computation.

facts · quoted verbatim
.hev-ask/

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Frontmatter fields reference
Reference table of section frontmatter: listing title vs literal heading, group and order for navigation, url and anchor for citations, terms for ranking, the content hash gating incremental builds, an agent-primary vs source-primary mode, deterministically extracted verbatim facts the model never authors, and source provenance references.

facts · quoted verbatim
titlestringtreelsheadinggroupordernumberurlanchorgithub-sluggerverifyidtermsstring[]hashmode'agent-primary' \| 'source-primary'source-primaryfactsFact[]sourcesSourceRef[]

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
How each field is used reference
Maps fields to behavior: the title-tree and summaries are prompt-cached into the agentic loop's system prompt; the glossary expands keyword queries; terms, summaries, and facts lift ranked sections above incidental body mentions; the anchor is what verify checks and citations deep-link to; the hash gates incremental re-distillation.

facts · quoted verbatim
facts_glossary/termssummaryanchorask digest verifyhashbuild

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Layout reference
The tree layout: a meta file, a glossary directory with one file per term, and one markdown file per heading-level section mirroring the doc paths. Underscore-prefixed names mark non-section entries so they sort first and never collide with a real slug; the entire artifact is markdown with no committed JSON.

facts · quoted verbatim
.hev-ask/ _meta.md overview · context · suggestions · version · contentHash _glossary/ digest.md one file per term: aliases + definition overview/ quick-start.md one file per section, mirroring your doc paths limits.md api/ cli.md_meta_glossary

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Regenerating reference
Rebuild after content changes and commit the result; the per-section hash makes rebuilds incremental. Build via the Claude Code skill (no API key) or the CLI build command (one API call) — the integration also builds during the site build when a key is present — then run verify to gate anchors, coverage, fidelity, and tree integrity. A migrate command converts a legacy JSON digest without a model call.

facts · quoted verbatim
hashask digest buildastro buildask digest verifydigest.jsonask digest migrate

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Search endpoint reference
The integration injects one on-demand route tree (default /api/ask): the base route serves the overlay with keyword JSON or an agentic SSE stream, keyless sub-routes expose the committed digest for CLIs and MCP servers, and the OpenAPI 3.1 contract is published at /openapi.yaml.

facts · quoted verbatim
/api/asktext/event-stream/openapi.yamlCallout.astro3.1openapi.yaml

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Agentic response (SSE) reference
With a key present and agentic mode, the endpoint streams named SSE frames: search events for each sub-query or opened section, a single sources event with the grounding set (sent before any token, used by clients to validate links), token deltas of the Markdown answer, a done frame, and an error frame for failures after streaming began. A source carries title, optional heading and group, and url — no snippet.

facts · quoted verbatim
modeagenticcontent-type: text/event-streamsearch{ query }sources{ sources: Source[], model, mode }token{ text }done{}error{ error }200Source{ title, heading?, url, group? }snippeturl

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Digest reads (GET) reference
Keyless GET routes read the digest virtual module with no model call: glossary listing and per-term lookup, section summaries (filterable by group) and full per-id sections (URL-encode ids containing slashes or hashes), the overview/context pair, and a gzip tar archive of the whole tree used as the MCP bulk transport — with a HEAD variant exposing the content hash so clients skip redundant downloads. Misses return 404 with a JSON error.

facts · quoted verbatim
{ "error": "Not found." }virtual:hev-ask/digestGET /api/ask/glossary{ "terms": GlossaryEntry[] }GET /api/ask/glossary/{term}GlossaryEntryGET /api/ask/sections{ "sections": SectionSummary[] }GET /api/ask/sections?group=APIGET /api/ask/sections/{id}DigestNodeGET /api/ask/overview{ "overview": string, "context": string }GET /api/ask/archive.hev-ask/SectionSummary{ id, title, heading, group, url }/api/ask/sections/api%2Fcli%23flagsask mcp --endpointHEAD /api/ask/archivex-hev-ask-content-hash404

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Errors reference
Error contract: 400 for invalid JSON bodies, 404 for missing digest reads, 500 when the chunk index fails to build, and — because the agentic stream is already 200 — mid-stream failures arrive as a final SSE error event rather than a status code.

facts · quoted verbatim
400{ "error": "Invalid JSON body." }404{ "error": "…" }500event: error200errore.g

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Index lifecycle reference
The chunk index builds once per server instance on the first request and is cached for the process lifetime; that first request also compares the live content hash against the digest's and logs a one-time staleness warning as the cue to rebuild.

facts · quoted verbatim
ask digest build

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Keyword response (JSON) reference
Keyword mode returns a 200 JSON envelope of ranked results (title, optional heading and group, url with anchor, snippet) plus the echoed query, the configured loop model, the mode that ran, and an optional warning when an agentic request was downgraded for lack of a key. The url field is the deep link, page-only for intro chunks.

facts · quoted verbatim
{ "results": [ { "title": "Concepts", "heading": "The agentic search loop", "url": "/docs/concepts#the-agentic-search-loop", "group": "Overview", "snippet": "When the reader presses Enter, the query goes to a bounded loop…" } ], "query": "how does agentic search work", "model": "claude-haiku-4-5", "mode": "keyword" }200resultsResult[]titleheading?urlgroup?snippetquerystringmodelmode'keyword'warningstring?#anchor

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
LLM tracing reference
Setting a PostHog key in the server environment makes every agentic answer emit an AI-generation trace with model, tokens, latency, and tool calls; host and content-capture level are configurable, and without a key tracing is a no-op the answer path never depends on.

facts · quoted verbatim
POSTHOG_KEYPOSTHOG_API_KEY$ai_generationPOSTHOG_HOSTPOSTHOG_CAPTURE_CONTENToffredactedfull

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Mode selection reference
The endpoint decides what to run: empty queries return an empty keyword envelope; explicit keyword mode or a missing key returns keyword JSON (with a warning when agentic was requested); otherwise the agentic SSE stream runs. There is no AI-unavailable error path — a missing key downgrades to keyword results, and the overlay branches on the response content-type.

facts · quoted verbatim
{ results: [], query: "", model, mode: "keyword" }mode: "keyword"mode: "agentic"warningcontent-type

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Request reference
Search is a POST with a JSON body of a query string and an optional mode; keyword forces the instant path, agentic requests the loop, and omitting mode behaves like agentic when a key is present. Empty or whitespace queries return an empty result set.

facts · quoted verbatim
{ "query": "how does autoscaling work", "mode": "agentic" }POSTquerystringmode'keyword' \| 'agentic'keywordagentic

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Suggested questions (GET) reference
A GET on the base route returns the digest's baked-in suggested questions and the loop model with no model call; the overlay fetches it once on first open when AI is on, and an empty list simply renders nothing.

facts · quoted verbatim
{ "suggestions": ["How does the digest stay fresh?"], "model": "claude-haiku-4-5" }GET /api/asksuggestions

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
The API key reference
The endpoint reads the key named by the configured provider from, in order, the adapter runtime environment (such as Cloudflare's), the process environment, then the build-time env. It is set wherever the host injects server secrets and never reaches the browser.

facts · quoted verbatim
ANTHROPIC_API_KEYOPENAI_API_KEYOPENROUTER_API_KEYproviderlocals.runtime.envprocess.envimport.meta.enve.g

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
MCP server reference
The MCP server is one tool plus instructions: the tool downloads the whole digest tree to local disk, and the instructions teach the agent to navigate it with its own file tools and cite with url+anchor. It deliberately hands an agent the corpus rather than reimplementing a search API — an MCP consumer is already an agent, so synthesis stays the overlay's job and there is no answer tool.

facts · quoted verbatim
ask mcptreecatgrepurlanchorlsanswerCallout.astro

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Co-location reference
Hydrate-to-disk assumes the MCP server and the agent's file tools share a host, which is true for the stdio transport — the only one this server exposes. A remote transport where the agent can't read the server's cache would need a separate resource fallback, since a local path would be useless.

facts · quoted verbatim
ask mcp

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Configure reference
Two configurations: point the server at a checked-out repo's local digest directory (keyless), or at a deployed site's endpoint — including any other site running hev ask — to pull its docs into the agent's workspace from anywhere.

facts · quoted verbatim
{ "mcpServers": { "docs": { "command": "ask", "args": ["--digest-dir", ".hev-ask", "mcp"] } } }{ "mcpServers": { "hevask": { "command": "ask", "args": ["--endpoint", "https://hevask.com/api/ask", "mcp"] } } }

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Data sources reference
The MCP server resolves data like the CLI: with an endpoint it downloads the deployed tree as a compressed archive; otherwise it reads the local digest directory. A freshly rebuilt tree is visible on the next fetch without restarting the server.

facts · quoted verbatim
ask mcp--endpoint <url>/api/ask/archive--digest-dir.hev-askfetch_docs

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Protocol surface reference
The server speaks newline-delimited JSON-RPC over stdio, handling initialization (returning the instructions), tool listing, and tool calls; unknown methods return protocol errors and tool failures return error-flagged MCP results. All substantive behavior lives in the shared Go package so the CLI, embeddable command group, and MCP server use the same tree helpers.

facts · quoted verbatim
initializeinstructionstools/listtools/callisError: truepkg/ask

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
The instructions reference
The shipped instructions teach two things: navigation (read the inline title-tree first, open a section only when its title says it's relevant, grep for specifics, don't read every file) and citation (cite every claim with the section's url and anchor as a deep link). Citation is made non-negotiable because it's easy to lose once an agent synthesizes off local files and it's the core grounded-deep-link value.

facts · quoted verbatim
instructionscatgrep_glossary/urlanchor/docs/page#anchor

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
The tool reference
The single tool materializes the digest tree at a host-keyed local cache path and returns the title-tree inline plus path, content hash, section count, and an up-to-date flag — one call bootstraps the whole disclosure ladder, after which the agent uses native file tools. A force argument re-pulls unconditionally; otherwise the remote content hash is compared and the download skipped when unchanged. The bounded corpus compresses small enough to ship in one shot with no per-file delta protocol.

facts · quoted verbatim
tree ~/.cache/hev-ask/hevask.com # already returned inline by fetch_docs cat ~/.cache/hev-ask/hevask.com/overview/quick-start.md grep -r "prerender" ~/.cache/hev-ask/hevask.comfetch_docs{ force?: boolean }{ path, contentHash, sections, tree, upToDate }~/.cache/hev-ask/hevask.com/force: truecontentHashupToDate: truee.g

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
SearchOverlay component reference
The Astro overlay component renders the ⌘K command palette; it's added once in a global layout, opens over the page, and doesn't affect layout until opened.

facts · quoted verbatim
--- import SearchOverlay from "@hevmind/ask/components/SearchOverlay.astro"; --- <SearchOverlay />SearchOverlay.astro⌘K<dialog>Callout.astro

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Any static site reference
Plain HTML sites need no framework: run the bundle command as a build step, deploy its output beside the HTML, drop the script tag into the template, and add the endpoint attribute only when agentic answers are wanted.

facts · quoted verbatim
ask digest bundle<script>

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Bundling the static assets reference
The bundle command emits the browser payload — keyword index, glossary, suggestions, and title-tree — into a directory the site serves. The output is generated every build and gitignored, not committed; the committed digest tree stays the reviewable source of truth, and regenerating per build prevents drift from what ships.

facts · quoted verbatim
ask digest bundle.hev-ask/

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Docusaurus reference
On Docusaurus, the bundle is emitted into the static directory by the build script and the overlay script is added through the site config with digest and endpoint data attributes. Docusaurus's explicit custom-id heading anchors are honored by its slug mode, and verify checks every anchor against the built HTML.

facts · quoted verbatim
// docusaurus.config.js export default { scripts: [ { src: "https://cdn.jsdelivr.net/npm/@hevmind/ask/overlay.js", type: "module", "data-hev-ask-digest": "/hev-ask/", "data-hev-ask-endpoint": "https://docs-ask.example.workers.dev/api/ask", }, ], };// package.json — bundle into the static dir before docusaurus build "scripts": { "build": "ask digest bundle --out static/hev-ask && docusaurus build" }static/builddocusaurus.config.js{#custom-id}ask digest verifybuild/

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Keyboard model reference
The overlay is ask-first and word-count driven: one word runs debounced keyword search with the first result auto-active; a second word switches to ask mode where Enter sends the question to the agentic loop; arrow keys move keyword selection, Escape closes, and suggested questions appear on open with AI enabled. Without a server key, asking returns keyword results with a visible warning — search never breaks.

facts · quoted verbatim
TabANTHROPIC_API_KEY

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Keyword results and deep links reference
Each keyword result row shows the document title, an optional heading breadcrumb, and a one-line snippet; the row links to the chunk's url, which already carries the anchor, so clicking lands on the exact heading.

facts · quoted verbatim
Concepts › The agentic loopurl#anchor

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
MkDocs reference
On MkDocs, the bundle goes into the docs directory and the overlay script is referenced through the extra-javascript setting in the site config.

facts · quoted verbatim
# mkdocs.yml extra_javascript: - hev-ask/overlay.jsdocs/hev-ask/extra_javascript

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Opening the overlay reference
Two built-in openers: the keyboard shortcut binds automatically once the component is on the page, and any element carrying the opener data attribute opens it on click, so any number of triggers can be wired.

facts · quoted verbatim
<button type="button" data-hev-ask-open> Search <kbd>⌘K</kbd> </button> <a href="#" data-hev-ask-open>Search the docs</a>⌘KCtrl-Kdata-hev-ask-open

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Props reference
The component takes three props: the endpoint it posts queries to (which must match the integration's endpoint option), the input placeholder text, and the debounce delay before a keyword query is sent.

facts · quoted verbatim
<SearchOverlay endpoint="/api/ask" placeholder="Search hev ask…" debounce={400} />endpointstring'/api/ask'placeholder'Search the docs…'debouncenumber500

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Suggested questions reference
With AI on, the overlay fetches suggested questions from the endpoint on first open and shows them in the empty state; they're baked into the digest at build time so no model call renders them, an empty digest shows none, and clicking one fills the input and asks immediately.

facts · quoted verbatim
GET /api/asksuggestions

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Support at a glance reference
A per-framework support table: Astro gets the turnkey integration, mounted component, and built-in route; Docusaurus, VitePress, MkDocs, and static HTML get the digest build as a build step, a drop-in overlay, and a hostable endpoint for agentic answers. The CLI and MCP surfaces are host-neutral on every row.

facts · quoted verbatim
hevAsk()SearchOverlay.astro/api/askask digest<script>mountHevAskextra_javascript

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
The hostable endpoint reference
For agentic answers without Astro, the bounded answer loop deploys as a standalone service (Cloudflare Worker, Node server, or Vercel function) serving the same POST contract as the Astro route, holding the key server-side and reading the committed digest. Deploy once and point any number of sites at it; keyword search runs entirely in the browser, so only the answer loop needs hosting.

facts · quoted verbatim
# scaffold and deploy the Worker flavor ask endpoint init --target cloudflare wrangler deploy # set ANTHROPIC_API_KEY as a secretPOST /api/askANTHROPIC_API_KEY

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
The mode toggle reference
An AI-on-Enter preference persists in localStorage; readers who flip it to keyword-only never trigger a model call — a space just searches a phrase, no suggested questions show, and the choice survives reloads.

facts · quoted verbatim
localStoragehev-ask:modeagentickeyword

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
The overlay on other frameworks reference
The same palette ships as a prebuilt web component loaded with one script tag from npm or a CDN: it reads a bundled copy of the digest in the browser so keyword search runs fully static, and an optional endpoint attribute enables agentic questions (omit it for keyword-only). Theming variables, the opener attribute, and the keyboard model are identical to the Astro component.

facts · quoted verbatim
<script type="module" src="https://cdn.jsdelivr.net/npm/@hevmind/ask/overlay.js" data-hev-ask-digest="/hev-ask/" data-hev-ask-endpoint="https://docs-ask.example.workers.dev/api/ask" ></script> <button data-hev-ask-open>Search <kbd>⌘K</kbd></button>SearchOverlay.astro@hevmind/ask/overlaydata-hev-ask-digestask digest bundledata-hev-ask-endpoint

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
The streamed answer reference
Pressing Enter with a key configured swaps keyword rows for an answer panel: sub-queries appear live, the grounded answer streams token-by-token, inline deep links point at exact section anchors, and a sources chip row lists the grounding set. Links are validated against the streamed source set — any URL outside it renders as plain text, so a hallucinated anchor can never become a clickable dead link.

facts · quoted verbatim
searched: …/docs/page#anchor

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
Theming reference
The overlay reads the page's CSS custom properties for background, primary text, secondary text, and accent colors; because its scoped styles key off those variables, matching a site's look usually means defining the tokens, not overriding overlay CSS.

facts · quoted verbatim
:root { --paper: #111111; /* overlay background */ --ink: #fafaf5; /* primary text */ --muted: #6b6b66; /* secondary text */ --signal: #e25822; /* accent / active state */ }as-:root

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗
VitePress reference
On VitePress, the bundle goes into the public directory and the overlay is mounted from the theme's enhance-app hook with digest and endpoint settings.

facts · quoted verbatim
// .vitepress/theme/index.ts import DefaultTheme from "vitepress/theme"; import { mountHevAsk } from "@hevmind/ask/overlay"; export default { extends: DefaultTheme, enhanceApp() { if (typeof window !== "undefined") { mountHevAsk({ digest: "/hev-ask/", endpoint: import.meta.env.VITE_ASK_ENDPOINT }); } }, };.vitepress/public/

Reference section — on open, the agent also receives this section's source text verbatim.
open section ↗

Overview

Concepts summary
The core idea: the digest is just a directory — docs distilled into a committed tree of markdown files, one per section, read two ways: a coding agent navigates it with its existing file tools, and the ⌘K overlay reads it server-side to synthesize grounded answers for humans. The tree is built offline with a strong model and committed to git; the readers run on demand with no durable state in the running site.

facts · quoted verbatim
⌘KDiagram.astroCallout.astro
open section ↗
Asking is the default summary
The overlay treats a single word as an instant keyword lookup and switches to ask mode the moment a query grows past one word, with suggested questions shown on open to make asking the obvious move. None of it is forced — a keyword-only preference persists and keeps the model out of the loop entirely.

facts · quoted verbatim
_meta.mdlocalStorage
open section ↗
Chunks and anchors summary
Documents are split on headings up to a configurable depth into section chunks whose URLs carry real anchors generated with github-slugger, matching what Astro and GitHub-flavored renderers emit; other adapters declare their own slug schemes. Both the offline build and the runtime index chunk through the same function, so anchors agree — and because the build reads files rather than a renderer, the digest is framework-independent.

facts · quoted verbatim
#####basePath + slug + #anchorgithub-slugger{#custom-id}getCollectiongithub.com
open section ↗
Degradation, by design summary
Every missing piece degrades rather than breaks: no runtime key means keyword-only, no build key keeps the committed tree with a warning, no digest tree drops the loop to keyword retrieval and ranking to raw token overlap, and a stale tree logs a one-line warning while still serving.

facts · quoted verbatim
.hev-ask/_meta.md
open section ↗
Host-neutral: one digest, any framework summary
The digest build never touches a renderer — it reads markdown, chunks on headings, derives anchors in code — so the artifact is identical across Astro, Docusaurus, VitePress, and MkDocs. Only the adapter differs: Astro's batteries-included integration, versus two host-neutral primitives elsewhere (the static drop-in overlay for keyword search and the hostable endpoint for agentic answers). The CLI and MCP read the tree directly on any host.

facts · quoted verbatim
.hev-ask/hevAsk()astro build/api/askSearchOverlay.astro<script>treecatgrep
open section ↗
Keyword search and the glossary summary
The instant path is a dependency-free prefilter: expand each query term with glossary aliases, score by token overlap widened by the digest's summaries, terms, and facts (so central sections outrank incidental mentions), cap results per document, and excerpt around the first match. No API key, no embeddings — and with no tree it degrades to plain token overlap, so keyword search always works.

facts · quoted verbatim
grepk8skubernetessummarytermsfacts
open section ↗
Progressive disclosure as a directory summary
Because the digest is a real directory, progressive disclosure is the directory's own cost model: a four-rung ladder where listings read frontmatter titles only (bounded by section count, safe to call speculatively) and each deeper read — summary, body, facts — is an explicit verb. Nothing larger than a title is ever returned by surprise.

facts · quoted verbatim
lscattreeheadfactsgrepask
open section ↗
The agentic search loop summary
The loop runs in two phases: gather, where the model sees the full title-tree and opens sections with a single open-section tool for up to a bounded number of rounds; and answer, where the accumulated sources go to the overlay for link validation and the model is called once more with no tools so it can only write prose. The answer is constrained to retrieved sections — it links only to provided URLs and cannot ground in what retrieval never found.

facts · quoted verbatim
open_section({ id })factsmaxIterationsurl
open section ↗
The ask digest directory summary
The build writes one distilled markdown+frontmatter file per section, mirroring doc paths, plus a glossary directory and a meta file — markdown all the way down, so prose and facts change together in one reviewable diff. Listings return only frontmatter titles, so titles must carry the open/skip decision: page titles come from the collection and sub-section titles are synthesized into descriptive one-liners.

facts · quoted verbatim
.hev-ask/overview/api/titleurlanchorfactssourcestermshash_glossary/_meta.mdcontextheading
open section ↗
The system prompt is cached summary
The title-tree and summaries enter the system prompt with a cache-control marker, so the gather rounds hit the prompt cache; the toolless answer turn can't reuse it but is the final call anyway. The reader's server-side loop and a consumer's coding agent are distinct readers climbing the same four-rung ladder — one over the in-memory tree, the other over files on its own disk.

facts · quoted verbatim
cache_control4.5
open section ↗
Two ways to build the tree summary
Only the distillation (summaries, glossary, context, suggestions) is model-authored; structure, facts, overview, hashes, and anchors are computed deterministically. That seam allows two build paths: the recommended Claude Code skill (runs in your subscription, no API key or token spend) and the CLI build (one API call to the Opus-class default, right for CI). Both are incremental, hash-gated, and produce a PR-reviewable tree.

facts · quoted verbatim
summarycontextsuggestionsfacts.hev-ask/ANTHROPIC_API_KEYask digest build4.8
open section ↗
Digest creation summary
The digest is created offline and committed like source: a build reads markdown off the filesystem, distils each section into a small markdown file, and writes the tree. The running site, CLI, and MCP server read the committed artifact and never call a model to serve it.

facts · quoted verbatim
.hev-ask/Callout.astroCodeTabs.astro
open section ↗
Built from markdown, not from a renderer summary
The build never imports a framework — it reads files, chunks on headings, and derives anchors in code, producing the same artifact on any renderer or none. Only the timing differs per host: the Astro integration runs it during the site build when a key is present; elsewhere it's a build or CI step. Overlay wiring on non-Astro sites is a separate, smaller job.

facts · quoted verbatim
astro build
open section ↗
Incremental by hash summary
Every section file records the hash of the content it was distilled from, so rebuilds re-distil only changed sections and a clean tree does no model work — making rebuild-on-every-change the intended workflow rather than a chore.

no verbatim facts in this section open section ↗
Two ways to run the build summary
Two build paths: the recommended bundled Claude Code skill, which needs no API key and shards the corpus so size never hits a context limit, and the CLI build for CI or non-Claude-Code use, one unattended API call on the default or any configured provider. Both write the same tree under the same hash gate.

facts · quoted verbatim
You: build the hev ask digest Claude runs: ask digest corpus # emits the sections to distil …writes context/glossary/summaries/suggestions… ask digest assemble # writes the .hev-ask/ treeexport ANTHROPIC_API_KEY=sk-ant-... pnpm exec ask digest buildexport OPENAI_API_KEY=sk-... pnpm exec ask digest build --provider openaiexport OPENROUTER_API_KEY=sk-or-... pnpm exec ask digest build --provider openrouterbuild-digestANTHROPIC_API_KEY--provider4.8
open section ↗
Verify, review, commit summary
The verify command is the CI gate: it builds the site, fails when any section anchor is missing from the rendered HTML, and warns on coverage or fidelity drift. The markdown tree makes each section's prose and facts one reviewable diff; a stale digest triggers a one-line runtime warning but keeps serving until rebuilt.

facts · quoted verbatim
pnpm exec ask digest verify # builds the site, checks every anchor resolves git add .hev-askask digest verify
open section ↗
What the model writes summary
Only the distillation is model-authored — per-section summaries, the glossary, orientation context, and suggested questions. Structure, verbatim facts, the overview, anchors, and hashes are derived deterministically in code, a seam that lets the model step run anywhere a model is available, including inside the editor.

no verbatim facts in this section open section ↗
Introduction summary
hev ask distills a docs site into a compact directory of markdown — one small file per section — that a coding agent can navigate with file tools and a ⌘K overlay answers readers from. It's host-neutral (built from markdown, not a renderer), ships a turnkey Astro integration, adds the same overlay to any other framework with one script, and fits technical docs, internal wikis, and medium-sized corpora.

facts · quoted verbatim
⌘KDiagram.astroCallout.astroastro.build
open section ↗
Next steps summary
Navigation hub pointing to the quick start, digest creation, concepts, the tradeoffs and limits pages, the CLI reference, and the full API reference.

facts · quoted verbatim
asktreecatgrep
open section ↗
One artifact, three readers summary
One committed tree serves three readers: the ⌘K overlay for humans (instant keyword results plus a grounded answer on Enter, every result deep-linked), the CLI's keyless read verbs for agents in any shell, and the MCP server that hydrates the tree to disk for an agent's own file tools. The corpus is only the content you point at — no crawler, no external index, nothing to keep in sync.

facts · quoted verbatim
.hev-ask/ANTHROPIC_API_KEY⌘Kasktreelsheadcatfactsgrepask mcpdocs/
open section ↗
Who this is for summary
For maintainers of markdown/MDX docs sites who want search that works without a service or crawler, deep-links to the right section, answers questions phrased in the reader's words, and is queryable by a coding agent. One integration covers it on Astro; other frameworks drop in the static overlay plus an optional hosted endpoint. Pagefind is recommended outright for keyless static keyword-only needs.

facts · quoted verbatim
pagefind.app
open section ↗
Limits summary
The hard boundaries to know before adopting: corpus scope, the recall ceiling, digest build bounds, frontmatter parsing, latency, and adapter requirements — edges of the current design, not bugs.

facts · quoted verbatim
Callout.astro
open section ↗
Agentic search adds latency summary
The agentic path is bounded by a configurable number of model round-trips — worst case a few seconds, not instant by nature. Keyword search remains the always-available instant lane, and lowering the iteration cap tightens the latency ceiling.

facts · quoted verbatim
maxIterations
open section ↗
Anchors depend on the renderer's slugger summary
Deep links stay correct only while generated heading slugs match the renderer's ids; the default slugger aligns with Astro and GitHub, adapters declare their own schemes, and the verify command fails when any chunk anchor is missing from built HTML — wire it into CI to catch slugging changes before a broken link ships.

facts · quoted verbatim
idgithub-sluggerask digest verifyverify
open section ↗
Frontmatter parsing is a flat-YAML subset summary
The offline build parses frontmatter with a small flat-YAML splitter handling string and number fields; nested structures aren't supported. This only affects the offline file-reading build — the Astro runtime index uses the collection API, which honors the real schema.

facts · quoted verbatim
getCollection
open section ↗
Recall has a keyword ceiling summary
Retrieval is glossary-widened token overlap, not embeddings, and the loop can only ground in what retrieval finds. The glossary recovers most synonym cases, but a query sharing no tokens with the docs or glossary may never surface the right section. Embeddings are the known fix and deliberately unbuilt; a richer glossary is the cheaper lever until analytics show consistent misses.

facts · quoted verbatim
k8skubernetes
open section ↗
Secrets live server-side summary
The agentic path needs the configured provider's key in the server environment running the endpoint; it's never exposed to the browser, and without it the endpoint serves keyword results — search degrades, it doesn't break.

facts · quoted verbatim
ANTHROPIC_API_KEYOPENAI_API_KEYOPENROUTER_API_KEYprovider/api/ask
open section ↗
The agentic path needs a server somewhere summary
Keyword search runs fully static in the browser on any host; only the agentic path needs a runtime — Astro's on-demand route with a server or hybrid adapter, or the standalone hostable endpoint elsewhere. A purely static site ships keyword search with nothing hosted but can't answer questions until an endpoint exists.

facts · quoted verbatim
/api/ask
open section ↗
The corpus is the content you configure summary
Search covers exactly the markdown you point at — a content collection, a docs tree, or globs — with no crawler or sitemap ingestion and no way to index pages outside the configured corpus, such as hand-written framework pages or bare routes.

facts · quoted verbatim
docs/.astro
open section ↗
The one-shot digest build is bounded; sharded builds are not summary
The one-shot build sends the full cleaned corpus in one model call and fails loudly past 600KB of section text; beyond that, the sharded build splits the corpus into prefix-stable shards distilled in fresh contexts and merged deterministically, scaling to corpora of tens of thousands of sections. The remaining ceiling is the runtime prompt: the answer loop inlines summaries, so very large trees don't yet fit it, though an agent reading over MCP pages through files with no such limit.

facts · quoted verbatim
ask digest build
open section ↗
Quick start summary
Add search to an existing Astro 5 docs site with a content collection in about five minutes: keyword search first with no key and nothing to host, then a server-side key enables the agentic answer loop on Enter. Other frameworks drop in the same overlay as a script tag and point it at a hosted endpoint.

facts · quoted verbatim
src/content/docsANTHROPIC_API_KEY<script>Callout.astroCodeTabs.astro
open section ↗
1. Install summary
Install the package from npm once published, or until then consume it straight from the package subdirectory on GitHub.

facts · quoted verbatim
pnpm add @hevmind/askpnpm add "git+ssh://git@github.com/hev/ask.git#main&path:/packages/ui"
open section ↗
2. Register the integration summary
Register the integration in the Astro config with the content collection name(s) and the slug-to-URL base path; collections is the only required option.

facts · quoted verbatim
// astro.config.mjs import { defineConfig } from "astro/config"; import hevAsk from "@hevmind/ask"; export default defineConfig({ integrations: [ hevAsk({ collections: ["docs"], // your content collection name(s) basePath: "/docs/", // slug → URL prefix: basePath + slug }), ], });collections
open section ↗
3. Add a server adapter summary
The ask route renders on demand, so add whichever server adapter matches the host; existing pages stay prerendered and only the search route runs as a function. The docs site itself uses Cloudflare.

facts · quoted verbatim
// astro.config.mjs import cloudflare from "@astrojs/cloudflare"; export default defineConfig({ adapter: cloudflare({ platformProxy: { enabled: true } }), // ...integrations as above });/api/ask
open section ↗
4. Render the overlay summary
Add the overlay component once in a global layout; any element with the opener data attribute opens the palette and the keyboard shortcut binds automatically. At this point keyword search works in dev.

facts · quoted verbatim
--- // src/layouts/Base.astro import SearchOverlay from "@hevmind/ask/components/SearchOverlay.astro"; --- <button type="button" data-hev-ask-open> Search <kbd>⌘K</kbd> </button> <slot /> <SearchOverlay />data-hev-ask-open⌘Kastro dev
open section ↗
5. Build the digest summary
Build the committed digest tree — it feeds the loop's domain context, ranks keyword results, supplies the glossary, and holds suggested questions. The recommended path is the bundled Claude Code skill (no API key, no token spend); the CLI build is the CI alternative with provider selection. Both are incremental and hash-gated; verify and commit afterward, and the integration rebuilds automatically during the site build when a key is present.

facts · quoted verbatim
You: build the hev ask digest Claude runs: ask digest corpus # emits the sections to distil …writes context/glossary/summaries/suggestions… ask digest assemble # writes the .hev-ask/ treeexport ANTHROPIC_API_KEY=sk-ant-... pnpm exec ask digest build # writes the .hev-ask/ treeexport OPENAI_API_KEY=sk-... pnpm exec ask digest build --provider openaiexport OPENROUTER_API_KEY=sk-or-... pnpm exec ask digest build --provider openrouterpnpm exec ask digest verify # builds the site, checks every anchor resolves git add .hev-askk8skubernetes--providerastro buildclaude.com
open section ↗
Enable agentic search summary
Set the provider's API key in the server environment where the search route runs; with a key, Enter runs the agentic loop with sub-queries, a grounded answer, and inline deep links. Non-default providers also need the provider option set in the integration; the Anthropic default needs only the key.

facts · quoted verbatim
# the default provider — nothing else to configure export ANTHROPIC_API_KEY=sk-ant-...# with provider: "openai" in the hevAsk() options export OPENAI_API_KEY=sk-...# with provider: "openrouter" in the hevAsk() options export OPENROUTER_API_KEY=sk-or-.../api/ask.envprovider
open section ↗
Prerequisites summary
Requires Astro 5 with at least one content collection, a server or hybrid adapter because the search route renders on demand, and a provider API key only for agentic search — keyword search needs no key.

facts · quoted verbatim
/api/askANTHROPIC_API_KEYproviderdocs.astro.build
open section ↗
Set up keyword search summary
Section header introducing the keyword-search setup steps: install, register the integration, add an adapter, and render the overlay.

no verbatim facts in this section open section ↗
Verify it works summary
Three checks: a single heading word should deep-link to its section, a multi-word question should stream a grounded answer showing the model's sub-queries, and the verify command exits non-zero when any chunk anchor is missing from built HTML — wire it into CI.

facts · quoted verbatim
/docs/page#headingask digest verify
open section ↗
Tradeoffs summary
The honest accounting of what hev ask trades away — dependency posture, the committed digest, agentic cost and latency — and how it compares to Pagefind, Algolia, and Orama, so adopters can judge the fit.

facts · quoted verbatim
Callout.astro
open section ↗
A committed digest summary
Committing the digest to git buys per-section PR review, runtime determinism, free reads with no model call on the request path, edge bundling without filesystem access, and direct agent navigation. The cost is staleness: it only regenerates when content changes and a build runs, with a runtime warning as the cue — and the per-section hash gate makes rebuild-in-CI on every change the cheap, intended workflow.

facts · quoted verbatim
treecatgrep
open section ↗
A flagship adapter, primitives for the rest summary
Host-neutral at the core, opinionated about Astro: the Astro integration is batteries-included, while other frameworks wire two primitives themselves — the static overlay plus, for agentic answers, the standalone endpoint. The digest, overlay, CLI, and MCP are identical everywhere, but off Astro you do the wiring the integration would have done; per-framework turnkey plugins are a goal, not a guarantee.

facts · quoted verbatim
<script>/api/ask
open section ↗
Cost and latency of agentic search summary
The agentic path costs real if small money and latency: worst case a few seconds of bounded Haiku round-trips per submitted query, with domain context prompt-cached across rounds; the offline build uses Opus but the hash gate means paying only when content changes. Keyword-only is a first-class mode for anyone who doesn't want a key in the loop.

facts · quoted verbatim
maxIterations
open section ↗
How it compares summary
Comparison table and guidance: Pagefind for excellent keyless static keyword search, Algolia for a managed crawler-backed service, Orama for client-side vector search with self-managed embeddings, and hev ask when docs are a folder of markdown on any framework and you want heading-level deep links plus answers to questions phrased in the reader's words.

no verbatim facts in this section open section ↗
Keyword retrieval, not embeddings summary
Retrieval is dependency-free token overlap widened by the glossary — nothing to host, edge-safe, instant — but paraphrase recall has a ceiling: the agent can only ground in what keyword retrieval found. The glossary recovers much of the synonym recall embeddings would give; the embeddings upgrade is deferred, not designed out.

no verbatim facts in this section open section ↗
One dependency, deliberately summary
The package is near zero-dependency with one deliberate exception: github-slugger, a small pure-JS, edge-safe library that guarantees byte-identical heading anchors with Astro and GitHub rather than risking hand-rolled slugs that 404 to the top of the page; adapters extend the guarantee to their own slug rules.

facts · quoted verbatim
github-sluggergithub.com
open section ↗
Two paths instead of one summary
Running an instant keyword path and an agentic path keeps the common one-or-two-word case instant and keyless while hard questions get a smarter ranker, at the cost of a slightly more complex interaction model — readers learn that Enter means ask AI. The trade fits docs, where queries split into jumping to a known thing and finding a thing you can't name.

no verbatim facts in this section open section ↗

Normalized digest data

{
  "version": 2,
  "generatedAt": "2026-06-10T13:16:20.949Z",
  "contentHash": "b5a2206dfc5d222323bf61b77864f51b2831accb09b2b1b73cece2ff89058bd6",
  "context": "**hev ask** (`@hevmind/ask`) is a `⌘K` search overlay and agent-readable docs distillation, documented at hevask.com, a site that searches itself with the package. The central artifact is the **ask digest**: a committed, offline-built markdown tree (`.hev-ask/`, one small file per section) holding section summaries, verbatim facts, source anchors, a glossary, and a site overview. The same tree serves three readers: the `⌘K` overlay for humans, the `ask` CLI read verbs (`tree`, `ls`, `head`, `cat`, `facts`, `grep`) for agents, and the `ask mcp` server, which hydrates the tree to local disk so an agent reads it with its own file tools. The digest is host-neutral (built from markdown, not a renderer); Astro gets the turnkey `hevAsk()` integration, while Docusaurus, VitePress, MkDocs, and plain static sites use the drop-in static overlay plus an optional hostable endpoint. Two retrieval paths: instant keyless **keyword** search (token overlap widened by the digest glossary, deep-linking to `/docs/page#anchor` with anchors from github-slugger, gated in CI by `ask digest verify`) and an **agentic** answer on Enter (needs a server-side provider API key — `ANTHROPIC_API_KEY` by default; OpenAI and OpenRouter are supported via the `provider` option, with `providerBaseUrl` for any OpenAI-compatible endpoint — and streams SSE with inline citations to opened sections). The digest is hash-gated and incremental: rebuilds skip model work for unchanged sections, and it's buildable via the Claude Code skill (subscription, sharded), the one-shot CLI `ask digest build`, or the sharded flow for big sites. Everything degrades instead of hard-failing: no key means keyword mode, no tree means plain excerpts. The corpus is only the configured content collection(s) or globs, with no crawler. The `POST /api/ask` endpoint renders on demand, so the agentic path needs a server or hybrid adapter. The digest was formerly called the knowledge graph (kg) and was a digest.json; both are legacy names. Users compare hev ask against Pagefind, Algolia DocSearch, and Orama; the Tradeoffs and Limits pages answer that directly.",
  "glossary": [
    {
      "term": "agentic search",
      "aliases": [
        "ask mode",
        "AI answers",
        "agentic loop",
        "ask ai"
      ],
      "definition": "The on-Enter path: a bounded tool-use loop that opens digest sections, then streams a grounded, deep-linked answer over SSE; requires a provider API key server-side."
    },
    {
      "term": "anchor",
      "aliases": [
        "deep link",
        "slug",
        "heading anchor"
      ],
      "definition": "The github-slugger heading id appended to a section URL so results land on the exact heading; ask digest verify gates anchors against the rendered HTML in CI."
    },
    {
      "term": "ask CLI",
      "aliases": [
        "cli",
        "ask binary",
        "ask command"
      ],
      "definition": "The ask binary: read verbs (tree, ls, head, cat, facts, grep) over the digest tree, plus producer commands under ask digest (build, corpus, assemble, verify, status, migrate)."
    },
    {
      "term": "ask digest",
      "aliases": [
        "digest",
        "kg",
        "knowledge graph",
        ".hev-ask"
      ],
      "definition": "The committed .hev-ask/ markdown tree — one distilled file per doc section with facts, anchors, glossary, and meta — built offline and read by the overlay, CLI, and MCP."
    },
    {
      "term": "disclosure ladder",
      "aliases": [
        "progressive disclosure",
        "four-rung ladder"
      ],
      "definition": "The cheap-to-expensive read order over the digest: tree/ls list titles only, then head, cat, and facts each open a larger slice of one section file."
    },
    {
      "term": "hostable endpoint",
      "aliases": [
        "standalone endpoint",
        "/api/ask",
        "search endpoint"
      ],
      "definition": "The /api/ask route contract — keyword JSON, agentic SSE, and keyless digest reads — served by the Astro integration or deployed standalone (Worker, Node, Vercel) for other frameworks."
    },
    {
      "term": "keyword search",
      "aliases": [
        "instant search",
        "keyword mode"
      ],
      "definition": "The keyless instant path: glossary-widened token-overlap ranking over heading-level chunks, returning JSON results that deep-link to section anchors."
    },
    {
      "term": "MCP server",
      "aliases": [
        "mcp",
        "ask mcp",
        "fetch_docs"
      ],
      "definition": "A stdio Model Context Protocol server with one tool that hydrates the whole digest tree to local disk so a coding agent reads it with its own tree/cat/grep."
    },
    {
      "term": "SearchOverlay",
      "aliases": [
        "overlay",
        "command palette",
        "cmd-k",
        "ask overlay"
      ],
      "definition": "The ⌘K palette component — SearchOverlay.astro on Astro, or a drop-in script-tag web component on any other site — that runs both search paths."
    },
    {
      "term": "sharded build",
      "aliases": [
        "shards",
        "shard"
      ],
      "definition": "The large-site digest flow: the corpus splits into slug-prefix shards, each distilled in a fresh context, then assembled into the merged tree — no context-window bound."
    }
  ],
  "overview": "## API\n- CLI — `api/cli`\n- Building the digest — `api/cli#building-the-digest`\n- Claude Code skill — `api/cli#claude-code-skill`\n- Distribution — `api/cli#distribution`\n- Flags — `api/cli#flags`\n- Go library — `api/cli#go-library`\n- MCP — `api/cli#mcp`\n- Reading the digest as a directory — `api/cli#reading-the-digest-as-a-directory`\n- Sharded builds for large sites — `api/cli#sharded-builds-for-large-sites`\n- Where it runs — `api/cli#where-it-runs`\n- Configuration — `api/configuration`\n- Choosing a provider — `api/configuration#choosing-a-provider`\n- Options — `api/configuration#options`\n- Tuning notes — `api/configuration#tuning-notes`\n- TypeScript — `api/configuration#typescript`\n- What the integration does — `api/configuration#what-the-integration-does`\n- Digest format — `api/digest`\n- _meta.md and _glossary/ — `api/digest#_metamd-and-_glossary`\n- A section file — `api/digest#a-section-file`\n- Degradation — `api/digest#degradation`\n- Frontmatter fields — `api/digest#frontmatter-fields`\n- How each field is used — `api/digest#how-each-field-is-used`\n- Layout — `api/digest#layout`\n- Regenerating — `api/digest#regenerating`\n- Search endpoint — `api/endpoint`\n- Agentic response (SSE) — `api/endpoint#agentic-response-sse`\n- Digest reads (GET) — `api/endpoint#digest-reads-get`\n- Errors — `api/endpoint#errors`\n- Index lifecycle — `api/endpoint#index-lifecycle`\n- Keyword response (JSON) — `api/endpoint#keyword-response-json`\n- LLM tracing — `api/endpoint#llm-tracing`\n- Mode selection — `api/endpoint#mode-selection`\n- Request — `api/endpoint#request`\n- Suggested questions (GET) — `api/endpoint#suggested-questions-get`\n- The API key — `api/endpoint#the-api-key`\n- MCP server — `api/mcp`\n- Co-location — `api/mcp#co-location`\n- Configure — `api/mcp#configure`\n- Data sources — `api/mcp#data-sources`\n- Protocol surface — `api/mcp#protocol-surface`\n- The instructions — `api/mcp#the-instructions`\n- The tool — `api/mcp#the-tool`\n- SearchOverlay component — `api/search-overlay`\n- Any static site — `api/search-overlay#any-static-site`\n- Bundling the static assets — `api/search-overlay#bundling-the-static-assets`\n- Docusaurus — `api/search-overlay#docusaurus`\n- Keyboard model — `api/search-overlay#keyboard-model`\n- Keyword results and deep links — `api/search-overlay#keyword-results-and-deep-links`\n- MkDocs — `api/search-overlay#mkdocs`\n- Opening the overlay — `api/search-overlay#opening-the-overlay`\n- Props — `api/search-overlay#props`\n- Suggested questions — `api/search-overlay#suggested-questions`\n- Support at a glance — `api/search-overlay#support-at-a-glance`\n- The hostable endpoint — `api/search-overlay#the-hostable-endpoint`\n- The mode toggle — `api/search-overlay#the-mode-toggle`\n- The overlay on other frameworks — `api/search-overlay#the-overlay-on-other-frameworks`\n- The streamed answer — `api/search-overlay#the-streamed-answer`\n- Theming — `api/search-overlay#theming`\n- VitePress — `api/search-overlay#vitepress`\n## Overview\n- Concepts — `concepts`\n- Asking is the default — `concepts#asking-is-the-default`\n- Chunks and anchors — `concepts#chunks-and-anchors`\n- Degradation, by design — `concepts#degradation-by-design`\n- Host-neutral: one digest, any framework — `concepts#host-neutral-one-digest-any-framework`\n- Keyword search and the glossary — `concepts#keyword-search-and-the-glossary`\n- Progressive disclosure as a directory — `concepts#progressive-disclosure-as-a-directory`\n- The agentic search loop — `concepts#the-agentic-search-loop`\n- The ask digest directory — `concepts#the-ask-digest-directory`\n- The system prompt is cached — `concepts#the-system-prompt-is-cached`\n- Two ways to build the tree — `concepts#two-ways-to-build-the-tree`\n- Digest creation — `digest-creation`\n- Built from markdown, not from a renderer — `digest-creation#built-from-markdown-not-from-a-renderer`\n- Incremental by hash — `digest-creation#incremental-by-hash`\n- Two ways to run the build — `digest-creation#two-ways-to-run-the-build`\n- Verify, review, commit — `digest-creation#verify-review-commit`\n- What the model writes — `digest-creation#what-the-model-writes`\n- Introduction — `index`\n- Next steps — `index#next-steps`\n- One artifact, three readers — `index#one-artifact-three-readers`\n- Who this is for — `index#who-this-is-for`\n- Limits — `limits`\n- Agentic search adds latency — `limits#agentic-search-adds-latency`\n- Anchors depend on the renderer's slugger — `limits#anchors-depend-on-the-renderers-slugger`\n- Frontmatter parsing is a flat-YAML subset — `limits#frontmatter-parsing-is-a-flat-yaml-subset`\n- Recall has a keyword ceiling — `limits#recall-has-a-keyword-ceiling`\n- Secrets live server-side — `limits#secrets-live-server-side`\n- The agentic path needs a server somewhere — `limits#the-agentic-path-needs-a-server-somewhere`\n- The corpus is the content you configure — `limits#the-corpus-is-the-content-you-configure`\n- The one-shot digest build is bounded; sharded builds are not — `limits#the-one-shot-digest-build-is-bounded-sharded-builds-are-not`\n- Quick start — `quickstart`\n- 1. Install — `quickstart#1-install`\n- 2. Register the integration — `quickstart#2-register-the-integration`\n- 3. Add a server adapter — `quickstart#3-add-a-server-adapter`\n- 4. Render the overlay — `quickstart#4-render-the-overlay`\n- 5. Build the digest — `quickstart#5-build-the-digest`\n- Enable agentic search — `quickstart#enable-agentic-search`\n- Prerequisites — `quickstart#prerequisites`\n- Set up keyword search — `quickstart#set-up-keyword-search`\n- Verify it works — `quickstart#verify-it-works`\n- Tradeoffs — `tradeoffs`\n- A committed digest — `tradeoffs#a-committed-digest`\n- A flagship adapter, primitives for the rest — `tradeoffs#a-flagship-adapter-primitives-for-the-rest`\n- Cost and latency of agentic search — `tradeoffs#cost-and-latency-of-agentic-search`\n- How it compares — `tradeoffs#how-it-compares`\n- Keyword retrieval, not embeddings — `tradeoffs#keyword-retrieval-not-embeddings`\n- One dependency, deliberately — `tradeoffs#one-dependency-deliberately`\n- Two paths instead of one — `tradeoffs#two-paths-instead-of-one`",
  "suggestions": [
    "How do I add hev ask to my Astro site?",
    "Can I use hev ask on Docusaurus or MkDocs?",
    "How does the agentic answer loop work?",
    "How do I build and refresh the ask digest?",
    "What can't hev ask do?"
  ],
  "nodes": [
    {
      "id": "api/cli",
      "kind": "section",
      "title": "CLI",
      "heading": null,
      "group": "API",
      "url": "/docs/api/cli",
      "summary": "Overview of the ask binary's two command groups: read verbs that treat the committed digest as a directory (map, skim, open, pull facts, search, plus a synthesized answer command and an MCP server), and producer commands under the digest group for building, verifying, and migrating the tree.",
      "hash": "bdfb1e0237588bbd0d990adfcb20a1e0eec2b2e35ea6dd867d23082fd3262e81",
      "facts": [
        {
          "kind": "code",
          "literal": "@hevmind/ask",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "ask",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "ls",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "head",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "answer",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "mcp",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "ask digest",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "build",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "corpus",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "assemble",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "verify",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "status",
          "chunkId": "api/cli"
        },
        {
          "kind": "code",
          "literal": "migrate",
          "chunkId": "api/cli"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "api/cli"
        },
        {
          "kind": "value",
          "literal": "CodeTabs.astro",
          "chunkId": "api/cli"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli",
          "url": "/docs/api/cli",
          "anchor": null
        }
      ],
      "mode": "source-primary",
      "terms": [
        "overview",
        "binary",
        "command",
        "groups",
        "read",
        "verbs",
        "treat",
        "committed",
        "digest",
        "directory",
        "skim",
        "open",
        "pull",
        "facts",
        "search",
        "plus",
        "synthesized",
        "answer",
        "server",
        "producer",
        "commands",
        "under",
        "group",
        "building",
        "verifying",
        "migrating",
        "tree",
        "hevmind",
        "head",
        "grep",
        "build",
        "corpus",
        "assemble",
        "verify",
        "status",
        "migrate",
        "callout",
        "astro",
        "codetabs",
        "reads"
      ]
    },
    {
      "id": "api/cli#building-the-digest",
      "kind": "section",
      "title": "CLI",
      "heading": "Building the digest",
      "group": "API",
      "url": "/docs/api/cli#building-the-digest",
      "summary": "Lists the producer commands run from the site root and explains that only the build command calls a model (so only it needs a key, selectable per provider). Builds are incremental and hash-gated — only changed sections are re-distilled, a clean tree makes zero model calls — and the one-shot build fails past 600KB of new section text, pointing to the sharded flow. A migrate command converts a legacy digest.json to the tree with no model call.",
      "hash": "c8c9b3c2808376bf87bc7128a3a9a84bdde6aa70ac2011e1ccb1debae2976f33",
      "facts": [
        {
          "kind": "code",
          "literal": "export ANTHROPIC_API_KEY=sk-ant-...\nask digest build                    # claude-opus-4-8 by default",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "export OPENAI_API_KEY=sk-...\nask digest build --provider openai  # gpt-5.1 by default",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "export OPENROUTER_API_KEY=sk-or-...\nask digest build --provider openrouter   # anthropic/claude-opus-4.8 by default",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "--provider",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "ask digest corpus",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "ask digest assemble",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "context",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "summaries",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "suggestions",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": ".hev-ask/digest.json",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "code",
          "literal": "ask digest migrate",
          "chunkId": "api/cli#building-the-digest"
        },
        {
          "kind": "value",
          "literal": "digest.json",
          "chunkId": "api/cli#building-the-digest"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#building-the-digest",
          "url": "/docs/api/cli#building-the-digest",
          "anchor": "building-the-digest"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "building",
        "digest",
        "lists",
        "producer",
        "commands",
        "site",
        "root",
        "explains",
        "only",
        "build",
        "command",
        "calls",
        "model",
        "needs",
        "selectable",
        "provider",
        "builds",
        "incremental",
        "hash",
        "gated",
        "changed",
        "sections",
        "distilled",
        "clean",
        "tree",
        "makes",
        "zero",
        "shot",
        "fails",
        "past",
        "600kb",
        "section",
        "text",
        "pointing",
        "sharded",
        "flow",
        "migrate",
        "converts",
        "legacy",
        "json"
      ]
    },
    {
      "id": "api/cli#claude-code-skill",
      "kind": "section",
      "title": "CLI",
      "heading": "Claude Code skill",
      "group": "API",
      "url": "/docs/api/cli#claude-code-skill",
      "summary": "The bundled build-digest skill builds the tree inside a Claude Code subscription instead of spending API tokens: it runs the deterministic producer seam sharded (corpus to per-shard inputs, one fresh-context distillation per shard, a synthesis pass, then assemble). Per-shard contexts mean corpus size never hits a context limit, and the output is identical in shape to a normal build with the same incremental hash gate.",
      "hash": "443db6e48ac36d708dfd7e6b19f5e65b8f34ee4eb0675c8da98bd86cacfecc96",
      "facts": [
        {
          "kind": "code",
          "literal": "ask digest corpus --shards-dir .hev-ask/shards    -> input-<id>.json + manifest.json\n...one fresh-context distillation per shard       -> distill-<id>.json...\n...one synthesis pass over the shard notes        -> global.json...\nask digest assemble --input-dir .hev-ask/shards   -> the .hev-ask/ tree",
          "chunkId": "api/cli#claude-code-skill"
        },
        {
          "kind": "code",
          "literal": "build-digest",
          "chunkId": "api/cli#claude-code-skill"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "api/cli#claude-code-skill"
        },
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "api/cli#claude-code-skill"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#claude-code-skill",
          "url": "/docs/api/cli#claude-code-skill",
          "anchor": "claude-code-skill"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "claude",
        "code",
        "skill",
        "bundled",
        "build",
        "digest",
        "builds",
        "tree",
        "inside",
        "subscription",
        "instead",
        "spending",
        "tokens",
        "runs",
        "deterministic",
        "producer",
        "seam",
        "sharded",
        "corpus",
        "shard",
        "inputs",
        "fresh",
        "context",
        "distillation",
        "synthesis",
        "pass",
        "assemble",
        "contexts",
        "mean",
        "size",
        "never",
        "hits",
        "limit",
        "output",
        "identical",
        "shape",
        "normal",
        "same",
        "incremental",
        "hash"
      ]
    },
    {
      "id": "api/cli#distribution",
      "kind": "section",
      "title": "CLI",
      "heading": "Distribution",
      "group": "API",
      "url": "/docs/api/cli#distribution",
      "summary": "The npm package exposes a single bin whose launcher resolves an env-var override first, then a platform-specific optional binary package, then the checked-out Go source (the latter only for monorepo development).",
      "hash": "6ca69ef59f845bf9734dc9ec208f3fa63fdd9272703d454891bdbebb56fcda55",
      "facts": [
        {
          "kind": "code",
          "literal": "ask",
          "chunkId": "api/cli#distribution"
        },
        {
          "kind": "code",
          "literal": "HEV_ASK_BINARY",
          "chunkId": "api/cli#distribution"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#distribution",
          "url": "/docs/api/cli#distribution",
          "anchor": "distribution"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "distribution",
        "package",
        "exposes",
        "single",
        "whose",
        "launcher",
        "resolves",
        "override",
        "first",
        "platform",
        "specific",
        "optional",
        "binary",
        "checked",
        "source",
        "latter",
        "only",
        "monorepo",
        "development",
        "hevaskbinary",
        "installed",
        "fallback",
        "published",
        "installs",
        "packaged",
        "path"
      ]
    },
    {
      "id": "api/cli#flags",
      "kind": "section",
      "title": "CLI",
      "heading": "Flags",
      "group": "API",
      "url": "/docs/api/cli#flags",
      "summary": "Reference table of global CLI flags covering the digest directory, remote endpoint, JSON output, result caps, collection and path options for producer commands, chunking depth, model and provider selection, sharded-mode directories and sizing, and verify's build-command, skip-build, and strict options. Global flags come before the command.",
      "hash": "fbe4499ab9007659db664eec6e7693dc252eab668c4d136ca4287dd223be1d52",
      "facts": [
        {
          "kind": "code",
          "literal": "ask --digest-dir .hev-ask --json grep \"openapi\"\nask --endpoint https://hevask.com/api/ask cat api/endpoint\nask digest build --collection docs --collection guides --chunk-heading-depth 2\nask digest verify --skip-build",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--digest-dir <dir>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": ".hev-ask",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--endpoint <url>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "answer",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--json",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--max-results <n>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--collection <name>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "docs",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--base-path <path>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "/docs/",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--content-glob <glob>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--chunk-heading-depth <n>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--digest-model <model>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "claude-opus-4-8",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "--provider <name>",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "anthropic",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "openai",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "openrouter",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "api/cli#flags"
        },
        {
          "kind": "code",
          "literal": "OPENAI_API_KEY",
          "chunkId": "api/cli#flags"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#flags",
          "url": "/docs/api/cli#flags",
          "anchor": "flags"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "flags",
        "reference",
        "table",
        "global",
        "covering",
        "digest",
        "directory",
        "remote",
        "endpoint",
        "json",
        "output",
        "result",
        "caps",
        "collection",
        "path",
        "options",
        "producer",
        "commands",
        "chunking",
        "depth",
        "model",
        "provider",
        "selection",
        "sharded",
        "mode",
        "directories",
        "sizing",
        "verify",
        "build",
        "command",
        "skip",
        "strict",
        "come",
        "before",
        "grep",
        "openapi",
        "https",
        "hevask",
        "docs",
        "guides"
      ]
    },
    {
      "id": "api/cli#go-library",
      "kind": "section",
      "title": "CLI",
      "heading": "Go library",
      "group": "API",
      "url": "/docs/api/cli#go-library",
      "summary": "The reusable Go API in pkg/ask offers pure helpers (loading the digest from a tree or embedded filesystem, listing summaries, getting sections, searching, an endpoint client, and serving MCP) or a dependency-free command group you can mount inside your own CLI.",
      "hash": "fdda297bbdabdbd250da161cec7574e09209c99f50b254923354681e1bef245c",
      "facts": [
        {
          "kind": "code",
          "literal": "group := ask.NewCommandGroup(ask.CommandOptions{\n\tDigestDir: \".hev-ask\",\n})\nerr := group.Run(ctx, []string{\"cat\", \"overview/quick-start\"}, os.Stdin, os.Stdout, os.Stderr)",
          "chunkId": "api/cli#go-library"
        },
        {
          "kind": "code",
          "literal": "pkg/ask",
          "chunkId": "api/cli#go-library"
        },
        {
          "kind": "code",
          "literal": "LoadDigest",
          "chunkId": "api/cli#go-library"
        },
        {
          "kind": "code",
          "literal": "embed.FS",
          "chunkId": "api/cli#go-library"
        },
        {
          "kind": "code",
          "literal": "ListSectionSummaries",
          "chunkId": "api/cli#go-library"
        },
        {
          "kind": "code",
          "literal": "GetSection",
          "chunkId": "api/cli#go-library"
        },
        {
          "kind": "code",
          "literal": "SearchDigest",
          "chunkId": "api/cli#go-library"
        },
        {
          "kind": "code",
          "literal": "NewEndpointClient",
          "chunkId": "api/cli#go-library"
        },
        {
          "kind": "code",
          "literal": "ServeMCP",
          "chunkId": "api/cli#go-library"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#go-library",
          "url": "/docs/api/cli#go-library",
          "anchor": "go-library"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "library",
        "reusable",
        "offers",
        "pure",
        "helpers",
        "loading",
        "digest",
        "tree",
        "embedded",
        "filesystem",
        "listing",
        "summaries",
        "getting",
        "sections",
        "searching",
        "endpoint",
        "client",
        "serving",
        "dependency",
        "free",
        "command",
        "group",
        "mount",
        "inside",
        "newcommandgroup",
        "commandoptions",
        "digestdir",
        "string",
        "overview",
        "quick",
        "start",
        "stdin",
        "stdout",
        "stderr",
        "loaddigest",
        "embed",
        "listsectionsummaries",
        "getsection",
        "searchdigest",
        "newendpointclient"
      ]
    },
    {
      "id": "api/cli#mcp",
      "kind": "section",
      "title": "CLI",
      "heading": "MCP",
      "group": "API",
      "url": "/docs/api/cli#mcp",
      "summary": "The mcp subcommand runs a stdio MCP server with one tool that downloads the whole digest tree to local disk and returns the title-tree inline, after which the agent uses its own file tools. It can point at a checked-out repo or a deployed endpoint via configuration.",
      "hash": "e9ba5f690d5158797f3f370cbc8f7a816946b64c3da22ea8ece21bc4d9afba91",
      "facts": [
        {
          "kind": "code",
          "literal": "{\n  \"mcpServers\": {\n    \"hevask\": {\n      \"command\": \"ask\",\n      \"args\": [\"--endpoint\", \"https://hevask.com/api/ask\", \"mcp\"]\n    }\n  }\n}",
          "chunkId": "api/cli#mcp"
        },
        {
          "kind": "code",
          "literal": "ask mcp",
          "chunkId": "api/cli#mcp"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "api/cli#mcp"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "api/cli#mcp"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "api/cli#mcp"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#mcp",
          "url": "/docs/api/cli#mcp",
          "anchor": "mcp"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "subcommand",
        "runs",
        "stdio",
        "server",
        "tool",
        "downloads",
        "whole",
        "digest",
        "tree",
        "local",
        "disk",
        "returns",
        "title",
        "inline",
        "after",
        "agent",
        "uses",
        "file",
        "tools",
        "point",
        "checked",
        "repo",
        "deployed",
        "endpoint",
        "configuration",
        "mcpservers",
        "hevask",
        "command",
        "args",
        "https",
        "grep",
        "reads",
        "files",
        "page",
        "instructions",
        "ships",
        "archive",
        "cache"
      ]
    },
    {
      "id": "api/cli#reading-the-digest-as-a-directory",
      "kind": "section",
      "title": "CLI",
      "heading": "Reading the digest as a directory",
      "group": "API",
      "url": "/docs/api/cli#reading-the-digest-as-a-directory",
      "summary": "Read verbs are path-addressed, mirroring doc URLs, and read the local tree by default or a deployed site's HTTP API with the endpoint flag. The four rungs go cheap to expensive: listings return titles only and are bounded by section count, while head, cat, and facts open progressively larger slices of one section file. The answer command needs a remote endpoint; grep plus cat is the keyless local path.",
      "hash": "921d271069e2a1fe2f0c8151c6b5b5868db94ce01f0da17fdc5dd117d717bd20",
      "facts": [
        {
          "kind": "code",
          "literal": "ask",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "--endpoint <url>",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "ls",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "head",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "ask answer",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "--endpoint",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "ask grep",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "ask cat",
          "chunkId": "api/cli#reading-the-digest-as-a-directory"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#reading-the-digest-as-a-directory",
          "url": "/docs/api/cli#reading-the-digest-as-a-directory",
          "anchor": "reading-the-digest-as-a-directory"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "reading",
        "digest",
        "directory",
        "read",
        "verbs",
        "path",
        "addressed",
        "mirroring",
        "urls",
        "local",
        "tree",
        "default",
        "deployed",
        "site",
        "http",
        "endpoint",
        "flag",
        "four",
        "rungs",
        "cheap",
        "expensive",
        "listings",
        "return",
        "titles",
        "only",
        "bounded",
        "section",
        "count",
        "while",
        "head",
        "facts",
        "open",
        "progressively",
        "larger",
        "slices",
        "file",
        "answer",
        "command",
        "needs",
        "remote"
      ]
    },
    {
      "id": "api/cli#sharded-builds-for-large-sites",
      "kind": "section",
      "title": "CLI",
      "heading": "Sharded builds for large sites",
      "group": "API",
      "url": "/docs/api/cli#sharded-builds-for-large-sites",
      "summary": "The sharded flow removes the first-build context bound: the corpus splits along slug-prefix boundaries, each shard is distilled in a fresh context, and assembly merges the tree. Sharding is stable and incremental — editing one doc re-pends only its shard, and stale distillations are detected by shard hash, skipped with a warning, and fall back to plain excerpts until re-distilled. Verify checks rendered anchors (always fatal on drift), coverage, literal fidelity, and tree integrity (warnings unless strict).",
      "hash": "edb0ce1e92994c33baa1814a21cdfb79ae95bdf7c3ffc385218dcd0f79c2d35e",
      "facts": [
        {
          "kind": "code",
          "literal": "ask digest corpus --shards-dir .hev-ask/shards   # input-<id>.json per shard + manifest.json\nask digest status --shards-dir .hev-ask/shards   # distilled / pending / stale, per shard\n# ...one distillation per shard writes distill-<id>.json; a final pass writes global.json...\nask digest assemble --input-dir .hev-ask/shards  # merge + write the .hev-ask/ tree",
          "chunkId": "api/cli#sharded-builds-for-large-sites"
        },
        {
          "kind": "code",
          "literal": "workers/...",
          "chunkId": "api/cli#sharded-builds-for-large-sites"
        },
        {
          "kind": "code",
          "literal": "pages/...",
          "chunkId": "api/cli#sharded-builds-for-large-sites"
        },
        {
          "kind": "code",
          "literal": "corpus",
          "chunkId": "api/cli#sharded-builds-for-large-sites"
        },
        {
          "kind": "code",
          "literal": "ask digest verify",
          "chunkId": "api/cli#sharded-builds-for-large-sites"
        },
        {
          "kind": "code",
          "literal": "--skip-build",
          "chunkId": "api/cli#sharded-builds-for-large-sites"
        },
        {
          "kind": "code",
          "literal": "_meta.md",
          "chunkId": "api/cli#sharded-builds-for-large-sites"
        },
        {
          "kind": "code",
          "literal": "--strict",
          "chunkId": "api/cli#sharded-builds-for-large-sites"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#sharded-builds-for-large-sites",
          "url": "/docs/api/cli#sharded-builds-for-large-sites",
          "anchor": "sharded-builds-for-large-sites"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "sharded",
        "builds",
        "large",
        "sites",
        "flow",
        "removes",
        "first",
        "build",
        "context",
        "bound",
        "corpus",
        "splits",
        "along",
        "slug",
        "prefix",
        "boundaries",
        "shard",
        "distilled",
        "fresh",
        "assembly",
        "merges",
        "tree",
        "sharding",
        "stable",
        "incremental",
        "editing",
        "pends",
        "only",
        "stale",
        "distillations",
        "detected",
        "hash",
        "skipped",
        "warning",
        "fall",
        "back",
        "plain",
        "excerpts",
        "until",
        "verify"
      ]
    },
    {
      "id": "api/cli#where-it-runs",
      "kind": "section",
      "title": "CLI",
      "heading": "Where it runs",
      "group": "API",
      "url": "/docs/api/cli#where-it-runs",
      "summary": "Producer commands run locally or in CI with filesystem access; the Astro integration also runs the digest build during the site build when a key is present, falling back to the committed tree. The deployed site reads the tree through a virtual module with no filesystem access, and running verify on every build is the mechanical check that anchors still match what Astro renders.",
      "hash": "3160b534adda5d403ca544d7fa24738f6edc01c050b30b719a2cc04be4a6eede",
      "facts": [
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "api/cli#where-it-runs"
        },
        {
          "kind": "code",
          "literal": "astro build",
          "chunkId": "api/cli#where-it-runs"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "api/cli#where-it-runs"
        },
        {
          "kind": "code",
          "literal": "virtual:hev-ask/digest",
          "chunkId": "api/cli#where-it-runs"
        },
        {
          "kind": "code",
          "literal": "ask digest verify",
          "chunkId": "api/cli#where-it-runs"
        }
      ],
      "sources": [
        {
          "chunkId": "api/cli#where-it-runs",
          "url": "/docs/api/cli#where-it-runs",
          "anchor": "where-it-runs"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "runs",
        "producer",
        "commands",
        "locally",
        "filesystem",
        "access",
        "astro",
        "integration",
        "also",
        "digest",
        "build",
        "during",
        "site",
        "present",
        "falling",
        "back",
        "committed",
        "tree",
        "deployed",
        "reads",
        "through",
        "virtual",
        "module",
        "running",
        "verify",
        "every",
        "mechanical",
        "check",
        "anchors",
        "still",
        "match",
        "renders",
        "anthropic",
        "invokes",
        "anthropicapikey",
        "falls",
        "command",
        "cannot",
        "does",
        "need"
      ]
    },
    {
      "id": "api/configuration",
      "kind": "section",
      "title": "Configuration",
      "heading": null,
      "group": "API",
      "url": "/docs/api/configuration",
      "summary": "The hevAsk() integration is the package's default export and takes one options object; only the collections option is effectively required, everything else defaults.",
      "hash": "e7c504dd58a7e10c8e9f034b0d0ce1286da961ec8f56fbe2ad5ad932f90fcbf6",
      "facts": [
        {
          "kind": "code",
          "literal": "// astro.config.mjs\nimport hevAsk from \"@hevmind/ask\";\n\nexport default defineConfig({\n  integrations: [\n    hevAsk({\n      collections: [\"docs\"],\n      basePath: \"/docs/\",\n      model: \"claude-haiku-4-5\",\n      maxResults: 6,\n    }),\n  ],\n});",
          "chunkId": "api/configuration"
        },
        {
          "kind": "code",
          "literal": "hevAsk()",
          "chunkId": "api/configuration"
        },
        {
          "kind": "code",
          "literal": "@hevmind/ask",
          "chunkId": "api/configuration"
        },
        {
          "kind": "code",
          "literal": "collections",
          "chunkId": "api/configuration"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "api/configuration"
        },
        {
          "kind": "value",
          "literal": "CodeTabs.astro",
          "chunkId": "api/configuration"
        }
      ],
      "sources": [
        {
          "chunkId": "api/configuration",
          "url": "/docs/api/configuration",
          "anchor": null
        }
      ],
      "mode": "source-primary",
      "terms": [
        "hevask",
        "integration",
        "package",
        "default",
        "export",
        "takes",
        "options",
        "object",
        "only",
        "collections",
        "option",
        "effectively",
        "required",
        "everything",
        "else",
        "defaults",
        "astro",
        "config",
        "import",
        "hevmind",
        "defineconfig",
        "integrations",
        "docs",
        "basepath",
        "model",
        "claude",
        "haiku",
        "maxresults",
        "callout",
        "codetabs",
        "every",
        "models",
        "endpoint",
        "chunking",
        "depth",
        "retrieval",
        "caps",
        "digest",
        "paths"
      ]
    },
    {
      "id": "api/configuration#choosing-a-provider",
      "kind": "section",
      "title": "Configuration",
      "heading": "Choosing a provider",
      "group": "API",
      "url": "/docs/api/configuration#choosing-a-provider",
      "summary": "The provider option selects who serves both the runtime loop and the offline digest build — behavior, digest format, and endpoint contract are identical; only the model defaults and key env var change. OpenRouter reaches any model it routes with one key, and a base-URL override makes any OpenAI-compatible endpoint work. Loop models must support tool calling; the digest builder also needs forced tool choice.",
      "hash": "64020ee9bbb713bf179bf7c6d3f2673b780e483e4c6b7f584c829f690db6acd3",
      "facts": [
        {
          "kind": "code",
          "literal": "// astro.config.mjs — the default; reads ANTHROPIC_API_KEY\nhevAsk({\n  collections: [\"docs\"],\n  // model defaults to claude-haiku-4-5\n});",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "// astro.config.mjs — reads OPENAI_API_KEY\nhevAsk({\n  collections: [\"docs\"],\n  provider: \"openai\",\n  // model defaults to gpt-4.1-mini\n});",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "// astro.config.mjs — reads OPENROUTER_API_KEY\nhevAsk({\n  collections: [\"docs\"],\n  provider: \"openrouter\",\n  model: \"anthropic/claude-haiku-4.5\", // or any OpenRouter model slug\n});",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "hevAsk({\n  collections: [\"docs\"],\n  provider: \"openai\",\n  providerBaseUrl: \"https://my-gateway.example.com/v1\",\n  model: \"my-model\",\n});",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "provider",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "OPENROUTER_API_KEY",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "providerBaseUrl",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "provider: \"openai\"",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "endpoint",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "api/configuration#choosing-a-provider"
        },
        {
          "kind": "code",
          "literal": "SearchOverlay",
          "chunkId": "api/configuration#choosing-a-provider"
        }
      ],
      "sources": [
        {
          "chunkId": "api/configuration#choosing-a-provider",
          "url": "/docs/api/configuration#choosing-a-provider",
          "anchor": "choosing-a-provider"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "choosing",
        "provider",
        "option",
        "selects",
        "serves",
        "both",
        "runtime",
        "loop",
        "offline",
        "digest",
        "build",
        "behavior",
        "format",
        "endpoint",
        "contract",
        "identical",
        "only",
        "model",
        "defaults",
        "change",
        "openrouter",
        "reaches",
        "routes",
        "base",
        "override",
        "makes",
        "openai",
        "compatible",
        "work",
        "models",
        "must",
        "support",
        "tool",
        "calling",
        "builder",
        "also",
        "needs",
        "forced",
        "choice",
        "astro"
      ]
    },
    {
      "id": "api/configuration#options",
      "kind": "section",
      "title": "Configuration",
      "heading": "Options",
      "group": "API",
      "url": "/docs/api/configuration#options",
      "summary": "Full options table for the integration: collections and basePath define the corpus and URLs; endpoint, provider, providerBaseUrl, model, and digestModel control routing and inference; maxResults, answerMaxTokens, maxIterations, chunkHeadingDepth, candidatePerSearch, and perDocCap tune retrieval and the loop; digestDir and digestContentGlobs locate the committed tree and build sources.",
      "hash": "3d7084435ad219aa81a8c7a65fc84859b1ef0613d128fa21ec4a2178b4fa7eb9",
      "facts": [
        {
          "kind": "code",
          "literal": "collections",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "string[]",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "basePath",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "string",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "'/docs/'",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "basePath + slug",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "#anchor",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "endpoint",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "'/api/ask'",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "provider",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "'anthropic'",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "'openai'",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "'openrouter'",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "OPENAI_API_KEY",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "OPENROUTER_API_KEY",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "providerBaseUrl",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "model",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "claude-haiku-4-5",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "gpt-4.1-mini",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "anthropic/claude-haiku-4.5",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "digestModel",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "claude-opus-4-8",
          "chunkId": "api/configuration#options"
        },
        {
          "kind": "code",
          "literal": "gpt-5.1",
          "chunkId": "api/configuration#options"
        }
      ],
      "sources": [
        {
          "chunkId": "api/configuration#options",
          "url": "/docs/api/configuration#options",
          "anchor": "options"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "options",
        "full",
        "table",
        "integration",
        "collections",
        "basepath",
        "define",
        "corpus",
        "urls",
        "endpoint",
        "provider",
        "providerbaseurl",
        "model",
        "digestmodel",
        "control",
        "routing",
        "inference",
        "maxresults",
        "answermaxtokens",
        "maxiterations",
        "chunkheadingdepth",
        "candidatepersearch",
        "perdoccap",
        "tune",
        "retrieval",
        "loop",
        "digestdir",
        "digestcontentglobs",
        "locate",
        "committed",
        "tree",
        "build",
        "sources",
        "string",
        "docs",
        "slug",
        "anchor",
        "anthropic",
        "openai",
        "openrouter"
      ]
    },
    {
      "id": "api/configuration#tuning-notes",
      "kind": "section",
      "title": "Configuration",
      "heading": "Tuning notes",
      "group": "API",
      "url": "/docs/api/configuration#tuning-notes",
      "summary": "Practical tuning guidance: chunking depth trades finer anchors against too-small sections, the iteration cap trades latency against multi-part-question recall, the per-document cap controls result spread, and candidates-per-search trades recall against token cost.",
      "hash": "357904627c549ccc59120393a2316912522af1027d5a3d35be21390520aadac2",
      "facts": [
        {
          "kind": "code",
          "literal": "chunkHeadingDepth",
          "chunkId": "api/configuration#tuning-notes"
        },
        {
          "kind": "code",
          "literal": "###",
          "chunkId": "api/configuration#tuning-notes"
        },
        {
          "kind": "code",
          "literal": "maxIterations",
          "chunkId": "api/configuration#tuning-notes"
        },
        {
          "kind": "code",
          "literal": "perDocCap",
          "chunkId": "api/configuration#tuning-notes"
        },
        {
          "kind": "code",
          "literal": "candidatePerSearch",
          "chunkId": "api/configuration#tuning-notes"
        }
      ],
      "sources": [
        {
          "chunkId": "api/configuration#tuning-notes",
          "url": "/docs/api/configuration#tuning-notes",
          "anchor": "tuning-notes"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "tuning",
        "notes",
        "practical",
        "guidance",
        "chunking",
        "depth",
        "trades",
        "finer",
        "anchors",
        "against",
        "small",
        "sections",
        "iteration",
        "latency",
        "multi",
        "part",
        "question",
        "recall",
        "document",
        "controls",
        "result",
        "spread",
        "candidates",
        "search",
        "token",
        "cost",
        "chunkheadingdepth",
        "maxiterations",
        "perdoccap",
        "candidatepersearch",
        "chunk",
        "granularity",
        "raise",
        "default",
        "section",
        "long",
        "pages",
        "drop",
        "stand",
        "alone"
      ]
    },
    {
      "id": "api/configuration#typescript",
      "kind": "section",
      "title": "Configuration",
      "heading": "TypeScript",
      "group": "API",
      "url": "/docs/api/configuration#typescript",
      "summary": "The integration's options type is exported for editor completion and typed configs.",
      "hash": "9bf5a2870c8b34a8276f2eea78e055b318b7af5e01ed708d3c91be079700f844",
      "facts": [
        {
          "kind": "code",
          "literal": "import type { HevAskOptions } from \"@hevmind/ask\";",
          "chunkId": "api/configuration#typescript"
        }
      ],
      "sources": [
        {
          "chunkId": "api/configuration#typescript",
          "url": "/docs/api/configuration#typescript",
          "anchor": "typescript"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "typescript",
        "integration",
        "options",
        "type",
        "exported",
        "editor",
        "completion",
        "typed",
        "configs",
        "import",
        "hevaskoptions",
        "hevmind",
        "help",
        "config",
        "typing"
      ]
    },
    {
      "id": "api/configuration#what-the-integration-does",
      "kind": "section",
      "title": "Configuration",
      "heading": "What the integration does",
      "group": "API",
      "url": "/docs/api/configuration#what-the-integration-does",
      "summary": "At Astro config setup the integration injects the on-demand endpoint route, registers the config and digest virtual modules, watches the digest directory for dev reloads, and warns on empty collections. At build start it runs the hash-gated digest build when the provider key is present, otherwise warns and proceeds with the committed artifact — the build never fails for lack of a key.",
      "hash": "0b9a79f3448bfbbfaff7b1b2d3b80844d670db91fb5228cd58d14f8a8f57220a",
      "facts": [
        {
          "kind": "code",
          "literal": "astro:config:setup",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "endpoint",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "@hevmind/ask/endpoint",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "prerender: false",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "virtual:hev-ask/config",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "virtual:hev-ask/digest",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "digestDir",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "collections",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "astro:build:start",
          "chunkId": "api/configuration#what-the-integration-does"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "api/configuration#what-the-integration-does"
        }
      ],
      "sources": [
        {
          "chunkId": "api/configuration#what-the-integration-does",
          "url": "/docs/api/configuration#what-the-integration-does",
          "anchor": "what-the-integration-does"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "integration",
        "does",
        "astro",
        "config",
        "setup",
        "injects",
        "demand",
        "endpoint",
        "route",
        "registers",
        "digest",
        "virtual",
        "modules",
        "watches",
        "directory",
        "reloads",
        "warns",
        "empty",
        "collections",
        "build",
        "start",
        "runs",
        "hash",
        "gated",
        "provider",
        "present",
        "otherwise",
        "proceeds",
        "committed",
        "artifact",
        "never",
        "fails",
        "lack",
        "hevmind",
        "prerender",
        "false",
        "digestdir",
        "anthropic",
        "starts",
        "pointing"
      ]
    },
    {
      "id": "api/digest",
      "kind": "section",
      "title": "Digest format",
      "heading": null,
      "group": "API",
      "url": "/docs/api/digest",
      "summary": "The ask digest is a committed directory built offline and globbed into the build through a virtual module, so the running site reads it with no filesystem access. It is the agent's view of the docs — a distilled, source-grounded mirror read progressively, where every section carries a url and anchor back to the live page. Earlier versions used a single JSON file; before 0.1 it was called the knowledge graph.",
      "hash": "b6293e0ab65f8b5986d57524cc424f78c9c857f9f546fc9998fbb7c7ac72221b",
      "facts": [
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "api/digest"
        },
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "api/digest"
        },
        {
          "kind": "code",
          "literal": "digest.json",
          "chunkId": "api/digest"
        },
        {
          "kind": "code",
          "literal": "kg",
          "chunkId": "api/digest"
        },
        {
          "kind": "code",
          "literal": "virtual:hev-ask/digest",
          "chunkId": "api/digest"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "api/digest"
        },
        {
          "kind": "code",
          "literal": "anchor",
          "chunkId": "api/digest"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "api/digest"
        },
        {
          "kind": "value",
          "literal": "0.1",
          "chunkId": "api/digest"
        }
      ],
      "sources": [
        {
          "chunkId": "api/digest",
          "url": "/docs/api/digest",
          "anchor": null
        }
      ],
      "mode": "source-primary",
      "terms": [
        "digest",
        "committed",
        "directory",
        "built",
        "offline",
        "globbed",
        "build",
        "through",
        "virtual",
        "module",
        "running",
        "site",
        "reads",
        "filesystem",
        "access",
        "agent",
        "view",
        "docs",
        "distilled",
        "source",
        "grounded",
        "mirror",
        "read",
        "progressively",
        "every",
        "section",
        "carries",
        "anchor",
        "back",
        "live",
        "page",
        "earlier",
        "versions",
        "single",
        "json",
        "file",
        "before",
        "called",
        "knowledge",
        "graph"
      ]
    },
    {
      "id": "api/digest#_metamd-and-_glossary",
      "kind": "section",
      "title": "Digest format",
      "heading": "_meta.md and _glossary/",
      "group": "API",
      "url": "/docs/api/digest#_metamd-and-_glossary",
      "summary": "The meta file carries digest-level fields — version, generation time, and content hash in frontmatter, plus the orientation context, overview map, and the overlay's suggested questions in the body. The glossary directory holds one file per term with aliases in frontmatter and the definition in the body; aliases widen keyword queries before retrieval.",
      "hash": "942dcfb8559c766f29833404f3162b513322dc3ebc5e47d56806d1b513206465",
      "facts": [
        {
          "kind": "code",
          "literal": "_meta.md",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "_glossary/",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "version",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "generatedAt",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "contentHash",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "context",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "overview",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "suggestions",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "_glossary/<term>.md",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "term",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "aliases",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "definition",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "k8s",
          "chunkId": "api/digest#_metamd-and-_glossary"
        },
        {
          "kind": "code",
          "literal": "kubernetes",
          "chunkId": "api/digest#_metamd-and-_glossary"
        }
      ],
      "sources": [
        {
          "chunkId": "api/digest#_metamd-and-_glossary",
          "url": "/docs/api/digest#_metamd-and-_glossary",
          "anchor": "_metamd-and-_glossary"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "meta",
        "glossary",
        "file",
        "carries",
        "digest",
        "level",
        "fields",
        "version",
        "generation",
        "time",
        "content",
        "hash",
        "frontmatter",
        "plus",
        "orientation",
        "context",
        "overview",
        "overlay",
        "suggested",
        "questions",
        "body",
        "directory",
        "holds",
        "term",
        "aliases",
        "definition",
        "widen",
        "keyword",
        "queries",
        "before",
        "retrieval",
        "generatedat",
        "contenthash",
        "suggestions",
        "kubernetes",
        "freshness",
        "gate",
        "group",
        "section",
        "ordering"
      ]
    },
    {
      "id": "api/digest#a-section-file",
      "kind": "section",
      "title": "Digest format",
      "heading": "A section file",
      "group": "API",
      "url": "/docs/api/digest#a-section-file",
      "summary": "Anatomy of one section file: frontmatter holds the title, heading, group, order, url, anchor, terms, hash, mode, verbatim facts, and sources; the first body paragraph is the summary served by head, the full body is served by cat, and the frontmatter facts are served by the facts verb — one file, three rungs of the disclosure ladder.",
      "hash": "09b10b67fd7759b696a8d7228b5a49dcac296da426f707c2a64076a2cad56437",
      "facts": [
        {
          "kind": "code",
          "literal": "head",
          "chunkId": "api/digest#a-section-file"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "api/digest#a-section-file"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "api/digest#a-section-file"
        }
      ],
      "sources": [
        {
          "chunkId": "api/digest#a-section-file",
          "url": "/docs/api/digest#a-section-file",
          "anchor": "a-section-file"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "section",
        "file",
        "anatomy",
        "frontmatter",
        "holds",
        "title",
        "heading",
        "group",
        "order",
        "anchor",
        "terms",
        "hash",
        "mode",
        "verbatim",
        "facts",
        "sources",
        "first",
        "body",
        "paragraph",
        "summary",
        "served",
        "head",
        "full",
        "verb",
        "three",
        "rungs",
        "disclosure",
        "ladder",
        "quick",
        "start",
        "astro",
        "site",
        "five",
        "minutes",
        "overview",
        "docs",
        "quickstart",
        "digest",
        "integration",
        "adapter"
      ]
    },
    {
      "id": "api/digest#degradation",
      "kind": "section",
      "title": "Digest format",
      "heading": "Degradation",
      "group": "API",
      "url": "/docs/api/digest#degradation",
      "summary": "The tree is read defensively: a missing or malformed digest drops the agentic loop to keyword-style search, ranking to raw token overlap, and suggested questions to none — nothing hard-fails. Because the digest is markdown, each section's prose and facts change together in one PR diff, which is why it's a directory rather than a runtime computation.",
      "hash": "8c7b92cf65264a8dd443821aed31b529e5da7fb17f7ee72414d61378fb7757e2",
      "facts": [
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "api/digest#degradation"
        }
      ],
      "sources": [
        {
          "chunkId": "api/digest#degradation",
          "url": "/docs/api/digest#degradation",
          "anchor": "degradation"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "degradation",
        "tree",
        "read",
        "defensively",
        "missing",
        "malformed",
        "digest",
        "drops",
        "agentic",
        "loop",
        "keyword",
        "style",
        "search",
        "ranking",
        "token",
        "overlap",
        "suggested",
        "questions",
        "none",
        "nothing",
        "hard",
        "fails",
        "because",
        "markdown",
        "section",
        "prose",
        "facts",
        "change",
        "together",
        "diff",
        "directory",
        "rather",
        "runtime",
        "computation",
        "integration",
        "uses",
        "falls",
        "back",
        "overlay",
        "shows"
      ]
    },
    {
      "id": "api/digest#frontmatter-fields",
      "kind": "section",
      "title": "Digest format",
      "heading": "Frontmatter fields",
      "group": "API",
      "url": "/docs/api/digest#frontmatter-fields",
      "summary": "Reference table of section frontmatter: listing title vs literal heading, group and order for navigation, url and anchor for citations, terms for ranking, the content hash gating incremental builds, an agent-primary vs source-primary mode, deterministically extracted verbatim facts the model never authors, and source provenance references.",
      "hash": "ac0ff9a835edcc72c30d1502c26241ac65e2dd9e634502949e1cc09fda26e06b",
      "facts": [
        {
          "kind": "code",
          "literal": "title",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "string",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "ls",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "heading",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "group",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "order",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "number",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "anchor",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "github-slugger",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "verify",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "id",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "terms",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "string[]",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "hash",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "mode",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "'agent-primary' \\| 'source-primary'",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "source-primary",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "Fact[]",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "sources",
          "chunkId": "api/digest#frontmatter-fields"
        },
        {
          "kind": "code",
          "literal": "SourceRef[]",
          "chunkId": "api/digest#frontmatter-fields"
        }
      ],
      "sources": [
        {
          "chunkId": "api/digest#frontmatter-fields",
          "url": "/docs/api/digest#frontmatter-fields",
          "anchor": "frontmatter-fields"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "frontmatter",
        "fields",
        "reference",
        "table",
        "section",
        "listing",
        "title",
        "literal",
        "heading",
        "group",
        "order",
        "navigation",
        "anchor",
        "citations",
        "terms",
        "ranking",
        "content",
        "hash",
        "gating",
        "incremental",
        "builds",
        "agent",
        "primary",
        "source",
        "mode",
        "deterministically",
        "extracted",
        "verbatim",
        "facts",
        "model",
        "never",
        "authors",
        "provenance",
        "references",
        "string",
        "tree",
        "number",
        "github",
        "slugger",
        "verify"
      ]
    },
    {
      "id": "api/digest#how-each-field-is-used",
      "kind": "section",
      "title": "Digest format",
      "heading": "How each field is used",
      "group": "API",
      "url": "/docs/api/digest#how-each-field-is-used",
      "summary": "Maps fields to behavior: the title-tree and summaries are prompt-cached into the agentic loop's system prompt; the glossary expands keyword queries; terms, summaries, and facts lift ranked sections above incidental body mentions; the anchor is what verify checks and citations deep-link to; the hash gates incremental re-distillation.",
      "hash": "17f47e86d1eba6bfe1ba189937eeefcf9e88ee2b8e80ce1cf3edca8b9c7949e1",
      "facts": [
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "api/digest#how-each-field-is-used"
        },
        {
          "kind": "code",
          "literal": "_glossary/",
          "chunkId": "api/digest#how-each-field-is-used"
        },
        {
          "kind": "code",
          "literal": "terms",
          "chunkId": "api/digest#how-each-field-is-used"
        },
        {
          "kind": "code",
          "literal": "summary",
          "chunkId": "api/digest#how-each-field-is-used"
        },
        {
          "kind": "code",
          "literal": "anchor",
          "chunkId": "api/digest#how-each-field-is-used"
        },
        {
          "kind": "code",
          "literal": "ask digest verify",
          "chunkId": "api/digest#how-each-field-is-used"
        },
        {
          "kind": "code",
          "literal": "hash",
          "chunkId": "api/digest#how-each-field-is-used"
        },
        {
          "kind": "code",
          "literal": "build",
          "chunkId": "api/digest#how-each-field-is-used"
        }
      ],
      "sources": [
        {
          "chunkId": "api/digest#how-each-field-is-used",
          "url": "/docs/api/digest#how-each-field-is-used",
          "anchor": "how-each-field-is-used"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "field",
        "maps",
        "fields",
        "behavior",
        "title",
        "tree",
        "summaries",
        "prompt",
        "cached",
        "agentic",
        "loop",
        "system",
        "glossary",
        "expands",
        "keyword",
        "queries",
        "terms",
        "facts",
        "lift",
        "ranked",
        "sections",
        "above",
        "incidental",
        "body",
        "mentions",
        "anchor",
        "verify",
        "checks",
        "citations",
        "deep",
        "link",
        "hash",
        "gates",
        "incremental",
        "distillation",
        "summary",
        "digest",
        "build",
        "injected",
        "opens"
      ]
    },
    {
      "id": "api/digest#layout",
      "kind": "section",
      "title": "Digest format",
      "heading": "Layout",
      "group": "API",
      "url": "/docs/api/digest#layout",
      "summary": "The tree layout: a meta file, a glossary directory with one file per term, and one markdown file per heading-level section mirroring the doc paths. Underscore-prefixed names mark non-section entries so they sort first and never collide with a real slug; the entire artifact is markdown with no committed JSON.",
      "hash": "6ebf2bffe75c0ce6e0e4ebce97214673a69cdc69161cbfe9d7e1a584adb512bc",
      "facts": [
        {
          "kind": "code",
          "literal": ".hev-ask/\n  _meta.md                     overview · context · suggestions · version · contentHash\n  _glossary/\n    digest.md                  one file per term: aliases + definition\n  overview/\n    quick-start.md             one file per section, mirroring your doc paths\n    limits.md\n  api/\n    cli.md",
          "chunkId": "api/digest#layout"
        },
        {
          "kind": "code",
          "literal": "_meta",
          "chunkId": "api/digest#layout"
        },
        {
          "kind": "code",
          "literal": "_glossary",
          "chunkId": "api/digest#layout"
        }
      ],
      "sources": [
        {
          "chunkId": "api/digest#layout",
          "url": "/docs/api/digest#layout",
          "anchor": "layout"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "layout",
        "tree",
        "meta",
        "file",
        "glossary",
        "directory",
        "term",
        "markdown",
        "heading",
        "level",
        "section",
        "mirroring",
        "paths",
        "underscore",
        "prefixed",
        "names",
        "mark",
        "entries",
        "sort",
        "first",
        "never",
        "collide",
        "real",
        "slug",
        "entire",
        "artifact",
        "committed",
        "json",
        "overview",
        "context",
        "suggestions",
        "version",
        "contenthash",
        "digest",
        "aliases",
        "definition",
        "quick",
        "start",
        "limits",
        "chunk"
      ]
    },
    {
      "id": "api/digest#regenerating",
      "kind": "section",
      "title": "Digest format",
      "heading": "Regenerating",
      "group": "API",
      "url": "/docs/api/digest#regenerating",
      "summary": "Rebuild after content changes and commit the result; the per-section hash makes rebuilds incremental. Build via the Claude Code skill (no API key) or the CLI build command (one API call) — the integration also builds during the site build when a key is present — then run verify to gate anchors, coverage, fidelity, and tree integrity. A migrate command converts a legacy JSON digest without a model call.",
      "hash": "18c55bbc27ee8afb9bdda4d22407ee10967f514cfa90fb49fb6506dc60a2a138",
      "facts": [
        {
          "kind": "code",
          "literal": "hash",
          "chunkId": "api/digest#regenerating"
        },
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "api/digest#regenerating"
        },
        {
          "kind": "code",
          "literal": "astro build",
          "chunkId": "api/digest#regenerating"
        },
        {
          "kind": "code",
          "literal": "ask digest verify",
          "chunkId": "api/digest#regenerating"
        },
        {
          "kind": "code",
          "literal": "digest.json",
          "chunkId": "api/digest#regenerating"
        },
        {
          "kind": "code",
          "literal": "ask digest migrate",
          "chunkId": "api/digest#regenerating"
        }
      ],
      "sources": [
        {
          "chunkId": "api/digest#regenerating",
          "url": "/docs/api/digest#regenerating",
          "anchor": "regenerating"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "regenerating",
        "rebuild",
        "after",
        "content",
        "changes",
        "commit",
        "result",
        "section",
        "hash",
        "makes",
        "rebuilds",
        "incremental",
        "build",
        "claude",
        "code",
        "skill",
        "command",
        "call",
        "integration",
        "also",
        "builds",
        "during",
        "site",
        "present",
        "verify",
        "gate",
        "anchors",
        "coverage",
        "fidelity",
        "tree",
        "integrity",
        "migrate",
        "converts",
        "legacy",
        "json",
        "digest",
        "without",
        "model",
        "astro",
        "means"
      ]
    },
    {
      "id": "api/endpoint",
      "kind": "section",
      "title": "Search endpoint",
      "heading": null,
      "group": "API",
      "url": "/docs/api/endpoint",
      "summary": "The integration injects one on-demand route tree (default /api/ask): the base route serves the overlay with keyword JSON or an agentic SSE stream, keyless sub-routes expose the committed digest for CLIs and MCP servers, and the OpenAPI 3.1 contract is published at /openapi.yaml.",
      "hash": "6326b7a8d7fb952de486ebf8d8df5438e6d86ae7aafd2ce10fc15ea6549a8046",
      "facts": [
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "api/endpoint"
        },
        {
          "kind": "code",
          "literal": "text/event-stream",
          "chunkId": "api/endpoint"
        },
        {
          "kind": "code",
          "literal": "/openapi.yaml",
          "chunkId": "api/endpoint"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "api/endpoint"
        },
        {
          "kind": "value",
          "literal": "3.1",
          "chunkId": "api/endpoint"
        },
        {
          "kind": "value",
          "literal": "openapi.yaml",
          "chunkId": "api/endpoint"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint",
          "url": "/docs/api/endpoint",
          "anchor": null
        }
      ],
      "mode": "source-primary",
      "terms": [
        "integration",
        "injects",
        "demand",
        "route",
        "tree",
        "default",
        "base",
        "serves",
        "overlay",
        "keyword",
        "json",
        "agentic",
        "stream",
        "keyless",
        "routes",
        "expose",
        "committed",
        "digest",
        "clis",
        "servers",
        "openapi",
        "contract",
        "published",
        "yaml",
        "text",
        "event",
        "callout",
        "astro",
        "suggestions",
        "reads",
        "mode",
        "selection",
        "error",
        "responses",
        "returns",
        "streams",
        "grounded",
        "answer",
        "server",
        "sent"
      ]
    },
    {
      "id": "api/endpoint#agentic-response-sse",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "Agentic response (SSE)",
      "group": "API",
      "url": "/docs/api/endpoint#agentic-response-sse",
      "summary": "With a key present and agentic mode, the endpoint streams named SSE frames: search events for each sub-query or opened section, a single sources event with the grounding set (sent before any token, used by clients to validate links), token deltas of the Markdown answer, a done frame, and an error frame for failures after streaming began. A source carries title, optional heading and group, and url — no snippet.",
      "hash": "366017faa11220e7fdd7545cd885b58cdf2133c5f21be853f4339fe775ebc51a",
      "facts": [
        {
          "kind": "code",
          "literal": "mode",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "agentic",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "content-type: text/event-stream",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "search",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "{ query }",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "sources",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "{ sources: Source[], model, mode }",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "token",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "{ text }",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "done",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "{}",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "error",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "{ error }",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "200",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "Source",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "{ title, heading?, url, group? }",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "snippet",
          "chunkId": "api/endpoint#agentic-response-sse"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "api/endpoint#agentic-response-sse"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#agentic-response-sse",
          "url": "/docs/api/endpoint#agentic-response-sse",
          "anchor": "agentic-response-sse"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "agentic",
        "response",
        "present",
        "mode",
        "endpoint",
        "streams",
        "named",
        "frames",
        "search",
        "events",
        "query",
        "opened",
        "section",
        "single",
        "sources",
        "event",
        "grounding",
        "sent",
        "before",
        "token",
        "clients",
        "validate",
        "links",
        "deltas",
        "markdown",
        "answer",
        "done",
        "frame",
        "error",
        "failures",
        "after",
        "streaming",
        "began",
        "source",
        "carries",
        "title",
        "optional",
        "heading",
        "group",
        "snippet"
      ]
    },
    {
      "id": "api/endpoint#digest-reads-get",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "Digest reads (GET)",
      "group": "API",
      "url": "/docs/api/endpoint#digest-reads-get",
      "summary": "Keyless GET routes read the digest virtual module with no model call: glossary listing and per-term lookup, section summaries (filterable by group) and full per-id sections (URL-encode ids containing slashes or hashes), the overview/context pair, and a gzip tar archive of the whole tree used as the MCP bulk transport — with a HEAD variant exposing the content hash so clients skip redundant downloads. Misses return 404 with a JSON error.",
      "hash": "e462a9453db8dbf2c1ce2211b0989c34a851fefa9e2dc075bb461f12817eff77",
      "facts": [
        {
          "kind": "code",
          "literal": "{ \"error\": \"Not found.\" }",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "virtual:hev-ask/digest",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "GET /api/ask/glossary",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "{ \"terms\": GlossaryEntry[] }",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "GET /api/ask/glossary/{term}",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "GlossaryEntry",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "GET /api/ask/sections",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "{ \"sections\": SectionSummary[] }",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "GET /api/ask/sections?group=API",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "GET /api/ask/sections/{id}",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "DigestNode",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "GET /api/ask/overview",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "{ \"overview\": string, \"context\": string }",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "GET /api/ask/archive",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "SectionSummary",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "{ id, title, heading, group, url }",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "/api/ask/sections/api%2Fcli%23flags",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "ask mcp --endpoint",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "HEAD /api/ask/archive",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "x-hev-ask-content-hash",
          "chunkId": "api/endpoint#digest-reads-get"
        },
        {
          "kind": "code",
          "literal": "404",
          "chunkId": "api/endpoint#digest-reads-get"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#digest-reads-get",
          "url": "/docs/api/endpoint#digest-reads-get",
          "anchor": "digest-reads-get"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "digest",
        "reads",
        "keyless",
        "routes",
        "read",
        "virtual",
        "module",
        "model",
        "call",
        "glossary",
        "listing",
        "term",
        "lookup",
        "section",
        "summaries",
        "filterable",
        "group",
        "full",
        "sections",
        "encode",
        "containing",
        "slashes",
        "hashes",
        "overview",
        "context",
        "pair",
        "gzip",
        "archive",
        "whole",
        "tree",
        "bulk",
        "transport",
        "head",
        "variant",
        "exposing",
        "content",
        "hash",
        "clients",
        "skip",
        "redundant"
      ]
    },
    {
      "id": "api/endpoint#errors",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "Errors",
      "group": "API",
      "url": "/docs/api/endpoint#errors",
      "summary": "Error contract: 400 for invalid JSON bodies, 404 for missing digest reads, 500 when the chunk index fails to build, and — because the agentic stream is already 200 — mid-stream failures arrive as a final SSE error event rather than a status code.",
      "hash": "c67a8ab9b70204c62cb0ae5f63d37f2d21863e6f4fdc6e684b85e3a81e37ff3d",
      "facts": [
        {
          "kind": "code",
          "literal": "400",
          "chunkId": "api/endpoint#errors"
        },
        {
          "kind": "code",
          "literal": "{ \"error\": \"Invalid JSON body.\" }",
          "chunkId": "api/endpoint#errors"
        },
        {
          "kind": "code",
          "literal": "404",
          "chunkId": "api/endpoint#errors"
        },
        {
          "kind": "code",
          "literal": "{ \"error\": \"…\" }",
          "chunkId": "api/endpoint#errors"
        },
        {
          "kind": "code",
          "literal": "500",
          "chunkId": "api/endpoint#errors"
        },
        {
          "kind": "code",
          "literal": "event: error",
          "chunkId": "api/endpoint#errors"
        },
        {
          "kind": "code",
          "literal": "200",
          "chunkId": "api/endpoint#errors"
        },
        {
          "kind": "code",
          "literal": "error",
          "chunkId": "api/endpoint#errors"
        },
        {
          "kind": "value",
          "literal": "e.g",
          "chunkId": "api/endpoint#errors"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#errors",
          "url": "/docs/api/endpoint#errors",
          "anchor": "errors"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "errors",
        "error",
        "contract",
        "invalid",
        "json",
        "bodies",
        "missing",
        "digest",
        "reads",
        "chunk",
        "index",
        "fails",
        "build",
        "because",
        "agentic",
        "stream",
        "already",
        "failures",
        "arrive",
        "final",
        "event",
        "rather",
        "status",
        "code",
        "body",
        "cause",
        "request",
        "wasn",
        "valid",
        "read",
        "route",
        "glossary",
        "term",
        "section",
        "found",
        "failed",
        "misconfigured",
        "collection",
        "failure",
        "during"
      ]
    },
    {
      "id": "api/endpoint#index-lifecycle",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "Index lifecycle",
      "group": "API",
      "url": "/docs/api/endpoint#index-lifecycle",
      "summary": "The chunk index builds once per server instance on the first request and is cached for the process lifetime; that first request also compares the live content hash against the digest's and logs a one-time staleness warning as the cue to rebuild.",
      "hash": "8ae12673a130ca300e56e9955e6f0835a89f68ad5a0152b23de3665127f7dee8",
      "facts": [
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "api/endpoint#index-lifecycle"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#index-lifecycle",
          "url": "/docs/api/endpoint#index-lifecycle",
          "anchor": "index-lifecycle"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "index",
        "lifecycle",
        "chunk",
        "builds",
        "once",
        "server",
        "instance",
        "first",
        "request",
        "cached",
        "process",
        "lifetime",
        "also",
        "compares",
        "live",
        "content",
        "hash",
        "against",
        "digest",
        "logs",
        "time",
        "staleness",
        "warning",
        "rebuild",
        "build",
        "built",
        "endpoint",
        "differ"
      ]
    },
    {
      "id": "api/endpoint#keyword-response-json",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "Keyword response (JSON)",
      "group": "API",
      "url": "/docs/api/endpoint#keyword-response-json",
      "summary": "Keyword mode returns a 200 JSON envelope of ranked results (title, optional heading and group, url with anchor, snippet) plus the echoed query, the configured loop model, the mode that ran, and an optional warning when an agentic request was downgraded for lack of a key. The url field is the deep link, page-only for intro chunks.",
      "hash": "bbc5f7240f935311df97464c2bf6780dc597f246cfa94d8bfd9176bfe72cdd40",
      "facts": [
        {
          "kind": "code",
          "literal": "{\n  \"results\": [\n    {\n      \"title\": \"Concepts\",\n      \"heading\": \"The agentic search loop\",\n      \"url\": \"/docs/concepts#the-agentic-search-loop\",\n      \"group\": \"Overview\",\n      \"snippet\": \"When the reader presses Enter, the query goes to a bounded loop…\"\n    }\n  ],\n  \"query\": \"how does agentic search work\",\n  \"model\": \"claude-haiku-4-5\",\n  \"mode\": \"keyword\"\n}",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "200",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "results",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "Result[]",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "title",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "heading?",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "group?",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "snippet",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "query",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "string",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "model",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "mode",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "'keyword'",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "warning",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "string?",
          "chunkId": "api/endpoint#keyword-response-json"
        },
        {
          "kind": "code",
          "literal": "#anchor",
          "chunkId": "api/endpoint#keyword-response-json"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#keyword-response-json",
          "url": "/docs/api/endpoint#keyword-response-json",
          "anchor": "keyword-response-json"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "keyword",
        "response",
        "json",
        "mode",
        "returns",
        "envelope",
        "ranked",
        "results",
        "title",
        "optional",
        "heading",
        "group",
        "anchor",
        "snippet",
        "plus",
        "echoed",
        "query",
        "configured",
        "loop",
        "model",
        "warning",
        "agentic",
        "request",
        "downgraded",
        "lack",
        "field",
        "deep",
        "link",
        "page",
        "only",
        "intro",
        "chunks",
        "concepts",
        "search",
        "docs",
        "overview",
        "reader",
        "presses",
        "enter",
        "goes"
      ]
    },
    {
      "id": "api/endpoint#llm-tracing",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "LLM tracing",
      "group": "API",
      "url": "/docs/api/endpoint#llm-tracing",
      "summary": "Setting a PostHog key in the server environment makes every agentic answer emit an AI-generation trace with model, tokens, latency, and tool calls; host and content-capture level are configurable, and without a key tracing is a no-op the answer path never depends on.",
      "hash": "e583d09f55427f22b7d112b649fb4111c7081e86ca0197320fc01a19b6e0c354",
      "facts": [
        {
          "kind": "code",
          "literal": "POSTHOG_KEY",
          "chunkId": "api/endpoint#llm-tracing"
        },
        {
          "kind": "code",
          "literal": "POSTHOG_API_KEY",
          "chunkId": "api/endpoint#llm-tracing"
        },
        {
          "kind": "code",
          "literal": "$ai_generation",
          "chunkId": "api/endpoint#llm-tracing"
        },
        {
          "kind": "code",
          "literal": "POSTHOG_HOST",
          "chunkId": "api/endpoint#llm-tracing"
        },
        {
          "kind": "code",
          "literal": "POSTHOG_CAPTURE_CONTENT",
          "chunkId": "api/endpoint#llm-tracing"
        },
        {
          "kind": "code",
          "literal": "off",
          "chunkId": "api/endpoint#llm-tracing"
        },
        {
          "kind": "code",
          "literal": "redacted",
          "chunkId": "api/endpoint#llm-tracing"
        },
        {
          "kind": "code",
          "literal": "full",
          "chunkId": "api/endpoint#llm-tracing"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#llm-tracing",
          "url": "/docs/api/endpoint#llm-tracing",
          "anchor": "llm-tracing"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "tracing",
        "setting",
        "posthog",
        "server",
        "environment",
        "makes",
        "every",
        "agentic",
        "answer",
        "emit",
        "generation",
        "trace",
        "model",
        "tokens",
        "latency",
        "tool",
        "calls",
        "host",
        "content",
        "capture",
        "level",
        "configurable",
        "without",
        "path",
        "never",
        "depends",
        "redacted",
        "full",
        "posthogkey",
        "posthogapikey",
        "same",
        "emits",
        "aigeneration",
        "loop",
        "posthoghost",
        "overrides",
        "cloud",
        "ingestion",
        "posthogcapturecontent",
        "default"
      ]
    },
    {
      "id": "api/endpoint#mode-selection",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "Mode selection",
      "group": "API",
      "url": "/docs/api/endpoint#mode-selection",
      "summary": "The endpoint decides what to run: empty queries return an empty keyword envelope; explicit keyword mode or a missing key returns keyword JSON (with a warning when agentic was requested); otherwise the agentic SSE stream runs. There is no AI-unavailable error path — a missing key downgrades to keyword results, and the overlay branches on the response content-type.",
      "hash": "268456691571b15ea83b4fb47d86fa28225dcc41a170a2483ba5d5e97a419665",
      "facts": [
        {
          "kind": "code",
          "literal": "{ results: [], query: \"\", model, mode: \"keyword\" }",
          "chunkId": "api/endpoint#mode-selection"
        },
        {
          "kind": "code",
          "literal": "mode: \"keyword\"",
          "chunkId": "api/endpoint#mode-selection"
        },
        {
          "kind": "code",
          "literal": "mode: \"agentic\"",
          "chunkId": "api/endpoint#mode-selection"
        },
        {
          "kind": "code",
          "literal": "warning",
          "chunkId": "api/endpoint#mode-selection"
        },
        {
          "kind": "code",
          "literal": "content-type",
          "chunkId": "api/endpoint#mode-selection"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#mode-selection",
          "url": "/docs/api/endpoint#mode-selection",
          "anchor": "mode-selection"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "mode",
        "selection",
        "endpoint",
        "decides",
        "empty",
        "queries",
        "return",
        "keyword",
        "envelope",
        "explicit",
        "missing",
        "returns",
        "json",
        "warning",
        "agentic",
        "requested",
        "otherwise",
        "stream",
        "runs",
        "there",
        "unavailable",
        "error",
        "path",
        "downgrades",
        "results",
        "overlay",
        "branches",
        "response",
        "content",
        "type",
        "query",
        "model",
        "plus",
        "request",
        "says",
        "reader",
        "still",
        "gets",
        "handles",
        "both"
      ]
    },
    {
      "id": "api/endpoint#request",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "Request",
      "group": "API",
      "url": "/docs/api/endpoint#request",
      "summary": "Search is a POST with a JSON body of a query string and an optional mode; keyword forces the instant path, agentic requests the loop, and omitting mode behaves like agentic when a key is present. Empty or whitespace queries return an empty result set.",
      "hash": "f2a05f3dd644d4d9abb081702bbbc0fe721849ccf0e70f59742aea2ae18980a0",
      "facts": [
        {
          "kind": "code",
          "literal": "{\n  \"query\": \"how does autoscaling work\",\n  \"mode\": \"agentic\"\n}",
          "chunkId": "api/endpoint#request"
        },
        {
          "kind": "code",
          "literal": "POST",
          "chunkId": "api/endpoint#request"
        },
        {
          "kind": "code",
          "literal": "query",
          "chunkId": "api/endpoint#request"
        },
        {
          "kind": "code",
          "literal": "string",
          "chunkId": "api/endpoint#request"
        },
        {
          "kind": "code",
          "literal": "mode",
          "chunkId": "api/endpoint#request"
        },
        {
          "kind": "code",
          "literal": "'keyword' \\| 'agentic'",
          "chunkId": "api/endpoint#request"
        },
        {
          "kind": "code",
          "literal": "keyword",
          "chunkId": "api/endpoint#request"
        },
        {
          "kind": "code",
          "literal": "agentic",
          "chunkId": "api/endpoint#request"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#request",
          "url": "/docs/api/endpoint#request",
          "anchor": "request"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "request",
        "search",
        "post",
        "json",
        "body",
        "query",
        "string",
        "optional",
        "mode",
        "keyword",
        "forces",
        "instant",
        "path",
        "agentic",
        "requests",
        "loop",
        "omitting",
        "behaves",
        "like",
        "present",
        "empty",
        "whitespace",
        "queries",
        "return",
        "result",
        "does",
        "autoscaling",
        "work",
        "field",
        "type",
        "description",
        "returns",
        "omitted"
      ]
    },
    {
      "id": "api/endpoint#suggested-questions-get",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "Suggested questions (GET)",
      "group": "API",
      "url": "/docs/api/endpoint#suggested-questions-get",
      "summary": "A GET on the base route returns the digest's baked-in suggested questions and the loop model with no model call; the overlay fetches it once on first open when AI is on, and an empty list simply renders nothing.",
      "hash": "09b11b93e36f83adbf3806b64893ae0d6e67036b50132a6ffb096ad9e279489b",
      "facts": [
        {
          "kind": "code",
          "literal": "{\n  \"suggestions\": [\"How does the digest stay fresh?\"],\n  \"model\": \"claude-haiku-4-5\"\n}",
          "chunkId": "api/endpoint#suggested-questions-get"
        },
        {
          "kind": "code",
          "literal": "GET /api/ask",
          "chunkId": "api/endpoint#suggested-questions-get"
        },
        {
          "kind": "code",
          "literal": "suggestions",
          "chunkId": "api/endpoint#suggested-questions-get"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#suggested-questions-get",
          "url": "/docs/api/endpoint#suggested-questions-get",
          "anchor": "suggested-questions-get"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "suggested",
        "questions",
        "base",
        "route",
        "returns",
        "digest",
        "baked",
        "loop",
        "model",
        "call",
        "overlay",
        "fetches",
        "once",
        "first",
        "open",
        "empty",
        "list",
        "simply",
        "renders",
        "nothing",
        "suggestions",
        "does",
        "stay",
        "fresh",
        "claude",
        "haiku",
        "query",
        "populate",
        "array",
        "without",
        "just",
        "means",
        "shows",
        "none"
      ]
    },
    {
      "id": "api/endpoint#the-api-key",
      "kind": "section",
      "title": "Search endpoint",
      "heading": "The API key",
      "group": "API",
      "url": "/docs/api/endpoint#the-api-key",
      "summary": "The endpoint reads the key named by the configured provider from, in order, the adapter runtime environment (such as Cloudflare's), the process environment, then the build-time env. It is set wherever the host injects server secrets and never reaches the browser.",
      "hash": "6b9f401de0da470a422dab86c8b67ba6461101611461a5f6ad508bcf0c854ece",
      "facts": [
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "api/endpoint#the-api-key"
        },
        {
          "kind": "code",
          "literal": "OPENAI_API_KEY",
          "chunkId": "api/endpoint#the-api-key"
        },
        {
          "kind": "code",
          "literal": "OPENROUTER_API_KEY",
          "chunkId": "api/endpoint#the-api-key"
        },
        {
          "kind": "code",
          "literal": "provider",
          "chunkId": "api/endpoint#the-api-key"
        },
        {
          "kind": "code",
          "literal": "locals.runtime.env",
          "chunkId": "api/endpoint#the-api-key"
        },
        {
          "kind": "code",
          "literal": "process.env",
          "chunkId": "api/endpoint#the-api-key"
        },
        {
          "kind": "code",
          "literal": "import.meta.env",
          "chunkId": "api/endpoint#the-api-key"
        },
        {
          "kind": "value",
          "literal": "e.g",
          "chunkId": "api/endpoint#the-api-key"
        }
      ],
      "sources": [
        {
          "chunkId": "api/endpoint#the-api-key",
          "url": "/docs/api/endpoint#the-api-key",
          "anchor": "the-api-key"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "endpoint",
        "reads",
        "named",
        "configured",
        "provider",
        "order",
        "adapter",
        "runtime",
        "environment",
        "such",
        "cloudflare",
        "process",
        "build",
        "time",
        "wherever",
        "host",
        "injects",
        "server",
        "secrets",
        "never",
        "reaches",
        "browser",
        "anthropic",
        "openai",
        "openrouter",
        "locals",
        "import",
        "meta",
        "anthropicapikey",
        "default",
        "openaiapikey",
        "openrouterapikey",
        "option",
        "sent"
      ]
    },
    {
      "id": "api/mcp",
      "kind": "section",
      "title": "MCP server",
      "heading": null,
      "group": "API",
      "url": "/docs/api/mcp",
      "summary": "The MCP server is one tool plus instructions: the tool downloads the whole digest tree to local disk, and the instructions teach the agent to navigate it with its own file tools and cite with url+anchor. It deliberately hands an agent the corpus rather than reimplementing a search API — an MCP consumer is already an agent, so synthesis stays the overlay's job and there is no answer tool.",
      "hash": "ff242827eef613609690f7b116ad40577a561e412599b78d9afd465f7436aaac",
      "facts": [
        {
          "kind": "code",
          "literal": "ask mcp",
          "chunkId": "api/mcp"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "api/mcp"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "api/mcp"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "api/mcp"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "api/mcp"
        },
        {
          "kind": "code",
          "literal": "anchor",
          "chunkId": "api/mcp"
        },
        {
          "kind": "code",
          "literal": "ls",
          "chunkId": "api/mcp"
        },
        {
          "kind": "code",
          "literal": "answer",
          "chunkId": "api/mcp"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "api/mcp"
        }
      ],
      "sources": [
        {
          "chunkId": "api/mcp",
          "url": "/docs/api/mcp",
          "anchor": null
        }
      ],
      "mode": "source-primary",
      "terms": [
        "server",
        "tool",
        "plus",
        "instructions",
        "downloads",
        "whole",
        "digest",
        "tree",
        "local",
        "disk",
        "teach",
        "agent",
        "navigate",
        "file",
        "tools",
        "cite",
        "anchor",
        "deliberately",
        "hands",
        "corpus",
        "rather",
        "reimplementing",
        "search",
        "consumer",
        "already",
        "synthesis",
        "stays",
        "overlay",
        "there",
        "answer",
        "grep",
        "callout",
        "astro",
        "hand",
        "coding",
        "docs",
        "directory",
        "reads",
        "runs",
        "stdio"
      ]
    },
    {
      "id": "api/mcp#co-location",
      "kind": "section",
      "title": "MCP server",
      "heading": "Co-location",
      "group": "API",
      "url": "/docs/api/mcp#co-location",
      "summary": "Hydrate-to-disk assumes the MCP server and the agent's file tools share a host, which is true for the stdio transport — the only one this server exposes. A remote transport where the agent can't read the server's cache would need a separate resource fallback, since a local path would be useless.",
      "hash": "0dd5d436dbfe12945ae2a67bf0100156e9645f9c1e9a8afe293b1b83a7348757",
      "facts": [
        {
          "kind": "code",
          "literal": "ask mcp",
          "chunkId": "api/mcp#co-location"
        }
      ],
      "sources": [
        {
          "chunkId": "api/mcp#co-location",
          "url": "/docs/api/mcp#co-location",
          "anchor": "co-location"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "location",
        "hydrate",
        "disk",
        "assumes",
        "server",
        "agent",
        "file",
        "tools",
        "share",
        "host",
        "true",
        "stdio",
        "transport",
        "only",
        "exposes",
        "remote",
        "read",
        "cache",
        "would",
        "need",
        "separate",
        "resource",
        "fallback",
        "since",
        "local",
        "path",
        "useless",
        "stdin",
        "stdout",
        "default",
        "intentionally",
        "cannot",
        "tool",
        "because",
        "returning",
        "useful"
      ]
    },
    {
      "id": "api/mcp#configure",
      "kind": "section",
      "title": "MCP server",
      "heading": "Configure",
      "group": "API",
      "url": "/docs/api/mcp#configure",
      "summary": "Two configurations: point the server at a checked-out repo's local digest directory (keyless), or at a deployed site's endpoint — including any other site running hev ask — to pull its docs into the agent's workspace from anywhere.",
      "hash": "bd48710aaa8e6b45422ed8cee00e44b2004fdbd68d1178fac60bae41e706b728",
      "facts": [
        {
          "kind": "code",
          "literal": "{\n  \"mcpServers\": {\n    \"docs\": {\n      \"command\": \"ask\",\n      \"args\": [\"--digest-dir\", \".hev-ask\", \"mcp\"]\n    }\n  }\n}",
          "chunkId": "api/mcp#configure"
        },
        {
          "kind": "code",
          "literal": "{\n  \"mcpServers\": {\n    \"hevask\": {\n      \"command\": \"ask\",\n      \"args\": [\"--endpoint\", \"https://hevask.com/api/ask\", \"mcp\"]\n    }\n  }\n}",
          "chunkId": "api/mcp#configure"
        }
      ],
      "sources": [
        {
          "chunkId": "api/mcp#configure",
          "url": "/docs/api/mcp#configure",
          "anchor": "configure"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "configure",
        "configurations",
        "point",
        "server",
        "checked",
        "repo",
        "local",
        "digest",
        "directory",
        "keyless",
        "deployed",
        "site",
        "endpoint",
        "including",
        "other",
        "running",
        "pull",
        "docs",
        "agent",
        "workspace",
        "anywhere",
        "mcpservers",
        "command",
        "args",
        "hevask",
        "https",
        "reads",
        "tree",
        "runs",
        "pulled"
      ]
    },
    {
      "id": "api/mcp#data-sources",
      "kind": "section",
      "title": "MCP server",
      "heading": "Data sources",
      "group": "API",
      "url": "/docs/api/mcp#data-sources",
      "summary": "The MCP server resolves data like the CLI: with an endpoint it downloads the deployed tree as a compressed archive; otherwise it reads the local digest directory. A freshly rebuilt tree is visible on the next fetch without restarting the server.",
      "hash": "863a2df687abe731858ab1157d344474fb96e257b5e52ec7266642179186a4dc",
      "facts": [
        {
          "kind": "code",
          "literal": "ask mcp",
          "chunkId": "api/mcp#data-sources"
        },
        {
          "kind": "code",
          "literal": "--endpoint <url>",
          "chunkId": "api/mcp#data-sources"
        },
        {
          "kind": "code",
          "literal": "/api/ask/archive",
          "chunkId": "api/mcp#data-sources"
        },
        {
          "kind": "code",
          "literal": "--digest-dir",
          "chunkId": "api/mcp#data-sources"
        },
        {
          "kind": "code",
          "literal": ".hev-ask",
          "chunkId": "api/mcp#data-sources"
        },
        {
          "kind": "code",
          "literal": "fetch_docs",
          "chunkId": "api/mcp#data-sources"
        }
      ],
      "sources": [
        {
          "chunkId": "api/mcp#data-sources",
          "url": "/docs/api/mcp#data-sources",
          "anchor": "data-sources"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "data",
        "sources",
        "server",
        "resolves",
        "like",
        "endpoint",
        "downloads",
        "deployed",
        "tree",
        "compressed",
        "archive",
        "otherwise",
        "reads",
        "local",
        "digest",
        "directory",
        "freshly",
        "rebuilt",
        "visible",
        "next",
        "fetch",
        "without",
        "restarting",
        "docs",
        "uses",
        "same",
        "resolution",
        "disk",
        "defaulting",
        "just",
        "fetchdocs"
      ]
    },
    {
      "id": "api/mcp#protocol-surface",
      "kind": "section",
      "title": "MCP server",
      "heading": "Protocol surface",
      "group": "API",
      "url": "/docs/api/mcp#protocol-surface",
      "summary": "The server speaks newline-delimited JSON-RPC over stdio, handling initialization (returning the instructions), tool listing, and tool calls; unknown methods return protocol errors and tool failures return error-flagged MCP results. All substantive behavior lives in the shared Go package so the CLI, embeddable command group, and MCP server use the same tree helpers.",
      "hash": "e99d0aabc9e51f725c1d5a66babc38fafa6631b456ce3eeb9647327596ca44ce",
      "facts": [
        {
          "kind": "code",
          "literal": "initialize",
          "chunkId": "api/mcp#protocol-surface"
        },
        {
          "kind": "code",
          "literal": "instructions",
          "chunkId": "api/mcp#protocol-surface"
        },
        {
          "kind": "code",
          "literal": "tools/list",
          "chunkId": "api/mcp#protocol-surface"
        },
        {
          "kind": "code",
          "literal": "tools/call",
          "chunkId": "api/mcp#protocol-surface"
        },
        {
          "kind": "code",
          "literal": "isError: true",
          "chunkId": "api/mcp#protocol-surface"
        },
        {
          "kind": "code",
          "literal": "pkg/ask",
          "chunkId": "api/mcp#protocol-surface"
        }
      ],
      "sources": [
        {
          "chunkId": "api/mcp#protocol-surface",
          "url": "/docs/api/mcp#protocol-surface",
          "anchor": "protocol-surface"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "protocol",
        "surface",
        "server",
        "speaks",
        "newline",
        "delimited",
        "json",
        "stdio",
        "handling",
        "initialization",
        "returning",
        "instructions",
        "tool",
        "listing",
        "calls",
        "unknown",
        "methods",
        "return",
        "errors",
        "failures",
        "error",
        "flagged",
        "results",
        "substantive",
        "behavior",
        "lives",
        "shared",
        "package",
        "embeddable",
        "command",
        "group",
        "same",
        "tree",
        "helpers",
        "initialize",
        "tools",
        "list",
        "call",
        "iserror",
        "true"
      ]
    },
    {
      "id": "api/mcp#the-instructions",
      "kind": "section",
      "title": "MCP server",
      "heading": "The instructions",
      "group": "API",
      "url": "/docs/api/mcp#the-instructions",
      "summary": "The shipped instructions teach two things: navigation (read the inline title-tree first, open a section only when its title says it's relevant, grep for specifics, don't read every file) and citation (cite every claim with the section's url and anchor as a deep link). Citation is made non-negotiable because it's easy to lose once an agent synthesizes off local files and it's the core grounded-deep-link value.",
      "hash": "14bcb7471103193eb94df0723bcfe733355523b8b1442cae8c864428d6418c5b",
      "facts": [
        {
          "kind": "code",
          "literal": "instructions",
          "chunkId": "api/mcp#the-instructions"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "api/mcp#the-instructions"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "api/mcp#the-instructions"
        },
        {
          "kind": "code",
          "literal": "_glossary/",
          "chunkId": "api/mcp#the-instructions"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "api/mcp#the-instructions"
        },
        {
          "kind": "code",
          "literal": "anchor",
          "chunkId": "api/mcp#the-instructions"
        },
        {
          "kind": "code",
          "literal": "/docs/page#anchor",
          "chunkId": "api/mcp#the-instructions"
        }
      ],
      "sources": [
        {
          "chunkId": "api/mcp#the-instructions",
          "url": "/docs/api/mcp#the-instructions",
          "anchor": "the-instructions"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "instructions",
        "shipped",
        "teach",
        "things",
        "navigation",
        "read",
        "inline",
        "title",
        "tree",
        "first",
        "open",
        "section",
        "only",
        "says",
        "relevant",
        "grep",
        "specifics",
        "every",
        "file",
        "citation",
        "cite",
        "claim",
        "anchor",
        "deep",
        "link",
        "made",
        "negotiable",
        "because",
        "easy",
        "lose",
        "once",
        "agent",
        "synthesizes",
        "local",
        "files",
        "core",
        "grounded",
        "value",
        "glossary",
        "docs"
      ]
    },
    {
      "id": "api/mcp#the-tool",
      "kind": "section",
      "title": "MCP server",
      "heading": "The tool",
      "group": "API",
      "url": "/docs/api/mcp#the-tool",
      "summary": "The single tool materializes the digest tree at a host-keyed local cache path and returns the title-tree inline plus path, content hash, section count, and an up-to-date flag — one call bootstraps the whole disclosure ladder, after which the agent uses native file tools. A force argument re-pulls unconditionally; otherwise the remote content hash is compared and the download skipped when unchanged. The bounded corpus compresses small enough to ship in one shot with no per-file delta protocol.",
      "hash": "54bc7be8d62d5112772761d161b203c851308fffd7751b1c920e8c99e1975b96",
      "facts": [
        {
          "kind": "code",
          "literal": "tree ~/.cache/hev-ask/hevask.com        # already returned inline by fetch_docs\ncat  ~/.cache/hev-ask/hevask.com/overview/quick-start.md\ngrep -r \"prerender\" ~/.cache/hev-ask/hevask.com",
          "chunkId": "api/mcp#the-tool"
        },
        {
          "kind": "code",
          "literal": "fetch_docs",
          "chunkId": "api/mcp#the-tool"
        },
        {
          "kind": "code",
          "literal": "{ force?: boolean }",
          "chunkId": "api/mcp#the-tool"
        },
        {
          "kind": "code",
          "literal": "{ path, contentHash, sections, tree, upToDate }",
          "chunkId": "api/mcp#the-tool"
        },
        {
          "kind": "code",
          "literal": "~/.cache/hev-ask/hevask.com/",
          "chunkId": "api/mcp#the-tool"
        },
        {
          "kind": "code",
          "literal": "force: true",
          "chunkId": "api/mcp#the-tool"
        },
        {
          "kind": "code",
          "literal": "contentHash",
          "chunkId": "api/mcp#the-tool"
        },
        {
          "kind": "code",
          "literal": "upToDate: true",
          "chunkId": "api/mcp#the-tool"
        },
        {
          "kind": "value",
          "literal": "e.g",
          "chunkId": "api/mcp#the-tool"
        }
      ],
      "sources": [
        {
          "chunkId": "api/mcp#the-tool",
          "url": "/docs/api/mcp#the-tool",
          "anchor": "the-tool"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "tool",
        "single",
        "materializes",
        "digest",
        "tree",
        "host",
        "keyed",
        "local",
        "cache",
        "path",
        "returns",
        "title",
        "inline",
        "plus",
        "content",
        "hash",
        "section",
        "count",
        "date",
        "flag",
        "call",
        "bootstraps",
        "whole",
        "disclosure",
        "ladder",
        "after",
        "agent",
        "uses",
        "native",
        "file",
        "tools",
        "force",
        "argument",
        "pulls",
        "unconditionally",
        "otherwise",
        "remote",
        "compared",
        "download",
        "skipped"
      ]
    },
    {
      "id": "api/search-overlay",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": null,
      "group": "API",
      "url": "/docs/api/search-overlay",
      "summary": "The Astro overlay component renders the ⌘K command palette; it's added once in a global layout, opens over the page, and doesn't affect layout until opened.",
      "hash": "d5156262703aa7e6cb35195e090b1c23f46c9afc441cd1132e051a171936da45",
      "facts": [
        {
          "kind": "code",
          "literal": "---\nimport SearchOverlay from \"@hevmind/ask/components/SearchOverlay.astro\";\n---\n<SearchOverlay />",
          "chunkId": "api/search-overlay"
        },
        {
          "kind": "code",
          "literal": "SearchOverlay.astro",
          "chunkId": "api/search-overlay"
        },
        {
          "kind": "code",
          "literal": "⌘K",
          "chunkId": "api/search-overlay"
        },
        {
          "kind": "code",
          "literal": "<dialog>",
          "chunkId": "api/search-overlay"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "api/search-overlay"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay",
          "url": "/docs/api/search-overlay",
          "anchor": null
        }
      ],
      "mode": "source-primary",
      "terms": [
        "astro",
        "overlay",
        "component",
        "renders",
        "command",
        "palette",
        "added",
        "once",
        "global",
        "layout",
        "opens",
        "page",
        "doesn",
        "affect",
        "until",
        "opened",
        "import",
        "searchoverlay",
        "hevmind",
        "components",
        "dialog",
        "callout",
        "props",
        "data",
        "open",
        "opener",
        "attribute",
        "keyboard",
        "model",
        "mode",
        "toggle",
        "theming",
        "through",
        "variables",
        "drop",
        "script",
        "docusaurus",
        "vitepress",
        "mkdocs",
        "static"
      ]
    },
    {
      "id": "api/search-overlay#any-static-site",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Any static site",
      "group": "API",
      "url": "/docs/api/search-overlay#any-static-site",
      "summary": "Plain HTML sites need no framework: run the bundle command as a build step, deploy its output beside the HTML, drop the script tag into the template, and add the endpoint attribute only when agentic answers are wanted.",
      "hash": "5bc9f3e49238a7029f2917dba220035cdbde4b3141ca78013be0cb6e04d31301",
      "facts": [
        {
          "kind": "code",
          "literal": "ask digest bundle",
          "chunkId": "api/search-overlay#any-static-site"
        },
        {
          "kind": "code",
          "literal": "<script>",
          "chunkId": "api/search-overlay#any-static-site"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#any-static-site",
          "url": "/docs/api/search-overlay#any-static-site",
          "anchor": "any-static-site"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "static",
        "site",
        "plain",
        "html",
        "sites",
        "need",
        "framework",
        "bundle",
        "command",
        "build",
        "step",
        "deploy",
        "output",
        "beside",
        "drop",
        "script",
        "template",
        "endpoint",
        "attribute",
        "only",
        "agentic",
        "answers",
        "wanted",
        "digest",
        "there",
        "satisfy",
        "release",
        "alongside",
        "want"
      ]
    },
    {
      "id": "api/search-overlay#bundling-the-static-assets",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Bundling the static assets",
      "group": "API",
      "url": "/docs/api/search-overlay#bundling-the-static-assets",
      "summary": "The bundle command emits the browser payload — keyword index, glossary, suggestions, and title-tree — into a directory the site serves. The output is generated every build and gitignored, not committed; the committed digest tree stays the reviewable source of truth, and regenerating per build prevents drift from what ships.",
      "hash": "77f8c50f2486577e256ed8eda9ca5648330bd15f01f56ec275d154b6dfa0019d",
      "facts": [
        {
          "kind": "code",
          "literal": "ask digest bundle",
          "chunkId": "api/search-overlay#bundling-the-static-assets"
        },
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "api/search-overlay#bundling-the-static-assets"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#bundling-the-static-assets",
          "url": "/docs/api/search-overlay#bundling-the-static-assets",
          "anchor": "bundling-the-static-assets"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "bundling",
        "static",
        "assets",
        "bundle",
        "command",
        "emits",
        "browser",
        "payload",
        "keyword",
        "index",
        "glossary",
        "suggestions",
        "title",
        "tree",
        "directory",
        "site",
        "serves",
        "output",
        "generated",
        "every",
        "build",
        "gitignored",
        "committed",
        "digest",
        "stays",
        "reviewable",
        "source",
        "truth",
        "regenerating",
        "prevents",
        "drift",
        "ships",
        "like",
        "step",
        "renders",
        "html",
        "served",
        "gitignore",
        "keep",
        "means"
      ]
    },
    {
      "id": "api/search-overlay#docusaurus",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Docusaurus",
      "group": "API",
      "url": "/docs/api/search-overlay#docusaurus",
      "summary": "On Docusaurus, the bundle is emitted into the static directory by the build script and the overlay script is added through the site config with digest and endpoint data attributes. Docusaurus's explicit custom-id heading anchors are honored by its slug mode, and verify checks every anchor against the built HTML.",
      "hash": "6eceffab590110ca1344359049f1a1892f1f4d5c2871542003b2a624ada9a945",
      "facts": [
        {
          "kind": "code",
          "literal": "// docusaurus.config.js\nexport default {\n  scripts: [\n    {\n      src: \"https://cdn.jsdelivr.net/npm/@hevmind/ask/overlay.js\",\n      type: \"module\",\n      \"data-hev-ask-digest\": \"/hev-ask/\",\n      \"data-hev-ask-endpoint\": \"https://docs-ask.example.workers.dev/api/ask\",\n    },\n  ],\n};",
          "chunkId": "api/search-overlay#docusaurus"
        },
        {
          "kind": "code",
          "literal": "// package.json — bundle into the static dir before docusaurus build\n\"scripts\": {\n  \"build\": \"ask digest bundle --out static/hev-ask && docusaurus build\"\n}",
          "chunkId": "api/search-overlay#docusaurus"
        },
        {
          "kind": "code",
          "literal": "static/",
          "chunkId": "api/search-overlay#docusaurus"
        },
        {
          "kind": "code",
          "literal": "build",
          "chunkId": "api/search-overlay#docusaurus"
        },
        {
          "kind": "code",
          "literal": "docusaurus.config.js",
          "chunkId": "api/search-overlay#docusaurus"
        },
        {
          "kind": "code",
          "literal": "{#custom-id}",
          "chunkId": "api/search-overlay#docusaurus"
        },
        {
          "kind": "code",
          "literal": "ask digest verify",
          "chunkId": "api/search-overlay#docusaurus"
        },
        {
          "kind": "code",
          "literal": "build/",
          "chunkId": "api/search-overlay#docusaurus"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#docusaurus",
          "url": "/docs/api/search-overlay#docusaurus",
          "anchor": "docusaurus"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "docusaurus",
        "bundle",
        "emitted",
        "static",
        "directory",
        "build",
        "script",
        "overlay",
        "added",
        "through",
        "site",
        "config",
        "digest",
        "endpoint",
        "data",
        "attributes",
        "explicit",
        "custom",
        "heading",
        "anchors",
        "honored",
        "slug",
        "mode",
        "verify",
        "checks",
        "every",
        "anchor",
        "against",
        "built",
        "html",
        "export",
        "default",
        "scripts",
        "https",
        "jsdelivr",
        "hevmind",
        "type",
        "module",
        "docs",
        "example"
      ]
    },
    {
      "id": "api/search-overlay#keyboard-model",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Keyboard model",
      "group": "API",
      "url": "/docs/api/search-overlay#keyboard-model",
      "summary": "The overlay is ask-first and word-count driven: one word runs debounced keyword search with the first result auto-active; a second word switches to ask mode where Enter sends the question to the agentic loop; arrow keys move keyword selection, Escape closes, and suggested questions appear on open with AI enabled. Without a server key, asking returns keyword results with a visible warning — search never breaks.",
      "hash": "ee1d21380babc93166dcbdb53a1180c1fd71608113d3f633a28f81b7c40dd1b6",
      "facts": [
        {
          "kind": "code",
          "literal": "Tab",
          "chunkId": "api/search-overlay#keyboard-model"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "api/search-overlay#keyboard-model"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#keyboard-model",
          "url": "/docs/api/search-overlay#keyboard-model",
          "anchor": "keyboard-model"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "keyboard",
        "model",
        "overlay",
        "first",
        "word",
        "count",
        "driven",
        "runs",
        "debounced",
        "keyword",
        "search",
        "result",
        "auto",
        "active",
        "second",
        "switches",
        "mode",
        "enter",
        "sends",
        "question",
        "agentic",
        "loop",
        "arrow",
        "keys",
        "move",
        "selection",
        "escape",
        "closes",
        "suggested",
        "questions",
        "appear",
        "open",
        "enabled",
        "without",
        "server",
        "asking",
        "returns",
        "results",
        "visible",
        "warning"
      ]
    },
    {
      "id": "api/search-overlay#keyword-results-and-deep-links",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Keyword results and deep links",
      "group": "API",
      "url": "/docs/api/search-overlay#keyword-results-and-deep-links",
      "summary": "Each keyword result row shows the document title, an optional heading breadcrumb, and a one-line snippet; the row links to the chunk's url, which already carries the anchor, so clicking lands on the exact heading.",
      "hash": "330287eee67f4021f8ba2a74434848977080dfdc106b39f73bac9c0326d60a78",
      "facts": [
        {
          "kind": "code",
          "literal": "Concepts › The agentic loop",
          "chunkId": "api/search-overlay#keyword-results-and-deep-links"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "api/search-overlay#keyword-results-and-deep-links"
        },
        {
          "kind": "code",
          "literal": "#anchor",
          "chunkId": "api/search-overlay#keyword-results-and-deep-links"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#keyword-results-and-deep-links",
          "url": "/docs/api/search-overlay#keyword-results-and-deep-links",
          "anchor": "keyword-results-and-deep-links"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "keyword",
        "results",
        "deep",
        "links",
        "result",
        "shows",
        "document",
        "title",
        "optional",
        "heading",
        "breadcrumb",
        "line",
        "snippet",
        "chunk",
        "already",
        "carries",
        "anchor",
        "clicking",
        "lands",
        "exact",
        "concepts",
        "agentic",
        "loop",
        "renders",
        "link"
      ]
    },
    {
      "id": "api/search-overlay#mkdocs",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "MkDocs",
      "group": "API",
      "url": "/docs/api/search-overlay#mkdocs",
      "summary": "On MkDocs, the bundle goes into the docs directory and the overlay script is referenced through the extra-javascript setting in the site config.",
      "hash": "5ff9bd89fc3f721d871f2e212ce8636856466218e115dacabc4e9bad5a20aca6",
      "facts": [
        {
          "kind": "code",
          "literal": "# mkdocs.yml\nextra_javascript:\n  - hev-ask/overlay.js",
          "chunkId": "api/search-overlay#mkdocs"
        },
        {
          "kind": "code",
          "literal": "docs/hev-ask/",
          "chunkId": "api/search-overlay#mkdocs"
        },
        {
          "kind": "code",
          "literal": "extra_javascript",
          "chunkId": "api/search-overlay#mkdocs"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#mkdocs",
          "url": "/docs/api/search-overlay#mkdocs",
          "anchor": "mkdocs"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "mkdocs",
        "bundle",
        "goes",
        "docs",
        "directory",
        "overlay",
        "script",
        "referenced",
        "through",
        "extra",
        "javascript",
        "setting",
        "site",
        "config",
        "reference",
        "extrajavascript"
      ]
    },
    {
      "id": "api/search-overlay#opening-the-overlay",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Opening the overlay",
      "group": "API",
      "url": "/docs/api/search-overlay#opening-the-overlay",
      "summary": "Two built-in openers: the keyboard shortcut binds automatically once the component is on the page, and any element carrying the opener data attribute opens it on click, so any number of triggers can be wired.",
      "hash": "3e4c8449e1af4f6a284fdcd274b32d88321a897b8133c10c6c232e10ec4d6a3f",
      "facts": [
        {
          "kind": "code",
          "literal": "<button type=\"button\" data-hev-ask-open>\n  Search <kbd>⌘K</kbd>\n</button>\n\n<a href=\"#\" data-hev-ask-open>Search the docs</a>",
          "chunkId": "api/search-overlay#opening-the-overlay"
        },
        {
          "kind": "code",
          "literal": "⌘K",
          "chunkId": "api/search-overlay#opening-the-overlay"
        },
        {
          "kind": "code",
          "literal": "Ctrl-K",
          "chunkId": "api/search-overlay#opening-the-overlay"
        },
        {
          "kind": "code",
          "literal": "data-hev-ask-open",
          "chunkId": "api/search-overlay#opening-the-overlay"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#opening-the-overlay",
          "url": "/docs/api/search-overlay#opening-the-overlay",
          "anchor": "opening-the-overlay"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "opening",
        "overlay",
        "built",
        "openers",
        "keyboard",
        "shortcut",
        "binds",
        "automatically",
        "once",
        "component",
        "page",
        "element",
        "carrying",
        "opener",
        "data",
        "attribute",
        "opens",
        "click",
        "number",
        "triggers",
        "wired",
        "button",
        "type",
        "open",
        "search",
        "href",
        "docs",
        "ctrl",
        "ways",
        "both",
        "bound",
        "wire",
        "many",
        "like",
        "header",
        "sidebar",
        "inline",
        "links"
      ]
    },
    {
      "id": "api/search-overlay#props",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Props",
      "group": "API",
      "url": "/docs/api/search-overlay#props",
      "summary": "The component takes three props: the endpoint it posts queries to (which must match the integration's endpoint option), the input placeholder text, and the debounce delay before a keyword query is sent.",
      "hash": "ae4f683359160725bca5d58e0e1aac3897a94d552fab66a948c2682add9e2524",
      "facts": [
        {
          "kind": "code",
          "literal": "<SearchOverlay\n  endpoint=\"/api/ask\"\n  placeholder=\"Search hev ask…\"\n  debounce={400}\n/>",
          "chunkId": "api/search-overlay#props"
        },
        {
          "kind": "code",
          "literal": "endpoint",
          "chunkId": "api/search-overlay#props"
        },
        {
          "kind": "code",
          "literal": "string",
          "chunkId": "api/search-overlay#props"
        },
        {
          "kind": "code",
          "literal": "'/api/ask'",
          "chunkId": "api/search-overlay#props"
        },
        {
          "kind": "code",
          "literal": "placeholder",
          "chunkId": "api/search-overlay#props"
        },
        {
          "kind": "code",
          "literal": "'Search the docs…'",
          "chunkId": "api/search-overlay#props"
        },
        {
          "kind": "code",
          "literal": "debounce",
          "chunkId": "api/search-overlay#props"
        },
        {
          "kind": "code",
          "literal": "number",
          "chunkId": "api/search-overlay#props"
        },
        {
          "kind": "code",
          "literal": "500",
          "chunkId": "api/search-overlay#props"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#props",
          "url": "/docs/api/search-overlay#props",
          "anchor": "props"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "props",
        "component",
        "takes",
        "three",
        "endpoint",
        "posts",
        "queries",
        "must",
        "match",
        "integration",
        "option",
        "input",
        "placeholder",
        "text",
        "debounce",
        "delay",
        "before",
        "keyword",
        "query",
        "sent",
        "searchoverlay",
        "search",
        "string",
        "docs",
        "number",
        "prop",
        "type",
        "default",
        "description",
        "overlay",
        "milliseconds",
        "after",
        "typing",
        "stops"
      ]
    },
    {
      "id": "api/search-overlay#suggested-questions",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Suggested questions",
      "group": "API",
      "url": "/docs/api/search-overlay#suggested-questions",
      "summary": "With AI on, the overlay fetches suggested questions from the endpoint on first open and shows them in the empty state; they're baked into the digest at build time so no model call renders them, an empty digest shows none, and clicking one fills the input and asks immediately.",
      "hash": "7b69c77e3577551acb6b854069a902fa75a2f4e203eaa0343c33db7656710c47",
      "facts": [
        {
          "kind": "code",
          "literal": "GET /api/ask",
          "chunkId": "api/search-overlay#suggested-questions"
        },
        {
          "kind": "code",
          "literal": "suggestions",
          "chunkId": "api/search-overlay#suggested-questions"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#suggested-questions",
          "url": "/docs/api/search-overlay#suggested-questions",
          "anchor": "suggested-questions"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "suggested",
        "questions",
        "overlay",
        "fetches",
        "endpoint",
        "first",
        "open",
        "shows",
        "empty",
        "state",
        "baked",
        "digest",
        "build",
        "time",
        "model",
        "call",
        "renders",
        "none",
        "clicking",
        "fills",
        "input",
        "asks",
        "immediately",
        "suggestions",
        "short",
        "list",
        "opens",
        "come",
        "there",
        "render",
        "simply",
        "nothing",
        "extra",
        "suggestion"
      ]
    },
    {
      "id": "api/search-overlay#support-at-a-glance",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Support at a glance",
      "group": "API",
      "url": "/docs/api/search-overlay#support-at-a-glance",
      "summary": "A per-framework support table: Astro gets the turnkey integration, mounted component, and built-in route; Docusaurus, VitePress, MkDocs, and static HTML get the digest build as a build step, a drop-in overlay, and a hostable endpoint for agentic answers. The CLI and MCP surfaces are host-neutral on every row.",
      "hash": "459a17a643d2212b27a127a6fab51e535bcc32e9fdc9cd83250b058d472224ce",
      "facts": [
        {
          "kind": "code",
          "literal": "hevAsk()",
          "chunkId": "api/search-overlay#support-at-a-glance"
        },
        {
          "kind": "code",
          "literal": "SearchOverlay.astro",
          "chunkId": "api/search-overlay#support-at-a-glance"
        },
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "api/search-overlay#support-at-a-glance"
        },
        {
          "kind": "code",
          "literal": "ask digest",
          "chunkId": "api/search-overlay#support-at-a-glance"
        },
        {
          "kind": "code",
          "literal": "<script>",
          "chunkId": "api/search-overlay#support-at-a-glance"
        },
        {
          "kind": "code",
          "literal": "mountHevAsk",
          "chunkId": "api/search-overlay#support-at-a-glance"
        },
        {
          "kind": "code",
          "literal": "extra_javascript",
          "chunkId": "api/search-overlay#support-at-a-glance"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#support-at-a-glance",
          "url": "/docs/api/search-overlay#support-at-a-glance",
          "anchor": "support-at-a-glance"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "support",
        "glance",
        "framework",
        "table",
        "astro",
        "gets",
        "turnkey",
        "integration",
        "mounted",
        "component",
        "built",
        "route",
        "docusaurus",
        "vitepress",
        "mkdocs",
        "static",
        "html",
        "digest",
        "build",
        "step",
        "drop",
        "overlay",
        "hostable",
        "endpoint",
        "agentic",
        "answers",
        "surfaces",
        "host",
        "neutral",
        "every",
        "hevask",
        "searchoverlay",
        "script",
        "mounthevask",
        "extra",
        "javascript",
        "keyword",
        "adapter",
        "theme",
        "extrajavascript"
      ]
    },
    {
      "id": "api/search-overlay#the-hostable-endpoint",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "The hostable endpoint",
      "group": "API",
      "url": "/docs/api/search-overlay#the-hostable-endpoint",
      "summary": "For agentic answers without Astro, the bounded answer loop deploys as a standalone service (Cloudflare Worker, Node server, or Vercel function) serving the same POST contract as the Astro route, holding the key server-side and reading the committed digest. Deploy once and point any number of sites at it; keyword search runs entirely in the browser, so only the answer loop needs hosting.",
      "hash": "de2a87abed98b0710faec2697d9c06ee50122f8ab3852fc8e2133a2af0333886",
      "facts": [
        {
          "kind": "code",
          "literal": "# scaffold and deploy the Worker flavor\nask endpoint init --target cloudflare\nwrangler deploy            # set ANTHROPIC_API_KEY as a secret",
          "chunkId": "api/search-overlay#the-hostable-endpoint"
        },
        {
          "kind": "code",
          "literal": "POST /api/ask",
          "chunkId": "api/search-overlay#the-hostable-endpoint"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "api/search-overlay#the-hostable-endpoint"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#the-hostable-endpoint",
          "url": "/docs/api/search-overlay#the-hostable-endpoint",
          "anchor": "the-hostable-endpoint"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "hostable",
        "endpoint",
        "agentic",
        "answers",
        "without",
        "astro",
        "bounded",
        "answer",
        "loop",
        "deploys",
        "standalone",
        "service",
        "cloudflare",
        "worker",
        "node",
        "server",
        "vercel",
        "function",
        "serving",
        "same",
        "post",
        "contract",
        "route",
        "holding",
        "side",
        "reading",
        "committed",
        "digest",
        "deploy",
        "once",
        "point",
        "number",
        "sites",
        "keyword",
        "search",
        "runs",
        "entirely",
        "browser",
        "only",
        "needs"
      ]
    },
    {
      "id": "api/search-overlay#the-mode-toggle",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "The mode toggle",
      "group": "API",
      "url": "/docs/api/search-overlay#the-mode-toggle",
      "summary": "An AI-on-Enter preference persists in localStorage; readers who flip it to keyword-only never trigger a model call — a space just searches a phrase, no suggested questions show, and the choice survives reloads.",
      "hash": "f5b67968083cdfbfa00b247a46ae07a527001d5feb7c83f6ef6b3cd40deac99e",
      "facts": [
        {
          "kind": "code",
          "literal": "localStorage",
          "chunkId": "api/search-overlay#the-mode-toggle"
        },
        {
          "kind": "code",
          "literal": "hev-ask:mode",
          "chunkId": "api/search-overlay#the-mode-toggle"
        },
        {
          "kind": "code",
          "literal": "agentic",
          "chunkId": "api/search-overlay#the-mode-toggle"
        },
        {
          "kind": "code",
          "literal": "keyword",
          "chunkId": "api/search-overlay#the-mode-toggle"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#the-mode-toggle",
          "url": "/docs/api/search-overlay#the-mode-toggle",
          "anchor": "the-mode-toggle"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "mode",
        "toggle",
        "enter",
        "preference",
        "persists",
        "localstorage",
        "readers",
        "flip",
        "keyword",
        "only",
        "never",
        "trigger",
        "model",
        "call",
        "space",
        "just",
        "searches",
        "phrase",
        "suggested",
        "questions",
        "show",
        "choice",
        "survives",
        "reloads",
        "agentic",
        "overlay",
        "under",
        "shown"
      ]
    },
    {
      "id": "api/search-overlay#the-overlay-on-other-frameworks",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "The overlay on other frameworks",
      "group": "API",
      "url": "/docs/api/search-overlay#the-overlay-on-other-frameworks",
      "summary": "The same palette ships as a prebuilt web component loaded with one script tag from npm or a CDN: it reads a bundled copy of the digest in the browser so keyword search runs fully static, and an optional endpoint attribute enables agentic questions (omit it for keyword-only). Theming variables, the opener attribute, and the keyboard model are identical to the Astro component.",
      "hash": "294cf6be8257ee487de6d9399df7bb94a4a88fbf3c1865008b451588f489d85e",
      "facts": [
        {
          "kind": "code",
          "literal": "<script\n  type=\"module\"\n  src=\"https://cdn.jsdelivr.net/npm/@hevmind/ask/overlay.js\"\n  data-hev-ask-digest=\"/hev-ask/\"\n  data-hev-ask-endpoint=\"https://docs-ask.example.workers.dev/api/ask\"\n></script>\n\n<button data-hev-ask-open>Search <kbd>⌘K</kbd></button>",
          "chunkId": "api/search-overlay#the-overlay-on-other-frameworks"
        },
        {
          "kind": "code",
          "literal": "SearchOverlay.astro",
          "chunkId": "api/search-overlay#the-overlay-on-other-frameworks"
        },
        {
          "kind": "code",
          "literal": "@hevmind/ask/overlay",
          "chunkId": "api/search-overlay#the-overlay-on-other-frameworks"
        },
        {
          "kind": "code",
          "literal": "data-hev-ask-digest",
          "chunkId": "api/search-overlay#the-overlay-on-other-frameworks"
        },
        {
          "kind": "code",
          "literal": "ask digest bundle",
          "chunkId": "api/search-overlay#the-overlay-on-other-frameworks"
        },
        {
          "kind": "code",
          "literal": "data-hev-ask-endpoint",
          "chunkId": "api/search-overlay#the-overlay-on-other-frameworks"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#the-overlay-on-other-frameworks",
          "url": "/docs/api/search-overlay#the-overlay-on-other-frameworks",
          "anchor": "the-overlay-on-other-frameworks"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "overlay",
        "other",
        "frameworks",
        "same",
        "palette",
        "ships",
        "prebuilt",
        "component",
        "loaded",
        "script",
        "reads",
        "bundled",
        "copy",
        "digest",
        "browser",
        "keyword",
        "search",
        "runs",
        "fully",
        "static",
        "optional",
        "endpoint",
        "attribute",
        "enables",
        "agentic",
        "questions",
        "omit",
        "only",
        "theming",
        "variables",
        "opener",
        "keyboard",
        "model",
        "identical",
        "astro",
        "type",
        "module",
        "https",
        "jsdelivr",
        "hevmind"
      ]
    },
    {
      "id": "api/search-overlay#the-streamed-answer",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "The streamed answer",
      "group": "API",
      "url": "/docs/api/search-overlay#the-streamed-answer",
      "summary": "Pressing Enter with a key configured swaps keyword rows for an answer panel: sub-queries appear live, the grounded answer streams token-by-token, inline deep links point at exact section anchors, and a sources chip row lists the grounding set. Links are validated against the streamed source set — any URL outside it renders as plain text, so a hallucinated anchor can never become a clickable dead link.",
      "hash": "e3cc1c7af28492ceee2772cc484fcc0a30279232d034fc13fcbb6a74e0f7c152",
      "facts": [
        {
          "kind": "code",
          "literal": "searched: …",
          "chunkId": "api/search-overlay#the-streamed-answer"
        },
        {
          "kind": "code",
          "literal": "/docs/page#anchor",
          "chunkId": "api/search-overlay#the-streamed-answer"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#the-streamed-answer",
          "url": "/docs/api/search-overlay#the-streamed-answer",
          "anchor": "the-streamed-answer"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "streamed",
        "answer",
        "pressing",
        "enter",
        "configured",
        "swaps",
        "keyword",
        "rows",
        "panel",
        "queries",
        "appear",
        "live",
        "grounded",
        "streams",
        "token",
        "inline",
        "deep",
        "links",
        "point",
        "exact",
        "section",
        "anchors",
        "sources",
        "chip",
        "lists",
        "grounding",
        "validated",
        "against",
        "source",
        "outside",
        "renders",
        "plain",
        "text",
        "hallucinated",
        "anchor",
        "never",
        "become",
        "clickable",
        "dead",
        "link"
      ]
    },
    {
      "id": "api/search-overlay#theming",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "Theming",
      "group": "API",
      "url": "/docs/api/search-overlay#theming",
      "summary": "The overlay reads the page's CSS custom properties for background, primary text, secondary text, and accent colors; because its scoped styles key off those variables, matching a site's look usually means defining the tokens, not overriding overlay CSS.",
      "hash": "37bbca09a73293fc3a1fe639cabd35a98647bf221c502cc18b4e1a02585df7cf",
      "facts": [
        {
          "kind": "code",
          "literal": ":root {\n  --paper: #111111;       /* overlay background */\n  --ink: #fafaf5;         /* primary text */\n  --muted: #6b6b66;       /* secondary text */\n  --signal: #e25822;      /* accent / active state */\n}",
          "chunkId": "api/search-overlay#theming"
        },
        {
          "kind": "code",
          "literal": "as-",
          "chunkId": "api/search-overlay#theming"
        },
        {
          "kind": "code",
          "literal": ":root",
          "chunkId": "api/search-overlay#theming"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#theming",
          "url": "/docs/api/search-overlay#theming",
          "anchor": "theming"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "theming",
        "overlay",
        "reads",
        "page",
        "custom",
        "properties",
        "background",
        "primary",
        "text",
        "secondary",
        "accent",
        "colors",
        "because",
        "scoped",
        "styles",
        "those",
        "variables",
        "matching",
        "site",
        "look",
        "usually",
        "means",
        "defining",
        "tokens",
        "overriding",
        "root",
        "paper",
        "111111",
        "fafaf5",
        "muted",
        "6b6b66",
        "signal",
        "e25822",
        "active",
        "state",
        "markup",
        "uses",
        "class",
        "prefix",
        "define"
      ]
    },
    {
      "id": "api/search-overlay#vitepress",
      "kind": "section",
      "title": "SearchOverlay component",
      "heading": "VitePress",
      "group": "API",
      "url": "/docs/api/search-overlay#vitepress",
      "summary": "On VitePress, the bundle goes into the public directory and the overlay is mounted from the theme's enhance-app hook with digest and endpoint settings.",
      "hash": "c5725004205e727e67ddb65cabf811a187df397a10d72e5bb48afc6e9e7712ba",
      "facts": [
        {
          "kind": "code",
          "literal": "// .vitepress/theme/index.ts\nimport DefaultTheme from \"vitepress/theme\";\nimport { mountHevAsk } from \"@hevmind/ask/overlay\";\n\nexport default {\n  extends: DefaultTheme,\n  enhanceApp() {\n    if (typeof window !== \"undefined\") {\n      mountHevAsk({ digest: \"/hev-ask/\", endpoint: import.meta.env.VITE_ASK_ENDPOINT });\n    }\n  },\n};",
          "chunkId": "api/search-overlay#vitepress"
        },
        {
          "kind": "code",
          "literal": ".vitepress/public/",
          "chunkId": "api/search-overlay#vitepress"
        }
      ],
      "sources": [
        {
          "chunkId": "api/search-overlay#vitepress",
          "url": "/docs/api/search-overlay#vitepress",
          "anchor": "vitepress"
        }
      ],
      "mode": "source-primary",
      "terms": [
        "vitepress",
        "bundle",
        "goes",
        "public",
        "directory",
        "overlay",
        "mounted",
        "theme",
        "enhance",
        "hook",
        "digest",
        "endpoint",
        "settings",
        "index",
        "import",
        "defaulttheme",
        "mounthevask",
        "hevmind",
        "export",
        "default",
        "extends",
        "enhanceapp",
        "typeof",
        "window",
        "undefined",
        "meta",
        "vite",
        "register",
        "viteaskendpoint"
      ]
    },
    {
      "id": "concepts",
      "kind": "section",
      "title": "Concepts",
      "heading": null,
      "group": "Overview",
      "url": "/docs/concepts",
      "summary": "The core idea: the digest is just a directory — docs distilled into a committed tree of markdown files, one per section, read two ways: a coding agent navigates it with its existing file tools, and the ⌘K overlay reads it server-side to synthesize grounded answers for humans. The tree is built offline with a strong model and committed to git; the readers run on demand with no durable state in the running site.",
      "hash": "f0a685967c67732cf07a30f2bd53d177317ecfad71a2882f464985695010891d",
      "facts": [
        {
          "kind": "code",
          "literal": "⌘K",
          "chunkId": "concepts"
        },
        {
          "kind": "value",
          "literal": "Diagram.astro",
          "chunkId": "concepts"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "concepts"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts",
          "url": "/docs/concepts",
          "anchor": null
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "core",
        "idea",
        "digest",
        "just",
        "directory",
        "docs",
        "distilled",
        "committed",
        "tree",
        "markdown",
        "files",
        "section",
        "read",
        "ways",
        "coding",
        "agent",
        "navigates",
        "existing",
        "file",
        "tools",
        "overlay",
        "reads",
        "server",
        "side",
        "synthesize",
        "grounded",
        "answers",
        "humans",
        "built",
        "offline",
        "strong",
        "model",
        "readers",
        "demand",
        "durable",
        "state",
        "running",
        "site",
        "diagram",
        "astro"
      ]
    },
    {
      "id": "concepts#asking-is-the-default",
      "kind": "section",
      "title": "Concepts",
      "heading": "Asking is the default",
      "group": "Overview",
      "url": "/docs/concepts#asking-is-the-default",
      "summary": "The overlay treats a single word as an instant keyword lookup and switches to ask mode the moment a query grows past one word, with suggested questions shown on open to make asking the obvious move. None of it is forced — a keyword-only preference persists and keeps the model out of the loop entirely.",
      "hash": "a3f146a134e17963029d99e4fc3bf803f5a03a7159cd15893680d25badbfd52c",
      "facts": [
        {
          "kind": "code",
          "literal": "_meta.md",
          "chunkId": "concepts#asking-is-the-default"
        },
        {
          "kind": "code",
          "literal": "localStorage",
          "chunkId": "concepts#asking-is-the-default"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#asking-is-the-default",
          "url": "/docs/concepts#asking-is-the-default",
          "anchor": "asking-is-the-default"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "asking",
        "default",
        "overlay",
        "treats",
        "single",
        "word",
        "instant",
        "keyword",
        "lookup",
        "switches",
        "mode",
        "moment",
        "query",
        "grows",
        "past",
        "suggested",
        "questions",
        "shown",
        "open",
        "make",
        "obvious",
        "move",
        "none",
        "forced",
        "only",
        "preference",
        "persists",
        "keeps",
        "model",
        "loop",
        "entirely",
        "meta",
        "localstorage",
        "first",
        "treated",
        "answered",
        "instantly",
        "index",
        "reader",
        "types"
      ]
    },
    {
      "id": "concepts#chunks-and-anchors",
      "kind": "section",
      "title": "Concepts",
      "heading": "Chunks and anchors",
      "group": "Overview",
      "url": "/docs/concepts#chunks-and-anchors",
      "summary": "Documents are split on headings up to a configurable depth into section chunks whose URLs carry real anchors generated with github-slugger, matching what Astro and GitHub-flavored renderers emit; other adapters declare their own slug schemes. Both the offline build and the runtime index chunk through the same function, so anchors agree — and because the build reads files rather than a renderer, the digest is framework-independent.",
      "hash": "7114c39ed148b671179972b86fbdceaa60d0146af253d0bf66722359e2522155",
      "facts": [
        {
          "kind": "code",
          "literal": "##",
          "chunkId": "concepts#chunks-and-anchors"
        },
        {
          "kind": "code",
          "literal": "###",
          "chunkId": "concepts#chunks-and-anchors"
        },
        {
          "kind": "code",
          "literal": "basePath + slug + #anchor",
          "chunkId": "concepts#chunks-and-anchors"
        },
        {
          "kind": "code",
          "literal": "github-slugger",
          "chunkId": "concepts#chunks-and-anchors"
        },
        {
          "kind": "code",
          "literal": "{#custom-id}",
          "chunkId": "concepts#chunks-and-anchors"
        },
        {
          "kind": "code",
          "literal": "getCollection",
          "chunkId": "concepts#chunks-and-anchors"
        },
        {
          "kind": "value",
          "literal": "github.com",
          "chunkId": "concepts#chunks-and-anchors"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#chunks-and-anchors",
          "url": "/docs/concepts#chunks-and-anchors",
          "anchor": "chunks-and-anchors"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "chunks",
        "anchors",
        "documents",
        "split",
        "headings",
        "configurable",
        "depth",
        "section",
        "whose",
        "urls",
        "carry",
        "real",
        "generated",
        "github",
        "slugger",
        "matching",
        "astro",
        "flavored",
        "renderers",
        "emit",
        "other",
        "adapters",
        "declare",
        "their",
        "slug",
        "schemes",
        "both",
        "offline",
        "build",
        "runtime",
        "index",
        "chunk",
        "through",
        "same",
        "function",
        "agree",
        "because",
        "reads",
        "files",
        "rather"
      ]
    },
    {
      "id": "concepts#degradation-by-design",
      "kind": "section",
      "title": "Concepts",
      "heading": "Degradation, by design",
      "group": "Overview",
      "url": "/docs/concepts#degradation-by-design",
      "summary": "Every missing piece degrades rather than breaks: no runtime key means keyword-only, no build key keeps the committed tree with a warning, no digest tree drops the loop to keyword retrieval and ranking to raw token overlap, and a stale tree logs a one-line warning while still serving.",
      "hash": "94c92585e092fcc000511ebc5e7640ac04f1bfd70029f77bd3aea3959affb6e0",
      "facts": [
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "concepts#degradation-by-design"
        },
        {
          "kind": "code",
          "literal": "_meta.md",
          "chunkId": "concepts#degradation-by-design"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#degradation-by-design",
          "url": "/docs/concepts#degradation-by-design",
          "anchor": "degradation-by-design"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "degradation",
        "design",
        "every",
        "missing",
        "piece",
        "degrades",
        "rather",
        "breaks",
        "runtime",
        "means",
        "keyword",
        "only",
        "build",
        "keeps",
        "committed",
        "tree",
        "warning",
        "digest",
        "drops",
        "loop",
        "retrieval",
        "ranking",
        "token",
        "overlap",
        "stale",
        "logs",
        "line",
        "while",
        "still",
        "serving",
        "meta",
        "built",
        "keep",
        "working",
        "pieces",
        "drop",
        "away",
        "mode",
        "overlay",
        "searches"
      ]
    },
    {
      "id": "concepts#host-neutral-one-digest-any-framework",
      "kind": "section",
      "title": "Concepts",
      "heading": "Host-neutral: one digest, any framework",
      "group": "Overview",
      "url": "/docs/concepts#host-neutral-one-digest-any-framework",
      "summary": "The digest build never touches a renderer — it reads markdown, chunks on headings, derives anchors in code — so the artifact is identical across Astro, Docusaurus, VitePress, and MkDocs. Only the adapter differs: Astro's batteries-included integration, versus two host-neutral primitives elsewhere (the static drop-in overlay for keyword search and the hostable endpoint for agentic answers). The CLI and MCP read the tree directly on any host.",
      "hash": "b670f196f7770314128233d4a8ce13b0b168f901639a3697bcaf9c119bc1a17a",
      "facts": [
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        },
        {
          "kind": "code",
          "literal": "hevAsk()",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        },
        {
          "kind": "code",
          "literal": "astro build",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        },
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        },
        {
          "kind": "code",
          "literal": "SearchOverlay.astro",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        },
        {
          "kind": "code",
          "literal": "<script>",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "concepts#host-neutral-one-digest-any-framework"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#host-neutral-one-digest-any-framework",
          "url": "/docs/concepts#host-neutral-one-digest-any-framework",
          "anchor": "host-neutral-one-digest-any-framework"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "host",
        "neutral",
        "digest",
        "framework",
        "build",
        "never",
        "touches",
        "renderer",
        "reads",
        "markdown",
        "chunks",
        "headings",
        "derives",
        "anchors",
        "code",
        "artifact",
        "identical",
        "across",
        "astro",
        "docusaurus",
        "vitepress",
        "mkdocs",
        "only",
        "adapter",
        "differs",
        "batteries",
        "included",
        "integration",
        "versus",
        "primitives",
        "elsewhere",
        "static",
        "drop",
        "overlay",
        "keyword",
        "search",
        "hostable",
        "endpoint",
        "agentic",
        "answers"
      ]
    },
    {
      "id": "concepts#keyword-search-and-the-glossary",
      "kind": "section",
      "title": "Concepts",
      "heading": "Keyword search and the glossary",
      "group": "Overview",
      "url": "/docs/concepts#keyword-search-and-the-glossary",
      "summary": "The instant path is a dependency-free prefilter: expand each query term with glossary aliases, score by token overlap widened by the digest's summaries, terms, and facts (so central sections outrank incidental mentions), cap results per document, and excerpt around the first match. No API key, no embeddings — and with no tree it degrades to plain token overlap, so keyword search always works.",
      "hash": "6496e6a2896ae22bcdf61b3dbba97df885d89427d2f4b266e7553f09e094cb91",
      "facts": [
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "concepts#keyword-search-and-the-glossary"
        },
        {
          "kind": "code",
          "literal": "k8s",
          "chunkId": "concepts#keyword-search-and-the-glossary"
        },
        {
          "kind": "code",
          "literal": "kubernetes",
          "chunkId": "concepts#keyword-search-and-the-glossary"
        },
        {
          "kind": "code",
          "literal": "summary",
          "chunkId": "concepts#keyword-search-and-the-glossary"
        },
        {
          "kind": "code",
          "literal": "terms",
          "chunkId": "concepts#keyword-search-and-the-glossary"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "concepts#keyword-search-and-the-glossary"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#keyword-search-and-the-glossary",
          "url": "/docs/concepts#keyword-search-and-the-glossary",
          "anchor": "keyword-search-and-the-glossary"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "keyword",
        "search",
        "glossary",
        "instant",
        "path",
        "dependency",
        "free",
        "prefilter",
        "expand",
        "query",
        "term",
        "aliases",
        "score",
        "token",
        "overlap",
        "widened",
        "digest",
        "summaries",
        "terms",
        "facts",
        "central",
        "sections",
        "outrank",
        "incidental",
        "mentions",
        "results",
        "document",
        "excerpt",
        "around",
        "first",
        "match",
        "embeddings",
        "tree",
        "degrades",
        "plain",
        "always",
        "works",
        "grep",
        "kubernetes",
        "summary"
      ]
    },
    {
      "id": "concepts#progressive-disclosure-as-a-directory",
      "kind": "section",
      "title": "Concepts",
      "heading": "Progressive disclosure as a directory",
      "group": "Overview",
      "url": "/docs/concepts#progressive-disclosure-as-a-directory",
      "summary": "Because the digest is a real directory, progressive disclosure is the directory's own cost model: a four-rung ladder where listings read frontmatter titles only (bounded by section count, safe to call speculatively) and each deeper read — summary, body, facts — is an explicit verb. Nothing larger than a title is ever returned by surprise.",
      "hash": "2ef9d29a6e5fbcfdd336ebb8ab2994c809066d85a04de2e86ec34711f48f0d27",
      "facts": [
        {
          "kind": "code",
          "literal": "ls",
          "chunkId": "concepts#progressive-disclosure-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "concepts#progressive-disclosure-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "concepts#progressive-disclosure-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "head",
          "chunkId": "concepts#progressive-disclosure-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "concepts#progressive-disclosure-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "concepts#progressive-disclosure-as-a-directory"
        },
        {
          "kind": "code",
          "literal": "ask",
          "chunkId": "concepts#progressive-disclosure-as-a-directory"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#progressive-disclosure-as-a-directory",
          "url": "/docs/concepts#progressive-disclosure-as-a-directory",
          "anchor": "progressive-disclosure-as-a-directory"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "progressive",
        "disclosure",
        "directory",
        "because",
        "digest",
        "real",
        "cost",
        "model",
        "four",
        "rung",
        "ladder",
        "listings",
        "read",
        "frontmatter",
        "titles",
        "only",
        "bounded",
        "section",
        "count",
        "safe",
        "call",
        "speculatively",
        "deeper",
        "summary",
        "body",
        "facts",
        "explicit",
        "verb",
        "nothing",
        "larger",
        "title",
        "ever",
        "returned",
        "surprise",
        "tree",
        "head",
        "grep",
        "just",
        "agent",
        "already"
      ]
    },
    {
      "id": "concepts#the-agentic-search-loop",
      "kind": "section",
      "title": "Concepts",
      "heading": "The agentic search loop",
      "group": "Overview",
      "url": "/docs/concepts#the-agentic-search-loop",
      "summary": "The loop runs in two phases: gather, where the model sees the full title-tree and opens sections with a single open-section tool for up to a bounded number of rounds; and answer, where the accumulated sources go to the overlay for link validation and the model is called once more with no tools so it can only write prose. The answer is constrained to retrieved sections — it links only to provided URLs and cannot ground in what retrieval never found.",
      "hash": "2f6dfa7319e162069240585c70a19b0d2727aa413c0bddd5dd0644f360619892",
      "facts": [
        {
          "kind": "code",
          "literal": "open_section({ id })",
          "chunkId": "concepts#the-agentic-search-loop"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "concepts#the-agentic-search-loop"
        },
        {
          "kind": "code",
          "literal": "maxIterations",
          "chunkId": "concepts#the-agentic-search-loop"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "concepts#the-agentic-search-loop"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#the-agentic-search-loop",
          "url": "/docs/concepts#the-agentic-search-loop",
          "anchor": "the-agentic-search-loop"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "agentic",
        "search",
        "loop",
        "runs",
        "phases",
        "gather",
        "model",
        "sees",
        "full",
        "title",
        "tree",
        "opens",
        "sections",
        "single",
        "open",
        "section",
        "tool",
        "bounded",
        "number",
        "rounds",
        "answer",
        "accumulated",
        "sources",
        "overlay",
        "link",
        "validation",
        "called",
        "once",
        "more",
        "tools",
        "only",
        "write",
        "prose",
        "constrained",
        "retrieved",
        "links",
        "provided",
        "urls",
        "cannot",
        "ground"
      ]
    },
    {
      "id": "concepts#the-ask-digest-directory",
      "kind": "section",
      "title": "Concepts",
      "heading": "The ask digest directory",
      "group": "Overview",
      "url": "/docs/concepts#the-ask-digest-directory",
      "summary": "The build writes one distilled markdown+frontmatter file per section, mirroring doc paths, plus a glossary directory and a meta file — markdown all the way down, so prose and facts change together in one reviewable diff. Listings return only frontmatter titles, so titles must carry the open/skip decision: page titles come from the collection and sub-section titles are synthesized into descriptive one-liners.",
      "hash": "d9602cd4160894a54ec544b98098991a34a8f6349b3394b4b5eb3b7299eed10d",
      "facts": [
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "overview/",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "api/",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "title",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "url",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "anchor",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "sources",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "terms",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "hash",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "_glossary/",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "_meta.md",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "context",
          "chunkId": "concepts#the-ask-digest-directory"
        },
        {
          "kind": "code",
          "literal": "heading",
          "chunkId": "concepts#the-ask-digest-directory"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#the-ask-digest-directory",
          "url": "/docs/concepts#the-ask-digest-directory",
          "anchor": "the-ask-digest-directory"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "digest",
        "directory",
        "build",
        "writes",
        "distilled",
        "markdown",
        "frontmatter",
        "file",
        "section",
        "mirroring",
        "paths",
        "plus",
        "glossary",
        "meta",
        "down",
        "prose",
        "facts",
        "change",
        "together",
        "reviewable",
        "diff",
        "listings",
        "return",
        "only",
        "titles",
        "must",
        "carry",
        "open",
        "skip",
        "decision",
        "page",
        "come",
        "collection",
        "synthesized",
        "descriptive",
        "liners",
        "overview",
        "title",
        "anchor",
        "sources"
      ]
    },
    {
      "id": "concepts#the-system-prompt-is-cached",
      "kind": "section",
      "title": "Concepts",
      "heading": "The system prompt is cached",
      "group": "Overview",
      "url": "/docs/concepts#the-system-prompt-is-cached",
      "summary": "The title-tree and summaries enter the system prompt with a cache-control marker, so the gather rounds hit the prompt cache; the toolless answer turn can't reuse it but is the final call anyway. The reader's server-side loop and a consumer's coding agent are distinct readers climbing the same four-rung ladder — one over the in-memory tree, the other over files on its own disk.",
      "hash": "740d6a77b01eeb8a97450a731c865c453c8e7aac42a1971856ecacdf05622c39",
      "facts": [
        {
          "kind": "code",
          "literal": "cache_control",
          "chunkId": "concepts#the-system-prompt-is-cached"
        },
        {
          "kind": "value",
          "literal": "4.5",
          "chunkId": "concepts#the-system-prompt-is-cached"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#the-system-prompt-is-cached",
          "url": "/docs/concepts#the-system-prompt-is-cached",
          "anchor": "the-system-prompt-is-cached"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "system",
        "prompt",
        "cached",
        "title",
        "tree",
        "summaries",
        "enter",
        "cache",
        "control",
        "marker",
        "gather",
        "rounds",
        "toolless",
        "answer",
        "turn",
        "reuse",
        "final",
        "call",
        "anyway",
        "reader",
        "server",
        "side",
        "loop",
        "consumer",
        "coding",
        "agent",
        "distinct",
        "readers",
        "climbing",
        "same",
        "four",
        "rung",
        "ladder",
        "memory",
        "other",
        "files",
        "disk",
        "section",
        "injected",
        "cachecontrol"
      ]
    },
    {
      "id": "concepts#two-ways-to-build-the-tree",
      "kind": "section",
      "title": "Concepts",
      "heading": "Two ways to build the tree",
      "group": "Overview",
      "url": "/docs/concepts#two-ways-to-build-the-tree",
      "summary": "Only the distillation (summaries, glossary, context, suggestions) is model-authored; structure, facts, overview, hashes, and anchors are computed deterministically. That seam allows two build paths: the recommended Claude Code skill (runs in your subscription, no API key or token spend) and the CLI build (one API call to the Opus-class default, right for CI). Both are incremental, hash-gated, and produce a PR-reviewable tree.",
      "hash": "ea8c9b547ad83de8bac44812d869f94180b8ff660c5fb30cba7a6662d1e77a14",
      "facts": [
        {
          "kind": "code",
          "literal": "summary",
          "chunkId": "concepts#two-ways-to-build-the-tree"
        },
        {
          "kind": "code",
          "literal": "context",
          "chunkId": "concepts#two-ways-to-build-the-tree"
        },
        {
          "kind": "code",
          "literal": "suggestions",
          "chunkId": "concepts#two-ways-to-build-the-tree"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "concepts#two-ways-to-build-the-tree"
        },
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "concepts#two-ways-to-build-the-tree"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "concepts#two-ways-to-build-the-tree"
        },
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "concepts#two-ways-to-build-the-tree"
        },
        {
          "kind": "value",
          "literal": "4.8",
          "chunkId": "concepts#two-ways-to-build-the-tree"
        }
      ],
      "sources": [
        {
          "chunkId": "concepts#two-ways-to-build-the-tree",
          "url": "/docs/concepts#two-ways-to-build-the-tree",
          "anchor": "two-ways-to-build-the-tree"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "ways",
        "build",
        "tree",
        "only",
        "distillation",
        "summaries",
        "glossary",
        "context",
        "suggestions",
        "model",
        "authored",
        "structure",
        "facts",
        "overview",
        "hashes",
        "anchors",
        "computed",
        "deterministically",
        "seam",
        "allows",
        "paths",
        "recommended",
        "claude",
        "code",
        "skill",
        "runs",
        "subscription",
        "token",
        "spend",
        "call",
        "opus",
        "class",
        "default",
        "right",
        "both",
        "incremental",
        "hash",
        "gated",
        "produce",
        "reviewable"
      ]
    },
    {
      "id": "digest-creation",
      "kind": "section",
      "title": "Digest creation",
      "heading": null,
      "group": "Overview",
      "url": "/docs/digest-creation",
      "summary": "The digest is created offline and committed like source: a build reads markdown off the filesystem, distils each section into a small markdown file, and writes the tree. The running site, CLI, and MCP server read the committed artifact and never call a model to serve it.",
      "hash": "ab2a11a79292291f51f62b5d2f5ec903af81ac9609ecb10ec4d71d9ad66f3f71",
      "facts": [
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "digest-creation"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "digest-creation"
        },
        {
          "kind": "value",
          "literal": "CodeTabs.astro",
          "chunkId": "digest-creation"
        }
      ],
      "sources": [
        {
          "chunkId": "digest-creation",
          "url": "/docs/digest-creation",
          "anchor": null
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "digest",
        "created",
        "offline",
        "committed",
        "like",
        "source",
        "build",
        "reads",
        "markdown",
        "filesystem",
        "distils",
        "section",
        "small",
        "file",
        "writes",
        "tree",
        "running",
        "site",
        "server",
        "read",
        "artifact",
        "never",
        "call",
        "model",
        "serve",
        "callout",
        "astro",
        "codetabs",
        "built",
        "distillation",
        "through",
        "claude",
        "code",
        "skill",
        "gated",
        "hashes",
        "verified",
        "repo",
        "other"
      ]
    },
    {
      "id": "digest-creation#built-from-markdown-not-from-a-renderer",
      "kind": "section",
      "title": "Digest creation",
      "heading": "Built from markdown, not from a renderer",
      "group": "Overview",
      "url": "/docs/digest-creation#built-from-markdown-not-from-a-renderer",
      "summary": "The build never imports a framework — it reads files, chunks on headings, and derives anchors in code, producing the same artifact on any renderer or none. Only the timing differs per host: the Astro integration runs it during the site build when a key is present; elsewhere it's a build or CI step. Overlay wiring on non-Astro sites is a separate, smaller job.",
      "hash": "473b58f15073f724b5961c7a62a2f9f09cabd49ec8b8e42e7d692e7ae6ec4461",
      "facts": [
        {
          "kind": "code",
          "literal": "astro build",
          "chunkId": "digest-creation#built-from-markdown-not-from-a-renderer"
        }
      ],
      "sources": [
        {
          "chunkId": "digest-creation#built-from-markdown-not-from-a-renderer",
          "url": "/docs/digest-creation#built-from-markdown-not-from-a-renderer",
          "anchor": "built-from-markdown-not-from-a-renderer"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "built",
        "markdown",
        "renderer",
        "build",
        "never",
        "imports",
        "framework",
        "reads",
        "files",
        "chunks",
        "headings",
        "derives",
        "anchors",
        "code",
        "producing",
        "same",
        "artifact",
        "none",
        "only",
        "timing",
        "differs",
        "host",
        "astro",
        "integration",
        "runs",
        "during",
        "site",
        "present",
        "elsewhere",
        "step",
        "overlay",
        "wiring",
        "sites",
        "separate",
        "smaller",
        "writes",
        "tree",
        "comes",
        "whether",
        "docusaurus"
      ]
    },
    {
      "id": "digest-creation#incremental-by-hash",
      "kind": "section",
      "title": "Digest creation",
      "heading": "Incremental by hash",
      "group": "Overview",
      "url": "/docs/digest-creation#incremental-by-hash",
      "summary": "Every section file records the hash of the content it was distilled from, so rebuilds re-distil only changed sections and a clean tree does no model work — making rebuild-on-every-change the intended workflow rather than a chore.",
      "hash": "55d38a351a62131967527fca13fca8ad624324075d63337614941148ce9174f1",
      "facts": [],
      "sources": [
        {
          "chunkId": "digest-creation#incremental-by-hash",
          "url": "/docs/digest-creation#incremental-by-hash",
          "anchor": "incremental-by-hash"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "incremental",
        "hash",
        "every",
        "section",
        "file",
        "records",
        "content",
        "distilled",
        "rebuilds",
        "distil",
        "only",
        "changed",
        "sections",
        "clean",
        "tree",
        "does",
        "model",
        "work",
        "making",
        "rebuild",
        "change",
        "intended",
        "workflow",
        "rather",
        "chore",
        "distils",
        "whose",
        "makes",
        "cheap",
        "enough"
      ]
    },
    {
      "id": "digest-creation#two-ways-to-run-the-build",
      "kind": "section",
      "title": "Digest creation",
      "heading": "Two ways to run the build",
      "group": "Overview",
      "url": "/docs/digest-creation#two-ways-to-run-the-build",
      "summary": "Two build paths: the recommended bundled Claude Code skill, which needs no API key and shards the corpus so size never hits a context limit, and the CLI build for CI or non-Claude-Code use, one unattended API call on the default or any configured provider. Both write the same tree under the same hash gate.",
      "hash": "cc8ff5c21b0b7eeda4b14b44b4f1df1a979bf029b005e2bf8c24d334fe803413",
      "facts": [
        {
          "kind": "code",
          "literal": "You: build the hev ask digest\n\nClaude runs:\n  ask digest corpus       # emits the sections to distil\n  …writes context/glossary/summaries/suggestions…\n  ask digest assemble     # writes the .hev-ask/ tree",
          "chunkId": "digest-creation#two-ways-to-run-the-build"
        },
        {
          "kind": "code",
          "literal": "export ANTHROPIC_API_KEY=sk-ant-...\npnpm exec ask digest build",
          "chunkId": "digest-creation#two-ways-to-run-the-build"
        },
        {
          "kind": "code",
          "literal": "export OPENAI_API_KEY=sk-...\npnpm exec ask digest build --provider openai",
          "chunkId": "digest-creation#two-ways-to-run-the-build"
        },
        {
          "kind": "code",
          "literal": "export OPENROUTER_API_KEY=sk-or-...\npnpm exec ask digest build --provider openrouter",
          "chunkId": "digest-creation#two-ways-to-run-the-build"
        },
        {
          "kind": "code",
          "literal": "build-digest",
          "chunkId": "digest-creation#two-ways-to-run-the-build"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "digest-creation#two-ways-to-run-the-build"
        },
        {
          "kind": "code",
          "literal": "--provider",
          "chunkId": "digest-creation#two-ways-to-run-the-build"
        },
        {
          "kind": "value",
          "literal": "4.8",
          "chunkId": "digest-creation#two-ways-to-run-the-build"
        }
      ],
      "sources": [
        {
          "chunkId": "digest-creation#two-ways-to-run-the-build",
          "url": "/docs/digest-creation#two-ways-to-run-the-build",
          "anchor": "two-ways-to-run-the-build"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "ways",
        "build",
        "paths",
        "recommended",
        "bundled",
        "claude",
        "code",
        "skill",
        "needs",
        "shards",
        "corpus",
        "size",
        "never",
        "hits",
        "context",
        "limit",
        "unattended",
        "call",
        "default",
        "configured",
        "provider",
        "both",
        "write",
        "same",
        "tree",
        "under",
        "hash",
        "gate",
        "digest",
        "runs",
        "emits",
        "sections",
        "distil",
        "writes",
        "glossary",
        "summaries",
        "suggestions",
        "assemble",
        "export",
        "anthropic"
      ]
    },
    {
      "id": "digest-creation#verify-review-commit",
      "kind": "section",
      "title": "Digest creation",
      "heading": "Verify, review, commit",
      "group": "Overview",
      "url": "/docs/digest-creation#verify-review-commit",
      "summary": "The verify command is the CI gate: it builds the site, fails when any section anchor is missing from the rendered HTML, and warns on coverage or fidelity drift. The markdown tree makes each section's prose and facts one reviewable diff; a stale digest triggers a one-line runtime warning but keeps serving until rebuilt.",
      "hash": "3e04fbcdb9c42dcd79f213c0ffc5ff67e8eba56d67c1e18de255ae88432e8c8a",
      "facts": [
        {
          "kind": "code",
          "literal": "pnpm exec ask digest verify     # builds the site, checks every anchor resolves\ngit add .hev-ask",
          "chunkId": "digest-creation#verify-review-commit"
        },
        {
          "kind": "code",
          "literal": "ask digest verify",
          "chunkId": "digest-creation#verify-review-commit"
        }
      ],
      "sources": [
        {
          "chunkId": "digest-creation#verify-review-commit",
          "url": "/docs/digest-creation#verify-review-commit",
          "anchor": "verify-review-commit"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "verify",
        "review",
        "commit",
        "command",
        "gate",
        "builds",
        "site",
        "fails",
        "section",
        "anchor",
        "missing",
        "rendered",
        "html",
        "warns",
        "coverage",
        "fidelity",
        "drift",
        "markdown",
        "tree",
        "makes",
        "prose",
        "facts",
        "reviewable",
        "diff",
        "stale",
        "digest",
        "triggers",
        "line",
        "runtime",
        "warning",
        "keeps",
        "serving",
        "until",
        "rebuilt",
        "pnpm",
        "exec",
        "checks",
        "every",
        "resolves",
        "because"
      ]
    },
    {
      "id": "digest-creation#what-the-model-writes",
      "kind": "section",
      "title": "Digest creation",
      "heading": "What the model writes",
      "group": "Overview",
      "url": "/docs/digest-creation#what-the-model-writes",
      "summary": "Only the distillation is model-authored — per-section summaries, the glossary, orientation context, and suggested questions. Structure, verbatim facts, the overview, anchors, and hashes are derived deterministically in code, a seam that lets the model step run anywhere a model is available, including inside the editor.",
      "hash": "bc56e588e06df49a56847fc7db807331fdb4e9d43d51ed574f7bbb540d36c1da",
      "facts": [],
      "sources": [
        {
          "chunkId": "digest-creation#what-the-model-writes",
          "url": "/docs/digest-creation#what-the-model-writes",
          "anchor": "what-the-model-writes"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "model",
        "writes",
        "only",
        "distillation",
        "authored",
        "section",
        "summaries",
        "glossary",
        "orientation",
        "context",
        "suggested",
        "questions",
        "structure",
        "verbatim",
        "facts",
        "overview",
        "anchors",
        "hashes",
        "derived",
        "deterministically",
        "code",
        "seam",
        "lets",
        "step",
        "anywhere",
        "available",
        "including",
        "inside",
        "editor",
        "summary",
        "everything",
        "else",
        "tree"
      ]
    },
    {
      "id": "index",
      "kind": "section",
      "title": "Introduction",
      "heading": null,
      "group": "Overview",
      "url": "/docs",
      "summary": "hev ask distills a docs site into a compact directory of markdown — one small file per section — that a coding agent can navigate with file tools and a ⌘K overlay answers readers from. It's host-neutral (built from markdown, not a renderer), ships a turnkey Astro integration, adds the same overlay to any other framework with one script, and fits technical docs, internal wikis, and medium-sized corpora.",
      "hash": "5a94ae0b351ff3ceebfccf626431a5b0d5420c9f81c900ff454f69e5b3646c92",
      "facts": [
        {
          "kind": "code",
          "literal": "⌘K",
          "chunkId": "index"
        },
        {
          "kind": "value",
          "literal": "Diagram.astro",
          "chunkId": "index"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "index"
        },
        {
          "kind": "value",
          "literal": "astro.build",
          "chunkId": "index"
        }
      ],
      "sources": [
        {
          "chunkId": "index",
          "url": "/docs",
          "anchor": null
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "distills",
        "docs",
        "site",
        "compact",
        "directory",
        "markdown",
        "small",
        "file",
        "section",
        "coding",
        "agent",
        "navigate",
        "tools",
        "overlay",
        "answers",
        "readers",
        "host",
        "neutral",
        "built",
        "renderer",
        "ships",
        "turnkey",
        "astro",
        "integration",
        "adds",
        "same",
        "other",
        "framework",
        "script",
        "fits",
        "technical",
        "internal",
        "wikis",
        "medium",
        "sized",
        "corpora",
        "diagram",
        "callout",
        "build",
        "tree"
      ]
    },
    {
      "id": "index#next-steps",
      "kind": "section",
      "title": "Introduction",
      "heading": "Next steps",
      "group": "Overview",
      "url": "/docs#next-steps",
      "summary": "Navigation hub pointing to the quick start, digest creation, concepts, the tradeoffs and limits pages, the CLI reference, and the full API reference.",
      "hash": "292d13fd4cc150850f930dbe0b306b79ccebb4ecad52afd02797d107a94aaf57",
      "facts": [
        {
          "kind": "code",
          "literal": "ask",
          "chunkId": "index#next-steps"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "index#next-steps"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "index#next-steps"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "index#next-steps"
        }
      ],
      "sources": [
        {
          "chunkId": "index#next-steps",
          "url": "/docs#next-steps",
          "anchor": "next-steps"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "next",
        "steps",
        "navigation",
        "pointing",
        "quick",
        "start",
        "digest",
        "creation",
        "concepts",
        "tradeoffs",
        "limits",
        "pages",
        "reference",
        "full",
        "tree",
        "grep",
        "search",
        "astro",
        "site",
        "five",
        "minutes",
        "built",
        "kept",
        "fresh",
        "verified",
        "chunks",
        "anchors",
        "disclosure",
        "ladder",
        "agentic",
        "loop",
        "directory",
        "choosing",
        "deliberately",
        "doesn",
        "browse",
        "every",
        "option",
        "component",
        "props"
      ]
    },
    {
      "id": "index#one-artifact-three-readers",
      "kind": "section",
      "title": "Introduction",
      "heading": "One artifact, three readers",
      "group": "Overview",
      "url": "/docs#one-artifact-three-readers",
      "summary": "One committed tree serves three readers: the ⌘K overlay for humans (instant keyword results plus a grounded answer on Enter, every result deep-linked), the CLI's keyless read verbs for agents in any shell, and the MCP server that hydrates the tree to disk for an agent's own file tools. The corpus is only the content you point at — no crawler, no external index, nothing to keep in sync.",
      "hash": "ecc5d42813f44e2bae5ad6bdcdded1f85fb0edb9be82f3cbbe7414f063d28ed8",
      "facts": [
        {
          "kind": "code",
          "literal": ".hev-ask/",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "⌘K",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "ask",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "ls",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "head",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "facts",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "ask mcp",
          "chunkId": "index#one-artifact-three-readers"
        },
        {
          "kind": "code",
          "literal": "docs/",
          "chunkId": "index#one-artifact-three-readers"
        }
      ],
      "sources": [
        {
          "chunkId": "index#one-artifact-three-readers",
          "url": "/docs#one-artifact-three-readers",
          "anchor": "one-artifact-three-readers"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "artifact",
        "three",
        "readers",
        "committed",
        "tree",
        "serves",
        "overlay",
        "humans",
        "instant",
        "keyword",
        "results",
        "plus",
        "grounded",
        "answer",
        "enter",
        "every",
        "result",
        "deep",
        "linked",
        "keyless",
        "read",
        "verbs",
        "agents",
        "shell",
        "server",
        "hydrates",
        "disk",
        "agent",
        "file",
        "tools",
        "corpus",
        "only",
        "content",
        "point",
        "crawler",
        "external",
        "index",
        "nothing",
        "keep",
        "sync"
      ]
    },
    {
      "id": "index#who-this-is-for",
      "kind": "section",
      "title": "Introduction",
      "heading": "Who this is for",
      "group": "Overview",
      "url": "/docs#who-this-is-for",
      "summary": "For maintainers of markdown/MDX docs sites who want search that works without a service or crawler, deep-links to the right section, answers questions phrased in the reader's words, and is queryable by a coding agent. One integration covers it on Astro; other frameworks drop in the static overlay plus an optional hosted endpoint. Pagefind is recommended outright for keyless static keyword-only needs.",
      "hash": "0b40a609d61a8ab6344a8eb64cec888f892ce876364bddd93286bee49ac715b5",
      "facts": [
        {
          "kind": "value",
          "literal": "pagefind.app",
          "chunkId": "index#who-this-is-for"
        }
      ],
      "sources": [
        {
          "chunkId": "index#who-this-is-for",
          "url": "/docs#who-this-is-for",
          "anchor": "who-this-is-for"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "maintainers",
        "markdown",
        "docs",
        "sites",
        "want",
        "search",
        "works",
        "without",
        "service",
        "crawler",
        "deep",
        "links",
        "right",
        "section",
        "answers",
        "questions",
        "phrased",
        "reader",
        "words",
        "queryable",
        "coding",
        "agent",
        "integration",
        "covers",
        "astro",
        "other",
        "frameworks",
        "drop",
        "static",
        "overlay",
        "plus",
        "optional",
        "hosted",
        "endpoint",
        "pagefind",
        "recommended",
        "outright",
        "keyless",
        "keyword",
        "only"
      ]
    },
    {
      "id": "limits",
      "kind": "section",
      "title": "Limits",
      "heading": null,
      "group": "Overview",
      "url": "/docs/limits",
      "summary": "The hard boundaries to know before adopting: corpus scope, the recall ceiling, digest build bounds, frontmatter parsing, latency, and adapter requirements — edges of the current design, not bugs.",
      "hash": "d7dca49533d95fbdc798e6cfdf74017abfc0cf190ff1530d7050351890b64fdb",
      "facts": [
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "limits"
        }
      ],
      "sources": [
        {
          "chunkId": "limits",
          "url": "/docs/limits",
          "anchor": null
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "hard",
        "boundaries",
        "know",
        "before",
        "adopting",
        "corpus",
        "scope",
        "recall",
        "ceiling",
        "digest",
        "build",
        "bounds",
        "frontmatter",
        "parsing",
        "latency",
        "adapter",
        "requirements",
        "edges",
        "current",
        "design",
        "bugs",
        "callout",
        "astro",
        "limits",
        "deliberately",
        "does",
        "these",
        "should",
        "none",
        "covers"
      ]
    },
    {
      "id": "limits#agentic-search-adds-latency",
      "kind": "section",
      "title": "Limits",
      "heading": "Agentic search adds latency",
      "group": "Overview",
      "url": "/docs/limits#agentic-search-adds-latency",
      "summary": "The agentic path is bounded by a configurable number of model round-trips — worst case a few seconds, not instant by nature. Keyword search remains the always-available instant lane, and lowering the iteration cap tightens the latency ceiling.",
      "hash": "39f47a0577b861e2dbe61b168c9018a6b5514c62ce98b8c23fb620d1d0a7e717",
      "facts": [
        {
          "kind": "code",
          "literal": "maxIterations",
          "chunkId": "limits#agentic-search-adds-latency"
        }
      ],
      "sources": [
        {
          "chunkId": "limits#agentic-search-adds-latency",
          "url": "/docs/limits#agentic-search-adds-latency",
          "anchor": "agentic-search-adds-latency"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "agentic",
        "search",
        "adds",
        "latency",
        "path",
        "bounded",
        "configurable",
        "number",
        "model",
        "round",
        "trips",
        "worst",
        "case",
        "seconds",
        "instant",
        "nature",
        "keyword",
        "remains",
        "always",
        "available",
        "lane",
        "lowering",
        "iteration",
        "tightens",
        "ceiling",
        "maxiterations",
        "default",
        "claude",
        "considered",
        "tune",
        "down",
        "need",
        "tighter"
      ]
    },
    {
      "id": "limits#anchors-depend-on-the-renderers-slugger",
      "kind": "section",
      "title": "Limits",
      "heading": "Anchors depend on the renderer's slugger",
      "group": "Overview",
      "url": "/docs/limits#anchors-depend-on-the-renderers-slugger",
      "summary": "Deep links stay correct only while generated heading slugs match the renderer's ids; the default slugger aligns with Astro and GitHub, adapters declare their own schemes, and the verify command fails when any chunk anchor is missing from built HTML — wire it into CI to catch slugging changes before a broken link ships.",
      "hash": "3be9d1ca0662266a81ed851e1d0f0874f32e2082cb2ff3336eafaa8eb6ac175e",
      "facts": [
        {
          "kind": "code",
          "literal": "id",
          "chunkId": "limits#anchors-depend-on-the-renderers-slugger"
        },
        {
          "kind": "code",
          "literal": "github-slugger",
          "chunkId": "limits#anchors-depend-on-the-renderers-slugger"
        },
        {
          "kind": "code",
          "literal": "ask digest verify",
          "chunkId": "limits#anchors-depend-on-the-renderers-slugger"
        },
        {
          "kind": "code",
          "literal": "verify",
          "chunkId": "limits#anchors-depend-on-the-renderers-slugger"
        }
      ],
      "sources": [
        {
          "chunkId": "limits#anchors-depend-on-the-renderers-slugger",
          "url": "/docs/limits#anchors-depend-on-the-renderers-slugger",
          "anchor": "anchors-depend-on-the-renderers-slugger"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "anchors",
        "depend",
        "renderer",
        "slugger",
        "deep",
        "links",
        "stay",
        "correct",
        "only",
        "while",
        "generated",
        "heading",
        "slugs",
        "match",
        "default",
        "aligns",
        "astro",
        "github",
        "adapters",
        "declare",
        "their",
        "schemes",
        "verify",
        "command",
        "fails",
        "chunk",
        "anchor",
        "missing",
        "built",
        "html",
        "wire",
        "catch",
        "slugging",
        "changes",
        "before",
        "broken",
        "link",
        "ships",
        "digest",
        "long"
      ]
    },
    {
      "id": "limits#frontmatter-parsing-is-a-flat-yaml-subset",
      "kind": "section",
      "title": "Limits",
      "heading": "Frontmatter parsing is a flat-YAML subset",
      "group": "Overview",
      "url": "/docs/limits#frontmatter-parsing-is-a-flat-yaml-subset",
      "summary": "The offline build parses frontmatter with a small flat-YAML splitter handling string and number fields; nested structures aren't supported. This only affects the offline file-reading build — the Astro runtime index uses the collection API, which honors the real schema.",
      "hash": "da3ebf7a72c862c9bb94804726792203ebd2dad95887c4c094bf492223e719b8",
      "facts": [
        {
          "kind": "code",
          "literal": "getCollection",
          "chunkId": "limits#frontmatter-parsing-is-a-flat-yaml-subset"
        }
      ],
      "sources": [
        {
          "chunkId": "limits#frontmatter-parsing-is-a-flat-yaml-subset",
          "url": "/docs/limits#frontmatter-parsing-is-a-flat-yaml-subset",
          "anchor": "frontmatter-parsing-is-a-flat-yaml-subset"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "frontmatter",
        "parsing",
        "flat",
        "yaml",
        "subset",
        "offline",
        "build",
        "parses",
        "small",
        "splitter",
        "handling",
        "string",
        "number",
        "fields",
        "nested",
        "structures",
        "aren",
        "supported",
        "only",
        "affects",
        "file",
        "reading",
        "astro",
        "runtime",
        "index",
        "uses",
        "collection",
        "honors",
        "real",
        "schema",
        "getcollection",
        "full",
        "parser",
        "handles",
        "common",
        "docs",
        "time",
        "files",
        "disk"
      ]
    },
    {
      "id": "limits#recall-has-a-keyword-ceiling",
      "kind": "section",
      "title": "Limits",
      "heading": "Recall has a keyword ceiling",
      "group": "Overview",
      "url": "/docs/limits#recall-has-a-keyword-ceiling",
      "summary": "Retrieval is glossary-widened token overlap, not embeddings, and the loop can only ground in what retrieval finds. The glossary recovers most synonym cases, but a query sharing no tokens with the docs or glossary may never surface the right section. Embeddings are the known fix and deliberately unbuilt; a richer glossary is the cheaper lever until analytics show consistent misses.",
      "hash": "df75d2232fca5a321ba6501fe42757e069ef11d194231d4a0af212994581279a",
      "facts": [
        {
          "kind": "code",
          "literal": "k8s",
          "chunkId": "limits#recall-has-a-keyword-ceiling"
        },
        {
          "kind": "code",
          "literal": "kubernetes",
          "chunkId": "limits#recall-has-a-keyword-ceiling"
        }
      ],
      "sources": [
        {
          "chunkId": "limits#recall-has-a-keyword-ceiling",
          "url": "/docs/limits#recall-has-a-keyword-ceiling",
          "anchor": "recall-has-a-keyword-ceiling"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "recall",
        "keyword",
        "ceiling",
        "retrieval",
        "glossary",
        "widened",
        "token",
        "overlap",
        "embeddings",
        "loop",
        "only",
        "ground",
        "finds",
        "recovers",
        "most",
        "synonym",
        "cases",
        "query",
        "sharing",
        "tokens",
        "docs",
        "never",
        "surface",
        "right",
        "section",
        "known",
        "deliberately",
        "unbuilt",
        "richer",
        "cheaper",
        "lever",
        "until",
        "analytics",
        "show",
        "consistent",
        "misses",
        "kubernetes",
        "agentic",
        "grounds",
        "answer"
      ]
    },
    {
      "id": "limits#secrets-live-server-side",
      "kind": "section",
      "title": "Limits",
      "heading": "Secrets live server-side",
      "group": "Overview",
      "url": "/docs/limits#secrets-live-server-side",
      "summary": "The agentic path needs the configured provider's key in the server environment running the endpoint; it's never exposed to the browser, and without it the endpoint serves keyword results — search degrades, it doesn't break.",
      "hash": "2adf59c2589370b5a968f7e95da1bd1c86a15fdc4f3dce2c0f994addb33152bc",
      "facts": [
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "limits#secrets-live-server-side"
        },
        {
          "kind": "code",
          "literal": "OPENAI_API_KEY",
          "chunkId": "limits#secrets-live-server-side"
        },
        {
          "kind": "code",
          "literal": "OPENROUTER_API_KEY",
          "chunkId": "limits#secrets-live-server-side"
        },
        {
          "kind": "code",
          "literal": "provider",
          "chunkId": "limits#secrets-live-server-side"
        },
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "limits#secrets-live-server-side"
        }
      ],
      "sources": [
        {
          "chunkId": "limits#secrets-live-server-side",
          "url": "/docs/limits#secrets-live-server-side",
          "anchor": "secrets-live-server-side"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "secrets",
        "live",
        "server",
        "side",
        "agentic",
        "path",
        "needs",
        "configured",
        "provider",
        "environment",
        "running",
        "endpoint",
        "never",
        "exposed",
        "browser",
        "without",
        "serves",
        "keyword",
        "results",
        "search",
        "degrades",
        "doesn",
        "break",
        "anthropic",
        "openai",
        "openrouter",
        "anthropicapikey",
        "default",
        "openaiapikey",
        "openrouterapikey",
        "option",
        "runs",
        "present",
        "runtime"
      ]
    },
    {
      "id": "limits#the-agentic-path-needs-a-server-somewhere",
      "kind": "section",
      "title": "Limits",
      "heading": "The agentic path needs a server somewhere",
      "group": "Overview",
      "url": "/docs/limits#the-agentic-path-needs-a-server-somewhere",
      "summary": "Keyword search runs fully static in the browser on any host; only the agentic path needs a runtime — Astro's on-demand route with a server or hybrid adapter, or the standalone hostable endpoint elsewhere. A purely static site ships keyword search with nothing hosted but can't answer questions until an endpoint exists.",
      "hash": "f6ba9d8e2cd2303d69ee82861d85d062cfb484e3cb111cb2187049e8b7116231",
      "facts": [
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "limits#the-agentic-path-needs-a-server-somewhere"
        }
      ],
      "sources": [
        {
          "chunkId": "limits#the-agentic-path-needs-a-server-somewhere",
          "url": "/docs/limits#the-agentic-path-needs-a-server-somewhere",
          "anchor": "the-agentic-path-needs-a-server-somewhere"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "agentic",
        "path",
        "needs",
        "server",
        "somewhere",
        "keyword",
        "search",
        "runs",
        "fully",
        "static",
        "browser",
        "host",
        "only",
        "runtime",
        "astro",
        "demand",
        "route",
        "hybrid",
        "adapter",
        "standalone",
        "hostable",
        "endpoint",
        "elsewhere",
        "purely",
        "site",
        "ships",
        "nothing",
        "hosted",
        "answer",
        "questions",
        "until",
        "exists",
        "drop",
        "overlay",
        "reads",
        "committed",
        "digest",
        "required",
        "rendered",
        "need"
      ]
    },
    {
      "id": "limits#the-corpus-is-the-content-you-configure",
      "kind": "section",
      "title": "Limits",
      "heading": "The corpus is the content you configure",
      "group": "Overview",
      "url": "/docs/limits#the-corpus-is-the-content-you-configure",
      "summary": "Search covers exactly the markdown you point at — a content collection, a docs tree, or globs — with no crawler or sitemap ingestion and no way to index pages outside the configured corpus, such as hand-written framework pages or bare routes.",
      "hash": "f3508affa059adf48c4ae3f6ee96dccd8792a0ee66479077d9e8d9be1be41521",
      "facts": [
        {
          "kind": "code",
          "literal": "docs/",
          "chunkId": "limits#the-corpus-is-the-content-you-configure"
        },
        {
          "kind": "code",
          "literal": ".astro",
          "chunkId": "limits#the-corpus-is-the-content-you-configure"
        }
      ],
      "sources": [
        {
          "chunkId": "limits#the-corpus-is-the-content-you-configure",
          "url": "/docs/limits#the-corpus-is-the-content-you-configure",
          "anchor": "the-corpus-is-the-content-you-configure"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "corpus",
        "content",
        "configure",
        "search",
        "covers",
        "exactly",
        "markdown",
        "point",
        "collection",
        "docs",
        "tree",
        "globs",
        "crawler",
        "sitemap",
        "ingestion",
        "index",
        "pages",
        "outside",
        "configured",
        "such",
        "hand",
        "written",
        "framework",
        "bare",
        "routes",
        "astro",
        "searches",
        "docusaurus",
        "nothing",
        "else",
        "there",
        "external",
        "aren",
        "part",
        "page",
        "react",
        "route",
        "example",
        "appear",
        "want"
      ]
    },
    {
      "id": "limits#the-one-shot-digest-build-is-bounded-sharded-builds-are-not",
      "kind": "section",
      "title": "Limits",
      "heading": "The one-shot digest build is bounded; sharded builds are not",
      "group": "Overview",
      "url": "/docs/limits#the-one-shot-digest-build-is-bounded-sharded-builds-are-not",
      "summary": "The one-shot build sends the full cleaned corpus in one model call and fails loudly past 600KB of section text; beyond that, the sharded build splits the corpus into prefix-stable shards distilled in fresh contexts and merged deterministically, scaling to corpora of tens of thousands of sections. The remaining ceiling is the runtime prompt: the answer loop inlines summaries, so very large trees don't yet fit it, though an agent reading over MCP pages through files with no such limit.",
      "hash": "b92a502b0c0bf50078803a9d6b07d38be0501c79206b0246bd30626eb1f8f08f",
      "facts": [
        {
          "kind": "code",
          "literal": "ask digest build",
          "chunkId": "limits#the-one-shot-digest-build-is-bounded-sharded-builds-are-not"
        }
      ],
      "sources": [
        {
          "chunkId": "limits#the-one-shot-digest-build-is-bounded-sharded-builds-are-not",
          "url": "/docs/limits#the-one-shot-digest-build-is-bounded-sharded-builds-are-not",
          "anchor": "the-one-shot-digest-build-is-bounded-sharded-builds-are-not"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "shot",
        "digest",
        "build",
        "bounded",
        "sharded",
        "builds",
        "sends",
        "full",
        "cleaned",
        "corpus",
        "model",
        "call",
        "fails",
        "loudly",
        "past",
        "600kb",
        "section",
        "text",
        "beyond",
        "splits",
        "prefix",
        "stable",
        "shards",
        "distilled",
        "fresh",
        "contexts",
        "merged",
        "deterministically",
        "scaling",
        "corpora",
        "tens",
        "thousands",
        "sections",
        "remaining",
        "ceiling",
        "runtime",
        "prompt",
        "answer",
        "loop",
        "inlines"
      ]
    },
    {
      "id": "quickstart",
      "kind": "section",
      "title": "Quick start",
      "heading": null,
      "group": "Overview",
      "url": "/docs/quickstart",
      "summary": "Add search to an existing Astro 5 docs site with a content collection in about five minutes: keyword search first with no key and nothing to host, then a server-side key enables the agentic answer loop on Enter. Other frameworks drop in the same overlay as a script tag and point it at a hosted endpoint.",
      "hash": "54831061153def336afcc7a27a41a77ca77fa55d4ade8329bf0326e8fc6c19de",
      "facts": [
        {
          "kind": "code",
          "literal": "src/content/docs",
          "chunkId": "quickstart"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "quickstart"
        },
        {
          "kind": "code",
          "literal": "<script>",
          "chunkId": "quickstart"
        },
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "quickstart"
        },
        {
          "kind": "value",
          "literal": "CodeTabs.astro",
          "chunkId": "quickstart"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart",
          "url": "/docs/quickstart",
          "anchor": null
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "search",
        "existing",
        "astro",
        "docs",
        "site",
        "content",
        "collection",
        "about",
        "five",
        "minutes",
        "keyword",
        "first",
        "nothing",
        "host",
        "server",
        "side",
        "enables",
        "agentic",
        "answer",
        "loop",
        "enter",
        "other",
        "frameworks",
        "drop",
        "same",
        "overlay",
        "script",
        "point",
        "hosted",
        "endpoint",
        "anthropic",
        "callout",
        "codetabs",
        "install",
        "integration",
        "build",
        "digest",
        "enable",
        "whose",
        "lives"
      ]
    },
    {
      "id": "quickstart#1-install",
      "kind": "section",
      "title": "Quick start",
      "heading": "1. Install",
      "group": "Overview",
      "url": "/docs/quickstart#1-install",
      "summary": "Install the package from npm once published, or until then consume it straight from the package subdirectory on GitHub.",
      "hash": "b0e3103a35b35c38f295163b3d2055792feacebcaf6e70c6d224e89d3f8f23e1",
      "facts": [
        {
          "kind": "code",
          "literal": "pnpm add @hevmind/ask",
          "chunkId": "quickstart#1-install"
        },
        {
          "kind": "code",
          "literal": "pnpm add \"git+ssh://git@github.com/hev/ask.git#main&path:/packages/ui\"",
          "chunkId": "quickstart#1-install"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart#1-install",
          "url": "/docs/quickstart#1-install",
          "anchor": "1-install"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "install",
        "package",
        "once",
        "published",
        "until",
        "consume",
        "straight",
        "subdirectory",
        "github",
        "pnpm",
        "hevmind",
        "main",
        "path",
        "packages"
      ]
    },
    {
      "id": "quickstart#2-register-the-integration",
      "kind": "section",
      "title": "Quick start",
      "heading": "2. Register the integration",
      "group": "Overview",
      "url": "/docs/quickstart#2-register-the-integration",
      "summary": "Register the integration in the Astro config with the content collection name(s) and the slug-to-URL base path; collections is the only required option.",
      "hash": "02f816dd61687ca1704bca5caeb6868ea8d531804bd9dc7ca569c05522811b6d",
      "facts": [
        {
          "kind": "code",
          "literal": "// astro.config.mjs\nimport { defineConfig } from \"astro/config\";\nimport hevAsk from \"@hevmind/ask\";\n\nexport default defineConfig({\n  integrations: [\n    hevAsk({\n      collections: [\"docs\"],   // your content collection name(s)\n      basePath: \"/docs/\",      // slug → URL prefix: basePath + slug\n    }),\n  ],\n});",
          "chunkId": "quickstart#2-register-the-integration"
        },
        {
          "kind": "code",
          "literal": "collections",
          "chunkId": "quickstart#2-register-the-integration"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart#2-register-the-integration",
          "url": "/docs/quickstart#2-register-the-integration",
          "anchor": "2-register-the-integration"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "register",
        "integration",
        "astro",
        "config",
        "content",
        "collection",
        "name",
        "slug",
        "base",
        "path",
        "collections",
        "only",
        "required",
        "option",
        "import",
        "defineconfig",
        "hevask",
        "hevmind",
        "export",
        "default",
        "integrations",
        "docs",
        "basepath",
        "prefix",
        "must",
        "everything",
        "else",
        "configuration",
        "reference"
      ]
    },
    {
      "id": "quickstart#3-add-a-server-adapter",
      "kind": "section",
      "title": "Quick start",
      "heading": "3. Add a server adapter",
      "group": "Overview",
      "url": "/docs/quickstart#3-add-a-server-adapter",
      "summary": "The ask route renders on demand, so add whichever server adapter matches the host; existing pages stay prerendered and only the search route runs as a function. The docs site itself uses Cloudflare.",
      "hash": "795eff804c3ce56e4f62c96e59090a4c4845680aef5ab40735d8a57b33976dcf",
      "facts": [
        {
          "kind": "code",
          "literal": "// astro.config.mjs\nimport cloudflare from \"@astrojs/cloudflare\";\n\nexport default defineConfig({\n  adapter: cloudflare({ platformProxy: { enabled: true } }),\n  // ...integrations as above\n});",
          "chunkId": "quickstart#3-add-a-server-adapter"
        },
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "quickstart#3-add-a-server-adapter"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart#3-add-a-server-adapter",
          "url": "/docs/quickstart#3-add-a-server-adapter",
          "anchor": "3-add-a-server-adapter"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "server",
        "adapter",
        "route",
        "renders",
        "demand",
        "whichever",
        "matches",
        "host",
        "existing",
        "pages",
        "stay",
        "prerendered",
        "only",
        "search",
        "runs",
        "function",
        "docs",
        "site",
        "itself",
        "uses",
        "cloudflare",
        "astro",
        "config",
        "import",
        "astrojs",
        "export",
        "default",
        "defineconfig",
        "platformproxy",
        "enabled",
        "true",
        "integrations",
        "above"
      ]
    },
    {
      "id": "quickstart#4-render-the-overlay",
      "kind": "section",
      "title": "Quick start",
      "heading": "4. Render the overlay",
      "group": "Overview",
      "url": "/docs/quickstart#4-render-the-overlay",
      "summary": "Add the overlay component once in a global layout; any element with the opener data attribute opens the palette and the keyboard shortcut binds automatically. At this point keyword search works in dev.",
      "hash": "5c984aa14647046abf4d3804523a339a029e8187d8562f22a9b55f4a3b7e7b33",
      "facts": [
        {
          "kind": "code",
          "literal": "---\n// src/layouts/Base.astro\nimport SearchOverlay from \"@hevmind/ask/components/SearchOverlay.astro\";\n---\n<button type=\"button\" data-hev-ask-open>\n  Search <kbd>⌘K</kbd>\n</button>\n\n<slot />\n\n<SearchOverlay />",
          "chunkId": "quickstart#4-render-the-overlay"
        },
        {
          "kind": "code",
          "literal": "data-hev-ask-open",
          "chunkId": "quickstart#4-render-the-overlay"
        },
        {
          "kind": "code",
          "literal": "⌘K",
          "chunkId": "quickstart#4-render-the-overlay"
        },
        {
          "kind": "code",
          "literal": "astro dev",
          "chunkId": "quickstart#4-render-the-overlay"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart#4-render-the-overlay",
          "url": "/docs/quickstart#4-render-the-overlay",
          "anchor": "4-render-the-overlay"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "render",
        "overlay",
        "component",
        "once",
        "global",
        "layout",
        "element",
        "opener",
        "data",
        "attribute",
        "opens",
        "palette",
        "keyboard",
        "shortcut",
        "binds",
        "automatically",
        "point",
        "keyword",
        "search",
        "works",
        "layouts",
        "base",
        "astro",
        "import",
        "searchoverlay",
        "hevmind",
        "components",
        "button",
        "type",
        "open",
        "slot",
        "somewhere",
        "like",
        "bound",
        "press"
      ]
    },
    {
      "id": "quickstart#5-build-the-digest",
      "kind": "section",
      "title": "Quick start",
      "heading": "5. Build the digest",
      "group": "Overview",
      "url": "/docs/quickstart#5-build-the-digest",
      "summary": "Build the committed digest tree — it feeds the loop's domain context, ranks keyword results, supplies the glossary, and holds suggested questions. The recommended path is the bundled Claude Code skill (no API key, no token spend); the CLI build is the CI alternative with provider selection. Both are incremental and hash-gated; verify and commit afterward, and the integration rebuilds automatically during the site build when a key is present.",
      "hash": "c3e971ffc29cc5333a5448cb5e2846615f72af766d664a071dd8b904dd6b09d4",
      "facts": [
        {
          "kind": "code",
          "literal": "You: build the hev ask digest\n\nClaude runs:\n  ask digest corpus       # emits the sections to distil\n  …writes context/glossary/summaries/suggestions…\n  ask digest assemble     # writes the .hev-ask/ tree",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "code",
          "literal": "export ANTHROPIC_API_KEY=sk-ant-...\npnpm exec ask digest build      # writes the .hev-ask/ tree",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "code",
          "literal": "export OPENAI_API_KEY=sk-...\npnpm exec ask digest build --provider openai",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "code",
          "literal": "export OPENROUTER_API_KEY=sk-or-...\npnpm exec ask digest build --provider openrouter",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "code",
          "literal": "pnpm exec ask digest verify     # builds the site, checks every anchor resolves\ngit add .hev-ask",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "code",
          "literal": "k8s",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "code",
          "literal": "kubernetes",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "code",
          "literal": "--provider",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "code",
          "literal": "astro build",
          "chunkId": "quickstart#5-build-the-digest"
        },
        {
          "kind": "value",
          "literal": "claude.com",
          "chunkId": "quickstart#5-build-the-digest"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart#5-build-the-digest",
          "url": "/docs/quickstart#5-build-the-digest",
          "anchor": "5-build-the-digest"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "build",
        "digest",
        "committed",
        "tree",
        "feeds",
        "loop",
        "domain",
        "context",
        "ranks",
        "keyword",
        "results",
        "supplies",
        "glossary",
        "holds",
        "suggested",
        "questions",
        "recommended",
        "path",
        "bundled",
        "claude",
        "code",
        "skill",
        "token",
        "spend",
        "alternative",
        "provider",
        "selection",
        "both",
        "incremental",
        "hash",
        "gated",
        "verify",
        "commit",
        "afterward",
        "integration",
        "rebuilds",
        "automatically",
        "during",
        "site",
        "present"
      ]
    },
    {
      "id": "quickstart#enable-agentic-search",
      "kind": "section",
      "title": "Quick start",
      "heading": "Enable agentic search",
      "group": "Overview",
      "url": "/docs/quickstart#enable-agentic-search",
      "summary": "Set the provider's API key in the server environment where the search route runs; with a key, Enter runs the agentic loop with sub-queries, a grounded answer, and inline deep links. Non-default providers also need the provider option set in the integration; the Anthropic default needs only the key.",
      "hash": "ef1e17ef641cdc4792581c2c5f7d313aa573f6ccc6cb923f2288488784deac0e",
      "facts": [
        {
          "kind": "code",
          "literal": "# the default provider — nothing else to configure\nexport ANTHROPIC_API_KEY=sk-ant-...",
          "chunkId": "quickstart#enable-agentic-search"
        },
        {
          "kind": "code",
          "literal": "# with provider: \"openai\" in the hevAsk() options\nexport OPENAI_API_KEY=sk-...",
          "chunkId": "quickstart#enable-agentic-search"
        },
        {
          "kind": "code",
          "literal": "# with provider: \"openrouter\" in the hevAsk() options\nexport OPENROUTER_API_KEY=sk-or-...",
          "chunkId": "quickstart#enable-agentic-search"
        },
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "quickstart#enable-agentic-search"
        },
        {
          "kind": "code",
          "literal": ".env",
          "chunkId": "quickstart#enable-agentic-search"
        },
        {
          "kind": "code",
          "literal": "provider",
          "chunkId": "quickstart#enable-agentic-search"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart#enable-agentic-search",
          "url": "/docs/quickstart#enable-agentic-search",
          "anchor": "enable-agentic-search"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "enable",
        "agentic",
        "search",
        "provider",
        "server",
        "environment",
        "route",
        "runs",
        "enter",
        "loop",
        "queries",
        "grounded",
        "answer",
        "inline",
        "deep",
        "links",
        "default",
        "providers",
        "also",
        "need",
        "option",
        "integration",
        "anthropic",
        "needs",
        "only",
        "nothing",
        "else",
        "configure",
        "export",
        "openai",
        "hevask",
        "options",
        "openrouter",
        "host",
        "secrets",
        "local",
        "present",
        "pressing",
        "overlay",
        "self"
      ]
    },
    {
      "id": "quickstart#prerequisites",
      "kind": "section",
      "title": "Quick start",
      "heading": "Prerequisites",
      "group": "Overview",
      "url": "/docs/quickstart#prerequisites",
      "summary": "Requires Astro 5 with at least one content collection, a server or hybrid adapter because the search route renders on demand, and a provider API key only for agentic search — keyword search needs no key.",
      "hash": "5eef6bcbb64bfe13a8f2d64c6597ac69ef41ab1136dece4916e64326dd033c7d",
      "facts": [
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "quickstart#prerequisites"
        },
        {
          "kind": "code",
          "literal": "ANTHROPIC_API_KEY",
          "chunkId": "quickstart#prerequisites"
        },
        {
          "kind": "code",
          "literal": "provider",
          "chunkId": "quickstart#prerequisites"
        },
        {
          "kind": "value",
          "literal": "docs.astro.build",
          "chunkId": "quickstart#prerequisites"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart#prerequisites",
          "url": "/docs/quickstart#prerequisites",
          "anchor": "prerequisites"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "prerequisites",
        "requires",
        "astro",
        "least",
        "content",
        "collection",
        "server",
        "hybrid",
        "adapter",
        "because",
        "search",
        "route",
        "renders",
        "demand",
        "provider",
        "only",
        "agentic",
        "keyword",
        "needs",
        "anthropic",
        "docs",
        "build",
        "node",
        "cloudflare",
        "vercel",
        "fully",
        "static",
        "serve",
        "anthropicapikey",
        "enable",
        "openai",
        "openrouter",
        "work",
        "option",
        "guide",
        "uses",
        "default"
      ]
    },
    {
      "id": "quickstart#set-up-keyword-search",
      "kind": "section",
      "title": "Quick start",
      "heading": "Set up keyword search",
      "group": "Overview",
      "url": "/docs/quickstart#set-up-keyword-search",
      "summary": "Section header introducing the keyword-search setup steps: install, register the integration, add an adapter, and render the overlay.",
      "hash": "20c32e1a769e434abfef0906b5f05128b3bc42af63060ad5c866de714eea0d47",
      "facts": [],
      "sources": [
        {
          "chunkId": "quickstart#set-up-keyword-search",
          "url": "/docs/quickstart#set-up-keyword-search",
          "anchor": "set-up-keyword-search"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "keyword",
        "search",
        "section",
        "header",
        "introducing",
        "setup",
        "steps",
        "install",
        "register",
        "integration",
        "adapter",
        "render",
        "overlay"
      ]
    },
    {
      "id": "quickstart#verify-it-works",
      "kind": "section",
      "title": "Quick start",
      "heading": "Verify it works",
      "group": "Overview",
      "url": "/docs/quickstart#verify-it-works",
      "summary": "Three checks: a single heading word should deep-link to its section, a multi-word question should stream a grounded answer showing the model's sub-queries, and the verify command exits non-zero when any chunk anchor is missing from built HTML — wire it into CI.",
      "hash": "ef40c511b8d94f0d7c0c8e3fdf7db8156b68ace57ccc8d3f7559c9cad10897e6",
      "facts": [
        {
          "kind": "code",
          "literal": "/docs/page#heading",
          "chunkId": "quickstart#verify-it-works"
        },
        {
          "kind": "code",
          "literal": "ask digest verify",
          "chunkId": "quickstart#verify-it-works"
        }
      ],
      "sources": [
        {
          "chunkId": "quickstart#verify-it-works",
          "url": "/docs/quickstart#verify-it-works",
          "anchor": "verify-it-works"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "verify",
        "works",
        "three",
        "checks",
        "single",
        "heading",
        "word",
        "should",
        "deep",
        "link",
        "section",
        "multi",
        "question",
        "stream",
        "grounded",
        "answer",
        "showing",
        "model",
        "queries",
        "command",
        "exits",
        "zero",
        "chunk",
        "anchor",
        "missing",
        "built",
        "html",
        "wire",
        "docs",
        "page",
        "digest",
        "keyword",
        "type",
        "result",
        "agentic",
        "click",
        "suggested",
        "press",
        "enter",
        "footer"
      ]
    },
    {
      "id": "tradeoffs",
      "kind": "section",
      "title": "Tradeoffs",
      "heading": null,
      "group": "Overview",
      "url": "/docs/tradeoffs",
      "summary": "The honest accounting of what hev ask trades away — dependency posture, the committed digest, agentic cost and latency — and how it compares to Pagefind, Algolia, and Orama, so adopters can judge the fit.",
      "hash": "1b4bca991a9374eeb54f7ce6a92452afc7b47d4c36d02ef744c6036823919c78",
      "facts": [
        {
          "kind": "value",
          "literal": "Callout.astro",
          "chunkId": "tradeoffs"
        }
      ],
      "sources": [
        {
          "chunkId": "tradeoffs",
          "url": "/docs/tradeoffs",
          "anchor": null
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "honest",
        "accounting",
        "trades",
        "away",
        "dependency",
        "posture",
        "committed",
        "digest",
        "agentic",
        "cost",
        "latency",
        "compares",
        "pagefind",
        "algolia",
        "orama",
        "adopters",
        "judge",
        "callout",
        "astro",
        "choosing",
        "adopting",
        "search",
        "every",
        "tool",
        "makes",
        "choices",
        "page",
        "version",
        "gives",
        "decide",
        "whether",
        "trade",
        "fits",
        "docs"
      ]
    },
    {
      "id": "tradeoffs#a-committed-digest",
      "kind": "section",
      "title": "Tradeoffs",
      "heading": "A committed digest",
      "group": "Overview",
      "url": "/docs/tradeoffs#a-committed-digest",
      "summary": "Committing the digest to git buys per-section PR review, runtime determinism, free reads with no model call on the request path, edge bundling without filesystem access, and direct agent navigation. The cost is staleness: it only regenerates when content changes and a build runs, with a runtime warning as the cue — and the per-section hash gate makes rebuild-in-CI on every change the cheap, intended workflow.",
      "hash": "110adfc68831d0e1a9dcd3844ea876fb7fbd211e79537b3c2e854618aaecdc8d",
      "facts": [
        {
          "kind": "code",
          "literal": "tree",
          "chunkId": "tradeoffs#a-committed-digest"
        },
        {
          "kind": "code",
          "literal": "cat",
          "chunkId": "tradeoffs#a-committed-digest"
        },
        {
          "kind": "code",
          "literal": "grep",
          "chunkId": "tradeoffs#a-committed-digest"
        }
      ],
      "sources": [
        {
          "chunkId": "tradeoffs#a-committed-digest",
          "url": "/docs/tradeoffs#a-committed-digest",
          "anchor": "a-committed-digest"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "committed",
        "digest",
        "committing",
        "buys",
        "section",
        "review",
        "runtime",
        "determinism",
        "free",
        "reads",
        "model",
        "call",
        "request",
        "path",
        "edge",
        "bundling",
        "without",
        "filesystem",
        "access",
        "direct",
        "agent",
        "navigation",
        "cost",
        "staleness",
        "only",
        "regenerates",
        "content",
        "changes",
        "build",
        "runs",
        "warning",
        "hash",
        "gate",
        "makes",
        "rebuild",
        "every",
        "change",
        "cheap",
        "intended",
        "workflow"
      ]
    },
    {
      "id": "tradeoffs#a-flagship-adapter-primitives-for-the-rest",
      "kind": "section",
      "title": "Tradeoffs",
      "heading": "A flagship adapter, primitives for the rest",
      "group": "Overview",
      "url": "/docs/tradeoffs#a-flagship-adapter-primitives-for-the-rest",
      "summary": "Host-neutral at the core, opinionated about Astro: the Astro integration is batteries-included, while other frameworks wire two primitives themselves — the static overlay plus, for agentic answers, the standalone endpoint. The digest, overlay, CLI, and MCP are identical everywhere, but off Astro you do the wiring the integration would have done; per-framework turnkey plugins are a goal, not a guarantee.",
      "hash": "ace3b69886bb992230df003c64bc5e89ff7954e8f07de9202a71d5d00d362d40",
      "facts": [
        {
          "kind": "code",
          "literal": "<script>",
          "chunkId": "tradeoffs#a-flagship-adapter-primitives-for-the-rest"
        },
        {
          "kind": "code",
          "literal": "/api/ask",
          "chunkId": "tradeoffs#a-flagship-adapter-primitives-for-the-rest"
        }
      ],
      "sources": [
        {
          "chunkId": "tradeoffs#a-flagship-adapter-primitives-for-the-rest",
          "url": "/docs/tradeoffs#a-flagship-adapter-primitives-for-the-rest",
          "anchor": "a-flagship-adapter-primitives-for-the-rest"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "flagship",
        "adapter",
        "primitives",
        "rest",
        "host",
        "neutral",
        "core",
        "opinionated",
        "about",
        "astro",
        "integration",
        "batteries",
        "included",
        "while",
        "other",
        "frameworks",
        "wire",
        "themselves",
        "static",
        "overlay",
        "plus",
        "agentic",
        "answers",
        "standalone",
        "endpoint",
        "digest",
        "identical",
        "everywhere",
        "wiring",
        "would",
        "done",
        "framework",
        "turnkey",
        "plugins",
        "goal",
        "guarantee",
        "script",
        "build",
        "config",
        "block"
      ]
    },
    {
      "id": "tradeoffs#cost-and-latency-of-agentic-search",
      "kind": "section",
      "title": "Tradeoffs",
      "heading": "Cost and latency of agentic search",
      "group": "Overview",
      "url": "/docs/tradeoffs#cost-and-latency-of-agentic-search",
      "summary": "The agentic path costs real if small money and latency: worst case a few seconds of bounded Haiku round-trips per submitted query, with domain context prompt-cached across rounds; the offline build uses Opus but the hash gate means paying only when content changes. Keyword-only is a first-class mode for anyone who doesn't want a key in the loop.",
      "hash": "64c96faf9220cd1746ff5fe83b61b585b03f23674074ae444bfec6a16b4411de",
      "facts": [
        {
          "kind": "code",
          "literal": "maxIterations",
          "chunkId": "tradeoffs#cost-and-latency-of-agentic-search"
        }
      ],
      "sources": [
        {
          "chunkId": "tradeoffs#cost-and-latency-of-agentic-search",
          "url": "/docs/tradeoffs#cost-and-latency-of-agentic-search",
          "anchor": "cost-and-latency-of-agentic-search"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "cost",
        "latency",
        "agentic",
        "search",
        "path",
        "costs",
        "real",
        "small",
        "money",
        "worst",
        "case",
        "seconds",
        "bounded",
        "haiku",
        "round",
        "trips",
        "submitted",
        "query",
        "domain",
        "context",
        "prompt",
        "cached",
        "across",
        "rounds",
        "offline",
        "build",
        "uses",
        "opus",
        "hash",
        "gate",
        "means",
        "paying",
        "only",
        "content",
        "changes",
        "keyword",
        "first",
        "class",
        "mode",
        "anyone"
      ]
    },
    {
      "id": "tradeoffs#how-it-compares",
      "kind": "section",
      "title": "Tradeoffs",
      "heading": "How it compares",
      "group": "Overview",
      "url": "/docs/tradeoffs#how-it-compares",
      "summary": "Comparison table and guidance: Pagefind for excellent keyless static keyword search, Algolia for a managed crawler-backed service, Orama for client-side vector search with self-managed embeddings, and hev ask when docs are a folder of markdown on any framework and you want heading-level deep links plus answers to questions phrased in the reader's words.",
      "hash": "f7153362862908034c56b96908a7bca0f733e311dfba14d3d4681b1c72e1fe12",
      "facts": [],
      "sources": [
        {
          "chunkId": "tradeoffs#how-it-compares",
          "url": "/docs/tradeoffs#how-it-compares",
          "anchor": "how-it-compares"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "compares",
        "comparison",
        "table",
        "guidance",
        "pagefind",
        "excellent",
        "keyless",
        "static",
        "keyword",
        "search",
        "algolia",
        "managed",
        "crawler",
        "backed",
        "service",
        "orama",
        "client",
        "side",
        "vector",
        "self",
        "embeddings",
        "docs",
        "folder",
        "markdown",
        "framework",
        "want",
        "heading",
        "level",
        "deep",
        "links",
        "plus",
        "answers",
        "questions",
        "phrased",
        "reader",
        "words",
        "tool",
        "retrieval",
        "ranking",
        "hosting"
      ]
    },
    {
      "id": "tradeoffs#keyword-retrieval-not-embeddings",
      "kind": "section",
      "title": "Tradeoffs",
      "heading": "Keyword retrieval, not embeddings",
      "group": "Overview",
      "url": "/docs/tradeoffs#keyword-retrieval-not-embeddings",
      "summary": "Retrieval is dependency-free token overlap widened by the glossary — nothing to host, edge-safe, instant — but paraphrase recall has a ceiling: the agent can only ground in what keyword retrieval found. The glossary recovers much of the synonym recall embeddings would give; the embeddings upgrade is deferred, not designed out.",
      "hash": "816629bc3f9d42150a53cdbf54324d130714f295a4f5db66f417ac4b8965fa94",
      "facts": [],
      "sources": [
        {
          "chunkId": "tradeoffs#keyword-retrieval-not-embeddings",
          "url": "/docs/tradeoffs#keyword-retrieval-not-embeddings",
          "anchor": "keyword-retrieval-not-embeddings"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "keyword",
        "retrieval",
        "embeddings",
        "dependency",
        "free",
        "token",
        "overlap",
        "widened",
        "glossary",
        "nothing",
        "host",
        "edge",
        "safe",
        "instant",
        "paraphrase",
        "recall",
        "ceiling",
        "agent",
        "only",
        "ground",
        "found",
        "recovers",
        "much",
        "synonym",
        "would",
        "give",
        "upgrade",
        "deferred",
        "designed",
        "vector",
        "store",
        "upside",
        "keep",
        "sync",
        "cost",
        "answers",
        "well",
        "readers",
        "routinely",
        "search"
      ]
    },
    {
      "id": "tradeoffs#one-dependency-deliberately",
      "kind": "section",
      "title": "Tradeoffs",
      "heading": "One dependency, deliberately",
      "group": "Overview",
      "url": "/docs/tradeoffs#one-dependency-deliberately",
      "summary": "The package is near zero-dependency with one deliberate exception: github-slugger, a small pure-JS, edge-safe library that guarantees byte-identical heading anchors with Astro and GitHub rather than risking hand-rolled slugs that 404 to the top of the page; adapters extend the guarantee to their own slug rules.",
      "hash": "ab20e6d42c28963543737ab48f6363737ae3acca033cbf40114668f79b31f2c6",
      "facts": [
        {
          "kind": "code",
          "literal": "github-slugger",
          "chunkId": "tradeoffs#one-dependency-deliberately"
        },
        {
          "kind": "value",
          "literal": "github.com",
          "chunkId": "tradeoffs#one-dependency-deliberately"
        }
      ],
      "sources": [
        {
          "chunkId": "tradeoffs#one-dependency-deliberately",
          "url": "/docs/tradeoffs#one-dependency-deliberately",
          "anchor": "one-dependency-deliberately"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "dependency",
        "deliberately",
        "package",
        "near",
        "zero",
        "deliberate",
        "exception",
        "github",
        "slugger",
        "small",
        "pure",
        "edge",
        "safe",
        "library",
        "guarantees",
        "byte",
        "identical",
        "heading",
        "anchors",
        "astro",
        "rather",
        "risking",
        "hand",
        "rolled",
        "slugs",
        "page",
        "adapters",
        "extend",
        "guarantee",
        "their",
        "slug",
        "rules",
        "aims",
        "close",
        "generating",
        "risks",
        "drifting",
        "renderer",
        "shipping",
        "link"
      ]
    },
    {
      "id": "tradeoffs#two-paths-instead-of-one",
      "kind": "section",
      "title": "Tradeoffs",
      "heading": "Two paths instead of one",
      "group": "Overview",
      "url": "/docs/tradeoffs#two-paths-instead-of-one",
      "summary": "Running an instant keyword path and an agentic path keeps the common one-or-two-word case instant and keyless while hard questions get a smarter ranker, at the cost of a slightly more complex interaction model — readers learn that Enter means ask AI. The trade fits docs, where queries split into jumping to a known thing and finding a thing you can't name.",
      "hash": "e48be674eb6b12550ce9b63172698290c2dfd2eff74eec7bf157321de76f4d67",
      "facts": [],
      "sources": [
        {
          "chunkId": "tradeoffs#two-paths-instead-of-one",
          "url": "/docs/tradeoffs#two-paths-instead-of-one",
          "anchor": "two-paths-instead-of-one"
        }
      ],
      "mode": "agent-primary",
      "terms": [
        "paths",
        "instead",
        "running",
        "instant",
        "keyword",
        "path",
        "agentic",
        "keeps",
        "common",
        "word",
        "case",
        "keyless",
        "while",
        "hard",
        "questions",
        "smarter",
        "ranker",
        "cost",
        "slightly",
        "more",
        "complex",
        "interaction",
        "model",
        "readers",
        "learn",
        "enter",
        "means",
        "trade",
        "fits",
        "docs",
        "queries",
        "split",
        "jumping",
        "known",
        "thing",
        "finding",
        "name",
        "runs",
        "asks",
        "reader"
      ]
    }
  ],
  "edges": []
}