llama-atmosphere-agent: make ShellToolTest run on Windows too

ShellToolTest used POSIX commands (ls, sleep, printf, `; exit 3`) and failed 4 of 5
tests on Windows, where ShellTool runs cmd.exe /c. Each test now picks its command
line with ShellTool.isWindows() -- the same detection ShellTool.run uses to choose
the shell -- so it always speaks the shell the tool actually starts:

- ls / dir /b
- `echo boom 1>&2; exit 3` / `echo boom 1>&2 & exit 3`
- truncation: echo on both, the expected length counts the platform's line
  separator (\n from sh, \r\n from cmd.exe)
- sleep 30 / ping -n 30 127.0.0.1 >nul (also a child of the shell, so the
  descendant kill stays covered)

Verified: Windows 11 (all 31 agent tests), Linux in maven:3.9-eclipse-temurin-21
(ShellToolTest 5/5, AgentOptionsTest 11/11).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01E2h8gXyyE5UeimkL9vQv9G

Author: bernardladenthin

CLAUDE.md

@@ -2214,9 +2214,11 @@ tools are only for files" — with the tool registered and `docker` on `PATH`; a
 refused too, so it was the prompt, not the chat history. Without `--allow-shell` the prompt says commands
 are unavailable and names the flag, so the model does not invent its own limitation. Pinned by
 `AgentOptionsTest.defaultSystemPromptIsGeneralPurposeAndAllowsAnyCommandWithTheShell` and
-`shellToolDescriptionDoesNotNarrowItToTheProject`. `ShellToolTest` uses POSIX commands (`ls`, `sleep`,
-`exit 3`), so it passes only on Linux/macOS — CI runs it on Linux; on Windows run the suite with
-`-Dtest=!ShellToolTest`.
+`shellToolDescriptionDoesNotNarrowItToTheProject`. `ShellToolTest` runs on every platform: each test
+picks its command line with `ShellTool.isWindows()` — the same detection `ShellTool.run` uses to choose
+`cmd.exe /c` over `sh -c` — so `ls`/`dir /b`, `sleep 30`/`ping -n 30 127.0.0.1 >nul`, and the truncation
+test counts the platform's line separator. It used plain POSIX commands before and failed 4 of 5 on
+Windows; never skip it per OS, give a new test both command forms instead.
 
 **Version bump note.** The pom's `llama.version` property is the **release** version, not the
 reactor's `-SNAPSHOT` (CI always overrides it, so a not-yet-published default never breaks CI).

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

@@ -17,17 +17,33 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
+/**
+ * Runs on every platform: each test picks its command line with {@link ShellTool#isWindows()}, the same
+ * detection {@link ShellTool#run} uses to choose between {@code cmd.exe /c} and {@code sh -c}, so the test
+ * always speaks the shell the tool actually starts.
+ */
 class ShellToolTest {
 
     @TempDir
     Path workspace;
 
+    /**
+     * The command line for the shell {@link ShellTool} starts on this platform.
+     *
+     * @param posix the {@code sh} form
+     * @param windows the {@code cmd.exe} form
+     * @return the form matching {@link ShellTool#isWindows()}
+     */
+    private static String shell(String posix, String windows) {
+        return ShellTool.isWindows() ? windows : posix;
+    }
+
     @Test
     void runsInTheWorkspaceAndReportsExitCodeAndOutput() throws Exception {
         Files.writeString(workspace.resolve("marker.txt"), "x");
         ToolDefinition tool = ShellTool.definition(workspace, Duration.ofSeconds(30), 10_000);
 
-        Object result = tool.executor().execute(Map.of("command", "ls"));
+        Object result = tool.executor().execute(Map.of("command", shell("ls", "dir /b")));
 
         assertThat(tool.name(), is(ShellTool.TOOL_NAME));
         assertThat(String.valueOf(result), startsWith("exit code: 0"));
@@ -38,7 +54,8 @@ void runsInTheWorkspaceAndReportsExitCodeAndOutput() throws Exception {
     void nonZeroExitAndStderrAreReturnedNotThrown() throws Exception {
         ToolDefinition tool = ShellTool.definition(workspace, Duration.ofSeconds(30), 10_000);
 
-        Object result = tool.executor().execute(Map.of("command", "echo boom 1>&2; exit 3"));
+        Object result =
+                tool.executor().execute(Map.of("command", shell("echo boom 1>&2; exit 3", "echo boom 1>&2 & exit 3")));
 
         assertThat(String.valueOf(result), startsWith("exit code: 3"));
         assertThat(String.valueOf(result), containsString("boom"));
@@ -53,15 +70,23 @@ void missingCommandIsAnErrorString() throws Exception {
 
     @Test
     void outputIsTruncatedToTheTail() throws Exception {
-        String result = ShellTool.run(workspace, "printf 'aaaaaaaaaaaaaaaaaaaaZZ'", Duration.ofSeconds(30), 5);
-
-        assertThat(result, containsString("[output truncated to the last 5 of 22 characters]"));
-        assertThat(result, containsString("aaaZZ"));
+        // echo is the one output command both shells share; it ends the line with the platform's
+        // separator (\n from sh, \r\n from cmd.exe), which is part of the counted output.
+        String newline = ShellTool.isWindows() ? "\r\n" : "\n";
+        String result = ShellTool.run(workspace, "echo aaaaaaaaaaaaaaaaaaaaZZ", Duration.ofSeconds(30), 5);
+
+        assertThat(
+                result,
+                containsString("[output truncated to the last 5 of " + (22 + newline.length()) + " characters]"));
+        assertThat(result, containsString("ZZ" + newline));
     }
 
     @Test
     void timeoutKillsTheProcess() throws Exception {
-        String result = ShellTool.run(workspace, "sleep 30", Duration.ofMillis(300), 10_000);
+        // cmd.exe has no sleep; ping waits about one second per echo request. Like `sh -c "sleep 30"`,
+        // it is a child of the shell, so this also covers killing the descendants.
+        String result = ShellTool.run(
+                workspace, shell("sleep 30", "ping -n 30 127.0.0.1 >nul"), Duration.ofMillis(300), 10_000);
 
         assertThat(result, startsWith("exit code: (killed after 0 s)"));
     }