CB-107: async fire-and-poll delegation (wait:false + ticket poll)

A caller's MCP client caps a blocking bridge_send at ~60s, but a real delegated
task runs for minutes. sendAsync runs the same blocking send on a background
virtual thread and returns a ticket; poll(ticket) reports pending/done/failed.
Async reuses the blocking path (and its per-target serialization), so it inherits
reply + completion resolution for free. Surfaces: REST POST message wait:false ->
202 {ticket} + GET /tasks/{ticket}; MCP bridge_send wait flag + new bridge_poll.
Terminal tickets are pruned after a TTL so the registry stays bounded.

bridged/src/test/java/dev/ltms/bridged/mcp/BridgeMcpTest.java

@@ -49,6 +49,43 @@ class BridgeMcpTest {
         assertEquals("LGTM", textOf(res));
     }
 
+    @Test
+    void asyncSendReturnsATicketThenPollReportsTheReply() throws Exception {
+        // wait:false parity — a ticket is issued, resolved by a reply, and surfaced by bridge_poll.
+        McpSchema.CallToolResult accepted = BridgeMcp.sendAsync(messages, "term_a", "do it");
+        assertNotEquals(Boolean.TRUE, accepted.isError());
+        String out = textOf(accepted);
+        assertTrue(out.contains("ticket="), out);
+        String ticket = out.substring(out.indexOf("ticket=") + "ticket=".length()).trim();
+
+        // Resolve the awaiting send once it has opened (retry past the async-open race).
+        long deadline = System.currentTimeMillis() + 3000;
+        McpSchema.CallToolResult reply = BridgeMcp.reply(rendezvous, "term_a", "async LGTM");
+        while (Boolean.TRUE.equals(reply.isError()) && System.currentTimeMillis() < deadline) {
+            //noinspection BusyWait
+            Thread.sleep(10);
+            reply = BridgeMcp.reply(rendezvous, "term_a", "async LGTM");
+        }
+        assertEquals("delivered", textOf(reply));
+
+        // Poll until the async send completes and reports the reply.
+        McpSchema.CallToolResult polled = BridgeMcp.poll(messages, ticket);
+        deadline = System.currentTimeMillis() + 3000;
+        while (!textOf(polled).contains("async LGTM") && System.currentTimeMillis() < deadline) {
+            //noinspection BusyWait
+            Thread.sleep(10);
+            polled = BridgeMcp.poll(messages, ticket);
+        }
+        assertEquals("async LGTM", textOf(polled));
+    }
+
+    @Test
+    void pollUnknownTicketIsAnError() {
+        McpSchema.CallToolResult res = BridgeMcp.poll(messages, "task-999");
+        assertTrue(res.isError());
+        assertTrue(textOf(res).contains("unknown ticket"));
+    }
+
     @Test
     void sendTimesOutWithAWorkingNote() {
         McpSchema.CallToolResult res = BridgeMcp.send(messages, "term_a", "hi", 120L);

bridged/src/test/java/dev/ltms/bridged/rest/BridgedAppTest.java

@@ -264,6 +264,50 @@ class BridgedAppTest {
         // (injection via agent.send is covered deterministically by the timeout-working test)
     }
 
+    @Test
+    void asyncSendReturnsATicketThenPollReportsTheReply() throws Exception {
+        // CB-107 fire-and-poll: wait:false returns a ticket immediately; the result is polled.
+        FakeHerdr herdr = new FakeHerdr().agentStatus("idle"); // poller delivers the injection
+        int port = start(herdr, "http://gx00.gw:8000", Set.of("gx00.gw"));
+
+        HttpResponse<String> accepted = postMessage(port, "{\"content\":\"do it\",\"wait\":false}");
+        assertEquals(202, accepted.statusCode());
+        String ticket = mapper.readTree(accepted.body()).get("ticket").asText();
+        assertFalse(ticket.isBlank(), "an async send must return a ticket");
+
+        // The worker replies once the async send is actually awaiting (retry past the startup race).
+        HttpResponse<String> reply;
+        long deadline = System.currentTimeMillis() + 3000;
+        do {
+            reply = postJson(port, "/sessions/term_a/reply", "{\"content\":\"async LGTM\"}");
+            if (reply.statusCode() != 409) break;
+            //noinspection BusyWait
+            Thread.sleep(10);
+        } while (System.currentTimeMillis() < deadline);
+        assertEquals(200, reply.statusCode());
+
+        // Polling the ticket now reports the finished delegation and its reply.
+        JsonNode task;
+        deadline = System.currentTimeMillis() + 3000;
+        do {
+            task = mapper.readTree(req(port, "GET", "/tasks/" + ticket).body());
+            if ("done".equals(task.path("phase").asText())) break;
+            //noinspection BusyWait
+            Thread.sleep(10);
+        } while (System.currentTimeMillis() < deadline);
+        assertEquals("done", task.get("phase").asText());
+        assertEquals("async LGTM", task.get("reply").asText());
+        assertEquals("reply", task.get("replySource").asText());
+    }
+
+    @Test
+    void pollUnknownTicketIs404() throws Exception {
+        int port = startHealthy();
+        HttpResponse<String> res = req(port, "GET", "/tasks/task-999");
+        assertEquals(404, res.statusCode());
+        assertEquals("unknown_ticket", mapper.readTree(res.body()).get("error").asText());
+    }
+
     @Test
     void replyWithNoPendingSendIsConflict() throws Exception {
         int port = startHealthy();