java-functional-lsp 0.12.0__tar.gz → 0.13.0__tar.gz

{java_functional_lsp-0.12.0 → java_functional_lsp-0.13.0}/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "java-functional-lsp",
   "description": "Java LSP with functional programming rules enforcement — null safety, immutability, no exceptions, Spring best practices. Wraps jdtls for full Java language support.",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "lspServers": {
     "java-functional": {
       "command": "java-functional-lsp",

{java_functional_lsp-0.12.0 → java_functional_lsp-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: java-functional-lsp
-Version: 0.12.0
+Version: 0.13.0
 Summary: Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions
 Project-URL: Homepage, https://github.com/aviadshiber/java-functional-lsp
 Project-URL: Repository, https://github.com/aviadshiber/java-functional-lsp
@@ -229,6 +229,7 @@ moving on. Fix any type errors or missing imports immediately.
 | "java-functional-lsp not found" | Run `brew install aviadshiber/tap/java-functional-lsp` |
 | Plugin not active | Run `claude plugin list` to verify, then `/reload-plugins` |
 | Diagnostics slow on first open | Normal — tree-sitter parses on first load, then incremental |
+| Java errors show up one tool call after the edit | Claude Code doesn't wait for LSP diagnostics after Edit/Write ([anthropics/claude-code#93321](https://github.com/anthropics/claude-code/issues/93321)). The plugin's hook waits up to 3s for them; if jdtls is slower (large projects), raise `JAVA_FUNCTIONAL_LSP_HOOK_WAIT` (max 4). See [Fresh jdtls diagnostics after edits](#fresh-jdtls-diagnostics-after-edits) |
 
 ### Other Editors
 
@@ -334,6 +335,33 @@ The jdtls Eclipse workspace index is cached in `~/.cache/jdtls-data/`. Warm star
 
 To force a clean rebuild: `rm -rf ~/.cache/jdtls-data/`
 
+### Fresh jdtls diagnostics after edits
+
+jdtls re-validates a file 0.4–2.4s after the last edit to *any* file, and its results carry no document version. So after an edit, java-functional-lsp holds back jdtls diagnostics for that file until jdtls publishes again, rather than re-sending the previous edit's results as if they were current ([#109](https://github.com/aviadshiber/java-functional-lsp/issues/109)):
+
+| Mode | Default for | After an edit |
+|------|-------------|---------------|
+| `custom-first` | Claude Code | Custom diagnostics publish at once, without jdtls errors; the full set follows when jdtls has re-validated |
+| `hold-all` | Other editors | Nothing is published for the file until jdtls has re-validated (no flickering squiggles) |
+| `off` | — | Previous behavior: custom diagnostics plus the last known jdtls diagnostics after 150ms |
+
+With Claude Code two more things happen:
+
+- **The plugin's PostToolUse hook waits for fresh results.** Claude Code attaches diagnostics as soon as its PostToolUse hooks finish, without waiting for the server ([anthropics/claude-code#93321](https://github.com/anthropics/claude-code/issues/93321)). The server records when it last published final diagnostics for each file, and `hooks/post_tool_lint.py` waits until that is newer than the edit (at most `JAVA_FUNCTIONAL_LSP_HOOK_WAIT` seconds, default 3, max 4), so jdtls's result for the edit arrives in the same tool result. The markers live in a private per-user temp directory and contain only a timestamp.
+- **jdtls gets a didSave after each edit.** Claude Code writes the file itself; when the edited buffer matches the file on disk, the server forwards a didSave. Without it, jdtls can re-check dependent files against the old version of the edited one (e.g. a caller keeps reporting a constructor's old arity) and never correct them.
+
+If jdtls doesn't publish in time (3s after the last edit, stretched when jdtls is slow, 10s at most), the last known jdtls diagnostics are used. Files whose module is still being imported, and files matched by `java.diagnostic.filter`, are never held. While you edit the same file in quick succession, its diagnostics update only once the burst settles.
+
+Environment variables:
+
+| Variable | Values | Effect |
+|----------|--------|--------|
+| `JAVA_FUNCTIONAL_LSP_DIAG_HOLD` | `custom-first`, `hold-all`, `off` | Overrides the mode above; `off` restores the previous behavior |
+| `JAVA_FUNCTIONAL_LSP_HOOK_WAIT` | seconds, `0`–`4` (default `3`) | How long the Claude Code PostToolUse hook waits for fresh jdtls diagnostics; `0` disables the wait |
+| `JAVA_FUNCTIONAL_LSP_LOG_LEVEL` | `DEBUG`, `INFO` (default), `WARNING` | Verbosity of java-functional-lsp's own logs; `DEBUG` adds one line per publish decision (file name, trigger, counts). Library logging (pygls) is unaffected — note that pygls already logs the JSON it sends, including diagnostic messages, at `INFO` |
+
+The log reports `jdtls freshness: released=… too_early=… timeout=… late_correction=…` every 100 decisions and when jdtls stops. Repeated `timeout` lines mean jdtls is slow or stuck on that module. A growing `late_correction` count means jdtls results were released too early.
+
 ### Suppressing jdtls diagnostics
 
 For project-specific jdtls false positives (e.g., annotation processor methods, MapStruct mappers), use `suppressJdtlsPatterns` to add custom regex filters:

{java_functional_lsp-0.12.0 → java_functional_lsp-0.13.0}/README.md

@@ -201,6 +201,7 @@ moving on. Fix any type errors or missing imports immediately.
 | "java-functional-lsp not found" | Run `brew install aviadshiber/tap/java-functional-lsp` |
 | Plugin not active | Run `claude plugin list` to verify, then `/reload-plugins` |
 | Diagnostics slow on first open | Normal — tree-sitter parses on first load, then incremental |
+| Java errors show up one tool call after the edit | Claude Code doesn't wait for LSP diagnostics after Edit/Write ([anthropics/claude-code#93321](https://github.com/anthropics/claude-code/issues/93321)). The plugin's hook waits up to 3s for them; if jdtls is slower (large projects), raise `JAVA_FUNCTIONAL_LSP_HOOK_WAIT` (max 4). See [Fresh jdtls diagnostics after edits](#fresh-jdtls-diagnostics-after-edits) |
 
 ### Other Editors
 
@@ -306,6 +307,33 @@ The jdtls Eclipse workspace index is cached in `~/.cache/jdtls-data/`. Warm star
 
 To force a clean rebuild: `rm -rf ~/.cache/jdtls-data/`
 
+### Fresh jdtls diagnostics after edits
+
+jdtls re-validates a file 0.4–2.4s after the last edit to *any* file, and its results carry no document version. So after an edit, java-functional-lsp holds back jdtls diagnostics for that file until jdtls publishes again, rather than re-sending the previous edit's results as if they were current ([#109](https://github.com/aviadshiber/java-functional-lsp/issues/109)):
+
+| Mode | Default for | After an edit |
+|------|-------------|---------------|
+| `custom-first` | Claude Code | Custom diagnostics publish at once, without jdtls errors; the full set follows when jdtls has re-validated |
+| `hold-all` | Other editors | Nothing is published for the file until jdtls has re-validated (no flickering squiggles) |
+| `off` | — | Previous behavior: custom diagnostics plus the last known jdtls diagnostics after 150ms |
+
+With Claude Code two more things happen:
+
+- **The plugin's PostToolUse hook waits for fresh results.** Claude Code attaches diagnostics as soon as its PostToolUse hooks finish, without waiting for the server ([anthropics/claude-code#93321](https://github.com/anthropics/claude-code/issues/93321)). The server records when it last published final diagnostics for each file, and `hooks/post_tool_lint.py` waits until that is newer than the edit (at most `JAVA_FUNCTIONAL_LSP_HOOK_WAIT` seconds, default 3, max 4), so jdtls's result for the edit arrives in the same tool result. The markers live in a private per-user temp directory and contain only a timestamp.
+- **jdtls gets a didSave after each edit.** Claude Code writes the file itself; when the edited buffer matches the file on disk, the server forwards a didSave. Without it, jdtls can re-check dependent files against the old version of the edited one (e.g. a caller keeps reporting a constructor's old arity) and never correct them.
+
+If jdtls doesn't publish in time (3s after the last edit, stretched when jdtls is slow, 10s at most), the last known jdtls diagnostics are used. Files whose module is still being imported, and files matched by `java.diagnostic.filter`, are never held. While you edit the same file in quick succession, its diagnostics update only once the burst settles.
+
+Environment variables:
+
+| Variable | Values | Effect |
+|----------|--------|--------|
+| `JAVA_FUNCTIONAL_LSP_DIAG_HOLD` | `custom-first`, `hold-all`, `off` | Overrides the mode above; `off` restores the previous behavior |
+| `JAVA_FUNCTIONAL_LSP_HOOK_WAIT` | seconds, `0`–`4` (default `3`) | How long the Claude Code PostToolUse hook waits for fresh jdtls diagnostics; `0` disables the wait |
+| `JAVA_FUNCTIONAL_LSP_LOG_LEVEL` | `DEBUG`, `INFO` (default), `WARNING` | Verbosity of java-functional-lsp's own logs; `DEBUG` adds one line per publish decision (file name, trigger, counts). Library logging (pygls) is unaffected — note that pygls already logs the JSON it sends, including diagnostic messages, at `INFO` |
+
+The log reports `jdtls freshness: released=… too_early=… timeout=… late_correction=…` every 100 decisions and when jdtls stops. Repeated `timeout` lines mean jdtls is slow or stuck on that module. A growing `late_correction` count means jdtls results were released too early.
+
 ### Suppressing jdtls diagnostics
 
 For project-specific jdtls false positives (e.g., annotation processor methods, MapStruct mappers), use `suppressJdtlsPatterns` to add custom regex filters:

java_functional_lsp-0.13.0/hooks/post_tool_lint.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""PostToolUse hook: lint a .java file after Edit/Write and surface violations to Claude.
+
+Reads the Claude Code PostToolUse JSON payload on stdin, runs java-functional-lsp
+on the edited file, and emits diagnostics as ``hookSpecificOutput.additionalContext``
+so the agent sees them in context and can fix them immediately (issue #70). Before
+returning it waits (bounded) for the running language server to publish fresh jdtls
+diagnostics for the file, so Claude Code attaches current ones to this edit (#109).
+
+Failure-safe by design: every path exits 0 — a linter problem must never break the
+editing session. Prefers the fast in-process import; falls back to the CLI when the
+package is not importable under this interpreter.
+"""
+
+from __future__ import annotations
+
+import getpass
+import hashlib
+import json
+import os
+import signal
+import stat
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+TIMEOUT_SECONDS = 5  # hard cap; single-file analysis is typically <200ms
+MAX_DIAGNOSTICS = 25  # keep additionalContext bounded
+POLL_SECONDS = 0.05
+DEFAULT_WAIT_SECONDS = 3.0
+MAX_WAIT_SECONDS = 4.0
+EXIT_MARGIN_SECONDS = 0.5  # finish well before SIGALRM so the lint output is printed
+MARKER_MAX_BYTES = 128
+
+
+def _fresh_wait_seconds() -> float:
+    try:
+        wait = float(os.environ.get("JAVA_FUNCTIONAL_LSP_HOOK_WAIT", DEFAULT_WAIT_SECONDS))
+    except ValueError:
+        return DEFAULT_WAIT_SECONDS
+    return max(0.0, min(wait, MAX_WAIT_SECONDS))
+
+
+def _user() -> str:
+    try:
+        return getpass.getuser()
+    except Exception:
+        return str(os.getuid()) if hasattr(os, "getuid") else "user"
+
+
+def _marker_path(file_path: str) -> Path:
+    """Must match java_functional_lsp.freshness_marker.marker_path (a test checks)."""
+    digest = hashlib.sha256(os.path.realpath(file_path).encode()).hexdigest()[:32]
+    return Path(tempfile.gettempdir()) / f"java-functional-lsp-{_user()}" / "fresh" / digest
+
+
+def _owned(st: os.stat_result) -> bool:
+    return not hasattr(os, "getuid") or st.st_uid == os.getuid()
+
+
+def _read_marker(marker: Path) -> tuple[int, str] | None:
+    """(server pid, content digest), or None unless the marker and its dirs are private and ours."""
+    try:
+        for level in (marker.parent.parent, marker.parent):
+            st = os.lstat(level)
+            if not stat.S_ISDIR(st.st_mode) or not _owned(st) or st.st_mode & 0o077:
+                return None
+        fd = os.open(marker, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0))
+        try:
+            st = os.fstat(fd)
+            if not stat.S_ISREG(st.st_mode) or not _owned(st):
+                return None
+            pid, digest = os.read(fd, MARKER_MAX_BYTES).decode().split()
+        finally:
+            os.close(fd)
+        server_pid = int(pid)
+        return (server_pid, digest) if server_pid > 0 else None  # kill(0|-n, 0) targets groups
+    except (OSError, ValueError):
+        return None
+
+
+def _server_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
+def _wait_for_fresh_diagnostics(path: Path, budget: float) -> None:
+    """Wait until the language server has published final diagnostics for this edit.
+
+    Claude Code attaches LSP diagnostics right after PostToolUse hooks finish, but jdtls
+    needs 0.4-2.4s to re-validate (#109). On each final publish the server records its pid
+    and a hash of the content it analyzed; waiting until that hash matches the file puts
+    fresh results in this tool result. No marker, or a dead server, means nobody will
+    publish — don't wait.
+    """
+    marker = _marker_path(str(path))
+    current = _read_marker(marker)
+    if current is None or not _server_alive(current[0]):
+        return
+    want = hashlib.sha256(path.read_bytes()).hexdigest()
+    deadline = time.monotonic() + min(_fresh_wait_seconds(), budget)
+    while current is not None and current[1] != want and time.monotonic() < deadline:
+        time.sleep(POLL_SECONDS)
+        current = _read_marker(marker)
+
+
+def _lint_in_process(path: Path) -> list[str] | None:
+    """Lint via direct import. Returns None if the package isn't importable here."""
+    try:
+        from java_functional_lsp.analyzers.base import is_excluded
+        from java_functional_lsp.cli import check_file, format_diagnostic, load_config
+    except ImportError:
+        return None
+    config = load_config(path)
+    if is_excluded(path.as_posix(), config.get("excludes", [])):
+        return []
+    return [format_diagnostic(path, d) for d in check_file(path, config)]
+
+
+def _lint_via_cli(path: Path) -> list[str]:
+    """Fallback: shell out to the installed CLI (exit 1 + stdout lines on violations)."""
+    proc = subprocess.run(
+        ["java-functional-lsp", "check", str(path)],
+        capture_output=True,
+        text=True,
+        timeout=TIMEOUT_SECONDS,
+        check=False,  # exit 1 just means violations were found
+    )
+    return [ln for ln in proc.stdout.splitlines() if ln.strip()]
+
+
+def main() -> None:
+    started = time.monotonic()
+    hook_input = json.load(sys.stdin)
+    file_path = (hook_input.get("tool_input") or {}).get("file_path", "")
+    if not file_path.endswith(".java"):
+        return  # silent no-op
+    path = Path(file_path)
+    if not path.is_file():
+        return  # tool call may have failed or the file was deleted
+
+    lines = _lint_in_process(path)
+    if lines is None:
+        lines = _lint_via_cli(path)
+    try:
+        budget = TIMEOUT_SECONDS - EXIT_MARGIN_SECONDS - (time.monotonic() - started)
+        _wait_for_fresh_diagnostics(path, budget=budget)
+    except Exception:
+        pass  # a marker problem must never suppress the lint output below
+    if not lines:
+        return  # clean file: stay silent, no per-edit context noise
+
+    if len(lines) > MAX_DIAGNOSTICS:
+        lines = [*lines[:MAX_DIAGNOSTICS], f"... and {len(lines) - MAX_DIAGNOSTICS} more"]
+    json.dump(
+        {
+            "hookSpecificOutput": {
+                "hookEventName": "PostToolUse",
+                "additionalContext": (
+                    "java-functional-lsp found violations in the file you just edited:\n"
+                    + "\n".join(lines)
+                    + "\nFix each violation now with your next Edit. Do not explain or list them."
+                ),
+            }
+        },
+        sys.stdout,
+    )
+
+
+if __name__ == "__main__":
+    if hasattr(signal, "SIGALRM"):  # POSIX hard runtime cap
+        signal.signal(signal.SIGALRM, lambda *_: sys.exit(0))
+        signal.alarm(TIMEOUT_SECONDS)
+    try:
+        main()
+    except Exception:
+        sys.exit(0)  # hooks must never break the session

{java_functional_lsp-0.12.0 → java_functional_lsp-0.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.12.0"
+version = "0.13.0"
 description = "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions"
 readme = "README.md"
 license = { text = "MIT" }
@@ -65,6 +65,8 @@ python_classes = ["Test*"]
 python_functions = ["test_*"]
 addopts = "--cov=java_functional_lsp --cov-report=term-missing --cov-fail-under=80"
 asyncio_mode = "auto"
+# Safety net so a hung await fails the test instead of the CI job; e2e tests set their own.
+timeout = 120
 markers = [
     "e2e: end-to-end tests that spawn a real jdtls subprocess (require jdtls + Java 21+; skipped when unavailable)",
 ]

{java_functional_lsp-0.12.0 → java_functional_lsp-0.13.0}/src/java_functional_lsp/__init__.py

@@ -1,3 +1,3 @@
 """java-functional-lsp: A Java LSP server enforcing functional programming best practices."""
 
-__version__ = "0.12.0"
+__version__ = "0.13.0"

java_functional_lsp-0.13.0/src/java_functional_lsp/freshness_marker.py

@@ -0,0 +1,78 @@
+"""Per-file "diagnostics are final" markers for the Claude Code PostToolUse hook (#109).
+
+Claude Code collects LSP diagnostics right after its PostToolUse hooks finish, without
+waiting for the server. When the server publishes final diagnostics for a file (fresh
+jdtls results merged in) it records the server pid and a hash of the content it analyzed;
+``hooks/post_tool_lint.py`` waits until the hash matches the file on disk, so the fresh
+set lands in the same tool result. A hash (not a time) means a publish for an older
+version of the file can never satisfy the hook, and the pid lets the hook skip waiting
+when the server that wrote the marker is gone.
+
+The hook keeps its own copy of :func:`marker_path` and of the directory checks (it may run
+without this package importable); tests keep the two in sync.
+"""
+
+from __future__ import annotations
+
+import getpass
+import hashlib
+import os
+import stat
+import tempfile
+from pathlib import Path
+
+#: Written at didOpen: never equals a content hash, so the hook waits for jdtls's first result.
+OPENING = "opening"
+
+_validated: set[Path] = set()
+
+
+def _user() -> str:
+    try:
+        return getpass.getuser()
+    except Exception:  # containers without a passwd entry: KeyError (<3.13) / OSError (3.13+)
+        return str(os.getuid()) if hasattr(os, "getuid") else "user"
+
+
+def marker_dir() -> Path:
+    return Path(tempfile.gettempdir()) / f"java-functional-lsp-{_user()}" / "fresh"
+
+
+def marker_path(file_path: str) -> Path:
+    digest = hashlib.sha256(os.path.realpath(file_path).encode()).hexdigest()[:32]
+    return marker_dir() / digest
+
+
+def content_digest(content: bytes) -> str:
+    return hashlib.sha256(content).hexdigest()
+
+
+def _ensure_private_dir(path: Path) -> bool:
+    """Create *path* if needed; True only for a real directory we own with no group/other access."""
+    path.mkdir(mode=0o700, exist_ok=True)
+    st = os.lstat(path)  # lstat: a symlink is never S_ISDIR
+    if not stat.S_ISDIR(st.st_mode) or (hasattr(os, "getuid") and st.st_uid != os.getuid()):
+        return False
+    if st.st_mode & 0o077:
+        os.chmod(path, 0o700)
+    return True
+
+
+def write_marker(file_path: str, digest: str) -> None:
+    """Record that final diagnostics for *file_path* were published for content *digest*. Never raises."""
+    try:
+        directory = marker_dir()
+        if directory not in _validated:
+            # Check each level before creating below it, so nothing lands behind a
+            # symlink planted in a shared temp dir.
+            if not (_ensure_private_dir(directory.parent) and _ensure_private_dir(directory)):
+                return
+            _validated.add(directory)
+        target = marker_path(file_path)
+        tmp = target.with_name(f"{target.name}.{os.getpid()}.tmp")
+        flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | getattr(os, "O_NOFOLLOW", 0)
+        with os.fdopen(os.open(tmp, flags, 0o600), "w") as f:
+            f.write(f"{os.getpid()} {digest}")
+        os.replace(tmp, target)
+    except Exception:
+        _validated.clear()

{java_functional_lsp-0.12.0 → java_functional_lsp-0.13.0}/src/java_functional_lsp/proxy.py

@@ -57,6 +57,9 @@ _DEFAULT_JDTLS_SETTINGS: dict[str, Any] = {
 #: Java 21"`` before the server even starts.
 _MIN_JDTLS_JAVA_MAJOR = 21
 
+#: Distinct jdtls→client request methods tracked individually; the rest count as "<other>".
+_MAX_DROPPED_METHODS = 50
+
 #: Matches the first version token in ``java -version`` output. Handles:
 #: - modern format: ``openjdk version "21.0.10" 2026-01-20``
 #: - legacy Java 8: ``openjdk version "1.8.0_452"`` (captures ``1``; caller
@@ -788,14 +791,24 @@ def _build_effective_params(
 class JdtlsProxy:
     """Manages a jdtls subprocess and provides async request/notification forwarding."""
 
-    def __init__(self, on_diagnostics: Callable[[str, list[Any]], None] | None = None) -> None:
+    def __init__(
+        self,
+        on_diagnostics: Callable[[str, list[Any]], None] | None = None,
+        uri_key: Callable[[str], str] = lambda uri: uri,
+        on_stopped: Callable[[], None] | None = None,
+    ) -> None:
         self._process: asyncio.subprocess.Process | None = None
         self._reader_task: asyncio.Task[None] | None = None
         self._stderr_task: asyncio.Task[None] | None = None
         self._next_id: int = 1
         self._pending: dict[int, asyncio.Future[Any]] = {}
+        # Keyed by uri_key(uri): jdtls may echo a URI in a different encoding than
+        # the client sent, so lookups must go through the same canonical key.
         self._diagnostics_cache: dict[str, list[Any]] = {}
+        self._uri_key = uri_key
         self._on_diagnostics = on_diagnostics
+        self._on_stopped = on_stopped
+        self._dropped_request_counts: dict[str, int] = {}
         self._available = False
         self._jdtls_capabilities: dict[str, Any] = {}
         # Lazy-start state
@@ -834,7 +847,19 @@ class JdtlsProxy:
 
     def get_cached_diagnostics(self, uri: str) -> list[Any]:
         """Get the latest jdtls diagnostics for a URI."""
-        return list(self._diagnostics_cache.get(uri, []))
+        return list(self._diagnostics_cache.get(self._uri_key(uri), []))
+
+    def _mark_stopped(self) -> None:
+        """Drop state that belongs to the dead jdtls process and notify the owner."""
+        if not self._available and not self._diagnostics_cache:
+            return  # already handled (reader EOF, then stop())
+        self._available = False
+        cached = len(self._diagnostics_cache)
+        self._diagnostics_cache.clear()
+        if cached:
+            logger.info("jdtls stopped: cleared cached diagnostics for %d files", cached)
+        if self._on_stopped:
+            self._on_stopped()
 
     def check_available(self) -> bool:
         """Check if jdtls is on PATH (lightweight, no subprocess started)."""
@@ -929,6 +954,8 @@ class JdtlsProxy:
 
             self._jdtls_capabilities = result.get("capabilities", {})
             logger.info("jdtls initialized (capabilities: %s)", list(self._jdtls_capabilities.keys()))
+            server_info = result.get("serverInfo") or {}
+            logger.info("jdtls server: %s %s", server_info.get("name", "?"), server_info.get("version", "?"))
 
             await self.send_notification("initialized", {})
             self._available = True
@@ -1170,7 +1197,7 @@ class JdtlsProxy:
 
     async def stop(self) -> None:
         """Shutdown jdtls subprocess gracefully."""
-        self._available = False
+        self._mark_stopped()
 
         if self._reader_task and not self._reader_task.done():
             self._reader_task.cancel()
@@ -1258,7 +1285,7 @@ class JdtlsProxy:
                 msg = await read_message(reader)
                 if msg is None:
                     logger.warning("jdtls stdout closed — subprocess may have exited")
-                    self._available = False
+                    self._mark_stopped()
                     break
 
                 self._dispatch_message(msg)
@@ -1266,7 +1293,7 @@ class JdtlsProxy:
             pass
         except Exception as e:
             logger.error("jdtls reader loop error: %s", e)
-            self._available = False
+            self._mark_stopped()
 
     async def _stderr_reader(self, stderr: asyncio.StreamReader) -> None:
         """Background task: log jdtls stderr output for debugging.
@@ -1311,6 +1338,20 @@ class JdtlsProxy:
         elif "method" in msg and "id" not in msg:
             # Notification from jdtls
             self._handle_notification(msg)
+        elif "method" in msg:
+            self._note_dropped_request(str(msg["method"]))
+
+    def _note_dropped_request(self, method: str) -> None:
+        """Count jdtls→client requests the proxy leaves unanswered (method names only, never params)."""
+        method = method[:100]
+        if method not in self._dropped_request_counts and len(self._dropped_request_counts) >= _MAX_DROPPED_METHODS:
+            method = "<other>"
+        count = self._dropped_request_counts.get(method, 0) + 1
+        self._dropped_request_counts[method] = count
+        if count == 1:
+            logger.info("jdtls request %r dropped (no client-side handler)", method)
+        else:
+            logger.debug("jdtls request %r dropped (%d times)", method, count)
 
     def _handle_notification(self, msg: dict[str, Any]) -> None:
         """Handle a notification from jdtls."""
@@ -1320,7 +1361,7 @@ class JdtlsProxy:
         if method == "textDocument/publishDiagnostics":
             uri = params.get("uri", "")
             diagnostics = params.get("diagnostics", [])
-            self._diagnostics_cache[uri] = diagnostics
+            self._diagnostics_cache[self._uri_key(uri)] = diagnostics
             if self._on_diagnostics:
                 self._on_diagnostics(uri, diagnostics)
         # Other notifications (window/logMessage, etc.) are silently ignored