Struct CompilePolicy 

pub struct CompilePolicy {

    pub response_reserve_tokens: u64,
    pub near_dup_dedup: bool,
    pub disabled_rules: Vec<String>,
    pub chunk: ChunkPolicy,
    pub record_events: bool,
    pub store_sources: bool,
    pub source_ttl_seconds: Option<u64>,
    pub event_ttl_seconds: Option<u64>,
    pub pricing: Option<PricingTable>,
    pub importance: ImportanceWeights,
    pub normalize_log_timestamps: bool,
    pub ids_as_strings: bool,
    pub slim_response: bool,
}

Tuning knobs of one compilation. Default is the recommended profile.

Fields

response_reserve_tokens: u64

Tokens kept aside for the model’s answer; the compiler packs into token_budget − response_reserve_tokens. Default 0: the caller knows their generation length, the compiler does not guess it.

near_dup_dedup: bool

Collapse near-duplicates (case/whitespace variants) in addition to exact duplicates. Default true.

disabled_rules: Vec<String>

Rule ids to disable (e.g. "abstract.log_dedup"). Disabled rules are skipped during classification; their fragments fall through to the next matching rule.

chunk: ChunkPolicy

How oversized fragments are split before packing. Only ChunkPolicy::max_chunk_bytes and ChunkPolicy::boundary apply here — the compiler forces overlap_bytes to 0, since it emits pieces by concatenation and an overlap prefix would duplicate content reported as verbatim. overlap_bytes is honoured only by the standalone crate::context::chunk::chunk_text API.

record_events: bool

Memory bridge only: record a compilation event (metadata and hashes, never fragment content) so savings stay aggregatable. Default true; set false to opt out entirely.

store_sources: bool

Memory bridge only: store each distinct fragment’s original (as an internal system fact, invisible to normal recall) so its ctx://source/<hash> handle round-trips. Default true.

source_ttl_seconds: Option<u64>

TTL applied to stored sources (None keeps them until forgotten).

event_ttl_seconds: Option<u64>

TTL applied to compilation events (None keeps them).

pricing: Option<PricingTable>

Caller-supplied pricing table so the insights also report the estimated cost avoided for super::model::CompileRequest::target_model — the wire channel for cost accounting (MCP and the bindings cannot reach the Rust-only super::ContextCompiler::with_pricing builder). Takes precedence over a builder-injected table. None (default) reports tokens only.

importance: ImportanceWeights

Memory bridge only: usage-driven importance blend over the pulled memories (RL confidence + batch-relative recency). The struct-level #[serde(default)] keeps 0.8.0 requests wire-compatible.

normalize_log_timestamps: bool

Opt-in, deterministic: before abstract.log_dedup groups a kind = "log" fragment’s repeated lines, mask each line’s volatile prefix (ISO/syslog timestamps, bracketed hex/pid counters) with fixed patterns — never a caller-supplied regex, so the collapse stays reproducible — so lines identical modulo timestamp collapse into one annotated line instead of surviving as distinct entries. The emitted line is still the first occurrence’s exact bytes; only the grouping key changes. Default false: masking is opt-in because it changes what “duplicate” means for logs, so callers who rely on the previous byte-exact grouping keep it unless they ask. See the crate README’s “Normalizing timestamped logs” section for the exact patterns.

ids_as_strings: bool

Wire-compat opt-in for the MCP context tools (compile_context, explain_compilation): when true, every super::wire::ID_KEYS field of the RESPONSE (fragment_id, content_hash, memory_id, fragment_ids) is rewritten into its decimal-string form, through the exact same tree walk the Node and WASM bindings already apply on every response (super::wire::stringify_id_fields). A raw MCP client — one that talks JSON-RPC directly, without either binding — parses ids as JS numbers (IEEE-754 doubles), which silently lose precision above 2^53; string ids round-trip exactly. Default false: existing MCP clients keep today’s byte-identical numeric response unless they opt in.

slim_response: bool

Quick win (V2a-2): when true, sections and decisions are emptied out of the response after compilation — content, insights, risk, warnings, sources, and retrieval_handles are unaffected. The full audit trail (sections/decisions) is still recoverable: re-compile the same request without slim_response (compilation is deterministic, so nothing is lost, only not sent this time). Default false.

Trait Implementations

impl Clone for CompilePolicy

fn clone(&self) -> CompilePolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompilePolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CompilePolicy

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompilePolicy

where CompilePolicy: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for CompilePolicy

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for CompilePolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.