fxcp_core/

constants.rs

// SPDX-License-Identifier: GPL-2.0-or-later
// Copyright (C) 2025 Joel Wirāmu Pauling <aenertia@aenertia.net>
//
// fxcp-core/src/constants.rs  --  Shared constants for tuning, timeouts, thresholds

//! Compile-time and runtime constants for foxing subsystems.
//! Includes worker tuning, retry limits, buffer sizes, and feature flags.

/// Crate version string, pulled from Cargo.toml at compile time.
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
/// Git commit hash at build time, or "unknown" if not set.
pub const GIT_COMMIT_HASH: &str = {
    match option_env!("GIT_HEAD_REF") {
        Some(s) => s,
        None => "unknown",
    }
};
/// Upper bound on worker threads the daemon will spawn.
pub const MAX_WORKER_CORES: usize = 64;
/// Default maximum event queue depth before back-pressure engages.
pub const DEFAULT_QUEUE_MAX: usize = 500_000;
/// Minimum interval between repeated error log messages for the same path.
pub const ERROR_LIMITER_SECS: u64 = 5;
/// Ceiling for exponential retry backoff across all retry loops.
pub const MAX_RETRY_BACKOFF_SECS: u64 = 60;
/// Free-space threshold on the target: below this, the daemon warns about low capacity.
pub const CAPACITY_THRESHOLD_MB: u64 = 512;
/// Default I/O buffer size for copy operations (MiB).
pub const DEFAULT_IO_BUFFER_SIZE_MIB: u64 = 1;
/// Seconds of inactivity before the daemon enters hibernation (reduced polling).
pub const DEFAULT_HIBERNATION_SECS: u64 = 600;
/// Polling interval (ms) for WAL barrier completion checks.
pub const BARRIER_CHECK_INTERVAL: u64 = 50;
/// Minimum I/O alignment for direct/O_DIRECT writes (bytes). Matches typical sector size.
pub const MINIMUM_ALIGNMENT_BYTES: usize = 4096;
/// Estimated per-entry memory overhead for the inode identity map (bytes).
pub const DEFAULT_IDENTITY_MAP_OVERHEAD_BYTES: u64 = 4096;
/// Per-event memory overhead in the dispatcher queue (bytes).
pub const EVENT_QUEUE_OVERHEAD_BYTES: u64 = 256;
/// Average total memory cost per queued event, including payload.
pub const AVG_EVENT_OVERHEAD_BYTES: u64 = EVENT_QUEUE_OVERHEAD_BYTES + 128;
/// Wire format version for BPF ring buffer event structs.
pub const BPF_EVENT_VERSION: u8 = 5;
/// Estimated number of in-flight entries in the BPF ring buffer.
pub const ESTIMATED_RING_DEPTH: u64 = 4096;
/// Maximum pending jobs in the hydration (resync) work queue.
pub const HYDRATION_QUEUE_CAPACITY: usize = 10_000;
/// Delay before retrying a hydration copy after an out-of-memory error.
pub const HYDRATION_OOM_RETRY_DELAY_SECS: u64 = 5;
/// Maximum retry attempts for a single hydration copy operation.
pub const HYDRATION_COPY_MAX_ATTEMPTS: u32 = 10;
/// Base delay for exponential backoff on hydration copy retries (ms).
pub const HYDRATION_COPY_BACKOFF_BASE_MS: u64 = 100;
/// Maximum backoff delay for hydration copy retries (ms).
pub const HYDRATION_COPY_BACKOFF_MAX_MS: u64 = 5000;
/// Maximum random jitter added to hydration copy backoff (ms).
pub const HYDRATION_COPY_JITTER_MAX_MS: u64 = 100;
/// Timeout for resolving an inode to a filesystem path during hydration.
pub const HYDRATION_PATH_RESOLVE_TIMEOUT_SECS: u64 = 2;
/// Polling interval when waiting for path resolution during hydration (ms).
pub const HYDRATION_PATH_RESOLVE_POLL_MS: u64 = 100;
/// Interval between hydration worker heartbeat log messages.
pub const HYDRATION_HEARTBEAT_INTERVAL_SECS: u64 = 30;
/// Timeout for receiving the next job from the hydration queue.
pub const HYDRATION_JOB_RECV_TIMEOUT_SECS: u64 = 15;
/// Minimum interval between memory allocation warning log messages during hydration.
pub const HYDRATION_ALLOCATION_WARN_INTERVAL_SECS: u64 = 5;
/// Directories modified within this window are considered "hot" and scanned first.
pub const HYDRATION_HOT_DIR_THRESHOLD_SECS: u64 = 24 * 3600;
/// Hydration batch limits for NVMe targets: (min_batch, max_batch).
pub const HYDRATION_BATCH_LIMITS_NVME: (usize, usize) = (4096, 65536);
/// Hydration batch limits for SSD targets: (min_batch, max_batch).
pub const HYDRATION_BATCH_LIMITS_SSD: (usize, usize) = (2048, 32768);
/// Hydration batch limits for network (NFS) targets: (min_batch, max_batch).
pub const HYDRATION_BATCH_LIMITS_NETWORK: (usize, usize) = (1024, 16384);
/// Hydration batch limits for HDD targets: (min_batch, max_batch).
pub const HYDRATION_BATCH_LIMITS_HDD: (usize, usize) = (1024, 8192);
/// Hydration batch limits for SD card targets: (min_batch, max_batch).
pub const HYDRATION_BATCH_LIMITS_SDCARD: (usize, usize) = (128, 1024);
/// Number of attempts to allocate a buffer from the worker pool before giving up.
pub const WORKER_BUFFER_POOL_ALLOC_ATTEMPTS: usize = 5;
/// Interval between worker housekeeping passes (stale entry cleanup, stats flush).
pub const WORKER_CLEANUP_INTERVAL_SECS: u64 = 60;
/// Minimum reorder buffer size before the worker starts processing events (bytes).
pub const WORKER_REORDER_BUFFER_MIN_BYTES: usize = 16 * 1024;
/// Maximum retries for a single event in the worker retry queue.
pub const WORKER_RETRY_QUEUE_MAX_RETRIES: u32 = 10;
/// Base backoff delay for the worker retry queue (ms). Doubles on each attempt.
pub const WORKER_RETRY_QUEUE_BASE_BACKOFF_MS: u64 = 50;
/// Delay after worker startup before running the first health check (ms).
pub const WORKER_STARTUP_CHECK_DELAY_MS: u64 = 100;
/// Minimum io_uring submission queue depth per worker.
pub const WORKER_IO_URING_DEPTH_MIN: u32 = 4;

/// Interval between adaptive tuner recalculations (microseconds).
pub const WORKER_TUNE_INTERVAL_US: u64 = 50_000;
/// Minimum events processed before the tuner considers adjusting parameters.
pub const WORKER_TUNE_EVENT_THRESHOLD: usize = 10;
/// Grace period after worker startup before I/O latency measurements are trusted.
pub const WORKER_INITIAL_IO_LATENCY_SECS: u64 = 10;

/// Debounce window for hydration tuner updates (microseconds).
pub const TUNER_HYDRATION_DEBOUNCE_US: u64 = 50_000;

/// Sliding window duration for tuner throughput and latency sampling.
pub const TUNER_WINDOW_SECS: u64 = 3; 
/// EWMA smoothing factor for tuner metrics (lower = smoother, slower to react).
pub const TUNER_EWMA_ALPHA: f64 = 0.25; 

/// Minimum delay between BBR tuner state transitions (microseconds).
pub const TUNER_STATE_TRANSITION_DELAY_US: u64 = 500_000;

/// Seconds of zero throughput before the tuner enters idle mode.
pub const TUNER_IDLE_TIMEOUT_SECS: u64 = 30;
/// Duration of the BBR startup phase (aggressive probing).
pub const TUNER_STARTUP_DURATION_SECS: u64 = 2; 
/// Maximum time the tuner stays in drain phase before returning to steady state.
pub const TUNER_DRAIN_TIMEOUT_SECS: u64 = 6; 

/// Upper bound on flush interval (microseconds). Caps how long writes can be batched.
pub const TUNER_MAX_FLUSH_US: u64 = 5_000_000;
/// Lower bound on flush interval (microseconds). Prevents excessive flushing.
pub const TUNER_MIN_FLUSH_US: u64 = 50;
/// BBR pacing gain during startup phase (2x = double estimated BDP).
pub const TUNER_BDP_PACING_GAIN_STARTUP: f64 = 2.0;
/// BBR pacing gain during drain phase (0.5x = half rate to clear queues).
pub const TUNER_BDP_PACING_GAIN_DRAIN: f64 = 0.5;
/// BBR pacing gain during bandwidth probing (1.25x = slight overshoot).
pub const TUNER_BDP_PACING_GAIN_PROBE: f64 = 1.25;
/// BBR pacing gain when muted by system pressure (0.75x = reduced throughput).
pub const TUNER_BDP_PACING_GAIN_MUTED: f64 = 0.75;
/// Memory usage fraction that triggers tuner throttling.
pub const TUNER_MEMORY_PRESSURE_THRESHOLD: f64 = 0.90;
/// I/O profile for HDD targets: (min_chunk, max_chunk, min_qd, max_qd).
pub const PROFILE_HDD_VALUES: (u64, u64, usize, usize) = (2 * 1024 * 1024, 64 * 1024 * 1024, 4, 32);
/// I/O profile for network (NFS) targets: (min_chunk, max_chunk, min_qd, max_qd).
pub const PROFILE_NETWORK_VALUES: (u64, u64, usize, usize) = (1024 * 1024, 32 * 1024 * 1024, 8, 128);
/// I/O profile for NVMe targets: (min_chunk, max_chunk, min_qd, max_qd).
pub const PROFILE_NVME_VALUES: (u64, u64, usize, usize) = (256 * 1024, 16 * 1024 * 1024, 16, 1024);
/// I/O profile for SSD targets: (min_chunk, max_chunk, min_qd, max_qd).
pub const PROFILE_SSD_VALUES: (u64, u64, usize, usize) = (128 * 1024, 8 * 1024 * 1024, 8, 64);
/// I/O profile for SD card targets: (min_chunk, max_chunk, min_qd, max_qd).
pub const PROFILE_SDCARD_VALUES: (u64, u64, usize, usize) = (512 * 1024, 16 * 1024 * 1024, 1, 8);
/// Cooldown period before the governor can toggle stress state again.
pub const GOVERNOR_HYSTERESIS_SECS: u64 = 1;
/// How often the governor samples PSI, memory, and CPU pressure (ms).
pub const GOVERNOR_CHECK_INTERVAL_MS: u64 = 500;
/// Initial pacing delay when the governor first detects system stress (ms).
pub const GOVERNOR_PACING_INITIAL_MS: u64 = 10;
/// Maximum pacing delay the governor can impose on workers (ms).
pub const GOVERNOR_PACING_MAX_MS: u64 = 1000;
/// Memory usage fraction above which the governor activates pressure throttling.
pub const GOVERNOR_MEMORY_HIGH_WATERMARK_PCT: f64 = 0.90;
/// Time-to-live for stale entries in the inode identity map (seconds).
pub const IDENTITY_EVICTION_TTL_SECS: u64 = 12 * 3600;
/// Number of events processed before capability caches are invalidated.
pub const CACHE_TTL_EVENTS: u64 = 100_000;
/// Interval between garbage collection sweeps for expired map entries.
pub const GC_INTERVAL_SECS: u64 = 30;
/// Maximum random jitter added to GC startup to avoid thundering herd (ms).
pub const GC_STARTUP_JITTER_MAX_MS: u64 = 5000;
/// Minimum quiet period between consecutive full-scan triggers.
pub const FULL_SCAN_DEBOUNCE_SECS: u64 = 5;
/// Minimum free inodes on the target before the daemon warns about exhaustion.
pub const MIN_INODES_THRESHOLD: u64 = 1000;
/// Smallest allowed chunk size in the buffer pool (bytes).
pub const BUFFER_POOL_MIN_CHUNK_SIZE: usize = 4096;
/// Copy failure rate (0.0..1.0) above which the governor declares the target unhealthy.
pub const GOVERNOR_FAILURE_RATE_THRESHOLD: f64 = 0.5;
/// Sliding window for computing the governor's failure rate.
pub const GOVERNOR_FAILURE_WINDOW_SECS: u64 = 30;
/// Timeout for copying small files (< 64KB). Covers metadata-heavy NFS round-trips.
pub const COPY_TIMEOUT_SMALL_SECS: u64 = 120;
/// Timeout for copying large files. Allows for slow network or HDD targets.
pub const COPY_TIMEOUT_LARGE_SECS: u64 = 600;
#[deprecated(note = "Use adaptive timeout from TunerOutput::postcopy_timeout_secs")]
pub const POSTCOPY_TIMEOUT_SECS: u64 = 300;
#[deprecated(note = "Use adaptive timeout from TunerOutput::segment_overall_timeout_secs")]
pub const PROCESS_SEGMENT_TIMEOUT_SECS: u64 = 600;
#[deprecated(note = "Use adaptive timeout from TunerOutput::segment_stall_timeout_secs")]
pub const PROCESS_SEGMENT_STALL_SECS: u64 = 60;
/// Consecutive io_uring completion timeouts before the worker declares a stall.
pub const IOURING_COMPLETION_TIMEOUT_STREAK: usize = 600;
/// Consecutive back-pressure timeouts before hydration gives up on a job.
pub const HYDRATION_BACKPRESSURE_TIMEOUT_ATTEMPTS: usize = 120;
/// How often the stall watchdog checks for stuck workers.
pub const STALL_WATCHDOG_INTERVAL_SECS: u64 = 30;
/// Seconds without progress before the watchdog declares a worker stalled.
pub const STALL_WATCHDOG_THRESHOLD_SECS: u64 = 120;
/// Retry queue iterations with zero progress before triggering a forced drain.
pub const RETRY_QUEUE_STALL_THRESHOLD_ITERATIONS: usize = 20;
/// PSI I/O pressure percentage that triggers governor throttling (normal mode).
pub const GOVERNOR_PSI_IO_THRESHOLD_NORMAL: f64 = 10.0;
/// PSI CPU pressure percentage that triggers governor throttling (normal mode).
pub const GOVERNOR_PSI_CPU_THRESHOLD_NORMAL: f64 = 10.0;
/// PSI I/O pressure threshold for hypervisor/container environments (relaxed mode).
pub const GOVERNOR_PSI_IO_THRESHOLD_RELAXED: f64 = 50.0;
/// PSI CPU pressure threshold for hypervisor/container environments (relaxed mode).
pub const GOVERNOR_PSI_CPU_THRESHOLD_RELAXED: f64 = 50.0;
/// When true, the daemon runs a single sync pass and exits (fxcp mode).
pub static ONE_SHOT_MODE: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
/// Minimum soft timeout for the reorder buffer before releasing out-of-order events (ms).
pub const REORDER_SOFT_TIMEOUT_MIN_MS: u64 = 50;
/// Maximum soft timeout for the reorder buffer (ms). Caps wait time for missing sequences.
pub const REORDER_SOFT_TIMEOUT_MAX_MS: u64 = 500;
/// Maximum number of events the reorder buffer can hold before dropping.
pub const REORDER_BUFFER_CAPACITY: usize = 100_000;
/// Time after which an undelivered reorder buffer entry is considered a zombie (ms).
pub const REORDER_ZOMBIE_TIMEOUT_MS: u64 = 30_000;
/// Reorder buffer fill fraction that triggers panic-mode forced delivery.
pub const REORDER_PRESSURE_PANIC_PCT: f64 = 0.8;
/// Reorder buffer fill fraction that triggers a warning log.
pub const REORDER_PRESSURE_WARN_PCT: f64 = 0.5;
/// Maximum memory budget for the reorder buffer (bytes).
pub const REORDER_BUFFER_BYTES: u64 = 64 * 1024 * 1024;

/// Timeout for the fsync liveness probe that detects stale NFS mounts.
pub const MOUNT_PROBE_FSYNC_TIMEOUT_SECS: u64 = 5;
/// Maximum events stored in the outage journal before oldest entries are dropped.
pub const OUTAGE_JOURNAL_MAX_ENTRIES: usize = 100_000;
/// Outage duration (seconds) beyond which recovery triggers a full scan instead of journal replay.
pub const OUTAGE_FULL_SCAN_THRESHOLD_SECS: u64 = 86400;

// --- Large File Resync (v0.9.2) ---
/// Files above this threshold use the per-target Merkle index (.foxing_meta/merkle.db)
/// instead of xattr storage, enabling finer-grained chunk sizes.
pub const MERKLE_INDEX_THRESHOLD: u64 = 256 * 1024 * 1024; // 256MB
/// Merkle chunk size for files stored in the per-target index.
/// 512KB gives a practical tradeoff: 640KB index per 10GB file, 64MB per 1TB.
pub const MERKLE_INDEX_CHUNK_SIZE: u64 = 512 * 1024; // 512KB
/// Maximum serialized Merkle signature size that fits in a Linux xattr.
pub const MERKLE_XATTR_MAX_BYTES: usize = 64 * 1024; // 64KB
/// Minimum file size for the Merkle delta copy path in hydration.
pub const MERKLE_DELTA_THRESHOLD: u64 = 1024 * 1024; // 1MB
/// Minimum chunk size for Merkle tree (64KB). Adaptive chunk_size scales up for large files.
pub const MIN_CHUNK_SIZE: usize = 65536;
/// Max Merkle leaves that fit in a 64KB xattr with fat nodes.
/// (65536 - 56 overhead) / 44 bytes per leaf (32 hash + 4 entropy + 8 simhash) = 1488.
pub const MAX_LEAVES_PER_XATTR: u64 = 1488;
/// Maximum dirty ranges tracked per file before overflow to full resync.
pub const DIRTY_RANGE_MAX_PER_FILE: usize = 4096;

// --- qcow2 Format Constants (spec-defined, not tunable) ---
/// qcow2 magic bytes: "QFI\xfb" in big-endian.
pub const QCOW2_MAGIC: u32 = 0x514649fb;
/// Header extension type for persistent dirty bitmaps.
pub const QCOW2_BITMAPS_EXTENSION: u32 = 0x23852875;
/// Maximum backing file path length (qcow2 spec).
pub const QCOW2_MAX_BACKING_PATH: u32 = 1023;
/// qcow2 v3 header size (minimum).
pub const QCOW2_HEADER_V3_SIZE: usize = 104;
/// Dirty tracking bitmap type identifier.
pub const QCOW2_BITMAP_TYPE_DIRTY: u8 = 1;
/// Bitmap flag: in_use (inconsistent  --  was not properly synced).
pub const QCOW2_BITMAP_FLAG_IN_USE: u32 = 0x01;
/// Bitmap flag: auto (actively recording writes).
pub const QCOW2_BITMAP_FLAG_AUTO: u32 = 0x02;
/// L1/L2 host offset extraction mask (bits 9-55).
pub const QCOW2_L2_OFFSET_MASK: u64 = 0x00FFFFFFFFFFFE00;

/// How often workers check whether the target mount is still alive (ms).
pub const WORKER_MOUNT_CHECK_INTERVAL_MS: u64 = 500;
/// How often workers flush Prometheus metric gauges (ms).
pub const WORKER_METRICS_UPDATE_INTERVAL_MS: u64 = 250;
/// Small file threshold for hydration fast-path (skip io_uring overhead).
pub const HYDRATION_SMALL_FILE_THRESHOLD: u64 = 256 * 1024; // 256KB
/// Log progress every N directories during hydration scan.
pub const HYDRATION_CHECKPOINT_INTERVAL: usize = 1000;
/// Log progress every N files during hydration copy.
pub const HYDRATION_LOG_INTERVAL: usize = 500;
/// Storm detection threshold range for event burst detection.
pub const STORM_THRESHOLD_MIN: usize = 2_000;
/// Maximum rename storm threshold before forced drain.
pub const STORM_THRESHOLD_MAX: usize = 100_000;

// --- System Classification ---
/// Systems with less than this are considered memory-constrained.
pub const SYSTEM_MEMORY_CONSTRAINED_MB: u64 = 2048;
/// Systems with more than this get expanded buffers.
pub const SYSTEM_MEMORY_LARGE_MB: u64 = 16384;

/// Sentinel value for unknown/unset inode generation.
pub const GENERATION_UNKNOWN: u32 = u32::MAX;

// --- Tuner v2 constants ---
/// Default estimated bandwidth for new targets before probing (GB/s).
pub const TUNER_DEFAULT_BANDWIDTH_GB_PER_SEC: f64 = 0.1;
/// Default flush interval for worker event batches (microseconds).
pub const TUNER_DEFAULT_FLUSH_INTERVAL_US: u64 = 1000;
/// Default coalesce threshold for merging small writes (bytes).
pub const TUNER_DEFAULT_COALESCE_BYTES: u64 = 65536;
/// Maximum coalesce threshold (4MB)  --  memory guardrail.
pub const TUNER_MAX_COALESCE_BYTES: u64 = 4_194_304;
/// Default batch size for worker event processing.
pub const TUNER_DEFAULT_BATCH_SIZE: usize = 32;
/// Default io_uring submission queue depth.
pub const TUNER_DEFAULT_QUEUE_DEPTH: u64 = 8;
/// Default assumed average event payload size (bytes).
pub const TUNER_DEFAULT_AVG_EVENT_SIZE_BYTES: u64 = 4096;
/// Latency spike detection threshold (microseconds); exceeding triggers drain.
pub const TUNER_DEFAULT_LATENCY_SPIKE_THRESHOLD_US: u64 = 5000;
/// Minimum flush interval floor (microseconds).
pub const TUNER_DEFAULT_FLUSH_MIN_US: u64 = 50;
/// Maximum flush interval ceiling (microseconds).
pub const TUNER_DEFAULT_FLUSH_MAX_US: u64 = 5_000_000;
/// Minimum pending queue depth before back-pressure engages.
pub const TUNER_DEFAULT_PENDING_QUEUE_MIN: usize = 16;
/// Maximum pending queue depth before events are dropped.
pub const TUNER_DEFAULT_PENDING_QUEUE_MAX: usize = 4096;
/// Memory pressure percentage threshold for tuner v2 throttling.
pub const TUNER_DEFAULT_MEMORY_PRESSURE_PCT: f64 = 0.85;
/// EWMA smoothing factor for queue depth estimation.
pub const TUNER_DEFAULT_QUEUE_DEPTH_ALPHA: f64 = 0.3;
/// AIMD additive increase step for batch size growth.
pub const TUNER_AIMD_ADDITIVE_STEP: usize = 4;
/// AIMD multiplicative decrease factor on congestion detection.
pub const TUNER_AIMD_MULTIPLICATIVE_FACTOR: f64 = 0.75;
/// Bandwidth threshold above which aggressive probing is used (GB/s).
pub const TUNER_HIGH_BANDWIDTH_THRESHOLD_GB_PER_SEC: f64 = 1.0;
/// Hard upper bound on batch size regardless of tuner state.
pub const TUNER_MAX_BATCH_SIZE: usize = 1024;
/// Hard lower bound on batch size to prevent starvation.
pub const TUNER_MIN_BATCH_SIZE: usize = 4;
/// Default EWMA alpha for tuner v2 smoothing filters.
pub const TUNER_V2_EWMA_ALPHA_DEFAULT: f64 = 0.25;

// --- AI Content Routing Policy ---

/// 100 MB  --  applies only to text/code files. Header-based groups
/// (media, video, archive, binary, document) have no size limit.
pub const AI_MAX_TEXT_FILE_SIZE: u64 = 100 * 1024 * 1024; // 100 MB

/// Maximum bytes of text content to embed via chunking.
/// Content beyond this point is truncated before `split_recursive()` to
/// bound ORT embedding cost while still allowing large files to be indexed.
/// 1 MiB of UTF-8 text produces ~4K chunks at 256 chars each.
pub const AI_MAX_EMBED_BYTES: usize = 1_048_576; // 1 MiB

// --- AI Chunk-Size Policy ---

/// Chunk size for code files (chars). Smaller chunks preserve function boundaries.
pub const AI_CHUNK_SIZE_CODE: usize = 256;
/// Overlap for code chunks (chars).
pub const AI_CHUNK_OVERLAP_CODE: usize = 32;

/// Chunk size for text/prose files (chars). Larger to preserve paragraph context.
pub const AI_CHUNK_SIZE_TEXT: usize = 1024;
/// Overlap for text chunks (chars).
pub const AI_CHUNK_OVERLAP_TEXT: usize = 128;

/// Chunk size for markup files like HTML/XML (chars).
pub const AI_CHUNK_SIZE_MARKUP: usize = 512;
/// Overlap for markup chunks (chars).
pub const AI_CHUNK_OVERLAP_MARKUP: usize = 128;

/// Chunk size for document files like PDF/DOCX (chars). Large to preserve document structure.
pub const AI_CHUNK_SIZE_DOCUMENT: usize = 1024;
/// Overlap for document chunks (chars).
pub const AI_CHUNK_OVERLAP_DOCUMENT: usize = 256;

/// Default chunk size for unknown/unrecognized content (chars).
pub const AI_CHUNK_SIZE_DEFAULT: usize = 512;
/// Default overlap for unknown content (chars).
pub const AI_CHUNK_OVERLAP_DEFAULT: usize = 64;

// --- AI Enrichment Prompt Budget ---

/// Maximum total prompt length (chars) sent to the LLM for enrichment.
/// Metadata context (Magika, extracted metadata, similar files) is always
/// included first. Raw file content fills the remaining budget.
/// Default: 12000 chars (~=3000 tokens)  --  leaves headroom for LLM response
/// within a 16K context window.
pub const AI_MAX_PROMPT_CHARS: usize = 12_000;

/// Maximum chars of raw file content in the enrichment prompt.
/// This is the unstructured content budget AFTER metadata context.
/// Truncated at UTF-8 boundary.  Default: 4000 chars.
pub const AI_MAX_CONTENT_CHARS: usize = 4_000;

/// Maximum chars for the indexed content preview section.
/// Prevents large multi-chunk files from blowing out the prompt.
/// Default: 1000 chars.
pub const AI_MAX_PREVIEW_CHARS: usize = 1_000;

/// Maximum chars for the collection context section.
/// Default: 500 chars.
pub const AI_MAX_COLLECTION_CONTEXT_CHARS: usize = 500;

// --- Effort-Tiered Pipeline Defaults ---

/// Maximum content chars sent to LLM at Quick effort.
/// Quick skips LLM entirely, but if forced: minimal content.
pub const AI_QUICK_MAX_CONTENT_CHARS: usize = 1_000;
/// Maximum content chars at Balanced effort.
pub const AI_BALANCED_MAX_CONTENT_CHARS: usize = 4_000;
/// Maximum content chars at Deep effort.
pub const AI_DEEP_MAX_CONTENT_CHARS: usize = 8_000;

/// Fallback max prompt chars at Quick effort.
pub const AI_QUICK_MAX_PROMPT_CHARS: usize = 4_000;
/// Fallback max prompt chars at Balanced effort.
pub const AI_BALANCED_MAX_PROMPT_CHARS: usize = 12_000;
/// Fallback max prompt chars at Deep effort.
pub const AI_DEEP_MAX_PROMPT_CHARS: usize = 50_000;

/// Max preview chars at each effort level.
pub const AI_QUICK_MAX_PREVIEW_CHARS: usize = 200;
/// Max preview chars at Balanced effort.
pub const AI_BALANCED_MAX_PREVIEW_CHARS: usize = 1_000;
/// Max preview chars at Deep effort.
pub const AI_DEEP_MAX_PREVIEW_CHARS: usize = 2_000;

/// Archive peek budget (milliseconds) per effort level.
pub const AI_QUICK_ARCHIVE_PEEK_BUDGET_MS: u64 = 10;
/// Archive peek budget at Balanced effort.
pub const AI_BALANCED_ARCHIVE_PEEK_BUDGET_MS: u64 = 10;
/// Archive peek budget at Deep effort (0 = no budget cap).
pub const AI_DEEP_ARCHIVE_PEEK_BUDGET_MS: u64 = 0;

// --- RAG / Sidecar Discovery Constants ---
// From docs/adrs/RAG-Standards-Sidecar-ADR.md

/// Minimum Magika confidence to accept ORT-layer sidecar data without LLM review.
/// At >=0.85, ORT alone can make the accept/reject decision.
pub const AI_SIDECAR_HIGH_CONFIDENCE: f32 = 0.85;

/// Minimum confidence to pass sidecar data to the LLM layer for evaluation.
/// LLM can reason about borderline cases; below this threshold, discard.
pub const AI_SIDECAR_CONFIDENCE_THRESHOLD: f32 = 0.70;

/// Maximum chars of sidecar context injected into the enrichment prompt.
pub const AI_MAX_SIDECAR_CONTEXT_CHARS: usize = 2_000;

/// Maximum number of sidecar sources attached per file enrichment.
pub const AI_SIDECAR_MAX_SOURCES_PER_FILE: usize = 3;

/// Staleness penalty ratio: sidecar data older than Nx the file's own mtime
/// delta gets a confidence penalty applied during sidecar scoring.
pub const AI_SIDECAR_STALENESS_PENALTY_RATIO: f32 = 10.0;

/// Adoption threshold: if fewer than 30% of files in a collection have a given
/// sidecar format, treat it as low-adoption and apply stricter confidence gating.
pub const AI_SIDECAR_LOW_ADOPTION_THRESHOLD: f32 = 0.30;

/// Character budget for the sidecar type prefix in an enrichment prompt.
pub const SIDECAR_PREFIX_BUDGET: usize = 100;

/// ORT-layer confidence threshold for reference file injection.
/// At >=0.90, reference file context can be injected without LLM gating.
pub const AI_REFERENCE_ORT_THRESHOLD: f32 = 0.90;

/// LLM-layer confidence threshold for reference file injection.
pub const AI_REFERENCE_LLM_THRESHOLD: f32 = 0.75;

/// Maximum chars of reference file context injected per enrichment prompt.
pub const AI_MAX_REFERENCE_CONTEXT_CHARS: usize = 500;

/// Maximum chars of association context (Dublin Core descriptions from associated files)
/// injected into the enrichment prompt. Truncated at UTF-8 boundary.
pub const AI_MAX_ASSOCIATION_CONTEXT_CHARS: usize = 1_000;

// --- AI Magika Routing Confidence ---

/// Magika ML confidence threshold for full trust (ignore extension).
/// At or above this, Magika's label/group/is_text are used directly.
pub const AI_MAGIKA_HIGH_CONFIDENCE: f32 = 0.85;

/// Magika ML confidence threshold for extension-supplemented routing.
/// Between this and AI_MAGIKA_HIGH_CONFIDENCE, Magika is used but
/// extension info supplements when there's a conflict.
/// Below this threshold, fall back to extension-only classification.
pub const AI_MAGIKA_SUPPLEMENT_THRESHOLD: f32 = 0.50;

/// Default Magika ML confidence threshold for the confidence gate in
/// `MagikaRouter::classify_file()` and `media_meta::extract_metadata()`.
/// At or above this score, Magika's classification is trusted directly.
/// Below this score, the gate checks whether the file extension is in
/// `MAGIKA_KNOWN_EXTENSIONS`: if yes, trust Magika; if no, fall back
/// to extension-based `ContentRouter`.
/// Configurable via `[ai.enrichment] magika_confidence_threshold` in
/// foxingd config.  CLI `fxcp enrich` uses this constant as the default.
pub const AI_MAGIKA_CONFIDENCE_THRESHOLD: f32 = 0.50;

// --- AI Sandwich Sampling ---

/// Head section ratio for sandwich sampling (35% of budget).
pub const AI_SANDWICH_HEAD_RATIO: f64 = 0.35;
/// Middle section ratio for sandwich sampling (25% of budget).
pub const AI_SANDWICH_MID_RATIO: f64 = 0.25;
/// Tail section ratio for sandwich sampling (20% of budget).
pub const AI_SANDWICH_TAIL_RATIO: f64 = 0.20;
/// Random sample ratio for sandwich sampling (20% of budget).
pub const AI_SANDWICH_RANDOM_RATIO: f64 = 0.20;
/// Number of random sample windows extracted from the interior.
pub const AI_SANDWICH_RANDOM_WINDOWS: usize = 3;
/// Marker prefix for the head section in sandwich output.
pub const AI_SANDWICH_MARKER_HEAD: &str = "[HEAD]";
/// Marker prefix for the middle section in sandwich output.
pub const AI_SANDWICH_MARKER_MID: &str = "[MID]";
/// Marker prefix for the tail section in sandwich output.
pub const AI_SANDWICH_MARKER_TAIL: &str = "[TAIL]";
/// Marker prefix for random sample sections in sandwich output.
pub const AI_SANDWICH_MARKER_SAMPLE: &str = "[SAMPLE]";
/// Maximum byte overhead from section markers and newlines.
pub const AI_SANDWICH_MARKER_OVERHEAD: usize = 50;

// -- Sprint 11b: Extension collision handling --
/// Confidence multiplier for extensions in COLLISION_MAP table.
/// Effective threshold = AI_MAGIKA_CONFIDENCE_THRESHOLD * AI_COLLISION_CONFIDENCE_MULTIPLIER.
/// At defaults: 0.50 * 1.5 = 0.75 effective threshold for collision-prone extensions.
/// This matches Magika's own raised threshold for markdown (0.75 in config.min.json).
pub const AI_COLLISION_CONFIDENCE_MULTIPLIER: f32 = 1.5;

/// Pico-8 cartridge PNG width (steganographic game data embedded in pixels).
pub const AI_PICO8_PNG_WIDTH: u32 = 160;
/// Pico-8 cartridge PNG height.
pub const AI_PICO8_PNG_HEIGHT: u32 = 205;

// Sprint 13 — extracted from inline literals

/// Maximum number of keywords extracted per file in LLM enrichment output.
pub const AI_MAX_KEYWORDS_PER_FILE: usize = 10;

/// Maximum number of entity mentions extracted per file in LLM enrichment output.
pub const AI_MAX_MENTIONS_PER_FILE: usize = 10;

/// Minimum retry delay for LLM API calls in milliseconds (floor for exponential backoff).
pub const AI_LLM_RETRY_MIN_DELAY_MS: u64 = 100;

/// Confidence score assigned to files detected as Pico-8 cartridges via dimension probe.
pub const AI_PICO8_DETECTION_CONFIDENCE: f32 = 0.80;

/// Maximum effective confidence after collision gate adjustment (ceiling to avoid 1.0).
pub const AI_COLLISION_CONFIDENCE_MAX: f32 = 0.99;

/// Maximum line length for key-value pairs in raw sidecar parsing.
pub const AI_SIDECAR_KV_MAX_LINE_LEN: usize = 200;

/// Depth penalty multiplier applied to XML sidecar confidence scores.
pub const AI_SIDECAR_XML_DEPTH_PENALTY: f32 = 0.85;

/// HTTP status codes that indicate a retryable LLM API error.
pub const AI_LLM_RETRYABLE_STATUS_CODES: &[u16] = &[429, 500, 502, 503, 529];

// --- AI Enrichment Engine Defaults ---

/// Default max output tokens per LLM enrichment request.
/// Applies when `ai.enrichment.max_tokens` is unset.
pub const AI_LLM_DEFAULT_MAX_TOKENS: u32 = 512;

/// Default sampling temperature for LLM enrichment requests.
/// Low value (0.2) favours consistency over creativity.
pub const AI_LLM_DEFAULT_TEMPERATURE: f32 = 0.2;

/// Default daily token budget (input + output). 0 = unlimited.
/// Offline-first default: local LLM servers (llama.cpp, vLLM, Ollama) have no token cost.
/// Set to a non-zero value only for paid cloud APIs (e.g. 100_000 for OpenAI free tier).
pub const AI_LLM_DAILY_TOKEN_BUDGET: u64 = 0;

/// HTTP timeout per LLM enrichment request (seconds).
pub const AI_LLM_REQUEST_TIMEOUT_SECS: u64 = 30;

/// Maximum retries on transient LLM failures before giving up.
pub const AI_LLM_MAX_RETRIES: u32 = 2;

/// Maximum concurrent LLM enrichment requests.
pub const AI_LLM_MAX_CONCURRENT: usize = 8;

/// Initial backoff delay for LLM retry loop (milliseconds).
pub const AI_LLM_RETRY_INITIAL_DELAY_MS: u64 = 500;

/// Maximum backoff delay for LLM retry loop (milliseconds).
pub const AI_LLM_RETRY_MAX_DELAY_MS: u64 = 30_000;

/// Budget reset interval  --  tokens_used counter resets after this many seconds.
pub const AI_LLM_BUDGET_RESET_SECS: u64 = 86_400;

/// Truncation limit for dc_abstract when LLM returns non-JSON (chars).
pub const AI_SAFE_TRUNCATE_ABSTRACT_LIMIT: usize = 200;

/// Truncation limit for description when LLM returns non-JSON (chars).
pub const AI_SAFE_TRUNCATE_DESCRIPTION_LIMIT: usize = 500;

/// Truncation limit for sidecar context and extracted metadata in
/// synthesised enrichment prompts (chars).
pub const AI_SAFE_TRUNCATE_CONTEXT_LIMIT: usize = 300;

// --- AI ORT / ONNX Embedding Engine ---

/// Maximum input sequence length (tokens) for ORT/ONNX tokenizer.
pub const AI_ORT_MAX_SEQUENCE_LENGTH: usize = 512;

/// Default batch size for ORT embedding inference.
pub const AI_ORT_DEFAULT_BATCH_SIZE: usize = 32;

// --- AI pgvector Sync ---

/// File batch size per transaction during pgvector export.
pub const AI_PGVECTOR_FILE_BATCH_SIZE: usize = 500;

/// HNSW `m` parameter  --  max bi-directional links per node.
pub const AI_HNSW_M: u32 = 16;

/// HNSW `ef_construction` for 64-bit SimHash binary index (bit_hamming_ops).
/// Set to 256 per SOTA recommendation for binary vectors with high near-duplicate ratios
/// (NapierOne dataset analysis: 64 produces poor recall on dense similarity clusters).
pub const AI_HNSW_EF_CONSTRUCTION_SIMHASH: u32 = 256;

/// HNSW `ef_construction` for embedding cosine-similarity index.
pub const AI_HNSW_EF_CONSTRUCTION_COSINE: u32 = 128;

// --- AI Docling Document Extraction ---

/// Maximum wait time for async docling-serve conversion (seconds).
pub const AI_DOCLING_TIMEOUT_SECS: u64 = 120;

/// Poll interval for docling-serve async status checks (milliseconds).
pub const AI_DOCLING_POLL_INTERVAL_MS: u64 = 1000;

// --- Worker Event Processing ---

/// Sequential I/O proximity threshold (bytes). I/O within this range of the
/// last sequential offset is treated as sequential for scheduling purposes.
pub const SEQUENTIAL_PROXIMITY_THRESHOLD_BYTES: u64 = 262_144;

/// Emergency prune threshold (bytes). When target storage drops below this,
/// the worker initiates emergency version pruning before retrying the copy.
pub const EMERGENCY_PRUNE_THRESHOLD_BYTES: u64 = 1_073_741_824;

/// Base timeout for copy operations (seconds). The actual timeout is computed
/// as `base + (file_size / 10MB) * per_10mb`, capped at `COPY_TIMEOUT_CAP_SECS`.
pub const COPY_TIMEOUT_BASE_SECS: u64 = 60;

/// Additional timeout per 10 MB of file data (seconds).
pub const COPY_TIMEOUT_PER_10MB_SECS: u64 = 60;

/// Maximum copy timeout regardless of file size (seconds).
pub const COPY_TIMEOUT_CAP_SECS: u64 = 300;

/// Timeout for simple event handler operations: rename, truncate, fallocate (seconds).
pub const EVENT_HANDLER_TIMEOUT_SECS: u64 = 60;

/// Default Prometheus metrics port for the foxingd API server.
pub const DEFAULT_METRICS_PORT: u16 = 9100;

// --- BPF Event Pipeline ---

/// Sequence gap threshold for BPF ring buffer. Gaps larger than this trigger
/// panic-mode hydration and a synthetic SequenceGap event.
pub const BPF_SEQUENCE_GAP_THRESHOLD: u64 = 1000;

/// Consecutive target errors before the worker requests a rescan on recovery.
pub const TARGET_ERROR_STREAK_THRESHOLD: u32 = 5;

/// Maximum events drained from the coalescer per flush tick. Prevents
/// unbounded processing in a single select iteration.
pub const WORKER_FLUSH_CAP_PER_TICK: usize = 256;

/// Maximum capacity of the per-worker write coalescer. Also used as the
/// denominator for buffer utilization metrics.
pub const COALESCER_MAX_CAPACITY: usize = 10_000;

/// Maximum entries in the TransientFilter map before forced GC + eviction.
/// Prevents unbounded HashMap growth under sustained create storms.
pub const BPF_MAX_TRANSIENT_ENTRIES: usize = 100_000;

/// Maximum number of block devices tracked simultaneously in the BPF
/// sequence tracker and identity map.
pub const BPF_MAX_TRACKED_DEVICES: usize = 256;

/// TransientFilter GC cutoff (seconds). Entries older than this are evicted
/// during periodic garbage collection to prevent unbounded growth.
pub const BPF_TRANSIENT_GC_CUTOFF_SECS: u64 = 30;

/// BPF ring buffer poll interval (milliseconds). Controls how often the
/// userspace event loop polls the kernel ring buffer for new events.
pub const BPF_RING_POLL_INTERVAL_MS: u64 = 100;

/// Interval between BPF per-device statistics reports (seconds).
pub const BPF_STATS_REPORT_INTERVAL_SECS: u64 = 30;

/// Per-event fixed overhead estimate (bytes) used by the ReorderBuffer
/// for memory accounting alongside the event payload size.
pub const BPF_EVENT_OVERHEAD_BYTES: u64 = 64;

/// Base event payload size estimate (bytes) used by the ReorderBuffer
/// for memory accounting. The actual size adds the event name length.
pub const BPF_EVENT_SIZE_ESTIMATE_BYTES: u64 = 256;

/// Bounded frontier width limit for the Coalescer. When the batch exceeds
/// this threshold, aggressive transient lifecycle pruning is triggered.
pub const COALESCER_FRONTIER_WIDTH_LIMIT: usize = 10_000;

/// Channel capacity for the metadata tin in the TinnedDispatcher.
/// Metadata events (chmod, chown, xattr) are droppable under pressure.
pub const DISPATCHER_METADATA_TIN_CAPACITY: usize = 1024;

/// Channel capacity for the bulk tin in the TinnedDispatcher.
/// Bulk events (write, truncate) are freely droppable; hydration catches misses.
pub const DISPATCHER_BULK_TIN_CAPACITY: usize = 4096;

// --- NFS Client Defaults ---

/// TCP connect timeout for NFSv4.2 client session recovery and privileged port fallback.
pub const NFS_TCP_CONNECT_TIMEOUT_SECS: u64 = 5;

/// TCP read/write timeout for NFSv4.2 compound RPC streams.
pub const NFS_TCP_RW_TIMEOUT_SECS: u64 = 10;

/// Sleep duration between retries when the NFS server is in grace period.
pub const NFS_RECONNECT_SLEEP_MS: u64 = 500;

/// Default NFS server port (IANA-assigned for NFSv4).
pub const NFS_DEFAULT_PORT: u16 = 2049;

/// Timeout for the NFS NULL RPC liveness probe (connect + read + write).
pub const NFS_PROBE_TIMEOUT_SECS: u64 = 2;

/// Maximum NFSv4.2 request size for channel negotiation (16MB data + 4KB header).
pub const NFS_MAX_REQUEST_SIZE: usize = 16 * 1024 * 1024 + 4096;

/// Maximum NFSv4.2 response size for channel negotiation (1MB).
pub const NFS_MAX_RESPONSE_SIZE: usize = 1024 * 1024;

/// Maximum file data size for krb5p compound RPC bypass (bytes).
///
/// The kernel's gss_krb5_unwrap produces garbled output when priv_bytes
/// (4-byte seq_num + compound_args) exceeds 3,952 bytes (247 x 16 AES blocks).
/// With ~260 bytes of non-data compound overhead, this limits write data to ~3,688
/// bytes. We use 3,584 (3.5KB) as a conservative threshold.
///
/// Files exceeding this are routed directly to VFS sendfile, avoiding the
/// failed-compound + session-recovery penalty (~25ms per file).
///
/// Empirical: priv_bytes=3,952 -> NFS4_OK; priv_bytes=3,964 -> NFS4ERR_BAD_STATEID.
/// GSS wrap overhead is constant at 72 bytes regardless of input size.
/// AUTH_SYS compounds of the same size succeed without error.
pub const KRB5P_MAX_WRITE_DATA: usize = 3584;

/// GSS wrap token overhead per compound RPC (RFC 4121 S4.2.6.2).
///
/// Breakdown:
/// - 16B: GSS token header (TOK_ID + Flags + Filler + EC + RR + SND_SEQ)
/// - 16B: AES confounder (prepended to plaintext before encryption)
/// - 12B: HMAC-SHA1-96 integrity check value
/// - ~28B: XDR alignment padding and GSS framing overhead
/// Total: ~72B per compound body
///
/// This overhead is already accounted for in KRB5P_MAX_WRITE_DATA (3584B),
/// which is empirically derived to stay safely below the 3952B AES-CTS
/// block boundary (247 x 16B AES blocks).
pub const GSS_WRAP_OVERHEAD_BYTES: usize = 72;

/// ALPN protocol identifier for RPC-over-TLS (RFC 9289 S7.2).
pub const NFS_TLS_ALPN: &[u8] = b"sunrpc";

/// Timeout for the TLS handshake after AUTH_TLS STARTTLS upgrade (seconds).
pub const NFS_TLS_HANDSHAKE_TIMEOUT_SECS: u64 = 10;

// --- I/O Operations ---

/// Deadline for io_uring completion poll before giving up on a single wait cycle.
pub const IO_URING_READABLE_TIMEOUT_MS: u64 = 100;

/// Minimum interval between repeated log messages during io_uring stall detection.
pub const LOG_THROTTLE_INTERVAL_SECS: u64 = 10;

// --- Sync / Tree Walking ---

/// Age cutoff for orphaned `.tmp.*` files during cleanup (seconds).
/// Files older than this are considered abandoned and removed.
pub const HOT_DIR_CUTOFF_SECS: u64 = 3600;

// --- Filesystem Ioctl Magic Numbers ---

/// FICLONE ioctl number for CoW reflink cloning.
pub const FICLONE_IOCTL: u64 = 0x40049409;
/// FS_IOC_SETFLAGS ioctl for setting filesystem flags (immutable, append-only).
pub const FS_IOC_SETFLAGS_IOCTL: u64 = 0x40086602;
/// XFS_IOC_EXCHANGE_RANGE ioctl for atomic file content exchange.
pub const XFS_IOC_EXCHANGE_RANGE: u64 = 0xC0385828;
/// btrfs filesystem magic number (from statfs).
pub const BTRFS_SUPER_MAGIC: u64 = 0x9123683E;
/// F2FS filesystem magic number (from statfs).
pub const F2FS_SUPER_MAGIC: u64 = 0xF2F52010;

// --- Content Verification ---

/// Sample size for head/tail content verification (64KB).
pub const CONTENT_VERIFY_SAMPLE_SIZE: usize = 65536;
/// Minimum file size before tail sampling is used during content verification (128KB).
pub const CONTENT_VERIFY_TAIL_THRESHOLD: usize = 131072;

// --- I/O Size Thresholds ---

/// Minimum hole size for FALLOC_FL_PUNCH_HOLE operations (16KB).
pub const MIN_HOLE_PUNCH_SIZE: u64 = 16 * 1024;
/// Headroom bytes reserved for FXAR restore disk space checks (10MB).
pub const FXAR_RESTORE_HEADROOM_BYTES: u64 = 10 * 1024 * 1024;

// --- Filesystem Geometry ---

/// Standard disk sector size (bytes). Used for sparse file detection
/// (`blocks * SECTOR_SIZE < file_size / 2`) and I/O alignment fallback.
pub const SECTOR_SIZE_BYTES: u64 = 512;

// --- copy_file_range ---

/// Maximum chunk size per `copy_file_range(2)` call (1 GiB).
/// Kernel may copy less; caller loops until complete.
pub const COPY_FILE_RANGE_CHUNK_SIZE: u64 = 1024 * 1024 * 1024;

// --- AI Preview / Truncation ---

/// Default character limit for chunk content previews stored in
/// `ChunkMeta`, pgvector `foxing_chunks.preview`, and SSE payloads.
pub const AI_CHUNK_PREVIEW_CHARS: usize = 200;

/// HNSW capacity growth increment when the index is full.
pub const AI_HNSW_CAPACITY_GROWTH_INCREMENT: usize = 1000;

// --- Daemon Housekeeping ---

/// Interval between target mount health checks in the hydration manager (seconds).
pub const MOUNT_HEALTH_CHECK_INTERVAL_SECS: u64 = 10;

/// SSE event stream poll sleep when no new events are available (milliseconds).
pub const SSE_POLL_INTERVAL_MS: u64 = 100;

/// Maximum dirty-range journal file size before the journal is discarded
/// and a full Merkle resync is triggered (bytes). 10 MiB.
pub const DIRTY_JOURNAL_MAX_BYTES: u64 = 10 * 1024 * 1024;

/// Batch buffer capacity for the hydration manager event loop.
pub const HYDRATION_BATCH_BUFFER_CAPACITY: usize = 100;

/// Minimum free bytes on target before fxcp sync aborts with an error (10 MiB).
pub const SYNC_MIN_FREE_BYTES: u64 = 10 * 1024 * 1024;

/// SMB/CIFS filesystem magic number (from statfs).
pub const SMB_SUPER_MAGIC: i64 = 0x517B;
/// CIFS filesystem magic number (from statfs).
pub const CIFS_MAGIC_NUMBER: i64 = 0xFF534D42_u32 as i64;

/// Hydration timeout floors for Network/NFS targets: (stall_secs, overall_secs, postcopy_secs).
pub const HYDRATION_TIMEOUT_FLOOR_NETWORK: (u64, u64, u64) = (60, 600, 300);
/// Hydration timeout floors for HDD targets: (stall_secs, overall_secs, postcopy_secs).
pub const HYDRATION_TIMEOUT_FLOOR_HDD: (u64, u64, u64) = (30, 300, 120);
/// Hydration timeout floors for SSD targets: (stall_secs, overall_secs, postcopy_secs).
pub const HYDRATION_TIMEOUT_FLOOR_SSD: (u64, u64, u64) = (15, 120, 60);
/// Hydration timeout floors for unknown/default targets: (stall_secs, overall_secs, postcopy_secs).
pub const HYDRATION_TIMEOUT_FLOOR_DEFAULT: (u64, u64, u64) = (10, 60, 30);

// --- FUSE Accelerator ---

/// Default metadata cache TTL (seconds) for the FUSE passthrough overlay.
/// StorageClassification-aware overrides apply at runtime: NFS 30s, HDD 60s, NVMe 5s.
/// Corresponds to `fuse_cache_ttl_secs` in `TargetConfig`.
pub const FUSE_CACHE_TTL_DEFAULT_SECS: u64 = 30;

// --- Fsync Latency Tracking ---

/// Default average fsync latency estimate for `FsyncLatencyTracker` (microseconds).
/// Corresponds to 1 second  --  conservative initial estimate for cold starts.
pub const FSYNC_LATENCY_DEFAULT_AVG_US: u64 = 1_000_000;

/// Default fsync latency deviation for `FsyncLatencyTracker` (microseconds).
/// Used in adaptive timeout calculation: timeout = avg + 4 x deviation.
pub const FSYNC_LATENCY_DEFAULT_DEVIATION_US: u64 = 500_000;

/// Maximum fsync latency estimate after timeout doubling (microseconds).
/// Caps `record_timeout()` to prevent runaway growth (30 seconds).
pub const FSYNC_LATENCY_MAX_US: u64 = 30_000_000;

/// Minimum adaptive fsync timeout (microseconds). Floor for `get_timeout()` clamp (5 seconds).
pub const FSYNC_TIMEOUT_MIN_US: u64 = 5_000_000;

/// Maximum adaptive fsync timeout (microseconds). Ceiling for `get_timeout()` clamp (60 seconds).
pub const FSYNC_TIMEOUT_MAX_US: u64 = 60_000_000;

// --- I/O Copy Strategy ---

/// Per-call chunk size for `sendfile(2)` in the copy-file helper (2 MiB).
/// Prevents a single sendfile from monopolizing the kernel for too long.
pub const SENDFILE_CHUNK_SIZE: u64 = 2 * 1024 * 1024;

/// Minimum file size to activate the NFS sendfile fast-path (64 KiB).
/// Below this, io_uring overhead is negligible and sendfile adds no benefit.
pub const NFS_SENDFILE_MIN_SIZE: u64 = 65_536;

/// File size boundary for copy strategy selection (64 KiB).
/// Files smaller than this use sendfile; larger files use io_uring pipeline.
pub const SMALL_FILE_THRESHOLD: u64 = 64 * 1024;

/// Read chunk size for stdin pipe mode (1 MiB).
/// Balances memory usage against syscall frequency for piped input.
pub const STDIN_CHUNK_SIZE: usize = 1024 * 1024;

/// Minimum page-cache residency ratio to trigger the cachestat sendfile fast-path.
/// At >=80% resident, sendfile outperforms io_uring for files in the decision zone.
pub const CACHE_RESIDENCY_SENDFILE_THRESHOLD: f64 = 0.80;

// --- Hashing ---

/// Default file-size threshold for lite (head+tail) hashing (128 KiB).
/// Files smaller than this get a full BLAKE3 hash; larger files use a
/// head+tail 4 KiB sample for fast change detection.
pub const LITE_HASH_DEFAULT_THRESHOLD: u64 = 128 * 1024;

/// Minimum file size for parallel BLAKE3 hashing via `update_rayon()` (1 MiB).
/// Below this threshold, single-threaded hashing is faster due to rayon overhead.
pub const RAYON_HASH_THRESHOLD: u64 = 1_048_576;

// --- NFS Client Extended ---

/// Maximum compound RPC byte budget before splitting into a new compound (800 KiB).
/// Keeps each compound well within the server's `ca_maxrequestsize` (~16 MiB).
pub const NFS_COMPOUND_BYTE_LIMIT: usize = 800 * 1024;

/// Estimated XDR header overhead per compound RPC (bytes).
/// Covers SEQUENCE, PUTFH root, and framing. Used as the initial byte accumulator.
pub const NFS_XDR_HEADER_OVERHEAD: usize = 512;

/// Estimated per-operation XDR overhead (bytes). Covers PUTFH + OPEN + WRITE +
/// CLOSE op headers and filehandle encoding for each file in a compound.
pub const NFS_XDR_PER_OP_OVERHEAD: usize = 256;

/// Requested `ca_maxoperations` in CREATE_SESSION. The server negotiates down
/// to its actual limit; this is the client's opening bid.
pub const NFS_CA_MAX_OPERATIONS: u32 = 64;

/// Initial `max_files_per_compound` for `CompoundSizeTuner` before AIMD adaptation.
pub const NFS_COMPOUND_TUNER_INITIAL_MAX_OPS: u32 = 64;

/// Start of the privileged port range for NFS source-port binding.
/// NFS servers with `sec=sys` may require connections from ports < 1024.
pub const NFS_PRIVILEGED_PORT_START: u16 = 900;

/// End (exclusive) of the privileged port range for NFS source-port binding.
pub const NFS_PRIVILEGED_PORT_END: u16 = 1024;

/// Initial capacity for the RPC reply buffer `Vec<u8>`.
/// Sized to hold a typical small-compound response without reallocation.
pub const NFS_REPLY_INITIAL_CAPACITY: usize = 4096;

/// IANA-assigned NFS/RDMA port (RFC 8267).
pub const NFS_RDMA_PORT: u16 = 20049;

// --- RDMA Transport ---

/// Maximum inline NFS body size for RDMA Send/Recv operations (bytes).
/// Must fit within `RDMA_MAX_INLINE` = body + header + padding.
pub const RDMA_MAX_INLINE_BODY: usize = 4096;

/// Padding/overhead added to inline body for RDMA message framing (bytes).
pub const RDMA_INLINE_PADDING: usize = 64;

/// Completion queue depth for RDMA ibverbs CQ creation.
pub const RDMA_CQ_DEPTH: i32 = 16;

/// Timeout for RDMA CM address/route resolution (milliseconds).
pub const RDMA_RESOLVE_TIMEOUT_MS: i32 = 5000;

/// Maximum CQ poll spins before declaring an RPC timeout.
/// At ~10ns per spin, 10M spins ~= 100ms busy-wait ceiling.
pub const RDMA_CQ_POLL_MAX_SPINS: u64 = 10_000_000;

/// Fallback RPC timeout for RDMA operations (seconds).
/// Used when CQ polling exhausts `RDMA_CQ_POLL_MAX_SPINS` without completion.
pub const RDMA_RPC_TIMEOUT_SECS: u64 = 30;

// --- Governor Extended ---

/// PSI relaxation multiplier for hypervisor/container environments.
/// Hypervisor-reported PSI values are inflated by host contention;
/// this multiplier relaxes the threshold to avoid false throttling.
pub const GOVERNOR_HYPERVISOR_PSI_MULTIPLIER: f64 = 5.0;

/// Total operations before the governor auto-resets its failure window.
/// Prevents transient error bursts from permanently marking a target unhealthy.
pub const GOVERNOR_FAILURE_WINDOW_RESET_OPS: u64 = 1000;

// --- WAL (Write-Ahead Log) ---

/// Initial token count for WAL batch admission control.
/// Each write operation consumes a token; tokens regenerate on flush.
pub const WAL_BATCH_TOKENS_INITIAL: usize = 1000;

/// Maximum concurrent writers before the WAL engages barrier mode.
/// Beyond this threshold, new writers block until the current batch completes.
pub const WAL_MAX_WRITERS_BEFORE_BARRIER: usize = 10;

/// Sequence number proximity to `u64::MAX` that triggers an overflow reset.
/// When `global_seq >= u64::MAX - threshold`, the sequence resets to 1.
pub const WAL_SEQUENCE_OVERFLOW_THRESHOLD: u64 = 10_000;

// --- Sync / Progress Reporting ---

/// Progress reporting interval in JSON output mode (milliseconds).
pub const PROGRESS_INTERVAL_JSON_MS: u64 = 1000;

/// Progress reporting interval in human-readable output mode (milliseconds).
pub const PROGRESS_INTERVAL_HUMAN_MS: u64 = 200;

/// io_uring submission queue depth for fxcp CLI tree-copy operations.
pub const FXCP_IO_URING_SQ_DEPTH: u32 = 256;

/// Buffer pool count for fxcp CLI tree-copy io_uring pipeline.
pub const FXCP_BUFFER_POOL_COUNT: usize = 64;

// --- NFS Writer / BatchTuner ---

/// Channel capacity for the NFS writer task's job queue.
/// Workers submit `NfsWriteJob` entries; the writer drains in batch cycles.
pub const NFS_WRITER_CHANNEL_CAPACITY: usize = 1000;

/// Maximum files per compound RPC for RDMA transport.
/// RDMA_MAX_INLINE=4188B  --  multi-file compounds exceed inline capacity.
pub const NFS_RDMA_MAX_BATCH: usize = 1;

/// Maximum compound byte budget for RDMA transport (bytes).
/// Sized to fit within RDMA_MAX_INLINE (4188B) with header overhead.
pub const NFS_RDMA_MAX_BATCH_BYTES: usize = 3500;

/// Maximum files per compound RPC for krb5p transport.
/// Reduced to avoid accumulating large batches that serialize into
/// many single-file compounds wastefully under AES encryption.
pub const NFS_KRB5P_MAX_BATCH: usize = 2;

/// Maximum files per compound RPC for TCP/TLS AUTH_SYS transport.
pub const NFS_TCP_MAX_BATCH: usize = 200;

/// Maximum compound byte budget for TCP/TLS transport (8 MiB).
pub const NFS_TCP_MAX_BATCH_BYTES: usize = 8 * 1024 * 1024;

/// EWMA smoothing factor for BatchTuner queue depth and RTT tracking.
pub const NFS_BATCH_EWMA_ALPHA: f64 = 0.2;

/// Queue pressure ratio above which BatchTuner increases batch size.
pub const NFS_BATCH_PRESSURE_HIGH: f64 = 0.8;

/// Queue pressure ratio below which BatchTuner decreases batch size.
pub const NFS_BATCH_PRESSURE_LOW: f64 = 0.2;

/// Additive increase step for BatchTuner AIMD batch size growth.
pub const NFS_BATCH_ADDITIVE_INCREASE: usize = 5;

/// Multiplicative decrease factor for BatchTuner AIMD batch size reduction.
pub const NFS_BATCH_MULTIPLICATIVE_DECREASE: f64 = 0.75;

/// Max files per batch_read_head compound (SEQUENCE+PUTFH+[LOOKUP+READ]×N).
/// Conservative for 8KB data responses (24KB reply per compound).
pub const NFS_BATCH_READ_HEAD_FILES_PER_COMPOUND: usize = 3;

// --- Daemon Lifecycle ---

/// Grace period for worker tasks to complete during daemon shutdown (seconds).
pub const SHUTDOWN_DEADLINE_SECS: u64 = 10;

/// TCP listen backlog for the Prometheus/API server socket.
pub const API_LISTEN_BACKLOG: u32 = 128;

/// Channel capacity for TUI event and command channels.
pub const TUI_CHANNEL_CAPACITY: usize = 32;

/// Epoch offset for full-scan debounce: `last_full_scan` is initialized to
/// `now - offset` so the first health-check-triggered scan fires immediately.
pub const FULL_SCAN_EPOCH_OFFSET_SECS: u64 = 60;

/// Timeout for workers to acknowledge a drain barrier during recovery (seconds).
pub const DRAIN_ACK_TIMEOUT_SECS: u64 = 30;

/// Timeout for a targeted recovery scan to complete (seconds).
pub const RECOVERY_SCAN_TIMEOUT_SECS: u64 = 120;

// --- SSE / EventBus ---

/// Maximum entries pulled from the EventBus per SSE poll cycle.
pub const SSE_PULL_BATCH_SIZE: usize = 64;

/// Interval between SSE keepalive comments to prevent proxy/client timeouts (seconds).
pub const SSE_KEEPALIVE_INTERVAL_SECS: u64 = 15;

/// Broadcast channel capacity for EventBus change notifications.
pub const EVENTBUS_NOTIFY_CHANNEL_CAPACITY: usize = 64;

// --- Stratis Integration ---

/// Stratis pool free-space percentage that triggers critical warnings and
/// emergency version pruning to reclaim capacity.
pub const STRATIS_POOL_CRITICAL_PCT: f64 = 5.0;

/// Stratis pool free-space percentage that triggers low-space warnings.
pub const STRATIS_POOL_LOW_PCT: f64 = 10.0;

/// Interval between Stratis pool capacity checks via D-Bus (seconds).
pub const STRATIS_MONITOR_INTERVAL_SECS: u64 = 30;

// --- AI Sidecar Confidence ---

/// Confidence score for raw/unstructured sidecar fallback matches.
pub const AI_SIDECAR_RAW_CONFIDENCE: f32 = 0.15;

/// Confidence score for structured key-value sidecar matches.
pub const AI_SIDECAR_KV_CONFIDENCE: f32 = 0.60;

/// Confidence score for XML-structured sidecar matches (highest structural signal).
pub const AI_SIDECAR_XML_CONFIDENCE: f32 = 0.95;

/// Confidence score for exact filename-stem sidecar matches.
pub const AI_SIDECAR_EXACT_CONFIDENCE: f32 = 0.85;

/// Jaro-Winkler similarity threshold for fuzzy sidecar filename matching.
pub const AI_SIDECAR_FUZZY_THRESHOLD: f32 = 0.80;

/// Confidence multiplier applied to Jaro-Winkler score for fuzzy sidecar matches.
pub const AI_SIDECAR_FUZZY_CONFIDENCE_MULTIPLIER: f32 = 0.70;

// --- AI Media Association ---

/// Confidence score for exact stem-match media-to-parent file association.
pub const AI_MEDIA_ASSOC_EXACT_CONFIDENCE: f32 = 0.92;

/// Jaro-Winkler similarity threshold for fuzzy media file association.
pub const AI_MEDIA_ASSOC_FUZZY_THRESHOLD: f32 = 0.85;

/// Confidence multiplier for fuzzy media file association scores.
pub const AI_MEDIA_ASSOC_FUZZY_CONFIDENCE_MULTIPLIER: f32 = 0.85;

// --- AI Search / Embedding ---

/// Reciprocal Rank Fusion (RRF) parameter `k` for hybrid search scoring.
/// Higher k smooths rank differences; k=60 is the standard default (Cormack et al.).
pub const AI_RRF_K: f64 = 60.0;

/// Approximate characters-per-token ratio for LLM token budget estimation.
/// Used to convert available token budget into a character limit for content truncation.
pub const AI_TOKENS_TO_CHARS_RATIO: f64 = 3.5;

/// Default embedding vector dimensions used when the model path is unknown or empty (HTTP-only mode).
///
/// **v0.10.0-dev reference value: 768** — set to match the production endpoint used during
/// 0.10-dev development: Granite Embedding 278M multilingual on awa:8001 (768-dim vectors).
///
/// Operators using a different model MUST set this to match their endpoint:
///   - Granite Embedding 278M / nomic-embed-text / BGE-base → 768
///   - all-MiniLM-L6-v2 / BGE-small / GTE-small → 384
///   - stella_en_400M / jina-embeddings-v3 → 1024
///
/// Mismatch between this constant and the actual endpoint causes EmbeddingIndex (local usearch HNSW)
/// to initialize with the wrong dimension, silently producing incorrect similarity scores.
/// The HTTP embedding engine auto-detects dimensions from the endpoint probe and is unaffected,
/// but the local HNSW index uses this constant as its fixed dimension at creation time.
///
/// Value 768 matches the Granite Embedding 278M production endpoint (awa:8001) used in v0.10.0-dev.
/// Operators using a different model (e.g. all-MiniLM-L6-v2 at 384-dim) must ensure their model
/// path is recognized by `fxcp-ai/src/model_registry.rs` so the correct dimension is returned.
pub const AI_DEFAULT_EMBEDDING_DIMS: usize = 768;

/// Maximum ORT intra-op parallelism threads. Caps thread count to avoid
/// over-subscribing CPU cores on high-core-count machines.
pub const AI_ORT_MAX_INTRA_THREADS: usize = 8;

// --- Hydration Worker ---

/// io_uring ring size per hydration worker.
/// Caps memory usage (e.g. 32 x 4MB = 128MB per worker instead of unbounded).
pub const HYDRATION_RING_BUFFER_CAP: u64 = 32;

/// Buffer count when optimal allocation fails (16 x 4MB = 64MB).
pub const HYDRATION_FALLBACK_BUFFER_COUNT: usize = 16;

/// Fallback chunk size in bytes when optimal allocation fails (4 MiB).
pub const HYDRATION_FALLBACK_CHUNK_SIZE: usize = 4 * 1024 * 1024;

/// Buffer pool capacity divisor when entering yield mode.
pub const HYDRATION_YIELD_MODE_BUFFER_DIVISOR: usize = 5;

/// Multiplier applied to `global_buffer_limit` to derive the storm threshold.
pub const HYDRATION_STORM_THRESHOLD_MULTIPLIER: u64 = 20;

/// Hysteresis multiplier for transitioning from primary -> yield mode.
pub const HYDRATION_HYSTERESIS_UP: f64 = 1.1;

/// Hysteresis multiplier for transitioning from yield -> primary mode.
pub const HYDRATION_HYSTERESIS_DOWN: f64 = 0.9;

/// Fraction of global buffer budget allocated to hydration in yield mode.
pub const HYDRATION_MEMORY_SHARE_YIELD: f64 = 0.20;

/// Fraction of global buffer budget allocated to hydration in primary mode.
pub const HYDRATION_MEMORY_SHARE_PRIMARY: f64 = 0.70;

/// Retry iterations during backpressure stall before aborting scan.
pub const HYDRATION_BACKPRESSURE_SLEEP_ITERATIONS: usize = 5;

/// Sleep between backpressure stall retries (milliseconds).
pub const HYDRATION_BACKPRESSURE_SLEEP_MS: u64 = 100;

/// Sleep at low watermark during scan (milliseconds).
pub const HYDRATION_LOW_WATERMARK_SLEEP_MS: u64 = 20;

/// Extra ring slots added beyond buffers_per_ring for safety margin.
pub const HYDRATION_IOURING_RING_PADDING: usize = 8;

/// Interval between allocation rechecks in hydration worker loop (seconds).
pub const HYDRATION_ALLOC_RECHECK_INTERVAL_SECS: u64 = 5;

/// Log worker liveness every N processed jobs.
pub const HYDRATION_WORKER_LOG_INTERVAL: u64 = 100;

/// io_uring ring size for dirty-range replay operations.
pub const HYDRATION_DIRTY_RANGE_RING_SIZE: u32 = 64;

/// Bytes to read for head-hash content verification in hydration sync_file_needed.
/// 8KB covers the observed corruption pattern (zeros starting at byte 2).
pub const HYDRATION_HEAD_VERIFY_BYTES: usize = 8192;

// --- Daemon Orchestration ---

/// Maximum targets tracked by TuningBoardManager.
pub const TUNING_BOARD_MANAGER_CAPACITY: usize = 64;

/// Minimum entries in the identity map after clamping.
pub const IDENTITY_MAP_MIN_ENTRIES: usize = 10_000;

/// Maximum entries in the identity map after clamping.
pub const IDENTITY_MAP_MAX_ENTRIES: usize = 1_000_000;

/// LRU size divisor: lru_size = max_entries / this.
pub const IDENTITY_LRU_SIZE_DIVISOR: usize = 10;

/// SystemGovernor periodic update interval (seconds).
pub const SYSTEM_GOVERNOR_UPDATE_INTERVAL_SECS: u64 = 5;

/// TuningBoardManager global consensus interval (seconds).
pub const TUNING_BOARD_CONSENSUS_INTERVAL_SECS: u64 = 5;

/// Broadcast channel capacity for barrier coordination.
pub const BARRIER_BROADCAST_CHANNEL_CAPACITY: usize = 16;

/// NFS client pool session count.
pub const NFS_CLIENT_POOL_SIZE: usize = 4;

/// Emergency pressure threshold for AI enrichment skip.
pub const GOVERNOR_EMERGENCY_PRESSURE_THRESHOLD: f64 = 0.9;

/// Throttle pressure threshold for AI enrichment delay.
pub const GOVERNOR_THROTTLE_PRESSURE_THRESHOLD: f64 = 0.5;

// --- Daemon Lifecycle ---

/// HTTP probe timeout for `is_daemon_running` liveness check (seconds).
pub const DAEMON_PROBE_TIMEOUT_SECS: u64 = 2;

/// Remote monitor poll interval for status/metrics fetching (milliseconds).
pub const MONITOR_POLL_INTERVAL_MS: u64 = 500;

/// Maximum versions shown in `snapshot list` output.
pub const VERSION_LIST_DISPLAY_LIMIT: usize = 20;

/// Timeout waiting for BPF probes to attach at daemon startup (seconds).
pub const BPF_READY_TIMEOUT_SECS: u64 = 60;

/// One-shot sync mode hydration completion check interval (milliseconds).
pub const ONE_SHOT_CHECK_INTERVAL_MS: u64 = 500;

// --- BPF Dedup ---

/// Dedup window for kprobe/fentry/LSM duplicate events (milliseconds).
pub const BPF_DEDUP_WINDOW_MS: u64 = 5;

/// How many dedup windows to retain before evicting (cleanup keeps Nx window).
pub const BPF_DEDUP_RETAIN_FACTOR: u32 = 10;

/// Periodic cleanup interval for the dedup cache (every N events).
pub const BPF_DEDUP_CLEANUP_INTERVAL: u64 = 1000;

// --- Reorder / Coalescer Thresholds ---

/// Pending event count that triggers panic-mode forced delivery in ReorderBuffer.
pub const REORDER_PENDING_PANIC_COUNT: usize = 1000;

/// Pending event count that triggers warning-level stall timeout in ReorderBuffer.
pub const REORDER_PENDING_WARN_COUNT: usize = 100;

/// Stall timeout under pressure conditions in ReorderBuffer (milliseconds).
pub const REORDER_PRESSURE_STALL_TIMEOUT_MS: u64 = 10;

/// Initial Vec capacity for EventBatch in the Coalescer.
pub const COALESCER_BATCH_INITIAL_CAPACITY: usize = 128;

// --- AI Sidecar Discovery ---

/// Minimum files in a directory before sidecar detection activates.
pub const AI_SIDECAR_MIN_DIR_FILES: usize = 3;

/// Minimum fraction (0.0–1.0) of files sharing the dominant extension before
/// `format_directory_context()` emits a directory context string.
/// Below this threshold the directory is too heterogeneous — context would be
/// misleading noise rather than useful signal for the LLM.
/// Example: 10 files, 3 .gg + 2 .zip + 2 .png + 3 others → dominant = 30% → suppressed.
///          100 files, 85 .smc + 10 .txt + 5 .xml → dominant = 85% → emitted.
pub const AI_DIR_CONTEXT_MIN_DOMINANT_FRACTION: f64 = 0.50;

/// Raw fallback snippet truncation (chars).
pub const AI_SIDECAR_RAW_SNIPPET_CHARS: usize = 500;

/// XML match snippet truncation (chars).
pub const AI_SIDECAR_XML_SNIPPET_CHARS: usize = 1000;

/// Minimum KV-style lines to classify a sidecar as structured.
pub const AI_SIDECAR_KV_MIN_LINES: usize = 3;

/// Maximum KV-style lines to extract from a structured sidecar.
pub const AI_SIDECAR_KV_MAX_LINES: usize = 10;

/// Context lines before an exact filename-stem match.
pub const AI_SIDECAR_EXACT_CONTEXT_BEFORE: usize = 5;

/// Context lines after an exact filename-stem match (i + N).
pub const AI_SIDECAR_EXACT_CONTEXT_AFTER: usize = 6;

/// Exact match snippet truncation (chars).
pub const AI_SIDECAR_EXACT_SNIPPET_CHARS: usize = 800;

/// Context lines before a fuzzy filename-stem match.
pub const AI_SIDECAR_FUZZY_CONTEXT_BEFORE: usize = 3;

/// Context lines after a fuzzy filename-stem match (idx + N).
pub const AI_SIDECAR_FUZZY_CONTEXT_AFTER: usize = 4;

/// Fuzzy match snippet truncation (chars).
pub const AI_SIDECAR_FUZZY_SNIPPET_CHARS: usize = 600;

/// Maximum ancestor directory depth for gamelist.xml walk-up discovery.
pub const AI_SIDECAR_ANCESTOR_MAX_DEPTH: usize = 4;

// --- AI Enrichment Extended ---

/// Hard cap on prompt chars for deep effort with probed context (chars).
pub const AI_DEEP_MAX_PROMPT_CHARS_CAP: usize = 200_000;

/// RPM sliding window duration for LLM rate limiting (seconds).
pub const AI_LLM_RPM_WINDOW_SECS: u64 = 60;

/// Maximum multiplier for exponential backoff on empty AI sweeps.
/// When a periodic sweep finds zero files needing work, the interval doubles
/// (up to base_interval × this cap). Resets to base on any non-empty sweep.
pub const AI_SWEEP_MAX_BACKOFF_MULTIPLIER: u32 = 8;

// --- AI pgvector Reconnect ---

/// Base interval for pgvector reconnection attempts when initial connection fails (seconds).
pub const AI_PGVECTOR_RECONNECT_BASE_SECS: u64 = 60;

/// Maximum interval for pgvector reconnection with exponential backoff cap (seconds).
pub const AI_PGVECTOR_RECONNECT_MAX_SECS: u64 = 300;

/// Minimum cosine similarity for taxonomy_nearest() pgvector HNSW fallback to populate PipelineContext.
pub const AI_TAXONOMY_NEAREST_THRESHOLD: f32 = 0.70;

/// CID pull-through mode: accept enrichment only when stored effort >= requested effort.
pub const AI_PGVECTOR_PULL_MODE_OPPORTUNISTIC: &str = "opportunistic";

/// CID pull-through mode: accept any enrichment for matched CIDs, never call LLM.
pub const AI_PGVECTOR_PULL_MODE_AUTHORITATIVE: &str = "authoritative";

// --- AI pgvector Sync Extended ---

/// Default maximum pgvector queue depth before back-pressure.
pub const AI_PGVECTOR_MAX_QUEUE_DEPTH: usize = 10_000;

/// Default flush batch size for pgvector sync.
pub const AI_PGVECTOR_FLUSH_BATCH_SIZE: usize = 5000;

/// SQL parameter limit chunk size for pgvector batch inserts.
pub const AI_PGVECTOR_CHUNK_SUB_BATCH: usize = 1000;

/// Maximum chunk content previews returned per file from pgvector.
pub const AI_PGVECTOR_MAX_CHUNK_PREVIEWS: usize = 20;

// --- AI Binary Extraction ---

/// Hard deadline for binary metadata extraction (milliseconds).
pub const AI_BINARY_DEADLINE_MS: u64 = 10;

/// Maximum printable strings to extract from binary `.rodata`/`.rdata`.
pub const AI_BINARY_MAX_STRINGS: usize = 50;

/// Minimum string length for binary string extraction.
pub const AI_BINARY_MIN_STRING_LEN: usize = 5;

/// Maximum symbols (imports + exports) before truncating.
pub const AI_BINARY_MAX_SYMBOLS: usize = 100;

/// Bytes of entry-point code to disassemble via capstone.
pub const AI_BINARY_CAPSTONE_PEEK_BYTES: usize = 256;

// --- AI Container RAG ---

/// Maximum requires entries displayed in container sidecar context.
pub const AI_CONTAINER_MAX_REQUIRES_DISPLAY: usize = 10;

/// Maximum file entries displayed in container sidecar context.
pub const AI_CONTAINER_MAX_FILES_DISPLAY: usize = 15;

/// Maximum requires to extract from RPM metadata.
pub const AI_CONTAINER_MAX_REQUIRES: usize = 20;

/// Maximum file entries to extract from RPM metadata.
pub const AI_CONTAINER_MAX_FILE_ENTRIES: usize = 20;

/// Maximum OCI manifest layers to extract.
pub const AI_CONTAINER_MAX_OCI_LAYERS: usize = 10;

// --- Identity / Watch ---

/// Yield to scheduler every N entries during identity scan.
pub const IDENTITY_SCAN_YIELD_INTERVAL: usize = 100;

/// Sleep every N entries during identity scan for throttling.
pub const IDENTITY_SCAN_SLEEP_INTERVAL: usize = 1000;

/// Sleep duration during identity scan throttling (microseconds).
pub const IDENTITY_SCAN_SLEEP_US: u64 = 50;

// --- TUI ---

/// Bandwidth history ring buffer capacity for TUI sparkline.
pub const TUI_BANDWIDTH_HISTORY_CAPACITY: usize = 60;

/// Latency history ring buffer capacity for TUI sparkline.
pub const TUI_LATENCY_HISTORY_CAPACITY: usize = 60;

/// Buffer utilization history capacity for TUI sparkline.
pub const TUI_BUFFER_UTIL_HISTORY_CAPACITY: usize = 100;

/// Log buffer capacity for TUI log panel.
pub const TUI_LOG_BUFFER_CAPACITY: usize = 1000;

/// TUI tick/refresh interval (milliseconds).
pub const TUI_TICK_INTERVAL_MS: u64 = 500;

/// When a file's hole ratio (bytes in holes / total bytes) exceeds this threshold,
/// skip fallocate pre-allocation. The io_uring pipeline will punch holes as needed.
/// This avoids the wasteful allocate-then-punch round-trip for borderline-sparse files.
pub const SPARSE_HOLE_RATIO_SKIP_THRESHOLD: f64 = 0.5;

// --- NFS NSS / Hostname / XDR Encoder Capacities ---

/// NSS getpwuid_r / getgrgid_r username/group lookup buffer size.
pub const NFS_NSS_BUFFER_SIZE: usize = 1024;

/// Hostname buffer for gethostname() syscall.
pub const NFS_HOSTNAME_BUFFER_SIZE: usize = 256;

/// Initial XDR encoder capacity for compound RPC body.
pub const NFS_XDR_ENCODER_BODY_CAPACITY: usize = 4096;

/// Initial XDR encoder capacity for small RPC messages (EXCHANGE_ID, CREATE_SESSION).
pub const NFS_XDR_ENCODER_SMALL_CAPACITY: usize = 512;

/// Initial XDR encoder capacity for GSS RPC header.
pub const NFS_XDR_ENCODER_TINY_CAPACITY: usize = 256;

/// Number of grace period retries for NFS WRITE operations.
pub const NFS_GRACE_RETRY_COUNT: usize = 3;

// --- Similarity / Delta Encoding ---

/// Minimum data length in bytes for TLSH computation.
pub const TLSH_MIN_DATA_SIZE: usize = 50;

/// Entropy threshold above which TLSH is skipped (encrypted/compressed data).
pub const TLSH_ENTROPY_SKIP_THRESHOLD: f32 = 7.9;

/// Maximum input size for delta encoding (64KB).
pub const DELTA_MAX_INPUT_SIZE: usize = 65_536;

/// Minimum match length for a delta Copy operation.
pub const DELTA_MIN_MATCH_LEN: usize = 8;

/// Match length considered "good enough" to stop early search in delta encoding.
pub const DELTA_GOOD_MATCH_LEN: usize = 256;

// --- Chunker ---

/// Maximum input size for the chunk_reader function (16MB).
pub const CHUNK_READER_MAX_INPUT: usize = 16 * 1024 * 1024;

/// Read buffer size for chunk_reader.
pub const CHUNK_READER_READ_BUFFER_SIZE: usize = 8192;

// --- BufferPool ---

/// Maximum number of registered buffers in a BufferPool.
pub const BUFFER_POOL_MAX_REGISTERED_BUFFERS: u32 = 65535;

// --- Timers / Poll Intervals ---

/// Poll sleep interval for version index scan (milliseconds).
pub const VERSION_SCAN_POLL_INTERVAL_MS: u64 = 100;

/// TUI browser event poll interval (milliseconds).
pub const BROWSER_EVENT_POLL_INTERVAL_MS: u64 = 100;

/// Minimum Kerberos ticket remaining lifetime before renewal (seconds).
pub const KRB5_TICKET_MIN_REMAINING_SECS: u64 = 60;

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
    use super::*;

    /// Verify effort-tier constants maintain strict ordering.
    /// Quick < Balanced < Deep for content, prompt, and preview char limits.
    #[test]
    fn test_constants_ordering_invariants() {
        // Content char limits must increase by effort level
        assert!(
            AI_QUICK_MAX_CONTENT_CHARS < AI_BALANCED_MAX_CONTENT_CHARS,
            "QUICK ({}) must be < BALANCED ({})",
            AI_QUICK_MAX_CONTENT_CHARS,
            AI_BALANCED_MAX_CONTENT_CHARS
        );
        assert!(
            AI_BALANCED_MAX_CONTENT_CHARS < AI_DEEP_MAX_CONTENT_CHARS,
            "BALANCED ({}) must be < DEEP ({})",
            AI_BALANCED_MAX_CONTENT_CHARS,
            AI_DEEP_MAX_CONTENT_CHARS
        );

        // Prompt char limits must increase by effort level
        assert!(
            AI_QUICK_MAX_PROMPT_CHARS < AI_BALANCED_MAX_PROMPT_CHARS,
            "QUICK prompt ({}) must be < BALANCED ({})",
            AI_QUICK_MAX_PROMPT_CHARS,
            AI_BALANCED_MAX_PROMPT_CHARS
        );
        assert!(
            AI_BALANCED_MAX_PROMPT_CHARS < AI_DEEP_MAX_PROMPT_CHARS,
            "BALANCED prompt ({}) must be < DEEP ({})",
            AI_BALANCED_MAX_PROMPT_CHARS,
            AI_DEEP_MAX_PROMPT_CHARS
        );

        // Preview char limits must increase by effort level
        assert!(
            AI_QUICK_MAX_PREVIEW_CHARS < AI_BALANCED_MAX_PREVIEW_CHARS,
            "QUICK preview ({}) must be < BALANCED ({})",
            AI_QUICK_MAX_PREVIEW_CHARS,
            AI_BALANCED_MAX_PREVIEW_CHARS
        );
        assert!(
            AI_BALANCED_MAX_PREVIEW_CHARS < AI_DEEP_MAX_PREVIEW_CHARS,
            "BALANCED preview ({}) must be < DEEP ({})",
            AI_BALANCED_MAX_PREVIEW_CHARS,
            AI_DEEP_MAX_PREVIEW_CHARS
        );

        // Embed byte cap must be positive and reasonable
        assert!(AI_MAX_EMBED_BYTES > 0);
        assert!(AI_MAX_EMBED_BYTES <= 10 * 1024 * 1024); // <= 10 MiB sanity cap
    }
}