if (path.empty() || path[0] != '~') return path;

std::string home = home_dir();

if (home.empty()) return path;

return home + path.substr(1);

std::ifstream file(path);

if (!file.is_open()) {

return std::unexpected(ConfigError::IOError);

}

return parse_config(file);

std::istringstream in{std::string(DEFAULT_CONFIG)};

auto parsed = parse_config(in);

// The embedded defaults are generated at build time and parsed by the same

// code that produced them, so a failure here is a build error, not a

// runtime condition — fall back to the struct's own initialisers.

return parsed.has_value() ? *parsed : Config{};

if (addr.empty()) return; // empty = TCP listener disabled, always fine

struct in_addr a4{};

struct in6_addr a6{};

if (inet_pton(AF_INET, addr.c_str(), &a4) == 1) return;

if (inet_pton(AF_INET6, addr.c_str(), &a6) == 1) return;

// Hostname: alnum, '-', '.' only; must not start/end with '.' or '-'.

bool looks_like_hostname = !addr.empty() &&

std::all_of(addr.begin(), addr.end(), [](unsigned char c) {

return std::isalnum(c) || c == '-' || c == '.';

}) &&

addr.front() != '.' && addr.front() != '-' &&

addr.back() != '.' && addr.back() != '-';

if (!looks_like_hostname) {

throw std::runtime_error(

"invalid [server] bind address: \"" + addr +

"\" (expected an IPv4/IPv6 literal or hostname)");

}

auto start = s.find_first_not_of(" \t\r\n");

if (start == std::string::npos) return "";

auto end = s.find_last_not_of(" \t\r\n");

return s.substr(start, end - start + 1);

std::string lower = val;

std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);

return lower == "true" || lower == "yes" || lower == "1";

Config cfg;

std::string section;

std::string line;

// Temporary storage for inference endpoint sections

std::map<std::string, Config::InferenceEndpointConfig> endpoint_map;

// Alias tracking: episode_idle_minutes supersedes the deprecated

// summary_pause_minutes. If the new key is never set explicitly but the

// old one is present, fall back to the old value after the parse loop.

bool episode_idle_set = false;

bool summary_pause_set = false;

while (std::getline(file, line)) {

line = trim(line);

// Skip empty lines and comments

if (line.empty() || line[0] == '#' || line[0] == ';') continue;

// Section header

if (line[0] == '[' && line.back() == ']') {

section = line.substr(1, line.size() - 2);

continue;

}

// Key = value

auto eq = line.find('=');

if (eq == std::string::npos) continue;

std::string key = trim(line.substr(0, eq));

std::string val = trim(line.substr(eq + 1));

// Strip inline comments (but not inside quoted values)

if (val[0] != '"' && val[0] != '\'') {

auto hash = val.find('#');

if (hash != std::string::npos) {

val = trim(val.substr(0, hash));

}

}

// Surrounding quotes around a value are stripped so that

// socket = '' (or "")

// reads as an empty string — same as a missing/commented line.

auto strip_quotes = [](std::string s) -> std::string {

if (s.size() >= 2 &&

((s.front() == '"' && s.back() == '"') ||

(s.front() == '\'' && s.back() == '\''))) {

return s.substr(1, s.size() - 2);

}

return s;

};

// Map to config fields. Most keys are plain schema fields (bool/int/

// float/string) applied via set_config_field_raw(), which shares the

// key -> Config-member-pointer tables in config_access.cpp with the

// CLI/dashboard config path (see config_schema.h). Keys with

// aliases, legacy back-compat quirks, or bespoke validation

// (clamping, "ignore non-positive", cross-key fallback) are not

// representable as a plain field assignment and are handled

// explicitly below, same as before.

if (section == "server") {

if (key == "socket") {

// Legacy key, back-compat: presence of a non-empty value

// enables the socket listener (not itself a schema field).

cfg.socket_enabled = !strip_quotes(val).empty();

} else if (key == "bind") {

cfg.bind_address = strip_quotes(val);

} else if (key == "hostname") {

cfg.server_name = val; // alias for server_name

} else if (key == "tls_cert") {

cfg.tls_cert = val; // alias for cert

} else if (key == "tls_key") {

cfg.tls_key = val; // alias for key

} else {

set_config_field_raw(cfg, key, val);

}

}

else if (section == "embedding") {

set_config_field_raw(cfg, key, val);

}

else if (section == "search") {

if (key == "inject_data") cfg.inject_data = parse_bool(val); // not a schema key

else set_config_field_raw(cfg, key, val);

}

else if (section == "inference") {

// Not schema keys (no CLI/dashboard-editable equivalent yet).

if (key == "model") cfg.inference_model = val;

else if (key == "api_url") cfg.inference_api_url = val;

else if (key == "api_key") cfg.inference_api_key = val;

else if (key == "max_tokens") cfg.inference_max_tokens = std::stoi(val);

else if (key == "default") cfg.inference_default = val;

}

else if (section == "summarizer") {

if (key == "episode_idle_minutes") {

int v = std::stoi(val);

if (v > 0) { cfg.episode_idle_minutes = v; episode_idle_set = true; }

} else {

set_config_field_raw(cfg, key, val);

}

}

else if (section.substr(0, 10) == "inference.") {

// Named endpoint section: [inference.local], [inference.anthropic], etc.

std::string ep_name = section.substr(10);

auto& ep = endpoint_map[ep_name];

ep.name = ep_name;

if (key == "api_url") ep.api_url = val;

else if (key == "api_key") ep.api_key = val;

else if (key == "models") ep.models = val;

else if (key == "format") ep.format = val;

else if (key == "max_context") ep.max_context = std::stoi(val);

else if (key == "max_tokens") ep.max_tokens = std::stoi(val);

}

else if (section == "logging") {

if (key == "log_max_size_mb") {

long v = std::stol(val);

if (v >= 0) cfg.log_max_size_mb = v;

}

else if (key == "log_max_age_days") {

int v = std::stoi(val);

if (v >= 0) cfg.log_max_age_days = v;

}

else set_config_field_raw(cfg, key, val); // log_level

}

else if (section == "paths") {

set_config_field_raw(cfg, key, val); // normalize_home

}

else if (section == "tls" || section == "ssl") {

// Legacy standalone section — kept silently for back-compat.

// TLS now lives under [server] (cert=/key=); see above.

if (key == "tls_cert") cfg.tls_cert = val;

else if (key == "tls_key") cfg.tls_key = val;

else set_config_field_raw(cfg, key, val); // cert / key

}

else if (section == "import") {

set_config_field_raw(cfg, key, val); // minimum_chunk_size

}

else if (section == "embed") {

// Section-local key names (timeout_ms, retries, max_workers)

// differ from their schema keys (embed_timeout_ms, ...), so

// route through the schema key explicitly rather than passing

// the raw INI key.

if (key == "timeout_ms") set_config_field_raw(cfg, "embed_timeout_ms", val);

else if (key == "retries") set_config_field_raw(cfg, "embed_retries", val);

else if (key == "max_workers") set_config_field_raw(cfg, "embed_max_workers", val);

}

else if (section == "housekeeping") {

if (key == "housekeeping_interval") {

int v = std::stoi(val);

cfg.housekeeping_interval = (v == 0) ? 0 : std::max(v, 10);

}

else if (key == "summary_pause_minutes") {

cfg.summary_pause_minutes = std::stoi(val);

summary_pause_set = true;

}

else if (key == "episode_idle_minutes") {

int v = std::stoi(val);

if (v > 0) { cfg.episode_idle_minutes = v; episode_idle_set = true; }

}

else if (key == "catch_up_batch_size") {

int v = std::stoi(val);

if (v > 0) cfg.catch_up_batch_size = v;

}

else if (key == "max_turn_failures") {

int v = std::stoi(val);

if (v >= 0) cfg.max_turn_failures = v;

}

else set_config_field_raw(cfg, key, val); // cleanup_max_age_hours, episode_threshold_*, episode_step_minutes

}

else if (section == "llama") {

// [llama] section removed — use external inference providers

// Silently ignore for backward compatibility with old configs

}

}

// Convert endpoint map to vector

for (auto& [name, ep] : endpoint_map) {

cfg.inference_endpoints.push_back(ep);

}

// Deprecated-alias fallback: if episode_idle_minutes was never set but the

// old summary_pause_minutes is present, adopt it. Keep summary_pause_minutes

// itself in sync with the effective idle gap so any lingering reader agrees.

if (!episode_idle_set && summary_pause_set && cfg.summary_pause_minutes > 0) {

cfg.episode_idle_minutes = cfg.summary_pause_minutes;

} else {

cfg.summary_pause_minutes = cfg.episode_idle_minutes;

}

// Fallback: if neither listener is configured, bring up TCP on loopback

// so the daemon always has at least one listener.

if (!cfg.socket_enabled && !cfg.tcp_enabled) {

cfg.tcp_enabled = true;

if (cfg.bind_address.empty()) cfg.bind_address = "127.0.0.1";

}

// Expand bind_address if it starts with ~ (rare, but historically

// supported for host-as-path oddities; kept for back-compat).

if (!cfg.bind_address.empty() && cfg.bind_address[0] == '~') {

// For bind_address, expand ~ to home but keep the host part

std::string home = expand_path("~");

if (home.back() != '/') home += '/';

cfg.bind_address = home + cfg.bind_address.substr(1);

}

// A malformed bind address is a startup error, not a silent fallback.

validate_bind_address(cfg.bind_address);

return cfg;

// Base layer: the compiled-in defaults. Ragger used to bootstrap a

// config file into ~/.ragger and read it back as the base layer, with the

// DB overlaid on top. That left the file half-live — stale for every key

// the dashboard had written a row for, still authoritative for every key

// it had not — and it was regenerated from defaults whenever it was

// deleted, so it silently reappeared as a stale layer. The settings table

// is now the only store; defaults live in the binary.

static Config cfg = load_default_config();

cfg.log_file = cfg.resolved_log_file_path();

// DB is the source of truth for user config: overlay any rows present in

// the settings table on top of the defaults. No-op if the DB doesn't exist

// yet (first run before serve creates it).

overlay_settings_from_db(cfg, cfg.resolved_db_path());

g_config = &cfg;

if (!g_config) return 0;

// Re-read the defaults and re-overlay the settings table — same two layers

// init_config() uses, so a SIGHUP reload and a fresh start agree.

Config fresh = load_default_config();

fresh.log_file = fresh.resolved_log_file_path();

overlay_settings_from_db(fresh, fresh.resolved_db_path());

Config& cfg = *g_config;

int changes = 0;

// Keys that require restart (log but don't apply)

auto warn_restart = [&](const std::string& name, bool changed) {

if (changed) {

std::cerr << std::format(ragger::lang::WARN_CONFIG_RESTART, name) << "\n";

}

};

warn_restart("port", fresh.port != cfg.port);

warn_restart("socket_enabled", fresh.socket_enabled != cfg.socket_enabled);

warn_restart("tcp_enabled", fresh.tcp_enabled != cfg.tcp_enabled);

warn_restart("bind_address", fresh.bind_address != cfg.bind_address);

warn_restart("tls_cert", fresh.tls_cert != cfg.tls_cert);

warn_restart("tls_key", fresh.tls_key != cfg.tls_key);

warn_restart("embedding_model", fresh.embedding_model != cfg.embedding_model);

warn_restart("embedding_dimensions", fresh.embedding_dimensions != cfg.embedding_dimensions);

warn_restart("embedding_vector_type", fresh.embedding_vector_type != cfg.embedding_vector_type);

warn_restart("embedding_engine", fresh.embedding_engine != cfg.embedding_engine);

// Hot-reloadable fields

#define RELOAD(field) do { \

if (cfg.field != fresh.field) { \

cfg.field = fresh.field; \

++changes; \

} \

} while(0)

// Search

RELOAD(default_search_limit);

RELOAD(default_min_score);

RELOAD(decision_supersede_threshold);

RELOAD(bm25_enabled);

RELOAD(bm25_weight);

RELOAD(vector_weight);

RELOAD(inject_data);

RELOAD(fts_w_unigram);

RELOAD(fts_w_bigram);

RELOAD(fts_w_metaphone);

RELOAD(fts_literal_enabled);

// Inference

RELOAD(inference_model);

RELOAD(inference_default);

RELOAD(inference_api_url);

RELOAD(inference_api_key);

RELOAD(inference_max_tokens);

RELOAD(summarizer_model);

RELOAD(summarizer_api_url);

RELOAD(summarizer_api_key);

RELOAD(summarizer_max_tokens);

RELOAD(summarizer_target_pct);

RELOAD(summarizer_max_pct);

RELOAD(summarizer_prompt);

// Endpoints: replace entirely if different

if (cfg.inference_endpoints.size() != fresh.inference_endpoints.size()) {

cfg.inference_endpoints = fresh.inference_endpoints;

++changes;

} else {

for (size_t i = 0; i < cfg.inference_endpoints.size(); ++i) {

auto& a = cfg.inference_endpoints[i];

auto& b = fresh.inference_endpoints[i];

if (a.name != b.name || a.api_url != b.api_url || a.api_key != b.api_key ||

a.models != b.models || a.format != b.format || a.max_context != b.max_context) {

cfg.inference_endpoints = fresh.inference_endpoints;

++changes;

break;

}

}

}

// Logging

// (log_level itself is not hot-reloadable — Diskerror::Logger is

// constructed once at startup with the level fixed.)

// Paths

RELOAD(normalize_home_path);

// Import

RELOAD(minimum_chunk_size);

// Embed (subprocess settings)

RELOAD(embed_timeout_ms);

RELOAD(embed_retries);

RELOAD(embed_max_workers);

// Housekeeping / retention

RELOAD(cleanup_max_age_hours);

RELOAD(housekeeping_interval);

RELOAD(summary_pause_minutes);

RELOAD(episode_idle_minutes);

RELOAD(catch_up_batch_size);

RELOAD(max_turn_failures);

RELOAD(capture_turns);

RELOAD(build_context);

RELOAD(auto_recall);

RELOAD(default_recipe);

// System ceilings

#undef RELOAD

return changes;

if (argv0.empty()) return;

// Resolve to an absolute path when possible; realpath handles a relative

// or PATH-less invocation. Fall back to the raw argv0.

char buf[4096];

if (::realpath(argv0.c_str(), buf)) g_executable_path = buf;

else g_executable_path = argv0;