config

config

Configuration loading, hardware detection, and engine recommendation.

User configuration lives at ~/.diapason/config.toml. load_config() detects hardware, fills sensible defaults, then overlays any user overrides found in the TOML file.

Classes

ConfigurationError

Bases: RuntimeError

Raised when the resolved home directory would violate isolation guarantees.

GpuInfo dataclass

GpuInfo(
    vendor: str = "",
    name: str = "",
    vram_gb: float = 0.0,
    compute_capability: str = "",
    count: int = 0,
)

Detected GPU metadata.

HardwareInfo dataclass

HardwareInfo(
    platform: str = "",
    cpu_brand: str = "",
    cpu_count: int = 0,
    ram_gb: float = 0.0,
    gpu: Optional[GpuInfo] = None,
)

Detected system hardware.

OllamaEngineConfig dataclass

OllamaEngineConfig(
    host: str = "",
    keep_alive: str = "30m",
    timeout_s: float = 300.0,
)

Per-engine config for Ollama.

VLLMEngineConfig dataclass

VLLMEngineConfig(host: str = 'http://localhost:8000')

Per-engine config for vLLM.

SGLangEngineConfig dataclass

SGLangEngineConfig(host: str = 'http://localhost:30000')

Per-engine config for SGLang.

LlamaCppEngineConfig dataclass

LlamaCppEngineConfig(
    host: str = "http://localhost:8080",
    binary_path: str = "",
)

Per-engine config for llama.cpp.

MLXEngineConfig dataclass

MLXEngineConfig(host: str = 'http://localhost:8080')

Per-engine config for MLX.

LMStudioEngineConfig dataclass

LMStudioEngineConfig(host: str = 'http://localhost:1234')

Per-engine config for LM Studio.

ExoEngineConfig dataclass

ExoEngineConfig(host: str = 'http://localhost:52415')

Per-engine config for Exo.

NexaEngineConfig dataclass

NexaEngineConfig(
    host: str = "http://localhost:18181", device: str = ""
)

Per-engine config for Nexa.

UzuEngineConfig dataclass

UzuEngineConfig(host: str = 'http://localhost:8000')

Per-engine config for Uzu.

AppleFmEngineConfig dataclass

AppleFmEngineConfig(host: str = 'http://localhost:8079')

Per-engine config for Apple Foundation Models.

GemmaCppEngineConfig dataclass

GemmaCppEngineConfig(
    model_path: str = "",
    tokenizer_path: str = "",
    model_type: str = "",
    num_threads: int = 0,
)

Per-engine config for gemma.cpp.

LemonadeEngineConfig dataclass

LemonadeEngineConfig(host: str = 'http://localhost:13305')

Per-engine config for Lemonade.

EngineConfig dataclass

EngineConfig(
    default: str = "ollama",
    ollama: OllamaEngineConfig = OllamaEngineConfig(),
    vllm: VLLMEngineConfig = VLLMEngineConfig(),
    sglang: SGLangEngineConfig = SGLangEngineConfig(),
    llamacpp: LlamaCppEngineConfig = LlamaCppEngineConfig(),
    mlx: MLXEngineConfig = MLXEngineConfig(),
    lmstudio: LMStudioEngineConfig = LMStudioEngineConfig(),
    exo: ExoEngineConfig = ExoEngineConfig(),
    nexa: NexaEngineConfig = NexaEngineConfig(),
    uzu: UzuEngineConfig = UzuEngineConfig(),
    apple_fm: AppleFmEngineConfig = AppleFmEngineConfig(),
    gemma_cpp: GemmaCppEngineConfig = GemmaCppEngineConfig(),
    lemonade: LemonadeEngineConfig = LemonadeEngineConfig(),
)

Inference engine settings with nested per-engine configs.

Attributes

ollama_host property writable

ollama_host: str

Deprecated: use engine.ollama.host.

vllm_host property writable

vllm_host: str

Deprecated: use engine.vllm.host.

llamacpp_host property writable

llamacpp_host: str

Deprecated: use engine.llamacpp.host.

llamacpp_path property writable

llamacpp_path: str

Deprecated: use engine.llamacpp.binary_path.

sglang_host property writable

sglang_host: str

Deprecated: use engine.sglang.host.

mlx_host property writable

mlx_host: str

Deprecated: use engine.mlx.host.

lmstudio_host property writable

lmstudio_host: str

Deprecated: use engine.lmstudio.host.

exo_host property writable

exo_host: str

Deprecated: use engine.exo.host.

nexa_host property writable

nexa_host: str

Deprecated: use engine.nexa.host.

uzu_host property writable

uzu_host: str

Deprecated: use engine.uzu.host.

apple_fm_host property writable

apple_fm_host: str

Deprecated: use engine.apple_fm.host.

lemonade_host property writable

lemonade_host: str

Deprecated: use engine.lemonade.host.

IntelligenceConfig dataclass

IntelligenceConfig(
    default_model: str = "",
    fallback_model: str = "",
    light_model: str = "",
    num_ctx: int = 0,
    checkpoint_path: str = "",
    quantization: str = "none",
    preferred_engine: str = "",
    provider: str = "",
    temperature: float = 0.7,
    max_tokens: int = 1024,
    top_p: float = 0.9,
    top_k: int = 40,
    repetition_penalty: float = 1.0,
    stop_sequences: str = "",
)

The model — identity, paths, quantization, and generation defaults.

DeepResearchConfig dataclass

DeepResearchConfig(engine: str = '', model: str = '')

Planner settings for the web Deep Research endpoint.

RoutingLearningConfig dataclass

RoutingLearningConfig(
    policy: str = "heuristic", min_samples: int = 5
)

Routing sub-policy config within Learning.

SFTConfig dataclass

SFTConfig(
    model_name: str = "Qwen/Qwen3-1.7B",
    max_seq_length: int = 4096,
    num_epochs: int = 3,
    batch_size: int = 8,
    learning_rate: float = 2e-05,
    weight_decay: float = 0.01,
    warmup_ratio: float = 0.1,
    max_grad_norm: float = 1.0,
    gradient_checkpointing: bool = True,
    use_lora: bool = True,
    lora_rank: int = 16,
    lora_alpha: int = 32,
    lora_dropout: float = 0.05,
    target_modules: str = "q_proj,v_proj",
    use_4bit: bool = False,
    checkpoint_dir: str = "checkpoints/sft",
    min_pairs: int = 10,
    agent_filter: str = "",
)

General-purpose SFT training config. Maps to [learning.intelligence.sft].

GRPOConfig dataclass

GRPOConfig(
    model_name: str = "Qwen/Qwen3-1.7B",
    max_seq_length: int = 4096,
    max_response_length: int = 2048,
    num_epochs: int = 10,
    batch_size: int = 16,
    learning_rate: float = 1e-06,
    max_grad_norm: float = 1.0,
    gradient_checkpointing: bool = True,
    num_samples_per_prompt: int = 8,
    temperature: float = 1.0,
    kl_coef: float = 0.0001,
    clip_ratio: float = 0.2,
    use_8bit_ref: bool = True,
    checkpoint_dir: str = "checkpoints/grpo",
    save_every_n_epochs: int = 1,
    keep_last_n: int = 3,
    min_prompts: int = 10,
    agent_filter: str = "",
)

General-purpose GRPO training config. Maps to [learning.intelligence.grpo].

DSPyOptimizerConfig dataclass

DSPyOptimizerConfig(
    optimizer: str = "BootstrapFewShotWithRandomSearch",
    task_lm: str = "",
    teacher_lm: str = "",
    max_bootstrapped_demos: int = 4,
    max_labeled_demos: int = 4,
    num_candidate_programs: int = 10,
    max_rounds: int = 1,
    optimize_system_prompt: bool = True,
    optimize_few_shot: bool = True,
    optimize_tool_descriptions: bool = True,
    min_traces: int = 20,
    metric_threshold: float = 0.7,
    agent_filter: str = "",
    config_dir: str = "",
)

DSPy agent optimizer config. Maps to [learning.agent.dspy].

GEPAOptimizerConfig dataclass

GEPAOptimizerConfig(
    reflection_lm: str = "",
    max_metric_calls: int = 150,
    population_size: int = 10,
    optimize_system_prompt: bool = True,
    optimize_tools: bool = True,
    optimize_max_turns: bool = True,
    optimize_temperature: bool = True,
    min_traces: int = 20,
    assessment_batch_size: int = 10,
    agent_filter: str = "",
    config_dir: str = "",
)

GEPA agent optimizer config. Maps to [learning.agent.gepa].

ACEOptimizerConfig dataclass

ACEOptimizerConfig(
    generator_model: str = "",
    reflector_model: str = "",
    curator_model: str = "",
    api_provider: str = "openai",
    num_epochs: int = 1,
    max_num_rounds: int = 3,
    eval_steps: int = 100,
    playbook_token_budget: int = 80000,
    max_tokens: int = 4096,
    save_dir: str = "",
    task_name: str = "diapason",
    min_traces: int = 20,
    agent_filter: str = "",
    config_dir: str = "",
)

ACE agent optimizer config. Maps to [learning.agent.ace].

ACE (Agentic Context Engineering) evolves a playbook — annotated natural-language strategies that get prepended to the agent's context — using a Generator / Reflector / Curator triad. Unlike DSPy (few-shot bootstrapping) or GEPA (Pareto-evolutionary prompt mutation), ACE writes a textual playbook that the agent reads at inference time.

See https://github.com/ace-agent/ace for the upstream reference. Install via pip install -e diapason[learning-ace] once the optional dep is available (ACE is not on PyPI as of v1.0.1; the extra installs from the upstream git repo).

IntelligenceLearningConfig dataclass

IntelligenceLearningConfig(
    policy: str = "none",
    sft: SFTConfig = SFTConfig(),
    grpo: GRPOConfig = GRPOConfig(),
)

Intelligence sub-policy config within Learning.

AgentLearningConfig dataclass

AgentLearningConfig(
    policy: str = "none",
    dspy: DSPyOptimizerConfig = DSPyOptimizerConfig(),
    gepa: GEPAOptimizerConfig = GEPAOptimizerConfig(),
    ace: ACEOptimizerConfig = ACEOptimizerConfig(),
)

Agent sub-policy config within Learning.

SkillsLearningConfig dataclass

SkillsLearningConfig(
    auto_optimize: bool = False,
    optimizer: str = "dspy",
    min_traces_per_skill: int = 20,
    optimization_interval_seconds: int = 86400,
    overlay_dir: str = (
        lambda: str(
            get_config_dir() / "learning" / "skills"
        )
    )(),
)

Configuration for the skills learning loop (Plan 2A).

MetricsConfig dataclass

MetricsConfig(
    accuracy_weight: float = 0.6,
    latency_weight: float = 0.2,
    cost_weight: float = 0.1,
    efficiency_weight: float = 0.1,
)

Reward / optimization metric weights.

SpecSearchCompositeRewardConfig dataclass

SpecSearchCompositeRewardConfig(
    alpha: float = 0.5,
    beta: float = 0.1,
    gamma: float = 0.1,
    delta: float = 0.3,
)

Composite reward weights for Intelligence-edit training (paper Eq. 1).

R(q, y) = alpha * R_acc - beta * E_hat - gamma * L_hat - delta * C_hat

SpecSearchLearningConfig dataclass

SpecSearchLearningConfig(
    enabled: bool = False,
    teacher_model: str = "claude-opus-4-6",
    teacher_engine: str = "cloud",
    autonomy_mode: str = "tiered",
    min_traces: int = 20,
    max_cost_per_session_usd: float = 5.0,
    max_tool_calls_per_diagnosis: int = 30,
    stagnation_k: int = 5,
    max_total_cost_usd: float = 50.0,
    stagnation_eps: float = 0.001,
    max_regression: float = 0.01,
    min_improvement: float = 0.0,
    benchmark_subsample_size: int = 50,
    benchmark_version: str = "personal_v1",
    composite_reward: SpecSearchCompositeRewardConfig = SpecSearchCompositeRewardConfig(),
)

LLM-guided spec search config (paper §3.3, Algorithm 1).

Maps to [learning.spec_search] and is consumed by SpecSearchOrchestrator.from_config and SpecSearchLoop.

LearningConfig dataclass

LearningConfig(
    enabled: bool = False,
    update_interval: int = 100,
    auto_update: bool = False,
    routing: RoutingLearningConfig = RoutingLearningConfig(),
    intelligence: IntelligenceLearningConfig = IntelligenceLearningConfig(),
    agent: AgentLearningConfig = AgentLearningConfig(),
    skills: SkillsLearningConfig = SkillsLearningConfig(),
    spec_search: SpecSearchLearningConfig = SpecSearchLearningConfig(),
    metrics: MetricsConfig = MetricsConfig(),
    training_enabled: bool = False,
    training_schedule: str = "",
    min_improvement: float = 0.02,
)

Learning system settings with per-primitive sub-policies.

Attributes

default_policy property writable

default_policy: str

Deprecated: use learning.routing.policy.

intelligence_policy property writable

intelligence_policy: str

Deprecated: use learning.intelligence.policy.

agent_policy property writable

agent_policy: str

Deprecated: use learning.agent.policy.

reward_weights property writable

reward_weights: str

Deprecated: use learning.metrics.*.

StorageConfig dataclass

StorageConfig(
    default_backend: str = "sqlite",
    db_path: str = (
        lambda: str(get_config_dir() / "memory.db")
    )(),
    context_top_k: int = 5,
    context_min_score: float = 0.0,
    context_max_tokens: int = 2048,
    chunk_size: int = 512,
    chunk_overlap: int = 64,
    enabled: bool = False,
    backend: str = "local",
    extraction_model: str = "",
    max_facts: int = 1000,
    facts_path: str = (
        lambda: str(get_config_dir() / "memory_facts.jsonl")
    )(),
)

Storage (memory) backend settings.

Covers both the retrieval/document store (default_backend, db_path, chunking, context injection) and the automatic long-term memory service (enabled, backend, extraction_model, max_facts, facts_path) configured under [memory] in config.toml.

MCPConfig dataclass

MCPConfig(enabled: bool = True, servers: str = '')

MCP (Model Context Protocol) settings.

BrowserConfig dataclass

BrowserConfig(
    headless: bool = True,
    timeout_ms: int = 30000,
    viewport_width: int = 1280,
    viewport_height: int = 720,
)

Browser automation settings (Playwright).

ToolsConfig dataclass

ToolsConfig(
    storage: StorageConfig = StorageConfig(),
    mcp: MCPConfig = MCPConfig(),
    browser: BrowserConfig = BrowserConfig(),
    enabled: str = "",
    ville: str = "",
)

Tools primitive settings — wraps storage and MCP configuration.

AgentConfig dataclass

AgentConfig(
    default_agent: str = "simple",
    max_turns: int = 10,
    tools: str = "",
    objective: str = "",
    system_prompt: str = "",
    system_prompt_path: str = "",
    context_from_memory: bool = True,
    trousse_adaptative: bool = False,
    tool_approval: str = "ask",
    default_system_prompt: str = "You are Diapason, a helpful AI assistant running locally on the user's own hardware. You are not a cloud service, and you are not Claude, ChatGPT, Gemini, or any other branded assistant. If asked who or what you are, identify yourself as Diapason. Respond helpfully, concisely, and accurately.",
)

Agent harness settings — orchestration, tools, system prompt.

Attributes

default_tools property writable

default_tools: str

Deprecated: use agent.tools.

ServerConfig dataclass

ServerConfig(
    host: str = "127.0.0.1",
    port: int = 8000,
    agent: str = "orchestrator",
    model: str = "",
    workers: int = 1,
    cors_origins: list = (
        lambda: [
            "http://localhost:3000",
            "http://localhost:5173",
            "http://localhost:5174",
            "http://127.0.0.1:3000",
            "http://127.0.0.1:5173",
            "http://127.0.0.1:5174",
            "tauri://localhost",
            "http://tauri.localhost",
            "https://tauri.localhost",
        ]
    )(),
)

API server settings.

TelemetryConfig dataclass

TelemetryConfig(
    enabled: bool = True,
    db_path: str = (
        lambda: str(get_config_dir() / "telemetry.db")
    )(),
    gpu_metrics: bool = False,
    gpu_poll_interval_ms: int = 50,
    energy_vendor: str = "",
    warmup_samples: int = 0,
    steady_state_window: int = 5,
    steady_state_threshold: float = 0.05,
)

Telemetry persistence settings.

AnalyticsConfig dataclass

AnalyticsConfig(
    enabled: bool = False,
    host: str = "https://34.231.106.201.sslip.io",
    key: str = "phc_ysKu72QaxzYNmDpHFcesD2ZZAe68zkdWJEKoYYkc5e3n",
    anon_id_path: str = (
        lambda: str(get_config_dir() / "anon_id")
    )(),
    flush_interval_seconds: int = 30,
    flush_at_size: int = 100,
)

External anonymous usage analytics (PostHog).

Separate concern from :class:TelemetryConfig, which stores local FLOPs/energy/inference metrics in SQLite. This controls anonymized usage events sent to the Diapason team's PostHog instance to measure setup success, retention, feature usage, and churn.

No chat content, prompts, model outputs, file paths, emails, IPs, or hardware identifiers are ever sent. See docs/telemetry.md.

TracesConfig dataclass

TracesConfig(
    enabled: bool = True,
    db_path: str = (
        lambda: str(get_config_dir() / "traces.db")
    )(),
)

Trace system settings.

ProactiveConfig dataclass

ProactiveConfig(
    enabled: bool = False,
    schedule: str = "0 5 * * *",
    hours_back: int = 24,
    timezone: str = "",
    notification_channel: str = "",
)

Proactive agent — autonomous action scheduling and approval routing.

TelegramChannelConfig dataclass

TelegramChannelConfig(
    bot_token: str = "",
    allowed_chat_ids: str = "",
    parse_mode: str = "Markdown",
)

Per-channel config for Telegram.

DiscordChannelConfig dataclass

DiscordChannelConfig(bot_token: str = '')

Per-channel config for Discord.

SlackChannelConfig dataclass

SlackChannelConfig(
    bot_token: str = "", app_token: str = ""
)

Per-channel config for Slack.

WebhookChannelConfig dataclass

WebhookChannelConfig(
    url: str = "", secret: str = "", method: str = "POST"
)

Per-channel config for generic webhooks.

EmailChannelConfig dataclass

EmailChannelConfig(
    smtp_host: str = "",
    smtp_port: int = 587,
    imap_host: str = "",
    imap_port: int = 993,
    username: str = "",
    password: str = "",
    use_tls: bool = True,
)

Per-channel config for email (SMTP/IMAP).

WhatsAppChannelConfig dataclass

WhatsAppChannelConfig(
    access_token: str = "", phone_number_id: str = ""
)

Per-channel config for WhatsApp Cloud API.

SignalChannelConfig dataclass

SignalChannelConfig(
    api_url: str = "", phone_number: str = ""
)

Per-channel config for Signal (via signal-cli REST API).

GoogleChatChannelConfig dataclass

GoogleChatChannelConfig(webhook_url: str = '')

Per-channel config for Google Chat webhooks.

IRCChannelConfig dataclass

IRCChannelConfig(
    server: str = "",
    port: int = 6667,
    nick: str = "",
    password: str = "",
    use_tls: bool = False,
)

Per-channel config for IRC.

WebChatChannelConfig dataclass

WebChatChannelConfig()

Per-channel config for in-memory webchat.

TeamsChannelConfig dataclass

TeamsChannelConfig(
    app_id: str = "",
    app_password: str = "",
    service_url: str = "",
)

Per-channel config for Microsoft Teams (Bot Framework).

MatrixChannelConfig dataclass

MatrixChannelConfig(
    homeserver: str = "", access_token: str = ""
)

Per-channel config for Matrix.

MattermostChannelConfig dataclass

MattermostChannelConfig(url: str = '', token: str = '')

Per-channel config for Mattermost.

FeishuChannelConfig dataclass

FeishuChannelConfig(app_id: str = '', app_secret: str = '')

Per-channel config for Feishu (Lark).

BlueBubblesChannelConfig dataclass

BlueBubblesChannelConfig(url: str = '', password: str = '')

Per-channel config for BlueBubbles (iMessage bridge).

WhatsAppBaileysChannelConfig dataclass

WhatsAppBaileysChannelConfig(
    auth_dir: str = "",
    assistant_name: str = "Diapason",
    assistant_has_own_number: bool = False,
)

Per-channel config for WhatsApp via Baileys protocol.

ChannelConfig dataclass

ChannelConfig(
    enabled: bool = False,
    default_channel: str = "",
    default_agent: str = "simple",
    telegram: TelegramChannelConfig = TelegramChannelConfig(),
    discord: DiscordChannelConfig = DiscordChannelConfig(),
    slack: SlackChannelConfig = SlackChannelConfig(),
    webhook: WebhookChannelConfig = WebhookChannelConfig(),
    email: EmailChannelConfig = EmailChannelConfig(),
    whatsapp: WhatsAppChannelConfig = WhatsAppChannelConfig(),
    signal: SignalChannelConfig = SignalChannelConfig(),
    google_chat: GoogleChatChannelConfig = GoogleChatChannelConfig(),
    irc: IRCChannelConfig = IRCChannelConfig(),
    webchat: WebChatChannelConfig = WebChatChannelConfig(),
    teams: TeamsChannelConfig = TeamsChannelConfig(),
    matrix: MatrixChannelConfig = MatrixChannelConfig(),
    mattermost: MattermostChannelConfig = MattermostChannelConfig(),
    feishu: FeishuChannelConfig = FeishuChannelConfig(),
    bluebubbles: BlueBubblesChannelConfig = BlueBubblesChannelConfig(),
    whatsapp_baileys: WhatsAppBaileysChannelConfig = WhatsAppBaileysChannelConfig(),
)

Channel messaging settings.

CapabilitiesConfig dataclass

CapabilitiesConfig(
    enabled: bool = True,
    policy_path: str = "",
    default_deny: bool = True,
)

RBAC capability system settings.

SecurityConfig dataclass

SecurityConfig(
    enabled: bool = True,
    scan_input: bool = True,
    scan_output: bool = True,
    mode: str = "redact",
    secret_scanner: bool = True,
    pii_scanner: bool = True,
    audit_log_path: str = (
        lambda: str(get_config_dir() / "audit.db")
    )(),
    enforce_tool_confirmation: bool = True,
    merkle_audit: bool = True,
    signing_key_path: str = "",
    ssrf_protection: bool = True,
    rate_limit_enabled: bool = True,
    rate_limit_rpm: int = 60,
    rate_limit_burst: int = 10,
    local_engine_bypass: bool = False,
    local_tool_bypass: bool = False,
    profile: str = "personal",
    vault_key_path: str = (
        lambda: str(get_config_dir() / ".vault_key")
    )(),
    capabilities: CapabilitiesConfig = CapabilitiesConfig(),
)

Security guardrails settings.

SandboxConfig dataclass

SandboxConfig(
    enabled: bool = False,
    image: str = "diapason-sandbox:latest",
    timeout: int = 300,
    workspace: str = "",
    mount_allowlist_path: str = "",
    max_concurrent: int = 5,
    runtime: str = "docker",
    wasm_fuel_limit: int = 1000000,
    wasm_memory_limit_mb: int = 256,
)

Container sandbox settings.

SchedulerConfig dataclass

SchedulerConfig(
    enabled: bool = False,
    poll_interval: int = 60,
    db_path: str = "",
)

Task scheduler settings.

HeartbeatConfig dataclass

HeartbeatConfig(
    enabled: bool = False,
    interval_seconds: int = 1800,
    workspace_dir: str = "",
    speak: bool = False,
    notify: bool = True,
    quiet_hours_enabled: bool = True,
    quiet_hours_start: str = "22:00",
    quiet_hours_end: str = "07:00",
    tool_allowlist: str = "digest_collect,memory_search,think,calendar_query",
)

Ambient HEARTBEAT.md queue drain (Diapason-style).

ReflexionConfig dataclass

ReflexionConfig(enabled: bool = True, model: str = '')

Le brouillon-critique des questions analytiques (server/reflexion.py).

model vide = le modèle du tour se relit lui-même ; un nom de modèle ("qwen3:14b") fait monter ces tours-là en gamme. Choisir un modèle qui COHABITE en mémoire avec celui du quotidien, sinon chaque question analytique évince le modèle de la voix et tout le monde attend.

RoutinesConfig dataclass

RoutinesConfig(
    enabled: bool = True,
    path: str = "",
    state_path: str = "",
    catchup_grace: bool = True,
    max_catchup_hours: int = 2,
    allow_shell: bool = False,
)

Named cron routines catalog (ROUTINES.json).

WorkflowConfig dataclass

WorkflowConfig(
    enabled: bool = False,
    max_parallel: int = 4,
    default_node_timeout: int = 300,
)

Workflow engine settings.

SessionConfig dataclass

SessionConfig(
    enabled: bool = False,
    max_age_hours: float = 24.0,
    consolidation_threshold: int = 100,
    db_path: str = (
        lambda: str(get_config_dir() / "sessions.db")
    )(),
)

Cross-channel session settings.

A2AConfig dataclass

A2AConfig(enabled: bool = False, auth_token: str = '')

Agent-to-Agent protocol settings.

OperatorsConfig dataclass

OperatorsConfig(
    enabled: bool = False,
    manifests_dir: str = (
        lambda: str(get_config_dir() / "operators")
    )(),
    auto_activate: str = "",
)

Operator lifecycle settings.

VoiceRealtimeConfig dataclass

VoiceRealtimeConfig(
    enabled: bool = True,
    provider: str = "local",
    model: str = "",
    voice: str = "",
    language: str = "",
    enable_tools: bool = True,
    max_tool_steps: int = 12,
    stt_model: str = "",
    tools: str = "",
    voice_lock: bool = True,
)

Duplex realtime voice (local pipeline / Gemini Live / OpenAI Realtime).

WakeWordConfig dataclass

WakeWordConfig(
    enabled: bool = False,
    backend: str = "phrase_gate",
    phrases: str = "diapason, hey diapason, dis diapason",
    action: str = "talk",
    cooldown_s: float = 2.5,
    sensitivity: float = 0.5,
    device: str = "",
    model_path: str = "",
    require_local_only: bool = True,
    text_gate: bool = True,
)

Always-on / text-gate wake word (opt-in; local only).

DesktopVisionConfig dataclass

DesktopVisionConfig(
    enabled: bool = False,
    monitor: int = 1,
    max_dimension: int = 1280,
    allow_cloud: bool = False,
    engine: str = "",
    model: str = "",
    redact: bool = False,
    keep_temp: bool = False,
    rate_limit_ms: int = 1500,
    share_interval_s: float = 5.0,
    share_max_minutes: float = 30.0,
)

Screen capture / share → vision model (opt-in).

DesktopLightningConfig dataclass

DesktopLightningConfig(
    enabled: bool = True,
    min_confidence: float = 0.9,
    allow_open: bool = True,
    allow_type: bool = True,
    allow_external_drafts: bool = True,
    allow_remote: bool = False,
    focus_timeout_s: float = 2.0,
    app_cache_ttl_s: float = 300.0,
    verify_actions: bool = True,
    preload_model: bool = True,
)

Fast deterministic desktop execution before any model call.

DesktopConfig dataclass

DesktopConfig(
    lightning: DesktopLightningConfig = DesktopLightningConfig(),
    vision: DesktopVisionConfig = DesktopVisionConfig(),
)

Desktop automation / vision settings.

SpeechConfig dataclass

SpeechConfig(
    backend: str = "auto",
    model: str = "base",
    language: str = "",
    device: str = "auto",
    compute_type: str = "float16",
    realtime: VoiceRealtimeConfig = VoiceRealtimeConfig(),
    wakeword: WakeWordConfig = WakeWordConfig(),
)

Speech-to-text settings.

DictationConfig dataclass

DictationConfig(
    polish: bool = True,
    dictionary: bool = True,
    dictionary_path: str = "",
    llm_polish: bool = False,
    email_mode: str = "off",
    llm_timeout_ms: int = 2000,
    paste_to_frontmost: bool = True,
    hotkey: str = "Cmd+Alt+Space",
    ptt_hold: bool = True,
    voice_commands: bool = True,
    auto_learn: bool = True,
)

Push-to-talk dictation polish + dictionary (Diapason-style).

OptimizeConfig dataclass

OptimizeConfig(
    max_trials: int = 20,
    early_stop_patience: int = 5,
    optimizer_model: str = "claude-sonnet-4-6",
    optimizer_provider: str = "anthropic",
    benchmark: str = "",
    max_samples: int = 50,
    judge_model: str = "gpt-5-mini-2025-08-07",
    db_path: str = (
        lambda: str(get_config_dir() / "optimize.db")
    )(),
)

Configuration optimization settings.

AgentManagerConfig dataclass

AgentManagerConfig(
    enabled: bool = True,
    db_path: str = (
        lambda: str(get_config_dir() / "agents.db")
    )(),
)

Persistent agent manager settings.

MemoryFilesConfig dataclass

MemoryFilesConfig(
    soul_path: str = (
        lambda: str(get_config_dir() / "SOUL.md")
    )(),
    memory_path: str = (
        lambda: str(get_config_dir() / "MEMORY.md")
    )(),
    user_path: str = (
        lambda: str(get_config_dir() / "USER.md")
    )(),
    nudge_interval: int = 10,
    persona_name: str = "",
)

Persistent memory-file paths and nudge settings.

SystemPromptConfig dataclass

SystemPromptConfig(
    prefix: str = "",
    soul_max_chars: int = 4000,
    memory_max_chars: int = 2500,
    user_max_chars: int = 1500,
    skill_desc_max_chars: int = 60,
    truncation_strategy: str = "head_tail",
)

Limits and strategy for system-prompt assembly.

CompressionConfig dataclass

CompressionConfig(
    enabled: bool = True,
    threshold: float = 0.5,
    strategy: str = "session_consolidation",
)

Configuration for context compression.

SkillSourceConfig dataclass

SkillSourceConfig(
    source: str = "",
    url: str = "",
    filter: Dict[str, Any] = dict(),
    auto_update: bool = False,
)

Configuration for a single skill source (Hermes, OpenClaw, GitHub).

SkillsConfig dataclass

SkillsConfig(
    enabled: bool = True,
    skills_dir: str = (
        lambda: str(get_config_dir() / "skills")
    )(),
    active: str = "*",
    auto_discover: bool = True,
    auto_sync: bool = False,
    nudge_interval: int = 15,
    index_repo: str = "https://github.com/diapason/skill-index.git",
    index_dir: str = (
        lambda: str(get_config_dir() / "skill-index")
    )(),
    max_depth: int = 5,
    sandbox_dangerous: bool = True,
    sources: List[SkillSourceConfig] = list(),
)

Configuration for agent-authored procedural skills.

DigestSectionConfig dataclass

DigestSectionConfig(
    sources: List[str] = list(),
    max_items: int = 10,
    priority_contacts: List[str] = list(),
)

Configuration for a single digest section.

DigestConfig dataclass

DigestConfig(
    enabled: bool = False,
    schedule: str = "0 6 * * *",
    timezone: str = "",
    persona: str = "diapason",
    sections: List[str] = (
        lambda: ["messages", "calendar", "health", "world"]
    )(),
    optional_sections: List[str] = (
        lambda: ["github", "financial", "music", "fitness"]
    )(),
    honorific: str = "sir",
    voice_id: str = "",
    voice_speed: float = 1.0,
    tts_backend: str = "cartesia",
    messages: DigestSectionConfig = (
        lambda: DigestSectionConfig(
            sources=["gmail", "slack", "google_tasks"]
        )
    )(),
    calendar: DigestSectionConfig = (
        lambda: DigestSectionConfig(sources=["gcalendar"])
    )(),
    health: DigestSectionConfig = (
        lambda: DigestSectionConfig(
            sources=["oura", "apple_health"]
        )
    )(),
    world: DigestSectionConfig = (
        lambda: DigestSectionConfig(sources=[])
    )(),
)

Configuration for the morning digest feature.

MeshConfig dataclass

MeshConfig(
    chiffrement: str = "opportuniste",
    discovery: bool = True,
)

Le maillage d'appareils, et ce qu'il chiffre.

chiffrement gouverne l'ÉMISSION seulement, et cette asymétrie est voulue :

• opportuniste (défaut) — on scelle vers un pair dont on détient une clé fraîche, et l'on part en clair vers les autres. C'est ce qui laisse le client mobile fonctionner : il ne publie aucune clé.
• exige — on refuse d'envoyer à un pair sans clé fraîche. Cela rend le téléphone injoignable, et il faut le savoir avant de le choisir.
• jamais — le comportement d'avant le 26 août 2026, pour revenir en arrière sans rien désinstaller.

EN RÉCEPTION, le clair est accepté quel que soit ce réglage. Non par négligence : /v1/mesh/commands/deliver est l'une des cinq portes du téléphone, et le client figé y poste une enveloppe claire. Rendre exige symétrique casserait net un appareil déjà déployé. Sans cette phrase, quelqu'un croirait raisonnablement que sa machine n'accepte plus de clair.

PrivacyConfig dataclass

PrivacyConfig(local_only: bool = True)

The single, authoritative answer to "may this leave the machine?".

Before this section existed the question was asked in three unrelated places, each covering one path and none covering the rest:

• speech.wakeword.require_local_only — declared, never read anywhere.
• desktop.vision.allow_cloud — vision only.
• nothing at all for speech-to-text or for LLM polish, which is how a failing local Whisper silently reached OpenAI and how dictation polish reached a cloud engine.

A promise that is enforced on some paths and not others is not a promise. local_only is therefore checked by every outbound path, and the per-domain switches may only ever be more restrictive than it — never less. Turning local_only on cannot be overridden by any of them.

New installations default to True. Existing cloud setups can opt in explicitly by setting local_only = false under [privacy].

DiapasonConfig dataclass

DiapasonConfig(
    installed_at: str = "",
    installer_version: str = "",
    hardware: HardwareInfo = HardwareInfo(),
    engine: EngineConfig = EngineConfig(),
    intelligence: IntelligenceConfig = IntelligenceConfig(),
    deep_research: DeepResearchConfig = DeepResearchConfig(),
    learning: LearningConfig = LearningConfig(),
    tools: ToolsConfig = ToolsConfig(),
    agent: AgentConfig = AgentConfig(),
    server: ServerConfig = ServerConfig(),
    telemetry: TelemetryConfig = TelemetryConfig(),
    analytics: AnalyticsConfig = AnalyticsConfig(),
    traces: TracesConfig = TracesConfig(),
    channel: ChannelConfig = ChannelConfig(),
    security: SecurityConfig = SecurityConfig(),
    mesh: MeshConfig = MeshConfig(),
    privacy: PrivacyConfig = PrivacyConfig(),
    sandbox: SandboxConfig = SandboxConfig(),
    scheduler: SchedulerConfig = SchedulerConfig(),
    heartbeat: HeartbeatConfig = HeartbeatConfig(),
    reflexion: ReflexionConfig = ReflexionConfig(),
    routines: RoutinesConfig = RoutinesConfig(),
    workflow: WorkflowConfig = WorkflowConfig(),
    sessions: SessionConfig = SessionConfig(),
    a2a: A2AConfig = A2AConfig(),
    operators: OperatorsConfig = OperatorsConfig(),
    speech: SpeechConfig = SpeechConfig(),
    desktop: DesktopConfig = DesktopConfig(),
    dictation: DictationConfig = DictationConfig(),
    optimize: OptimizeConfig = OptimizeConfig(),
    agent_manager: AgentManagerConfig = AgentManagerConfig(),
    memory_files: MemoryFilesConfig = MemoryFilesConfig(),
    system_prompt: SystemPromptConfig = SystemPromptConfig(),
    compression: CompressionConfig = CompressionConfig(),
    skills: SkillsConfig = SkillsConfig(),
    digest: DigestConfig = DigestConfig(),
    proactive: ProactiveConfig = ProactiveConfig(),
    mining: Optional["MiningConfig"] = None,
)

Top-level configuration for Diapason.

Attributes

memory property writable

memory: StorageConfig

Backward-compatible accessor — canonical location is tools.storage.

Functions:

get_cache_dir

get_cache_dir() -> Path

Resolve the directory for regenerable caches (eval datasets, etc.).

Lives at <root>/cache so caches stay inside the single Diapason directory instead of scattering across ~/.cache.

Source code in src/diapason/core/paths.py

def get_cache_dir() -> Path:
    """Resolve the directory for regenerable caches (eval datasets, etc.).

    Lives at ``<root>/cache`` so caches stay inside the single Diapason
    directory instead of scattering across ``~/.cache``.
    """
    return get_config_dir() / "cache"

get_config_dir

get_config_dir() -> Path

Resolve Diapason' single root directory, honoring env overrides.

Precedence: $DIAPASON_HOME > $XDG_DATA_HOME/diapason > ~/.diapason. The result is always absolute and is rejected if it falls inside the Diapason source tree.

Source code in src/diapason/core/paths.py

def get_config_dir() -> Path:
    """Resolve Diapason' single root directory, honoring env overrides.

    Precedence: ``$DIAPASON_HOME`` > ``$XDG_DATA_HOME/diapason`` >
    ``~/.diapason``. The result is always absolute and is rejected if it
    falls inside the Diapason source tree.
    """
    # Read through the env helper: DIAPASON_HOME wins, the historical
    # OPENJARVIS_HOME / JARVIS_HOME keep working so existing shell profiles,
    # CI jobs and units do not break silently.
    from diapason.core.env import get as _env_get

    env_home = _env_get("HOME")
    if env_home:
        resolved = Path(env_home).expanduser().resolve()
        return _reject_source_tree(resolved)

    xdg_data = os.environ.get("XDG_DATA_HOME")
    if xdg_data:
        resolved = (Path(xdg_data).expanduser() / _XDG_SUBDIR_NAME).resolve()
        return _reject_source_tree(resolved)

    return (Path.home() / _DEFAULT_DIR_NAME).resolve()

get_config_path

get_config_path() -> Path

Resolve the path to config.toml under the Diapason root.

Source code in src/diapason/core/paths.py

def get_config_path() -> Path:
    """Resolve the path to ``config.toml`` under the Diapason root."""
    return get_config_dir() / "config.toml"

get_data_dir

get_data_dir() -> Path

Resolve the directory for persistent data (databases, blobs, …).

Consolidated under the single root; identical to :func:get_config_dir. Provided as a distinct name so call sites read intentionally.

Source code in src/diapason/core/paths.py

def get_data_dir() -> Path:
    """Resolve the directory for persistent data (databases, blobs, …).

    Consolidated under the single root; identical to :func:`get_config_dir`.
    Provided as a distinct name so call sites read intentionally.
    """
    return get_config_dir()

detect_hardware

detect_hardware() -> HardwareInfo

Auto-detect hardware capabilities with graceful fallbacks.

Source code in src/diapason/core/config.py

def detect_hardware() -> HardwareInfo:
    """Auto-detect hardware capabilities with graceful fallbacks."""
    gpu = _detect_nvidia_gpu() or _detect_amd_gpu() or _detect_apple_gpu()
    return HardwareInfo(
        platform=platform.system().lower(),
        cpu_brand=_detect_cpu_brand(),
        cpu_count=os.cpu_count() or 1,
        ram_gb=_total_ram_gb(),
        gpu=gpu,
    )

recommend_engine

recommend_engine(hw: HardwareInfo) -> str

Suggest the best inference engine for the detected hardware.

Source code in src/diapason/core/config.py

def recommend_engine(hw: HardwareInfo) -> str:
    """Suggest the best inference engine for the detected hardware."""
    gpu = hw.gpu
    if gpu is None:
        return "llamacpp"
    if gpu.vendor == "apple":
        return "mlx"
    if gpu.vendor == "nvidia":
        # Datacenter cards (A100, H100, L40, etc.) → vllm; consumer → ollama
        datacenter_keywords = ("A100", "H100", "H200", "L40", "A10", "A30")
        if any(kw in gpu.name for kw in datacenter_keywords):
            return "vllm"
        return "ollama"
    if gpu.vendor == "amd":
        # Datacenter cards (MI300, MI325, MI350, MI355) → vllm; consumer → lemonade
        amd_datacenter_keywords = ("MI300", "MI325", "MI350", "MI355")
        if any(kw in gpu.name for kw in amd_datacenter_keywords):
            return "vllm"
        return "lemonade"
    return "llamacpp"

recommend_model

recommend_model(hw: HardwareInfo, engine: str) -> str

Suggest a default model for the selected engine and hardware.

For Lemonade, prefer the validated Qwen3.6 35B A3B GGUF default. For other local engines, use the generic Qwen3.5 tier mapping.

Source code in src/diapason/core/config.py

def recommend_model(hw: HardwareInfo, engine: str) -> str:
    """Suggest a default model for the selected engine and hardware.

    For Lemonade, prefer the validated Qwen3.6 35B A3B GGUF default.
    For other local engines, use the generic Qwen3.5 tier mapping.
    """
    from diapason.intelligence.model_catalog import BUILTIN_MODELS

    available_gb = _available_memory_gb(hw)
    if available_gb <= 0:
        return ""

    if engine == "lemonade":
        return _LEMONADE_DEFAULT_MODEL

    # Build a lookup for quick engine-compatibility checks
    catalog = {spec.model_id: spec for spec in BUILTIN_MODELS}

    # Try explicit tier mapping first
    model_id = _MODEL_TIER_FALLBACK
    for max_ram, tier_model in _MODEL_TIERS:
        if available_gb <= max_ram:
            model_id = tier_model
            break

    spec = catalog.get(model_id)
    if spec and engine in spec.supported_engines:
        return model_id

    # Fallback: scan all Qwen3.5 models for engine compatibility
    candidates = [
        s
        for s in BUILTIN_MODELS
        if s.provider == "alibaba"
        and s.model_id.startswith("qwen3.5:")
        and engine in s.supported_engines
    ]
    candidates.sort(key=lambda s: s.parameter_count_b, reverse=True)
    for s in candidates:
        estimated_gb = s.parameter_count_b * 0.5 * 1.1
        if estimated_gb <= available_gb:
            return s.model_id

    return ""

estimated_download_gb

estimated_download_gb(parameter_count_b: float) -> float

Estimate download size in GB for Q4_K_M quantized model.

Source code in src/diapason/core/config.py

def estimated_download_gb(parameter_count_b: float) -> float:
    """Estimate download size in GB for Q4_K_M quantized model."""
    return parameter_count_b * 0.5 * 1.1

apply_security_profile

apply_security_profile(
    security_cfg: "SecurityConfig",
    server_cfg: "ServerConfig | None",
    *,
    overrides: "set[str] | None" = None,
) -> None

Expand a named security profile into config fields.

Fields in overrides (explicitly set by the user in TOML) are not overwritten by the profile.

Source code in src/diapason/core/config.py

def apply_security_profile(
    security_cfg: "SecurityConfig",
    server_cfg: "ServerConfig | None",
    *,
    overrides: "set[str] | None" = None,
) -> None:
    """Expand a named security profile into config fields.

    Fields in *overrides* (explicitly set by the user in TOML) are
    not overwritten by the profile.
    """
    profile = security_cfg.profile
    if not profile:
        return

    if profile not in _SECURITY_PROFILES:
        raise ValueError(
            f"Unknown security profile '{profile}'. "
            f"Valid profiles: {', '.join(_SECURITY_PROFILES)}"
        )

    _overrides = overrides or set()
    pdef = _SECURITY_PROFILES[profile]

    for key, value in pdef.get("security", {}).items():
        if key not in _overrides and hasattr(security_cfg, key):
            setattr(security_cfg, key, value)

    if server_cfg is not None:
        for key, value in pdef.get("server", {}).items():
            if key not in _overrides and hasattr(server_cfg, key):
                setattr(server_cfg, key, value)

validate_config_key

validate_config_key(dotted_key: str) -> type

Validate a dotted config key and return the leaf field's Python type.

Raises :class:ValueError when the key does not map to a known field. The function walks the DiapasonConfig dataclass hierarchy using dataclasses.fields().

Examples::

validate_config_key("engine.ollama.host")      # -> str
validate_config_key("intelligence.temperature") # -> float

Source code in src/diapason/core/config.py

def validate_config_key(dotted_key: str) -> type:
    """Validate a dotted config key and return the leaf field's Python type.

    Raises :class:`ValueError` when the key does not map to a known field.
    The function walks the ``DiapasonConfig`` dataclass hierarchy using
    ``dataclasses.fields()``.

    Examples::

        validate_config_key("engine.ollama.host")      # -> str
        validate_config_key("intelligence.temperature") # -> float
    """
    from dataclasses import fields as dc_fields

    parts = dotted_key.split(".")
    if len(parts) < 2:
        raise ValueError(
            f"Config key must have at least two segments (e.g. engine.default), "
            f"got: {dotted_key!r}"
        )

    if parts[0] not in _SETTABLE_SECTIONS:
        raise ValueError(
            f"Unknown config key: {dotted_key!r} "
            f"(valid top-level sections: {sorted(_SETTABLE_SECTIONS)})"
        )

    # Walk the dataclass tree
    current_cls = DiapasonConfig
    for i, part in enumerate(parts):
        field_map = {f.name: f for f in dc_fields(current_cls)}
        if part not in field_map:
            path_so_far = ".".join(parts[: i + 1])
            raise ValueError(
                f"Unknown config key: {dotted_key!r} "
                f"(no field {part!r} at {path_so_far}; "
                f"valid fields: {sorted(field_map.keys())})"
            )
        fld = field_map[part]
        # Resolve the type — unwrap Optional, etc.
        fld_type = fld.type
        if isinstance(fld_type, str):
            # Evaluate forward references in the config module namespace
            import diapason.core.config as _cfg_mod

            fld_type = eval(fld_type, vars(_cfg_mod))  # noqa: S307

        if i == len(parts) - 1:
            # Leaf — return the primitive type
            return fld_type
        else:
            # Must be a nested dataclass
            if not hasattr(fld_type, "__dataclass_fields__"):
                path_so_far = ".".join(parts[: i + 1])
                raise ValueError(
                    f"Unknown config key: {dotted_key!r} "
                    f"({path_so_far} is a leaf of type {fld_type.__name__}, "
                    f"not a section)"
                )
            current_cls = fld_type

    # Should not reach here, but satisfy type checker
    raise ValueError(f"Unknown config key: {dotted_key!r}")

load_config cached

load_config(path: Optional[Path] = None) -> DiapasonConfig

Detect hardware, build defaults, overlay TOML overrides.

PARAMETER	DESCRIPTION
path	Explicit config file. If not set, uses DIAPASON_CONFIG when set, otherwise ~/.diapason/config.toml. TYPE: Optional[Path] DEFAULT: None

Source code in src/diapason/core/config.py

@functools.lru_cache(maxsize=1)
def load_config(path: Optional[Path] = None) -> DiapasonConfig:
    """Detect hardware, build defaults, overlay TOML overrides.

    Parameters
    ----------
    path:
        Explicit config file. If not set, uses ``DIAPASON_CONFIG`` when set,
        otherwise ``~/.diapason/config.toml``.
    """
    _ensure_config_dir()
    hw = detect_hardware()
    cfg = DiapasonConfig(hardware=hw)
    cfg.engine.default = recommend_engine(hw)

    if path is not None:
        config_path = Path(path)
    elif _env_get("CONFIG"):
        config_path = Path(_env_get("CONFIG")).expanduser().resolve()
    else:
        config_path = get_config_path()
    if config_path.exists():
        with open(config_path, "rb") as fh:
            data = tomllib.load(fh)

        # Run backward-compat migrations before applying
        _migrate_toml_data(data, cfg)

        # All top-level sections — recursive _apply_toml_section handles
        # nested sub-configs (engine.ollama, learning.routing, channel.*, etc.)
        top_sections = (
            "engine",
            "intelligence",
            "deep_research",
            "learning",
            "agent",
            "server",
            "telemetry",
            "analytics",
            "traces",
            "security",
            "privacy",
            "mesh",
            "channel",
            "tools",
            "sandbox",
            "scheduler",
            "heartbeat",
            "reflexion",
            "routines",
            "workflow",
            "sessions",
            "a2a",
            "operators",
            "speech",
            "desktop",
            "dictation",
            "optimize",
            "agent_manager",
            "digest",
            "proactive",
            "memory_files",
            "system_prompt",
            "compression",
            "skills",
        )
        for section_name in top_sections:
            if section_name in data:
                _apply_toml_section(
                    getattr(cfg, section_name),
                    data[section_name],
                )

        # Memory: accept [memory] (old) → maps to tools.storage
        if "memory" in data:
            _apply_toml_section(cfg.tools.storage, data["memory"])

        # Top-level install provenance (installed_at, installer_version)
        for key in ("installed_at", "installer_version"):
            if key in data:
                setattr(cfg, key, data[key])

        # Expand security profile (user TOML overrides take precedence)
        _user_security_keys = set(data.get("security", {}).keys())
        apply_security_profile(cfg.security, cfg.server, overrides=_user_security_keys)

        # Mining: dedicated parser for tagged-union submit_target
        cfg.mining = _parse_mining_section(data)

    # Apply profile even without a config file (in case defaults set one)
    if not config_path.exists() and cfg.security.profile:
        apply_security_profile(cfg.security, cfg.server)

    return cfg

generate_minimal_toml

generate_minimal_toml(
    hw: HardwareInfo,
    engine: str | None = None,
    *,
    host: str | None = None,
) -> str

Render a minimal TOML config with only essential settings.

Source code in src/diapason/core/config.py

def generate_minimal_toml(
    hw: HardwareInfo, engine: str | None = None, *, host: str | None = None
) -> str:
    """Render a minimal TOML config with only essential settings."""
    engine = engine or recommend_engine(hw)
    model = recommend_model(hw, engine)
    gpu_comment = ""
    if hw.gpu:
        mem_label = "unified memory" if hw.gpu.vendor == "apple" else "VRAM"
        gpu_comment = f"\n# GPU: {hw.gpu.name} ({hw.gpu.vram_gb} GB {mem_label})"
    if host:
        engine_host_section = f'\n[engine.{engine}]\nhost = "{host}"\n'
    else:
        engine_host_section = (
            f"\n[engine.{engine}]\n"
            f'# host = "http://localhost:11434"  '
            f"# set to remote URL if engine runs elsewhere\n"
        )
    return f"""\
# Diapason configuration
# Hardware: {hw.cpu_brand} ({hw.cpu_count} cores, {hw.ram_gb} GB RAM){gpu_comment}
# Full reference config: diapason init --full

[engine]
default = "{engine}"
{engine_host_section}
[intelligence]
default_model = "{model}"
# light_model = ""            # petit modèle pour les tours d'une ligne (vide = aucun)
# num_ctx = 0                 # fenêtre de contexte d'Ollama (0 = 16384)

[agent]
default_agent = "simple"

[tools]
enabled = ["code_interpreter", "web_search", "file_read", "shell_exec"]
"""

generate_default_toml

generate_default_toml(
    hw: HardwareInfo,
    engine: str | None = None,
    *,
    host: str | None = None,
) -> str

Render a commented TOML string suitable for ~/.diapason/config.toml.

Source code in src/diapason/core/config.py

def generate_default_toml(
    hw: HardwareInfo, engine: str | None = None, *, host: str | None = None
) -> str:
    """Render a commented TOML string suitable for ``~/.diapason/config.toml``."""
    engine = engine or recommend_engine(hw)
    model = recommend_model(hw, engine)
    gpu_line = ""
    if hw.gpu:
        gpu_line = f"# Detected GPU: {hw.gpu.name} ({hw.gpu.vram_gb} GB VRAM)"

    model_comment = ""
    if model:
        model_comment = "  # recommended for your hardware"

    result = f"""\
# Diapason configuration
# Generated by `diapason init`
#
# Hardware: {hw.cpu_brand} ({hw.cpu_count} cores, {hw.ram_gb} GB RAM)
{gpu_line}

[engine]
default = "{engine}"

[engine.ollama]
host = "http://localhost:11434"
keep_alive = "30m"            # keep the model resident between commands
timeout_s = 300.0              # bound wedged model reads

[engine.vllm]
host = "http://localhost:8000"

[engine.sglang]
host = "http://localhost:30000"

# [engine.llamacpp]
# host = "http://localhost:8080"
# binary_path = ""

[engine.mlx]
host = "http://localhost:8080"

# [engine.lmstudio]
# host = "http://localhost:1234"

# [engine.exo]
# host = "http://localhost:52415"

# [engine.nexa]
# host = "http://localhost:18181"
# device = ""  # cpu, gpu, npu

# [engine.uzu]
# host = "http://localhost:8080"

# [engine.apple_fm]
# host = "http://localhost:8079"

[intelligence]
default_model = "{model}"{model_comment}
fallback_model = ""
# model_path = ""              # Local weights (HF repo, GGUF file, etc.)
# checkpoint_path = ""         # Checkpoint/adapter path
# quantization = "none"        # none, fp8, int8, int4, gguf_q4, gguf_q8
# preferred_engine = ""        # Override engine for this model (e.g., "vllm")
# provider = ""                # local, openai, anthropic, google
temperature = 0.7
max_tokens = 1024
# top_p = 0.9
# top_k = 40
# repetition_penalty = 1.0
# stop_sequences = ""

# [deep_research]
# engine = ""                  # empty = use [engine].default
# model = ""                   # empty = use [intelligence].default_model

[agent]
default_agent = "simple"
max_turns = 10
# tools = ""                   # Comma-separated tool names
# objective = ""               # Concise purpose string
# system_prompt = ""           # Inline system prompt
# system_prompt_path = ""      # Path to system prompt file
context_from_memory = true

[desktop.lightning]
enabled = true                 # explicit low-risk commands bypass the LLM
min_confidence = 0.90
allow_open = true
allow_type = true
allow_external_drafts = true  # compose only; never send automatically
allow_remote = false           # remote API clients cannot control this host
focus_timeout_s = 2.0
app_cache_ttl_s = 300.0
verify_actions = true
preload_model = true

[tools.storage]
default_backend = "sqlite"

# Automatic long-term memory: extracts durable facts from conversations in the
# background and persists them. Starts/stops with `diapason serve` and
# `diapason chat`; manage stored facts with `diapason memory list` / `clear`.
[memory]
enabled = false               # set true to enable the memory service
backend = "local"             # fact-store backend (local = on-disk JSONL)
extraction_model = ""         # model for fact extraction ("" = active model)
max_facts = 1000              # cap on stored facts

[tools.mcp]
enabled = true

# [tools.browser]
# headless = true
# timeout_ms = 30000
# viewport_width = 1280
# viewport_height = 720

[server]
host = "127.0.0.1"
port = 8000
agent = "orchestrator"

# La découverte ne publie rien tant que le second socket Mesh n'est pas
# explicitement activé avec `diapason serve --lan-host ...`.
[mesh]
chiffrement = "opportuniste"
discovery = true

[learning]
enabled = false
update_interval = 100
# auto_update = false

[learning.routing]
policy = "heuristic"
# min_samples = 5

# [learning.intelligence]
# policy = "none"              # "sft" to learn from traces

# [learning.agent]
# policy = "none"              # "agent_advisor" | "icl_updater"

# [learning.metrics]
# accuracy_weight = 0.6
# latency_weight = 0.2
# cost_weight = 0.1
# efficiency_weight = 0.1

[telemetry]
enabled = true
# gpu_metrics = false
# gpu_poll_interval_ms = 50

[traces]
enabled = false

[channel]
enabled = false
default_agent = "simple"

# [channel.telegram]
# bot_token = ""  # Or set TELEGRAM_BOT_TOKEN env var

# [channel.discord]
# bot_token = ""  # Or set DISCORD_BOT_TOKEN env var

# [channel.slack]
# bot_token = ""  # Or set SLACK_BOT_TOKEN env var

# [channel.webhook]
# url = ""

# [channel.whatsapp]
# access_token = ""      # Or set WHATSAPP_ACCESS_TOKEN env var
# phone_number_id = ""   # Or set WHATSAPP_PHONE_NUMBER_ID env var

# [channel.signal]
# api_url = ""            # signal-cli REST API URL
# phone_number = ""       # Or set SIGNAL_PHONE_NUMBER env var

# [channel.google_chat]
# webhook_url = ""        # Or set GOOGLE_CHAT_WEBHOOK_URL env var

# [channel.irc]
# server = ""
# port = 6667
# nick = ""
# use_tls = false

# [channel.teams]
# app_id = ""             # Or set TEAMS_APP_ID env var
# app_password = ""       # Or set TEAMS_APP_PASSWORD env var

# [channel.matrix]
# homeserver = ""         # Or set MATRIX_HOMESERVER env var
# access_token = ""       # Or set MATRIX_ACCESS_TOKEN env var

# [channel.mattermost]
# url = ""                # Or set MATTERMOST_URL env var
# token = ""              # Or set MATTERMOST_TOKEN env var

# [channel.feishu]
# app_id = ""             # Or set FEISHU_APP_ID env var
# app_secret = ""         # Or set FEISHU_APP_SECRET env var

# [channel.bluebubbles]
# url = ""                # Or set BLUEBUBBLES_URL env var
# password = ""           # Or set BLUEBUBBLES_PASSWORD env var

[security]
enabled = true
mode = "warn"
scan_input = true
scan_output = true
secret_scanner = true
pii_scanner = true
enforce_tool_confirmation = true
ssrf_protection = true
# rate_limit_enabled = false
# rate_limit_rpm = 60
# rate_limit_burst = 10

# [sandbox]
# enabled = false
# image = "diapason-sandbox:latest"
# timeout = 300
# max_concurrent = 5
# runtime = "docker"

# [scheduler]
# enabled = false
# poll_interval = 60
# db_path = ""                # Defaults to ~/.diapason/scheduler.db

# [channel.whatsapp_baileys]
# auth_dir = ""               # Defaults to ~/.diapason/whatsapp_auth
# assistant_name = "Diapason"
# assistant_has_own_number = false
"""
    if host:
        import re as _re

        pattern = _re.escape(f"[engine.{engine}]") + r"\nhost = \"[^\"]*\""
        replacement = f'[engine.{engine}]\\nhost = "{host}"'
        result = _re.sub(pattern, replacement, result)
    return result