fix(s090): the trace test waits for the turn, not for the model call

The FIPS leg failed on slice 014's branch while its sibling run of the same commit
passed. That is R26's signature, and R26's own counter-example entry says the
signature is not the diagnosis, so the stack trace was read first. It was not R26.

Trinity.TelemetryTest, two turns are two traces, sent its second user message as
soon as it received the llm call stop event from the first. That event fires when
the model call ends, not when the turn does: the session is still thinking while
it writes the result, so the second message returned {:error, {:busy, :thinking}}.

It has been racy since slice 090 and passed on the ordinary gate for days because
that leg is faster where it matters. The FIPS leg is about half again as slow,
which is enough to lose the race reliably.

The test now waits for idle, which is what it meant: two turns is a claim about
two turns, and the end of a model call is not the end of a turn. A poll against a
deadline rather than a sleep, so it flunks naming the state it was stuck in rather
than trading one race for a slower one.

Signed-off-by: Ayla Croft <aylacroft@proton.me>

Author: HackTuah

test/trinity/telemetry/telemetry_test.exs

@@ -170,12 +170,38 @@ defmodule Trinity.TelemetryTest do
       {:ok, _} = Sessions.send_user_message(session.id, "first")
       assert_receive {^ref, [:trinity, :llm, :call, :stop], _, first}, 5_000
 
+      # The stop event fires when the model call ends, and the session is still `:thinking` while it
+      # writes the result. Sending the next message on that event is a race: it passed on the
+      # ordinary gate for weeks and failed on the FIPS leg, which is slower, with
+      # `{:error, {:busy, :thinking}}`. Waiting for idle is what the test meant all along.
+      await_idle(session.id)
+
       {:ok, _} = Sessions.send_user_message(session.id, "second")
       assert_receive {^ref, [:trinity, :llm, :call, :stop], _, second}, 5_000
 
       refute first.trace_id == second.trace_id
     end
 
+    defp await_idle(id, timeout \\ 5_000) do
+      deadline = System.monotonic_time(:millisecond) + timeout
+      await_idle(id, deadline, :first)
+    end
+
+    defp await_idle(id, deadline, _) do
+      case Sessions.state(id) do
+        %{state: :idle} ->
+          :ok
+
+        other ->
+          if System.monotonic_time(:millisecond) > deadline do
+            flunk("session #{id} was #{inspect(other)} and never became idle")
+          else
+            Process.sleep(10)
+            await_idle(id, deadline, :again)
+          end
+      end
+    end
+
     test "outside a trace an event carries no trace id, rather than an invented one" do
       ref = make_ref()
       me = self()