@@ -122,6 +122,41 @@ defmodule Trinity.Subagents do
     end)
   end
 
+  @doc """
+  Whether a child is still working.
+
+  Asked of the process, not of the row. `SessionRow.status` is the session's lifecycle - active,
+  archived, compacted - and a finished subagent is still `"active"` forever, so a panel that reads
+  it reports every child as running until somebody archives it. The screenshot for this slice's
+  AC7 is what caught that: four children, three of them long finished, all labelled active with a
+  stop button each.
+  """
+  @spec running?(String.t()) :: boolean()
+  def running?(session_id) do
+    # `Sessions.state/1` answers with a view map, not the bare state atom. Comparing the map to
+    # `:idle` is never equal, so the first version of this reported every child as running and the
+    # panel's labels were wrong in the opposite direction from the bug it was written to fix.
+    case Sessions.state(session_id) do
+      %{state: state} -> state != :idle
+      _ -> false
+    end
+  rescue
+    _ -> false
+  catch
+    :exit, _ -> false
+  end
+
+  @doc """
+  A short, distinguishing form of a session id.
+
+  The **tail**, not the head. These ids are UUIDv7, which is time-ordered, so children created in
+  the same second share their leading bytes: measured, four ids generated together had one
+  distinct 8-character prefix between them. A short id whose whole job is to tell two rows apart
+  has to come from the random end.
+  """
+  @spec short_id(String.t()) :: String.t()
+  def short_id(id) when is_binary(id), do: String.slice(id, -8, 8)
+
   @doc "The children of a session, newest first."
   @spec children(String.t()) :: [Sessions.SessionRow.t()]
   def children(parent_session_id) do
 
@@ -100,7 +100,7 @@ defmodule TrinityWeb.SessionLive.Show do
     |> assign(status: status, draft: text, last_seq: last_seq)
     |> assign(
       approvals: Permissions.pending(id),
-      subagents: Trinity.Subagents.children(id),
+      subagents: subagent_panel(id),
       pending_count: length(Permissions.pending(:all))
     )
     |> assign_context(rows)
@@ -136,6 +136,15 @@ defmodule TrinityWeb.SessionLive.Show do
   defp content(nil), do: nil
   defp content(%Message{content: content}), do: content
 
+  # Each child paired with whether it is still working, asked of its process rather than read from
+  # its row: SessionRow.status is the session lifecycle and stays "active" long after a subagent
+  # has finished.
+  defp subagent_panel(session_id) do
+    session_id
+    |> Trinity.Subagents.children()
+    |> Enum.map(&{&1, Trinity.Subagents.running?(&1.id)})
+  end
+
   # Slice 080 AC7. The subagent tree for this session: what was delegated, how each child ended,
   # and a way to stop one. It renders nothing when there are none, because an empty panel on every
   # session teaches people to ignore the space it occupies.
@@ -148,20 +157,20 @@ defmodule TrinityWeb.SessionLive.Show do
         {gettext("Subagents")} ({length(@panel)})
       </h2>
       <ul class="flex flex-col gap-1">
-        <li :for={child <- @panel} class="flex items-center gap-2 text-sm">
+        <li :for={{child, running?} <- @panel} class="flex items-center gap-2 text-sm">
           <span class={[
             "rounded px-1.5 py-0.5 font-mono text-meta",
-            child.status == "active" && "bg-warning/20 text-warning",
-            child.status != "active" && "bg-base-200 opacity-70"
+            running? && "bg-warning/20 text-warning",
+            !running? && "bg-base-200 opacity-70"
           ]}>
-            {child.status}
+            {if running?, do: gettext("running"), else: gettext("done")}
           </span>
           <.link navigate={~p"/s/#{child.id}"} class="min-w-0 flex-1 truncate hover:underline">
             {child.title || gettext("untitled brief")}
           </.link>
-          <span class="font-mono text-meta opacity-50">{String.slice(child.id, 0, 8)}</span>
+          <span class="font-mono text-meta opacity-50">{Trinity.Subagents.short_id(child.id)}</span>
           <button
-            :if={child.status == "active"}
+            :if={running?}
             type="button"
             phx-click="cancel_subagent"
             phx-value-id={child.id}
@@ -193,7 +202,7 @@ defmodule TrinityWeb.SessionLive.Show do
   # child cancelled while its own children run leaves work nobody is waiting for.
   def handle_event("cancel_subagent", %{"id" => id}, socket) do
     _ = Trinity.Subagents.cancel_subtree(id)
-    {:noreply, assign(socket, subagents: Trinity.Subagents.children(socket.assigns.session.id))}
+    {:noreply, assign(socket, subagents: subagent_panel(socket.assigns.session.id))}
   end
 
   def handle_event("cancel", _params, socket) do
 
@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# SPDX-FileCopyrightText: Sudo Apt Holdings LLC
+# SPDX-License-Identifier: Apache-2.0
+# A session with subagents, for slice 080's AC7 screenshot. Same shape as
+# scripts/dev_chat_on_test_registry.sh: the test environment's Repo without its sandbox pool, its
+# own database (never the suite's), the fake provider, the application started by hand, and the
+# port printed as PORT=<n>.
+#
+# It delegates three briefs and leaves one child running, because a panel screenshot of three
+# finished children shows the list but not the thing the panel exists for: a stop control next to
+# work that is still going.
+cd "$(dirname "$0")/.."
+export MIX_ENV=test
+exec systemd-run --user --scope -p MemoryMax=32G --quiet -- mix run --no-start --no-halt -e '
+repo = Application.get_env(:trinity, Trinity.Repo) |> Keyword.delete(:pool) |> Keyword.put(:database, "trinity_screenshots.db")
+Application.put_env(:trinity, Trinity.Repo, repo)
+rrepo = Application.get_env(:trinity, Trinity.Repo.Receipts) |> Keyword.delete(:pool) |> Keyword.put(:database, "trinity_screenshots_receipts.db")
+Application.put_env(:trinity, Trinity.Repo.Receipts, rrepo)
+endpoint = Application.get_env(:trinity, TrinityWeb.Endpoint) |> Keyword.put(:check_origin, false)
+Application.put_env(:trinity, TrinityWeb.Endpoint, endpoint)
+Application.put_env(:trinity, :mcp_boot, false)
+# Both repos are migrated before the application starts, not after: Oban verifies its migration
+# as it boots (slice 050), so a run that migrates afterwards never gets that far.
+{:ok, _} = Application.ensure_all_started(:ecto_sql)
+for r <- [Trinity.Repo, Trinity.Repo.Receipts] do
+  {:ok, pid} = r.start_link()
+  Ecto.Migrator.run(r, :up, all: true)
+  GenServer.stop(pid)
+end
+{:ok, _} = Application.ensure_all_started(:trinity)
+Logger.configure(level: :warning)
+
+alias Trinity.{Sessions, Subagents}
+alias Trinity.LLM.Providers.Fake
+
+answer = fn text ->
+  Enum.flat_map(String.split(text), &[{:text_delta, &1 <> " "}, {:sleep, 10}]) ++
+    [{:usage, %{input_tokens: 40, output_tokens: 30}}, {:done, :stop}]
+end
+
+{:ok, parent} = Sessions.create_session(%{persona_id: Sessions.default_persona().id, title: "Refactoring the receipt chain"})
+
+Fake.scripts([
+  answer.("The chain writer checkpoints every 200 receipts and on terminate. Three call sites."),
+  answer.("Two tests cover the checkpoint path; neither covers terminate during sandbox teardown."),
+  answer.("The verifier reads the registry, not the key file, so it needs no custody adapter.")
+])
+
+for brief <- [
+  "Read lib/trinity/receipts/chain_writer.ex and say when it checkpoints",
+  "Find the tests that cover checkpointing and say what they miss",
+  "Say what the verifier needs from key custody, if anything"
+] do
+  {:ok, _} = Subagents.delegate(parent.id, brief)
+end
+
+# One left running, so the panel shows an active child with its stop control.
+Fake.scripts([[{:text_delta, "Reading the migration history "}, {:sleep, 600_000}, {:done, :stop}]])
+spawn(fn -> Subagents.delegate(parent.id, "Trace every migration that touched the receipts table") end)
+Process.sleep(1_500)
+
+{:ok, {_, port}} = TrinityWeb.Endpoint.server_info(:http)
+IO.puts("PORT=#{port}")
+IO.puts("SESSION=#{parent.id}")
+'
@@ -21,13 +21,42 @@ defmodule TrinityWeb.SubagentPanelTest do
   setup do
     Fake.clear()
     on_exit(fn -> Fake.clear() end)
+    # ConnCase does not stop the session processes a test starts, and a child left running holds
+    # the sandbox connection past its owner, which fails the *next* test's setup rather than this
+    # one's. Cleaned up here for the same reason SessionCase does it.
+    on_exit(fn -> Trinity.SessionCase.stop_all_sessions() end)
 
     {:ok, parent} =
       Sessions.create_session(%{persona_id: Sessions.default_persona().id, title: "parent"})
 
     {:ok, parent: parent}
   end
 
+  test "a short id distinguishes children rather than sharing a prefix with them" do
+    ids = for _ <- 1..4, do: Trinity.UUID.generate()
+
+    # Measured, not assumed: four ids generated together had one distinct 8-character prefix
+    # between them, which is what sent the first version of this panel out with four identical
+    # labels.
+    assert ids |> Enum.map(&String.slice(&1, 0, 8)) |> Enum.uniq() |> length() == 1
+    assert ids |> Enum.map(&Subagents.short_id/1) |> Enum.uniq() |> length() == 4
+  end
+
+  test "a finished child is shown as done, with no stop control", %{conn: conn, parent: parent} do
+    Fake.scripts([script_deltas(1, "finished ")])
+    {:ok, result} = Subagents.delegate(parent.id, "a brief that completes")
+
+    {:ok, _live, html} = live(conn, ~p"/s/#{parent.id}")
+
+    # The row's own status is still "active" here, because that field is the session lifecycle.
+    assert Sessions.get_session(result.session_id).status == "active"
+
+    # The panel must not repeat that: the child has finished, and offering to stop it is a button
+    # that does nothing.
+    assert html =~ "done"
+    refute html =~ ~s(phx-value-id="#{result.session_id}")
+  end
+
   test "with no subagents the panel is absent rather than empty", %{conn: conn, parent: parent} do
     {:ok, _live, html} = live(conn, ~p"/s/#{parent.id}")
     refute html =~ ~s(id="subagents")
@@ -44,26 +73,55 @@ defmodule TrinityWeb.SubagentPanelTest do
 
     assert html =~ ~s(id="subagents")
     assert html =~ "read the long file and answer"
-    assert html =~ String.slice(result.session_id, 0, 8)
+    # The tail, not the head: these ids are UUIDv7 and children made in the same second share
+    # their leading bytes, so a head-based short id tells two rows apart only by accident.
+    assert html =~ Subagents.short_id(result.session_id)
+    assert html =~ "done"
     assert html =~ ~s(href="/s/#{result.session_id}")
   end
 
-  test "stopping a subagent from the panel cancels it and the panel survives", %{
+  test "stopping a running subagent cancels it, and the panel survives", %{
     conn: conn,
     parent: parent
   } do
-    Fake.scripts([script_deltas(1, "done ")])
-    {:ok, result} = Subagents.delegate(parent.id, "a brief to stop")
+    # A child left running, so there is a stop control to press. {:sleep, ms} holds the turn open;
+    # a script that merely omits its terminator does not, which is a lesson from this slice's
+    # supervision test.
+    Fake.scripts([[{:text_delta, "working "}, {:sleep, 30_000}, {:done, :stop}]])
+    task = Task.async(fn -> Subagents.delegate(parent.id, "a brief to stop") end)
+
+    # The row exists before the process does: create_child/3 inserts the session, and the turn
+    # starts after. Waiting for the row and asserting running? in the same breath is a race the
+    # first version of this test lost.
+    child_id = await_child(parent.id)
+    assert await_running(child_id), "the child never reached a running state"
 
     {:ok, live, _html} = live(conn, ~p"/s/#{parent.id}")
 
     html =
       live
-      |> element(~s(#subagents button[phx-value-id="#{result.session_id}"]))
+      |> element(~s(#subagents button[phx-value-id="#{child_id}"]))
       |> render_click()
 
     # The page still renders and still knows about the child; cancelling is not deleting.
     assert html =~ "a brief to stop"
+    Task.await(task, 30_000)
+  end
+
+  defp await_running(session_id, attempts \\ 200) do
+    cond do
+      Subagents.running?(session_id) -> true
+      attempts > 0 -> Process.sleep(10) && await_running(session_id, attempts - 1)
+      true -> false
+    end
+  end
+
+  defp await_child(parent_id, attempts \\ 200) do
+    case Subagents.children(parent_id) do
+      [child | _] -> child.id
+      [] when attempts > 0 -> Process.sleep(10) && await_child(parent_id, attempts - 1)
+      [] -> flunk("no child session appeared")
+    end
   end
 
   defp script_deltas(n, text) do