@@ -40,9 +40,9 @@ jobs:
           retention-days: 7
 
   # The SDK targets and releases on Java 17, but Error Prone (which runs NullAway) needs
-  # JDK 21. The parent pom's nullaway profile activates on JDK 21+, so this job is the one
-  # that enforces the @NullMarked packages at ERROR.
-  nullaway:
+  # JDK 21. The parent pom's errorprone profile activates on JDK 21+, so this job is the one
+  # that enforces Error Prone's bug checks and the @NullMarked packages at ERROR.
+  errorprone:
     runs-on: ubuntu-latest
     timeout-minutes: 30
 
@@ -56,7 +56,7 @@ jobs:
           distribution: 'temurin'
           cache: maven
 
-      - name: Build with Maven (NullAway enforced)
+      - name: Build with Maven (Error Prone and NullAway enforced)
         run: ./mvnw -B clean verify
 
   # Issue #14 only reproduced when the JVM was starved of cores: the agent's lock release
 
@@ -95,6 +95,20 @@ Found by the NullAway adoption; each has a test.
 - `AcpSchema.deserializeJsonRpcMessage` threw `NullPointerException` for the JSON `null` literal
   instead of the documented `IllegalArgumentException`.
 
+Found by enabling Error Prone's bug checks; each has a test.
+
+- `StdioAcpClientTransport` read the agent's stdout and stderr in the platform default charset
+  while writing to it in UTF-8. On Java 17 that charset follows the platform (Cp1252 on Windows,
+  US-ASCII under a POSIX locale), so non-ASCII text from the agent arrived garbled. Both are now
+  read as UTF-8.
+- The Streamable HTTP client rejected an initialize response whose `Content-Type` was upper case
+  when the JVM's default locale was Turkish (`"APPLICATION/JSON".toLowerCase()` is
+  `"applıcatıon/json"` there). The client's and the servlet's media-type checks, and the `os.name`
+  check in `AgentParameters`, now lower-case with `Locale.ROOT`.
+- In `acp-agent-support`, a handler method whose result was not the ACP method's response type
+  failed with an opaque `ClassCastException` message; the `INTERNAL_ERROR` now names the method and
+  both types.
+
 ### Build
 
 - Architecture rules (ArchUnit) guard the package structure: acp-core's layers (util and json under the
@@ -108,6 +122,15 @@ Found by the NullAway adoption; each has a test.
   job; the JDK 17 build and release are unchanged. Compilation uses `--release 17`, so a JDK 21 build
   still compiles against the Java 17 API. `.mvn/jvm.config` opens the javac internals Error Prone needs
   (harmless on JDK 17).
+- Error Prone's own bug checks run beside NullAway, at ERROR, in the JDK 21 build. The profile is
+  renamed `errorprone` (from `nullaway`), and so is its CI job. Every check Error Prone enables by
+  default runs, and `failOnWarning` makes its warnings fail the build too (as it does javac's own
+  default warnings, such as use of an API deprecated for removal). One check is disabled as style,
+  `StatementSwitchToExpressionSwitch`. Two more are enabled: `SystemOut`, since anything printed to
+  standard out corrupts a stdio agent's JSON-RPC stream, and `CheckReturnValue` over
+  `reactor.core.publisher`, so a Mono or Flux operator whose result is dropped (and never runs)
+  fails the build; `config/errorprone/reactor-ignorable-results.txt` lists the results that may be
+  dropped, with reasons. Still main sources only, still JDK 21+ only.
 
 ## [0.18.0] - 2026-09-25
 
 
@@ -0,0 +1,29 @@
+# Reactor methods whose result the Error Prone build may drop (CheckReturnValue:ApiExclusionList).
+# The errorprone profile makes every reactor.core.publisher result must-use, so that an operator
+# whose Mono or Flux is dropped (and so never subscribed) fails the build. One signature per line,
+# erased parameter types; a line starting with # matches no method.
+#
+# subscribe: fire-and-forget subscriptions; the Disposable is not needed to keep them running.
+reactor.core.publisher.Mono#subscribe()
+reactor.core.publisher.Mono#subscribe(java.util.function.Consumer)
+reactor.core.publisher.Mono#subscribe(java.util.function.Consumer,java.util.function.Consumer)
+reactor.core.publisher.Mono#subscribe(java.util.function.Consumer,java.util.function.Consumer,java.lang.Runnable)
+reactor.core.publisher.Mono#subscribe(java.util.function.Consumer,java.util.function.Consumer,java.lang.Runnable,java.util.function.Consumer)
+reactor.core.publisher.Mono#subscribe(java.util.function.Consumer,java.util.function.Consumer,java.lang.Runnable,reactor.util.context.Context)
+reactor.core.publisher.Flux#subscribe()
+reactor.core.publisher.Flux#subscribe(java.util.function.Consumer)
+reactor.core.publisher.Flux#subscribe(java.util.function.Consumer,java.util.function.Consumer)
+reactor.core.publisher.Flux#subscribe(java.util.function.Consumer,java.util.function.Consumer,java.lang.Runnable)
+reactor.core.publisher.Flux#subscribe(java.util.function.Consumer,java.util.function.Consumer,java.lang.Runnable,java.util.function.Consumer)
+reactor.core.publisher.Flux#subscribe(java.util.function.Consumer,java.util.function.Consumer,java.lang.Runnable,reactor.util.context.Context)
+# Terminal signals: a failed emit almost always means the sink already terminated, which is the
+# outcome the caller wants (a racing emission could also refuse it; accepted for terminal signals).
+# tryEmitNext is NOT listed: dropping its result silently loses a message.
+reactor.core.publisher.Sinks.Empty#tryEmitEmpty()
+reactor.core.publisher.Sinks.Empty#tryEmitError(java.lang.Throwable)
+reactor.core.publisher.Sinks.One#tryEmitValue(java.lang.Object)
+reactor.core.publisher.Sinks.Many#tryEmitComplete()
+reactor.core.publisher.Sinks.Many#tryEmitError(java.lang.Throwable)
+# Fluent callback registration: returns the same sink.
+reactor.core.publisher.FluxSink#onCancel(reactor.core.Disposable)
+reactor.core.publisher.MonoSink#onCancel(reactor.core.Disposable)
@@ -59,7 +59,7 @@
     <properties>
         <java.version>17</java.version>
         <!-- release, not source/target: compiles against the Java 17 API even when the build
-             runs on a newer JDK (the NullAway profile below runs only on JDK 21+). -->
+             runs on a newer JDK (the errorprone profile below runs only on JDK 21+). -->
         <maven.compiler.release>${java.version}</maven.compiler.release>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
@@ -94,7 +94,7 @@
         <owasp.version>13.0.0</owasp.version>
         <cyclonedx-maven-plugin.version>2.9.3</cyclonedx-maven-plugin.version>
 
-        <!-- Null checking (nullaway profile, JDK 21+ only) -->
+        <!-- Error Prone and NullAway (errorprone profile, JDK 21+ only) -->
         <errorprone.version>2.50.0</errorprone.version>
         <nullaway.version>0.13.8</nullaway.version>
     </properties>
@@ -157,7 +157,7 @@
             </dependency>
 
             <!-- Null-marking annotations (@NullMarked, @Nullable). Annotations only; NullAway
-                 enforces them in the nullaway profile. -->
+                 enforces them in the errorprone profile. -->
             <dependency>
                 <groupId>org.jspecify</groupId>
                 <artifactId>jspecify</artifactId>
@@ -369,18 +369,31 @@
     </build>
 
     <profiles>
-        <!-- NullAway: enforces the JSpecify null-marking of main sources at ERROR.
+        <!-- Error Prone: Error Prone's own bug checks and NullAway, at ERROR, on main sources.
              Error Prone 2.50 runs only on JDK 21+, while the SDK targets Java 17 and its
-             release build runs on JDK 17, so the check activates by JDK: every build on
+             release build runs on JDK 17, so the profile activates by JDK: every build on
              JDK 21+ (including the CI job that exists for it) is checked, and a JDK 17
              build compiles exactly as before. The javac internals Error Prone needs are
-             opened in .mvn/jvm.config. Scope, per the canonical Java library guide:
-             - only NullAway, every other Error Prone check disabled (nullness, not lint);
-             - only @NullMarked packages (OnlyNullMarked), in JSpecify mode;
+             opened in .mvn/jvm.config. Scope:
+             - Error Prone's default-enabled checks, and failOnWarning (javac -Werror), so a
+               check whose default severity is WARNING fails the build like an ERROR one.
+               -Werror also fails on javac's own default warnings (removal, for one), which
+               are worth failing on too; suggestions stay notes. A new Error Prone version
+               brings its new checks in at ERROR: triage them on upgrade.
+             - Checks that are pure style for this code base are disabled by name below,
+               each with its reason. A real exception is a @SuppressWarnings with a reason.
+             - Beyond the defaults, two bug finders that fit this code base:
+               CheckReturnValue over reactor.core.publisher: a Mono or Flux operator whose
+               result is dropped never runs. Results that are fine to drop (subscribe's
+               Disposable, a terminal tryEmit*, fluent sink callbacks) are listed with
+               reasons in config/errorprone/reactor-ignorable-results.txt.
+               SystemOut: the stdio transport owns System.out, and anything else printed
+               there corrupts the JSON-RPC stream.
+             - NullAway: only @NullMarked packages (OnlyNullMarked), in JSpecify mode.
              - only default-compile: test sources are deliberately unchecked;
              - never fork the compiler (compiler-plugin then hides every diagnostic). -->
         <profile>
-            <id>nullaway</id>
+            <id>errorprone</id>
             <activation>
                 <jdk>[21,)</jdk>
             </activation>
@@ -393,11 +406,14 @@
                             <execution>
                                 <id>default-compile</id>
                                 <configuration>
+                                    <failOnWarning>true</failOnWarning>
                                     <compilerArgs>
                                         <arg>-XDcompilePolicy=simple</arg>
                                         <arg>--should-stop=ifError=FLOW</arg>
                                         <arg>-XDaddTypeAnnotationsToSymbol=true</arg>
-                                        <arg>-Xplugin:ErrorProne -XepDisableAllChecks -Xep:NullAway:ERROR -XepOpt:NullAway:JSpecifyMode=true -XepOpt:NullAway:OnlyNullMarked=true</arg>
+                                        <!-- Disabled, as style for this code base:
+                                             StatementSwitchToExpressionSwitch: arrow or colon switch is a style choice. -->
+                                        <arg>-Xplugin:ErrorProne -Xep:StatementSwitchToExpressionSwitch:OFF -Xep:SystemOut:ERROR -XepOpt:CheckReturnValue:Packages=reactor.core.publisher -XepOpt:CheckReturnValue:ApiExclusionList=${maven.multiModuleProjectDirectory}/config/errorprone/reactor-ignorable-results.txt -Xep:NullAway:ERROR -XepOpt:NullAway:JSpecifyMode=true -XepOpt:NullAway:OnlyNullMarked=true</arg>
                                     </compilerArgs>
                                     <annotationProcessorPaths>
                                         <path>