test: make e2e tests hermetic and load-robust under parallel CTest

Three tests flaked or could collide under `ctest -j`:

- toolset_e2e_test: (1) used a FIXED shared temp root
  ($TMPDIR/agentty_toolset_e2e) while setting a global HOME and spawning
  real subprocesses — every other test in the suite keys its sandbox on
  getpid(); made this one match. (2) The process_poll checks raced fixed
  wait_ms windows (500 ms for the first poll) against subprocess
  scheduling latency; on a loaded box the child hadn't been scheduled to
  emit its first line yet, cascading three failures. Replaced with a
  poll-until-marker loop on a generous deadline so the assertions test
  semantics (initial output, later output once, no replay), not timing.
- mcp_bridge_test / acp_integration_test: same fixed-shared-path
  anti-pattern (agentty_mcp_e2e / agentty_acp_it) — made both PID-unique
  and remove_all the root up front.

Full suite now 100% green across repeated -j12 runs (was intermittently
1-2 failures).

Author: 1ay1

tests/acp_integration_test.cpp

@@ -48,7 +48,10 @@ int main() {
     namespace fs = std::filesystem;
     // The write tool's sandbox refuses paths outside the workspace root.
     // Point the root at a tmp dir we own so the scripted `write` succeeds.
-    const fs::path tmp = fs::temp_directory_path() / "agentty_acp_it";
+    // PID-unique so the suite stays hermetic under parallel CTest (-j).
+    const fs::path tmp = fs::temp_directory_path() /
+                         ("agentty_acp_it_" + std::to_string(::getpid()));
+    fs::remove_all(tmp);
     fs::create_directories(tmp);
     // Sandbox persistence too: AgentServer::persist() writes every turn
     // to persistence::threads_dir() = $HOME/.agentty/threads. Without

tests/mcp_bridge_test.cpp

@@ -12,6 +12,7 @@
 
 #include <cstdio>
 #include <cstdlib>
+#include <unistd.h>   // getpid
 #include <filesystem>
 #include <fstream>
 #include <string>
@@ -56,8 +57,10 @@ int main() {
 
     // Write a temp mcp.json pointing at the example server, and aim the bridge
     // at it via AGENTTY_MCP_CONFIG.
-    auto tmp = fs::temp_directory_path() / "agentty_mcp_e2e";
-    std::error_code ec; fs::create_directories(tmp, ec);
+    // PID-unique so the suite stays hermetic under parallel CTest (-j).
+    auto tmp = fs::temp_directory_path() /
+               ("agentty_mcp_e2e_" + std::to_string(::getpid()));
+    std::error_code ec; fs::remove_all(tmp, ec); fs::create_directories(tmp, ec);
     auto cfg = tmp / "mcp.json";
     {
         std::ofstream f(cfg);

tests/toolset_e2e_test.cpp

@@ -18,6 +18,7 @@
 #include <chrono>
 #include <cstdio>
 #include <cstdlib>
+#include <unistd.h>   // getpid
 #include <filesystem>
 #include <fstream>
 #include <string>
@@ -83,7 +84,13 @@ int main() {
     // ── Sandbox: everything under one temp root, BEFORE first registry()
     // touch (the registry is a process-lifetime static; workspace root and
     // HOME must be final before it is built).
-    auto root = fs::temp_directory_path() / "agentty_toolset_e2e";
+    // PID-unique sandbox: CTest runs the suite with -j, and this test spawns
+    // real subprocesses (bash/process_start) under a global HOME. A FIXED
+    // shared path let a sibling test's teardown race our tree — the source of
+    // the intermittent toolset_e2e failure under -j12. Match the rest of the
+    // suite and key the root on getpid().
+    auto root = fs::temp_directory_path() /
+                ("agentty_toolset_e2e_" + std::to_string(::getpid()));
     std::error_code ec;
     fs::remove_all(root, ec);
     fs::create_directories(root / "src");
@@ -265,9 +272,31 @@ int main() {
             const auto marker = started->text.find("proc-");
             const auto end = started->text.find(' ', marker);
             const std::string id = started->text.substr(marker, end - marker);
-            auto first = run("process_poll", {{"id", id}, {"wait_ms", 500}});
+
+            // Poll until a marker shows rather than racing one fixed window:
+            // under a loaded CI box (this test co-schedules with the whole
+            // suite) the child can take far longer than any single wait_ms to
+            // be scheduled and have its pipe drained. Loop with a generous
+            // overall deadline so the assertion tests SEMANTICS (initial
+            // output arrives, later output arrives once, no replay) instead
+            // of subprocess scheduling latency.
+            auto poll_until = [&](const char* needle, int budget_ms) {
+                auto last = run("process_poll", {{"id", id}, {"wait_ms", 500}});
+                int waited = 500;
+                while (!has(last, needle) && waited < budget_ms) {
+                    auto r = run("process_poll", {{"id", id}, {"wait_ms", 500}});
+                    waited += 500;
+                    // A poll only returns output produced since the previous
+                    // poll; keep the newest non-empty result so the hit isn't
+                    // lost when a later poll comes back empty.
+                    if (has(r, needle) || r) last = std::move(r);
+                }
+                return last;
+            };
+
+            auto first = poll_until("process-first", 10000);
             check(has(first, "process-first"), "process_poll: returns initial output");
-            auto second = run("process_poll", {{"id", id}, {"wait_ms", 2000}});
+            auto second = poll_until("process-second", 10000);
             check(has(second, "process-second"), "process_poll: waits for new output");
             check(second.has_value() && !has(second, "process-first"),
                   "process_poll: does not repeat previously delivered output");