refactor(server, tests): improve error feedback, logging, and test infrastructure

Replace silent null returns with proper LSP errors (kota::fail) for
feature requests on closed documents, failed compilations, invalid
positions, and unresolvable hierarchy items. Add client notifications
(window/logMessage) for key failures so integration tests can observe
errors without reading server logs. Expand logging coverage in
compilation pipeline (compile args, compilation phases, worker results).

Improve test infrastructure: conditional log dump on failure, yield-based
workspace fixture with post-test cleanup, named timing constants replacing
hardcoded sleeps, and log message capture/assertion helpers.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

cmake/package.cmake

@@ -41,7 +41,8 @@ set(FLATBUFFERS_BUILD_FLATHASH OFF CACHE BOOL "" FORCE)
 FetchContent_Declare(
     kotatsu
     GIT_REPOSITORY https://github.com/clice-io/kotatsu
-    GIT_TAG e024f3b427a554502c4aa015952800a03ca4384b
+    GIT_TAG main
+    GIT_SHALLOW TRUE
 )
 
 set(KOTA_ENABLE_ZEST ON)

docs/en/architecture.md

@@ -153,7 +153,7 @@ String values support `${workspace}` substitution.
 
 ## IPC Protocol
 
-The master and workers communicate using custom RPC messages defined in `src/server/protocol/`. Each message type has a `RequestTraits` or `NotificationTraits` specialization that defines the method name and result type.
+The master and workers communicate using custom RPC messages defined in `src/server/protocol.h`. Each message type has a `RequestTraits` or `NotificationTraits` specialization that defines the method name and result type.
 
 ### Stateful Worker Messages
 

src/clice.cc

@@ -4,33 +4,33 @@
 #include <print>
 #include <string>
 
-#include "server/service/agentic.h"
-#include "server/service/master_server.h"
-#include "server/worker/stateful_worker.h"
-#include "server/worker/stateless_worker.h"
+#include "server/master_server.h"
+#include "server/stateful_worker.h"
+#include "server/stateless_worker.h"
 #include "support/logging.h"
 
+#include "kota/async/async.h"
 #include "kota/deco/deco.h"
+#include "kota/ipc/codec/json.h"
+#include "kota/ipc/peer.h"
+#include "kota/ipc/recording_transport.h"
+#include "kota/ipc/transport.h"
 
 namespace clice {
 
 using kota::deco::decl::KVStyle;
 
 struct Options {
-    DecoKV(
-        style = KVStyle::JoinedOrSeparate,
-        help =
-            "Running mode: pipe, socket, daemon, relay, agentic, stateless-worker, stateful-worker",
-        required = false)
+    DecoKV(style = KVStyle::JoinedOrSeparate,
+           help = "Running mode: pipe, socket, stateless-worker, stateful-worker",
+           required = false)
     <std::string> mode;
 
     DecoKV(style = KVStyle::JoinedOrSeparate, help = "Socket mode address", required = false)
     <std::string> host = "127.0.0.1";
 
-    DecoKV(style = KVStyle::JoinedOrSeparate,
-           help = "Agentic TCP port (0 = disabled)",
-           required = false)
-    <int> port = 0;
+    DecoKV(style = KVStyle::JoinedOrSeparate, help = "Socket mode port", required = false)
+    <int> port = 50051;
 
     DecoKV(style = KVStyle::JoinedOrSeparate,
            names = {"--log-level", "--log-level="},
@@ -43,50 +43,6 @@ struct Options {
            required = false)
     <std::string> record;
 
-    DecoKV(style = KVStyle::JoinedOrSeparate,
-           help = "File path for agentic queries",
-           required = false)
-    <std::string> path;
-
-    DecoKV(
-        style = KVStyle::JoinedOrSeparate,
-        help =
-            "Agentic method (compileCommand, symbolSearch, definition, references, "
-            "documentSymbols, readSymbol, callGraph, typeHierarchy, projectFiles, "
-            "fileDeps, impactAnalysis, status, shutdown)",
-        required = false)
-    <std::string> method;
-
-    DecoKV(style = KVStyle::JoinedOrSeparate,
-           help = "Symbol name for agentic queries",
-           required = false)
-    <std::string> name;
-
-    DecoKV(style = KVStyle::JoinedOrSeparate,
-           help = "Search query for symbolSearch",
-           required = false)
-    <std::string> query;
-
-    DecoKV(style = KVStyle::JoinedOrSeparate,
-           help = "Line number for position-based lookup",
-           required = false)
-    <int> line;
-
-    DecoKV(style = KVStyle::JoinedOrSeparate,
-           help = "Direction: callers/callees or supertypes/subtypes",
-           required = false)
-    <std::string> direction;
-
-    DecoKV(style = KVStyle::JoinedOrSeparate,
-           help = "Unix domain socket path for daemon mode",
-           required = false)
-    <std::string> socket;
-
-    DecoKV(style = KVStyle::JoinedOrSeparate,
-           help = "Workspace root directory for daemon mode",
-           required = false)
-    <std::string> workspace;
-
     // Internal options (passed from master to worker processes)
     DecoKV(style = KVStyle::JoinedOrSeparate,
            names = {"--worker-memory-limit", "--worker-memory-limit="},
@@ -112,6 +68,9 @@ struct Options {
 
 int main(int argc, const char** argv) {
 #ifndef _WIN32
+    // On POSIX systems, ignore SIGPIPE so that writing to a closed pipe
+    // (e.g. when the LSP client disconnects) returns EPIPE instead of
+    // killing the process.  This is standard practice for pipe-based servers.
     signal(SIGPIPE, SIG_IGN);
 #endif
 
@@ -151,6 +110,8 @@ int main(int argc, const char** argv) {
         return 1;
     }
 
+    std::string self_path = argv[0];
+
     auto& mode = *opts.mode;
 
     auto worker_name = opts.worker_name.value_or("");
@@ -170,51 +131,77 @@ int main(int argc, const char** argv) {
                                                log_dir);
     }
 
-    if(mode == "pipe" || mode == "socket") {
-        clice::ServerOptions server_opts;
-        server_opts.mode = mode;
-        server_opts.host = opts.host.value_or("127.0.0.1");
-        server_opts.port = opts.port.value_or(0);
-        server_opts.self_path = argv[0];
-        server_opts.record = opts.record.value_or("");
-        return clice::run_server_mode(server_opts);
-    }
+    if(mode == "pipe") {
+        clice::logging::stderr_logger("master", clice::logging::options);
 
-    if(mode == "daemon") {
-        auto workspace = opts.workspace.value_or("");
-        if(workspace.empty()) {
-            LOG_ERROR("--workspace is required for daemon mode");
+        kota::event_loop loop;
+
+        auto transport = kota::ipc::StreamTransport::open_stdio(loop);
+        if(!transport) {
+            LOG_ERROR("failed to open stdio transport");
             return 1;
         }
 
-        clice::DaemonOptions daemon_opts;
-        daemon_opts.socket_path = opts.socket.value_or("");
-        daemon_opts.workspace = std::move(workspace);
-        daemon_opts.self_path = argv[0];
-        return clice::run_daemon_mode(daemon_opts);
+        std::unique_ptr<kota::ipc::Transport> final_transport = std::move(*transport);
+        if(opts.record.has_value()) {
+            final_transport =
+                std::make_unique<kota::ipc::RecordingTransport>(std::move(final_transport),
+                                                                *opts.record);
+        }
+
+        kota::ipc::JsonPeer peer(loop, std::move(final_transport));
+        clice::MasterServer server(loop, peer, std::move(self_path));
+        server.register_handlers();
+
+        loop.schedule(peer.run());
+        loop.run();
+        return 0;
     }
 
-    if(mode == "agentic") {
-        auto port = opts.port.value_or(0);
-        if(port <= 0) {
-            LOG_ERROR("--port is required for agentic mode");
+    if(mode == "socket") {
+        clice::logging::stderr_logger("master", clice::logging::options);
+
+        kota::event_loop loop;
+
+        auto host = opts.host.value_or("127.0.0.1");
+        auto port = opts.port.value_or(50051);
+
+        auto acceptor = kota::tcp::listen(host, port, {}, loop);
+        if(!acceptor) {
+            LOG_ERROR("failed to listen on {}:{}", host, port);
             return 1;
         }
-        clice::AgenticQueryOptions aq;
-        aq.host = opts.host.value_or("127.0.0.1");
-        aq.port = port;
-        aq.method = opts.method.value_or("compileCommand");
-        aq.path = opts.path.value_or("");
-        aq.name = opts.name.value_or("");
-        aq.query = opts.query.value_or("");
-        aq.line = opts.line.value_or(0);
-        aq.direction = opts.direction.value_or("");
-        return clice::run_agentic_mode(aq);
-    }
 
-    if(mode == "relay") {
-        auto socket = opts.socket.value_or("");
-        return clice::run_relay_mode(socket);
+        LOG_INFO("Listening on {}:{} ...", host, port);
+
+        auto task = [&]() -> kota::task<> {
+            auto client = co_await acceptor->accept();
+            if(!client.has_value()) {
+                LOG_ERROR("failed to accept connection");
+                loop.stop();
+                co_return;
+            }
+
+            LOG_INFO("Client connected");
+
+            std::unique_ptr<kota::ipc::Transport> transport =
+                std::make_unique<kota::ipc::StreamTransport>(std::move(client.value()));
+            if(opts.record.has_value()) {
+                transport = std::make_unique<kota::ipc::RecordingTransport>(std::move(transport),
+                                                                            *opts.record);
+            }
+            kota::ipc::JsonPeer peer(loop, std::move(transport));
+            clice::MasterServer server(loop, peer, std::string(self_path));
+            server.register_handlers();
+
+            co_await peer.run();
+            peer.close();
+            loop.stop();
+        };
+
+        loop.schedule(task());
+        loop.run();
+        return 0;
     }
 
     LOG_ERROR("unknown mode '{}'", mode);

src/compile/compilation.cpp

@@ -242,6 +242,7 @@ CompilationStatus CompilationUnitRef::Self::run_clang(
     std::unique_ptr diagnostic_consumer = self.create_diagnostic();
     std::unique_ptr invocation = self.create_invocation(params, diagnostic_consumer.get());
     if(!invocation) {
+        LOG_WARN("run_clang: invocation creation failed");
         return CompilationStatus::SetupFail;
     }
 
@@ -256,6 +257,7 @@ CompilationStatus CompilationUnitRef::Self::run_clang(
     }
 
     if(!instance.createTarget()) {
+        LOG_WARN("run_clang: target creation failed");
         return CompilationStatus::SetupFail;
     }
 
@@ -270,6 +272,7 @@ CompilationStatus CompilationUnitRef::Self::run_clang(
         /// But if we fail to `BeginSourceFile` we don't need to call `EndSourceFile`. So just
         /// reset it.
         self.action.reset();
+        LOG_WARN("run_clang: BeginSourceFile failed");
         return CompilationStatus::SetupFail;
     }
 
@@ -303,6 +306,8 @@ CompilationStatus CompilationUnitRef::Self::run_clang(
     /// in crash frequently. So forbidden it here and return as error.
     if(!instance.getFrontendOpts().OutputFile.empty() &&
        instance.getDiagnostics().hasErrorOccurred()) {
+        LOG_WARN("run_clang: errors during PCH/PCM generation, output={}",
+                 instance.getFrontendOpts().OutputFile);
         return CompilationStatus::FatalError;
     }
 

src/compile/tidy.cpp

@@ -92,11 +92,15 @@ tidy::ClangTidyOptions create_options() {
                          // include-cleaner is directly integrated in IncludeCleaner.cpp
                          "-misc-include-cleaner",
 
+                         // ----- False Positives -----
+
                          // Check relies on seeing ifndef/define/endif directives,
                          // clangd doesn't replay those when using a preamble.
                          "-llvm-header-guard",
                          "-modernize-macro-to-enum",
 
+                         // ----- Crashing Checks -----
+
                          // Check can choke on invalid (intermediate) c++
                          // code, which is often the case when clangd
                          // tries to build an AST.

src/feature/feature.h

@@ -104,6 +104,4 @@ auto document_format(llvm::StringRef file,
                      PositionEncoding encoding = PositionEncoding::UTF16)
     -> std::vector<protocol::TextEdit>;
 
-auto format_code(llvm::StringRef file, llvm::StringRef code) -> std::string;
-
 }  // namespace clice::feature

src/feature/formatting.cpp

@@ -49,7 +49,7 @@ auto document_format(llvm::StringRef file,
         range ? tooling::Range(range->begin, range->length()) : tooling::Range(0, content.size());
     auto replacements = format_content(file, content, selection);
     if(!replacements) {
-        LOG_WARN("Failed to format {}: {}", file, replacements.error());
+        LOG_INFO("Fail to format for {}\n{}", file, replacements.error());
         return edits;
     }
 
@@ -66,20 +66,4 @@ auto document_format(llvm::StringRef file,
     return edits;
 }
 
-auto format_code(llvm::StringRef file, llvm::StringRef code) -> std::string {
-    auto style = clang::format::getStyle(clang::format::DefaultFormatStyle,
-                                         file,
-                                         clang::format::DefaultFallbackStyle,
-                                         code);
-    if(!style)
-        return code.str();
-
-    auto replacements = clang::format::reformat(*style, code, {tooling::Range(0, code.size())});
-    auto result = tooling::applyAllReplacements(code, replacements);
-    if(!result)
-        return code.str();
-
-    return llvm::StringRef(*result).trim().str();
-}
-
 }  // namespace clice::feature

src/semantic/resolver.cpp

@@ -1111,6 +1111,8 @@ public:
         return Base::TransformDecltypeType(TLB, TL);
     }
 
+    // --- State ---
+
 private:
     clang::Sema& sema;
     clang::ASTContext& context;

src/server/compile_graph.cpp

@@ -1,4 +1,4 @@
-#include "server/compiler/compile_graph.h"
+#include "server/compile_graph.h"
 
 #include <algorithm>
 

src/server/compiler.cpp

@@ -1,4 +1,4 @@
-#include "server/compiler/compiler.h"
+#include "server/compiler.h"
 
 #include <format>
 #include <ranges>
@@ -6,7 +6,7 @@
 
 #include "command/search_config.h"
 #include "index/tu_index.h"
-#include "server/protocol/worker.h"
+#include "server/protocol.h"
 #include "support/filesystem.h"
 #include "support/logging.h"
 #include "syntax/include_resolver.h"
@@ -28,20 +28,16 @@ using serde_raw = kota::codec::RawValue;
 /// Detect whether the cursor is inside a preamble directive (include/import).
 
 Compiler::Compiler(kota::event_loop& loop,
+                   kota::ipc::JsonPeer& peer,
                    Workspace& workspace,
                    WorkerPool& pool,
                    llvm::DenseMap<std::uint32_t, Session>& sessions) :
-    loop(loop), workspace(workspace), pool(pool), sessions(sessions) {}
+    loop(loop), peer(peer), workspace(workspace), pool(pool), sessions(sessions) {}
 
 Compiler::~Compiler() {
     workspace.cancel_all();
 }
 
-kota::task<> Compiler::stop() {
-    compile_tasks.cancel();
-    co_await compile_tasks.join();
-}
-
 void Compiler::init_compile_graph() {
     if(workspace.path_to_module.empty()) {
         LOG_INFO("No C++20 modules detected, skipping CompileGraph");
@@ -126,9 +122,11 @@ void Compiler::init_compile_graph() {
 
         auto result = co_await pool.send_stateless(bp);
         if(!result.has_value() || !result.value().success) {
-            LOG_WARN("BuildPCM failed for module {}: {}",
-                     mod_it->second,
-                     result.has_value() ? result.value().error : result.error().message);
+            auto error_msg = result.has_value() ? result.value().error : result.error().message;
+            LOG_WARN("BuildPCM failed for module {}: {}", mod_it->second, error_msg);
+            peer.send_notification(protocol::LogMessageParams{
+                protocol::MessageType::Warning,
+                std::format("PCM build failed for module {}: {}", mod_it->second, error_msg)});
             co_return false;
         }
 
@@ -175,6 +173,10 @@ bool Compiler::fill_compile_args(llvm::StringRef path,
         auto& cmd = results.front();
         directory = cmd.resolved.directory.str();
         arguments = cmd.to_string_argv();
+        LOG_DEBUG("fill_compile_args: CDB match for {} (dir={}, {} args)",
+                  path,
+                  directory,
+                  arguments.size());
         return true;
     }
 
@@ -414,8 +416,6 @@ std::string uri_to_path(const std::string& uri) {
 void Compiler::publish_diagnostics(const std::string& uri,
                                    int version,
                                    const kota::codec::RawValue& diagnostics_json) {
-    if(!peer)
-        return;
     std::vector<protocol::Diagnostic> diagnostics;
     if(!diagnostics_json.empty()) {
         auto status = kota::codec::json::from_json(diagnostics_json.data, diagnostics);
@@ -427,16 +427,14 @@ void Compiler::publish_diagnostics(const std::string& uri,
     params.uri = uri;
     params.version = version;
     params.diagnostics = std::move(diagnostics);
-    peer->send_notification(params);
+    peer.send_notification(params);
 }
 
 void Compiler::clear_diagnostics(const std::string& uri) {
-    if(!peer)
-        return;
     protocol::PublishDiagnosticsParams params;
     params.uri = uri;
     params.diagnostics = {};
-    peer->send_notification(params);
+    peer.send_notification(params);
 }
 
 kota::task<bool> Compiler::ensure_pch(Session& session,
@@ -529,9 +527,11 @@ kota::task<bool> Compiler::ensure_pch(Session& session,
     auto result = co_await pool.send_stateless(bp);
 
     if(!result.has_value() || !result.value().success) {
-        LOG_WARN("PCH build failed for {}: {}",
-                 path,
-                 result.has_value() ? result.value().error : result.error().message);
+        auto error_msg = result.has_value() ? result.value().error : result.error().message;
+        LOG_WARN("PCH build failed for {}: {}", path, error_msg);
+        peer.send_notification(protocol::LogMessageParams{
+            protocol::MessageType::Warning,
+            std::format("PCH build failed for {}: {}", path, error_msg)});
         workspace.pch_cache[path_id].building.reset();
         completion->set();
         co_return false;
@@ -637,101 +637,6 @@ void Compiler::record_deps(Session& session, llvm::ArrayRef<std::string> deps) {
 /// Called lazily by forward_query() / forward_build() before every
 /// feature request (hover, semantic tokens, etc.). Guarantees that when it
 /// returns true the stateful worker assigned to `path_id` holds an up-to-date
-kota::task<> Compiler::run_compile(std::uint32_t pid, std::shared_ptr<Session::PendingCompile> pc) {
-    auto find_session = [&]() -> Session* {
-        auto it = sessions.find(pid);
-        return it != sessions.end() ? &it->second : nullptr;
-    };
-
-    auto* sess = find_session();
-    if(!sess) {
-        pc->done.set();
-        co_return;
-    }
-
-    auto finish_compile = [&]() {
-        auto* s = find_session();
-        if(s && s->compiling == pc) {
-            s->compiling.reset();
-        }
-        LOG_INFO("ensure_compiled: finish path_id={}", pid);
-        pc->done.set();
-    };
-
-    auto gen = sess->generation;
-    LOG_INFO("ensure_compiled: starting compile path_id={} gen={}", pid, gen);
-
-    auto file_path = std::string(workspace.path_pool.resolve(pid));
-    auto uri = lsp::URI::from_file_path(file_path);
-    std::string uri_str = uri.has_value() ? uri->str() : file_path;
-
-    worker::CompileParams params;
-    params.path = file_path;
-    params.version = sess->version;
-    params.text = sess->text;
-    if(!fill_compile_args(file_path, params.directory, params.arguments, sess)) {
-        finish_compile();
-        co_return;
-    }
-
-    if(!co_await ensure_deps(*sess, params.directory, params.arguments, params.pch, params.pcms)) {
-        LOG_WARN("Dependency preparation failed for {}, skipping compile", uri_str);
-        finish_compile();
-        co_return;
-    }
-
-    sess = find_session();
-    if(!sess) {
-        pc->done.set();
-        co_return;
-    }
-
-    auto result = co_await pool.send_stateful(pid, params);
-
-    sess = find_session();
-    if(!sess) {
-        pc->done.set();
-        co_return;
-    }
-
-    if(sess->generation != gen) {
-        LOG_INFO("ensure_compiled: generation mismatch ({} vs {}) for {}",
-                 sess->generation,
-                 gen,
-                 uri_str);
-        finish_compile();
-        co_return;
-    }
-
-    if(!result.has_value()) {
-        LOG_WARN("Compile failed for {}: {}", uri_str, result.error().message);
-        clear_diagnostics(uri_str);
-        finish_compile();
-        co_return;
-    }
-
-    sess->ast_dirty = false;
-    pc->succeeded = true;
-    record_deps(*sess, result.value().deps);
-
-    if(!result.value().tu_index_data.empty()) {
-        auto tu_index = index::TUIndex::from(result.value().tu_index_data.data());
-        OpenFileIndex ofi;
-        ofi.file_index = std::move(tu_index.main_file_index);
-        ofi.symbols = std::move(tu_index.symbols);
-        ofi.content = sess->text;
-        ofi.mapper.emplace(ofi.content, lsp::PositionEncoding::UTF16);
-        sess->file_index = std::move(ofi);
-    }
-
-    auto version = sess->version;
-    finish_compile();
-
-    publish_diagnostics(uri_str, version, result.value().diagnostics);
-    if(on_indexing_needed)
-        on_indexing_needed();
-}
-
 /// AST and diagnostics have been published to the client.
 ///
 /// Lifecycle overview (pull-based model):
@@ -751,9 +656,9 @@ kota::task<> Compiler::run_compile(std::uint32_t pid, std::shared_ptr<Session::P
 /// worker); every other file is read from disk by the compiler.
 ///
 /// Concurrency: multiple concurrent feature requests for the same file will
-/// each call ensure_compiled(). The first one spawns a compile task into the
-/// Compiler's task_group; subsequent ones wait on the shared event.
-/// The spawned task is not cancelled by LSP $/cancelRequest, preventing
+/// each call ensure_compiled(). The first one launches a detached compile
+/// task via loop.schedule(); subsequent ones wait on the shared event.
+/// The detached task cannot be cancelled by LSP $/cancelRequest, preventing
 /// the race where cancellation wakes all waiters and they all start compiles.
 kota::task<bool> Compiler::ensure_compiled(Session& session) {
     auto path_id = session.path_id;
@@ -782,12 +687,134 @@ kota::task<bool> Compiler::ensure_compiled(Session& session) {
             co_return true;
     }
 
+    // No compile in flight and AST is dirty — launch a detached compile task.
+    // The detached task is scheduled via loop.schedule() so it is NOT subject
+    // to LSP $/cancelRequest cancellation.  This eliminates the race where
+    // cancellation fires the RAII guard, waking all waiters simultaneously
+    // and causing them all to start new compiles.
     auto pending_compile = std::make_shared<Session::PendingCompile>();
     session.compiling = pending_compile;
 
-    LOG_INFO("ensure_compiled: launching compile path_id={} gen={}", path_id, session.generation);
+    LOG_INFO("ensure_compiled: launching detached compile path_id={} gen={}",
+             path_id,
+             session.generation);
 
-    compile_tasks.spawn(run_compile(path_id, pending_compile));
+    // Capture path_id by value so the detached lambda can re-lookup the session
+    // from the sessions map after co_await (DenseMap may invalidate pointers).
+    loop.schedule([](Compiler* self,
+                     std::uint32_t pid,
+                     std::shared_ptr<Session::PendingCompile> pc) -> kota::task<> {
+        // Re-lookup session from the sessions map (pointer may have been
+        // invalidated by DenseMap growth during co_await).
+        auto find_session = [&]() -> Session* {
+            auto it = self->sessions.find(pid);
+            return it != self->sessions.end() ? &it->second : nullptr;
+        };
+
+        auto* sess = find_session();
+        if(!sess) {
+            pc->done.set();
+            co_return;
+        }
+
+        auto finish_compile = [&]() {
+            auto* s = find_session();
+            if(s && s->compiling == pc) {
+                s->compiling.reset();
+            }
+            LOG_INFO("ensure_compiled: finish_compile (detached) path_id={}", pid);
+            pc->done.set();
+        };
+
+        auto gen = sess->generation;
+        LOG_INFO("ensure_compiled: starting compile (detached) path_id={} gen={}", pid, gen);
+
+        auto file_path = std::string(self->workspace.path_pool.resolve(pid));
+        auto uri = lsp::URI::from_file_path(file_path);
+        std::string uri_str = uri.has_value() ? uri->str() : file_path;
+
+        worker::CompileParams params;
+        params.path = file_path;
+        params.version = sess->version;
+        params.text = sess->text;
+        if(!self->fill_compile_args(file_path, params.directory, params.arguments, sess)) {
+            LOG_WARN("ensure_compiled: no compile args for {}", uri_str);
+            self->peer.send_notification(protocol::LogMessageParams{
+                protocol::MessageType::Warning,
+                std::format("No compile arguments available for {}", file_path)});
+            finish_compile();
+            co_return;
+        }
+
+        if(!co_await self
+                ->ensure_deps(*sess, params.directory, params.arguments, params.pch, params.pcms)) {
+            LOG_WARN("Dependency preparation failed for {}, skipping compile", uri_str);
+            self->peer.send_notification(protocol::LogMessageParams{
+                protocol::MessageType::Warning,
+                std::format("Dependency preparation failed for {}", file_path)});
+            finish_compile();
+            co_return;
+        }
+
+        // Re-lookup after co_await (DenseMap may have grown).
+        sess = find_session();
+        if(!sess) {
+            pc->done.set();
+            co_return;
+        }
+
+        auto result = co_await self->pool.send_stateful(pid, params);
+
+        // Re-lookup after co_await.
+        sess = find_session();
+        if(!sess) {
+            pc->done.set();
+            co_return;
+        }
+
+        if(sess->generation != gen) {
+            LOG_INFO("ensure_compiled: generation mismatch ({} vs {}) for {}",
+                     sess->generation,
+                     gen,
+                     uri_str);
+            finish_compile();
+            co_return;
+        }
+
+        if(!result.has_value()) {
+            LOG_WARN("Compile failed for {}: {}", uri_str, result.error().message);
+            self->peer.send_notification(protocol::LogMessageParams{
+                protocol::MessageType::Error,
+                std::format("Compilation failed for {}: {}", file_path, result.error().message)});
+            self->clear_diagnostics(uri_str);
+            finish_compile();
+            co_return;
+        }
+
+        sess->ast_dirty = false;
+        pc->succeeded = true;
+        self->record_deps(*sess, result.value().deps);
+
+        // Store open file index from the stateful worker's TUIndex.
+        if(!result.value().tu_index_data.empty()) {
+            auto tu_index = index::TUIndex::from(result.value().tu_index_data.data());
+            OpenFileIndex ofi;
+            ofi.file_index = std::move(tu_index.main_file_index);
+            ofi.symbols = std::move(tu_index.symbols);
+            ofi.content = sess->text;
+            ofi.mapper.emplace(ofi.content, lsp::PositionEncoding::UTF16);
+            sess->file_index = std::move(ofi);
+        }
+
+        auto version = sess->version;
+        finish_compile();
+
+        // Publish diagnostics AFTER marking compile as done, so that concurrent
+        // forward_query() calls can proceed immediately.
+        self->publish_diagnostics(uri_str, version, result.value().diagnostics);
+        if(self->on_indexing_needed)
+            self->on_indexing_needed();
+    }(this, path_id, pending_compile));
 
     // Wait for the detached compile to finish.  If this wait is cancelled
     // by LSP $/cancelRequest, the detached task continues unaffected.
@@ -807,11 +834,17 @@ Compiler::RawResult Compiler::forward_query(worker::QueryKind kind,
     auto text = session.text;
 
     if(!co_await ensure_compiled(session)) {
-        co_return serde_raw{"null"};
+        LOG_WARN("forward_query: compilation failed for {}", path);
+        co_await kota::fail("Compilation failed");
     }
 
     auto sit = sessions.find(path_id);
-    if(sit == sessions.end() || sit->second.ast_dirty) {
+    if(sit == sessions.end()) {
+        LOG_WARN("forward_query: session lost after compile for {}", path);
+        co_await kota::fail("Document was closed during compilation");
+    }
+    if(sit->second.ast_dirty) {
+        LOG_DEBUG("forward_query: still dirty after compile for {} (concurrent edit)", path);
         co_return serde_raw{"null"};
     }
 
@@ -823,8 +856,13 @@ Compiler::RawResult Compiler::forward_query(worker::QueryKind kind,
 
     if(position) {
         auto offset = mapper.to_offset(*position);
-        if(!offset)
-            co_return serde_raw{"null"};
+        if(!offset) {
+            LOG_WARN("forward_query: invalid position {}:{} for {}",
+                     position->line,
+                     position->character,
+                     path);
+            co_await kota::fail("Invalid position: failed to convert to byte offset");
+        }
         wp.offset = *offset;
     }
 
@@ -838,7 +876,8 @@ Compiler::RawResult Compiler::forward_query(worker::QueryKind kind,
 
     auto result = co_await pool.send_stateful(path_id, wp);
     if(!result.has_value()) {
-        co_return serde_raw{};
+        LOG_WARN("forward_query: worker failed for {}: {}", path, result.error().message);
+        co_await kota::fail(result.error().message);
     }
     co_return std::move(result.value());
 }
@@ -857,53 +896,36 @@ Compiler::RawResult Compiler::forward_build(worker::BuildKind kind,
     wp.version = session.version;
     wp.text = session.text;
     if(!fill_compile_args(path, wp.directory, wp.arguments, &session)) {
-        co_return serde_raw{};
+        LOG_WARN("forward_build: compile args not available for {}", path);
+        co_await kota::fail("Compile arguments not available");
     }
 
     if(!co_await ensure_deps(session, wp.directory, wp.arguments, wp.pch, wp.pcms)) {
-        co_return serde_raw{};
+        LOG_WARN("forward_build: dependency preparation failed for {}", path);
+        co_await kota::fail("Dependency preparation failed");
     }
 
     // After co_await, verify session still exists.
     if(sessions.find(path_id) == sessions.end()) {
-        co_return serde_raw{};
+        LOG_WARN("forward_build: session lost after co_await for {}", path);
+        co_await kota::fail("Document was closed during compilation");
     }
 
     lsp::PositionMapper mapper(wp.text, lsp::PositionEncoding::UTF16);
     auto offset = mapper.to_offset(position);
-    if(!offset)
-        co_return serde_raw{"null"};
+    if(!offset) {
+        LOG_WARN("forward_build: invalid position {}:{} for {}",
+                 position.line,
+                 position.character,
+                 path);
+        co_await kota::fail("Invalid position: failed to convert to byte offset");
+    }
     wp.offset = *offset;
 
     auto result = co_await pool.send_stateless(wp);
     if(!result.has_value()) {
-        co_return serde_raw{};
-    }
-    co_return std::move(result.value().result_json);
-}
-
-Compiler::RawResult Compiler::forward_format(Session& session,
-                                             std::optional<protocol::Range> range) {
-    auto path_id = session.path_id;
-    auto path = std::string(workspace.path_pool.resolve(path_id));
-
-    worker::BuildParams wp;
-    wp.kind = worker::BuildKind::Format;
-    wp.file = path;
-    wp.text = session.text;
-
-    if(range) {
-        lsp::PositionMapper mapper(wp.text, lsp::PositionEncoding::UTF16);
-        auto begin = mapper.to_offset(range->start);
-        auto end = mapper.to_offset(range->end);
-        if(!begin || !end)
-            co_return serde_raw{"null"};
-        wp.format_range = {*begin, *end};
-    }
-
-    auto result = co_await pool.send_stateless(wp);
-    if(!result.has_value()) {
-        co_return serde_raw{"null"};
+        LOG_WARN("forward_build: worker failed for {}: {}", path, result.error().message);
+        co_await kota::fail(result.error().message);
     }
     co_return std::move(result.value().result_json);
 }
@@ -921,8 +943,10 @@ Compiler::RawResult Compiler::handle_completion(const protocol::Position& positi
            pctx.kind == CompletionContext::IncludeAngled) {
             std::string directory;
             std::vector<std::string> arguments;
-            if(!fill_compile_args(path, directory, arguments))
-                co_return serde_raw{"[]"};
+            if(!fill_compile_args(path, directory, arguments)) {
+                LOG_WARN("handle_completion: compile args not available for {}", path);
+                co_await kota::fail("Compile arguments not available for include completion");
+            }
 
             std::vector<const char*> args_ptrs;
             args_ptrs.reserve(arguments.size());

src/server/compiler.h

@@ -8,9 +8,9 @@
 #include <vector>
 
 #include "command/command.h"
-#include "server/service/session.h"
-#include "server/worker/worker_pool.h"
-#include "server/workspace/workspace.h"
+#include "server/session.h"
+#include "server/worker_pool.h"
+#include "server/workspace.h"
 #include "syntax/completion.h"
 
 #include "kota/async/async.h"
@@ -50,14 +50,10 @@ std::string uri_to_path(const std::string& uri);
 class Compiler {
 public:
     Compiler(kota::event_loop& loop,
+             kota::ipc::JsonPeer& peer,
              Workspace& workspace,
              WorkerPool& pool,
              llvm::DenseMap<std::uint32_t, Session>& sessions);
-
-    void set_peer(kota::ipc::JsonPeer* p) {
-        peer = p;
-    }
-
     ~Compiler();
 
     void init_compile_graph();
@@ -90,9 +86,6 @@ public:
                             const protocol::Position& position,
                             Session& session);
 
-    /// Forward a formatting request to a stateless worker.
-    RawResult forward_format(Session& session, std::optional<protocol::Range> range = {});
-
     /// Handle completion requests.  Detects preamble context (include/import)
     /// and serves those locally; delegates code completion to a stateless worker.
     RawResult handle_completion(const protocol::Position& position, Session& session);
@@ -103,12 +96,7 @@ public:
     /// Callback invoked when indexing should be scheduled.
     std::function<void()> on_indexing_needed;
 
-    /// Cancel in-flight compile tasks and wait for them to finish.
-    kota::task<> stop();
-
 private:
-    kota::task<> run_compile(std::uint32_t path_id, std::shared_ptr<Session::PendingCompile> pc);
-
     kota::task<bool> ensure_deps(Session& session,
                                  const std::string& directory,
                                  const std::vector<std::string>& arguments,
@@ -137,11 +125,10 @@ private:
 
 private:
     kota::event_loop& loop;
-    kota::ipc::JsonPeer* peer = nullptr;
+    kota::ipc::JsonPeer& peer;
     Workspace& workspace;
     WorkerPool& pool;
     llvm::DenseMap<std::uint32_t, Session>& sessions;
-    kota::task_group<> compile_tasks{loop};
 };
 
 }  // namespace clice

src/server/config.cpp

@@ -1,4 +1,4 @@
-#include "server/workspace/config.h"
+#include "server/config.h"
 
 #include <algorithm>
 
@@ -168,7 +168,7 @@ std::optional<Config> Config::load_from_json(llvm::StringRef json, llvm::StringR
     return config;
 }
 
-Config Config::load_from_workspace(llvm::StringRef workspace_root) {
+Config Config::load_from_workspace(llvm::StringRef workspace_root, std::string* warning) {
     if(!workspace_root.empty()) {
         for(auto* name: {"clice.toml", ".clice/config.toml"}) {
             auto config_path = path::join(workspace_root, name);
@@ -179,6 +179,9 @@ Config Config::load_from_workspace(llvm::StringRef workspace_root) {
             // Present but malformed: fall through to defaults, but surface
             // the situation clearly so users know their config wasn't applied.
             LOG_WARN("Falling back to default configuration because {} is invalid", config_path);
+            if(warning)
+                *warning = std::format("Configuration file {} is invalid, falling back to defaults",
+                                       config_path);
         }
     }
 

src/server/config.h

@@ -73,7 +73,10 @@ struct Config {
 
     /// Load config from the workspace, trying standard locations.
     /// Returns a default config (with apply_defaults) if no file is found.
-    static Config load_from_workspace(llvm::StringRef workspace_root);
+    /// If `warning` is non-null and a config file was found but malformed,
+    /// the warning message is written there.
+    static Config load_from_workspace(llvm::StringRef workspace_root,
+                                      std::string* warning = nullptr);
 };
 
 }  // namespace clice

src/server/indexer.cpp

@@ -1,4 +1,4 @@
-#include "server/compiler/indexer.h"
+#include "server/indexer.h"
 
 #include <algorithm>
 #include <string>
@@ -6,10 +6,10 @@
 #include <vector>
 
 #include "index/tu_index.h"
-#include "server/compiler/compiler.h"
-#include "server/protocol/worker.h"
-#include "server/service/session.h"
-#include "server/worker/worker_pool.h"
+#include "server/compiler.h"
+#include "server/protocol.h"
+#include "server/session.h"
+#include "server/worker_pool.h"
 #include "support/filesystem.h"
 #include "support/logging.h"
 
@@ -447,152 +447,6 @@ std::optional<SymbolInfo> Indexer::resolve_symbol(index::SymbolHash hash) {
     return SymbolInfo{hash, std::move(name), kind, def_loc->uri, def_loc->range};
 }
 
-static std::string extract_line(llvm::StringRef content, std::uint32_t offset) {
-    if(content.empty() || offset >= content.size())
-        return {};
-    std::size_t line_start = 0;
-    if(offset > 0) {
-        auto pos = content.rfind('\n', offset - 1);
-        if(pos != llvm::StringRef::npos)
-            line_start = pos + 1;
-    }
-    auto line_end = content.find('\n', offset);
-    if(line_end == llvm::StringRef::npos)
-        line_end = content.size();
-    return content.slice(line_start, line_end).str();
-}
-
-std::optional<Indexer::DefinitionText> Indexer::get_definition_text(index::SymbolHash hash) {
-    for(auto& [id, sess]: sessions) {
-        if(!sess.file_index || !sess.file_index->mapper)
-            continue;
-        auto it = sess.file_index->file_index.relations.find(hash);
-        if(it == sess.file_index->file_index.relations.end())
-            continue;
-        for(auto& rel: it->second) {
-            if(rel.kind.value() != RelationKind::Definition)
-                continue;
-            auto def_range = std::bit_cast<LocalSourceRange>(rel.target_symbol);
-            if(def_range.begin >= def_range.end)
-                continue;
-            llvm::StringRef content = sess.file_index->content;
-            if(def_range.end > content.size())
-                continue;
-            auto start = sess.file_index->mapper->to_position(def_range.begin);
-            auto end = sess.file_index->mapper->to_position(def_range.end);
-            if(!start || !end)
-                continue;
-            return DefinitionText{
-                .file = std::string(workspace.path_pool.resolve(id)),
-                .start_line = static_cast<int>(start->line) + 1,
-                .end_line = static_cast<int>(end->line) + 1,
-                .text =
-                    std::string(content.substr(def_range.begin, def_range.end - def_range.begin)),
-            };
-        }
-    }
-
-    auto sym_it = workspace.project_index.symbols.find(hash);
-    if(sym_it == workspace.project_index.symbols.end())
-        return std::nullopt;
-
-    for(auto file_id: sym_it->second.reference_files) {
-        if(is_proj_path_open(file_id))
-            continue;
-        auto shard_it = workspace.merged_indices.find(file_id);
-        if(shard_it == workspace.merged_indices.end())
-            continue;
-        auto* m = shard_it->second.mapper();
-        if(!m)
-            continue;
-        auto content = shard_it->second.index.content();
-
-        std::optional<DefinitionText> result;
-        shard_it->second.index.lookup(
-            hash,
-            RelationKind::Definition,
-            [&](const index::Relation& r) {
-                auto def_range = std::bit_cast<LocalSourceRange>(r.target_symbol);
-                if(def_range.begin >= def_range.end || def_range.end > content.size())
-                    return true;
-                auto start = m->to_position(def_range.begin);
-                auto end = m->to_position(def_range.end);
-                if(!start || !end)
-                    return true;
-                result = DefinitionText{
-                    .file = workspace.project_index.path_pool.path(file_id).str(),
-                    .start_line = static_cast<int>(start->line) + 1,
-                    .end_line = static_cast<int>(end->line) + 1,
-                    .text = std::string(
-                        content.substr(def_range.begin, def_range.end - def_range.begin)),
-                };
-                return false;
-            });
-        if(result)
-            return result;
-    }
-
-    return std::nullopt;
-}
-
-std::vector<Indexer::ReferenceWithContext> Indexer::collect_references(index::SymbolHash hash,
-                                                                       RelationKind kind) {
-    std::vector<ReferenceWithContext> results;
-
-    auto sym_it = workspace.project_index.symbols.find(hash);
-    if(sym_it != workspace.project_index.symbols.end()) {
-        for(auto file_id: sym_it->second.reference_files) {
-            if(is_proj_path_open(file_id))
-                continue;
-            auto shard_it = workspace.merged_indices.find(file_id);
-            if(shard_it == workspace.merged_indices.end())
-                continue;
-            auto* m = shard_it->second.mapper();
-            if(!m)
-                continue;
-            auto content = shard_it->second.index.content();
-            auto file_path = workspace.project_index.path_pool.path(file_id);
-
-            shard_it->second.index.lookup(hash, kind, [&](const index::Relation& r) {
-                auto start = m->to_position(r.range.begin);
-                if(!start)
-                    return true;
-                results.push_back(ReferenceWithContext{
-                    .file = file_path.str(),
-                    .line = static_cast<int>(start->line) + 1,
-                    .context = extract_line(content, r.range.begin),
-                });
-                return true;
-            });
-        }
-    }
-
-    for(auto& [id, sess]: sessions) {
-        if(!sess.file_index || !sess.file_index->mapper)
-            continue;
-        auto it = sess.file_index->file_index.relations.find(hash);
-        if(it == sess.file_index->file_index.relations.end())
-            continue;
-        auto file_path = workspace.path_pool.resolve(id);
-        llvm::StringRef content = sess.file_index->content;
-
-        for(auto& rel: it->second) {
-            if(rel.kind != kind)
-                continue;
-            auto start = sess.file_index->mapper->to_position(rel.range.begin);
-            if(!start)
-                continue;
-            results.push_back(ReferenceWithContext{
-                .file = file_path.str(),
-                .line = static_cast<int>(start->line) + 1,
-                .context = extract_line(content, rel.range.begin),
-            });
-        }
-    }
-
-    return results;
-}
-
 std::vector<protocol::CallHierarchyIncomingCall>
     Indexer::find_incoming_calls(index::SymbolHash hash) {
     llvm::DenseMap<index::SymbolHash, std::vector<protocol::Range>> caller_ranges;
@@ -788,11 +642,6 @@ void Indexer::resume_indexing() {
     }
 }
 
-kota::task<> Indexer::stop() {
-    bg_tasks.cancel();
-    co_await bg_tasks.join();
-}
-
 void Indexer::schedule() {
     if(!*workspace.config.project.enable_indexing || indexing_active || indexing_scheduled)
         return;
@@ -802,11 +651,7 @@ void Indexer::schedule() {
         index_idle_timer = std::make_shared<kota::timer>(kota::timer::create(loop));
     }
     index_idle_timer->start(std::chrono::milliseconds(*workspace.config.project.idle_timeout_ms));
-
-    if(!bg_tasks.spawn(run_background_indexing())) {
-        indexing_scheduled = false;
-        LOG_WARN("Failed to spawn background indexing task (task group stopped)");
-    }
+    loop.schedule(run_background_indexing());
 }
 
 kota::task<> Indexer::index_one(std::uint32_t server_path_id) {
@@ -849,14 +694,18 @@ kota::task<> Indexer::index_one(std::uint32_t server_path_id) {
     }
 }
 
-kota::task<> Indexer::monitor_resources() {
-    while(true) {
-        co_await kota::sleep(std::chrono::milliseconds(3000));
+kota::task<> Indexer::monitor_resources(std::uint32_t generation) {
+    while(generation == monitor_generation) {
+        co_await kota::sleep(std::chrono::milliseconds(3000), loop);
+
+        if(generation != monitor_generation)
+            break;
 
         auto mem = kota::sys::memory();
         if(mem.total == 0)
             continue;
 
+        // Respect cgroup/container limits when present.
         auto effective_total =
             (mem.constrained > 0 && mem.constrained < mem.total) ? mem.constrained : mem.total;
         auto ratio = static_cast<double>(mem.available) / static_cast<double>(effective_total);
@@ -887,73 +736,87 @@ kota::task<> Indexer::run_background_indexing() {
     }
 
     indexing_active = true;
+    ++monitor_generation;
+    loop.schedule(monitor_resources(monitor_generation));
 
-    kota::cancellation_source monitor_cancel;
-    bg_tasks.spawn(kota::with_token(monitor_resources(), monitor_cancel.token()));
-
+    // Put module interface units first so their PCMs are built before
+    // non-module files that might import them.
     std::stable_partition(
         index_queue.begin() + index_queue_pos,
         index_queue.end(),
         [this](std::uint32_t id) { return workspace.path_to_module.contains(id); });
 
-    auto total = index_queue.size() - index_queue_pos;
+    auto batch = index_queue.size() - index_queue_pos;
     std::size_t dispatched = 0;
     std::size_t completed = 0;
+    finished = 0;
 
+    // Progress reporting via LSP $/progress.
     std::optional<lsp::ProgressReporter<kota::ipc::JsonPeer>> progress;
     if(peer) {
         progress.emplace(*peer, protocol::ProgressToken(std::string("clice/backgroundIndex")));
         auto create_result = co_await progress->create();
         if(!create_result.has_error()) {
-            progress->begin("Indexing", std::format("0/{} files", total), 0);
+            progress->begin("Indexing", std::format("0/{} files", batch), 0);
         } else {
             progress.reset();
         }
     }
 
-    kota::task_group<> workers(loop);
-    std::size_t in_flight = 0;
-    kota::event slot_available;
-
-    while(index_queue_pos < index_queue.size()) {
-        if(pause_depth > 0)
-            co_await resume_event.wait();
-
-        auto server_path_id = index_queue[index_queue_pos++];
-        auto file_path = std::string(workspace.path_pool.resolve(server_path_id));
-        if(sessions.contains(server_path_id) || !need_update(file_path)) {
-            ++completed;
-            continue;
-        }
-
-        while(in_flight >= max_concurrent) {
-            slot_available.reset();
-            co_await slot_available.wait();
-        }
-
-        ++in_flight;
-        ++dispatched;
-        workers.spawn([&, server_path_id]() -> kota::task<> {
-            co_await index_one(server_path_id);
-            --in_flight;
-            ++completed;
-            if(progress) {
-                auto pct = total > 0 ? static_cast<std::uint32_t>(completed * 100 / total) : 100;
-                progress->report(std::format("{}/{} files", completed, total), pct);
+    while(index_queue_pos < index_queue.size() || inflight > 0) {
+        // Dispatch new tasks up to max_concurrent.
+        while(index_queue_pos < index_queue.size() && inflight < max_concurrent) {
+            // Wait if paused by a user request.
+            if(pause_depth > 0) {
+                co_await resume_event.wait();
             }
-            slot_available.set();
-        }());
-    }
 
-    co_await workers.join();
+            auto server_path_id = index_queue[index_queue_pos++];
+
+            // Quick pre-filter: skip open files and fresh files without
+            // consuming a concurrency slot.
+            auto file_path = std::string(workspace.path_pool.resolve(server_path_id));
+            if(sessions.contains(server_path_id) || !need_update(file_path)) {
+                ++completed;
+                continue;
+            }
+
+            ++inflight;
+            ++dispatched;
+
+            // Launch the index task.  On completion it decrements
+            // inflight, bumps finished, and signals the event.
+            loop.schedule([](Indexer* self, std::uint32_t id, kota::event& done) -> kota::task<> {
+                co_await self->index_one(id);
+                --self->inflight;
+                ++self->finished;
+                done.set();
+            }(this, server_path_id, completion_event));
+        }
+
+        if(inflight == 0)
+            break;
+
+        // Wait for at least one task to finish.
+        co_await completion_event.wait();
+        completion_event.reset();
+
+        // Drain all completions that occurred since last wake.
+        completed += std::exchange(finished, 0);
+
+        // Report progress.
+        if(progress) {
+            auto pct = batch > 0 ? static_cast<std::uint32_t>(completed * 100 / batch) : 100;
+            progress->report(std::format("{}/{} files", completed, batch), pct);
+        }
+    }
 
     if(progress) {
         progress->end(std::format("Indexed {} files", dispatched));
     }
 
-    monitor_cancel.cancel();
-
     indexing_active = false;
+    ++monitor_generation;  // Stop the monitor coroutine.
     LOG_INFO("Background indexing complete: {} files dispatched", dispatched);
     save(workspace.config.project.index_dir);
 }

src/server/indexer.h

@@ -9,7 +9,7 @@
 
 #include "semantic/relation_kind.h"
 #include "semantic/symbol_kind.h"
-#include "server/workspace/workspace.h"
+#include "server/workspace.h"
 
 #include "kota/async/async.h"
 #include "kota/ipc/codec/json.h"
@@ -61,8 +61,8 @@ public:
             WorkerPool& pool,
             Compiler& compiler,
             std::function<bool(std::uint32_t)> is_file_open = {}) :
-        loop(loop), bg_tasks(loop), workspace(workspace), sessions(sessions), pool(pool),
-        compiler(compiler), is_file_open(std::move(is_file_open)) {}
+        loop(loop), workspace(workspace), sessions(sessions), pool(pool), compiler(compiler),
+        is_file_open(std::move(is_file_open)) {}
 
     /// Set the LSP peer for progress reporting.  Must be called before
     /// schedule() if progress notifications are desired.
@@ -167,43 +167,6 @@ public:
     std::vector<protocol::SymbolInformation> search_symbols(llvm::StringRef query,
                                                             std::size_t max_results = 100);
 
-    struct DefinitionText {
-        std::string file;
-        int start_line;
-        int end_line;
-        std::string text;
-    };
-
-    /// Get full definition text for a symbol, using stored index ranges and content.
-    std::optional<DefinitionText> get_definition_text(index::SymbolHash hash);
-
-    struct ReferenceWithContext {
-        std::string file;
-        int line;
-        std::string context;
-    };
-
-    /// Collect references (or definitions) with context lines from stored content.
-    std::vector<ReferenceWithContext> collect_references(index::SymbolHash hash, RelationKind kind);
-
-    /// Cancel background indexing and wait for all tasks to settle.
-    kota::task<> stop();
-
-    /// Whether background indexing is currently idle (no active or queued work).
-    bool is_idle() const {
-        return !indexing_active && index_queue_pos >= index_queue.size();
-    }
-
-    /// Number of files remaining in the indexing queue.
-    std::size_t pending_files() const {
-        return index_queue_pos < index_queue.size() ? index_queue.size() - index_queue_pos : 0;
-    }
-
-    /// Total files that were enqueued in the current (or last) indexing round.
-    std::size_t total_queued() const {
-        return index_queue.size();
-    }
-
     /// Convert internal SymbolKind to LSP SymbolKind.
     static protocol::SymbolKind to_lsp_symbol_kind(SymbolKind kind);
 
@@ -245,7 +208,6 @@ private:
 
 private:
     kota::event_loop& loop;
-    kota::task_group<> bg_tasks;
     Workspace& workspace;
     llvm::DenseMap<std::uint32_t, Session>& sessions;
     WorkerPool& pool;
@@ -269,15 +231,27 @@ private:
     /// Concurrency control for background indexing.
     std::size_t max_concurrent = 2;
     std::size_t baseline_concurrent = 2;
+    std::size_t inflight = 0;
+    std::size_t finished = 0;  ///< Incremented by each completed dispatch task.
 
     /// Pause/resume: when paused, new index tasks wait on this event.
     /// Uses a counter so nested pause/resume pairs work correctly.
     std::size_t pause_depth = 0;
     kota::event resume_event{true};
 
+    /// Completion event — signalled by each finished dispatch task so the
+    /// main loop can wake up.  Must be a member (not local to the coroutine)
+    /// because inflight tasks capture it by reference and may outlive the
+    /// coroutine frame during server shutdown.
+    kota::event completion_event;
+
+    /// Generation counter — incremented each run so a stale monitor_resources
+    /// coroutine can detect that its owning run has ended.
+    std::uint32_t monitor_generation = 0;
+
     kota::task<> run_background_indexing();
     kota::task<> index_one(std::uint32_t server_path_id);
-    kota::task<> monitor_resources();
+    kota::task<> monitor_resources(std::uint32_t generation);
 };
 
 }  // namespace clice

src/server/master_server.cpp

@@ -0,0 +1,924 @@
+#include "server/master_server.h"
+
+#include <algorithm>
+#include <format>
+#include <string>
+#include <type_traits>
+#include <variant>
+
+#include "semantic/symbol_kind.h"
+#include "server/protocol.h"
+#include "support/filesystem.h"
+#include "support/logging.h"
+
+#include "kota/codec/json/json.h"
+#include "kota/ipc/lsp/position.h"
+#include "kota/ipc/lsp/protocol.h"
+#include "kota/ipc/lsp/uri.h"
+#include "kota/meta/enum.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+
+namespace clice {
+
+namespace protocol = kota::ipc::protocol;
+namespace lsp = kota::ipc::lsp;
+namespace refl = kota::meta;
+using kota::ipc::RequestResult;
+using RequestContext = kota::ipc::JsonPeer::RequestContext;
+using serde_raw = kota::codec::RawValue;
+
+/// Serialize a value to a JSON RawValue using LSP config.
+template <typename T>
+static serde_raw to_raw(const T& value) {
+    auto json = kota::codec::json::to_json<kota::ipc::lsp_config>(value);
+    return serde_raw{json ? std::move(*json) : "null"};
+}
+
+MasterServer::MasterServer(kota::event_loop& loop,
+                           kota::ipc::JsonPeer& peer,
+                           std::string self_path) :
+    loop(loop), peer(peer), pool(loop), compiler(loop, peer, workspace, pool, sessions),
+    indexer(loop,
+            workspace,
+            sessions,
+            pool,
+            compiler,
+            [this](uint32_t proj_path_id) {
+                // Bridge project-level path_id to server-level path_id.
+                // The two PathPools may assign different IDs to the same path.
+                auto path = workspace.project_index.path_pool.path(proj_path_id);
+                auto server_id = workspace.path_pool.intern(path);
+                return sessions.contains(server_id);
+            }),
+    self_path(std::move(self_path)) {}
+
+MasterServer::~MasterServer() = default;
+
+void MasterServer::load_workspace() {
+    if(workspace_root.empty())
+        return;
+
+    auto& cfg = workspace.config.project;
+
+    if(!cfg.cache_dir.empty()) {
+        auto ec = llvm::sys::fs::create_directories(cfg.cache_dir);
+        if(ec) {
+            LOG_WARN("Failed to create cache directory {}: {}",
+                     std::string_view(cfg.cache_dir),
+                     ec.message());
+        } else {
+            LOG_INFO("Cache directory: {}", std::string_view(cfg.cache_dir));
+        }
+
+        for(auto* subdir: {"cache/pch", "cache/pcm"}) {
+            auto dir = path::join(cfg.cache_dir, subdir);
+            if(auto ec2 = llvm::sys::fs::create_directories(dir))
+                LOG_WARN("Failed to create {}: {}", dir, ec2.message());
+        }
+
+        workspace.cleanup_cache();
+        workspace.load_cache();
+    }
+
+    // Discover compile_commands.json: configured paths first, then auto-scan.
+    std::string cdb_path;
+    for(auto& configured: cfg.compile_commands_paths) {
+        // Each entry can be a file or a directory containing compile_commands.json.
+        if(llvm::sys::fs::is_directory(configured)) {
+            auto candidate = path::join(configured, "compile_commands.json");
+            if(llvm::sys::fs::exists(candidate)) {
+                cdb_path = std::move(candidate);
+                break;
+            }
+        } else if(llvm::sys::fs::exists(configured)) {
+            cdb_path = configured;
+            break;
+        } else {
+            LOG_WARN("Configured compile_commands_path not found: {}", configured);
+        }
+    }
+
+    // Auto-scan: workspace root + all immediate subdirectories.
+    if(cdb_path.empty()) {
+        auto try_candidate = [&](llvm::StringRef dir) -> bool {
+            auto candidate = path::join(dir, "compile_commands.json");
+            if(llvm::sys::fs::exists(candidate)) {
+                cdb_path = std::move(candidate);
+                return true;
+            }
+            return false;
+        };
+
+        if(!try_candidate(workspace_root)) {
+            std::error_code ec;
+            for(llvm::sys::fs::directory_iterator it(workspace_root, ec), end; it != end && !ec;
+                it.increment(ec)) {
+                if(it->type() == llvm::sys::fs::file_type::directory_file) {
+                    if(try_candidate(it->path()))
+                        break;
+                }
+            }
+        }
+    }
+
+    if(cdb_path.empty()) {
+        LOG_WARN("No compile_commands.json found in workspace {}", workspace_root);
+        peer.send_notification(protocol::LogMessageParams{
+            protocol::MessageType::Warning,
+            std::format("No compile_commands.json found in workspace {}", workspace_root)});
+        return;
+    }
+
+    auto count = workspace.cdb.load(cdb_path);
+    LOG_INFO("Loaded CDB from {} with {} entries", cdb_path, count);
+
+    auto report = scan_dependency_graph(workspace.cdb,
+                                        workspace.path_pool,
+                                        workspace.dep_graph,
+                                        /*cache=*/nullptr,
+                                        [this](llvm::StringRef path,
+                                               std::vector<std::string>& append,
+                                               std::vector<std::string>& remove) {
+                                            workspace.config.match_rules(path, append, remove);
+                                        });
+    workspace.dep_graph.build_reverse_map();
+
+    auto unresolved = report.includes_found - report.includes_resolved;
+    double accuracy =
+        report.includes_found > 0
+            ? 100.0 * static_cast<double>(report.includes_resolved) / report.includes_found
+            : 100.0;
+    LOG_INFO(
+        "Dependency scan: {}ms, {} files ({} source + {} header), " "{} edges, {}/{} resolved ({:.1f}%), {} waves",
+        report.elapsed_ms,
+        report.total_files,
+        report.source_files,
+        report.header_files,
+        report.total_edges,
+        report.includes_resolved,
+        report.includes_found,
+        accuracy,
+        report.waves);
+    if(unresolved > 0)
+        LOG_WARN("{} unresolved includes", unresolved);
+
+    workspace.build_module_map();
+    indexer.load(cfg.index_dir);
+
+    if(*cfg.enable_indexing) {
+        for(auto& entry: workspace.cdb.get_entries()) {
+            auto file = workspace.cdb.resolve_path(entry.file);
+            auto server_id = workspace.path_pool.intern(file);
+            indexer.enqueue(server_id);
+        }
+        indexer.schedule();
+    }
+
+    compiler.init_compile_graph();
+}
+
+void MasterServer::register_handlers() {
+    using StringVec = std::vector<std::string>;
+
+    peer.on_request([this](RequestContext& ctx, const protocol::InitializeParams& params)
+                        -> RequestResult<protocol::InitializeParams> {
+        if(lifecycle != ServerLifecycle::Uninitialized) {
+            co_return kota::outcome_error(protocol::Error{"Server already initialized"});
+        }
+
+        auto& init = params.lsp__initialize_params;
+        if(init.root_uri.has_value()) {
+            workspace_root = uri_to_path(*init.root_uri);
+        }
+
+        // Capture initializationOptions as raw JSON for config loading.
+        if(init.initialization_options.has_value()) {
+            auto json =
+                kota::codec::json::to_json<kota::ipc::lsp_config>(*init.initialization_options);
+            if(json)
+                init_options_json = std::move(*json);
+        }
+
+        lifecycle = ServerLifecycle::Initialized;
+        LOG_INFO("Initialized with workspace: {}", workspace_root);
+
+        protocol::InitializeResult result;
+        auto& caps = result.capabilities;
+
+        caps.text_document_sync = protocol::TextDocumentSyncOptions{
+            .open_close = true,
+            .change = protocol::TextDocumentSyncKind::Incremental,
+            .save = protocol::variant<protocol::boolean, protocol::SaveOptions>{true},
+        };
+        caps.workspace = protocol::WorkspaceOptions{};
+        caps.workspace->workspace_folders = protocol::WorkspaceFoldersServerCapabilities{
+            .supported = true,
+            .change_notifications = true,
+        };
+
+        caps.hover_provider = true;
+        caps.completion_provider = protocol::CompletionOptions{
+            .trigger_characters = StringVec{".", "<", ">", ":", "\"", "/", "*"},
+        };
+        caps.signature_help_provider = protocol::SignatureHelpOptions{
+            .trigger_characters = StringVec{"(", ")", "{", "}", "<", ">", ","},
+        };
+        /// FIXME: In the future, we would support work done progress.
+        caps.declaration_provider = protocol::DeclarationOptions{
+            .work_done_progress = false,
+        };
+        caps.definition_provider = protocol::DefinitionOptions{
+            .work_done_progress = false,
+        };
+        caps.implementation_provider = protocol::ImplementationOptions{
+            .work_done_progress = false,
+        };
+        caps.type_definition_provider = protocol::TypeDefinitionOptions{
+            .work_done_progress = false,
+        };
+        caps.references_provider = protocol::ReferenceOptions{
+            .work_done_progress = false,
+        };
+        caps.document_symbol_provider = true;
+        caps.document_link_provider = protocol::DocumentLinkOptions{};
+        caps.code_action_provider = true;
+        caps.folding_range_provider = true;
+        caps.inlay_hint_provider = true;
+        caps.call_hierarchy_provider = true;
+        caps.type_hierarchy_provider = true;
+        caps.workspace_symbol_provider = true;
+
+        protocol::SemanticTokensOptions sem_opts;
+        {
+            auto lower_first = [](std::string_view name) -> std::string {
+                std::string s(name);
+                if(!s.empty()) {
+                    s[0] = static_cast<char>(std::tolower(static_cast<unsigned char>(s[0])));
+                }
+                return s;
+            };
+
+            auto to_names = [&](auto names) {
+                return std::ranges::to<std::vector>(names | std::views::transform(lower_first));
+            };
+
+            sem_opts.legend = protocol::SemanticTokensLegend{
+                to_names(refl::reflection<SymbolKind::Kind>::member_names),
+                to_names(refl::reflection<SymbolModifiers::Kind>::member_names),
+            };
+        }
+        sem_opts.full = true;
+        result.capabilities.semantic_tokens_provider = std::move(sem_opts);
+
+        protocol::ServerInfo info;
+        info.name = "clice";
+        info.version = "0.1.0";
+        result.server_info = std::move(info);
+
+        co_return result;
+    });
+
+    peer.on_notification([this](const protocol::InitializedParams& params) {
+        // Config priority: initializationOptions > clice.toml > defaults.
+        // Load the workspace config (with defaults applied) first, then overlay
+        // any initializationOptions on top so fields not mentioned in the JSON
+        // keep the values from clice.toml — kotatsu's deserializer only touches
+        // fields that are present in the input.
+        std::string config_warning;
+        workspace.config = Config::load_from_workspace(workspace_root, &config_warning);
+        if(!config_warning.empty())
+            peer.send_notification(
+                protocol::LogMessageParams{protocol::MessageType::Warning, config_warning});
+        if(!init_options_json.empty()) {
+            if(auto ov = kota::codec::json::parse(init_options_json, workspace.config); !ov) {
+                LOG_WARN("Failed to apply initializationOptions: {}", ov.error().to_string());
+                peer.send_notification(protocol::LogMessageParams{
+                    protocol::MessageType::Warning,
+                    std::format("Failed to apply initializationOptions: {}",
+                                ov.error().to_string())});
+            } else {
+                // Re-run apply_defaults so overridden strings get workspace
+                // substitution and `compiled_rules` is rebuilt if `rules`
+                // changed. Defaults are gated on zero/empty sentinels, so
+                // existing values from the overlay are preserved.
+                workspace.config.apply_defaults(workspace_root);
+                LOG_INFO("Applied initializationOptions overlay");
+            }
+            init_options_json.clear();
+        }
+
+        auto& cfg = workspace.config.project;
+
+        if(!cfg.logging_dir.empty()) {
+            auto now = std::chrono::system_clock::now();
+            auto pid = llvm::sys::Process::getProcessId();
+            auto session_dir =
+                path::join(cfg.logging_dir, std::format("{:%Y-%m-%d_%H-%M-%S}_{}", now, pid));
+            logging::file_logger("master", session_dir, logging::options);
+            session_log_dir = session_dir;
+        }
+
+        LOG_INFO("Server ready (stateful={}, stateless={}, idle={}ms)",
+                 cfg.stateful_worker_count.value,
+                 cfg.stateless_worker_count.value,
+                 *cfg.idle_timeout_ms);
+
+        WorkerPoolOptions pool_opts;
+        pool_opts.self_path = self_path;
+        pool_opts.stateful_count = cfg.stateful_worker_count;
+        pool_opts.stateless_count = cfg.stateless_worker_count;
+        pool_opts.worker_memory_limit = cfg.worker_memory_limit;
+        pool_opts.log_dir = session_log_dir;
+        if(!pool.start(pool_opts)) {
+            LOG_ERROR("Failed to start worker pool");
+            peer.send_notification(protocol::LogMessageParams{protocol::MessageType::Error,
+                                                              "Failed to start worker pool"});
+            return;
+        }
+
+        lifecycle = ServerLifecycle::Ready;
+
+        compiler.on_indexing_needed = [this]() {
+            indexer.schedule();
+        };
+
+        indexer.set_peer(&peer);
+        indexer.set_max_concurrency(cfg.stateless_worker_count.value);
+
+        load_workspace();
+    });
+
+    peer.on_request(
+        [this](RequestContext& ctx,
+               const protocol::ShutdownParams& params) -> RequestResult<protocol::ShutdownParams> {
+            lifecycle = ServerLifecycle::ShuttingDown;
+            LOG_INFO("Shutdown requested");
+            co_return nullptr;
+        });
+
+    peer.on_notification([this](const protocol::ExitParams& params) {
+        lifecycle = ServerLifecycle::Exited;
+        LOG_INFO("Exit notification received");
+
+        indexer.save(workspace.config.project.index_dir);
+        workspace.save_cache();
+
+        loop.schedule([this]() -> kota::task<> {
+            co_await pool.stop();
+            loop.stop();
+        }());
+    });
+
+    /// Document lifecycle — handled directly by MasterServer.
+
+    peer.on_notification([this](const protocol::DidOpenTextDocumentParams& params) {
+        if(lifecycle != ServerLifecycle::Ready)
+            return;
+
+        auto path = uri_to_path(params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+
+        auto [it, inserted] = sessions.try_emplace(path_id);
+        auto& session = it->second;
+        if(!inserted) {
+            // DenseMap tombstone may retain stale data — reset to a fresh Session.
+            session = Session{};
+        }
+        session.path_id = path_id;
+        session.version = params.text_document.version;
+        session.text = params.text_document.text;
+        session.generation++;
+
+        LOG_DEBUG("didOpen: {} (v{})", path, params.text_document.version);
+    });
+
+    peer.on_notification([this](const protocol::DidChangeTextDocumentParams& params) {
+        if(lifecycle != ServerLifecycle::Ready)
+            return;
+
+        auto path = uri_to_path(params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+
+        auto it = sessions.find(path_id);
+        if(it == sessions.end())
+            return;
+
+        auto& session = it->second;
+        session.version = params.text_document.version;
+
+        for(auto& change: params.content_changes) {
+            std::visit(
+                [&](auto& c) {
+                    using T = std::remove_cvref_t<decltype(c)>;
+                    if constexpr(std::is_same_v<T,
+                                                protocol::TextDocumentContentChangeWholeDocument>) {
+                        session.text = c.text;
+                    } else {
+                        auto& range = c.range;
+                        lsp::PositionMapper mapper(session.text, lsp::PositionEncoding::UTF16);
+                        auto start = mapper.to_offset(range.start);
+                        auto end = mapper.to_offset(range.end);
+                        if(start && end && *start <= *end) {
+                            session.text.replace(*start, *end - *start, c.text);
+                        }
+                    }
+                },
+                change);
+        }
+
+        session.generation++;
+        session.ast_dirty = true;
+
+        LOG_DEBUG("didChange: path={} version={} gen={}",
+                  path,
+                  session.version,
+                  session.generation);
+
+        worker::DocumentUpdateParams update;
+        update.path = path;
+        update.version = session.version;
+        pool.notify_stateful(path_id, update);
+    });
+
+    peer.on_notification([this](const protocol::DidCloseTextDocumentParams& params) {
+        if(lifecycle != ServerLifecycle::Ready)
+            return;
+
+        auto path = uri_to_path(params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+
+        workspace.on_file_closed(path_id);
+        pool.notify_stateful(path_id, worker::EvictParams{path});
+
+        // Clear diagnostics for the closed file.
+        protocol::PublishDiagnosticsParams diag_params;
+        diag_params.uri = params.text_document.uri;
+        peer.send_notification(diag_params);
+
+        sessions.erase(path_id);
+
+        indexer.enqueue(path_id);
+        indexer.schedule();
+
+        LOG_DEBUG("didClose: {}", path);
+    });
+
+    peer.on_notification([this](const protocol::DidSaveTextDocumentParams& params) {
+        if(lifecycle != ServerLifecycle::Ready)
+            return;
+
+        auto path = uri_to_path(params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+
+        auto dirtied = workspace.on_file_saved(path_id);
+        for(auto dirty_id: dirtied) {
+            if(auto sit = sessions.find(dirty_id); sit != sessions.end()) {
+                sit->second.ast_dirty = true;
+            } else {
+                indexer.enqueue(dirty_id);
+            }
+        }
+
+        // Invalidate header contexts for sessions whose host is this file.
+        for(auto& [hdr_id, session]: sessions) {
+            if(session.header_context && session.header_context->host_path_id == path_id) {
+                session.header_context.reset();
+                session.ast_dirty = true;
+            }
+        }
+
+        indexer.schedule();
+
+        LOG_DEBUG("didSave: {}", path);
+    });
+
+    /// Feature requests — stateful forwarding.
+
+    peer.on_request([this](RequestContext& ctx, const protocol::HoverParams& params) -> RawResult {
+        auto path = uri_to_path(params.text_document_position_params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+        auto sit = sessions.find(path_id);
+        if(sit == sessions.end())
+            co_await kota::fail("Document not open");
+        co_return co_await compiler.forward_query(worker::QueryKind::Hover,
+                                                  sit->second,
+                                                  params.text_document_position_params.position);
+    });
+
+    peer.on_request([this](RequestContext& ctx,
+                           const protocol::SemanticTokensParams& params) -> RawResult {
+        auto path = uri_to_path(params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+        auto sit = sessions.find(path_id);
+        if(sit == sessions.end())
+            co_await kota::fail("Document not open");
+        co_return co_await compiler.forward_query(worker::QueryKind::SemanticTokens, sit->second);
+    });
+
+    peer.on_request(
+        [this](RequestContext& ctx, const protocol::InlayHintParams& params) -> RawResult {
+            auto path = uri_to_path(params.text_document.uri);
+            auto path_id = workspace.path_pool.intern(path);
+            auto sit = sessions.find(path_id);
+            if(sit == sessions.end())
+                co_await kota::fail("Document not open");
+            co_return co_await compiler.forward_query(worker::QueryKind::InlayHints,
+                                                      sit->second,
+                                                      {},
+                                                      params.range);
+        });
+
+    peer.on_request(
+        [this](RequestContext& ctx, const protocol::FoldingRangeParams& params) -> RawResult {
+            auto path = uri_to_path(params.text_document.uri);
+            auto path_id = workspace.path_pool.intern(path);
+            auto sit = sessions.find(path_id);
+            if(sit == sessions.end())
+                co_await kota::fail("Document not open");
+            co_return co_await compiler.forward_query(worker::QueryKind::FoldingRange, sit->second);
+        });
+
+    peer.on_request([this](RequestContext& ctx,
+                           const protocol::DocumentSymbolParams& params) -> RawResult {
+        auto path = uri_to_path(params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+        auto sit = sessions.find(path_id);
+        if(sit == sessions.end())
+            co_await kota::fail("Document not open");
+        co_return co_await compiler.forward_query(worker::QueryKind::DocumentSymbol, sit->second);
+    });
+
+    peer.on_request([this](RequestContext& ctx,
+                           const protocol::DocumentLinkParams& params) -> RawResult {
+        auto path = uri_to_path(params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+        auto sit = sessions.find(path_id);
+        if(sit == sessions.end())
+            co_await kota::fail("Document not open");
+        auto& session = sit->second;
+        auto result = co_await compiler.forward_query(worker::QueryKind::DocumentLink, session);
+        if(!result.has_value())
+            co_return serde_raw{"null"};
+        // Merge document links from PCH if available.
+        auto& links = result.value();
+        // Re-lookup session after co_await since iterators may be invalidated.
+        auto sit2 = sessions.find(path_id);
+        if(sit2 != sessions.end() && sit2->second.pch_ref) {
+            auto pch_it = workspace.pch_cache.find(sit2->second.pch_ref->path_id);
+            if(pch_it != workspace.pch_cache.end() && !pch_it->second.document_links_json.empty()) {
+                auto& pch_json = pch_it->second.document_links_json;
+                // Merge two JSON arrays.
+                if(!links.data.empty() && links.data != "null" && links.data.size() > 2) {
+                    // "[a,b]" + "[c,d]" -> "[a,b,c,d]"
+                    links.data.pop_back();  // remove trailing ']'
+                    links.data += ',';
+                    links.data.append(pch_json.begin() + 1, pch_json.end());  // skip '['
+                } else {
+                    links.data = pch_json;
+                }
+            }
+        }
+        co_return std::move(links);
+    });
+
+    peer.on_request(
+        [this](RequestContext& ctx, const protocol::CodeActionParams& params) -> RawResult {
+            auto path = uri_to_path(params.text_document.uri);
+            auto path_id = workspace.path_pool.intern(path);
+            auto sit = sessions.find(path_id);
+            if(sit == sessions.end())
+                co_await kota::fail("Document not open");
+            co_return co_await compiler.forward_query(worker::QueryKind::CodeAction, sit->second);
+        });
+
+    /// Helper: resolve URI to path, path_id, and Session pointer.
+    auto resolve_uri = [this](const std::string& uri) {
+        struct Result {
+            std::string path;
+            std::uint32_t path_id;
+            Session* session;
+        };
+        auto path = uri_to_path(uri);
+        auto path_id = workspace.path_pool.intern(path);
+        auto sit = sessions.find(path_id);
+        Session* session = (sit != sessions.end()) ? &sit->second : nullptr;
+        return Result{std::move(path), path_id, session};
+    };
+
+    auto lookup_at = [this, resolve_uri](const std::string& uri, const protocol::Position& pos) {
+        auto [path, path_id, session] = resolve_uri(uri);
+        return indexer.lookup_symbol(uri, path, pos, session);
+    };
+
+    auto query_at = [this, resolve_uri](const std::string& uri,
+                                        const protocol::Position& pos,
+                                        RelationKind kind) -> std::vector<protocol::Location> {
+        auto [path, path_id, session] = resolve_uri(uri);
+        return indexer.query_relations(path, pos, kind, session);
+    };
+
+    auto resolve_item =
+        [this,
+         resolve_uri](const std::string& uri,
+                      const protocol::Range& range,
+                      const std::optional<protocol::LSPAny>& data) -> std::optional<SymbolInfo> {
+        auto [path, path_id, session] = resolve_uri(uri);
+        return indexer.resolve_hierarchy_item(uri, path, range, data, session);
+    };
+
+    /// Feature requests — index-based with AST fallback.
+
+    peer.on_request([this, query_at](RequestContext& ctx,
+                                     const protocol::DefinitionParams& params) -> RawResult {
+        auto& uri = params.text_document_position_params.text_document.uri;
+        auto& pos = params.text_document_position_params.position;
+
+        auto result = query_at(uri, pos, RelationKind::Definition);
+        if(!result.empty()) {
+            co_return to_raw(result);
+        }
+
+        auto path = uri_to_path(uri);
+        auto path_id = workspace.path_pool.intern(path);
+        auto sit = sessions.find(path_id);
+        if(sit == sessions.end())
+            co_await kota::fail("Document not open");
+        co_return co_await compiler.forward_query(worker::QueryKind::GoToDefinition,
+                                                  sit->second,
+                                                  pos);
+    });
+
+    peer.on_request([this, query_at](RequestContext& ctx,
+                                     const protocol::ReferenceParams& params) -> RawResult {
+        auto& uri = params.text_document_position_params.text_document.uri;
+        auto& pos = params.text_document_position_params.position;
+
+        auto locations = query_at(uri, pos, RelationKind::Reference);
+
+        if(params.context.include_declaration) {
+            auto defs = query_at(uri, pos, RelationKind::Definition);
+            locations.insert(locations.end(),
+                             std::make_move_iterator(defs.begin()),
+                             std::make_move_iterator(defs.end()));
+        }
+
+        if(locations.empty())
+            co_return serde_raw{"null"};
+        co_return to_raw(locations);
+    });
+
+    peer.on_request(
+        [this](RequestContext& ctx, const protocol::TypeDefinitionParams& params) -> RawResult {
+            co_return serde_raw{"null"};
+        });
+
+    peer.on_request(
+        [this](RequestContext& ctx, const protocol::ImplementationParams& params) -> RawResult {
+            co_return serde_raw{"null"};
+        });
+
+    peer.on_request(
+        [this](RequestContext& ctx, const protocol::DeclarationParams& params) -> RawResult {
+            co_return serde_raw{"null"};
+        });
+
+    /// Feature requests — stateless forwarding.
+
+    peer.on_request(
+        [this](RequestContext& ctx, const protocol::CompletionParams& params) -> RawResult {
+            auto path = uri_to_path(params.text_document_position_params.text_document.uri);
+            auto path_id = workspace.path_pool.intern(path);
+            auto sit = sessions.find(path_id);
+            if(sit == sessions.end())
+                co_await kota::fail("Document not open");
+            auto pause = indexer.scoped_pause();
+            auto result =
+                co_await compiler.handle_completion(params.text_document_position_params.position,
+                                                    sit->second);
+            co_return std::move(result);
+        });
+
+    peer.on_request([this](RequestContext& ctx,
+                           const protocol::SignatureHelpParams& params) -> RawResult {
+        auto path = uri_to_path(params.text_document_position_params.text_document.uri);
+        auto path_id = workspace.path_pool.intern(path);
+        auto sit = sessions.find(path_id);
+        if(sit == sessions.end())
+            co_await kota::fail("Document not open");
+        auto pause = indexer.scoped_pause();
+        auto result = co_await compiler.forward_build(worker::BuildKind::SignatureHelp,
+                                                      params.text_document_position_params.position,
+                                                      sit->second);
+        co_return std::move(result);
+    });
+
+    /// Hierarchy queries — index-based.
+
+    peer.on_request(
+        [this, lookup_at](RequestContext& ctx,
+                          const protocol::CallHierarchyPrepareParams& params) -> RawResult {
+            auto& uri = params.text_document_position_params.text_document.uri;
+            auto& pos = params.text_document_position_params.position;
+
+            auto info = lookup_at(uri, pos);
+            if(!info)
+                co_return serde_raw{"null"};
+            if(!(info->kind == SymbolKind::Function || info->kind == SymbolKind::Method))
+                co_return serde_raw{"null"};
+
+            std::vector<protocol::CallHierarchyItem> items;
+            items.push_back(Indexer::build_call_hierarchy_item(*info));
+            co_return to_raw(items);
+        });
+
+    peer.on_request([this, resolve_item](
+                        RequestContext& ctx,
+                        const protocol::CallHierarchyIncomingCallsParams& params) -> RawResult {
+        auto info = resolve_item(params.item.uri, params.item.range, params.item.data);
+        if(!info)
+            co_await kota::fail("Failed to resolve call hierarchy item");
+        auto results = indexer.find_incoming_calls(info->hash);
+        co_return to_raw(results);
+    });
+
+    peer.on_request([this, resolve_item](
+                        RequestContext& ctx,
+                        const protocol::CallHierarchyOutgoingCallsParams& params) -> RawResult {
+        auto info = resolve_item(params.item.uri, params.item.range, params.item.data);
+        if(!info)
+            co_await kota::fail("Failed to resolve call hierarchy item");
+        auto results = indexer.find_outgoing_calls(info->hash);
+        co_return to_raw(results);
+    });
+
+    peer.on_request(
+        [this, lookup_at](RequestContext& ctx,
+                          const protocol::TypeHierarchyPrepareParams& params) -> RawResult {
+            auto& uri = params.text_document_position_params.text_document.uri;
+            auto& pos = params.text_document_position_params.position;
+
+            auto info = lookup_at(uri, pos);
+            if(!info)
+                co_return serde_raw{"null"};
+            if(!(info->kind == SymbolKind::Class || info->kind == SymbolKind::Struct ||
+                 info->kind == SymbolKind::Enum || info->kind == SymbolKind::Union))
+                co_return serde_raw{"null"};
+
+            std::vector<protocol::TypeHierarchyItem> items;
+            items.push_back(Indexer::build_type_hierarchy_item(*info));
+            co_return to_raw(items);
+        });
+
+    peer.on_request(
+        [this, resolve_item](RequestContext& ctx,
+                             const protocol::TypeHierarchySupertypesParams& params) -> RawResult {
+            auto info = resolve_item(params.item.uri, params.item.range, params.item.data);
+            if(!info)
+                co_await kota::fail("Failed to resolve type hierarchy item");
+            auto results = indexer.find_supertypes(info->hash);
+            co_return to_raw(results);
+        });
+
+    peer.on_request(
+        [this, resolve_item](RequestContext& ctx,
+                             const protocol::TypeHierarchySubtypesParams& params) -> RawResult {
+            auto info = resolve_item(params.item.uri, params.item.range, params.item.data);
+            if(!info)
+                co_await kota::fail("Failed to resolve type hierarchy item");
+            auto results = indexer.find_subtypes(info->hash);
+            co_return to_raw(results);
+        });
+
+    peer.on_request(
+        [this](RequestContext& ctx, const protocol::WorkspaceSymbolParams& params) -> RawResult {
+            auto results = indexer.search_symbols(params.query);
+            co_return to_raw(results);
+        });
+
+    /// clice/ extension commands.
+
+    peer.on_request(
+        "clice/queryContext",
+        [this](RequestContext& ctx, const ext::QueryContextParams& params) -> RawResult {
+            auto path = uri_to_path(params.uri);
+            auto path_id = workspace.path_pool.intern(path);
+            int offset_val = std::max(0, params.offset.value_or(0));
+            constexpr int page_size = 10;
+
+            ext::QueryContextResult result;
+            std::vector<ext::ContextItem> all_items;
+
+            auto hosts = workspace.dep_graph.find_host_sources(path_id);
+            for(auto host_id: hosts) {
+                auto host_path = workspace.path_pool.resolve(host_id);
+                auto host_cdb = workspace.cdb.lookup(host_path, {.suppress_logging = true});
+                if(host_cdb.empty())
+                    continue;
+                auto host_uri_opt = lsp::URI::from_file_path(std::string(host_path));
+                if(!host_uri_opt)
+                    continue;
+                ext::ContextItem item;
+                item.label = llvm::sys::path::filename(host_path).str();
+                item.description = std::string(host_path);
+                item.uri = host_uri_opt->str();
+                all_items.push_back(std::move(item));
+            }
+
+            if(hosts.empty()) {
+                auto entries = workspace.cdb.lookup(path, {.suppress_logging = true});
+                for(std::size_t i = 0; i < entries.size(); ++i) {
+                    auto& cmd = entries[i];
+                    auto argv = cmd.to_argv();
+                    std::string desc;
+                    for(std::size_t j = 0; j < argv.size(); ++j) {
+                        llvm::StringRef a(argv[j]);
+                        if(a.starts_with("-D") || a.starts_with("-O") || a.starts_with("-std=") ||
+                           a.starts_with("-g")) {
+                            if(!desc.empty())
+                                desc += ' ';
+                            desc += argv[j];
+                            if((a == "-D" || a == "-O") && j + 1 < argv.size()) {
+                                desc += argv[++j];
+                            }
+                        }
+                    }
+                    if(desc.empty())
+                        desc = std::format("config #{}", i);
+
+                    auto uri_opt = lsp::URI::from_file_path(std::string(path));
+                    if(!uri_opt)
+                        continue;
+                    ext::ContextItem item;
+                    item.label = desc;
+                    item.description = cmd.resolved.directory.str();
+                    item.uri = uri_opt->str();
+                    all_items.push_back(std::move(item));
+                }
+            }
+
+            result.total = static_cast<int>(all_items.size());
+            int end = std::min(offset_val + page_size, static_cast<int>(all_items.size()));
+            for(int i = offset_val; i < end; ++i) {
+                result.contexts.push_back(std::move(all_items[i]));
+            }
+            co_return to_raw(result);
+        });
+
+    peer.on_request(
+        "clice/currentContext",
+        [this](RequestContext& ctx, const ext::CurrentContextParams& params) -> RawResult {
+            auto path = uri_to_path(params.uri);
+            auto path_id = workspace.path_pool.intern(path);
+
+            ext::CurrentContextResult result;
+            auto sit = sessions.find(path_id);
+            if(sit != sessions.end() && sit->second.active_context) {
+                auto ctx_path = workspace.path_pool.resolve(*sit->second.active_context);
+                auto ctx_uri_opt = lsp::URI::from_file_path(std::string(ctx_path));
+                if(ctx_uri_opt) {
+                    ext::ContextItem item;
+                    item.label = llvm::sys::path::filename(ctx_path).str();
+                    item.description = std::string(ctx_path);
+                    item.uri = ctx_uri_opt->str();
+                    result.context = std::move(item);
+                }
+            }
+            co_return to_raw(result);
+        });
+
+    peer.on_request(
+        "clice/switchContext",
+        [this](RequestContext& ctx, const ext::SwitchContextParams& params) -> RawResult {
+            auto path = uri_to_path(params.uri);
+            auto path_id = workspace.path_pool.intern(path);
+            auto context_path = uri_to_path(params.context_uri);
+            auto context_path_id = workspace.path_pool.intern(context_path);
+
+            ext::SwitchContextResult result;
+
+            auto context_cdb = workspace.cdb.lookup(context_path, {.suppress_logging = true});
+            if(context_cdb.empty()) {
+                result.success = false;
+                co_return to_raw(result);
+            }
+
+            auto sit = sessions.find(path_id);
+            if(sit == sessions.end()) {
+                result.success = false;
+                co_return to_raw(result);
+            }
+
+            sit->second.active_context = context_path_id;
+            sit->second.header_context.reset();
+            sit->second.pch_ref.reset();
+            sit->second.ast_deps.reset();
+            sit->second.ast_dirty = true;
+
+            result.success = true;
+            co_return to_raw(result);
+        });
+}
+
+}  // namespace clice

src/server/master_server.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "server/compiler.h"
+#include "server/indexer.h"
+#include "server/session.h"
+#include "server/worker_pool.h"
+#include "server/workspace.h"
+
+#include "kota/async/async.h"
+#include "kota/codec/json/json.h"
+#include "kota/ipc/peer.h"
+#include "llvm/ADT/DenseMap.h"
+
+namespace clice {
+
+enum class ServerLifecycle : std::uint8_t {
+    Uninitialized,
+    Initialized,
+    Ready,
+    ShuttingDown,
+    Exited,
+};
+
+/// Top-level LSP server — the single orchestration point for the language
+/// server process.
+///
+/// Responsibilities:
+///   - Owns the two-layer state model: Workspace (disk truth) and Sessions
+///     (per-open-file volatile state).
+///   - Manages Session lifecycle directly: didOpen creates, didChange mutates,
+///     didSave syncs to Workspace, didClose destroys.
+///   - Dispatches compilation and feature queries to Compiler.
+///   - Dispatches index lookups and background indexing to Indexer.
+///
+/// Design principle:
+///   Open files are never depended upon by other files.  Dependencies always
+///   point to disk files.  The only path from Session to Workspace is didSave.
+class MasterServer {
+public:
+    MasterServer(kota::event_loop& loop, kota::ipc::JsonPeer& peer, std::string self_path);
+    ~MasterServer();
+
+    void register_handlers();
+
+private:
+    kota::event_loop& loop;
+    kota::ipc::JsonPeer& peer;
+
+    /// Persistent project-wide state (config, CDB, path pool, dependency
+    /// graphs, compilation caches, symbol index).
+    Workspace workspace;
+
+    /// Per-file editing sessions, keyed by server-level path_id.
+    llvm::DenseMap<std::uint32_t, Session> sessions;
+
+    /// Worker process pool for offloading compilation and queries.
+    WorkerPool pool;
+
+    /// Compilation lifecycle manager (reads/writes workspace and sessions).
+    Compiler compiler;
+
+    /// Index query and background scheduling (reads from workspace and sessions).
+    Indexer indexer;
+
+    ServerLifecycle lifecycle = ServerLifecycle::Uninitialized;
+    std::string self_path;
+    std::string workspace_root;
+    std::string session_log_dir;
+    std::string init_options_json;  ///< Raw JSON from initializationOptions, consumed once.
+
+    void load_workspace();
+
+    using RawResult = kota::task<kota::codec::RawValue, kota::ipc::Error>;
+};
+
+}  // namespace clice

src/server/protocol.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -9,6 +10,7 @@
 #include "syntax/token.h"
 
 #include "kota/codec/json/json.h"
+#include "kota/ipc/lsp/protocol.h"
 #include "kota/ipc/protocol.h"
 
 namespace clice::worker {
@@ -64,7 +66,6 @@ enum class BuildKind : uint8_t {
     Index,
     Completion,
     SignatureHelp,
-    Format,
 };
 
 /// Unified parameters for all stateless build/compilation tasks.
@@ -75,7 +76,6 @@ enum class BuildKind : uint8_t {
 ///   - Index:         + pcms
 ///   - Completion:    + text, version, offset, pch, pcms
 ///   - SignatureHelp: + text, version, offset, pch, pcms
-///   - Format:        + text, format_range (optional)
 struct BuildParams {
     BuildKind kind;
     std::string file;
@@ -92,7 +92,6 @@ struct BuildParams {
     std::string output_path;               ///< BuildPCH, BuildPCM
     std::string module_name;               ///< BuildPCM
     uint32_t preamble_bound = UINT32_MAX;  ///< BuildPCH
-    LocalSourceRange format_range;         ///< Format (default = full document)
 };
 
 /// Unified result for stateless build tasks.
@@ -123,6 +122,43 @@ struct EvictedParams {
 
 }  // namespace clice::worker
 
+namespace clice::ext {
+
+struct ContextItem {
+    std::string label;
+    std::string description;
+    std::string uri;
+};
+
+struct QueryContextParams {
+    std::string uri;
+    std::optional<int> offset;
+};
+
+struct QueryContextResult {
+    std::vector<ContextItem> contexts;
+    int total;
+};
+
+struct CurrentContextParams {
+    std::string uri;
+};
+
+struct CurrentContextResult {
+    std::optional<ContextItem> context;
+};
+
+struct SwitchContextParams {
+    std::string uri;
+    std::string context_uri;
+};
+
+struct SwitchContextResult {
+    bool success;
+};
+
+}  // namespace clice::ext
+
 namespace kota::ipc::protocol {
 
 template <>

src/server/protocol/agentic.h

@@ -1,297 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "kota/ipc/protocol.h"
-
-namespace clice::agentic {
-
-struct CompileCommandParams {
-    std::string path;
-};
-
-struct CompileCommandResult {
-    std::string file;
-    std::string directory;
-    std::vector<std::string> arguments;
-};
-
-struct FileInfo {
-    std::string path;
-    std::string kind;
-    std::optional<std::string> module_name;
-};
-
-struct ProjectFilesParams {
-    std::optional<std::string> filter;
-};
-
-struct ProjectFilesResult {
-    std::vector<FileInfo> files;
-    int total = 0;
-};
-
-struct DepEntry {
-    std::string path;
-    int depth = 0;
-};
-
-struct FileDepsParams {
-    std::string path;
-    std::optional<std::string> direction;
-    std::optional<int> depth;
-};
-
-struct FileDepsResult {
-    std::string file;
-    std::vector<DepEntry> includes;
-    std::vector<DepEntry> includers;
-};
-
-struct ImpactAnalysisParams {
-    std::string path;
-};
-
-struct ImpactAnalysisResult {
-    std::vector<std::string> direct_dependents;
-    std::vector<std::string> transitive_dependents;
-    std::vector<std::string> affected_modules;
-};
-
-struct SymbolEntry {
-    std::string name;
-    std::string kind;
-    std::string file;
-    int line = 0;
-    std::optional<std::string> container;
-    std::uint64_t symbol_id = 0;
-};
-
-struct SymbolSearchParams {
-    std::string query;
-    std::optional<std::vector<std::string>> kind_filter;
-    std::optional<int> max_results;
-};
-
-struct SymbolSearchResult {
-    std::vector<SymbolEntry> symbols;
-};
-
-struct ReadSymbolParams {
-    std::optional<std::string> name;
-    std::optional<std::string> path;
-    std::optional<int> line;
-    std::optional<std::uint64_t> symbol_id;
-};
-
-struct ReadSymbolResult {
-    std::string name;
-    std::string kind;
-    std::string file;
-    int start_line = 0;
-    int end_line = 0;
-    std::string text;
-    std::optional<std::string> signature;
-    std::uint64_t symbol_id = 0;
-};
-
-struct DocumentSymbolEntry {
-    std::string name;
-    std::string kind;
-    int start_line = 0;
-    int end_line = 0;
-    std::uint64_t symbol_id = 0;
-};
-
-struct DocumentSymbolsParams {
-    std::string path;
-};
-
-struct DocumentSymbolsResult {
-    std::vector<DocumentSymbolEntry> symbols;
-};
-
-struct DefinitionParams {
-    std::optional<std::string> name;
-    std::optional<std::string> path;
-    std::optional<int> line;
-    std::optional<std::uint64_t> symbol_id;
-};
-
-struct LocationEntry {
-    std::string file;
-    int start_line = 0;
-    int end_line = 0;
-    std::string text;
-};
-
-struct DefinitionResult {
-    std::string name;
-    std::string kind;
-    std::uint64_t symbol_id = 0;
-    std::optional<LocationEntry> definition;
-};
-
-struct ReferenceEntry {
-    std::string file;
-    int line = 0;
-    std::string context;
-};
-
-struct ReferencesParams {
-    std::optional<std::string> name;
-    std::optional<std::string> path;
-    std::optional<int> line;
-    std::optional<std::uint64_t> symbol_id;
-    std::optional<bool> include_declaration;
-};
-
-struct ReferencesResult {
-    std::string name;
-    std::string kind;
-    std::uint64_t symbol_id = 0;
-    std::vector<ReferenceEntry> references;
-    int total = 0;
-};
-
-struct CallGraphEntry {
-    std::string name;
-    std::string kind;
-    std::string file;
-    int line = 0;
-    std::uint64_t symbol_id = 0;
-};
-
-struct CallGraphParams {
-    std::optional<std::string> name;
-    std::optional<std::string> path;
-    std::optional<int> line;
-    std::optional<std::uint64_t> symbol_id;
-    std::optional<std::string> direction;
-    std::optional<int> depth;
-};
-
-struct CallGraphResult {
-    CallGraphEntry root;
-    std::vector<CallGraphEntry> callers;
-    std::vector<CallGraphEntry> callees;
-};
-
-struct TypeHierarchyEntry {
-    std::string name;
-    std::string kind;
-    std::string file;
-    int line = 0;
-    std::uint64_t symbol_id = 0;
-};
-
-struct TypeHierarchyParams {
-    std::optional<std::string> name;
-    std::optional<std::string> path;
-    std::optional<int> line;
-    std::optional<std::uint64_t> symbol_id;
-    std::optional<std::string> direction;
-};
-
-struct TypeHierarchyResult {
-    TypeHierarchyEntry root;
-    std::vector<TypeHierarchyEntry> supertypes;
-    std::vector<TypeHierarchyEntry> subtypes;
-};
-
-struct StatusParams {};
-
-struct StatusResult {
-    bool idle = true;
-    int pending = 0;
-    int total = 0;
-    int indexed = 0;
-};
-
-struct ShutdownParams {};
-
-}  // namespace clice::agentic
-
-namespace kota::ipc::protocol {
-
-template <>
-struct RequestTraits<clice::agentic::CompileCommandParams> {
-    using Result = clice::agentic::CompileCommandResult;
-    constexpr inline static std::string_view method = "agentic/compileCommand";
-};
-
-template <>
-struct RequestTraits<clice::agentic::ProjectFilesParams> {
-    using Result = clice::agentic::ProjectFilesResult;
-    constexpr inline static std::string_view method = "agentic/projectFiles";
-};
-
-template <>
-struct RequestTraits<clice::agentic::FileDepsParams> {
-    using Result = clice::agentic::FileDepsResult;
-    constexpr inline static std::string_view method = "agentic/fileDeps";
-};
-
-template <>
-struct RequestTraits<clice::agentic::ImpactAnalysisParams> {
-    using Result = clice::agentic::ImpactAnalysisResult;
-    constexpr inline static std::string_view method = "agentic/impactAnalysis";
-};
-
-template <>
-struct RequestTraits<clice::agentic::SymbolSearchParams> {
-    using Result = clice::agentic::SymbolSearchResult;
-    constexpr inline static std::string_view method = "agentic/symbolSearch";
-};
-
-template <>
-struct RequestTraits<clice::agentic::ReadSymbolParams> {
-    using Result = clice::agentic::ReadSymbolResult;
-    constexpr inline static std::string_view method = "agentic/readSymbol";
-};
-
-template <>
-struct RequestTraits<clice::agentic::DocumentSymbolsParams> {
-    using Result = clice::agentic::DocumentSymbolsResult;
-    constexpr inline static std::string_view method = "agentic/documentSymbols";
-};
-
-template <>
-struct RequestTraits<clice::agentic::DefinitionParams> {
-    using Result = clice::agentic::DefinitionResult;
-    constexpr inline static std::string_view method = "agentic/definition";
-};
-
-template <>
-struct RequestTraits<clice::agentic::ReferencesParams> {
-    using Result = clice::agentic::ReferencesResult;
-    constexpr inline static std::string_view method = "agentic/references";
-};
-
-template <>
-struct RequestTraits<clice::agentic::CallGraphParams> {
-    using Result = clice::agentic::CallGraphResult;
-    constexpr inline static std::string_view method = "agentic/callGraph";
-};
-
-template <>
-struct RequestTraits<clice::agentic::TypeHierarchyParams> {
-    using Result = clice::agentic::TypeHierarchyResult;
-    constexpr inline static std::string_view method = "agentic/typeHierarchy";
-};
-
-template <>
-struct RequestTraits<clice::agentic::StatusParams> {
-    using Result = clice::agentic::StatusResult;
-    constexpr inline static std::string_view method = "agentic/status";
-};
-
-template <>
-struct NotificationTraits<clice::agentic::ShutdownParams> {
-    constexpr inline static std::string_view method = "agentic/shutdown";
-};
-
-}  // namespace kota::ipc::protocol

src/server/protocol/extension.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace clice::ext {
-
-struct ContextItem {
-    std::string label;
-    std::string description;
-    std::string uri;
-};
-
-struct QueryContextParams {
-    std::string uri;
-    std::optional<int> offset;
-};
-
-struct QueryContextResult {
-    std::vector<ContextItem> contexts;
-    int total = 0;
-};
-
-struct CurrentContextParams {
-    std::string uri;
-};
-
-struct CurrentContextResult {
-    std::optional<ContextItem> context;
-};
-
-struct SwitchContextParams {
-    std::string uri;
-    std::string context_uri;
-};
-
-struct SwitchContextResult {
-    bool success = false;
-};
-
-}  // namespace clice::ext

src/server/service/agent_client.cpp

@@ -1,787 +0,0 @@
-#include "server/service/agent_client.h"
-
-#include <algorithm>
-#include <format>
-#include <ranges>
-#include <string>
-#include <vector>
-
-#include "server/protocol/agentic.h"
-#include "server/service/master_server.h"
-#include "support/filesystem.h"
-#include "support/logging.h"
-
-#include "kota/ipc/lsp/uri.h"
-#include "kota/meta/enum.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/SmallVector.h"
-
-namespace clice {
-
-using kota::ipc::RequestResult;
-using RequestContext = kota::ipc::JsonPeer::RequestContext;
-namespace lsp = kota::ipc::lsp;
-namespace protocol = kota::ipc::protocol;
-
-static std::string_view symbol_kind_name(SymbolKind kind) {
-    constexpr auto names = kota::meta::reflection<SymbolKind::Kind>::member_names;
-    auto idx = static_cast<std::size_t>(kind.value());
-    if(idx < names.size())
-        return names[idx];
-    return "Unknown";
-}
-
-struct ResolvedSymbol {
-    index::SymbolHash hash = 0;
-    std::string name;
-    SymbolKind kind;
-    std::string file;
-    int line = 0;
-};
-
-static std::vector<ResolvedSymbol> resolve_locator(const agentic::ReadSymbolParams& loc,
-                                                   Workspace& workspace,
-                                                   llvm::DenseMap<std::uint32_t, Session>& sessions,
-                                                   Indexer& indexer) {
-    if(loc.symbol_id.has_value() && *loc.symbol_id != 0) {
-        auto hash = static_cast<index::SymbolHash>(*loc.symbol_id);
-        std::string name;
-        SymbolKind kind;
-        if(!indexer.find_symbol_info(hash, name, kind))
-            return {};
-        auto def_loc = indexer.find_definition_location(hash);
-        if(!def_loc)
-            return {};
-        auto file = uri_to_path(def_loc->uri);
-        int line_num = static_cast<int>(def_loc->range.start.line) + 1;
-        return {
-            {hash, std::move(name), kind, std::move(file), line_num}
-        };
-    }
-
-    if(loc.name.has_value() && !loc.name->empty()) {
-        std::string query_lower = llvm::StringRef(*loc.name).lower();
-        std::vector<ResolvedSymbol> candidates;
-        std::vector<ResolvedSymbol> exact_matches;
-        llvm::DenseSet<index::SymbolHash> seen;
-
-        auto try_symbol = [&](index::SymbolHash hash, const index::Symbol& symbol) {
-            if(symbol.name.empty())
-                return;
-            if(llvm::StringRef(symbol.name).lower().find(query_lower) == std::string::npos)
-                return;
-            auto def_loc = indexer.find_definition_location(hash);
-            if(!def_loc)
-                return;
-            if(!seen.insert(hash).second)
-                return;
-
-            auto file = uri_to_path(def_loc->uri);
-            int line_num = static_cast<int>(def_loc->range.start.line) + 1;
-
-            if(loc.path.has_value() && !loc.path->empty()) {
-                llvm::StringRef wanted(*loc.path);
-                bool basename_only = wanted.find_last_of("/\\") == llvm::StringRef::npos;
-                if(basename_only) {
-                    if(llvm::sys::path::filename(file) != wanted)
-                        return;
-                } else if(!llvm::StringRef(file).ends_with(wanted)) {
-                    return;
-                }
-            }
-
-            bool is_exact = llvm::StringRef(symbol.name).lower() == query_lower ||
-                            llvm::StringRef(symbol.name).ends_with("::" + *loc.name);
-
-            ResolvedSymbol rs{hash, symbol.name, symbol.kind, std::move(file), line_num};
-            if(is_exact)
-                exact_matches.push_back(std::move(rs));
-            else
-                candidates.push_back(std::move(rs));
-        };
-
-        for(auto& [hash, symbol]: workspace.project_index.symbols)
-            try_symbol(hash, symbol);
-        for(auto& [_, sess]: sessions) {
-            if(!sess.file_index)
-                continue;
-            for(auto& [hash, symbol]: sess.file_index->symbols)
-                try_symbol(hash, symbol);
-        }
-
-        if(!exact_matches.empty())
-            return exact_matches;
-        return candidates;
-    }
-
-    if(loc.path.has_value() && loc.line.has_value()) {
-        auto path_str = *loc.path;
-        auto target_line = static_cast<protocol::uinteger>(*loc.line - 1);
-
-        auto pool_it = workspace.path_pool.cache.find(path_str);
-        auto server_id = pool_it != workspace.path_pool.cache.end() ? pool_it->second : ~0u;
-        auto* sess =
-            server_id != ~0u && sessions.contains(server_id) ? &sessions[server_id] : nullptr;
-        if(sess && sess->file_index) {
-            auto& fi = *sess->file_index;
-            if(fi.mapper) {
-                for(auto& [hash, rels]: fi.file_index.relations) {
-                    for(auto& rel: rels) {
-                        if(rel.kind.value() != RelationKind::Definition)
-                            continue;
-                        auto start = fi.mapper->to_position(rel.range.begin);
-                        if(start && start->line == target_line) {
-                            std::string name;
-                            SymbolKind kind;
-                            if(indexer.find_symbol_info(hash, name, kind))
-                                return {
-                                    {hash, std::move(name), kind, path_str, *loc.line}
-                                };
-                        }
-                    }
-                }
-            }
-        }
-
-        auto it = workspace.project_index.path_pool.find(path_str);
-        if(it == workspace.project_index.path_pool.cache.end())
-            return {};
-
-        auto proj_id = it->second;
-        auto shard_it = workspace.merged_indices.find(proj_id);
-        if(shard_it == workspace.merged_indices.end())
-            return {};
-
-        for(auto& [hash, symbol]: workspace.project_index.symbols) {
-            if(!symbol.reference_files.contains(proj_id))
-                continue;
-            bool found = false;
-            shard_it->second.find_relations(hash,
-                                            RelationKind::Definition,
-                                            [&](const index::Relation&, protocol::Range range) {
-                                                if(range.start.line == target_line) {
-                                                    found = true;
-                                                    return false;
-                                                }
-                                                return true;
-                                            });
-            if(found)
-                return {
-                    {hash, symbol.name, symbol.kind, path_str, *loc.line}
-                };
-        }
-
-        return {};
-    }
-
-    return {};
-}
-
-static std::uint64_t extract_symbol_id(const std::optional<protocol::LSPAny>& data) {
-    if(!data.has_value())
-        return 0;
-    if(auto* val = std::get_if<std::int64_t>(&static_cast<const protocol::LSPVariant&>(*data)))
-        return static_cast<std::uint64_t>(*val);
-    LOG_WARN("extract_symbol_id: unexpected LSPAny variant type");
-    return 0;
-}
-
-AgentClient::AgentClient(MasterServer& server, kota::ipc::JsonPeer& peer) :
-    server(server), peer(peer) {
-    using namespace agentic;
-
-    auto& srv = this->server;
-
-    peer.on_request(
-        [&srv](RequestContext&,
-               const CompileCommandParams& params) -> RequestResult<CompileCommandParams> {
-            std::string directory;
-            std::vector<std::string> arguments;
-            if(!srv.compiler.fill_compile_args(params.path, directory, arguments)) {
-                co_return kota::outcome_error(
-                    kota::ipc::Error{std::format("no compile command found for {}", params.path)});
-            }
-
-            co_return CompileCommandResult{
-                .file = params.path,
-                .directory = std::move(directory),
-                .arguments = std::move(arguments),
-            };
-        });
-
-    peer.on_request([&srv](RequestContext&,
-                           const ProjectFilesParams& params) -> RequestResult<ProjectFilesParams> {
-        auto& ws = srv.workspace;
-        auto filter = params.filter.value_or("all");
-
-        ProjectFilesResult result;
-        llvm::DenseSet<std::uint32_t> seen;
-
-        for(auto& entry: ws.cdb.get_entries()) {
-            auto file_path = ws.cdb.resolve_path(entry.file);
-            if(file_path.empty())
-                continue;
-
-            auto proj_it = ws.project_index.path_pool.find(file_path);
-            if(proj_it != ws.project_index.path_pool.cache.end()) {
-                if(!seen.insert(proj_it->second).second)
-                    continue;
-            }
-
-            std::string kind_str;
-            auto mod_it = ws.path_to_module.find(ws.path_pool.intern(file_path));
-            if(mod_it != ws.path_to_module.end()) {
-                kind_str = "module";
-            } else {
-                auto ext = llvm::sys::path::extension(file_path);
-                if(ext == ".h" || ext == ".hpp" || ext == ".hxx" || ext == ".hh")
-                    kind_str = "header";
-                else
-                    kind_str = "source";
-            }
-
-            if(filter != "all" && filter != kind_str)
-                continue;
-
-            FileInfo fi;
-            fi.path = file_path.str();
-            fi.kind = std::move(kind_str);
-            if(mod_it != ws.path_to_module.end())
-                fi.module_name = mod_it->second;
-            result.files.push_back(std::move(fi));
-        }
-
-        if(filter == "all" || filter == "header") {
-            for(auto& [path_id, shard]: ws.merged_indices) {
-                if(seen.contains(path_id))
-                    continue;
-                auto path_str = ws.project_index.path_pool.path(path_id);
-                auto ext = llvm::sys::path::extension(path_str);
-                if(ext == ".h" || ext == ".hpp" || ext == ".hxx" || ext == ".hh") {
-                    seen.insert(path_id);
-                    result.files.push_back(FileInfo{
-                        .path = path_str.str(),
-                        .kind = "header",
-                    });
-                }
-            }
-        }
-
-        result.total = static_cast<int>(result.files.size());
-        co_return result;
-    });
-
-    peer.on_request(
-        [&srv](RequestContext&, const FileDepsParams& params) -> RequestResult<FileDepsParams> {
-            auto& ws = srv.workspace;
-            auto pool_it = ws.path_pool.cache.find(params.path);
-            if(pool_it == ws.path_pool.cache.end())
-                co_return FileDepsResult{.file = params.path};
-            auto path_id = pool_it->second;
-            auto direction = params.direction.value_or("both");
-            auto max_depth = params.depth.value_or(1);
-
-            FileDepsResult result;
-            result.file = params.path;
-
-            if(direction == "includes" || direction == "both") {
-                auto includes = ws.dep_graph.get_all_includes(path_id);
-                for(auto inc_id: includes) {
-                    auto real_id = inc_id & DependencyGraph::PATH_ID_MASK;
-                    auto inc_path = ws.path_pool.resolve(real_id);
-                    result.includes.push_back(DepEntry{.path = inc_path.str(), .depth = 1});
-                }
-
-                if(max_depth == 0 || max_depth > 1) {
-                    llvm::DenseSet<std::uint32_t> visited;
-                    visited.insert(path_id);
-                    for(auto& dep: result.includes)
-                        visited.insert(ws.path_pool.intern(dep.path));
-
-                    for(std::size_t i = 0; i < result.includes.size(); ++i) {
-                        if(max_depth > 0 && result.includes[i].depth >= max_depth)
-                            continue;
-                        auto dep_id = ws.path_pool.intern(result.includes[i].path);
-                        auto sub = ws.dep_graph.get_all_includes(dep_id);
-                        for(auto sub_id: sub) {
-                            auto real_id = sub_id & DependencyGraph::PATH_ID_MASK;
-                            if(!visited.insert(real_id).second)
-                                continue;
-                            auto sub_path = ws.path_pool.resolve(real_id);
-                            result.includes.push_back(DepEntry{
-                                .path = sub_path.str(),
-                                .depth = result.includes[i].depth + 1,
-                            });
-                        }
-                    }
-                }
-            }
-
-            if(direction == "includers" || direction == "both") {
-                auto includers = ws.dep_graph.get_includers(path_id);
-                for(auto inc_id: includers) {
-                    auto inc_path = ws.path_pool.resolve(inc_id);
-                    result.includers.push_back(DepEntry{.path = inc_path.str(), .depth = 1});
-                }
-
-                if(max_depth == 0 || max_depth > 1) {
-                    llvm::DenseSet<std::uint32_t> visited;
-                    visited.insert(path_id);
-                    for(auto& dep: result.includers) {
-                        auto it = ws.path_pool.cache.find(dep.path);
-                        if(it != ws.path_pool.cache.end())
-                            visited.insert(it->second);
-                    }
-
-                    for(std::size_t i = 0; i < result.includers.size(); ++i) {
-                        if(max_depth > 0 && result.includers[i].depth >= max_depth)
-                            continue;
-                        auto dep_it = ws.path_pool.cache.find(result.includers[i].path);
-                        if(dep_it == ws.path_pool.cache.end())
-                            continue;
-                        auto sub = ws.dep_graph.get_includers(dep_it->second);
-                        for(auto sub_id: sub) {
-                            if(!visited.insert(sub_id).second)
-                                continue;
-                            auto sub_path = ws.path_pool.resolve(sub_id);
-                            result.includers.push_back(DepEntry{
-                                .path = sub_path.str(),
-                                .depth = result.includers[i].depth + 1,
-                            });
-                        }
-                    }
-                }
-            }
-
-            co_return result;
-        });
-
-    peer.on_request(
-        [&srv](RequestContext&,
-               const ImpactAnalysisParams& params) -> RequestResult<ImpactAnalysisParams> {
-            auto& ws = srv.workspace;
-            auto pool_it = ws.path_pool.cache.find(params.path);
-            if(pool_it == ws.path_pool.cache.end())
-                co_return ImpactAnalysisResult{};
-            auto path_id = pool_it->second;
-
-            ImpactAnalysisResult result;
-
-            auto direct_includers = ws.dep_graph.get_includers(path_id);
-            for(auto inc_id: direct_includers) {
-                result.direct_dependents.push_back(ws.path_pool.resolve(inc_id).str());
-            }
-
-            auto hosts = ws.dep_graph.find_host_sources(path_id);
-            llvm::DenseSet<std::uint32_t> seen;
-            seen.insert(path_id);
-            for(auto inc_id: direct_includers)
-                seen.insert(inc_id);
-            for(auto host_id: hosts) {
-                if(seen.insert(host_id).second)
-                    result.transitive_dependents.push_back(ws.path_pool.resolve(host_id).str());
-            }
-
-            for(auto host_id: hosts) {
-                auto it = ws.path_to_module.find(host_id);
-                if(it != ws.path_to_module.end())
-                    result.affected_modules.push_back(it->second);
-            }
-            auto mod_it = ws.path_to_module.find(path_id);
-            if(mod_it != ws.path_to_module.end())
-                result.affected_modules.push_back(mod_it->second);
-
-            co_return result;
-        });
-
-    peer.on_request([&srv](RequestContext&,
-                           const SymbolSearchParams& params) -> RequestResult<SymbolSearchParams> {
-        auto max = params.max_results.value_or(100);
-        std::string query_lower = llvm::StringRef(params.query).lower();
-
-        SymbolSearchResult result;
-        llvm::DenseSet<index::SymbolHash> seen;
-
-        auto try_symbol = [&](index::SymbolHash hash, const index::Symbol& symbol) {
-            if(static_cast<int>(result.symbols.size()) >= max)
-                return;
-            if(symbol.name.empty())
-                return;
-            if(!query_lower.empty() &&
-               llvm::StringRef(symbol.name).lower().find(query_lower) == std::string::npos)
-                return;
-            if(params.kind_filter.has_value()) {
-                auto kind_name = std::string(symbol_kind_name(symbol.kind));
-                auto& filter = *params.kind_filter;
-                if(std::ranges::find(filter, kind_name) == filter.end())
-                    return;
-            }
-            auto def_loc = srv.indexer.find_definition_location(hash);
-            if(!def_loc)
-                return;
-            if(!seen.insert(hash).second)
-                return;
-            auto file = uri_to_path(def_loc->uri);
-            result.symbols.push_back(SymbolEntry{
-                .name = symbol.name,
-                .kind = std::string(symbol_kind_name(symbol.kind)),
-                .file = std::move(file),
-                .line = static_cast<int>(def_loc->range.start.line) + 1,
-                .symbol_id = hash,
-            });
-        };
-
-        for(auto& [hash, symbol]: srv.workspace.project_index.symbols)
-            try_symbol(hash, symbol);
-        for(auto& [_, sess]: srv.sessions) {
-            if(!sess.file_index)
-                continue;
-            for(auto& [hash, symbol]: sess.file_index->symbols)
-                try_symbol(hash, symbol);
-        }
-
-        co_return result;
-    });
-
-    peer.on_request(
-        [&srv](RequestContext&, const ReadSymbolParams& params) -> RequestResult<ReadSymbolParams> {
-            auto candidates = resolve_locator(params, srv.workspace, srv.sessions, srv.indexer);
-            if(candidates.empty())
-                co_return kota::outcome_error(kota::ipc::Error{"symbol not found"});
-            if(candidates.size() > 1) {
-                co_return kota::outcome_error(kota::ipc::Error{
-                    std::format("ambiguous: {} candidates, use symbolId to disambiguate",
-                                candidates.size())});
-            }
-
-            auto& rs = candidates[0];
-            auto def_text = srv.indexer.get_definition_text(rs.hash);
-            if(!def_text)
-                co_return kota::outcome_error(kota::ipc::Error{"definition not found"});
-
-            co_return ReadSymbolResult{
-                .name = rs.name,
-                .kind = std::string(symbol_kind_name(rs.kind)),
-                .file = std::move(def_text->file),
-                .start_line = def_text->start_line,
-                .end_line = def_text->end_line,
-                .text = std::move(def_text->text),
-                .symbol_id = rs.hash,
-            };
-        });
-
-    peer.on_request(
-        [&srv](RequestContext&,
-               const DocumentSymbolsParams& params) -> RequestResult<DocumentSymbolsParams> {
-            auto is_document_level = [](SymbolKind kind) {
-                return kind == SymbolKind::Namespace || kind == SymbolKind::Class ||
-                       kind == SymbolKind::Struct || kind == SymbolKind::Union ||
-                       kind == SymbolKind::Enum || kind == SymbolKind::Type ||
-                       kind == SymbolKind::Field || kind == SymbolKind::EnumMember ||
-                       kind == SymbolKind::Function || kind == SymbolKind::Method ||
-                       kind == SymbolKind::Variable || kind == SymbolKind::Macro ||
-                       kind == SymbolKind::Concept || kind == SymbolKind::Module ||
-                       kind == SymbolKind::Operator || kind == SymbolKind::Attribute;
-            };
-
-            DocumentSymbolsResult result;
-
-            auto pool_it = srv.workspace.path_pool.cache.find(params.path);
-            if(pool_it == srv.workspace.path_pool.cache.end())
-                co_return result;
-            auto server_id = pool_it->second;
-            auto sess_it = srv.sessions.find(server_id);
-            if(sess_it != srv.sessions.end() && sess_it->second.file_index) {
-                auto& fi = *sess_it->second.file_index;
-                for(auto& [hash, rels]: fi.file_index.relations) {
-                    for(auto& rel: rels) {
-                        if(rel.kind.value() != RelationKind::Definition)
-                            continue;
-                        std::string name;
-                        SymbolKind kind;
-                        if(!srv.indexer.find_symbol_info(hash, name, kind))
-                            continue;
-                        if(!is_document_level(kind))
-                            continue;
-                        if(fi.mapper) {
-                            auto start = fi.mapper->to_position(rel.range.begin);
-                            auto end = fi.mapper->to_position(rel.range.end);
-                            if(start && end) {
-                                result.symbols.push_back(DocumentSymbolEntry{
-                                    .name = std::move(name),
-                                    .kind = std::string(symbol_kind_name(kind)),
-                                    .start_line = static_cast<int>(start->line) + 1,
-                                    .end_line = static_cast<int>(end->line) + 1,
-                                    .symbol_id = hash,
-                                });
-                                break;
-                            }
-                        }
-                    }
-                }
-                co_return result;
-            }
-
-            auto it = srv.workspace.project_index.path_pool.find(params.path);
-            if(it == srv.workspace.project_index.path_pool.cache.end())
-                co_return result;
-
-            auto proj_id = it->second;
-            auto shard_it = srv.workspace.merged_indices.find(proj_id);
-            if(shard_it == srv.workspace.merged_indices.end())
-                co_return result;
-
-            for(auto& [hash, symbol]: srv.workspace.project_index.symbols) {
-                if(symbol.name.empty())
-                    continue;
-                if(!is_document_level(symbol.kind))
-                    continue;
-                if(!symbol.reference_files.contains(proj_id))
-                    continue;
-
-                shard_it->second.find_relations(
-                    hash,
-                    RelationKind::Definition,
-                    [&](const index::Relation&, protocol::Range range) {
-                        result.symbols.push_back(DocumentSymbolEntry{
-                            .name = symbol.name,
-                            .kind = std::string(symbol_kind_name(symbol.kind)),
-                            .start_line = static_cast<int>(range.start.line) + 1,
-                            .end_line = static_cast<int>(range.end.line) + 1,
-                            .symbol_id = hash,
-                        });
-                        return true;
-                    });
-            }
-
-            co_return result;
-        });
-
-    peer.on_request(
-        [&srv](RequestContext&, const DefinitionParams& params) -> RequestResult<DefinitionParams> {
-            auto candidates = resolve_locator(
-                ReadSymbolParams{params.name, params.path, params.line, params.symbol_id},
-                srv.workspace,
-                srv.sessions,
-                srv.indexer);
-            if(candidates.empty())
-                co_return kota::outcome_error(kota::ipc::Error{"symbol not found"});
-            if(candidates.size() > 1) {
-                co_return kota::outcome_error(kota::ipc::Error{
-                    std::format("ambiguous: {} candidates, use symbolId to disambiguate",
-                                candidates.size())});
-            }
-
-            auto& rs = candidates[0];
-
-            DefinitionResult result;
-            result.name = rs.name;
-            result.kind = std::string(symbol_kind_name(rs.kind));
-            result.symbol_id = rs.hash;
-
-            if(auto def_text = srv.indexer.get_definition_text(rs.hash)) {
-                result.definition = LocationEntry{
-                    .file = std::move(def_text->file),
-                    .start_line = def_text->start_line,
-                    .end_line = def_text->end_line,
-                    .text = std::move(def_text->text),
-                };
-            }
-
-            co_return result;
-        });
-
-    peer.on_request(
-        [&srv](RequestContext&, const ReferencesParams& params) -> RequestResult<ReferencesParams> {
-            auto candidates = resolve_locator(
-                ReadSymbolParams{params.name, params.path, params.line, params.symbol_id},
-                srv.workspace,
-                srv.sessions,
-                srv.indexer);
-            if(candidates.empty())
-                co_return kota::outcome_error(kota::ipc::Error{"symbol not found"});
-            if(candidates.size() > 1) {
-                co_return kota::outcome_error(kota::ipc::Error{
-                    std::format("ambiguous: {} candidates, use symbolId to disambiguate",
-                                candidates.size())});
-            }
-
-            auto& rs = candidates[0];
-
-            ReferencesResult result;
-            result.name = rs.name;
-            result.kind = std::string(symbol_kind_name(rs.kind));
-            result.symbol_id = rs.hash;
-
-            for(auto& ref: srv.indexer.collect_references(rs.hash, RelationKind::Reference)) {
-                result.references.push_back(ReferenceEntry{
-                    .file = std::move(ref.file),
-                    .line = ref.line,
-                    .context = std::move(ref.context),
-                });
-            }
-            if(params.include_declaration.value_or(false)) {
-                for(auto& ref: srv.indexer.collect_references(rs.hash, RelationKind::Definition)) {
-                    result.references.push_back(ReferenceEntry{
-                        .file = std::move(ref.file),
-                        .line = ref.line,
-                        .context = std::move(ref.context),
-                    });
-                }
-            }
-
-            result.total = static_cast<int>(result.references.size());
-            co_return result;
-        });
-
-    peer.on_request(
-        [&srv](RequestContext&, const CallGraphParams& params) -> RequestResult<CallGraphParams> {
-            auto candidates = resolve_locator(
-                ReadSymbolParams{params.name, params.path, params.line, params.symbol_id},
-                srv.workspace,
-                srv.sessions,
-                srv.indexer);
-            if(candidates.empty())
-                co_return kota::outcome_error(kota::ipc::Error{"symbol not found"});
-            if(candidates.size() > 1) {
-                co_return kota::outcome_error(kota::ipc::Error{
-                    std::format("ambiguous: {} candidates, use symbolId to disambiguate",
-                                candidates.size())});
-            }
-
-            auto& rs = candidates[0];
-            auto direction = params.direction.value_or("both");
-
-            CallGraphResult result;
-            result.root = CallGraphEntry{
-                .name = rs.name,
-                .kind = std::string(symbol_kind_name(rs.kind)),
-                .file = rs.file,
-                .line = rs.line,
-                .symbol_id = rs.hash,
-            };
-
-            auto resolve_kind = [&](std::uint64_t sym_id) -> std::string {
-                if(sym_id == 0)
-                    return "Function";
-                std::string name;
-                SymbolKind kind;
-                if(srv.indexer.find_symbol_info(sym_id, name, kind))
-                    return std::string(symbol_kind_name(kind));
-                return "Function";
-            };
-
-            if(direction == "callers" || direction == "both") {
-                auto incoming = srv.indexer.find_incoming_calls(rs.hash);
-                for(auto& call: incoming) {
-                    auto sid = extract_symbol_id(call.from.data);
-                    result.callers.push_back(CallGraphEntry{
-                        .name = call.from.name,
-                        .kind = resolve_kind(sid),
-                        .file = uri_to_path(call.from.uri),
-                        .line = static_cast<int>(call.from.range.start.line) + 1,
-                        .symbol_id = sid,
-                    });
-                }
-            }
-
-            if(direction == "callees" || direction == "both") {
-                auto outgoing = srv.indexer.find_outgoing_calls(rs.hash);
-                for(auto& call: outgoing) {
-                    auto sid = extract_symbol_id(call.to.data);
-                    result.callees.push_back(CallGraphEntry{
-                        .name = call.to.name,
-                        .kind = resolve_kind(sid),
-                        .file = uri_to_path(call.to.uri),
-                        .line = static_cast<int>(call.to.range.start.line) + 1,
-                        .symbol_id = sid,
-                    });
-                }
-            }
-
-            co_return result;
-        });
-
-    peer.on_request(
-        [&srv](RequestContext&,
-               const TypeHierarchyParams& params) -> RequestResult<TypeHierarchyParams> {
-            auto candidates = resolve_locator(
-                ReadSymbolParams{params.name, params.path, params.line, params.symbol_id},
-                srv.workspace,
-                srv.sessions,
-                srv.indexer);
-            if(candidates.empty())
-                co_return kota::outcome_error(kota::ipc::Error{"symbol not found"});
-            if(candidates.size() > 1) {
-                co_return kota::outcome_error(kota::ipc::Error{
-                    std::format("ambiguous: {} candidates, use symbolId to disambiguate",
-                                candidates.size())});
-            }
-
-            auto& rs = candidates[0];
-            auto direction = params.direction.value_or("both");
-
-            TypeHierarchyResult result;
-            result.root = TypeHierarchyEntry{
-                .name = rs.name,
-                .kind = std::string(symbol_kind_name(rs.kind)),
-                .file = rs.file,
-                .line = rs.line,
-                .symbol_id = rs.hash,
-            };
-
-            auto resolve_kind = [&](std::uint64_t sym_id) -> std::string {
-                if(sym_id == 0)
-                    return "Class";
-                std::string name;
-                SymbolKind kind;
-                if(srv.indexer.find_symbol_info(sym_id, name, kind))
-                    return std::string(symbol_kind_name(kind));
-                return "Class";
-            };
-
-            if(direction == "supertypes" || direction == "both") {
-                for(auto& item: srv.indexer.find_supertypes(rs.hash)) {
-                    auto sid = extract_symbol_id(item.data);
-                    result.supertypes.push_back(TypeHierarchyEntry{
-                        .name = item.name,
-                        .kind = resolve_kind(sid),
-                        .file = uri_to_path(item.uri),
-                        .line = static_cast<int>(item.range.start.line) + 1,
-                        .symbol_id = sid,
-                    });
-                }
-            }
-
-            if(direction == "subtypes" || direction == "both") {
-                for(auto& item: srv.indexer.find_subtypes(rs.hash)) {
-                    auto sid = extract_symbol_id(item.data);
-                    result.subtypes.push_back(TypeHierarchyEntry{
-                        .name = item.name,
-                        .kind = resolve_kind(sid),
-                        .file = uri_to_path(item.uri),
-                        .line = static_cast<int>(item.range.start.line) + 1,
-                        .symbol_id = sid,
-                    });
-                }
-            }
-
-            co_return result;
-        });
-
-    peer.on_request([&srv](RequestContext&, const StatusParams&) -> RequestResult<StatusParams> {
-        StatusResult result;
-        result.idle = srv.indexer.is_idle();
-        result.pending = static_cast<int>(srv.indexer.pending_files());
-        result.total = static_cast<int>(srv.indexer.total_queued());
-        result.indexed = std::max(0, result.total - result.pending);
-        co_return result;
-    });
-
-    peer.on_notification([&srv](const ShutdownParams&) {
-        LOG_INFO("agentic/shutdown received, shutting down");
-        srv.schedule_shutdown();
-    });
-}
-
-}  // namespace clice

src/server/service/agent_client.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "kota/ipc/codec/json.h"
-
-namespace clice {
-
-class MasterServer;
-
-class AgentClient {
-public:
-    AgentClient(MasterServer& server, kota::ipc::JsonPeer& peer);
-
-private:
-    MasterServer& server;
-    kota::ipc::JsonPeer& peer;
-};
-
-}  // namespace clice

src/server/service/agentic.cpp

@@ -1,177 +0,0 @@
-#include "server/service/agentic.h"
-
-#include <memory>
-#include <print>
-#include <string>
-
-#include "server/protocol/agentic.h"
-#include "support/filesystem.h"
-#include "support/logging.h"
-
-#include "kota/async/async.h"
-#include "kota/ipc/codec/json.h"
-#include "kota/ipc/transport.h"
-
-namespace clice {
-
-template <typename Params>
-static kota::task<bool> send_and_print(kota::ipc::JsonPeer& peer, Params params) {
-    auto result = co_await peer.send_request(std::move(params));
-    if(!result) {
-        LOG_ERROR("request failed: {}", result.error().message);
-        co_return false;
-    }
-    auto json = kota::codec::json::to_string<kota::ipc::lsp_config>(*result);
-    std::println("{}", json ? *json : "null");
-    co_return true;
-}
-
-static kota::task<> agentic_request(kota::ipc::JsonPeer& peer,
-                                    int& exit_code,
-                                    const AgenticQueryOptions& opts) {
-    bool ok = false;
-
-    if(opts.method == "compileCommand") {
-        ok = co_await send_and_print(peer, agentic::CompileCommandParams{.path = opts.path});
-    } else if(opts.method == "projectFiles") {
-        auto filter = opts.query.empty() ? std::nullopt : std::optional(opts.query);
-        ok = co_await send_and_print(peer, agentic::ProjectFilesParams{.filter = filter});
-    } else if(opts.method == "symbolSearch") {
-        ok = co_await send_and_print(peer, agentic::SymbolSearchParams{.query = opts.query});
-    } else if(opts.method == "definition") {
-        auto name = opts.name.empty() ? std::nullopt : std::optional(opts.name);
-        auto path = opts.path.empty() ? std::nullopt : std::optional(opts.path);
-        auto line = opts.line > 0 ? std::optional(opts.line) : std::nullopt;
-        ok = co_await send_and_print(
-            peer,
-            agentic::DefinitionParams{.name = name, .path = path, .line = line});
-    } else if(opts.method == "references") {
-        auto name = opts.name.empty() ? std::nullopt : std::optional(opts.name);
-        auto path = opts.path.empty() ? std::nullopt : std::optional(opts.path);
-        auto line = opts.line > 0 ? std::optional(opts.line) : std::nullopt;
-        ok = co_await send_and_print(
-            peer,
-            agentic::ReferencesParams{.name = name, .path = path, .line = line});
-    } else if(opts.method == "readSymbol") {
-        auto name = opts.name.empty() ? std::nullopt : std::optional(opts.name);
-        auto path = opts.path.empty() ? std::nullopt : std::optional(opts.path);
-        auto line = opts.line > 0 ? std::optional(opts.line) : std::nullopt;
-        ok = co_await send_and_print(
-            peer,
-            agentic::ReadSymbolParams{.name = name, .path = path, .line = line});
-    } else if(opts.method == "documentSymbols") {
-        ok = co_await send_and_print(peer, agentic::DocumentSymbolsParams{.path = opts.path});
-    } else if(opts.method == "callGraph") {
-        auto name = opts.name.empty() ? std::nullopt : std::optional(opts.name);
-        auto path = opts.path.empty() ? std::nullopt : std::optional(opts.path);
-        auto line = opts.line > 0 ? std::optional(opts.line) : std::nullopt;
-        auto dir = opts.direction.empty() ? std::nullopt : std::optional(opts.direction);
-        ok = co_await send_and_print(peer,
-                                     agentic::CallGraphParams{
-                                         .name = name,
-                                         .path = path,
-                                         .line = line,
-                                         .direction = dir,
-                                     });
-    } else if(opts.method == "typeHierarchy") {
-        auto name = opts.name.empty() ? std::nullopt : std::optional(opts.name);
-        auto path = opts.path.empty() ? std::nullopt : std::optional(opts.path);
-        auto line = opts.line > 0 ? std::optional(opts.line) : std::nullopt;
-        auto dir = opts.direction.empty() ? std::nullopt : std::optional(opts.direction);
-        ok = co_await send_and_print(peer,
-                                     agentic::TypeHierarchyParams{
-                                         .name = name,
-                                         .path = path,
-                                         .line = line,
-                                         .direction = dir,
-                                     });
-    } else if(opts.method == "fileDeps") {
-        auto dir = opts.direction.empty() ? std::nullopt : std::optional(opts.direction);
-        ok = co_await send_and_print(peer,
-                                     agentic::FileDepsParams{.path = opts.path, .direction = dir});
-    } else if(opts.method == "impactAnalysis") {
-        ok = co_await send_and_print(peer, agentic::ImpactAnalysisParams{.path = opts.path});
-    } else if(opts.method == "status") {
-        ok = co_await send_and_print(peer, agentic::StatusParams{});
-    } else if(opts.method == "shutdown") {
-        peer.send_notification(agentic::ShutdownParams{});
-        ok = true;
-    } else {
-        LOG_ERROR("unknown agentic method '{}'", opts.method);
-    }
-
-    if(ok)
-        exit_code = 0;
-    peer.close();
-}
-
-static kota::task<> agentic_client(int& exit_code,
-                                   std::unique_ptr<kota::ipc::JsonPeer>& peer_out,
-                                   const AgenticQueryOptions& opts) {
-    auto& loop = kota::event_loop::current();
-    auto transport = co_await kota::ipc::StreamTransport::connect_tcp(opts.host, opts.port, loop);
-    if(!transport) {
-        LOG_ERROR("failed to connect to {}:{}", opts.host, opts.port);
-        co_return;
-    }
-
-    peer_out = std::make_unique<kota::ipc::JsonPeer>(loop, std::move(*transport));
-    co_await kota::when_all(peer_out->run(), agentic_request(*peer_out, exit_code, opts));
-}
-
-int run_agentic_mode(const AgenticQueryOptions& opts) {
-    logging::stderr_logger("agentic", logging::options);
-
-    kota::event_loop loop;
-    int exit_code = 1;
-    std::unique_ptr<kota::ipc::JsonPeer> peer;
-    loop.schedule(agentic_client(exit_code, peer, opts));
-    loop.run();
-    return exit_code;
-}
-
-static kota::task<> relay_forward(kota::ipc::Transport& from, kota::ipc::Transport& to) {
-    while(true) {
-        auto msg = co_await from.read_message();
-        if(!msg)
-            break;
-        co_await to.write_message(*msg);
-    }
-    to.close();
-}
-
-static kota::task<> relay_main(kota::event_loop& loop, int& exit_code, std::string socket_path) {
-    auto stdio = kota::ipc::StreamTransport::open_stdio(loop);
-    if(!stdio) {
-        LOG_ERROR("failed to open stdio transport");
-        loop.stop();
-        co_return;
-    }
-
-    auto conn = co_await kota::pipe::connect(socket_path, {}, loop);
-    if(!conn) {
-        LOG_ERROR("failed to connect to {}", socket_path);
-        loop.stop();
-        co_return;
-    }
-
-    auto socket = std::make_unique<kota::ipc::StreamTransport>(std::move(*conn));
-
-    co_await kota::when_all(relay_forward(**stdio, *socket), relay_forward(*socket, **stdio));
-    exit_code = 0;
-    loop.stop();
-}
-
-int run_relay_mode(llvm::StringRef socket_path) {
-    logging::stderr_logger("relay", logging::options);
-
-    auto path = socket_path.empty() ? path::default_socket_path() : socket_path.str();
-
-    kota::event_loop loop;
-    int exit_code = 1;
-    loop.schedule(relay_main(loop, exit_code, std::move(path)));
-    loop.run();
-    return exit_code;
-}
-
-}  // namespace clice

src/server/service/agentic.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "llvm/ADT/StringRef.h"
-
-namespace clice {
-
-struct AgenticQueryOptions {
-    std::string host;
-    int port = 0;
-    std::string method;
-    std::string path;
-    std::string name;
-    std::string query;
-    int line = 0;
-    std::string direction;
-};
-
-int run_agentic_mode(const AgenticQueryOptions& opts);
-
-int run_relay_mode(llvm::StringRef socket_path);
-
-}  // namespace clice

src/server/service/lsp_client.cpp

@@ -1,714 +0,0 @@
-#include "server/service/lsp_client.h"
-
-#include <algorithm>
-#include <format>
-#include <string>
-#include <type_traits>
-#include <variant>
-
-#include "semantic/symbol_kind.h"
-#include "server/protocol/extension.h"
-#include "server/protocol/worker.h"
-#include "server/service/master_server.h"
-#include "support/filesystem.h"
-#include "support/logging.h"
-
-#include "kota/codec/json/json.h"
-#include "kota/ipc/lsp/position.h"
-#include "kota/ipc/lsp/protocol.h"
-#include "kota/ipc/lsp/uri.h"
-#include "kota/meta/enum.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/Process.h"
-
-namespace clice {
-
-namespace protocol = kota::ipc::protocol;
-namespace lsp = kota::ipc::lsp;
-namespace refl = kota::meta;
-using kota::ipc::RequestResult;
-using RequestContext = kota::ipc::JsonPeer::RequestContext;
-using serde_raw = kota::codec::RawValue;
-
-template <typename T>
-static serde_raw to_raw(const T& value) {
-    auto json = kota::codec::json::to_json<kota::ipc::lsp_config>(value);
-    return serde_raw{json ? std::move(*json) : "null"};
-}
-
-LSPClient::LSPClient(MasterServer& server, kota::ipc::JsonPeer& peer) : server(server), peer(peer) {
-    server.compiler.set_peer(&peer);
-    server.indexer.set_peer(&peer);
-
-    using StringVec = std::vector<std::string>;
-
-    peer.on_request([this](RequestContext& ctx, const protocol::InitializeParams& params)
-                        -> RequestResult<protocol::InitializeParams> {
-        auto& srv = this->server;
-        if(srv.lifecycle != ServerLifecycle::Uninitialized) {
-            co_return kota::outcome_error(protocol::Error{"Server already initialized"});
-        }
-
-        auto& init = params.lsp__initialize_params;
-        if(init.root_uri.has_value()) {
-            srv.workspace_root = uri_to_path(*init.root_uri);
-        }
-
-        if(init.initialization_options.has_value()) {
-            auto json =
-                kota::codec::json::to_json<kota::ipc::lsp_config>(*init.initialization_options);
-            if(json)
-                srv.init_options_json = std::move(*json);
-        }
-
-        srv.lifecycle = ServerLifecycle::Initialized;
-        LOG_INFO("Initialized with workspace: {}", srv.workspace_root);
-
-        protocol::InitializeResult result;
-        auto& caps = result.capabilities;
-
-        caps.text_document_sync = protocol::TextDocumentSyncOptions{
-            .open_close = true,
-            .change = protocol::TextDocumentSyncKind::Incremental,
-            .save = protocol::variant<protocol::boolean, protocol::SaveOptions>{true},
-        };
-        caps.workspace = protocol::WorkspaceOptions{};
-        caps.workspace->workspace_folders = protocol::WorkspaceFoldersServerCapabilities{
-            .supported = true,
-            .change_notifications = true,
-        };
-
-        caps.hover_provider = true;
-        caps.completion_provider = protocol::CompletionOptions{
-            .trigger_characters = StringVec{".", "<", ">", ":", "\"", "/", "*"},
-        };
-        caps.signature_help_provider = protocol::SignatureHelpOptions{
-            .trigger_characters = StringVec{"(", ")", "{", "}", "<", ">", ","},
-        };
-        caps.declaration_provider = protocol::DeclarationOptions{
-            .work_done_progress = false,
-        };
-        caps.definition_provider = protocol::DefinitionOptions{
-            .work_done_progress = false,
-        };
-        caps.implementation_provider = protocol::ImplementationOptions{
-            .work_done_progress = false,
-        };
-        caps.type_definition_provider = protocol::TypeDefinitionOptions{
-            .work_done_progress = false,
-        };
-        caps.references_provider = protocol::ReferenceOptions{
-            .work_done_progress = false,
-        };
-        caps.document_symbol_provider = true;
-        caps.document_link_provider = protocol::DocumentLinkOptions{};
-        caps.code_action_provider = true;
-        caps.folding_range_provider = true;
-        caps.inlay_hint_provider = true;
-        caps.call_hierarchy_provider = true;
-        caps.type_hierarchy_provider = true;
-        caps.workspace_symbol_provider = true;
-        caps.document_formatting_provider = true;
-        caps.document_range_formatting_provider = true;
-
-        protocol::SemanticTokensOptions sem_opts;
-        {
-            auto lower_first = [](std::string_view name) -> std::string {
-                std::string s(name);
-                if(!s.empty()) {
-                    s[0] = static_cast<char>(std::tolower(static_cast<unsigned char>(s[0])));
-                }
-                return s;
-            };
-
-            auto to_names = [&](auto names) {
-                return std::ranges::to<std::vector>(names | std::views::transform(lower_first));
-            };
-
-            sem_opts.legend = protocol::SemanticTokensLegend{
-                to_names(refl::reflection<SymbolKind::Kind>::member_names),
-                to_names(refl::reflection<SymbolModifiers::Kind>::member_names),
-            };
-        }
-        sem_opts.full = true;
-        result.capabilities.semantic_tokens_provider = std::move(sem_opts);
-
-        protocol::ServerInfo info;
-        info.name = "clice";
-        info.version = "0.1.0";
-        result.server_info = std::move(info);
-
-        co_return result;
-    });
-
-    peer.on_notification([this]([[maybe_unused]] const protocol::InitializedParams& params) {
-        this->server.initialize();
-    });
-
-    peer.on_request(
-        [this](RequestContext& ctx,
-               const protocol::ShutdownParams& params) -> RequestResult<protocol::ShutdownParams> {
-            this->server.lifecycle = ServerLifecycle::ShuttingDown;
-            LOG_INFO("Shutdown requested");
-            co_return nullptr;
-        });
-
-    peer.on_notification([this]([[maybe_unused]] const protocol::ExitParams& params) {
-        LOG_INFO("Exit notification received");
-        this->server.schedule_shutdown();
-    });
-
-    peer.on_notification([this](const protocol::DidOpenTextDocumentParams& params) {
-        auto& srv = this->server;
-        if(srv.lifecycle != ServerLifecycle::Ready)
-            return;
-
-        auto path = uri_to_path(params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-
-        auto& session = srv.open_session(path_id);
-        session.version = params.text_document.version;
-        session.text = params.text_document.text;
-        session.generation++;
-
-        LOG_DEBUG("didOpen: {} (v{})", path, params.text_document.version);
-    });
-
-    peer.on_notification([this](const protocol::DidChangeTextDocumentParams& params) {
-        auto& srv = this->server;
-        if(srv.lifecycle != ServerLifecycle::Ready)
-            return;
-
-        auto path = uri_to_path(params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-
-        auto* session = srv.find_session(path_id);
-        if(!session)
-            return;
-
-        session->version = params.text_document.version;
-
-        for(auto& change: params.content_changes) {
-            std::visit(
-                [&](auto& c) {
-                    using T = std::remove_cvref_t<decltype(c)>;
-                    if constexpr(std::is_same_v<T,
-                                                protocol::TextDocumentContentChangeWholeDocument>) {
-                        session->text = c.text;
-                    } else {
-                        auto& range = c.range;
-                        lsp::PositionMapper mapper(session->text, lsp::PositionEncoding::UTF16);
-                        auto start = mapper.to_offset(range.start);
-                        auto end = mapper.to_offset(range.end);
-                        if(start && end && *start <= *end) {
-                            session->text.replace(*start, *end - *start, c.text);
-                        }
-                    }
-                },
-                change);
-        }
-
-        session->generation++;
-        session->ast_dirty = true;
-
-        LOG_DEBUG("didChange: path={} version={} gen={}",
-                  path,
-                  session->version,
-                  session->generation);
-
-        worker::DocumentUpdateParams update;
-        update.path = path;
-        update.version = session->version;
-        srv.pool.notify_stateful(path_id, update);
-    });
-
-    peer.on_notification([this](const protocol::DidCloseTextDocumentParams& params) {
-        auto& srv = this->server;
-        if(srv.lifecycle != ServerLifecycle::Ready)
-            return;
-
-        auto path_id = srv.workspace.path_pool.intern(uri_to_path(params.text_document.uri));
-        srv.close_session(path_id, this->peer);
-    });
-
-    peer.on_notification([this](const protocol::DidSaveTextDocumentParams& params) {
-        auto& srv = this->server;
-        if(srv.lifecycle != ServerLifecycle::Ready)
-            return;
-
-        auto path = uri_to_path(params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-        srv.on_file_saved(path_id);
-
-        LOG_DEBUG("didSave: {}", path);
-    });
-
-    peer.on_request([this](RequestContext& ctx, const protocol::HoverParams& params) -> RawResult {
-        auto& srv = this->server;
-        auto path = uri_to_path(params.text_document_position_params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-        auto* session = srv.find_session(path_id);
-        if(!session)
-            co_return serde_raw{"null"};
-        co_return co_await srv.compiler.forward_query(
-            worker::QueryKind::Hover,
-            *session,
-            params.text_document_position_params.position);
-    });
-
-    peer.on_request([this](RequestContext& ctx,
-                           const protocol::SemanticTokensParams& params) -> RawResult {
-        auto& srv = this->server;
-        auto path = uri_to_path(params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-        auto* session = srv.find_session(path_id);
-        if(!session)
-            co_return serde_raw{"null"};
-        co_return co_await srv.compiler.forward_query(worker::QueryKind::SemanticTokens, *session);
-    });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::InlayHintParams& params) -> RawResult {
-            auto& srv = this->server;
-            auto path = uri_to_path(params.text_document.uri);
-            auto path_id = srv.workspace.path_pool.intern(path);
-            auto* session = srv.find_session(path_id);
-            if(!session)
-                co_return serde_raw{"null"};
-            co_return co_await srv.compiler.forward_query(worker::QueryKind::InlayHints,
-                                                          *session,
-                                                          {},
-                                                          params.range);
-        });
-
-    peer.on_request([this](RequestContext& ctx,
-                           const protocol::FoldingRangeParams& params) -> RawResult {
-        auto& srv = this->server;
-        auto path = uri_to_path(params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-        auto* session = srv.find_session(path_id);
-        if(!session)
-            co_return serde_raw{"null"};
-        co_return co_await srv.compiler.forward_query(worker::QueryKind::FoldingRange, *session);
-    });
-
-    peer.on_request([this](RequestContext& ctx,
-                           const protocol::DocumentSymbolParams& params) -> RawResult {
-        auto& srv = this->server;
-        auto path = uri_to_path(params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-        auto* session = srv.find_session(path_id);
-        if(!session)
-            co_return serde_raw{"null"};
-        co_return co_await srv.compiler.forward_query(worker::QueryKind::DocumentSymbol, *session);
-    });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::DocumentLinkParams& params) -> RawResult {
-            auto& srv = this->server;
-            auto path = uri_to_path(params.text_document.uri);
-            auto path_id = srv.workspace.path_pool.intern(path);
-            auto* session = srv.find_session(path_id);
-            if(!session)
-                co_return serde_raw{"null"};
-            auto result =
-                co_await srv.compiler.forward_query(worker::QueryKind::DocumentLink, *session);
-            if(!result.has_value())
-                co_return serde_raw{"null"};
-            auto& links = result.value();
-            auto* session2 = srv.find_session(path_id);
-            if(session2 && session2->pch_ref) {
-                auto& pch_cache = srv.workspace.pch_cache;
-                auto pch_it = pch_cache.find(session2->pch_ref->path_id);
-                if(pch_it != pch_cache.end() && !pch_it->second.document_links_json.empty()) {
-                    auto& pch_json = pch_it->second.document_links_json;
-                    if(!links.data.empty() && links.data != "null" && links.data.size() > 2) {
-                        links.data.pop_back();
-                        links.data += ',';
-                        links.data.append(pch_json.begin() + 1, pch_json.end());
-                    } else {
-                        links.data = pch_json;
-                    }
-                }
-            }
-            co_return std::move(links);
-        });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::CodeActionParams& params) -> RawResult {
-            auto& srv = this->server;
-            auto path = uri_to_path(params.text_document.uri);
-            auto path_id = srv.workspace.path_pool.intern(path);
-            auto* session = srv.find_session(path_id);
-            if(!session)
-                co_return serde_raw{"null"};
-            co_return co_await srv.compiler.forward_query(worker::QueryKind::CodeAction, *session);
-        });
-
-    auto resolve_uri = [this](const std::string& uri) {
-        struct Result {
-            std::string path;
-            std::uint32_t path_id;
-            Session* session;
-        };
-        auto path = uri_to_path(uri);
-        auto path_id = this->server.workspace.path_pool.intern(path);
-        auto* session = this->server.find_session(path_id);
-        return Result{std::move(path), path_id, session};
-    };
-
-    auto lookup_at = [this, resolve_uri](const std::string& uri, const protocol::Position& pos) {
-        auto [path, path_id, session] = resolve_uri(uri);
-        return this->server.indexer.lookup_symbol(uri, path, pos, session);
-    };
-
-    auto query_at = [this, resolve_uri](const std::string& uri,
-                                        const protocol::Position& pos,
-                                        RelationKind kind) -> std::vector<protocol::Location> {
-        auto [path, path_id, session] = resolve_uri(uri);
-        return this->server.indexer.query_relations(path, pos, kind, session);
-    };
-
-    auto resolve_item =
-        [this,
-         resolve_uri](const std::string& uri,
-                      const protocol::Range& range,
-                      const std::optional<protocol::LSPAny>& data) -> std::optional<SymbolInfo> {
-        auto [path, path_id, session] = resolve_uri(uri);
-        return this->server.indexer.resolve_hierarchy_item(uri, path, range, data, session);
-    };
-
-    peer.on_request([this, query_at](RequestContext& ctx,
-                                     const protocol::DefinitionParams& params) -> RawResult {
-        auto& uri = params.text_document_position_params.text_document.uri;
-        auto& pos = params.text_document_position_params.position;
-
-        auto result = query_at(uri, pos, RelationKind::Definition);
-        if(!result.empty()) {
-            co_return to_raw(result);
-        }
-
-        auto& srv = this->server;
-        auto path = uri_to_path(uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-        auto* session = srv.find_session(path_id);
-        if(!session)
-            co_return serde_raw{"null"};
-        co_return co_await srv.compiler.forward_query(worker::QueryKind::GoToDefinition,
-                                                      *session,
-                                                      pos);
-    });
-
-    peer.on_request([this, query_at](RequestContext& ctx,
-                                     const protocol::ReferenceParams& params) -> RawResult {
-        auto& uri = params.text_document_position_params.text_document.uri;
-        auto& pos = params.text_document_position_params.position;
-
-        auto locations = query_at(uri, pos, RelationKind::Reference);
-
-        if(params.context.include_declaration) {
-            auto defs = query_at(uri, pos, RelationKind::Definition);
-            locations.insert(locations.end(),
-                             std::make_move_iterator(defs.begin()),
-                             std::make_move_iterator(defs.end()));
-        }
-
-        if(locations.empty())
-            co_return serde_raw{"null"};
-        co_return to_raw(locations);
-    });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::TypeDefinitionParams& params) -> RawResult {
-            co_return serde_raw{"null"};
-        });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::ImplementationParams& params) -> RawResult {
-            co_return serde_raw{"null"};
-        });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::DeclarationParams& params) -> RawResult {
-            co_return serde_raw{"null"};
-        });
-
-    peer.on_request([this](RequestContext& ctx,
-                           const protocol::CompletionParams& params) -> RawResult {
-        auto& srv = this->server;
-        auto path = uri_to_path(params.text_document_position_params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-        auto* session = srv.find_session(path_id);
-        if(!session)
-            co_return serde_raw{"null"};
-        auto pause = srv.indexer.scoped_pause();
-        auto result =
-            co_await srv.compiler.handle_completion(params.text_document_position_params.position,
-                                                    *session);
-        co_return std::move(result);
-    });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::SignatureHelpParams& params) -> RawResult {
-            auto& srv = this->server;
-            auto path = uri_to_path(params.text_document_position_params.text_document.uri);
-            auto path_id = srv.workspace.path_pool.intern(path);
-            auto* session = srv.find_session(path_id);
-            if(!session)
-                co_return serde_raw{"null"};
-            auto pause = srv.indexer.scoped_pause();
-            auto result =
-                co_await srv.compiler.forward_build(worker::BuildKind::SignatureHelp,
-                                                    params.text_document_position_params.position,
-                                                    *session);
-            co_return std::move(result);
-        });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::DocumentFormattingParams& params) -> RawResult {
-            auto& srv = this->server;
-            auto path = uri_to_path(params.text_document.uri);
-            auto path_id = srv.workspace.path_pool.intern(path);
-            auto* session = srv.find_session(path_id);
-            if(!session)
-                co_return serde_raw{"null"};
-            auto pause = srv.indexer.scoped_pause();
-            co_return co_await srv.compiler.forward_format(*session);
-        });
-
-    peer.on_request([this](RequestContext& ctx,
-                           const protocol::DocumentRangeFormattingParams& params) -> RawResult {
-        auto& srv = this->server;
-        auto path = uri_to_path(params.text_document.uri);
-        auto path_id = srv.workspace.path_pool.intern(path);
-        auto* session = srv.find_session(path_id);
-        if(!session)
-            co_return serde_raw{"null"};
-        auto pause = srv.indexer.scoped_pause();
-        co_return co_await srv.compiler.forward_format(*session, params.range);
-    });
-
-    peer.on_request(
-        [this, lookup_at](RequestContext& ctx,
-                          const protocol::CallHierarchyPrepareParams& params) -> RawResult {
-            auto& uri = params.text_document_position_params.text_document.uri;
-            auto& pos = params.text_document_position_params.position;
-
-            auto info = lookup_at(uri, pos);
-            if(!info)
-                co_return serde_raw{"null"};
-            if(!(info->kind == SymbolKind::Function || info->kind == SymbolKind::Method))
-                co_return serde_raw{"null"};
-
-            std::vector<protocol::CallHierarchyItem> items;
-            items.push_back(Indexer::build_call_hierarchy_item(*info));
-            co_return to_raw(items);
-        });
-
-    peer.on_request([this, resolve_item](
-                        RequestContext& ctx,
-                        const protocol::CallHierarchyIncomingCallsParams& params) -> RawResult {
-        auto info = resolve_item(params.item.uri, params.item.range, params.item.data);
-        if(!info)
-            co_return serde_raw{"null"};
-        auto results = this->server.indexer.find_incoming_calls(info->hash);
-        if(results.empty())
-            co_return serde_raw{"null"};
-        co_return to_raw(results);
-    });
-
-    peer.on_request([this, resolve_item](
-                        RequestContext& ctx,
-                        const protocol::CallHierarchyOutgoingCallsParams& params) -> RawResult {
-        auto info = resolve_item(params.item.uri, params.item.range, params.item.data);
-        if(!info)
-            co_return serde_raw{"null"};
-        auto results = this->server.indexer.find_outgoing_calls(info->hash);
-        if(results.empty())
-            co_return serde_raw{"null"};
-        co_return to_raw(results);
-    });
-
-    peer.on_request(
-        [this, lookup_at](RequestContext& ctx,
-                          const protocol::TypeHierarchyPrepareParams& params) -> RawResult {
-            auto& uri = params.text_document_position_params.text_document.uri;
-            auto& pos = params.text_document_position_params.position;
-
-            auto info = lookup_at(uri, pos);
-            if(!info)
-                co_return serde_raw{"null"};
-            if(!(info->kind == SymbolKind::Class || info->kind == SymbolKind::Struct ||
-                 info->kind == SymbolKind::Enum || info->kind == SymbolKind::Union))
-                co_return serde_raw{"null"};
-
-            std::vector<protocol::TypeHierarchyItem> items;
-            items.push_back(Indexer::build_type_hierarchy_item(*info));
-            co_return to_raw(items);
-        });
-
-    peer.on_request(
-        [this, resolve_item](RequestContext& ctx,
-                             const protocol::TypeHierarchySupertypesParams& params) -> RawResult {
-            auto info = resolve_item(params.item.uri, params.item.range, params.item.data);
-            if(!info)
-                co_return serde_raw{"null"};
-            auto results = this->server.indexer.find_supertypes(info->hash);
-            if(results.empty())
-                co_return serde_raw{"null"};
-            co_return to_raw(results);
-        });
-
-    peer.on_request(
-        [this, resolve_item](RequestContext& ctx,
-                             const protocol::TypeHierarchySubtypesParams& params) -> RawResult {
-            auto info = resolve_item(params.item.uri, params.item.range, params.item.data);
-            if(!info)
-                co_return serde_raw{"null"};
-            auto results = this->server.indexer.find_subtypes(info->hash);
-            if(results.empty())
-                co_return serde_raw{"null"};
-            co_return to_raw(results);
-        });
-
-    peer.on_request(
-        [this](RequestContext& ctx, const protocol::WorkspaceSymbolParams& params) -> RawResult {
-            auto results = this->server.indexer.search_symbols(params.query);
-            if(results.empty())
-                co_return serde_raw{"null"};
-            co_return to_raw(results);
-        });
-
-    peer.on_request(
-        "clice/queryContext",
-        [this](RequestContext& ctx, const ext::QueryContextParams& params) -> RawResult {
-            auto& srv = this->server;
-            auto path = uri_to_path(params.uri);
-            auto path_id = srv.workspace.path_pool.intern(path);
-            int offset_val = std::max(0, params.offset.value_or(0));
-            constexpr int page_size = 10;
-
-            ext::QueryContextResult result;
-            std::vector<ext::ContextItem> all_items;
-
-            auto& ws = srv.workspace;
-            auto hosts = ws.dep_graph.find_host_sources(path_id);
-            for(auto host_id: hosts) {
-                auto host_path = ws.path_pool.resolve(host_id);
-                auto host_cdb = ws.cdb.lookup(host_path, {.suppress_logging = true});
-                if(host_cdb.empty())
-                    continue;
-                auto host_uri_opt = lsp::URI::from_file_path(std::string(host_path));
-                if(!host_uri_opt)
-                    continue;
-                ext::ContextItem item;
-                item.label = llvm::sys::path::filename(host_path).str();
-                item.description = std::string(host_path);
-                item.uri = host_uri_opt->str();
-                all_items.push_back(std::move(item));
-            }
-
-            if(hosts.empty()) {
-                auto entries = ws.cdb.lookup(path, {.suppress_logging = true});
-                for(std::size_t i = 0; i < entries.size(); ++i) {
-                    auto& cmd = entries[i];
-                    auto argv = cmd.to_argv();
-                    std::string desc;
-                    for(std::size_t j = 0; j < argv.size(); ++j) {
-                        llvm::StringRef a(argv[j]);
-                        if(a.starts_with("-D") || a.starts_with("-O") || a.starts_with("-std=") ||
-                           a.starts_with("-g")) {
-                            if(!desc.empty())
-                                desc += ' ';
-                            desc += argv[j];
-                            if((a == "-D" || a == "-O") && j + 1 < argv.size()) {
-                                desc += argv[++j];
-                            }
-                        }
-                    }
-                    if(desc.empty())
-                        desc = std::format("config #{}", i);
-
-                    auto uri_opt = lsp::URI::from_file_path(std::string(path));
-                    if(!uri_opt)
-                        continue;
-                    ext::ContextItem item;
-                    item.label = desc;
-                    item.description = cmd.resolved.directory.str();
-                    item.uri = uri_opt->str();
-                    all_items.push_back(std::move(item));
-                }
-            }
-
-            result.total = static_cast<int>(all_items.size());
-            int end = std::min(offset_val + page_size, static_cast<int>(all_items.size()));
-            for(int i = offset_val; i < end; ++i) {
-                result.contexts.push_back(std::move(all_items[i]));
-            }
-            co_return to_raw(result);
-        });
-
-    peer.on_request(
-        "clice/currentContext",
-        [this](RequestContext& ctx, const ext::CurrentContextParams& params) -> RawResult {
-            auto& srv = this->server;
-            auto path = uri_to_path(params.uri);
-            auto path_id = srv.workspace.path_pool.intern(path);
-
-            ext::CurrentContextResult result;
-            auto* session = srv.find_session(path_id);
-            if(session && session->active_context) {
-                auto ctx_path = srv.workspace.path_pool.resolve(*session->active_context);
-                auto ctx_uri_opt = lsp::URI::from_file_path(std::string(ctx_path));
-                if(ctx_uri_opt) {
-                    ext::ContextItem item;
-                    item.label = llvm::sys::path::filename(ctx_path).str();
-                    item.description = std::string(ctx_path);
-                    item.uri = ctx_uri_opt->str();
-                    result.context = std::move(item);
-                }
-            }
-            co_return to_raw(result);
-        });
-
-    peer.on_request(
-        "clice/switchContext",
-        [this](RequestContext& ctx, const ext::SwitchContextParams& params) -> RawResult {
-            auto& srv = this->server;
-            auto path = uri_to_path(params.uri);
-            auto path_id = srv.workspace.path_pool.intern(path);
-            auto context_path = uri_to_path(params.context_uri);
-            auto context_path_id = srv.workspace.path_pool.intern(context_path);
-
-            ext::SwitchContextResult result;
-
-            auto& ws = srv.workspace;
-            auto context_cdb = ws.cdb.lookup(context_path, {.suppress_logging = true});
-            if(context_cdb.empty()) {
-                result.success = false;
-                co_return to_raw(result);
-            }
-
-            auto* session = srv.find_session(path_id);
-            if(!session) {
-                result.success = false;
-                co_return to_raw(result);
-            }
-
-            session->active_context = context_path_id;
-            session->header_context.reset();
-            session->pch_ref.reset();
-            session->ast_deps.reset();
-            session->ast_dirty = true;
-
-            result.success = true;
-            co_return to_raw(result);
-        });
-}
-
-LSPClient::~LSPClient() {
-    server.compiler.set_peer(nullptr);
-    server.indexer.set_peer(nullptr);
-}
-
-}  // namespace clice

src/server/service/lsp_client.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "kota/async/async.h"
-#include "kota/codec/json/json.h"
-#include "kota/ipc/codec/json.h"
-
-namespace clice {
-
-class MasterServer;
-
-class LSPClient {
-public:
-    LSPClient(MasterServer& server, kota::ipc::JsonPeer& peer);
-    ~LSPClient();
-
-private:
-    using RawResult = kota::task<kota::codec::RawValue, kota::ipc::Error>;
-
-    MasterServer& server;
-    kota::ipc::JsonPeer& peer;
-};
-
-}  // namespace clice

src/server/service/master_server.cpp

@@ -1,551 +0,0 @@
-#include "server/service/master_server.h"
-
-#include <cerrno>
-#include <cstring>
-#include <list>
-#include <memory>
-#include <string>
-#include <vector>
-
-#ifndef _WIN32
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <unistd.h>
-#endif
-
-#include "server/protocol/worker.h"
-#include "server/service/agent_client.h"
-#include "server/service/lsp_client.h"
-#include "support/filesystem.h"
-#include "support/logging.h"
-
-#include "kota/async/async.h"
-#include "kota/async/io/fs_event.h"
-#include "kota/codec/json/json.h"
-#include "kota/ipc/codec/json.h"
-#include "kota/ipc/lsp/protocol.h"
-#include "kota/ipc/lsp/uri.h"
-#include "kota/ipc/recording_transport.h"
-#include "kota/ipc/transport.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/Process.h"
-
-namespace clice {
-
-namespace lsp = kota::ipc::lsp;
-namespace protocol = kota::ipc::protocol;
-
-MasterServer::MasterServer(kota::event_loop& loop, std::string self_path) :
-    loop(loop), pool(loop), compiler(loop, workspace, pool, sessions),
-    indexer(loop,
-            workspace,
-            sessions,
-            pool,
-            compiler,
-            [this](uint32_t proj_path_id) {
-                auto path = workspace.project_index.path_pool.path(proj_path_id);
-                auto server_id = workspace.path_pool.intern(path);
-                return sessions.contains(server_id);
-            }),
-    self_path(std::move(self_path)) {}
-
-MasterServer::~MasterServer() = default;
-
-void MasterServer::initialize() {
-    workspace.config = Config::load_from_workspace(workspace_root);
-    if(!init_options_json.empty()) {
-        if(auto ov = kota::codec::json::parse(init_options_json, workspace.config); !ov) {
-            LOG_WARN("Failed to apply initializationOptions: {}", ov.error().to_string());
-        } else {
-            workspace.config.apply_defaults(workspace_root);
-            LOG_INFO("Applied initializationOptions overlay");
-        }
-        init_options_json.clear();
-    }
-
-    auto& cfg = workspace.config.project;
-
-    if(!cfg.logging_dir.empty()) {
-        auto now = std::chrono::system_clock::now();
-        auto pid = llvm::sys::Process::getProcessId();
-        session_log_dir =
-            path::join(cfg.logging_dir, std::format("{:%Y-%m-%d_%H-%M-%S}_{}", now, pid));
-        logging::file_logger("master", session_log_dir, logging::options);
-    }
-
-    LOG_INFO("Server ready (stateful={}, stateless={}, idle={}ms)",
-             cfg.stateful_worker_count.value,
-             cfg.stateless_worker_count.value,
-             *cfg.idle_timeout_ms);
-
-    WorkerPoolOptions pool_opts;
-    pool_opts.self_path = self_path;
-    pool_opts.stateful_count = cfg.stateful_worker_count;
-    pool_opts.stateless_count = cfg.stateless_worker_count;
-    pool_opts.worker_memory_limit = cfg.worker_memory_limit;
-    pool_opts.log_dir = session_log_dir;
-    if(!pool.start(pool_opts)) {
-        LOG_ERROR("Failed to start worker pool");
-        return;
-    }
-
-    lifecycle = ServerLifecycle::Ready;
-
-    compiler.on_indexing_needed = [this]() {
-        indexer.schedule();
-    };
-
-    indexer.set_max_concurrency(cfg.stateless_worker_count.value);
-
-    load_workspace();
-}
-
-void MasterServer::initialize(llvm::StringRef root) {
-    workspace_root = root.str();
-    initialize();
-}
-
-void MasterServer::start_file_watcher() {
-    if(workspace_root.empty())
-        return;
-
-    loop.schedule([this]() -> kota::task<> {
-        auto watcher = kota::fs_event::create(workspace_root, {}, loop);
-        if(!watcher) {
-            LOG_WARN("Failed to start file watcher for {}", workspace_root);
-            co_return;
-        }
-
-        LOG_INFO("File watcher started for {}", workspace_root);
-
-        while(true) {
-            auto changes = co_await watcher->next();
-            if(!changes)
-                break;
-
-            for(auto& change: *changes) {
-                if(change.type != kota::fs_event::effect::modify &&
-                   change.type != kota::fs_event::effect::create)
-                    continue;
-
-                llvm::StringRef file(change.path);
-                if(file.ends_with("compile_commands.json")) {
-                    LOG_INFO("CDB changed, reloading workspace");
-                    load_workspace();
-                    continue;
-                }
-
-                if(file.ends_with(".cpp") || file.ends_with(".cc") || file.ends_with(".cxx") ||
-                   file.ends_with(".c") || file.ends_with(".h") || file.ends_with(".hpp") ||
-                   file.ends_with(".hxx") || file.ends_with(".cppm") || file.ends_with(".ixx")) {
-                    auto path_id = workspace.path_pool.intern(file);
-                    on_file_saved(path_id);
-                }
-            }
-        }
-    }());
-}
-
-Session* MasterServer::find_session(std::uint32_t path_id) {
-    auto it = sessions.find(path_id);
-    return it != sessions.end() ? &it->second : nullptr;
-}
-
-Session& MasterServer::open_session(std::uint32_t path_id) {
-    auto [it, inserted] = sessions.try_emplace(path_id);
-    auto& session = it->second;
-    if(!inserted)
-        session = Session{};
-    session.path_id = path_id;
-    return session;
-}
-
-void MasterServer::close_session(std::uint32_t path_id, kota::ipc::JsonPeer& peer) {
-    namespace protocol = kota::ipc::protocol;
-
-    auto path = workspace.path_pool.resolve(path_id);
-    workspace.on_file_closed(path_id);
-    pool.notify_stateful(path_id, worker::EvictParams{std::string(path)});
-
-    protocol::PublishDiagnosticsParams diag_params;
-    auto uri = lsp::URI::from_file_path(std::string(path));
-    if(uri)
-        diag_params.uri = uri->str();
-    diag_params.diagnostics = {};
-    peer.send_notification(diag_params);
-
-    sessions.erase(path_id);
-
-    indexer.enqueue(path_id);
-    indexer.schedule();
-
-    LOG_DEBUG("didClose: {}", path);
-}
-
-void MasterServer::on_file_saved(std::uint32_t path_id) {
-    auto dirtied = workspace.on_file_saved(path_id);
-    for(auto dirty_id: dirtied) {
-        if(auto* session = find_session(dirty_id)) {
-            session->ast_dirty = true;
-        } else {
-            indexer.enqueue(dirty_id);
-        }
-    }
-
-    for(auto& [hdr_id, session]: sessions) {
-        if(session.header_context && session.header_context->host_path_id == path_id) {
-            session.header_context.reset();
-            session.ast_dirty = true;
-        }
-    }
-
-    indexer.schedule();
-}
-
-void MasterServer::schedule_shutdown() {
-    if(lifecycle == ServerLifecycle::Exited)
-        return;
-    lifecycle = ServerLifecycle::Exited;
-
-    indexer.save(workspace.config.project.index_dir);
-    workspace.save_cache();
-    shutdown_event.set();
-
-    loop.schedule([this]() -> kota::task<> {
-        co_await kota::when_all(indexer.stop(), compiler.stop(), pool.stop());
-        loop.stop();
-    }());
-}
-
-void MasterServer::load_workspace() {
-    if(workspace_root.empty())
-        return;
-
-    auto& cfg = workspace.config.project;
-
-    if(!cfg.cache_dir.empty()) {
-        auto ec = llvm::sys::fs::create_directories(cfg.cache_dir);
-        if(ec) {
-            LOG_WARN("Failed to create cache directory {}: {}",
-                     std::string_view(cfg.cache_dir),
-                     ec.message());
-        } else {
-            LOG_INFO("Cache directory: {}", std::string_view(cfg.cache_dir));
-        }
-
-        for(auto* subdir: {"cache/pch", "cache/pcm"}) {
-            auto dir = path::join(cfg.cache_dir, subdir);
-            if(auto ec2 = llvm::sys::fs::create_directories(dir))
-                LOG_WARN("Failed to create {}: {}", dir, ec2.message());
-        }
-
-        workspace.cleanup_cache();
-        workspace.load_cache();
-    }
-
-    std::string cdb_path;
-    for(auto& configured: cfg.compile_commands_paths) {
-        if(llvm::sys::fs::is_directory(configured)) {
-            auto candidate = path::join(configured, "compile_commands.json");
-            if(llvm::sys::fs::exists(candidate)) {
-                cdb_path = std::move(candidate);
-                break;
-            }
-        } else if(llvm::sys::fs::exists(configured)) {
-            cdb_path = configured;
-            break;
-        } else {
-            LOG_WARN("Configured compile_commands_path not found: {}", configured);
-        }
-    }
-
-    if(cdb_path.empty()) {
-        auto try_candidate = [&](llvm::StringRef dir) -> bool {
-            auto candidate = path::join(dir, "compile_commands.json");
-            if(llvm::sys::fs::exists(candidate)) {
-                cdb_path = std::move(candidate);
-                return true;
-            }
-            return false;
-        };
-
-        if(!try_candidate(workspace_root)) {
-            std::error_code ec;
-            for(llvm::sys::fs::directory_iterator it(workspace_root, ec), end; it != end && !ec;
-                it.increment(ec)) {
-                if(it->type() == llvm::sys::fs::file_type::directory_file) {
-                    if(try_candidate(it->path()))
-                        break;
-                }
-            }
-        }
-    }
-
-    if(cdb_path.empty()) {
-        LOG_WARN("No compile_commands.json found in workspace {}", workspace_root);
-        return;
-    }
-
-    auto count = workspace.cdb.load(cdb_path);
-    LOG_INFO("Loaded CDB from {} with {} entries", cdb_path, count);
-
-    auto report = scan_dependency_graph(workspace.cdb,
-                                        workspace.path_pool,
-                                        workspace.dep_graph,
-                                        /*cache=*/nullptr,
-                                        [this](llvm::StringRef path,
-                                               std::vector<std::string>& append,
-                                               std::vector<std::string>& remove) {
-                                            workspace.config.match_rules(path, append, remove);
-                                        });
-    workspace.dep_graph.build_reverse_map();
-
-    auto unresolved = report.includes_found - report.includes_resolved;
-    double accuracy =
-        report.includes_found > 0
-            ? 100.0 * static_cast<double>(report.includes_resolved) / report.includes_found
-            : 100.0;
-    LOG_INFO(
-        "Dependency scan: {}ms, {} files ({} source + {} header), " "{} edges, {}/{} resolved ({:.1f}%), {} waves",
-        report.elapsed_ms,
-        report.total_files,
-        report.source_files,
-        report.header_files,
-        report.total_edges,
-        report.includes_resolved,
-        report.includes_found,
-        accuracy,
-        report.waves);
-    if(unresolved > 0)
-        LOG_WARN("{} unresolved includes", unresolved);
-
-    workspace.build_module_map();
-    indexer.load(cfg.index_dir);
-
-    if(*cfg.enable_indexing) {
-        for(auto& entry: workspace.cdb.get_entries()) {
-            auto file = workspace.cdb.resolve_path(entry.file);
-            auto server_id = workspace.path_pool.intern(file);
-            indexer.enqueue(server_id);
-        }
-        indexer.schedule();
-    }
-
-    compiler.init_compile_graph();
-}
-
-struct Connection {
-    std::unique_ptr<kota::ipc::JsonPeer> peer;
-    std::unique_ptr<LSPClient> lsp_client;
-    std::unique_ptr<AgentClient> agent_client;
-};
-
-static kota::task<> run_connection(kota::ipc::JsonPeer* peer,
-                                   std::list<Connection>& connections,
-                                   std::list<Connection>::iterator pos) {
-    co_await peer->run();
-    LOG_INFO("Client disconnected");
-    connections.erase(pos);
-}
-
-static kota::task<> accept_connections(MasterServer& server,
-                                       kota::tcp::acceptor acceptor,
-                                       bool register_lsp,
-                                       std::list<Connection>& connections) {
-    auto& loop = kota::event_loop::current();
-    kota::task_group<> connection_group(loop);
-    bool lsp_registered = false;
-
-    while(true) {
-        auto conn = co_await acceptor.accept();
-        if(!conn.has_value())
-            break;
-
-        LOG_INFO("Client connected");
-
-        auto transport = std::make_unique<kota::ipc::StreamTransport>(std::move(*conn));
-        auto peer = std::make_unique<kota::ipc::JsonPeer>(loop, std::move(transport));
-
-        std::unique_ptr<LSPClient> lsp;
-        if(register_lsp && !lsp_registered) {
-            lsp = std::make_unique<LSPClient>(server, *peer);
-            lsp_registered = true;
-        }
-        auto agent = std::make_unique<AgentClient>(server, *peer);
-
-        auto* peer_ptr = peer.get();
-        auto it = connections.emplace(connections.end(),
-                                      Connection{
-                                          .peer = std::move(peer),
-                                          .lsp_client = std::move(lsp),
-                                          .agent_client = std::move(agent),
-                                      });
-
-        connection_group.spawn(run_connection(peer_ptr, connections, it));
-    }
-
-    co_await connection_group.join();
-}
-
-int run_server_mode(const ServerOptions& opts) {
-    logging::stderr_logger("master", logging::options);
-
-    kota::event_loop loop;
-    MasterServer server(loop, opts.self_path);
-    std::list<Connection> connections;
-
-    if(opts.mode == "pipe") {
-        auto transport = kota::ipc::StreamTransport::open_stdio(loop);
-        if(!transport) {
-            LOG_ERROR("failed to open stdio transport");
-            return 1;
-        }
-
-        std::unique_ptr<kota::ipc::Transport> final_transport = std::move(*transport);
-        if(!opts.record.empty()) {
-            final_transport =
-                std::make_unique<kota::ipc::RecordingTransport>(std::move(final_transport),
-                                                                opts.record);
-        }
-
-        kota::ipc::JsonPeer lsp_peer(loop, std::move(final_transport));
-        LSPClient lsp_client(server, lsp_peer);
-
-        if(opts.port > 0) {
-            auto acceptor = kota::tcp::listen(opts.host, opts.port, {}, loop);
-            if(acceptor) {
-                LOG_INFO("Agentic protocol listening on {}:{}", opts.host, opts.port);
-                loop.schedule(accept_connections(server, std::move(*acceptor), false, connections));
-            } else {
-                LOG_WARN("Failed to start agentic listener on {}:{}", opts.host, opts.port);
-            }
-        }
-
-        loop.schedule(lsp_peer.run());
-        loop.run();
-        return 0;
-    }
-
-    if(opts.mode == "socket") {
-        auto acceptor = kota::tcp::listen(opts.host, opts.port, {}, loop);
-        if(!acceptor) {
-            LOG_ERROR("failed to listen on {}:{}", opts.host, opts.port);
-            return 1;
-        }
-
-        LOG_INFO("Listening on {}:{} ...", opts.host, opts.port);
-        loop.schedule(accept_connections(server, std::move(*acceptor), true, connections));
-        loop.run();
-        return 0;
-    }
-
-    LOG_ERROR("unknown server mode '{}'", opts.mode);
-    return 1;
-}
-
-struct DaemonConnection {
-    std::unique_ptr<kota::ipc::JsonPeer> peer;
-    std::unique_ptr<AgentClient> agent_client;
-};
-
-static kota::task<> run_daemon_connection(kota::ipc::JsonPeer* peer,
-                                          std::list<DaemonConnection>& connections,
-                                          std::list<DaemonConnection>::iterator pos) {
-    co_await peer->run();
-    LOG_INFO("Daemon client disconnected");
-    connections.erase(pos);
-}
-
-static kota::task<> daemon_main(MasterServer& server, kota::pipe::acceptor acceptor) {
-    auto& loop = kota::event_loop::current();
-    std::list<DaemonConnection> connections;
-    kota::task_group<> connection_group(loop);
-
-    co_await kota::when_all(
-        [&]() -> kota::task<> {
-            while(true) {
-                auto conn = co_await acceptor.accept();
-                if(!conn.has_value())
-                    break;
-
-                LOG_INFO("Daemon client connected");
-
-                auto transport = std::make_unique<kota::ipc::StreamTransport>(std::move(*conn));
-                auto peer = std::make_unique<kota::ipc::JsonPeer>(loop, std::move(transport));
-                auto agent = std::make_unique<AgentClient>(server, *peer);
-
-                auto* peer_ptr = peer.get();
-                auto it = connections.emplace(connections.end(),
-                                              DaemonConnection{
-                                                  .peer = std::move(peer),
-                                                  .agent_client = std::move(agent),
-                                              });
-
-                connection_group.spawn(run_daemon_connection(peer_ptr, connections, it));
-            }
-        }(),
-        [&]() -> kota::task<> {
-            co_await server.get_shutdown_event().wait();
-            acceptor.stop();
-            for(auto& conn: connections) {
-                conn.peer->close();
-            }
-        }());
-
-    co_await connection_group.join();
-}
-
-int run_daemon_mode(const DaemonOptions& opts) {
-    logging::stderr_logger("daemon", logging::options);
-
-    auto socket_path = opts.socket_path.empty() ? path::default_socket_path() : opts.socket_path;
-
-    auto socket_dir = llvm::sys::path::parent_path(socket_path);
-    if(auto ec = llvm::sys::fs::create_directories(socket_dir)) {
-        LOG_ERROR("Failed to create socket directory {}: {}", socket_dir, ec.message());
-        return 1;
-    }
-
-    if(llvm::sys::fs::exists(socket_path)) {
-#ifndef _WIN32
-        int fd = ::socket(AF_UNIX, SOCK_STREAM, 0);
-        if(fd >= 0) {
-            struct sockaddr_un addr{};
-            addr.sun_family = AF_UNIX;
-            auto len = std::min(socket_path.size(), sizeof(addr.sun_path) - 1);
-            std::memcpy(addr.sun_path, socket_path.data(), len);
-            bool live = ::connect(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) == 0;
-            ::close(fd);
-            if(live) {
-                LOG_ERROR("Another daemon is already running on {}", socket_path);
-                return 1;
-            }
-        }
-#endif
-        llvm::sys::fs::remove(socket_path);
-    }
-
-    kota::event_loop loop;
-    MasterServer server(loop, opts.self_path);
-
-    if(!opts.workspace.empty()) {
-        server.initialize(opts.workspace);
-        server.start_file_watcher();
-    }
-
-    auto acceptor = kota::pipe::listen(socket_path, {}, loop);
-    if(!acceptor) {
-        LOG_ERROR("Failed to listen on {}", socket_path);
-        return 1;
-    }
-
-    LOG_INFO("Daemon listening on {}", socket_path);
-    loop.schedule(daemon_main(server, std::move(*acceptor)));
-    loop.run();
-
-    llvm::sys::fs::remove(socket_path);
-    return 0;
-}
-
-}  // namespace clice

src/server/service/master_server.h

@@ -1,93 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-
-#include "server/compiler/compiler.h"
-#include "server/compiler/indexer.h"
-#include "server/service/session.h"
-#include "server/worker/worker_pool.h"
-#include "server/workspace/workspace.h"
-
-#include "kota/async/async.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringRef.h"
-
-namespace clice {
-
-enum class ServerLifecycle : std::uint8_t {
-    Uninitialized,
-    Initialized,
-    Ready,
-    ShuttingDown,
-    Exited,
-};
-
-/// Core server state — owns the two-layer state model (Workspace + Sessions),
-/// the worker pool, compilation engine, and indexer.
-///
-/// Does NOT own any transport or peer.  Protocol-specific handler registration
-/// is done by LSPClient and AgentClient, which access private members directly.
-class MasterServer {
-    friend class LSPClient;
-    friend class AgentClient;
-
-public:
-    MasterServer(kota::event_loop& loop, std::string self_path);
-    ~MasterServer();
-
-    void initialize();
-    void initialize(llvm::StringRef root);
-
-    void start_file_watcher();
-
-    Session* find_session(std::uint32_t path_id);
-    Session& open_session(std::uint32_t path_id);
-    void close_session(std::uint32_t path_id, kota::ipc::JsonPeer& peer);
-
-    void on_file_saved(std::uint32_t path_id);
-
-    void schedule_shutdown();
-
-    kota::event& get_shutdown_event() {
-        return shutdown_event;
-    }
-
-private:
-    kota::event shutdown_event;
-    void load_workspace();
-
-    kota::event_loop& loop;
-
-    Workspace workspace;
-    llvm::DenseMap<std::uint32_t, Session> sessions;
-    WorkerPool pool;
-    Compiler compiler;
-    Indexer indexer;
-
-    ServerLifecycle lifecycle = ServerLifecycle::Uninitialized;
-    std::string self_path;
-    std::string workspace_root;
-    std::string session_log_dir;
-    std::string init_options_json;
-};
-
-struct ServerOptions {
-    std::string mode;
-    std::string host = "127.0.0.1";
-    int port = 0;
-    std::string self_path;
-    std::string record;
-};
-
-int run_server_mode(const ServerOptions& opts);
-
-struct DaemonOptions {
-    std::string socket_path;
-    std::string workspace;
-    std::string self_path;
-};
-
-int run_daemon_mode(const DaemonOptions& opts);
-
-}  // namespace clice

src/server/session.h

@@ -5,7 +5,7 @@
 #include <optional>
 #include <string>
 
-#include "server/workspace/workspace.h"
+#include "server/workspace.h"
 
 #include "kota/async/async.h"
 #include "llvm/ADT/SmallVector.h"

src/server/stateful_worker.cpp

@@ -1,4 +1,4 @@
-#include "server/worker/stateful_worker.h"
+#include "server/stateful_worker.h"
 
 #include <atomic>
 #include <cstdint>
@@ -10,8 +10,8 @@
 #include "compile/compilation.h"
 #include "feature/feature.h"
 #include "index/tu_index.h"
-#include "server/protocol/worker.h"
-#include "server/worker/worker_common.h"
+#include "server/protocol.h"
+#include "server/worker_common.h"
 #include "support/logging.h"
 
 #include "kota/async/async.h"
@@ -94,6 +94,7 @@ class StatefulWorker {
     kota::task<kota::codec::RawValue> with_ast(llvm::StringRef path, F&& fn) {
         auto it = documents.find(path);
         if(it == documents.end()) {
+            LOG_WARN("with_ast: document not found: {}", path.str());
             co_return kota::codec::RawValue{"null"};
         }
 
@@ -105,8 +106,10 @@ class StatefulWorker {
         co_await doc->strand.lock();
 
         auto result = co_await kota::queue([&]() -> kota::codec::RawValue {
-            if(!doc->has_ast || (!doc->unit.completed() && !doc->unit.fatal_error()))
+            if(!doc->has_ast || (!doc->unit.completed() && !doc->unit.fatal_error())) {
+                LOG_WARN("with_ast: AST not available for {}", path.str());
                 return kota::codec::RawValue{"null"};
+            }
             return fn(*doc);
         });
 

src/server/stateless_worker.cpp

@@ -1,10 +1,10 @@
-#include "server/worker/stateless_worker.h"
+#include "server/stateless_worker.h"
 
 #include "compile/compilation.h"
 #include "feature/feature.h"
 #include "index/tu_index.h"
-#include "server/protocol/worker.h"
-#include "server/worker/worker_common.h"
+#include "server/protocol.h"
+#include "server/worker_common.h"
 #include "support/logging.h"
 
 #include "kota/async/async.h"
@@ -244,6 +244,8 @@ static worker::BuildResult handle_completion(const worker::BuildParams& params)
     cp.completion = {params.file, params.offset};
 
     auto items = feature::code_complete(cp);
+    if(items.empty())
+        LOG_DEBUG("Completion: no items returned for {}:{}", params.file, params.offset);
     LOG_DEBUG("Completion done: {} items, {}ms", items.size(), timer.ms());
 
     worker::BuildResult result;
@@ -267,29 +269,13 @@ static worker::BuildResult handle_signature_help(const worker::BuildParams& para
     cp.completion = {params.file, params.offset};
 
     auto help = feature::signature_help(cp);
-    LOG_DEBUG("SignatureHelp done: {}ms", timer.ms());
+    LOG_DEBUG("SignatureHelp done: {} signatures, {}ms", help.signatures.size(), timer.ms());
 
     worker::BuildResult result;
     result.result_json = to_raw(help);
     return result;
 }
 
-static worker::BuildResult handle_format(const worker::BuildParams& params) {
-    ScopedTimer timer;
-
-    std::optional<LocalSourceRange> range;
-    if(params.format_range.valid()) {
-        range = params.format_range;
-    }
-
-    auto edits = feature::document_format(params.file, params.text, range);
-    LOG_DEBUG("Format done: {} edits, {}ms", edits.size(), timer.ms());
-
-    worker::BuildResult result;
-    result.result_json = to_raw(edits);
-    return result;
-}
-
 int run_stateless_worker_mode(const std::string& worker_name, const std::string& log_dir) {
     logging::stderr_logger(worker_name, logging::options);
     if(!log_dir.empty()) {
@@ -321,7 +307,6 @@ int run_stateless_worker_mode(const std::string& worker_name, const std::string&
                 }
                 case K::Completion: return handle_completion(params);
                 case K::SignatureHelp: return handle_signature_help(params);
-                case K::Format: return handle_format(params);
             }
             return {false, "Unknown build kind"};
         });

src/server/worker_pool.cpp

@@ -1,4 +1,4 @@
-#include "server/worker/worker_pool.h"
+#include "server/worker_pool.h"
 
 #include <csignal>
 #include <string>
@@ -96,8 +96,9 @@ bool WorkerPool::spawn_worker(const std::string& self_path,
                                                                   std::move(spawn.stdin_pipe));
     auto peer = std::make_unique<kota::ipc::BincodePeer>(loop, std::move(transport));
 
+    // Schedule stderr log collection
     std::string prefix = "[" + worker_name + "]";
-    io_group.spawn(drain_stderr(std::move(spawn.stderr_pipe), prefix));
+    loop.schedule(drain_stderr(std::move(spawn.stderr_pipe), prefix));
 
     workers.push_back(WorkerProcess{
         .proc = std::move(spawn.proc),
@@ -107,7 +108,8 @@ bool WorkerPool::spawn_worker(const std::string& self_path,
 
     auto& w = workers.back();
     w.alive = true;
-    io_group.spawn(w.peer->run());
+    ++alive_count_;
+    loop.schedule(w.peer->run());
 
     return true;
 }
@@ -120,14 +122,14 @@ bool WorkerPool::start(const WorkerPoolOptions& options) {
         if(!spawn_worker(options.self_path, false, 0)) {
             return false;
         }
-        monitor_group.spawn(monitor_worker(stateless_workers.size() - 1, false));
+        loop.schedule(monitor_worker(stateless_workers.size() - 1, false));
     }
 
     for(std::uint32_t i = 0; i < options.stateful_count; ++i) {
         if(!spawn_worker(options.self_path, true, options.worker_memory_limit)) {
             return false;
         }
-        monitor_group.spawn(monitor_worker(stateful_workers.size() - 1, true));
+        loop.schedule(monitor_worker(stateful_workers.size() - 1, true));
     }
 
     // Register evicted notification handler for each stateful worker
@@ -149,17 +151,23 @@ kota::task<> WorkerPool::stop() {
     LOG_INFO("WorkerPool stopping...");
     shutting_down_ = true;
 
+    // Close output pipes to signal workers to exit gracefully.
     for(auto& w: stateless_workers)
         w.peer->close_output();
     for(auto& w: stateful_workers)
         w.peer->close_output();
 
+    // Send SIGTERM.  monitor_worker coroutines handle the wait.
     for(auto& w: stateless_workers)
         w.proc.kill(SIGTERM);
     for(auto& w: stateful_workers)
         w.proc.kill(SIGTERM);
 
-    co_await kota::when_all(monitor_group.join(), io_group.join());
+    // Wait until all monitor_worker coroutines have finished.
+    if(alive_count_ > 0) {
+        all_exited_.reset();
+        co_await all_exited_.wait();
+    }
 
     LOG_INFO("WorkerPool stopped");
 }
@@ -234,9 +242,13 @@ kota::task<> WorkerPool::monitor_worker(std::size_t index, bool stateful) {
 
     auto result = co_await w.proc.wait();
     w.alive = false;
+    --alive_count_;
 
-    if(shutting_down_)
+    if(shutting_down_) {
+        if(alive_count_ == 0)
+            all_exited_.set();
         co_return;
+    }
 
     if(result.has_value()) {
         auto& exit = result.value();
@@ -319,7 +331,7 @@ bool WorkerPool::respawn_worker(std::size_t index, bool stateful) {
     auto peer = std::make_unique<kota::ipc::BincodePeer>(loop, std::move(transport));
 
     std::string prefix = "[" + worker_name + "]";
-    io_group.spawn(drain_stderr(std::move(spawn.stderr_pipe), prefix));
+    loop.schedule(drain_stderr(std::move(spawn.stderr_pipe), prefix));
 
     workers[index] = WorkerProcess{
         .proc = std::move(spawn.proc),
@@ -330,7 +342,8 @@ bool WorkerPool::respawn_worker(std::size_t index, bool stateful) {
     };
 
     auto& w = workers[index];
-    io_group.spawn(w.peer->run());
+    ++alive_count_;
+    loop.schedule(w.peer->run());
 
     if(stateful) {
         w.peer->on_notification([this](const worker::EvictedParams& params) {
@@ -339,7 +352,7 @@ bool WorkerPool::respawn_worker(std::size_t index, bool stateful) {
         });
     }
 
-    monitor_group.spawn(monitor_worker(index, stateful));
+    loop.schedule(monitor_worker(index, stateful));
 
     LOG_INFO("Worker {} restarted (attempt {})", worker_name, old_restart_count);
     return true;

src/server/worker_pool.h

@@ -6,7 +6,7 @@
 #include <list>
 #include <memory>
 
-#include "server/protocol/worker.h"
+#include "server/protocol.h"
 
 #include "kota/async/async.h"
 #include "kota/ipc/codec/bincode.h"
@@ -83,8 +83,8 @@ private:
     std::size_t pick_least_loaded();
 
     bool shutting_down_ = false;
-    kota::task_group<> monitor_group{loop};
-    kota::task_group<> io_group{loop};
+    std::size_t alive_count_ = 0;
+    kota::event all_exited_{true};  // Signalled when alive_count_ reaches 0.
     WorkerPoolOptions options_;
     std::string log_dir_;
 

src/server/workspace.cpp

@@ -1,4 +1,4 @@
-#include "server/workspace/workspace.h"
+#include "server/workspace.h"
 
 #include <algorithm>
 #include <chrono>

src/server/workspace.h

@@ -11,8 +11,8 @@
 #include "index/merged_index.h"
 #include "index/project_index.h"
 #include "semantic/relation_kind.h"
-#include "server/compiler/compile_graph.h"
-#include "server/workspace/config.h"
+#include "server/compile_graph.h"
+#include "server/config.h"
 #include "support/path_pool.h"
 #include "syntax/dependency_graph.h"
 

src/support/doxygen.cpp

@@ -51,15 +51,6 @@ std::vector<std::pair<llvm::StringRef, llvm::ArrayRef<DoxygenInfo::BlockCommandC
     return res;
 }
 
-std::vector<std::pair<llvm::StringRef, const DoxygenInfo::ParamCommandCommentContent*>>
-    DoxygenInfo::get_param_command_comments() const {
-    std::vector<std::pair<llvm::StringRef, const ParamCommandCommentContent*>> res;
-    for(const auto& [name, info]: param_command_comments) {
-        res.emplace_back(name, &info);
-    }
-    return res;
-}
-
 /// Process inline commands, we only interested in `\b` (bold), `\e` (italic) and `\c` (inline code)
 ///
 /// \param line   The line

src/support/doxygen.h

@@ -49,9 +49,6 @@ public:
         return doc_for_return;
     }
 
-    std::vector<std::pair<llvm::StringRef, const ParamCommandCommentContent*>>
-        get_param_command_comments() const;
-
 private:
     llvm::SmallDenseMap<llvm::StringRef, std::vector<BlockCommandCommentContent>>
         block_command_comments;

src/support/filesystem.h

@@ -37,14 +37,6 @@ inline std::string real_path(llvm::StringRef file) {
     return path.str().str();
 }
 
-inline std::string default_socket_path() {
-    llvm::SmallString<128> home;
-    if(!llvm::sys::path::home_directory(home))
-        return "/tmp/clice.sock";
-    llvm::sys::path::append(home, ".clice", "clice.sock");
-    return home.str().str();
-}
-
 }  // namespace path
 
 namespace fs {

src/support/structed_text.cpp

@@ -1,4 +1,4 @@
-#include "support/markup.h"
+#include "support/structed_text.h"
 
 #include <algorithm>
 #include <cctype>
@@ -25,23 +25,22 @@ std::unique_ptr<Block> BulletList::clone() const {
 
 void BulletList::render_markdown(llvm::raw_ostream& os) const {
     for(auto& item: items) {
-        auto content = item.as_markdown();
-        os << "- ";
-        for(size_t i = 0; i < content.size(); ++i) {
-            os << content[i];
-            if(content[i] == '\n' && i + 1 < content.size())
-                os << "  ";
-        }
-        os << '\n';
+        os << "- " << item.as_markdown() << '\n';
     }
 }
 
-Markup& BulletList::add_item() {
+StructedText& BulletList::add_item() {
     return items.emplace_back();
 }
 
+// Clangd inserts escape char '\' before '*', '-' and other markdown markers
+// That causes markdown comments are escaped and cannot be rendered properly
+// on editors
+// We do nothing on it. All the left comments are regarded as markdown rather
+// than plain text
 void Paragraph::render_markdown(llvm::raw_ostream& os) const {
     bool need_space = false;
+    bool has_chunks = false;
     for(auto& chunk: chunks) {
         if(chunk.space_ahead || need_space) {
             os << ' ';
@@ -59,15 +58,17 @@ void Paragraph::render_markdown(llvm::raw_ostream& os) const {
                 os << '`' << chunk.content << '`';
                 break;
             }
-            case Kind::Strikethrough: {
+            case Kind::Strikethough: {
                 os << "~~" << chunk.content << "~~";
                 break;
             }
             default: {
+                // Kind::PlainText
                 os << chunk.content;
                 break;
             }
         }
+        has_chunks = true;
         need_space = chunk.space_after;
     }
 }
@@ -75,6 +76,7 @@ void Paragraph::render_markdown(llvm::raw_ostream& os) const {
 Paragraph& Paragraph::append_text(std::string text, Kind kind) {
     if(kind == Kind::PlainText) {
         llvm::StringRef s{text};
+        // s = s.trim(" \t\v\f\r");
         if(s.empty()) {
             return *this;
         }
@@ -110,10 +112,6 @@ public:
         Paragraph::render_markdown(os);
     }
 
-    std::unique_ptr<Block> clone() const override {
-        return std::make_unique<Heading>(*this);
-    }
-
 private:
     unsigned level;
 };
@@ -121,7 +119,7 @@ private:
 class Ruler : public Block {
 public:
     void render_markdown(llvm::raw_ostream& os) const override {
-        os << "---\n";
+        os << "\n---\n";
     }
 
     bool is_ruler() const override {
@@ -136,10 +134,7 @@ public:
 class CodeBlock : public Block {
 public:
     void render_markdown(llvm::raw_ostream& os) const override {
-        os << "```" << lang << '\n' << code;
-        if(!code.empty() && code.back() != '\n')
-            os << '\n';
-        os << "```\n";
+        os << "```" << lang << '\n' << code << "```\n";
     }
 
     std::unique_ptr<Block> clone() const override {
@@ -165,55 +160,60 @@ static std::string render_blocks(llvm::ArrayRef<std::unique_ptr<Block>> blocks)
     blocks = blocks.drop_back(blocks.end() - last.base());
 
     bool last_block_was_ruler = true;
+    // render
     for(const auto& b: blocks) {
         if(b->is_ruler() && last_block_was_ruler) {
             continue;
         }
         last_block_was_ruler = b->is_ruler();
         b->render_markdown(os);
-        os << "\n\n";
     }
 
-    // Collapse runs of 3+ newlines down to 2 (one blank line max).
-    std::string result;
-    llvm::StringRef text(os.str());
-    text = text.trim();
+    // Get rid of redundant empty lines introduced in plaintext while imitating
+    // padding in markdown.
+    std::string adjusted_result;
+    llvm::StringRef trimmed_text(os.str());
+    trimmed_text = trimmed_text.trim(" \t\v\f\r");
 
-    llvm::copy_if(text, std::back_inserter(result), [&text](const char& C) {
-        return !llvm::StringRef(text.data(), &C - text.data() + 1).ends_with("\n\n\n");
-    });
+    llvm::copy_if(trimmed_text,
+                  std::back_inserter(adjusted_result),
+                  [&trimmed_text](const char& C) {
+                      return !llvm::StringRef(trimmed_text.data(), &C - trimmed_text.data() + 1)
+                                  // We allow at most two newlines.
+                                  .ends_with("\n\n\n");
+                  });
 
-    return result;
+    return adjusted_result;
 }
 
-void Markup::append(Markup& other) {
+void StructedText::append(StructedText& other) {
     std::move(other.blocks.begin(), other.blocks.end(), std::back_inserter(blocks));
 }
 
-Paragraph& Markup::add_paragraph() {
+Paragraph& StructedText::add_paragraph() {
     blocks.emplace_back(std::make_unique<Paragraph>());
     return *static_cast<Paragraph*>(blocks.back().get());
 }
 
-void Markup::add_ruler() {
+void StructedText::add_ruler() {
     blocks.push_back(std::make_unique<Ruler>());
 }
 
-void Markup::add_code_block(std::string code, std::string lang) {
+void StructedText::add_code_block(std::string code, std::string lang) {
     blocks.emplace_back(std::make_unique<CodeBlock>(std::move(code), std::move(lang)));
 }
 
-Paragraph& Markup::add_heading(unsigned level) {
+Paragraph& StructedText::add_heading(unsigned level) {
     blocks.emplace_back(std::make_unique<Heading>(level));
     return *static_cast<Paragraph*>(blocks.back().get());
 }
 
-BulletList& Markup::add_bullet_list() {
+BulletList& StructedText::add_bullet_list() {
     blocks.push_back(std::make_unique<BulletList>());
     return *static_cast<BulletList*>(blocks.back().get());
 }
 
-std::string Markup::as_markdown() const {
+std::string StructedText::as_markdown() const {
     return render_blocks(blocks);
 }
 

src/support/structed_text.h

@@ -5,11 +5,11 @@
 #include <string>
 #include <vector>
 
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/raw_os_ostream.h"
 
 namespace clice {
 
-/// Base class of markup blocks
+/// Base class of structed text
 class Block {
 public:
     virtual void render_markdown(llvm::raw_ostream& os) const = 0;
@@ -31,7 +31,7 @@ public:
         Italic,
         PlainText,
         InlineCode,
-        Strikethrough,
+        Strikethough,
     };
     void render_markdown(llvm::raw_ostream& os) const override;
 
@@ -54,7 +54,7 @@ private:
     std::vector<Chunk> chunks;
 };
 
-class Markup;
+class StructedText;
 
 /// Allow nested structure
 class BulletList : public Block {
@@ -65,23 +65,23 @@ public:
 
     std::unique_ptr<Block> clone() const override;
 
-    Markup& add_item();
+    StructedText& add_item();
 
 private:
-    std::vector<Markup> items;
+    std::vector<StructedText> items;
 };
 
-class Markup {
+class StructedText {
 public:
-    Markup() = default;
+    StructedText() = default;
 
-    Markup(const Markup& other) {
+    StructedText(const StructedText& other) {
         *this = other;
     }
 
-    Markup(Markup&&) = default;
+    StructedText(StructedText&&) = default;
 
-    Markup& operator=(const Markup& other) {
+    StructedText& operator=(const StructedText& other) {
         blocks.clear();
         for(auto& b: other.blocks) {
             blocks.push_back(b->clone());
@@ -89,9 +89,9 @@ public:
         return *this;
     }
 
-    Markup& operator=(Markup&&) = default;
+    StructedText& operator=(StructedText&&) = default;
 
-    void append(Markup& doc);
+    void append(StructedText& doc);
 
     Paragraph& add_paragraph();
 

tests/conftest.py

@@ -1,7 +1,6 @@
 import asyncio
 import json
 import shutil
-import socket
 import subprocess
 import sys
 from pathlib import Path
@@ -11,6 +10,14 @@ import pytest
 from tests.integration.utils.client import CliceClient
 
 
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+    """Store test outcome so fixtures can detect failures."""
+    outcome = yield
+    rep = outcome.get_result()
+    setattr(item, f"rep_{rep.when}", rep)
+
+
 def pytest_addoption(parser: pytest.Parser) -> None:
     parser.addoption(
         "--executable",
@@ -76,7 +83,8 @@ def workspace(request: pytest.FixtureRequest, test_data_dir: Path) -> Path | Non
     """
     marker = request.node.get_closest_marker("workspace")
     if marker is None:
-        return None
+        yield None
+        return
     if not marker.args or not isinstance(marker.args[0], str):
         raise pytest.UsageError(
             "@pytest.mark.workspace requires a string argument, e.g. "
@@ -89,21 +97,25 @@ def workspace(request: pytest.FixtureRequest, test_data_dir: Path) -> Path | Non
     clice_dir = path / ".clice"
     if clice_dir.exists():
         shutil.rmtree(clice_dir)
-    return path
+    yield path
+    # Post-test cleanup: remove cache generated during the test.
+    if clice_dir.exists():
+        shutil.rmtree(clice_dir)
 
 
 @pytest.fixture
 async def client(
-    request: pytest.FixtureRequest,
-    executable: Path,
-    workspace: Path | None,
+    request: pytest.FixtureRequest, executable: Path, workspace: Path | None
 ):
     """Spawn clice server, auto-initialize if @pytest.mark.workspace is present."""
     config = request.config
     mode = config.getoption("--mode")
-    host = config.getoption("--host")
 
-    cmd = [str(executable), "--mode", mode, "--host", host]
+    cmd = [str(executable), "--mode", mode]
+    if mode == "socket":
+        host = config.getoption("--host")
+        port = config.getoption("--port")
+        cmd += ["--host", host, "--port", str(port)]
 
     c = CliceClient()
     await c.start_io(*cmd)
@@ -119,40 +131,11 @@ async def client(
 
     yield c
 
-    await _shutdown_client(c)
-
-
-def _find_free_port() -> int:
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(("127.0.0.1", 0))
-        return s.getsockname()[1]
-
-
-@pytest.fixture
-async def agentic(
-    request: pytest.FixtureRequest,
-    executable: Path,
-    workspace: Path | None,
-):
-    """Start a server with agentic TCP port, yield (executable, host, port)."""
-    host = "127.0.0.1"
-    port = _find_free_port()
-    cmd = [str(executable), "--mode", "pipe", "--host", host, "--port", str(port)]
-
-    c = CliceClient()
-    await c.start_io(*cmd)
-
-    if workspace is not None:
-        init_options_marker = request.node.get_closest_marker("init_options")
-        init_options = dict(init_options_marker.args[0]) if init_options_marker else {}
-        project = dict(init_options.get("project", {}))
-        project.setdefault("cache_dir", str(workspace / ".clice"))
-        init_options["project"] = project
-        await c.initialize(workspace, initialization_options=init_options)
-
-    yield executable, host, port
-
-    await _shutdown_client(c)
+    test_failed = (
+        getattr(request.node, "rep_call", None) is not None
+        and request.node.rep_call.failed
+    )
+    await _shutdown_client(c, verbose=test_failed)
 
 
 def generate_cdb(workspace: Path) -> None:
@@ -185,8 +168,12 @@ async def make_client(executable: Path, workspace: Path) -> CliceClient:
     return c
 
 
-async def _shutdown_client(c: CliceClient) -> None:
-    """Gracefully shut down a client, force-kill if needed."""
+async def _shutdown_client(c: CliceClient, *, verbose: bool = False) -> None:
+    """Gracefully shut down a client, force-kill if needed.
+
+    When verbose=True (typically on test failure), dump collected log messages
+    and server stderr to help diagnose the failure.
+    """
     try:
         await asyncio.wait_for(c.shutdown_async(None), timeout=3.0)
     except Exception:
@@ -216,6 +203,11 @@ async def _shutdown_client(c: CliceClient) -> None:
     except Exception:
         pass
 
+    if verbose and c.log_messages:
+        for msg in c.log_messages:
+            level = {1: "ERROR", 2: "WARN", 3: "INFO", 4: "LOG"}.get(msg.type, "?")
+            print(f"[logMessage/{level}] {msg.message}", flush=True)
+
     try:
         c._stop_event.set()
         for task in c._async_tasks:
@@ -292,12 +284,6 @@ def _generate_test_data_cdbs(data_dir: Path) -> None:
         if cr_main.exists():
             _write(cr_dir, [_entry(cr_dir, cr_main)])
 
-    # formatting
-    fmt_dir = data_dir / "formatting"
-    fmt_main = fmt_dir / "main.cpp"
-    if fmt_main.exists():
-        _write(fmt_dir, [_entry(fmt_dir, fmt_main)])
-
     # pch_test
     pt_dir = data_dir / "pch_test"
     if pt_dir.exists():

tests/data/formatting/.clang-format

@@ -1,3 +0,0 @@
-BasedOnStyle: LLVM
-IndentWidth: 4
-ColumnLimit: 80

tests/data/formatting/main.cpp

@@ -1 +0,0 @@
-int add(int a, int b) { return a + b; }

tests/integration/agentic/test_agentic.py

@@ -1,592 +0,0 @@
-"""Tests for the agentic protocol handlers."""
-
-import asyncio
-import json
-import socket
-import subprocess
-from concurrent.futures import ThreadPoolExecutor
-
-import pytest
-
-from tests.integration.utils.wait import wait_for_index
-
-
-class AgenticRpcClient:
-    """Minimal JSON-RPC client that speaks Content-Length framing over TCP."""
-
-    def __init__(self, host: str, port: int):
-        self.sock = socket.create_connection((host, port), timeout=10)
-        self.request_id = 0
-        self.buffer = b""
-
-    def request(self, method: str, params: dict):
-        self.request_id += 1
-        body = json.dumps(
-            {
-                "jsonrpc": "2.0",
-                "id": self.request_id,
-                "method": method,
-                "params": params,
-            }
-        )
-        payload = f"Content-Length: {len(body)}\r\n\r\n{body}".encode("utf-8")
-        self.sock.sendall(payload)
-        return self._read_response()
-
-    def _read_response(self):
-        while b"\r\n\r\n" not in self.buffer:
-            data = self.sock.recv(4096)
-            if not data:
-                raise ConnectionError("connection closed")
-            self.buffer += data
-
-        header_end = self.buffer.index(b"\r\n\r\n")
-        headers = self.buffer[:header_end].decode("utf-8")
-        self.buffer = self.buffer[header_end + 4 :]
-
-        content_length = 0
-        for line in headers.split("\r\n"):
-            if line.lower().startswith("content-length:"):
-                content_length = int(line.split(":")[1].strip())
-
-        while len(self.buffer) < content_length:
-            data = self.sock.recv(4096)
-            if not data:
-                raise ConnectionError("connection closed")
-            self.buffer += data
-
-        body = self.buffer[:content_length].decode("utf-8")
-        self.buffer = self.buffer[content_length:]
-        return json.loads(body)
-
-    def close(self):
-        self.sock.close()
-
-
-def run_agentic(executable, host, port, path, timeout=10):
-    result = subprocess.run(
-        [
-            str(executable),
-            "--mode",
-            "agentic",
-            "--host",
-            host,
-            "--port",
-            str(port),
-            "--path",
-            path,
-        ],
-        capture_output=True,
-        text=True,
-        timeout=timeout,
-    )
-    return result
-
-
-@pytest.mark.workspace("hello_world")
-async def test_compile_command(agentic, workspace):
-    executable, host, port = agentic
-    main_cpp = (workspace / "main.cpp").as_posix()
-    result = run_agentic(executable, host, port, main_cpp)
-    assert result.returncode == 0, f"stderr: {result.stderr}"
-    data = json.loads(result.stdout)
-    assert data["file"] == main_cpp
-    assert data["directory"] == workspace.as_posix()
-    assert len(data["arguments"]) > 0
-
-
-@pytest.mark.workspace("hello_world")
-async def test_compile_command_fallback(agentic, workspace):
-    executable, host, port = agentic
-    result = run_agentic(executable, host, port, "/nonexistent/file.cpp")
-    assert result.returncode == 0, f"stderr: {result.stderr}"
-    data = json.loads(result.stdout)
-    assert data["file"] == "/nonexistent/file.cpp"
-
-
-@pytest.mark.workspace("hello_world")
-async def test_multiple_requests(agentic, workspace):
-    executable, host, port = agentic
-    main_cpp = (workspace / "main.cpp").as_posix()
-    for _ in range(3):
-        result = run_agentic(executable, host, port, main_cpp)
-        assert result.returncode == 0, f"stderr: {result.stderr}"
-        data = json.loads(result.stdout)
-        assert data["file"] == main_cpp
-
-
-async def test_connection_refused(executable):
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(("127.0.0.1", 0))
-        free_port = s.getsockname()[1]
-    result = run_agentic(executable, "127.0.0.1", free_port, "/some/file.cpp")
-    assert result.returncode != 0
-
-
-@pytest.mark.workspace("hello_world")
-async def test_concurrent_connections(agentic, workspace):
-    executable, host, port = agentic
-    main_cpp = (workspace / "main.cpp").as_posix()
-
-    def do_request(_):
-        return run_agentic(executable, host, port, main_cpp)
-
-    with ThreadPoolExecutor(max_workers=4) as pool:
-        results = list(pool.map(do_request, range(4)))
-
-    for r in results:
-        assert r.returncode == 0, f"stderr: {r.stderr}"
-        data = json.loads(r.stdout)
-        assert data["file"] == main_cpp
-
-
-@pytest.fixture
-async def indexed_agentic(request, executable, workspace):
-    """Start server with LSP+agentic, compile a file, wait for indexing."""
-    from tests.integration.utils.client import CliceClient
-    from tests.conftest import _shutdown_client, _find_free_port
-
-    host = "127.0.0.1"
-    port = _find_free_port()
-    cmd = [str(executable), "--mode", "pipe", "--host", host, "--port", str(port)]
-
-    c = CliceClient()
-    await c.start_io(*cmd)
-
-    init_options = {"project": {"cache_dir": str(workspace / ".clice")}}
-    await c.initialize(workspace, initialization_options=init_options)
-
-    uri, _ = await c.open_and_wait(workspace / "main.cpp")
-    assert await wait_for_index(c, uri, "add"), "Index not ready"
-
-    rpc = AgenticRpcClient(host, port)
-
-    for _ in range(30):
-        resp = rpc.request("agentic/symbolSearch", {"query": "add"})
-        if "result" in resp and resp["result"]["symbols"]:
-            break
-        await asyncio.sleep(1)
-    else:
-        pytest.fail("agentic/symbolSearch never returned indexed symbols")
-
-    yield rpc, workspace
-
-    rpc.close()
-    c.close(uri)
-    await _shutdown_client(c)
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_compile_command(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    path = (workspace / "main.cpp").as_posix()
-    resp = rpc.request("agentic/compileCommand", {"path": path})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["file"] == path
-    assert len(result["arguments"]) > 0
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_project_files(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/projectFiles", {})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["total"] > 0
-    paths = [f["path"] for f in result["files"]]
-    assert any("main.cpp" in p for p in paths)
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_project_files_filter(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/projectFiles", {"filter": "source"})
-    assert "result" in resp
-    for f in resp["result"]["files"]:
-        assert f["kind"] == "source"
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_symbol_search(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/symbolSearch", {"query": "add"})
-    assert "result" in resp, f"unexpected response: {resp}"
-    symbols = resp["result"]["symbols"]
-    add_sym = next((s for s in symbols if s["name"] == "add"), None)
-    assert add_sym is not None, f"'add' not found in {[s['name'] for s in symbols]}"
-    assert add_sym["kind"] == "Function"
-    assert add_sym["line"] == 19
-    assert add_sym["symbolId"] != 0
-    assert "main.cpp" in add_sym["file"]
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_symbol_search_kind(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request(
-        "agentic/symbolSearch", {"query": "Animal", "kindFilter": ["Struct"]}
-    )
-    assert "result" in resp
-    for s in resp["result"]["symbols"]:
-        assert s["kind"] == "Struct"
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_symbol_search_max(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/symbolSearch", {"query": "", "maxResults": 3})
-    assert "result" in resp
-    assert len(resp["result"]["symbols"]) <= 3
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_read_symbol(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/readSymbol", {"name": "add"})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["name"] == "add"
-    assert result["symbolId"] != 0
-    assert result["startLine"] == 19
-    assert result["endLine"] == 21
-    assert "int add(int a, int b)" in result["text"]
-    assert "return a + b;" in result["text"]
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_read_symbol_by_id(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp1 = rpc.request("agentic/readSymbol", {"name": "add"})
-    assert "result" in resp1
-    sid = resp1["result"]["symbolId"]
-
-    resp2 = rpc.request("agentic/readSymbol", {"symbolId": sid})
-    assert "result" in resp2
-    assert resp2["result"]["name"] == "add"
-    assert resp2["result"]["symbolId"] == sid
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_document_symbols(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    path = (workspace / "main.cpp").as_posix()
-    resp = rpc.request("agentic/documentSymbols", {"path": path})
-    assert "result" in resp, f"unexpected response: {resp}"
-    symbols = resp["result"]["symbols"]
-    names = [s["name"] for s in symbols]
-    kinds = [s["kind"] for s in symbols]
-    assert "add" in names, f"expected 'add' in {names}"
-    assert "main" in names, f"expected 'main' in {names}"
-    assert "global_var" in names, f"expected 'global_var' in {names}"
-    assert "Parameter" not in kinds, (
-        f"Parameters should be filtered: {list(zip(names, kinds))}"
-    )
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_definition(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/definition", {"name": "add"})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["name"] == "add"
-    assert result["definition"] is not None
-    defn = result["definition"]
-    assert "main.cpp" in defn["file"]
-    assert defn["startLine"] == 19
-    assert defn["endLine"] == 21
-    assert "int add(int a, int b)" in defn["text"]
-    assert "return a + b;" in defn["text"]
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_definition_by_position(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    path = (workspace / "main.cpp").as_posix()
-    resp = rpc.request("agentic/definition", {"path": path, "line": 19})
-    assert "result" in resp, f"unexpected response: {resp}"
-    assert resp["result"]["name"] == "add"
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_references(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/references", {"name": "global_var"})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["name"] == "global_var"
-    assert result["total"] == 2
-    lines = sorted(r["line"] for r in result["references"])
-    assert lines == [34, 38]
-    contexts = [r["context"] for r in result["references"]]
-    assert any("global_var + 1" in c for c in contexts)
-    assert any("global_var * 2" in c for c in contexts)
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_references_include_decl(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request(
-        "agentic/references", {"name": "global_var", "includeDeclaration": True}
-    )
-    assert "result" in resp
-    result = resp["result"]
-    assert result["total"] == 3
-    lines = sorted(r["line"] for r in result["references"])
-    assert 31 in lines, f"expected declaration line 31 in {lines}"
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_call_graph_incoming(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/callGraph", {"name": "add", "direction": "callers"})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["root"]["name"] == "add"
-    assert result["root"]["line"] == 19
-    assert result["root"]["symbolId"] != 0
-    callers = result["callers"]
-    caller_names = [c["name"] for c in callers]
-    assert "compute" in caller_names, f"expected 'compute' in {caller_names}"
-    compute = next(c for c in callers if c["name"] == "compute")
-    assert compute["line"] == 24
-    assert compute["symbolId"] != 0
-    assert result["callees"] == []
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_call_graph_outgoing(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/callGraph", {"name": "compute", "direction": "callees"})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["root"]["name"] == "compute"
-    callees = result["callees"]
-    callee_names = [c["name"] for c in callees]
-    assert "add" in callee_names, f"expected 'add' in {callee_names}"
-    add_entry = next(c for c in callees if c["name"] == "add")
-    assert add_entry["line"] == 19
-    assert result["callers"] == []
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_type_hierarchy_supertypes(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request(
-        "agentic/typeHierarchy", {"name": "Dog", "direction": "supertypes"}
-    )
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["root"]["name"] == "Dog"
-    assert result["root"]["line"] == 9
-    supertypes = result["supertypes"]
-    supertype_names = [t["name"] for t in supertypes]
-    assert "Animal" in supertype_names, f"expected 'Animal' in {supertype_names}"
-    animal = next(t for t in supertypes if t["name"] == "Animal")
-    assert animal["line"] == 2
-    assert animal["symbolId"] != 0
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_type_hierarchy_subtypes(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request(
-        "agentic/typeHierarchy", {"name": "Animal", "direction": "subtypes"}
-    )
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["root"]["name"] == "Animal"
-    assert result["root"]["line"] == 2
-    subtypes = result["subtypes"]
-    subtype_names = [t["name"] for t in subtypes]
-    assert "Dog" in subtype_names, f"expected 'Dog' in {subtype_names}"
-    assert "Cat" in subtype_names, f"expected 'Cat' in {subtype_names}"
-    dog = next(t for t in subtypes if t["name"] == "Dog")
-    assert dog["line"] == 9
-    cat = next(t for t in subtypes if t["name"] == "Cat")
-    assert cat["line"] == 14
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_status(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/status", {})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert isinstance(result["idle"], bool)
-    assert result["total"] > 0
-    assert isinstance(result["pending"], int)
-    assert isinstance(result["indexed"], int)
-
-
-@pytest.mark.workspace("hello_world")
-async def test_rpc_shutdown(executable, workspace):
-    """Shutdown notification should cause the server to exit."""
-    from tests.integration.utils.client import CliceClient
-    from tests.conftest import _shutdown_client, _find_free_port
-
-    host = "127.0.0.1"
-    port = _find_free_port()
-    cmd = [str(executable), "--mode", "pipe", "--host", host, "--port", str(port)]
-
-    c = CliceClient()
-    await c.start_io(*cmd)
-    init_options = {"project": {"cache_dir": str(workspace / ".clice")}}
-    await c.initialize(workspace, initialization_options=init_options)
-
-    rpc = AgenticRpcClient(host, port)
-    body = json.dumps({"jsonrpc": "2.0", "method": "agentic/shutdown", "params": {}})
-    rpc.sock.sendall(f"Content-Length: {len(body)}\r\n\r\n{body}".encode())
-    rpc.sock.settimeout(5)
-    try:
-        rpc.sock.recv(4096)
-    except (socket.timeout, OSError):
-        pass
-    rpc.sock.close()
-
-    import asyncio
-
-    for _ in range(20):
-        if c._server.returncode is not None:
-            break
-        await asyncio.sleep(0.5)
-    assert c._server.returncode is not None, "Server did not exit after shutdown"
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_symbol_not_found(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/definition", {"name": "nonexistent_symbol_xyz"})
-    assert "error" in resp
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_symbol_id_roundtrip(indexed_agentic, workspace):
-    """Search -> get symbolId -> definition -> verify consistency."""
-    rpc, _ = indexed_agentic
-    search = rpc.request("agentic/symbolSearch", {"query": "compute"})
-    assert "result" in search
-    symbols = search["result"]["symbols"]
-    compute = next((s for s in symbols if s["name"] == "compute"), None)
-    assert compute is not None, f"'compute' not found in {[s['name'] for s in symbols]}"
-
-    defn = rpc.request("agentic/definition", {"symbolId": compute["symbolId"]})
-    assert "result" in defn
-    assert defn["result"]["name"] == "compute"
-    assert defn["result"]["symbolId"] == compute["symbolId"]
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_file_deps(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    path = (workspace / "main.cpp").as_posix()
-    resp = rpc.request("agentic/fileDeps", {"path": path})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert result["file"] == path
-    assert isinstance(result["includes"], list)
-    assert isinstance(result["includers"], list)
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_file_deps_direction(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    path = (workspace / "main.cpp").as_posix()
-    resp = rpc.request("agentic/fileDeps", {"path": path, "direction": "includes"})
-    assert "result" in resp
-    assert resp["result"]["includers"] == []
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_file_deps_unknown(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/fileDeps", {"path": "/nonexistent/file.cpp"})
-    assert "result" in resp
-    assert resp["result"]["includes"] == []
-    assert resp["result"]["includers"] == []
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_impact_analysis(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    path = (workspace / "main.cpp").as_posix()
-    resp = rpc.request("agentic/impactAnalysis", {"path": path})
-    assert "result" in resp, f"unexpected response: {resp}"
-    result = resp["result"]
-    assert isinstance(result["directDependents"], list)
-    assert isinstance(result["transitiveDependents"], list)
-    assert isinstance(result["affectedModules"], list)
-
-
-@pytest.mark.workspace("index_features")
-async def test_rpc_impact_analysis_unknown(indexed_agentic, workspace):
-    rpc, _ = indexed_agentic
-    resp = rpc.request("agentic/impactAnalysis", {"path": "/nonexistent/file.cpp"})
-    assert "result" in resp
-    assert resp["result"]["directDependents"] == []
-
-
-async def test_shutdown_during_indexing(executable, tmp_path):
-    """Shutdown during active background indexing must exit cleanly."""
-    from tests.integration.utils.client import CliceClient
-    from tests.conftest import _find_free_port
-
-    workspace = tmp_path / "ws"
-    workspace.mkdir()
-
-    entries = []
-    for i in range(20):
-        src = workspace / f"file_{i}.cpp"
-        src.write_text(
-            f"struct Type_{i} {{ int v = {i}; void m() {{}} }};\n"
-            f"int func_{i}(int x) {{ return x + {i}; }}\n"
-            f"int caller_{i}() {{ return func_{i}({i}); }}\n"
-        )
-        entries.append(
-            {
-                "directory": workspace.as_posix(),
-                "file": src.as_posix(),
-                "arguments": ["clang++", "-std=c++17", "-fsyntax-only", src.as_posix()],
-            }
-        )
-
-    (workspace / "compile_commands.json").write_text(json.dumps(entries))
-
-    host = "127.0.0.1"
-    port = _find_free_port()
-    cmd = [str(executable), "--mode", "pipe", "--host", host, "--port", str(port)]
-
-    c = CliceClient()
-    await c.start_io(*cmd)
-
-    init_options = {
-        "project": {
-            "cache_dir": str(workspace / ".clice"),
-            "idle_timeout_ms": 0,
-        }
-    }
-    await c.initialize(workspace, initialization_options=init_options)
-
-    # Give indexing a moment to start, then send shutdown
-    await asyncio.sleep(0.5)
-
-    rpc = AgenticRpcClient(host, port)
-    body = json.dumps({"jsonrpc": "2.0", "method": "agentic/shutdown", "params": {}})
-    rpc.sock.sendall(f"Content-Length: {len(body)}\r\n\r\n{body}".encode())
-    rpc.sock.settimeout(5)
-    try:
-        rpc.sock.recv(4096)
-    except (socket.timeout, OSError):
-        pass
-    rpc.sock.close()
-
-    for _ in range(30):
-        if c._server.returncode is not None:
-            break
-        await asyncio.sleep(0.5)
-
-    assert c._server.returncode is not None, "Server did not exit after shutdown"
-    assert c._server.returncode >= 0, (
-        f"Server crashed with signal {-c._server.returncode}"
-    )

tests/integration/agentic/test_cli.py

@@ -1,189 +0,0 @@
-"""CLI-based tests for agentic mode — run clice --mode agentic as a subprocess."""
-
-import json
-import subprocess
-
-import pytest
-
-from tests.integration.utils.wait import wait_for_index
-
-
-def run_cli(executable, host, port, method, **kwargs):
-    cmd = [
-        str(executable),
-        "--mode",
-        "agentic",
-        "--host",
-        host,
-        "--port",
-        str(port),
-        "--method",
-        method,
-    ]
-    for k, v in kwargs.items():
-        cmd.extend([f"--{k}", str(v)])
-    result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
-    return result
-
-
-@pytest.fixture
-async def indexed_server(request, executable, workspace):
-    """Start server with LSP+agentic, compile a file, wait for indexing."""
-    import asyncio
-    from tests.integration.utils.client import CliceClient
-    from tests.conftest import _shutdown_client, _find_free_port
-
-    host = "127.0.0.1"
-    port = _find_free_port()
-    cmd = [str(executable), "--mode", "pipe", "--host", host, "--port", str(port)]
-
-    c = CliceClient()
-    await c.start_io(*cmd)
-
-    init_options = {"project": {"cache_dir": str(workspace / ".clice")}}
-    await c.initialize(workspace, initialization_options=init_options)
-
-    uri, _ = await c.open_and_wait(workspace / "main.cpp")
-    assert await wait_for_index(c, uri, "add"), "Index not ready"
-
-    from tests.integration.agentic.test_agentic import AgenticRpcClient
-
-    rpc = AgenticRpcClient(host, port)
-    for _ in range(30):
-        resp = rpc.request("agentic/symbolSearch", {"query": "add"})
-        if "result" in resp and resp["result"]["symbols"]:
-            break
-        await asyncio.sleep(1)
-    rpc.close()
-
-    yield executable, host, port, workspace
-
-    c.close(uri)
-    await _shutdown_client(c)
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_compile_command(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    path = (workspace / "main.cpp").as_posix()
-    r = run_cli(exe, host, port, "compileCommand", path=path)
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert data["file"] == path
-    assert len(data["arguments"]) > 0
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_symbol_search(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    r = run_cli(exe, host, port, "symbolSearch", query="add")
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    names = [s["name"] for s in data["symbols"]]
-    assert "add" in names
-    add_sym = next(s for s in data["symbols"] if s["name"] == "add")
-    assert add_sym["kind"] == "Function"
-    assert add_sym["line"] == 19
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_definition(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    r = run_cli(exe, host, port, "definition", name="add")
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert data["name"] == "add"
-    defn = data["definition"]
-    assert defn["startLine"] == 19
-    assert defn["endLine"] == 21
-    assert "return a + b;" in defn["text"]
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_definition_by_position(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    path = (workspace / "main.cpp").as_posix()
-    r = run_cli(exe, host, port, "definition", path=path, line=19)
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert data["name"] == "add"
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_references(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    r = run_cli(exe, host, port, "references", name="global_var")
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert data["name"] == "global_var"
-    assert data["total"] == 2
-    lines = sorted(ref["line"] for ref in data["references"])
-    assert lines == [34, 38]
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_read_symbol(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    r = run_cli(exe, host, port, "readSymbol", name="compute")
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert data["name"] == "compute"
-    assert "add(1, 2)" in data["text"]
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_document_symbols(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    path = (workspace / "main.cpp").as_posix()
-    r = run_cli(exe, host, port, "documentSymbols", path=path)
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    names = [s["name"] for s in data["symbols"]]
-    assert "add" in names
-    assert "main" in names
-    assert "global_var" in names
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_call_graph(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    r = run_cli(exe, host, port, "callGraph", name="add", direction="callers")
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert data["root"]["name"] == "add"
-    caller_names = [c["name"] for c in data["callers"]]
-    assert "compute" in caller_names
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_type_hierarchy(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    r = run_cli(exe, host, port, "typeHierarchy", name="Dog", direction="supertypes")
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert data["root"]["name"] == "Dog"
-    supertype_names = [t["name"] for t in data["supertypes"]]
-    assert "Animal" in supertype_names
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_project_files(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    r = run_cli(exe, host, port, "projectFiles")
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert data["total"] > 0
-    paths = [f["path"] for f in data["files"]]
-    assert any("main.cpp" in p for p in paths)
-
-
-@pytest.mark.workspace("index_features")
-async def test_cli_status(indexed_server, workspace):
-    exe, host, port, _ = indexed_server
-    r = run_cli(exe, host, port, "status")
-    assert r.returncode == 0, f"stderr: {r.stderr}"
-    data = json.loads(r.stdout)
-    assert isinstance(data["idle"], bool)
-    assert data["total"] > 0
-    assert isinstance(data["pending"], int)
-    assert isinstance(data["indexed"], int)

tests/integration/compilation/test_persistent_cache.py

@@ -16,6 +16,7 @@ from lsprotocol.types import (
 
 from tests.conftest import make_client, shutdown_client
 from tests.integration.utils import write_cdb, doc
+from tests.integration.utils.wait import MTIME_GRANULARITY, SETTLE_TIME
 from tests.integration.utils.cache import (
     list_pch_files,
     list_pcm_files,
@@ -100,7 +101,7 @@ async def test_pch_reused_on_close_reopen(client, tmp_path):
 
     # Close.
     client.text_document_did_close(DidCloseTextDocumentParams(text_document=doc(uri)))
-    await asyncio.sleep(0.5)
+    await asyncio.sleep(SETTLE_TIME)
 
     # Clear diagnostics so we can wait for fresh ones.
     client.diagnostics.pop(uri, None)
@@ -227,7 +228,7 @@ async def test_pch_rebuilt_on_header_change(client, tmp_path):
     assert len(pch_before) >= 1
 
     # Modify header — changes preamble content hash.
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "header.h").write_text("#pragma once\nstruct V2 { int b; };\n")
     # Also update main.cpp to use V2 so it compiles cleanly.
     (tmp_path / "main.cpp").write_text(
@@ -236,7 +237,7 @@ async def test_pch_rebuilt_on_header_change(client, tmp_path):
 
     # Close and reopen to get fresh preamble.
     client.text_document_did_close(DidCloseTextDocumentParams(text_document=doc(uri)))
-    await asyncio.sleep(0.5)
+    await asyncio.sleep(SETTLE_TIME)
     client.diagnostics.pop(uri, None)
 
     uri2, _ = await client.open_and_wait(tmp_path / "main.cpp")

tests/integration/compilation/test_staleness.py

@@ -21,7 +21,7 @@ from lsprotocol.types import (
 )
 
 from tests.integration.utils import write_cdb, doc
-from tests.integration.utils.wait import wait_for_recompile
+from tests.integration.utils.wait import MTIME_GRANULARITY, wait_for_recompile
 from tests.integration.utils.assertions import assert_clean_compile, assert_has_errors
 
 
@@ -42,7 +42,7 @@ async def test_header_change_invalidates_ast(client, tmp_path):
 
     # Modify header on disk — introduce an error.
     # Ensure mtime advances past filesystem granularity (1s on some FSes).
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "header.h").write_text(
         "inline int value() { return }\n"
     )  # syntax error
@@ -71,7 +71,7 @@ async def test_header_change_invalidates_pch(client, tmp_path):
 
     # Modify header — rename struct field.
     # Ensure mtime advances past filesystem granularity (1s on some FSes).
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "header.h").write_text(
         "#pragma once\nstruct Foo { int y; };\n"  # x -> y
     )
@@ -115,16 +115,22 @@ async def test_touch_without_content_change_skips_recompile(client, tmp_path):
     assert_clean_compile(client, uri)
 
     # Touch the header — mtime changes but content stays the same.
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     original_content = (tmp_path / "header.h").read_text()
     (tmp_path / "header.h").write_text(original_content)
 
     # Hover triggers ensure_compiled which runs deps_changed.
     # Layer 2 hash confirms nothing actually changed → cached AST reused.
-    # Hover on "main" (line 1, col 4) which should be hoverable.
-    hover = await client.text_document_hover_async(
-        HoverParams(text_document=doc(uri), position=Position(line=1, character=4))
-    )
+    # The first hover may see ast_dirty=true (mtime changed, hash check in progress),
+    # so retry to let the hash check complete.
+    hover = None
+    for _ in range(3):
+        hover = await client.text_document_hover_async(
+            HoverParams(text_document=doc(uri), position=Position(line=1, character=4))
+        )
+        if hover is not None:
+            break
+        await asyncio.sleep(SETTLE_TIME)
     assert hover is not None
 
     # No new diagnostics should appear — the file is still clean.
@@ -145,7 +151,7 @@ async def test_header_replaced_with_different_content(client, tmp_path):
     assert_clean_compile(client, uri)
 
     # Replace header — delete and recreate with a breaking change.
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "header.h").unlink()
     (tmp_path / "header.h").write_text("inline int renamed_value() { return 1; }\n")
 
@@ -170,7 +176,7 @@ async def test_fix_error_clears_diagnostics(client, tmp_path):
     assert_has_errors(client, uri, "Expected diagnostics from broken header")
 
     # Fix the header.
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "header.h").write_text("inline int value() { return 1; }\n")
 
     # Hover triggers recompilation — diagnostics should clear.
@@ -198,7 +204,7 @@ async def test_multiple_files_share_header(client, tmp_path):
     assert_clean_compile(client, uri_b)
 
     # Break the shared header.
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "shared.h").write_text("inline int shared() { return }\n")
 
     # Both files should get diagnostics after hover.
@@ -223,7 +229,7 @@ async def test_transitive_header_change(client, tmp_path):
     assert_clean_compile(client, uri)
 
     # Modify the transitive dep (base.h).
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "base.h").write_text("inline int base() { return }\n")  # broken
 
     await wait_for_recompile(client, uri)
@@ -310,7 +316,7 @@ async def test_didclose_then_reopen(client, tmp_path):
     client.text_document_did_close(DidCloseTextDocumentParams(text_document=doc(uri)))
 
     # Modify on disk while closed.
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "main.cpp").write_text("int main() { return }\n")  # broken
 
     # Reopen — should compile the new (broken) content from disk.
@@ -321,7 +327,7 @@ async def test_didclose_then_reopen(client, tmp_path):
 
 
 async def test_didclose_clears_hover(client, tmp_path):
-    """After didClose, hover on the closed file should return None."""
+    """After didClose, hover on the closed file should return an error."""
     (tmp_path / "main.cpp").write_text("int main() { return 0; }\n")
     write_cdb(tmp_path, ["main.cpp"])
     await client.initialize(tmp_path)
@@ -330,10 +336,10 @@ async def test_didclose_clears_hover(client, tmp_path):
 
     client.text_document_did_close(DidCloseTextDocumentParams(text_document=doc(uri)))
 
-    hover = await client.text_document_hover_async(
-        HoverParams(text_document=doc(uri), position=Position(line=0, character=4))
-    )
-    assert hover is None, "Hover on closed file should return None"
+    with pytest.raises(Exception, match="Document not open"):
+        await client.text_document_hover_async(
+            HoverParams(text_document=doc(uri), position=Position(line=0, character=4))
+        )
 
 
 async def test_didsave_triggers_recompile_for_dependents(client, tmp_path):
@@ -349,7 +355,7 @@ async def test_didsave_triggers_recompile_for_dependents(client, tmp_path):
     assert_clean_compile(client, uri)
 
     # Modify header on disk and send didSave.
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(MTIME_GRANULARITY)
     (tmp_path / "header.h").write_text("inline int value() { return }\n")  # broken
     client.text_document_did_save(
         DidSaveTextDocumentParams(

tests/integration/features/test_formatting.py

@@ -1,74 +0,0 @@
-import pytest
-from lsprotocol.types import Position, Range
-
-from tests.integration.utils.workspace import did_change
-
-UNFORMATTED = "int    add(   int   a  ,  int   b  ) {\nreturn   a+b ;\n}\n"
-FORMATTED = "int add(int a, int b) { return a + b; }\n"
-
-
-def apply_edits(text, edits):
-    """Apply LSP TextEdits to a string, processing from end to start."""
-    lines = text.split("\n")
-    for edit in sorted(
-        edits, key=lambda e: (e.range.start.line, e.range.start.character), reverse=True
-    ):
-        start = edit.range.start
-        end = edit.range.end
-        before = (
-            "\n".join(lines[: start.line])
-            + ("\n" if start.line > 0 else "")
-            + lines[start.line][: start.character]
-        )
-        after = (
-            lines[end.line][end.character :]
-            + ("\n" if end.line < len(lines) - 1 else "")
-            + "\n".join(lines[end.line + 1 :])
-        )
-        text = before + edit.new_text + after
-        lines = text.split("\n")
-    return text
-
-
-@pytest.mark.workspace("formatting")
-async def test_format_document(client, workspace):
-    uri, _ = await client.open_and_wait(workspace / "main.cpp")
-
-    did_change(client, uri, 1, UNFORMATTED)
-    edits = await client.format_document(uri)
-
-    assert edits is not None
-    assert len(edits) > 0
-    result = apply_edits(UNFORMATTED, edits)
-    assert result == FORMATTED
-
-    client.close(uri)
-
-
-@pytest.mark.workspace("formatting")
-async def test_format_range(client, workspace):
-    uri, _ = await client.open_and_wait(workspace / "main.cpp")
-
-    did_change(client, uri, 1, UNFORMATTED)
-    edits = await client.format_range(
-        uri,
-        Range(start=Position(line=1, character=0), end=Position(line=2, character=0)),
-    )
-
-    assert edits is not None
-    assert len(edits) > 0
-
-    client.close(uri)
-
-
-@pytest.mark.workspace("formatting")
-async def test_format_already_formatted(client, workspace):
-    uri, _ = await client.open_and_wait(workspace / "main.cpp")
-
-    did_change(client, uri, 1, FORMATTED)
-    edits = await client.format_document(uri)
-
-    assert edits is not None
-    assert len(edits) == 0
-
-    client.close(uri)

tests/integration/features/test_server.py

@@ -10,6 +10,7 @@ from lsprotocol.types import (
 )
 
 from tests.integration.utils import doc
+from tests.integration.utils.wait import SETTLE_TIME
 from tests.integration.utils.workspace import did_change
 
 
@@ -34,8 +35,6 @@ async def test_capabilities(client, workspace):
     assert capability_enabled(caps.folding_range_provider)
     assert capability_enabled(caps.inlay_hint_provider)
     assert capability_enabled(caps.code_action_provider)
-    assert caps.document_formatting_provider is True
-    assert caps.document_range_formatting_provider is True
     assert caps.semantic_tokens_provider is not None
 
 
@@ -72,7 +71,7 @@ async def test_semantic_token_modifier_legend(client, workspace):
 @pytest.mark.workspace("hello_world")
 async def test_did_open_close_cycle(client, workspace):
     uri, _ = client.open(workspace / "main.cpp")
-    await asyncio.sleep(0.5)
+    await asyncio.sleep(SETTLE_TIME)
     client.close(uri)
 
 
@@ -85,8 +84,8 @@ async def test_shutdown_exit(client, workspace):
 async def test_feature_requests_after_close(client, workspace):
     uri, _ = client.open(workspace / "main.cpp")
     client.close(uri)
-    result = await client.hover_at(uri, 0, 0)
-    assert result is None
+    with pytest.raises(Exception, match="Document not open"):
+        await client.hover_at(uri, 0, 0)
 
 
 @pytest.mark.workspace("hello_world")
@@ -96,7 +95,7 @@ async def test_incremental_change(client, workspace):
         content += f"\n// change {i}"
         did_change(client, uri, i + 1, content)
         await asyncio.sleep(0.05)
-    await asyncio.sleep(1)
+    await asyncio.sleep(SETTLE_TIME * 2)
     client.close(uri)
 
 
@@ -193,23 +192,23 @@ async def test_rapid_changes_stress(client, workspace):
     for i in range(20):
         content += f"\n// stress change {i}\n"
         did_change(client, uri, i + 1, content)
-    await asyncio.sleep(2)
+    await asyncio.sleep(SETTLE_TIME * 2)
     client.close(uri)
 
 
 @pytest.mark.workspace("hello_world")
 async def test_save_notification(client, workspace):
     uri, _ = client.open(workspace / "main.cpp")
-    await asyncio.sleep(0.5)
+    await asyncio.sleep(SETTLE_TIME)
     client.text_document_did_save(DidSaveTextDocumentParams(text_document=doc(uri)))
-    await asyncio.sleep(0.5)
+    await asyncio.sleep(SETTLE_TIME)
     client.close(uri)
 
 
 @pytest.mark.workspace("hello_world")
 async def test_hover_on_unknown_file(client, workspace):
-    result = await client.hover_at("file:///nonexistent/fake.cpp", 0, 0)
-    assert result is None
+    with pytest.raises(Exception, match="Document not open"):
+        await client.hover_at("file:///nonexistent/fake.cpp", 0, 0)
 
 
 @pytest.mark.workspace("hello_world")

tests/integration/lifecycle/test_file_operation.py

@@ -13,13 +13,14 @@ from lsprotocol.types import (
 )
 
 from tests.integration.utils import doc
+from tests.integration.utils.wait import IDLE_TIMEOUT
 from tests.integration.utils.workspace import did_change
 
 
 @pytest.mark.workspace("hello_world")
 async def test_did_open(client, workspace):
     client.open(workspace / "main.cpp")
-    await asyncio.sleep(5)
+    await asyncio.sleep(IDLE_TIMEOUT)
 
 
 @pytest.mark.workspace("hello_world")
@@ -29,13 +30,13 @@ async def test_did_change(client, workspace):
         content += "\n"
         await asyncio.sleep(0.2)
         did_change(client, uri, i + 1, content)
-    await asyncio.sleep(5)
+    await asyncio.sleep(IDLE_TIMEOUT)
 
 
 @pytest.mark.workspace("clang_tidy")
 async def test_clang_tidy(client, workspace):
     client.open(workspace / "main.cpp")
-    await asyncio.sleep(5)
+    await asyncio.sleep(IDLE_TIMEOUT)
 
 
 @pytest.mark.workspace("hello_world")
@@ -56,7 +57,7 @@ async def test_hover_save_close(client, workspace):
         )
     )
     client.text_document_did_close(DidCloseTextDocumentParams(text_document=doc(uri)))
-    closed_hover = await client.text_document_hover_async(
-        HoverParams(text_document=doc(uri), position=Position(line=0, character=0))
-    )
-    assert closed_hover is None
+    with pytest.raises(Exception, match="Document not open"):
+        await client.text_document_hover_async(
+            HoverParams(text_document=doc(uri), position=Position(line=0, character=0))
+        )

tests/integration/modules/test_modules.py

@@ -14,6 +14,7 @@ from lsprotocol.types import (
 )
 
 from tests.integration.utils.assertions import assert_clean_compile, assert_has_errors
+from tests.integration.utils.wait import IDLE_TIMEOUT
 
 
 @pytest.mark.workspace("modules/single_module_no_deps")
@@ -267,7 +268,7 @@ async def test_circular_module_dependency(client, workspace):
     the server remains responsive by opening a non-cyclic file afterwards.
     """
     client.open(workspace / "cycle_a.cppm")
-    await asyncio.sleep(5.0)
+    await asyncio.sleep(IDLE_TIMEOUT)
 
     uri_ok, _ = await client.open_and_wait(workspace / "ok.cppm")
     diags = client.diagnostics.get(uri_ok, [])

tests/integration/stress/test_rapid_edit.py

@@ -10,6 +10,7 @@ from lsprotocol.types import (
 )
 
 from tests.integration.utils import doc
+from tests.integration.utils.wait import SETTLE_TIME
 from tests.integration.utils.workspace import did_change
 
 
@@ -53,7 +54,7 @@ async def test_rapid_edits_with_hover(client, workspace):
         await asyncio.sleep(0.02)  # ~20ms between edits
 
     # Wait a moment for in-flight requests to settle.
-    await asyncio.sleep(1.0)
+    await asyncio.sleep(SETTLE_TIME * 2)
 
     # Final hover must succeed and return correct result.
     final_hover = await asyncio.wait_for(

tests/integration/utils/assertions.py

@@ -1,6 +1,6 @@
-"""Diagnostic assertion helpers for integration tests."""
+"""Diagnostic and log message assertion helpers for integration tests."""
 
-from lsprotocol.types import Diagnostic, DiagnosticSeverity
+from lsprotocol.types import Diagnostic, DiagnosticSeverity, MessageType
 
 
 def get_errors(diagnostics: list[Diagnostic]) -> list[Diagnostic]:
@@ -48,3 +48,23 @@ def assert_clean_compile(client, uri: str) -> None:
     """Assert the file compiled without any diagnostics at all."""
     diags = client.diagnostics.get(uri, [])
     assert len(diags) == 0, f"Expected clean compile, got: {diags}"
+
+
+def has_log_message(
+    client, substring: str, *, severity: MessageType | None = None
+) -> bool:
+    """Check if any log message contains the given substring."""
+    for msg in client.log_messages:
+        if severity is not None and msg.type != severity:
+            continue
+        if substring in msg.message:
+            return True
+    return False
+
+
+def assert_no_log_errors(client) -> None:
+    """Assert that no error-level log messages were received."""
+    errors = [m for m in client.log_messages if m.type == MessageType.Error]
+    assert len(errors) == 0, (
+        f"Expected no log errors, got: {[e.message for e in errors]}"
+    )

tests/integration/utils/client.py

@@ -7,6 +7,7 @@ from urllib.parse import unquote
 from lsprotocol.types import (
     PROGRESS,
     TEXT_DOCUMENT_PUBLISH_DIAGNOSTICS,
+    WINDOW_LOG_MESSAGE,
     WINDOW_WORK_DONE_PROGRESS_CREATE,
     ClientCapabilities,
     CodeActionContext,
@@ -16,17 +17,15 @@ from lsprotocol.types import (
     Diagnostic,
     DidCloseTextDocumentParams,
     DidOpenTextDocumentParams,
-    DocumentFormattingParams,
     DocumentLinkParams,
-    DocumentRangeFormattingParams,
     DocumentSymbolParams,
     FoldingRangeParams,
-    FormattingOptions,
     HoverParams,
     InlayHintParams,
     InitializeParams,
     InitializeResult,
     InitializedParams,
+    LogMessageParams,
     Position,
     ProgressParams,
     PublishDiagnosticsParams,
@@ -51,6 +50,7 @@ class CliceClient(BaseLanguageClient):
         super().__init__("clice-test-client", "0.1.0")
         self.diagnostics: dict[str, list[Diagnostic]] = {}
         self.diagnostics_events: dict[str, asyncio.Event] = {}
+        self.log_messages: list[LogMessageParams] = []
         self.progress_tokens: list[str] = []
         self.progress_events: list[dict] = []
         self.init_result: InitializeResult | None = None
@@ -67,6 +67,10 @@ class CliceClient(BaseLanguageClient):
                 if key in self.diagnostics_events:
                     self.diagnostics_events[key].set()
 
+        @self.feature(WINDOW_LOG_MESSAGE)
+        def on_log_message(params: LogMessageParams) -> None:
+            self.log_messages.append(params)
+
         @self.feature(WINDOW_WORK_DONE_PROGRESS_CREATE)
         def on_create_progress(params: WorkDoneProgressCreateParams) -> None:
             token = str(params.token) if isinstance(params.token, int) else params.token
@@ -95,18 +99,13 @@ class CliceClient(BaseLanguageClient):
         *,
         initialization_options: dict | None = None,
     ) -> InitializeResult:
-        if initialization_options is None:
-            initialization_options = {}
-        project = dict(initialization_options.get("project", {}))
-        project.setdefault("cache_dir", str(workspace / ".clice"))
-        initialization_options["project"] = project
-
         params = InitializeParams(
             capabilities=ClientCapabilities(),
             root_uri=workspace.as_uri(),
             workspace_folders=[WorkspaceFolder(uri=workspace.as_uri(), name="test")],
         )
-        params.initialization_options = initialization_options
+        if initialization_options is not None:
+            params.initialization_options = initialization_options
         result = await self.initialize_async(params)
         self.initialized(InitializedParams())
         self.init_result = result
@@ -315,29 +314,6 @@ class CliceClient(BaseLanguageClient):
             timeout=timeout,
         )
 
-    async def format_document(self, uri: str, *, timeout: float = 30.0):
-        return await asyncio.wait_for(
-            self.text_document_formatting_async(
-                DocumentFormattingParams(
-                    text_document=TextDocumentIdentifier(uri=uri),
-                    options=FormattingOptions(tab_size=4, insert_spaces=True),
-                )
-            ),
-            timeout=timeout,
-        )
-
-    async def format_range(self, uri: str, range_: Range, *, timeout: float = 30.0):
-        return await asyncio.wait_for(
-            self.text_document_range_formatting_async(
-                DocumentRangeFormattingParams(
-                    text_document=TextDocumentIdentifier(uri=uri),
-                    range=range_,
-                    options=FormattingOptions(tab_size=4, insert_spaces=True),
-                )
-            ),
-            timeout=timeout,
-        )
-
     # ── Extension protocol ───────────────────────────────────────────
 
     async def query_context(self, uri: str, *, timeout: float = 30.0):

tests/integration/utils/wait.py

@@ -9,6 +9,11 @@ from lsprotocol.types import (
     WorkspaceSymbolParams,
 )
 
+# Standard timing constants — use these instead of hardcoded sleep values.
+MTIME_GRANULARITY = 1.1  # Filesystem mtime precision (1s on many FSes, +0.1 margin)
+SETTLE_TIME = 0.5  # Time for server to stabilize after an operation
+IDLE_TIMEOUT = 5.0  # Time to wait for server idle in lifecycle tests
+
 
 async def wait_for_recompile(client, uri: str, *, timeout: float = 60.0) -> None:
     """Trigger recompilation via hover and wait for fresh diagnostics.

tests/unit/feature/document_link_tests.cpp

@@ -21,11 +21,6 @@ void run(llvm::StringRef source, llvm::StringRef standard = "-std=c++17") {
     links = feature::document_links(*unit, feature::PositionEncoding::UTF8);
 }
 
-auto to_local_range(const protocol::Range& range) -> LocalSourceRange {
-    feature::PositionMapper converter(unit->interested_content(), feature::PositionEncoding::UTF8);
-    return LocalSourceRange(*converter.to_offset(range.start), *converter.to_offset(range.end));
-}
-
 void EXPECT_LINK(std::size_t index, llvm::StringRef name, llvm::StringRef path) {
     auto& link = links[index];
     auto expected = range(name, "main.cpp");

tests/unit/feature/folding_range_tests.cpp

@@ -37,19 +37,10 @@ void run(llvm::StringRef code) {
 }
 
 auto to_local_range(const protocol::FoldingRange& range) -> LocalSourceRange {
-    feature::PositionMapper converter(unit->interested_content(), feature::PositionEncoding::UTF8);
-
-    auto start = protocol::Position{
-        .line = range.start_line,
-        .character = range.start_character.value_or(0),
-    };
-
-    auto end = protocol::Position{
-        .line = range.end_line,
-        .character = range.end_character.value_or(0),
-    };
-
-    return LocalSourceRange(*converter.to_offset(start), *converter.to_offset(end));
+    return Tester::to_local_range(protocol::Range{
+        .start = {.line = range.start_line, .character = range.start_character.value_or(0)},
+        .end = {.line = range.end_line,   .character = range.end_character.value_or(0)  },
+    });
 }
 
 void EXPECT_FOLDING(std::uint32_t index,

tests/unit/feature/formatting_tests.cpp

@@ -12,41 +12,6 @@ TEST_CASE(Simple) {
     ASSERT_NE(edits.size(), 0U);
 }
 
-TEST_CASE(RangeFormat) {
-    llvm::StringRef code = "int x=1;\nint   y =  2 ;\nint z=3;\n";
-    LocalSourceRange range;
-    range.begin = static_cast<std::uint32_t>(code.find("int   y"));
-    range.end = static_cast<std::uint32_t>(code.find("\nint z") + 1);
-    auto range_edits = feature::document_format("main.cpp", code, range);
-    auto full_edits = feature::document_format("main.cpp", code, std::nullopt);
-    ASSERT_NE(range_edits.size(), 0U);
-    EXPECT_LE(range_edits.size(), full_edits.size());
-}
-
-TEST_CASE(Idempotent) {
-    llvm::StringRef code = "int main() {\n    return 0;\n}\n";
-    auto edits = feature::document_format("main.cpp", code, std::nullopt);
-    EXPECT_EQ(edits.size(), 0U);
-}
-
-TEST_CASE(IncludeSort) {
-    llvm::StringRef code = "#include <vector>\n#include <algorithm>\n\nint main() {}\n";
-    auto edits = feature::document_format("main.cpp", code, std::nullopt);
-    ASSERT_NE(edits.size(), 0U);
-}
-
-TEST_CASE(FormatCode) {
-    auto result = feature::format_code("main.cpp", "int   add(  int a,int    b ){return a+b;}");
-    EXPECT_NE(result.find("int add("), std::string::npos);
-    EXPECT_EQ(result.find("  int a,int"), std::string::npos);
-}
-
-TEST_CASE(FormatCodeIdempotent) {
-    auto first = feature::format_code("main.cpp", "int   add(  int a,int    b ){return a+b;}");
-    auto second = feature::format_code("main.cpp", first);
-    EXPECT_EQ(first, second);
-}
-
 };  // TEST_SUITE(Formatting)
 
 }  // namespace

tests/unit/semantic/template_resolver_tests.cpp

@@ -456,6 +456,8 @@ TEST_CASE(BasePackExpansion) {
     )code");
 }
 
+// --- Robustness tests for edge cases found during stress testing ---
+
 TEST_CASE(RecursiveBaseClass) {
     // Regression test: callback_traits<F> inherits callback_traits<decltype(&F::operator())>,
     // creating infinite recursion through lookupInBases. CTD cycle detection must bail out.

tests/unit/server/compile_graph_integration_tests.cpp

@@ -3,7 +3,7 @@
 #include "test/test.h"
 #include "command/command.h"
 #include "compile/compilation.h"
-#include "server/compiler/compile_graph.h"
+#include "server/compile_graph.h"
 #include "support/path_pool.h"
 #include "syntax/dependency_graph.h"
 #include "syntax/scan.h"

tests/unit/server/compile_graph_tests.cpp

@@ -1,7 +1,7 @@
 #include <optional>
 
 #include "test/test.h"
-#include "server/compiler/compile_graph.h"
+#include "server/compile_graph.h"
 
 namespace clice::testing {
 namespace {

tests/unit/server/config_tests.cpp

@@ -2,7 +2,7 @@
 
 #include "test/temp_dir.h"
 #include "test/test.h"
-#include "server/workspace/config.h"
+#include "server/config.h"
 #include "support/filesystem.h"
 
 #include "kota/codec/json/json.h"

tests/unit/server/module_worker_tests.cpp

@@ -2,7 +2,7 @@
 #include <vector>
 
 #include "test/test.h"
-#include "server/protocol/worker.h"
+#include "server/protocol.h"
 #include "server/worker_test_helpers.h"
 
 namespace clice::testing {
@@ -29,6 +29,7 @@ TEST_CASE(BuildPCMThenCompileWithImport) {
     tmp.touch("consumer.cpp", "import Hello;\n" "int main() { return hello()[0]; }\n");
     auto consumer = tmp.path("consumer.cpp");
 
+    // --- Phase 1: Build PCM via stateless worker ---
     WorkerHandle sl;
     ASSERT_TRUE(sl.spawn("stateless-worker"));
 
@@ -62,6 +63,7 @@ TEST_CASE(BuildPCMThenCompileWithImport) {
     ASSERT_TRUE(phase1_done);
     ASSERT_FALSE(pcm_path.empty());
 
+    // --- Phase 2: Compile consumer with the PCM via stateful worker ---
     WorkerHandle sf;
     ASSERT_TRUE(sf.spawn("stateful-worker"));
 

tests/unit/server/pch_worker_tests.cpp

@@ -2,7 +2,7 @@
 #include <vector>
 
 #include "test/test.h"
-#include "server/protocol/worker.h"
+#include "server/protocol.h"
 #include "server/worker_test_helpers.h"
 #include "syntax/scan.h"
 
@@ -30,6 +30,7 @@ TEST_CASE(BuildPCHThenCompile) {
 
     auto dir = std::string(tmp.root);
 
+    // --- Phase 1: Build PCH via stateless worker ---
     WorkerHandle sl;
     ASSERT_TRUE(sl.spawn("stateless-worker"));
 
@@ -68,6 +69,7 @@ TEST_CASE(BuildPCHThenCompile) {
     // Verify the PCH file exists on disk.
     ASSERT_TRUE(llvm::sys::fs::exists(pch_path));
 
+    // --- Phase 2: Compile with PCH via stateful worker ---
     WorkerHandle sf;
     ASSERT_TRUE(sf.spawn("stateful-worker"));
 

tests/unit/server/stateful_worker_tests.cpp

@@ -2,7 +2,7 @@
 #include <vector>
 
 #include "test/test.h"
-#include "server/protocol/worker.h"
+#include "server/protocol.h"
 #include "server/worker_test_helpers.h"
 
 #include "kota/codec/json/json.h"

tests/unit/server/stateless_worker_tests.cpp

@@ -2,7 +2,7 @@
 #include <vector>
 
 #include "test/test.h"
-#include "server/protocol/worker.h"
+#include "server/protocol.h"
 #include "server/worker_test_helpers.h"
 
 #include "kota/codec/bincode/bincode.h"

tests/unit/server/worker_test_helpers.h

@@ -11,7 +11,7 @@
 #include "test/temp_dir.h"
 #include "command/argument_parser.h"
 #include "command/command.h"
-#include "server/protocol/worker.h"
+#include "server/protocol.h"
 #include "support/filesystem.h"
 
 #include "kota/async/async.h"

tests/unit/support/markup_tests.cpp

@@ -1,248 +0,0 @@
-#include "test/test.h"
-#include "support/markup.h"
-
-namespace clice::testing {
-
-namespace {
-
-TEST_SUITE(Markup) {
-
-TEST_CASE(EmptyDocument) {
-    Markup st;
-    EXPECT_EQ(st.as_markdown(), "");
-}
-
-TEST_CASE(SingleParagraph) {
-    Markup st;
-    st.add_paragraph().append_text("hello world");
-    EXPECT_EQ(st.as_markdown(), "hello world");
-}
-
-TEST_CASE(PlainTextSpacing) {
-    Markup st;
-    auto& p = st.add_paragraph();
-    p.append_text("hello");
-    p.append_text("world");
-    EXPECT_EQ(st.as_markdown(), "hello world");
-}
-
-TEST_CASE(InlineCode) {
-    Markup st;
-    auto& p = st.add_paragraph();
-    p.append_text("Type:");
-    p.append_text("int", Paragraph::Kind::InlineCode);
-    EXPECT_EQ(st.as_markdown(), "Type: `int`");
-}
-
-TEST_CASE(Bold) {
-    Markup st;
-    st.add_paragraph().append_text("important", Paragraph::Kind::Bold);
-    EXPECT_EQ(st.as_markdown(), "**important**");
-}
-
-TEST_CASE(Italic) {
-    Markup st;
-    st.add_paragraph().append_text("emphasis", Paragraph::Kind::Italic);
-    EXPECT_EQ(st.as_markdown(), "*emphasis*");
-}
-
-TEST_CASE(Strikethrough) {
-    Markup st;
-    st.add_paragraph().append_text("removed", Paragraph::Kind::Strikethrough);
-    EXPECT_EQ(st.as_markdown(), "~~removed~~");
-}
-
-TEST_CASE(MixedInline) {
-    Markup st;
-    auto& p = st.add_paragraph();
-    p.append_text("Returns:", Paragraph::Kind::Bold);
-    p.append_text("the result");
-    EXPECT_EQ(st.as_markdown(), "**Returns:** the result");
-}
-
-TEST_CASE(ConsecutiveInlineCode) {
-    Markup st;
-    auto& p = st.add_paragraph();
-    p.append_text("int", Paragraph::Kind::InlineCode);
-    p.append_text("x", Paragraph::Kind::InlineCode);
-    EXPECT_EQ(st.as_markdown(), "`int` `x`");
-}
-
-TEST_CASE(Heading) {
-    Markup st;
-    st.add_heading(3).append_text("Title");
-    EXPECT_EQ(st.as_markdown(), "### Title");
-}
-
-TEST_CASE(HeadingWithInlineCode) {
-    Markup st;
-    auto& h = st.add_heading(2);
-    h.append_text("function");
-    h.append_text("foo", Paragraph::Kind::InlineCode);
-    EXPECT_EQ(st.as_markdown(), "## function `foo`");
-}
-
-TEST_CASE(Ruler) {
-    Markup st;
-    st.add_paragraph().append_text("above");
-    st.add_ruler();
-    st.add_paragraph().append_text("below");
-    auto md = st.as_markdown();
-    EXPECT_NE(md.find("above"), std::string::npos);
-    EXPECT_NE(md.find("---"), std::string::npos);
-    EXPECT_NE(md.find("below"), std::string::npos);
-}
-
-TEST_CASE(ConsecutiveRulers) {
-    Markup st;
-    st.add_paragraph().append_text("text");
-    st.add_ruler();
-    st.add_ruler();
-    st.add_paragraph().append_text("more");
-    auto md = st.as_markdown();
-    auto first = md.find("---");
-    auto second = md.find("---", first + 3);
-    EXPECT_EQ(second, std::string::npos);
-}
-
-TEST_CASE(LeadingTrailingRulers) {
-    Markup st;
-    st.add_ruler();
-    st.add_paragraph().append_text("content");
-    st.add_ruler();
-    EXPECT_EQ(st.as_markdown(), "content");
-}
-
-TEST_CASE(CodeBlock) {
-    Markup st;
-    st.add_code_block("int x = 0;", "cpp");
-    EXPECT_EQ(st.as_markdown(), "```cpp\nint x = 0;\n```");
-}
-
-TEST_CASE(CodeBlockTrailingNewline) {
-    Markup st;
-    st.add_code_block("int x = 0;\n", "cpp");
-    EXPECT_EQ(st.as_markdown(), "```cpp\nint x = 0;\n```");
-}
-
-TEST_CASE(CodeBlockNoLang) {
-    Markup st;
-    st.add_code_block("hello");
-    EXPECT_EQ(st.as_markdown(), "```\nhello\n```");
-}
-
-TEST_CASE(BulletListSimple) {
-    Markup st;
-    auto& list = st.add_bullet_list();
-    list.add_item().add_paragraph().append_text("one");
-    list.add_item().add_paragraph().append_text("two");
-    list.add_item().add_paragraph().append_text("three");
-    EXPECT_EQ(st.as_markdown(), "- one\n- two\n- three");
-}
-
-TEST_CASE(BulletListFormatted) {
-    Markup st;
-    auto& list = st.add_bullet_list();
-    list.add_item().add_paragraph().append_text("bold", Paragraph::Kind::Bold);
-    list.add_item().add_paragraph().append_text("code", Paragraph::Kind::InlineCode);
-    EXPECT_EQ(st.as_markdown(), "- **bold**\n- `code`");
-}
-
-TEST_CASE(BulletListMultiline) {
-    Markup st;
-    auto& list = st.add_bullet_list();
-    list.add_item().add_paragraph().append_text("line1\nline2");
-    auto md = st.as_markdown();
-    EXPECT_NE(md.find("- line1\n  line2"), std::string::npos);
-}
-
-TEST_CASE(BlockSeparation) {
-    Markup st;
-    st.add_paragraph().append_text("first");
-    st.add_paragraph().append_text("second");
-    auto md = st.as_markdown();
-    EXPECT_NE(md.find("first\n"), std::string::npos);
-    EXPECT_NE(md.find("second"), std::string::npos);
-    EXPECT_EQ(md.find("firstsecond"), std::string::npos);
-}
-
-TEST_CASE(ParagraphThenList) {
-    Markup st;
-    st.add_paragraph().append_text("Parameters:");
-    auto& list = st.add_bullet_list();
-    list.add_item().add_paragraph().append_text("int x", Paragraph::Kind::InlineCode);
-    auto md = st.as_markdown();
-    EXPECT_EQ(md.find("Parameters:- "), std::string::npos);
-    EXPECT_EQ(md.find("Parameters:-"), std::string::npos);
-    EXPECT_NE(md.find("Parameters:"), std::string::npos);
-    EXPECT_NE(md.find("- `int x`"), std::string::npos);
-}
-
-TEST_CASE(HeadingThenRuler) {
-    Markup st;
-    st.add_heading(3).append_text("title");
-    st.add_ruler();
-    st.add_paragraph().append_text("body");
-    auto md = st.as_markdown();
-    EXPECT_NE(md.find("### title\n"), std::string::npos);
-    EXPECT_NE(md.find("---"), std::string::npos);
-    EXPECT_NE(md.find("body"), std::string::npos);
-}
-
-TEST_CASE(TripleNewlineCollapse) {
-    Markup st;
-    st.add_paragraph().append_text("a\n\n\n\nb");
-    auto md = st.as_markdown();
-    EXPECT_EQ(md.find("\n\n\n"), std::string::npos);
-}
-
-TEST_CASE(ClonePreservesHeading) {
-    Markup st;
-    st.add_heading(2).append_text("Title");
-    Markup copy = st;
-    auto md = copy.as_markdown();
-    EXPECT_NE(md.find("## Title"), std::string::npos);
-}
-
-TEST_CASE(NewlineChar) {
-    Markup st;
-    auto& p = st.add_paragraph();
-    p.append_text("line1");
-    p.append_newline_char();
-    p.append_text("line2");
-    auto md = st.as_markdown();
-    EXPECT_NE(md.find("line1"), std::string::npos);
-    EXPECT_NE(md.find("line2"), std::string::npos);
-}
-
-TEST_CASE(FullHoverLike) {
-    Markup st;
-    st.add_heading(3).append_text("function").append_text("add", Paragraph::Kind::InlineCode);
-    st.add_ruler();
-    st.add_paragraph().append_text("\xe2\x86\x92").append_text("int", Paragraph::Kind::InlineCode);
-    st.add_paragraph().append_text("Parameters:");
-    auto& params = st.add_bullet_list();
-    params.add_item().add_paragraph().append_text("int a", Paragraph::Kind::InlineCode);
-    params.add_item().add_paragraph().append_text("int b", Paragraph::Kind::InlineCode);
-    st.add_ruler();
-    st.add_code_block("int add(int a, int b);\n", "cpp");
-
-    auto md = st.as_markdown();
-
-    EXPECT_NE(md.find("### function `add`"), std::string::npos);
-    EXPECT_NE(md.find("---"), std::string::npos);
-    EXPECT_NE(md.find("\xe2\x86\x92 `int`"), std::string::npos);
-    EXPECT_NE(md.find("Parameters:"), std::string::npos);
-    EXPECT_NE(md.find("- `int a`"), std::string::npos);
-    EXPECT_NE(md.find("- `int b`"), std::string::npos);
-    EXPECT_NE(md.find("```cpp"), std::string::npos);
-
-    EXPECT_EQ(md.find("`int`Parameters"), std::string::npos);
-    EXPECT_EQ(md.find("Parameters:- "), std::string::npos);
-}
-
-};  // TEST_SUITE(Markup)
-
-}  // namespace
-
-}  // namespace clice::testing

tests/unit/support/structed_text_tests.cpp

@@ -0,0 +1,121 @@
+#include "test/test.h"
+#include "support/format.h"
+#include "support/structed_text.h"
+
+namespace clice::testing {
+
+namespace {
+
+TEST_SUITE(StructedText) {
+
+TEST_CASE(Paragraph) {
+    constexpr const char* cb =
+        R"c(// Without processing, recommended
+char *longestPalindrome_solv2(const char *s) {
+    int len = strlen(s);
+    int max_start = 0;
+    int max_len = 0;
+    for (int i = 0; i < len; ++i) {
+        // j = 0, max_len is odd
+        // j = 1, max_len is even
+        for (int j = 0; j <= 1; ++j) {
+            int l = i;
+            int r = i + j;
+
+            // expand the range from center
+            while (l >= 0 && r < len && s[l] == s[r]) {
+                --l;
+                ++r;
+            }
+
+            ++l;
+            --r;
+
+            if (max_len < r - l + 1) {
+                max_len = r - l + 1;
+                max_start = i;
+            }
+        }
+    }
+    char *res = (char *)malloc((max_len + 1) * sizeof(char));
+    memcpy(res, s + max_start, max_len);
+    res[max_len] = '\0';
+    return res;
+}
+)c";
+    StructedText st;
+    st.add_paragraph().append_text("CodeBlock Example:").append_newline_char();
+    st.add_code_block(cb, "c");
+    auto& para = st.add_paragraph();
+    para.append_text("para1").append_newline_char();
+    /// std::println("{}", st.as_markdown());
+}
+
+TEST_CASE(BulletList) {
+    StructedText st;
+    st.add_bullet_list().add_item().add_paragraph().append_text("Item1");
+    st.add_bullet_list().add_item().add_paragraph().append_text("Item2",
+                                                                Paragraph::Kind::InlineCode);
+    st.add_bullet_list().add_item().add_paragraph().append_text("Item3", Paragraph::Kind::Bold);
+    st.add_bullet_list().add_item().add_paragraph().append_text("Item4", Paragraph::Kind::Italic);
+    st.add_bullet_list().add_item().add_paragraph().append_text("Item5",
+                                                                Paragraph::Kind::Strikethough);
+    /// std::println("{}", st.as_markdown());
+}
+
+TEST_CASE(FullText) {
+    StructedText st;
+    st.add_heading(3)
+        .append_text("function")
+        .append_text("test_bar", Paragraph::Kind::InlineCode)
+        .append_newline_char()
+        .append_text("Provided by:")
+        .append_text("`foo/bar/baz.h`");
+    st.add_ruler();
+    st.add_paragraph()
+        .append_text("→")
+        .append_text("int", Paragraph::Kind::InlineCode)
+        .append_newline_char();
+    st.add_paragraph().append_text("Paramaters:", Paragraph::Kind::Bold).append_newline_char();
+    auto& params = st.add_bullet_list();
+    params.add_item()
+        .add_paragraph()
+        .append_text("int foo", Paragraph::Kind::InlineCode)
+        .append_text("doc for foo\ndoc for foo line2");
+    params.add_item()
+        .add_paragraph()
+        .append_text("char** bar", Paragraph::Kind::InlineCode)
+        .append_text("doc for bar");
+    params.add_item()
+        .add_paragraph()
+        .append_text("char** baz", Paragraph::Kind::InlineCode)
+        .append_text("doc for baz");
+    st.add_paragraph().append_text(R"md(
+brief block
+brief line2
+    a b c d e f
+    ~~~~^
+This is *Italic* **Bold** ~~Striketough~~, `InlineCode`
+)md");
+    st.add_ruler();
+    st.add_paragraph().append_text("Details:", Paragraph::Kind::Bold).append_newline_char();
+    auto& details = st.add_bullet_list();
+    details.add_item().add_paragraph().append_text("Detail1: blah blah...");
+    details.add_item().add_paragraph().append_text("Detail2: blah blah...\n    Line2: ......");
+    details.add_item().add_paragraph().append_text("Detail3: blah blah...");
+    st.add_ruler();
+    st.add_paragraph().append_text("Details:", Paragraph::Kind::Bold).append_newline_char();
+    auto& warnings = st.add_bullet_list();
+    warnings.add_item().add_paragraph().append_text("warnings1: blah blah...");
+    warnings.add_item().add_paragraph().append_text("warnings2: blah blah...\n    Line2: ......");
+    warnings.add_item().add_paragraph().append_text("warnings3: blah blah...");
+    st.add_ruler();
+    st.add_code_block("int test_bar(int foo, char **bar, char **baz);\n", "cpp");
+    /// std::println("{}", st.as_markdown());
+}
+
+};  // TEST_SUITE(StructedText)
+
+}  // namespace
+
+}  // namespace clice::testing

tests/unit/syntax/scan_tests.cpp

@@ -291,6 +291,8 @@ int x;
 
 TEST_SUITE(PreambleComplete) {
 
+// --- #include completeness ---
+
 TEST_CASE(CompleteQuotedInclude) {
     llvm::StringRef content = "#include \"foo.h\"\nint x;";
     auto bound = compute_preamble_bound(content);
@@ -339,7 +341,8 @@ TEST_CASE(MultipleIncludesLastIncomplete) {
     EXPECT_FALSE(is_preamble_complete(content, bound));
 }
 
-// compute_preamble_bound does not include import/export lines in its
+// --- C++20 module statements ---
+// Note: compute_preamble_bound does not include import/export lines in its
 // bound, so we pass manual bounds covering the relevant lines.
 
 TEST_CASE(CompleteImport) {
@@ -378,6 +381,8 @@ TEST_CASE(CompleteExportImport) {
     EXPECT_TRUE(is_preamble_complete(content, 19));
 }
 
+// --- Edge cases ---
+
 TEST_CASE(EmptyPreamble) {
     llvm::StringRef content = "int x;";
     EXPECT_TRUE(is_preamble_complete(content, 0));

tests/unit/test/tester.h

@@ -8,6 +8,7 @@
 #include "test/test.h"
 #include "command/command.h"
 #include "compile/compilation.h"
+#include "feature/feature.h"
 #include "support/logging.h"
 
 namespace clice::testing {
@@ -82,6 +83,12 @@ struct Tester {
 
     LocalSourceRange range(llvm::StringRef name = "", llvm::StringRef file = "");
 
+    LocalSourceRange to_local_range(const kota::ipc::protocol::Range& range) {
+        feature::PositionMapper converter(unit->interested_content(),
+                                          feature::PositionEncoding::UTF8);
+        return LocalSourceRange(*converter.to_offset(range.start), *converter.to_offset(range.end));
+    }
+
     void clear();
 };