Check every control character's round trip through the scripted chunks

everyControlCharacterSurvivesAsJson parsed each chunk but never read the
text back, and any hexadecimal or short escape parses, so a quote() that
wrote the wrong character passed for all 32 inputs. Only the separate
round-trip test read a value, for one sample string whose CR exists only
on Windows. A contentOf helper now joins the delta.content of a turn's
chunks, the loop compares it with the input for every character from
U+0000 to U+001F and for the quote/backslash and DEL/U+0085/U+2028
inputs, and the round-trip test uses the same helper.

Shown red by mutation of quote(): CR written as \n fails with
'U+000D Expected: is "a\rb" but: was "a\nb"' (the old test stayed green
on Linux), BS written as \f fails at U+0008; unchanged code 3/3 green.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VBFFnrhtvXiUeyxjmUc4R2

Author: claude

BUGHUNT-FOUND.md

@@ -1583,6 +1583,7 @@ Repos plus eins. Geprüfte Klassen ohne Fund stehen in [`BUGHUNT-CHECKED.md`](BU
 - **Fix:** `quote` bekommt `\r`, `\t`, `\b`, `\f` und — das Tragende — einen `default`-Zweig, der alles unter `0x20` als `\uXXXX` schreibt, damit ein nicht aufgelistetes Steuerzeichen die Lücke nicht wieder aufreißen kann. Der Test selbst bleibt unangetastet: `System.lineSeparator()` dort ist richtig, weil genau das CRLF überhaupt erst ausübt. Ein `grep` über alle handgerollten JSON-Quote-Helfer im Repository zeigt, dass es diese eine Stelle war.
 - **Tests:** Neu `ScriptedBackendTest` (3): jeder Chunk eines Text-Zuges parst als JSON (mit `System.lineSeparator()`, CRLF, LF und einzelnem CR); **jedes** der 32 Steuerzeichen einzeln, also der `default`-Zweig und nicht die vier benannten Fälle; und der Text kommt unverändert aus dem Chunk zurück.
 - **Rot-Grün-Nachweis:** Mit der alten `quote`-Fassung kurz zurückgesetzt: `ScriptedBackendTest` 2 Failures + 1 Error (`System.lineSeparator(): chunk is not JSON`, `U+0000: chunk is not JSON`, `JsonParse Illegal unquoted character ((CTRL-CHAR, code 13))`) und `AgentSessionTest` 1 Failure. Mit dem Fix (Datei danach byte-identisch wiederhergestellt) beide dreimal hintereinander grün, und das ganze Modul 281/0/0/60 — die 60 sind die dokumentierten JLine-Fälle. `spotless:check` grün.
+- **Nachtrag (Branch-Review 2026-10-20):** `#everyControlCharacterSurvivesAsJson` prüfte für die 32 Steuerzeichen nur, dass jeder Chunk parst; jedes `\uXXXX` und jede kurze Maske parst aber, so dass ein falsches Zeichen durchging – auf Linux ungeprüft blieben die Werte von `\r`, `\b` und `\f` (Fund J15-2). Der neue Helfer `contentOf(List<String>)` hängt das `delta.content` aller Chunks eines Zuges aneinander; der Test vergleicht damit jetzt für jedes Zeichen von U+0000 bis U+001F sowie für Anführungszeichen/Backslash und DEL/U+0085/U+2028 den Text mit der Eingabe, und `#theTextComesBackOutOfTheChunkUnchanged` nutzt denselben Helfer statt der eigenen Schleife. Gegenprobe rot: `\r` als `\n` geschrieben (`U+000D Expected: is "a\rb" but: was "a\nb"`; die alte Testfassung blieb damit auf Linux grün, 3/3), `\b` als `\f` (`U+0008`); unverändert 3/3 grün.
 - **Status:** gefixt
 - **Commit:** java-llama.cpp `d68aa3d`
 

llama-atmosphere-agent/src/test/java/net/ladenthin/llama/atmosphere/ScriptedBackendTest.java

@@ -39,6 +39,18 @@ private static void assertEveryChunkIsJson(String what, List<String> chunks) {
         }
     }
 
+    /** The text a turn's chunks carry: the {@code delta.content} of every chunk, in order. */
+    private static String contentOf(List<String> chunks) throws Exception {
+        StringBuilder content = new StringBuilder();
+        for (String chunk : chunks) {
+            var delta = MAPPER.readTree(chunk).path("choices").path(0).path("delta");
+            if (delta.path("content").isTextual()) {
+                content.append(delta.path("content").asText());
+            }
+        }
+        return content.toString();
+    }
+
     @Test
     void aTextTurnCarryingTheLineSeparatorIsJsonOnEveryPlatform() {
         assertEveryChunkIsJson(
@@ -52,29 +64,30 @@ void aTextTurnCarryingTheLineSeparatorIsJsonOnEveryPlatform() {
     /**
      * The default branch of {@code quote}, not the named cases: a control character nobody listed is
      * what reopened the gap, so every one of them is checked rather than the four with a short escape.
+     * Valid JSON is not enough -- any hexadecimal or short escape parses -- so each must also come back
+     * as itself: a wrong code point, or a CR written with the escape of an LF, parses just as well.
      */
     @Test
-    void everyControlCharacterSurvivesAsJson() {
+    void everyControlCharacterSurvivesAsJson() throws Exception {
         for (int c = 0; c < 0x20; c++) {
+            String what = "U+" + String.format("%04X", c);
             String text = "a" + (char) c + "b";
-            assertEveryChunkIsJson("U+" + String.format("%04X", c), ScriptedBackend.textTurn(text));
+            List<String> chunks = ScriptedBackend.textTurn(text);
+            assertEveryChunkIsJson(what, chunks);
+            assertThat(what, contentOf(chunks), is(text));
         }
-        assertEveryChunkIsJson("quote and backslash", ScriptedBackend.textTurn("say \"hi\"\\ now"));
-        assertEveryChunkIsJson("DEL and beyond", ScriptedBackend.textTurn("a\u007fb\u0085c
d"));
+        String quoted = "say \"hi\"\\ now";
+        assertEveryChunkIsJson("quote and backslash", ScriptedBackend.textTurn(quoted));
+        assertThat("quote and backslash", contentOf(ScriptedBackend.textTurn(quoted)), is(quoted));
+        String beyond = "a\u007fb\u0085c
d";
+        assertEveryChunkIsJson("DEL and beyond", ScriptedBackend.textTurn(beyond));
+        assertThat("DEL and beyond", contentOf(ScriptedBackend.textTurn(beyond)), is(beyond));
     }
 
     /** A chunk must also carry the text back unchanged -- escaping may not lose or alter it. */
     @Test
     void theTextComesBackOutOfTheChunkUnchanged() throws Exception {
         String text = "working" + System.lineSeparator() + "\tdone \"quoted\" \\ U+0001:\u0001";
-        List<String> chunks = ScriptedBackend.textTurn(text);
-        String content = null;
-        for (String chunk : chunks) {
-            var delta = MAPPER.readTree(chunk).path("choices").path(0).path("delta");
-            if (delta.path("content").isTextual()) {
-                content = delta.path("content").asText();
-            }
-        }
-        assertThat(content, is(text));
+        assertThat(contentOf(ScriptedBackend.textTurn(text)), is(text));
     }
 }