config.example.toml

Rama main · réplica de lectura del repositorio original.

# Axon configuration — tuning knobs only.
# Copy to ~/.axon/config.toml or point AXON_CONFIG_PATH at a custom location.
#
# ┌─ SINGLE SOURCE OF TRUTH ───────────────────────────────────────────────────┐
# │ This file is the authoritative reference for every TOML config key.        │
# │ The docs tables in CLAUDE.md and docs/guides/configuration.md are           │
# │ summaries — if they disagree with this file, this file wins.               │
# └────────────────────────────────────────────────────────────────────────────┘
#
# Usage:
#   mkdir -m 700 ~/.axon
#   cp config.example.toml ~/.axon/config.toml
#   chmod 600 ~/.axon/config.toml
#
# All values shown are defaults. Uncomment only what you need to change.
#
# Secrets, endpoint URLs, auth/runtime bootstrap, and Docker Compose
# interpolation belong in ~/.axon/.env — not here.
# This file is safe to commit to source control.
#
# Override path: AXON_CONFIG_PATH=/path/to/config.toml
#
# Priority (highest to lowest):
#   CLI flags for command inputs > environment variables > this file > built-in defaults
#
# Shape: this file follows the 20-section config contract
# (docs/pipeline-unification/configuration/config-contract.md). Unknown keys
# and stale pre-contract section names (e.g. old top-level [llm]/[tei]/
# [scrape]/[workers]) fail with a clear deprecation error naming the new
# section instead of being silently ignored.

[server]
# Default vector collection. Env: AXON_COLLECTION (or --collection flag).
# default-collection = "axon"

# Development-only compile-time escape hatch: allow `cargo build`/`cargo test`
# to embed the fallback web panel when apps/web/out is absent or contains only
# fallback marker assets. Release builds should keep this false.
# Env override: AXON_ALLOW_FALLBACK_WEB_ASSETS
# allow-fallback-web-assets = false

[server.projection-batch]
# Shared CLI/MCP/REST ceilings. Preflight owns request/input/query bounds;
# source plans persist the page/item/byte/document/chunk/vector/time clamps;
# execution owns serialized response size and global/per-principal admission
# and start-rate limits. Provider redirect safety remains provider-owned rather
# than exposing a projection knob that an adapter might ignore. Environment
# variables use AXON_PROJECTION_BATCH_<UPPER_SNAKE_KEY>; callers only clamp lower.
# max-inputs = 32
# max-request-bytes = 1048576
# max-input-bytes = 16384
# max-query-bytes = 16384
# max-idempotency-key-bytes = 256
# max-aggregate-input-bytes = 262144
# max-response-bytes = 8388608
# max-pages = 1000
# max-manifest-items = 10000
# max-fetched-bytes-per-item = 16777216
# max-decompressed-bytes-per-item = 33554432
# max-prepared-bytes = 67108864
# max-documents = 10000
# max-chunks = 100000
# max-vector-points = 100000
# max-elapsed-secs = 900
# max-query-window = 1000
# global-max-in-flight-requests = 64
# caller-max-in-flight-requests = 8
# caller-rate-limit-per-minute = 120

[server.mcp]
# Timeout for MCP task-result waits.
# Env: AXON_TASK_RESULT_WAIT_TIMEOUT_SECS
# task-result-wait-timeout-secs = 300

[server.mcp.embed]
# Local filesystem embed guards for MCP-triggered embed actions.
# Env: AXON_MCP_EMBED_MAX_LOCAL_BYTES
# max-local-bytes = 10485760
# Env: AXON_MCP_EMBED_MAX_LOCAL_DEPTH
# max-local-depth = 16
# Env: AXON_MCP_EMBED_MAX_LOCAL_ENTRIES
# max-local-entries = 10000

# Service endpoint URLs are intentionally not configured here.
# Put QDRANT_URL, TEI_URL, and AXON_CHROME_REMOTE_URL in ~/.axon/.env.
# Local source requests from server transports are fail-closed unless their
# resolved path is under AXON_SOURCE_LOCAL_ALLOWED_ROOTS (comma-separated).
# Use a dedicated absolute read-only mount. Symlinked roots, nested mounts,
# relative paths, and empty authenticated-server allowlists are rejected.

[sources.code-search]
# Foreground freshness TTL before checking whether a Git checkout changed.
# Env: AXON_CODE_SEARCH_FRESHNESS_TTL_SECS
# freshness-ttl-secs = 30
# Timeout for a foreground code-search reindex.
# Env: AXON_CODE_SEARCH_REINDEX_TIMEOUT_SECS
# reindex-timeout-secs = 300
# Skip files larger than this many bytes during local code indexing.
# Env: AXON_CODE_SEARCH_MAX_FILE_BYTES
# max-file-bytes = 10485760
# Number of changed files processed per foreground refresh batch.
# Env: AXON_CODE_SEARCH_CHANGED_FILE_BATCH_SIZE
# changed-file-batch-size = 64

[pipeline]
# Maximum concurrent jobs the unified job-store worker runs at once (clamped 1-64).
# Env: AXON_UNIFIED_WORKER_CONCURRENCY
# unified-worker-concurrency = 8
# Maximum concurrent `Source` jobs (every source job kind — web, git, feeds,
# registries, Reddit, YouTube, CLI/MCP tools, local paths — plus `map`), gated
# independently of unified-worker-concurrency above (clamped 1-64). Several
# source kinds share constrained external resources (a single Chrome instance
# for web/render-backed acquisition, upstream API rate limits for other
# adapters), so this keeps one noisy source kind from starving the rest of
# the general worker pool. Raising it increases source-acquisition
# throughput at the cost of more concurrent Chrome sessions / adapter API
# load; lowering it protects those shared resources at the cost of slower
# source ingestion.
# Env: AXON_SOURCE_JOB_CONCURRENCY_LIMIT
# max-active-source-jobs = 4
# Per-document embed timeout in seconds.
# Env: AXON_EMBED_DOC_TIMEOUT_SECS
# embed-doc-timeout-secs = 300
# Queue summary interval in seconds (0 = disabled, clamped 0-3600).
# Env: AXON_QUEUE_SUMMARY_SECS
# queue-summary-secs = 30
# Timeout in seconds for --wait true job polling (clamped 30-3600).
# Env: AXON_JOB_WAIT_TIMEOUT_SECS
# job-wait-timeout-secs = 300

[pipeline.chunking]
# Shared quality cutoff: trimmed characters after bounded source-context packing.
# Applies across profiles. Below-minimum leftovers are omitted; punctuation-only
# and structurally empty chunks are omitted regardless of this setting.
# Env: AXON_CHUNK_MIN_CHARS
# minimum-chars = 200
# Markdown chunk target maximum. Env still wins for ad hoc overrides.
# Env: AXON_MARKDOWN_CHUNK_MAX_CHARS
# markdown-max-chars = 2000
# Markdown chunk minimum before tiny chunk merge/padding behavior.
# Env: AXON_MARKDOWN_CHUNK_MIN_CHARS
# markdown-min-chars = 500
# Character overlap between neighboring markdown chunks.
# Env: AXON_CHUNK_OVERLAP_CHARS
# overlap-chars = 200

[pipeline.endpoints]
# Concurrency limits for endpoint map/verification helpers.
# Env: AXON_ENDPOINT_BUNDLE_CONCURRENCY
# bundle-concurrency = 8
# Env: AXON_ENDPOINT_CHROME_CONCURRENCY
# chrome-concurrency = 1
# Env: AXON_ENDPOINT_VERIFY_CONCURRENCY
# verify-concurrency = 16
# Env: AXON_ENDPOINT_PROBE_CONCURRENCY
# probe-concurrency = 4

[jobs]
# Seconds before a running job is considered stale. Env still overrides TOML.
# Env: AXON_JOB_STALE_TIMEOUT_SECS
# stale-after-secs = 300
# Additional grace period before stale reclaim. Env still overrides TOML.
# Env: AXON_JOB_STALE_CONFIRM_SECS
# stale-grace-secs = 60
# Seconds between watchdog sweeps. Env still overrides TOML.
# Env: AXON_WATCHDOG_SWEEP_SECS
# watchdog-sweep-secs = 15
# Seconds a kind's queue may hold pending jobs with zero running workers
# before the liveness watchdog kicks the lane. 0 disables.
# Env: AXON_WORKER_STARVATION_SECS
# worker-starvation-secs = 120
# Maximum reclaim attempts before a stale job is dead-lettered. 0 = unlimited.
# Env: AXON_MAX_JOB_ATTEMPTS
# max-job-attempts = 5
# Auto-start a background `axon jobs worker` after a detached CLI enqueue
# (`axon <source>` without --wait) when no worker process is already running.
# Env: AXON_JOBS_AUTO_WORKER
# auto-worker = true
# Idle seconds before an auto-started worker exits. 0 = run until stopped.
# Env: AXON_JOBS_WORKER_IDLE_EXIT_SECS
# worker-idle-exit-secs = 300
#
# ── Retention sweep (DELETES OPERATOR DATA on a schedule) ──────────────────
# The background retention sweep in `SqliteUnifiedJobStore::run_retention_sweep`
# permanently DELETES rows older than these windows: job/event/artifact
# history is not recoverable once swept. Widen a window before you need the
# history, not after.
# Seconds between periodic retention sweeps.
# Env: AXON_JOBS_RETENTION_SWEEP_SECS
# retention-sweep-secs = 3600
# Days a terminal (completed/failed/canceled) job row — and its cascaded
# children — survives before the sweep DELETES it.
# Env: AXON_JOBS_RETENTION_TERMINAL_DAYS
# terminal-retention-days = 30
# Days a `job_events` row for a non-failed job survives before the sweep
# DELETES it.
# Env: AXON_JOBS_RETENTION_EVENT_DAYS
# event-retention-days = 14
# Days a `job_events` row for a failed job survives before the sweep DELETES
# it (kept longer than ordinary events for postmortem evidence).
# Env: AXON_JOBS_RETENTION_FAILED_EVENT_DAYS
# failed-event-retention-days = 60
# Days a `provider_reservations` row (provider capacity/health history)
# survives before the sweep DELETES it.
# Env: AXON_JOBS_RETENTION_PROVIDER_HEALTH_DAYS
# provider-health-retention-days = 7
# Days a `job_artifacts` row survives before the sweep DELETES it.
# Env: AXON_JOBS_RETENTION_ARTIFACT_DAYS
# artifact-retention-days = 30
# Seconds an `interactive`-priority job may sit queued with no
# `interactive`-priority job running before the starvation watchdog emits a
# warning event. Does not delete anything; grouped here because it shares
# the `[jobs]` section. 0 disables the check.
# Env: AXON_JOBS_INTERACTIVE_STARVATION_SLO_SECS
# interactive-starvation-slo-secs = 30

[providers.embedding]
# This section is critical for avoiding embedding-pipeline bottlenecks.
# Env: TEI_MAX_CLIENT_BATCH_SIZE
# batch-size = 96
# Process-wide max concurrent Axon client requests to native TEI `/embed`.
# Env: AXON_TEI_MAX_CONCURRENT
# max-concurrent-requests = 8
# Weighted cap on total input chunks concurrently submitted to native TEI.
# Env: AXON_TEI_MAX_IN_FLIGHT_INPUTS
# max-in-flight-inputs = 320
# Per-attempt timeout in milliseconds. Env: TEI_REQUEST_TIMEOUT_MS
# request-timeout-ms = 30000
# Max retry attempts after the initial TEI request. Env: TEI_MAX_RETRIES
# max-retries = 5
# Base backoff (ms) before exponential growth + jitter between retried
# `/embed` requests on 429/5xx. Env: AXON_TEI_RETRY_BACKOFF_MS
# retry-backoff-ms = 500
# Consecutive failures before the TEI provider self-reports a cooldown.
# Env: AXON_TEI_COOLDOWN_AFTER_FAILURES
# cooldown-after-failures = 3
# Cooldown window length (seconds) once tripped. Env: AXON_TEI_COOLDOWN_SECS
# cooldown-secs = 30
# Embedding reservation slots reserved for interactive (ask/query) embeddings;
# background/maintenance embed jobs cannot consume this headroom out of
# max-concurrent-requests. Env: AXON_TEI_INTERACTIVE_RESERVED_REQUESTS
# interactive-reserved-requests = 1
# Soft per-tier concurrency ceilings for background/maintenance-priority embed
# requests. Not yet independently enforced (both currently share one combined
# non-interactive ceiling — see docs/pipeline-unification/configuration/config-contract.md).
# Env: AXON_TEI_BACKGROUND_MAX_CONCURRENT_REQUESTS, AXON_TEI_MAINTENANCE_MAX_CONCURRENT_REQUESTS
# background-max-concurrent-requests = 3
# maintenance-max-concurrent-requests = 1
# Apply the query/document instruction prefix when the provider capability
# supports it. Env: AXON_TEI_QUERY_INSTRUCTION_ENABLED
# query-instruction-enabled = true
# Persist dense embedding vectors for warm/repeated ingestion. Disabled by
# default. Entries become logically unusable seven days after creation. Source
# deletion cannot immediately purge a shared content-addressed row; a periodic,
# fixed-budget sweep reclaims expired rows physically and may require multiple
# passes after a large backlog.
# Env: AXON_EMBED_CACHE_ENABLED
# cache-enabled = false
# Target maximum cached vectors retained with amortized LRU pruning. The cache
# may temporarily exceed this target between maintenance sweeps.
# Env: AXON_EMBED_CACHE_MAX_ENTRIES
# cache-max-entries = 100000
# Max chunk inputs pooled into one native TEI embedding wave.
# Env: AXON_EMBED_POOL_MAX_INPUTS
# pool-max-inputs = 512
# Env: AXON_TEI_CLIENT_MAX_BATCH_TOKENS
# max-batch-tokens = 65536
# Env: AXON_EMBED_SCHEDULER_ENABLED
# scheduler-enabled = true
# Env: AXON_VECTOR_UPSERT_EMBED_OVERLAP
# vector-upsert-overlap-enabled = true
# Maximum retained bytes admitted to the prepared-generation channel. Defaults
# to 128 MiB and is clamped from 1 MiB through 4 GiB.
# Env: AXON_EMBED_PREPARED_BYTE_BUDGET
# prepared-byte-budget = 134217728
# Concurrent source-document preparation tasks before embedding.
# Env: AXON_EMBED_PREP_CONCURRENCY
# prep-concurrency = 8
# Maximum aggregate source-document bytes admitted to concurrent preparation.
# Env: AXON_PREP_MAX_IN_FLIGHT_BYTES
# prep-max-in-flight-bytes = 67108864
# Maximum delay used to pool prepared chunks before an embedding request.
# Set to 0 to flush each acquired wave immediately.
# Env: AXON_EMBED_SCHEDULER_FLUSH_MS
# scheduler-flush-ms = 1500
# Optional circuit breakers after exact dedupe. `0` / unset disables the cap.
# Env: AXON_EMBED_MAX_CHUNKS_PER_DOC, AXON_EMBED_MAX_SOURCE_CHUNKS_PER_DOC
# max-chunks-per-doc = 0
# max-source-chunks-per-doc = 0
# Drop exact duplicate chunks within one logical document before embedding.
# Env: AXON_EMBED_DEDUPE_EXACT_CHUNKS
# dedupe-exact-chunks = true
# OpenAI-compatible embedding endpoints (e.g. vLLM at a `/v1` TEI_URL) use
# separate client-side defaults so native TEI tuning isn't overloaded.
# Env: AXON_OPENAI_EMBEDDING_MODEL, fallback VLLM_SERVED_MODEL_NAME
# openai-model = "axon-qwen3-embedding"
# Env: AXON_OPENAI_EMBED_MAX_CLIENT_BATCH_SIZE
# openai-max-client-batch-size = 32
# Env: AXON_OPENAI_EMBED_MAX_CONCURRENT
# openai-max-concurrent = 32
# Env: AXON_OPENAI_EMBED_MAX_IN_FLIGHT_INPUTS
# openai-max-in-flight-inputs = 512
# Env: AXON_OPENAI_EMBED_POOL_MAX_INPUTS
# openai-pool-max-inputs = 1024

[providers.vector]
# Upsert request batch size and request parallelism. This is the canonical
# replacement for legacy pipeline.qdrant-point-buffer / AXON_QDRANT_POINT_BUFFER.
# Env: AXON_QDRANT_UPSERT_BATCH_SIZE
# upsert-batch-points = 1024
# Env: AXON_QDRANT_UPSERT_PARALLELISM
# write-concurrency = 2
# Enable RRF hybrid search (requires a named-mode Qdrant collection).
# Env: AXON_HYBRID_SEARCH
# hybrid-enabled = true
# HNSW ef for named-mode (dense+sparse) collections (clamped 32–512).
# Env: AXON_HNSW_EF_SEARCH
# hnsw-ef = 128
# Maximum bytes stored in Qdrant `structured_blob` payload per chunk.
# Env: AXON_STRUCTURED_DATA_MAX_BYTES. Default: 65536. Clamped 1024–16777216.
# structured-data-max-bytes = 65536
# Bulk-load mode and collection indexing thresholds for newly created collections.
# Env: AXON_QDRANT_BULK_LOAD
# bulk-load = false
# Env: AXON_QDRANT_BULK_INDEXING_THRESHOLD_KB
# bulk-indexing-threshold-kb = 10485760
# Env: AXON_QDRANT_INDEXING_THRESHOLD_KB
# indexing-threshold-kb = 20000
# HNSW construction params for newly created collections.
# Env: AXON_QDRANT_HNSW_M
# hnsw-m = 32
# Env: AXON_QDRANT_HNSW_EF_CONSTRUCT
# hnsw-ef-construct = 256
# Payload index creation profile and fanout.
# Env: AXON_QDRANT_PAYLOAD_INDEX_PROFILE
# payload-index-profile = "full"
# Env: AXON_QDRANT_PAYLOAD_INDEX_PARALLELISM
# payload-index-parallelism = 16
# Collection memory/latency tradeoffs for newly created collections.
# Env: AXON_QDRANT_HNSW_ON_DISK
# hnsw-on-disk = false
# Enable scalar INT8 quantization for newly created collections.
# Env: AXON_QDRANT_QUANTIZATION_ENABLED
# quantization-enabled = false
# Env: AXON_QDRANT_QUANTIZATION_ALWAYS_RAM
# quantization-always-ram = true
# Pipeline point batches with wait=false, then use an ordered wait=true write barrier.
# Env: AXON_QDRANT_ASYNC_WRITES
# async-writes = false
# Point publication transport: "rest" or "grpc".
# Env: AXON_QDRANT_TRANSPORT
# transport = "rest"
# Required when transport = "grpc": QDRANT_GRPC_URL (kept in ~/.axon/.env).

[providers.llm]
# Completion backend. AXON_LLM_BACKEND overrides this value.
# backend = "gemini-headless"
# Non-secret model names. Env vars still win.
# Env: AXON_SYNTHESIS_OPENAI_MODEL
# synthesis-openai-model = ""
# Optional runtime-only OpenAI-compatible sampling override: AXON_OPENAI_TEMPERATURE=0.2
# Finite range 0..=2. Unset omits the field and preserves provider defaults.
# Env: AXON_CHAT_OPENAI_MODEL
# chat-openai-model = ""
# Env: AXON_SYNTHESIS_HEADLESS_GEMINI_MODEL or AXON_HEADLESS_GEMINI_MODEL
# synthesis-gemini-model = ""
# Env: AXON_CHAT_HEADLESS_GEMINI_MODEL
# chat-gemini-model = ""
# Optional override for whether the synthesis model should be treated as
# high-context by the adaptive ask context builder. Env: AXON_SYNTHESIS_HIGH_CONTEXT
# high-context = true
# Max concurrent LLM completion requests across the selected backend (clamped 1-64).
# Unset: Gemini 4, OpenAI-compatible 16. Explicit values (including 4) are honored.
# Env: AXON_LLM_COMPLETION_CONCURRENCY
# completion-concurrency = 4
# Timeout in seconds for each LLM completion request (clamped 10-1800).
# Env: AXON_LLM_COMPLETION_TIMEOUT_SECS
# completion-timeout-secs = 300
# Idle pooled `codex app-server` child TTL (clamped 0-3600; 0 disables).
# Env: AXON_CODEX_POOL_IDLE_TTL_SECS
# codex-pool-idle-ttl-secs = 300
#
# Codex app-server command/home stay runtime/bootstrap env-only. AXON_CODEX_CMD
# is shared by synthesis and Palette control; when Palette control is enabled it
# must be an absolute executable path. The runtimes do not select independent binaries.
# AXON_CODEX_CMD=/absolute/path/to/codex
# AXON_CODEX_HOME, AXON_SYNTHESIS_CODEX_MODEL,
# AXON_CODEX_COMPLETION_CONCURRENCY.

# Codex Palette management is a distinct, default-off runtime. It never uses
# the synthesis pool or its isolated homes. AXON_CODEX_CONTROL_HOME must be an
# existing absolute, non-symlink directory managed by the server host. The
# binary and control home must be owned by the effective Axon server user (root
# only when Axon runs as root). Ancestors need not share that owner, but they
# must not be group/world writable, and no checked path may traverse symlinks.
# AXON_CODEX_CONTROL_ENABLED=false
# AXON_CODEX_CONTROL_HOME=/absolute/path/to/stable/codex-control-home
# AXON_CODEX_CONTROL_REQUEST_TIMEOUT_SECS=30
# AXON_CODEX_CONTROL_READ_CONCURRENCY=4
# AXON_CODEX_CONTROL_ACCOUNT_WRITES=false
# AXON_CODEX_CONTROL_CONFIG_WRITES=false
# AXON_CODEX_CONTROL_MCP_WRITES=false
# AXON_CODEX_CONTROL_PLUGIN_WRITES=false
# AXON_CODEX_CONTROL_SKILL_WRITES=false

[providers.search]
# `research` fetches each top source's full page and synthesizes over it by
# default; set false for snippet-only/fast synthesis.
# Env: AXON_RESEARCH_FULL_CONTENT
# research-full-content = true

[providers.fetch]
# Delay between requests in milliseconds.
# delay-ms = 0
# Per-request HTTP timeout. Unset to use performance-profile default.
# request-timeout-ms = 20000
# End-to-end timeout for one service-level scrape batch.
# Env: AXON_SCRAPE_BATCH_TIMEOUT_SECS
# batch-timeout-secs = 120
# Fetch retry count. Unset to use performance-profile default.
# retries = 2
# Retry backoff in milliseconds. Unset to use performance-profile default.
# retry-backoff-ms = 250

[providers.render]
# Custom User-Agent header sent by Chrome. Env: AXON_CHROME_USER_AGENT
# user-agent = "Mozilla/5.0 (compatible; Axon/1.0)"
# bypass-csp = false
# accept-invalid-certs = false
# Seconds to wait for Chrome network idle before page capture.
# network-idle-timeout-secs = 15
# Remote Chrome bootstrap probe timeout (clamped to at least 250ms).
# bootstrap-timeout-ms = 3000
# Remote Chrome bootstrap probe retries (clamped 0-10).
# bootstrap-retries = 2
# Push Spider/Chromey's local policy to capable remote Chrome engines.
remote-local-policy = false

[retrieval]
# Candidates per prefetch arm before RRF fusion (clamped 10–500).
# Env: AXON_HYBRID_CANDIDATES
# hybrid-candidates = 100
# Hybrid prefetch window for the ask pipeline (clamped 10–500).
# Env: AXON_ASK_HYBRID_CANDIDATES
# ask-hybrid-candidates = 150

[ask]
# LLM synthesis defaults to Gemini headless. Configure AXON_LLM_BACKEND and
# backend-specific runtime variables in the env layer rather than config.toml.
# Max context characters passed to the LLM (clamped 20_000–1_000_000).
# Env: AXON_ASK_MAX_CONTEXT_CHARS
# max-context-chars = 300000
# Max chunks returned per ask query (clamped 3–64); static default 24.
# Env: AXON_ASK_CHUNK_LIMIT
# chunk-limit = 24
# Max candidate chunks fetched before scoring (clamped 8–300).
# Env: AXON_ASK_CANDIDATE_LIMIT
# candidate-limit = 250
# Max full documents included in context (clamped 1–20).
# Env: AXON_ASK_FULL_DOCS
# full-docs = 6
# Backfill chunks from top documents to pad context (clamped 0–20).
# Env: AXON_ASK_BACKFILL_CHUNKS
# backfill-chunks = 5
# Concurrent document fetches during context build (clamped 1–16).
# Env: AXON_ASK_DOC_FETCH_CONCURRENCY
# doc-fetch-concurrency = 4
# Max chunks per document in context (clamped 8–2000).
# Env: AXON_ASK_DOC_CHUNK_LIMIT
# doc-chunk-limit = 96
# Minimum relevance score to include a chunk (clamped -1.0–2.0).
# Env: AXON_ASK_MIN_RELEVANCE_SCORE
# min-relevance-score = 0.45
# Domains treated as authoritative during reranking.
# Env override: AXON_ASK_AUTHORITATIVE_DOMAINS=code.claude.com,docs.rs
# authoritative-domains = []
# Boost weight for authoritative domains (clamped 0.0–0.5).
# Env: AXON_ASK_AUTHORITATIVE_BOOST
# authoritative-boost = 0.0
# Min unique citations for non-trivial answers (clamped 1–5).
# Env: AXON_ASK_MIN_CITATIONS_NONTRIVIAL
# min-citations-nontrivial = 2

[ask.cache]
# In-process document-chunk cache for the ask full-doc fetch path. Only
# useful in long-lived parents (`axon serve`, `axon mcp`). Default: disabled.
# enabled = false
# max-capacity-bytes = 268435456
# ttl-secs = 300

[ask.adaptive]
# Full-doc fetch skip gate: elides full-doc backfill when reranked top-K
# already covers enough unique URLs, chunk bytes, and quality. Default: disabled.
# fulldoc-skip-enabled = false
# fulldoc-skip-min-urls = 3
# fulldoc-skip-min-chars = 4000
# fulldoc-skip-score-delta = 0.15

[crawl]
# Respect robots.txt directives.
# respect-robots = false
# Discover and backfill URLs from sitemap.xml after crawl.
# discover-sitemaps = true
# Thin-page threshold in markdown characters.
# min-markdown-chars = 200
# Skip thin pages instead of saving or embedding them.
# drop-thin-markdown = true
# Abort an in-process crawl when RSS reaches this percent of host/cgroup
# memory. 0 disables the guard. Env: AXON_CRAWL_MEMORY_ABORT_PERCENT
# memory-abort-percent = 85.0
# Only backfill sitemap URLs with a <lastmod> within the last N days. 0 disables.
# sitemap-since-days = 0
# Maximum number of sitemap documents to parse. 0 = unlimited.
# max-sitemaps = 512
# Probe /llms.txt at the site root and merge its links into backfill/map.
# discover-llms-txt = true
# Maximum number of URLs to take from a single /llms.txt. 0 = unlimited.
# max-llms-txt-urls = 512
# Thin-page ratio that triggers auto-switch to Chrome.
# auto-switch-thin-ratio = 0.60
# Minimum page count before auto-switch eligibility check.
# auto-switch-min-pages = 10
# Only crawl URLs matching these regex patterns.
# url-whitelist = ["^https://example\\.com/docs/"]
# Allow explicitly uncapped broad-domain crawls without a path budget/whitelist.
# Env: AXON_ALLOW_UNBOUNDED_BROAD_CRAWL
# allow-unbounded-broad-crawl = false
# Maximum response size per page in bytes. 0 = unlimited.
# max-page-bytes = 4194304
# Only follow same-origin redirects.
# redirect-policy-strict = false
# DOM retry ladder thresholds (words) and body-fallback multiplier.
# Env: AXON_LADDER_STRATEGY1_THRESHOLD / _STRATEGY2_THRESHOLD / _BODY_MULTIPLIER
# ladder-strategy1-threshold = 30
# ladder-strategy2-threshold = 200
# ladder-body-multiplier = 2.0
# Override crawl and backfill concurrency at once. Default from performance-profile.
# concurrency-limit = 128
# crawl-concurrency-limit = 128
# backfill-concurrency-limit = 64

[crawl.adaptive-concurrency]
# Off by default. When enabled, Axon replaces the fixed crawl semaphore with
# Spider's adaptive semaphore for the main Spider crawl path.
enabled = false
min = 1
# max defaults to the resolved crawl concurrency limit.
# max = 64

[crawl.verticals]
# Enable per-site vertical extractors (GitHub, PyPI, Reddit, HN, etc.).
# Env: AXON_ENABLE_VERTICALS. Default: true.
# enabled = true
# Vertical extractor names to SKIP in auto-dispatch.
# Env: AXON_AUTO_DISPATCH_SKIP (comma-separated). Default: empty.
# auto-dispatch-skip = ["amazon_product", "ebay_listing"]
# Per-vertical cache TTL in seconds:
# [crawl.verticals.cache-ttl-secs]
# github = 86400
# reddit = 3600
# hn = 21600

[crawl.antibot]
# Enable Akamai/Cloudflare cookie warmup retry on antibot challenge.
# Env: AXON_CHALLENGE_WARMUP. Default: true.
# cookie-warmup = true
# Maximum bytes scanned for antibot challenge patterns (per-page).
# Env: AXON_ANTIBOT_MAX_BODY_SCAN_BYTES. Default: 150000. Clamped 1000–10485760.
# max-body-scan-bytes = 150000

[watch]
# Recurring URL-watch scheduler sweep interval and lease TTL.
# Env: AXON_WATCH_TICK_SECS
# tick-secs = 15
# Env: AXON_WATCH_LEASE_SECS
# lease-secs = 300

[memory]
[graph]
[artifacts]
[prune]
[observability]
[security]
# Reserved for the remaining config-contract sections. No knob in this slice
# reads these yet; kept present so `config.toml` files written against the
# contract parse cleanly ahead of the runtime wiring landing.

# ── Remaining advanced env-only overrides ───────────────────────────────────
# These implemented values are still environment-only because they are host
# affinity, source-specific migration guards, or early runtime/bootstrap knobs.
# They do NOT belong in .env.example unless a deployment actually needs them.
#
# Embed job filesystem affinity. Compose sets the server container to
# "axon-container"; host CLI workers normally leave this empty.
#   AXON_FS_NAMESPACE
#
# Source chunking and conditional recrawl circuit breakers. Leave unset unless
# tuning a known large-corpus edge case.
#   AXON_MAX_TREE_SITTER_FILE_BYTES
#   AXON_RESIDUAL_GAP_FLOOR
#   AXON_ETAG_MAX_MISS_RUNS
#
# Log rotation is configured via env var only (not TOML), because
# init_tracing() runs before Config is built.
#   AXON_LOG_MAX_BYTES (default: 10485760 = 10 MiB; 0 = disable rotation)