LSP Feature Tracking

Single source of truth for which LSP 3.17 capabilities lattice implements and which are planned. Updated every commit that moves a row.

Sequencing for the in-flight polish work (the async-result render-wake fix, server lifecycle state, status surfaces, diagnostics inline/popup) lives in the LSP slice plan (complete — archived); the design contracts are in lsp-architecture.md §12–§15. Note: rows below marked ✅ for $/progress, semanticTokens, and inlayHint cover wire + cache; they only repaint off-keystroke once slice L1 lands.

Status legend:

Phases:

Capability columns:

• Spec § / method — LSP 3.17 spec section + method name.
• Client cap — what we advertise in initialize.capabilities.
• Server cap gating — which ServerCapabilities field gates the feature.
• Phase — when it lands.
• Status — current implementation state.
• Notes — implementation pointers + caveats.

Lifecycle

Document synchronisation

Server → client notifications

Server-initiated requests

Workspace operations

Language features (text document)

Hover / signatures / completion

Navigation

Edits

Decorations / inline information

Logging & introspection (lattice-side)

These aren't LSP methods -- they're lattice's debugging surface around LSP traffic. Tracked here so the matrix is the single source of truth.

Notebook documents

Tracking summary

Counts as of 2026-06-30:

✅ breaks down as 77 LSP protocol methods + 14 lattice-side logging / introspection features. The 11 🚧 rows all ship the wire wrapper + capability probe; only the host-side trigger is deferred (file-op UX, multi-cursor shadow edits, DAP, inlay-interaction UX, or the lsp-types proposed flag — see each row's note). ⏹️ = workspace/didChangeWorkspaceFolders (multi-root, post-1.0); ⛔ = the four notebookDocument/* methods.

Phase rollup:

• 4.1 Foundation: complete. Wire layer + actor/handshake + sync + diagnostics (broadcast → layer → renderer → buffer view + nav) + logging (rings + tracing fan-out + buffer views + commands) + supervisor + App-side wiring + edit-dispatch + open-on-:e all shipped. workspace/configuration surfaces real values from the merged user + project TOML tree via the ConfigurationBus mpsc + oneshot channel and the App::drain_inbound_configuration_requests drain; users place server-namespaced settings under [lsp.<server-id>].
• 4.2 Navigation: complete. ✅ hover (K), definition (gd), declaration (gD), typeDefinition (gy), implementation (gI), references (gr), documentSymbol (:lsp-symbols), workspaceSymbol (:lsp-workspace-symbol), workspaceSymbol/resolve (eager-resolve at fan-out for LSP 3.17+ Nested-WorkspaceLocation symbols), Insert-mode completion (the full 4.2.g surface: shell + buffer-words + LSP source + docs popup + lazy completionItem/resolve + snippets + frequency / per-source priority / per-language overrides + tree-sitter + path source + commit chars + ghost text + cross-source dedup + typed picker routing). All multi-result lookups + :diagnostics route through the unified vertico picker (PickerSource::LspLocations + PickerAction::JumpToLspLocation); picker routing payload is now typed (RoutingPayload enum) so accept dispatch reads variants instead of parsing tab-encoded strings. Tag stack <C-t> pops gd-family drill-downs LIFO; jump list <C-o>/<C-i> walks every cursor jump chronologically. The :complete picker bridge stays as the cmdline-driven peer of the inline popup.
• 4.3 Edits: complete. formatting + rangeFormatting; signatureHelp + Insert-mode autopilot; rename + prepareRename; willSave / didSave notifications; willSaveWaitUntil format-on-save (500ms per-server bound); codeAction + resolve + executeCommand; onTypeFormatting Insert-mode autopilot; workspace/applyEdit (server-initiated) ferries through the ApplyEditBus mpsc + per-request oneshot, drained per-frame by App::drain_inbound_apply_edits. codeAction Commands keep routing through executeCommand (fire-and-forget); applyEdit is the inbound complement servers use after executeCommand callbacks.
• 4.4 Polish: complete. All slices shipped end-to-end where the trigger UX exists today; wire wrappers + capability probes ship for the rest with strong-reason defers on missing host plumbing. 4.4.k (workspace/didChangeConfiguration fan-out from the typed-option cascade) + 4.4.l (file-watcher pipeline: pure parse + match in lattice-lsp::file_watcher + App-side notify::RecommendedWatcher in lattice-ui-tui::app::lsp_watcher fanning out workspace/didChangeWatchedFiles per matching server) + 4.4.m (six wire wrappers for the file-lifecycle hooks + FileOpKind capability discriminator + didCreateFiles trigger on first-save; willCreate / will-Rename / did-Rename / will-Delete / did-Delete triggers strong-reason deferred on missing editor UX) + 4.4.n (client/registerCapability + client/unregisterCapability parse + index into Capabilities.dynamic, republished via ArcSwap<Capabilities>). 4.4.a (window/showMessage + window/logMessage + telemetry/event) + 4.4.b ($/setTrace + $/logTrace + window/showDocument + window/showMessageRequest full picker UX: actionless prompts auto-reply, actionful prompts open a queued one-at-a-time picker with accept/dismiss arms wired through RoutingPayload::AcceptShowMessageAction) + 4.4.c ($/progress accumulator + modeline slot + window/workDoneProgress/cancel + lsp-progress-mode sub-mode + :lsp-progress-cancel) + 4.4.d (supervisor restart_server + per-server backoff window + crash-detection auto-restart via LspActorExited typed event + :lsp-restart wired end-to-end) + 4.4.e (documentHighlight cursor-driven pump + renderer overlay + selectionRange smart-expansion via :lsp-expand-region/:lsp-shrink-region; both sub-modes gate request issuance and paint) + 4.4.f (foldingRange -> FoldMethod::Lsp feeding the existing fold infra; per-tick pump on document-version change; cascades to Syntax when cache is empty; lsp-folding-mode sub-mode gate) + 4.4.g (textDocument/inlayHint viewport-bounded pump with viewport±100 overscan + workspace/inlayHint/refresh + lsp-inlay-hint-mode + renderer's reusable splice_virtual_text_into_spans virtual-text helper; inlayHint/resolve wrapper + capability probe shipped, trigger UX strong-reason deferred) + 4.4.h (textDocument/semanticTokens/full with relative-position decoder + per-kind fg overlay preserving prior bg/underline; lsp-semantic-tokens-mode sub-mode) + 4.4.i (textDocument/semanticTokens/full/delta -- pump prefers delta when the cache has a result_id and the server advertises support; drain splices SemanticTokensEdit operations into the cached raw vec, re-decodes against the legend captured at request time, and falls back to a fresh full request on stale baseline / out-of-bounds splice; workspace/semanticTokens/refresh invalidates the cache for attached buffers; semanticTokens/range wrapper shipped, viewport pump strong-reason deferred) + 4.4.j (textDocument/diagnostic pull pump with previous_result_id threading + Unchanged/Full drain into the shared DiagnosticsLayer + workspace/diagnostic/refresh cache eviction; workspace/diagnostic wrapper shipped, host pump strong-reason deferred) + 4.4.o (lsp.log_level + lsp.log_capacity typed options seed the logger at boot; lsp.trace_io strong-reason deferred -- per-server typed-option shape unwarranted, runtime :lsp-trace covers the case) shipped.
• 4.5 Expansion: complete where the host UX exists; the rest is wire-only with documented strong-reason defers. 4.5.a (callHierarchy) + 4.5.b (typeHierarchy) + 4.5.c (documentLink + gx) + 4.5.d (codeLens + resolve + refresh) + 4.5.e (documentColor + colorPresentation) + 4.5.g (moniker) + 4.5.h workspace/inlineValue/refresh shipped end-to-end. 4.5.f (linkedEditingRange), 4.5.h (inlineValue trigger), and 4.5.i (inlineCompletion) ship wire wrappers + capability probes where lsp-types exposes them; deferred on missing host plumbing (multi-cursor shadow-edit machinery, DAP integration, lsp-types proposed feature flag respectively). 4.5.a (textDocument/prepareCallHierarchy + callHierarchy/incomingCalls + callHierarchy/outgoingCalls; :lsp-incoming-calls / :lsp-outgoing-calls ex-commands) + 4.5.b (textDocument/prepareTypeHierarchy + typeHierarchy/supertypes + typeHierarchy/subtypes; :lsp-supertypes / :lsp-subtypes ex-commands) + 4.5.c (textDocument/documentLink + documentLink/resolve; per-tick cache + gx Normal-mode chord follows the link covering the cursor; file:// -> :e, external -> OS handler) + 4.5.g (textDocument/moniker; :lsp-moniker ex-command).
• post-1.0: notebooks + multi-root workspaces.

When you finish a feature, flip its Status column and update the phase rollup. The matrix is the single source of truth: every LSP feature in lattice has a row here, and every row reflects reality.

4.4 slicing plan

Phase 4.4's items split into six affinity groups. Recommended order is depth-first by group; rationale beside each. Slice ids (4.4.a, 4.4.b, ...) follow the same scheme as 4.2.g.

Group 1 — server → editor messaging

window/showMessage, window/showMessageRequest, window/showDocument, window/logMessage, telemetry/event, $/setTrace (C → S), $/logTrace (S → C). All map onto primitives that already exist (minibuffer notifications, modal pickers, buffer-open, the *lsp:<server>:trace* buffer). Several are partially logged today; flipping them to first-class UI is the highest UX-per-line ratio of the phase.

• 4.4.a -- window/showMessage + window/logMessage + telemetry/event. The three currently-logged items get a proper UI surface (minibuffer for show, opt-in plugin subscription for telemetry).
• 4.4.b -- ✅ shipped. $/setTrace (ServerHandle::set_trace driven by :lsp-trace) + $/logTrace (routes into the trace ring; verbose tail preserved as an indented second record) + window/showDocument (full bus -> drain -> reply pipeline; file:// opens via :e; external delegates to OS handler) + window/showMessageRequest (actionless prompts auto-reply null and surface on the minibuffer; actionful prompts open a one-at-a-time picker -- PickerSource::LspShowMessageRequest, RoutingPayload::AcceptShowMessageAction { request_id, action_index }; accept replies with the chosen MessageActionItem, dismiss replies null. Multiple in- flight requests queue in lsp_show_message_request_queue and open in arrival order). None of the slice's wire surfaces require renderer changes.

Group 2 — server → editor live state

$/progress → modeline progress slot, window/workDoneProgress/cancel, plus the supervisor work needed for :lsp-restart to actually shut down + respawn an actor and replay didOpen to every attached buffer. Stays close to the per-actor DocSync work that's fresh in mind.

• 4.4.c -- ✅ shipped. $/progress accumulator (App-side HashMap<(server_id, token), LspProgressUpdate> fed by LspProgressUpdate typed events the actor emits) + modeline slot (the [lsp:rust] segment grows a [title: message NN%] suffix when active progress matches an attached server) + L ServerHandle::cancel_progress + :lsp-progress-cancel [server] ex-command. lsp-progress-mode minor gates the modeline render per buffer.
• 4.4.d -- ✅ shipped. Supervisor restart_server walks every (workspace, server_id) actor, shuts the old handle, drops the fan-in, re-spawns through actor::spawn, restarts the diagnostics pump, and replays didOpen (empty text -- next edit refills the actor mirror) for every URI bound to the recovered key. Per-server-id rolling-window backoff (MAX_RESTARTS=3 inside a 60s window, `RESTART_BACKOFF_BASE
  • 2^ndelay capped at 30s) gates both:lsp-restartand the auto path. Crash-detection auto-restart subscribes the supervisor task toLspActorExited(emitted by the actor on exit;Clean/Unexpectedreason discriminator) and reuses the same gate + spawn path.RestartReport` returns the re-spawned keys + replayed URIs for the user-facing echo.

Group 3 — new renderer overlays

textDocument/documentHighlight, textDocument/selectionRange, textDocument/inlayHint + inlayHint/resolve + workspace refresh, textDocument/foldingRange. Each adds a renderer layer; can land in any order. Suggested grouping is by infra reuse:

• 4.4.e -- ✅ shipped. documentHighlight: per-tick pump (maybe_request_document_highlight) compares the live cursor to the last-issue cursor; on change, cancels any in-flight request and fires a fresh one. The drain coalesces multiple responses to the latest so a /word search-storm only paints the final result. Renderer overlay paints a soft background tint per DocumentHighlightKind (READ = dim green, WRITE = dim red, TEXT/None = dim blue); composes cleanly with diagnostics underline + visual selection + hlsearch. lsp-document-highlight-mode gates both the request issuance and the renderer paint (mode-off clears stale state so the overlay disappears immediately). selectionRange: :lsp-expand-region / :lsp-shrink-region ex-commands. First expand fires the request; the linked-list response is flattened innermost-first into App::lsp_selection_chain. Subsequent invocations step lsp_selection_chain_index outward (expand) / inward (shrink) and reseat the Visual selection. Cache invalidates when the cursor moves outside the innermost range or the buffer changes. Shrink at index 0 exits Visual; expand past outermost echoes "outermost". lsp-selection-range-mode gates the request issuance.
• 4.4.f -- ✅ shipped. FoldMethod::Lsp added to lattice-core::folding (label lsp, appended to :set foldmethod=<Tab> enumeration). ServerHandle::folding_range
  • supports_folding_range capability probe. Per-tick pump (maybe_request_folding_range) fires on document-version change; drain seats LspFoldsCache and triggers recompute_folds. Identity hash combines start_line + end_line + kind discriminant so closed-state carries across re-fetches that return the same logical fold. Cascade to Syntax (which itself cascades to markdown / indent) keeps the fold list non-empty while the server is slow or doesn't advertise the capability. lsp-folding-mode is coupled to the foldmethod option: activating the mode (direct :lsp-folding-mode toggle or the lsp-mode cascade) stashes the buffer's prior foldmethod and swaps it to lsp; deactivating restores the stash. So :lsp-folding-mode is the one-touch on/off for the LSP fold provider -- the mode and the option stay coherent. Cascade list in (de)activate_lsp_sub_modes_for updated to include the modes added in 4.4.c (lsp-progress-mode), 4.4.e (lsp-document-highlight-mode, lsp-selection-range-mode), and 4.4.f (lsp-folding-mode) -- the umbrella now cascades all 13 sub-modes.
• 4.4.g -- ✅ shipped (inlayHint/resolve deferred). textDocument/inlayHint + workspace/inlayHint/refresh
  • new lsp-inlay-hint-mode sub-mode cascaded by LspMode::implies(). Renderer infrastructure: a generic splice_virtual_text_into_spans(spans, byte_offset, text, style) helper splits the span at the boundary (or inserts cleanly between spans). Used by the inlay-hint pass; reusable by future virtual-text overlays (inline- value, inline-completion). Cache keyed by (BufferId, doc_version) with refresh-event-driven invalidation. The lazy inlayHint/resolve path is deferred until the hint-tooltip UX lands (servers must tolerate clients that don't resolve, per spec).

Group 4 — semantic tokens

textDocument/semanticTokens/full + /delta + /range, workspace/semanticTokens/refresh. Most complex single feature in 4.4: relative-position varint encoding, modifier bitmask, layered highlight resolution against tree-sitter. Stays standalone so the tree-sitter highlight fast paths don't churn under unrelated changes.

• 4.4.h -- ✅ shipped. textDocument/semanticTokens/full end-to-end: ServerHandle::semantic_tokens_full request wrapper + capability probe + legend accessors (the per-server token-type / token-modifier names captured at handshake). Per-tick pump on doc-version change; decoder walks the relative-position stream into absolute DecodedSemanticToken { line, start_char, length, token_type, modifiers }. Renderer's apply_semantic_token_overlay repaints the foreground within each token's byte range while preserving the prior span's bg / underline / reverse so the visual selection, hlsearch, and diagnostic-underline overlays layer cleanly on top of LSP-colored text. Kind → hue mapping covers the LSP-standard set (keyword, type, function, string, number, comment, operator, variable, namespace); modifiers fold into the style (deprecated → strike-through; readonly/static → italic; defaultLibrary → dim). lsp-semantic-tokens-mode sub-mode gates request issuance and paint.
• 4.4.i -- ✅ shipped (range pump strong-reason deferred -- see the matrix row above). semanticTokens/full/delta: pump prefers delta when the cache has a result_id and the server advertises delta = true in its options; falls back to full otherwise. LspSemanticTokensCache grew a raw_data: Vec<lsp_types::SemanticToken> field alongside the decoded view so the drain can splice SemanticTokensEdit { start, delete_count, data } operations in place (via the apply_semantic_token_edits helper) before re-decoding through the legend captured at request time. Stale baselines (the cache's result_id no longer matches the delta's previous_result_id) and out-of-bounds splices evict the cache and let the next pump issue a clean semanticTokens/full request. workspace/semanticTokens/refresh lands the same shape as workspace/inlayHint/refresh: actor replies null inline + publishes LspSemanticTokensRefresh; the App's drain_semantic_tokens_refresh drops the cache (including the cached result_id) for every buffer attached to the requesting server. Workspace-side advertisement (semantic_tokens.refresh_support = true) is in client_capabilities so servers know we honour the request. semanticTokens/range ships only as a wrapper + capability probe; the v1 pump uses full + delta and ignores range. Viewport- aware fetching is a follow-up that swaps the pump strategy without re-touching the wire path.

Group 5 — pull-based + workspace integration

Pull diagnostics, configuration push, file watchers. The largest single dependency surface in 4.4 (the notify crate) lands here.

• 4.4.j -- ✅ shipped (workspace pull strong-reason deferred -- see the matrix row). textDocument/diagnostic per-tick pump fires when lsp-diagnostics-mode is on AND the active server advertises pull AND doc-version changed; threads previous_result_id so Unchanged responses are cheap. LspPullDiagnosticsCache { document_version, result_id } keys the staleness bookkeeping per buffer; Full reports flow into DiagnosticsLayer via the same DiagnosticEvent shape push uses (so the layer / :diagnostics view / modeline summary don't need to know whether the diagnostics arrived push or pull). workspace/diagnostic/refresh evicts the cache for every attached buffer so the next tick re-pulls with no previous_result_id and forces a Full. Client advertises text_document.diagnostic = { related_document_support = true } + workspace.diagnostic = { refresh_support = true }. Wire wrapper workspace_diagnostic ships callable; the host pump is deferred because the :diagnostics view fed off the bus assumes open-file scope, and the rework to merge a one- off workspace pull is its own slice. Niche today (servers that only emit on workspace pull and never push are rare); revisit if a real corpus needs it.
• 4.4.k -- ✅ shipped. workspace/didChangeConfiguration fan-out from the §5.12 OptionChanged cascade. The cascade (apply_option_cascade) calls a pure lsp_server_scope(name) -> Option<&str> helper to discriminate server-scoped lsp.<server>.<key> writes from host-side lsp.<host-knob> writes; only server-scoped writes fan out. fan_out_did_change_configuration(server_id) serialises the lsp.<server> JSON subtree from the merged TOML and notifies every matching running actor (cross-workspace too -- config is global). Pairs cleanly with the existing inbound workspace/configuration path; servers that pull see the same subtree the push delivered.
• 4.4.l -- ✅ shipped. File watchers + workspace/didChangeWatchedFiles. Pure parse + match in lattice-lsp::file_watcher (compiles each FileSystemWatcher glob into a shared globset::GlobSet per server, honours WatchKind defaults + RelativePattern base anchoring); App-side service in lattice-ui-tui::app::lsp_watcher owns a notify::RecommendedWatcher lazily spawned when at least one server has registered watchers. Per-tick: refresh the watcher's subscribed paths to the union of running-actor workspace roots (per-server fingerprint short-circuit skips recompile) + drain queued fs events, classify them into LSP FileChangeType, match per server, and batch into one workspace/didChangeWatchedFiles notification per matching server. Debounce + target//node_modules/ ignore globs are follow-up work.
• 4.4.m -- ✅ wire layer + didCreateFiles trigger shipped; remaining triggers strong-reason deferred. All six wire wrappers (will_create_files, did_create_files, will_rename_files, did_rename_files, will_delete_files, did_delete_files) on ServerHandle + matching supports_*_files probes via new FileOpKind discriminator
  • Capabilities::file_operations_options. Client advertises interest in all six hooks under workspace.file_operations. Trigger: App::save_blocking detects first-save (path didn't exist pre-save) and fans out workspace/didCreateFiles to every attached server advertising the capability. The other five triggers are deferred on missing editor UX (in-place file rename, editor-driven delete) or missing pre-save blocking-edits infrastructure (willCreate's atomic WorkspaceEdit application). The wrappers ship ahead so future trigger work plugs into a stable surface.

Group 6 — capability + config polish

• 4.4.n -- ✅ shipped. Dynamic registration tracking. New lattice-lsp::dynamic_registration module owns the DynamicRegistration { id, method, register_options } record
  • the DynamicRegistry { by_id, by_method } two-way index (HashMap<id, registration> + HashMap<method, Vec>) so register is O(1), unregister-by-id is O(1), and the "is method X registered?" probe is O(1). Capabilities grew a pub dynamic: DynamicRegistry field; with_dynamic_mut clones the snapshot and mutates the registry through a closure so the actor can publish without touching the rest of the struct. HandleInner.capabilities flipped from Arc<Capabilities> to Arc<ArcSwap<Capabilities>> so reads are lock-free and writes are a single atomic swap; ServerHandle::capabilities() loads a fresh Arc per call. The actor parses RegistrationParams / UnregistrationParams inline (before falling through to handle_server_request), mutates the local snapshot, and stores into the cell -- malformed params log + still reply null so the wire stays unblocked. Every supports_* probe that gates a likely-dynamic feature (hover, definition, references, document_symbol, workspace_symbol, completion, formatting / range / signatureHelp, rename, code_action, document_highlight, selection_range, folding_range, inlay_hint) ORs in dynamic.has(method). Client advertises workspace.didChangeWatchedFiles.dynamic_registration = true (+ relative_pattern_support) so servers register file- watcher patterns lazily after handshake -- 4.4.l consumes those DidChangeWatchedFilesRegistrationOptions blobs from the registry.
  • 4.4.o -- lsp.toml log keys (log_level, log_capacity, trace_io) wired through the §5.12 typed-options layer at startup; today only the runtime :lsp-log-level / :lsp-trace paths exist.

  Trade-offs flagged

  • Semantic tokens (Group 4) ahead of overlays (Group 3) is defensible if you'd rather get the highest-impact polish in first, but it's also the highest churn risk -- highlight layering interacts with tree-sitter and the renderer's fast paths. Default order keeps it after the overlays so the renderer changes that group introduces are stable before semantic tokens layer on top.
  • File watchers (Group 5) earlier as standalone infra would unlock non-LSP features (markdown live-preview, etc.) sooner, but they're standalone enough to stay where they are without blocking anything.
  • :lsp-restart (4.4.d) could fold into 4.4.c as a single "supervisor lifecycle" slice, but the two touch different surfaces (modeline rendering vs. actor lifecycle) and read cleaner as separate commits.