json arr = json::array();

for (const auto& r : results)

arr.push_back({{"id", r.id}, {"text", r.text}, {"score", r.score},

{"metadata", r.metadata}, {"timestamp", r.timestamp}});

return arr;

: memory(mem), users_(config().resolved_db_path()), host(h), port(p)

{

bootstrap_auth();

init_inference();

tcp_svr = make_tcp_server();

if (!config().server_name.empty()) {

httplib::Headers server_header{{"Server", config().server_name}};

unix_svr.set_default_headers(server_header);

tcp_svr->set_default_headers(server_header);

}

setup_routes(unix_svr);

setup_routes(*tcp_svr);

warmup();

const auto& cfg = config();

const bool have_cert = !cfg.tls_cert.empty();

const bool have_key = !cfg.tls_key.empty();

if (have_cert != have_key) {

// Only one of cert/key set — misconfiguration. Warn and fall

// back to plain HTTP; enforcing TLS on a half-configured pair

// isn't possible.

std::string msg = std::format(lang::WARN_TLS_PARTIAL_CONFIG,

have_cert ? "cert" : "key");

Diskerror::Logger::warn(msg);

std::cerr << msg << "\n";

return std::make_unique<httplib::Server>();

}

if (!have_cert && !have_key) {

return std::make_unique<httplib::Server>();

}

try {

auto svr = std::make_unique<httplib::SSLServer>(

cfg.tls_cert.c_str(), cfg.tls_key.c_str());

if (!svr->is_valid()) {

std::string msg = std::format(lang::WARN_TLS_INVALID_CERT,

cfg.tls_cert, cfg.tls_key);

Diskerror::Logger::warn(msg);

std::cerr << msg << "\n";

return std::make_unique<httplib::Server>();

}

tls_enabled_ = true;

Diskerror::Logger::info(std::format(lang::MSG_TLS_ENABLED, cfg.tls_cert));

return svr;

} catch (const std::exception& e) {

std::string msg = std::format(lang::WARN_TLS_SETUP_FAILED, e.what());

Diskerror::Logger::warn(msg);

std::cerr << msg << "\n";

return std::make_unique<httplib::Server>();

}

// Pre-load embedding cache so first request isn't slow

try {

auto result = memory.search("warmup", 1, 0.0f);

Diskerror::Logger::info(std::format(lang::MSG_WARMUP_EMBEDDING_CACHE, memory.count()));

} catch (const std::exception& e) {

Diskerror::Logger::info(std::format(lang::MSG_WARMUP_ERROR, e.what()));

}

// Preload default model on local inference engines

if (auto inf = inference()) {

preload_local_model(inf, inf->model);

}

const std::string& model_name) {

if (model_name.empty() || !inf) return;

try {

auto& ep = inf->resolve_endpoint(model_name);

if (!ep.is_local()) return;

} catch (...) {

return;

}

std::thread([inf, model_name]() {

auto err = inf->ensure_model_loaded(model_name);

if (err.empty()) {

Diskerror::Logger::info(std::format(lang::MSG_PRELOADED_MODEL, model_name));

} else {

// WARN, not info — preload is best-effort but a misconfigured or

// unreachable management endpoint is the kind of thing the user

// wants to see (issue #47). The err string already carries the

// tried URL via ERR_ENGINE_UNREACHABLE / ERR_MODEL_LOAD_*.

Diskerror::Logger::warn(std::format(lang::MSG_MODEL_PRELOAD_SKIPPED, err));

}

}).detach();

const auto& cfg = config();

float max_age_hours = cfg.cleanup_max_age_hours;

// 1. Purge old conversation entries — use the main memory backend,

// not a separate sqlite::Backend. Opening a second connection to the

// same file while the main backend holds it can produce SQLite

// BUSY/LOCKED contention that silently prevents the backfill UPDATE

// in step 3 from committing.

if (max_age_hours > 0) {

try {

int deleted = memory.cleanup_old_conversations(max_age_hours);

if (deleted > 0) {

Diskerror::Logger::info(std::format(

lang::MSG_HOUSEKEEPING_EXPIRED, 0, deleted));

}

} catch (const std::exception& e) {

Diskerror::Logger::critical(std::format(lang::ERR_CLEANUP_DB, e.what()));

}

}

// 2. Catch up unsummarized turns.

if (summarizer_) {

summarizer_->enqueue_catch_up();

}

// 3. Backfill NULL embeddings (deferred stores, partial rebuilds).

// If embeddings are degraded, try to recover first — a rebuild may

// have fixed the drift since the last housekeeping tick.

if (memory.embeddings_degraded()) {

memory.try_recover_embeddings();

}

if (!memory.embeddings_degraded()) {

try {

// Finish an interrupted re-embed before the ordinary backfill.

// This resumes the remaining rows with the promoted identity;

// the plain backfill below then handles deferred stores.

memory.resume_interrupted_reembed();

int filled = memory.backfill_embeddings();

if (filled > 0) {

Diskerror::Logger::info(std::format(

lang::MSG_BACKFILLED_EMBEDDINGS, filled));

}

} catch (const std::exception& e) {

Diskerror::Logger::warn(std::format(lang::ERR_CLEANUP_DB, e.what()));

}

}

// 4. (Reindex housekeeping removed in Step 10 — the custom text index

// is maintained incrementally by the write path; use

// `ragger reindex [table|all]` for manual rebuilds.)

std::lock_guard<std::mutex> lock(housekeeping_locks_mutex_);

if (housekeeping_locks_.count(username)) return true; // already own it

fs::create_directories("/tmp/ragger");

std::string lock_path = "/tmp/ragger/housekeeping-" + username + ".lock";

int fd = open(lock_path.c_str(), O_WRONLY | O_CREAT, 0644);

if (fd < 0) return false;

if (flock(fd, LOCK_EX | LOCK_NB) != 0) {

::close(fd);

return false; // another instance owns it

}

// Write our PID

ftruncate(fd, 0);

auto pid_str = std::to_string(getpid());

(void)write(fd, pid_str.c_str(), pid_str.size());

housekeeping_locks_[username] = fd;

Diskerror::Logger::info(std::format(lang::MSG_HOUSEKEEPING_OWNER, username));

return true;

poller_running_ = true;

poller_thread_ = std::thread([this]() {

while (poller_running_) {

std::this_thread::sleep_for(std::chrono::milliseconds(200));

// (1) shutdown / restart — stop the listeners exactly as the

// old housekeeping-thread block did; main() re-execs on

// restart after the listeners return.

if (g_shutdown_requested.load(std::memory_order_relaxed) ||

g_restart_requested.load(std::memory_order_relaxed)) {

Diskerror::Logger::info(

g_restart_requested.load(std::memory_order_relaxed)

? "Restart signal received; stopping listeners to re-exec"

: "Shutdown signal received; stopping listeners");

if (unix_svr.is_running()) unix_svr.stop();

if (tcp_svr && tcp_svr->is_running()) tcp_svr->stop();

return;

}

// (2) Reload (SIGHUP): config, plus the search caches — the

// DB file may have been changed by another process (CLI

// import/delete, a hand edit). SIGHUP, not a new signal, so

// a newer CLI can never kill an older daemon. Lives here so

// reload works with housekeeping disabled (every CLI write

// sends SIGHUP).

if (g_config_reload_requested.exchange(false)) {

memory.backend()->invalidate_all_caches();

Diskerror::Logger::info(lang::MSG_CACHE_RELOADED);

int n = reload_config();

if (n > 0) {

Diskerror::Logger::info(std::format(ragger::lang::MSG_CONFIG_RELOADED_N, n));

// Re-initialize inference client if endpoints changed

try {

auto fresh = std::make_shared<InferenceClient>(

InferenceClient::from_config(config()));

set_inference(std::move(fresh));

Diskerror::Logger::info(lang::MSG_INFERENCE_CLIENT_OK);

} catch (const std::exception& e) {

Diskerror::Logger::critical(std::format(lang::ERR_INFERENCE_CLIENT_FAIL, e.what()));

}

} else {

Diskerror::Logger::info(lang::MSG_CONFIG_RELOADED_NONE);

}

}

}

});

if (config().housekeeping_interval == 0) {

Diskerror::Logger::info(lang::MSG_HOUSEKEEPING_DISABLED);

return;

}

timer_running_ = true;

timer_thread_ = std::thread([this]() {

while (timer_running_) {

const int interval = config().housekeeping_interval; // live

if (interval <= 0) {

std::this_thread::sleep_for(std::chrono::seconds(1));

continue;

}

for (int i = 0; i < interval && timer_running_; ++i) {

std::this_thread::sleep_for(std::chrono::seconds(1));

// Check for signal-triggered housekeeping

if (g_housekeeping_requested.exchange(false)) {

Diskerror::Logger::info(lang::MSG_HOUSEKEEPING_SIGNAL);

run_housekeeping();

}

}

if (timer_running_) {

run_housekeeping();

}

}

});

timer_running_ = false;

poller_running_ = false;

if (timer_thread_.joinable()) {

timer_thread_.join();

}

if (poller_thread_.joinable()) {

poller_thread_.join();

}

// Release all user housekeeping locks

std::lock_guard<std::mutex> lock(housekeeping_locks_mutex_);

for (auto& [username, fd] : housekeeping_locks_) {

flock(fd, LOCK_UN);

::close(fd);

}

housekeeping_locks_.clear();

const auto& cfg = config();

auto client = InferenceClient::from_config(cfg);

if (!client.endpoints.empty()) {

auto n = client.endpoints.size();

set_inference(std::make_shared<InferenceClient>(std::move(client)));

Diskerror::Logger::info(std::format(lang::MSG_INFERENCE_ENABLED, n));

}

// Single-user mode: ensure token exists

server_token_ = ensure_token();

if (!server_token_.empty()) {

std::string token_hash = hash_token(server_token_);

auto user = users_.get_user_by_token_hash(token_hash);

if (!user) {

// Auto-create the single user

std::string username = "default";

struct passwd* pw = getpwuid(getuid());

if (pw) username = pw->pw_name;

int user_id = users_.create_user(username, token_hash);

user = UserInfo{user_id, username, token_hash};

Diskerror::Logger::info(std::format(lang::MSG_CREATED_USER, username, user_id));

}

default_user_ = user;

}

Diskerror::Logger::info(lang::MSG_SINGLE_USER_MODE);

if (req.remote_addr.empty()) return false; // unix socket

if (req.remote_addr == "127.0.0.1" || req.remote_addr == "::1") {

return false;

}

return true;

const auto& cfg = config();

// Auth bypass: unix socket and localhost requests are pre-authenticated

// as the default (single) user.

if (!request_requires_auth(req) && default_user_) {

return default_user_;

}

// Parse "Bearer <token>" from the Authorization header.

auto auth_header = req.get_header_value("Authorization");

const std::string bearer_prefix = "Bearer ";

std::string token;

if (auth_header.substr(0, bearer_prefix.size()) == bearer_prefix) {

token = auth_header.substr(bearer_prefix.size());

} else if (req.has_param("token")) {

// Browser navigation / EventSource can't set headers — accept the

// token as a query parameter (?token=...) for the dashboard and

// its SSE stream. Same trust model: holding the token = authorized.

token = req.get_param_value("token");

} else {

return std::nullopt;

}

// Hash and lookup in database

std::string token_hash = hash_token(token);

auto user = users_.get_user_by_token_hash(token_hash);

if (user) {

return user;

}

// Fallback: direct comparison with server token

if (token == server_token_ && default_user_) {

return default_user_;

}

return std::nullopt;

httplib::Response& res) {

auto body = json::parse(req.body);

std::string text = body.value("text", "");

json metadata = body.value("metadata", json::object());

if (text.empty()) {

Diskerror::Logger::debug("POST /store 400");

res.status = 400;

res.set_content(lang::HTTP_MISSING_TEXT, "text/plain");

return;

}

if (!metadata.contains("collection") || metadata["collection"].get<std::string>().empty())

metadata["collection"] = "memory";

if (!metadata.contains("source") || metadata["source"].get<std::string>().empty())

metadata["source"] = user.username;

auto& mem = _get_memory(user.username);

// Route curated decisions to knowledge(kind='decision'); everything

// else (fact/preference/lesson/unspecified) lands in

// knowledge(kind='note') via store().

std::string category = metadata.value("category", "");

if (category == "decision") {

std::string tags = metadata.value("tags", "");

// Default "current" (the only status the recall pipeline

// surfaces). Callers can pass metadata.status="roadmap" for

// planned/future work that shouldn't clutter every session's

// recall until it's actually done.

std::string status = metadata.value("status", "current");

int did = mem.store_decision(text, status, tags);

Diskerror::Logger::debug("POST /store 200 (decision)");

respond_json(res, json{{"id", std::to_string(did)},

{"status", "stored"},

{"kind", "decision"}});

return;

}

std::string id = mem.store(text, metadata);

Diskerror::Logger::debug("POST /store 200");

respond_json(res, json{{"id", id}, {"status", "stored"}});

httplib::Response& res) {

auto body = json::parse(req.body);

auto& mem = _get_memory(user.username);

// Project (Phase 3): explicit name/path wins; otherwise infer from

// cwd (longest-prefix match). No match leaves it empty — not an

// error. Shared with the MCP surface via parse_decision_input.

KnowledgeInput in = parse_decision_input(body);

try {

auto r = mem.store_knowledge(in);

Diskerror::Logger::debug("POST /decision 200");

respond_json(res, json{

{"id", r.id},

{"kind", r.kind},

{"status", "stored"},

{"superseded", r.superseded ? json(*r.superseded) : json(nullptr)},

{"possible_supersedes", supersedes_json(r.possible_supersedes)}});

} catch (const std::invalid_argument& e) {

Diskerror::Logger::debug("POST /decision 400");

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

httplib::Response& res) {

auto body = json::parse(req.body);

std::string text = body.value("text", "");

if (text.empty()) {

Diskerror::Logger::debug("POST /memory/note 400");

res.status = 400;

res.set_content(lang::HTTP_MISSING_TEXT, "text/plain");

return;

}

json metadata = json::object();

metadata["source"] = user.username;

if (body.contains("tags"))

metadata["tags"] = body["tags"];

auto& mem = _get_memory(user.username);

// ---- insight routing (Phase 5; PHASE7 kind="insight") -----------

if (body.contains("evidence") && body["evidence"].is_array()) {

KnowledgeInput in = parse_note_insight(body, text);

try {

auto r = mem.store_knowledge(in);

Diskerror::Logger::debug("POST /memory/note 200 (insight)");

respond_json(res, json{

{"id", r.id},

{"kind", r.kind},

{"status", "stored"},

{"superseded", r.superseded ? json(*r.superseded) : json(nullptr)},

{"possible_supersedes", supersedes_json(r.possible_supersedes)}});

} catch (const std::invalid_argument& e) {

Diskerror::Logger::debug("POST /memory/note 400 (insight)");

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

return;

}

try {

std::string id = mem.store(text, metadata);

Diskerror::Logger::debug("POST /memory/note 200");

respond_json(res, json{

{"id", id},

{"status", "stored"},

{"possible_supersedes", supersedes_json(mem.possible_supersedes_for_text(text))}});

} catch (const std::invalid_argument& e) {

Diskerror::Logger::debug("POST /memory/note 400");

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

httplib::Response& res) {

auto body = json::parse(req.body);

auto& mem = _get_memory(user.username);

TimelineQuery q = parse_timeline_query(body);

try {

Diskerror::Logger::debug("POST /memory/timeline 200");

respond_json(res, mem.agent_timeline(q));

} catch (const std::invalid_argument& e) {

Diskerror::Logger::debug("POST /memory/timeline 400");

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

httplib::Response& res) {

auto body = json::parse(req.body);

UpdateRequest u = parse_update_request(body);

auto& mem = _get_memory(user.username);

try {

Diskerror::Logger::debug("POST /memory/update 200");

respond_json(res, mem.agent_update(u));

} catch (const std::invalid_argument& e) {

Diskerror::Logger::debug("POST /memory/update 400");

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

httplib::Response& res) {

auto body = json::parse(req.body);

const std::string action = body.value("action", "");

std::vector<std::string> ids;

if (body.contains("ids"))

ids = body["ids"].get<std::vector<std::string>>();

auto& mem = _get_memory(user.username);

try {

Diskerror::Logger::debug("POST /memory/review 200");

respond_json(res, mem.agent_review(action, ids));

} catch (const std::invalid_argument& e) {

Diskerror::Logger::debug("POST /memory/review 400");

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

httplib::Response& res) {

auto body = json::parse(req.body);

// Shared with the MCP surface via parse_agent_search_query.

auto& mem = _get_memory(user.username);

AgentSearchQuery q = parse_agent_search_query(body);

try {

auto hits = mem.agent_search(q);

json arr = json::array();

for (const auto& h : hits) {

arr.push_back({{"id", h.id}, {"layer", h.layer},

{"score", h.score}, {"matched_by", h.matched_by},

{"created", h.created}, {"snippet", h.snippet},

{"extra", h.extra}});

}

Diskerror::Logger::debug("POST /memory/search 200");

respond_json(res, json{{"results", std::move(arr)}});

} catch (const std::invalid_argument& e) {

Diskerror::Logger::debug("POST /memory/search 400");

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

httplib::Response& res) {

auto body = json::parse(req.body);

AgentGetQuery q = parse_agent_get_query(body);

auto& mem = _get_memory(user.username);

try {

Diskerror::Logger::debug("POST /memory/get 200");

respond_json(res, mem.agent_get(q));

} catch (const std::invalid_argument& e) {

Diskerror::Logger::debug("POST /memory/get 400");

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

httplib::Response& res) {

auto body = json::parse(req.body);

std::string query = body.value("query", "");

if (query.empty()) {

Diskerror::Logger::debug("POST /search 400");

res.status = 400; res.set_content(lang::HTTP_MISSING_QUERY, "text/plain"); return;

}

int limit = body.value("limit", config().default_search_limit);

float min_score = body.value("min_score", config().default_min_score);

auto collections = body.value("collections", std::vector<std::string>{});

auto t0 = std::chrono::high_resolution_clock::now();

auto& mem = _get_memory(user.username);

auto sr = mem.search(query, limit, min_score, collections);

auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(

std::chrono::high_resolution_clock::now() - t0).count();

json timing = sr.timing;

timing["total_ms"] = ms;

Diskerror::Logger::trace(std::format(lang::DBG_QUERY_LOG, query, sr.results.size(), ms));

Diskerror::Logger::debug(std::format(lang::DBG_HTTP, "POST", "/search", "200"));

respond_json(res, json{{"results", search_results_to_json(sr.results)},

{"timing", timing}});

httplib::Response& res) {

auto body = json::parse(req.body);

std::string user_text = body.value("user", "");

std::string assistant = body.value("assistant", "");

std::string model = body.value("model", "");

std::string session_id = body.value("session_id", "");

std::string session_name = body.value("session_name", "");

std::string name_source = body.value("name_source", "");

if (user_text.empty()) {

Diskerror::Logger::debug("POST /turn 400");

respond_json(res, json{{"error", "missing required field: user"}}, 400);

return;

}

auto& mem = _get_memory(user.username);

auto result = capture_turn(mem, user_text, assistant, model, session_id,

session_name, name_source);

// PHASE6 2.2: hand the fresh turn straight to the summarizer so L2

// runs as soon as the single worker is free (the periodic tick is

// the safety net, not the primary path). Non-blocking: enqueue only,

// the request never waits for inference. summarizer_ is assigned in

// serve() before the listeners start, so every request thread sees a

// fully-constructed pointer without locking. MCP capture (no daemon

// summarizer in-process) is unchanged: the daemon's tick finds those.

if (result.captured && !assistant.empty() && summarizer_)

summarizer_->enqueue_turn(result.turn_id, result.clean_user, assistant,

model, session_id, /*source_timestamp=*/"");

Diskerror::Logger::debug(std::format(lang::DBG_HTTP, "POST", "/turn", "200"));

respond_json(res, json{{"status", result.captured ? "captured" : "disabled"},

{"turn_id", result.turn_id}});

httplib::Response& res) {

std::string sid = req.matches[1];

std::string recipe_name = req.get_param_value("recipe");

auto& mem = _get_memory(user.username);

auto ctx = build_context(mem, sid, recipe_name);

if (!ctx.enabled) {

respond_json(res, json{{"status", "disabled"}});

return;

}

json chunks = json::array();

for (const auto& c : ctx.chunks)

chunks.push_back({{"kind", c.kind}, {"text", c.text}, {"timestamp", c.timestamp}});

Diskerror::Logger::debug(std::format(lang::DBG_HTTP, "GET", "/session", "200"));

respond_json(res, json{{"status", "ok"},

{"session_id", sid},

{"recipe", ctx.recipe_name},

{"chunks", chunks}});

httplib::Response& res) {

int id = 0;

if (!util::parse_positive_int(std::string(req.matches[1]), id))

throw std::invalid_argument("memory id must be a positive integer");

auto& mem = _get_memory(user.username);

if (mem.delete_memory(id)) {

Diskerror::Logger::debug("DELETE /memory 200");

respond_json(res, json{{"id", id}, {"status", "deleted"}});

} else {

Diskerror::Logger::debug("DELETE /memory 404");

res.status = 404; res.set_content(lang::HTTP_MEMORY_NOT_FOUND, "text/plain");

}

httplib::Response& res) {

auto body = json::parse(req.body);

if (!body.contains("ids") || !body["ids"].is_array()) {

Diskerror::Logger::debug("POST /delete_batch 400");

res.status = 400; res.set_content(lang::HTTP_MISSING_IDS, "text/plain"); return;

}

auto ids = body["ids"].get<std::vector<int>>();

auto& mem = _get_memory(user.username);

int deleted = mem.delete_batch(ids);

Diskerror::Logger::debug("POST /delete_batch 200");

respond_json(res, json{{"deleted", deleted}});

httplib::Response& res) {

auto body = json::parse(req.body);

if (!body.contains("metadata") || !body["metadata"].is_object()) {

Diskerror::Logger::debug("POST /search_by_metadata 400");

res.status = 400; res.set_content(lang::HTTP_MISSING_METADATA, "text/plain"); return;

}

auto results = _get_memory(user.username).search_by_metadata(

body["metadata"], body.value("limit", 0),

body.value("after", ""), body.value("before", ""));

Diskerror::Logger::debug("POST /search_by_metadata 200");

respond_json(res, json{{"results", search_results_to_json(results)},

{"count", results.size()}});

// GET /health — no auth required

svr.Get("/health", [this](const httplib::Request&, httplib::Response& res) {

respond_json(res, json{{"status", "ok"},

{"version", RAGGER_VERSION},

{"commit", RAGGER_COMMIT},

{"built", RAGGER_BUILD_DATE},

{"memories", memory.count()},

{"embeddable_rows", memory.count_embeddable_rows()},

{"degraded", memory.embeddings_degraded()}});

Diskerror::Logger::debug("GET /health 200");

});

// Wrap a handler with bearer auth + uniform error handling.

auto guarded = [this](auto handler) {

return [this, handler](const httplib::Request& req, httplib::Response& res) {

auto user = _check_auth(req);

if (!user) {

Diskerror::Logger::debug(std::format("{} {} 401", req.method, req.path));

res.status = 401;

res.set_content(lang::HTTP_UNAUTHORIZED, "text/plain");

return;

}

// Cross-origin write guard (C §1.8): after auth, before the

// handler. A browser sends Origin on cross-site writes; the

// authority must match Host. GET/HEAD/OPTIONS and requests

// with no Origin (curl, CLI, plugin, MCP) pass through.

if (!request_origin_allowed(req.method,

req.get_header_value("Origin"),

req.get_header_value("Host"))) {

Diskerror::Logger::debug(std::format("{} {} 403 (origin)", req.method, req.path));

res.status = 403;

res.set_content("ERROR: cross-origin request refused", "text/plain");

return;

}

try {

handler(*user, req, res);

} catch (const json::exception& e) {

Diskerror::Logger::debug(std::format("{} {} 400", req.method, req.path));

res.status = 400;

res.set_content(std::format(lang::HTTP_JSON_ERROR, e.what()), "text/plain");

} catch (const std::invalid_argument& e) {

// Malformed inputs (bad ids, bad ports, validation failures)

// are client errors, not server faults (C §1.10).

Diskerror::Logger::debug(std::format("{} {} 400", req.method, req.path));

res.status = 400;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

} catch (const std::exception& e) {

Diskerror::Logger::critical(std::format(lang::ERR_ROUTE_FAILED, req.method, req.path, e.what()));

res.status = 500;

res.set_content(std::string("ERROR: ") + e.what(), "text/plain");

}

};

};

svr.Get("/count", guarded([this](const UserInfo& user, const httplib::Request&,

httplib::Response& res) {

respond_json(res, json{{"count", _get_memory(user.username).count()}});

Diskerror::Logger::debug("GET /count 200");

}));

svr.Post("/store", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_store(u, req, res); }));

svr.Post("/decision", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_decision(u, req, res); }));

svr.Post("/search", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_search(u, req, res); }));

svr.Post("/memory/search", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_memory_search(u, req, res); }));

svr.Post("/memory/get", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_memory_get(u, req, res); }));

svr.Post("/memory/note", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_memory_note(u, req, res); }));

svr.Post("/memory/timeline", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_memory_timeline(u, req, res); }));

svr.Post("/memory/update", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_memory_update(u, req, res); }));

svr.Post("/memory/review", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_memory_review(u, req, res); }));

svr.Post("/turn", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_turn(u, req, res); }));

svr.Get(R"(/session/([^/]+))", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_session(u, req, res); }));

svr.Delete(R"(/memory/(\d+))", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_delete_memory(u, req, res); }));

svr.Post("/delete_batch", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_delete_batch(u, req, res); }));

svr.Post("/search_by_metadata", guarded([this](const UserInfo& u, const httplib::Request& req, httplib::Response& res) { handle_search_by_metadata(u, req, res); }));

svr.Get("/user/token", guarded([this](const UserInfo& user, const httplib::Request&,

httplib::Response& res) {

struct passwd* pw = getpwnam(user.username.c_str());

if (!pw) { res.status = 404; res.set_content(std::format(R"({{"error":"{}"}})", lang::HTTP_SYSTEM_USER_NOT_FOUND), "application/json"); return; }

std::string token_file = std::string(pw->pw_dir) + "/.ragger/token";

std::ifstream f(token_file);

if (!f) { res.status = 404; res.set_content(std::format(R"({{"error":"{}"}})", lang::HTTP_NO_TOKEN_FILE), "application/json"); return; }

std::string token;

std::getline(f, token);

size_t s = token.find_first_not_of(" \t\r\n");

size_t e = token.find_last_not_of(" \t\r\n");

if (s != std::string::npos) token = token.substr(s, e - s + 1);

Diskerror::Logger::debug("GET /user/token 200");

respond_json(res, json{{"token", token}, {"username", user.username}});

}));

// ---- Dashboard (embedded HTML/JS) --------------------------------

// GET /dashboard[?token=...] -> the single-page control panel. The

// page then talks to /config and /events with the same token.

svr.Get("/dashboard", guarded([this](const UserInfo&, const httplib::Request&,

httplib::Response& res) {

res.set_content(DASHBOARD_HTML, "text/html; charset=utf-8");

Diskerror::Logger::debug("GET /dashboard 200");

}));

// ---- Config API (dashboard + programmatic) -----------------------

// GET /config -> all settings as {key: {value, ...schema}}

// GET /config/<key> -> one setting