- **Authority reaches only the account that opened the thread.**

  `OpenAgents.Threads.get_for_user/2` joins through the owner visitor, so

  another account's thread id resolves to `nil` and the route refuses it with

  the same `not_found` an absent id gets. No route returns a grant token for a

  thread the caller did not open, and the token is returned exactly once, at

  the mint.

  the same `not_found` an absent id gets. The web thread viewer

  (`OpenAgentsWeb.ThreadShowLive`) resolves through the same lookup and

  renders `nil` as the same plain 404 an unknown id gets, so the browser

  confirms no more existence than the API, and it reads the transcript and the

  grant meter without ever holding a plaintext token. No route returns a grant

  token for a thread the caller did not open, and the token is returned

  exactly once, at the mint.

  Amended 2026-08-23 (issue #174): that sentence quantifies over routes, so it

  is enumerated rather than sampled. A plaintext grant token comes into

`priv/repo/migrations/20260823221416_allow_thread_scoped_inference_grants.exs`,

`test/openagents/threads/grant_fence_test.exs`,

`test/openagents/threads/grant_token_reach_test.exs`,

`test/openagents/threads_test.exs`, and

`test/openagents_web/controllers/thread_controller_test.exs`.

`test/openagents/threads_test.exs`,

`test/openagents_web/controllers/thread_controller_test.exs`, and

`test/openagents_web/live/thread_show_live_test.exs`.

## Tenant deployment control plane

  Refused on a terminal thread: a transcript that keeps growing after the

  report was written is not the transcript the report describes.

  A committed append is broadcast as `{:thread_event, event}` on the thread's

  topic (`subscribe/1`), after the transaction, so a subscriber never sees an

  event that rolled back.

  """

  @spec record_event(Thread.t(), String.t(), map()) ::

          {:ok, Thread.t()} | {:error, :thread_terminal | Ecto.Changeset.t()}

    Repo.transaction(fn ->

      case locked(thread.id) do

        %Thread{status: "open"} = current ->

          with {:ok, _event} <- insert_event(current, event_type, payload, now),

          with {:ok, event} <- insert_event(current, event_type, payload, now),

               {:ok, updated} <-

                 current |> Thread.event_count_changeset(current.event_count + 1) |> Repo.update() do

            updated

            {updated, event}

          else

            {:error, reason} -> Repo.rollback(reason)

          end

          Repo.rollback(:thread_terminal)

      end

    end)

    |> case do

      {:ok, {updated, event}} ->

        Phoenix.PubSub.broadcast(OpenAgents.PubSub, topic(updated.id), {:thread_event, event})

        {:ok, updated}

      {:error, reason} ->

        {:error, reason}

    end

  end

  @doc """

  Subscribe to a thread's transcript appends.

  Delivers `{:thread_event, %OpenAgents.Threads.Event{}}` for each committed

  append. Subscribe before reading the snapshot and dedup by the event id,

  which is monotonic per thread.

  """

  @spec subscribe(Thread.t() | String.t()) :: :ok | {:error, term()}

  def subscribe(%Thread{id: thread_id}), do: subscribe(thread_id)

  def subscribe(thread_id) when is_binary(thread_id) do

    Phoenix.PubSub.subscribe(OpenAgents.PubSub, topic(thread_id))

  end

  defp topic(thread_id), do: "thread:" <> thread_id

  @doc """

  Mint model authority for a thread.

defmodule OpenAgentsWeb.ThreadIndexLive do

  @moduledoc """

  The account's threads as a shell projection.

  Each row reads only the denormalized thread record — status, objective,

  counts, timestamps, terminal usage — never the transcript (issue #201's

  shell/detail split). The row title is the thread's objective: it is what the

  reader asked for, it lives on the shell row, and deriving the first

  `turn.user` event would mean reading transcripts for a listing. The list is a

  snapshot taken at mount; live updates belong to the detail page, which

  subscribes to its one thread's topic.

  """

  use OpenAgentsWeb, :live_view

  alias OpenAgents.Threads

  @title_characters 100

  @impl true

  def mount(_params, _session, socket) do

    user = socket.assigns.current_user

    _reaped = Threads.reap_expired(user)

    threads = Threads.list_for_user(user)

    {:ok,

     socket

     |> assign(:page_title, "Threads · OpenAgents")

     |> assign(:threads_empty?, threads == [])

     |> stream(:threads, threads)}

  end

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <main id="thread-index" class="mx-auto w-full max-w-5xl space-y-6 px-4 py-10">

        <.header>

          Threads

          <:subtitle>Every thread this account has opened, newest first.</:subtitle>

        </.header>

        <.empty :if={@threads_empty?} id="threads-empty" title="No threads yet">

          Open one with

          <.kbd>openagents coder</.kbd>

          or <.kbd>POST /api/v3/threads</.kbd>.

        </.empty>

        <.table :if={!@threads_empty?} id="threads-table" rows={@streams.threads}>

          <:col :let={{_id, thread}} label="Objective">

            <.link

              navigate={~p"/threads/#{thread.id}"}

              id={"thread-link-#{thread.id}"}

              class="font-medium hover:underline"

            >

              {title(thread.objective)}

            </.link>

          </:col>

          <:col :let={{_id, thread}} label="Status">

            <.badge variant={status_variant(thread.status)}>{thread.status}</.badge>

          </:col>

          <:col :let={{_id, thread}} label="Events">

            <span class="tabular-nums">{thread.event_count}</span>

          </:col>

          <:col :let={{_id, thread}} label="Model">

            <span class="font-mono text-xs text-muted-foreground">{thread.model}</span>

          </:col>

          <:col :let={{_id, thread}} label="Opened">

            <.time_ago at={thread.started_at} class="text-muted-foreground" />

          </:col>

          <:col :let={{_id, thread}} label="Last event">

            <.time_ago at={thread.updated_at} class="text-muted-foreground" />

          </:col>

          <:col :let={{_id, thread}} label="Spent">

            <span class="tabular-nums text-muted-foreground">{spent(thread.usage)}</span>

          </:col>

        </.table>

      </main>

    </Layouts.app>

    """

  end

  defp title(objective) do

    if String.length(objective) > @title_characters do

      String.slice(objective, 0, @title_characters) <> "…"

    else

      objective

    end

  end

  defp status_variant("open"), do: :info

  defp status_variant("succeeded"), do: :success

  defp status_variant("failed"), do: :danger

  defp status_variant("cancelled"), do: :dim

  defp status_variant(_status), do: :default

  # The terminal usage map is client-reported and its shape is not pinned, so

  # this reads the keys the grant meter uses and shows nothing otherwise.

  defp spent(usage) when is_map(usage) do

    case integer(usage, "estimated_cost_microusd") do

      nil ->

        case integer(usage, "total_tokens") do

          nil -> "—"

          tokens -> "#{tokens} tok"

        end

      microusd ->

        "$#{:erlang.float_to_binary(microusd / 1_000_000, decimals: 2)}"

    end

  end

  defp spent(_usage), do: "—"

  defp integer(map, key) do

    case Map.get(map, key) do

      value when is_integer(value) -> value

      value when is_float(value) -> trunc(value)

      _absent -> nil

    end

  end

end

defmodule OpenAgentsWeb.ThreadShowLive do

  @moduledoc """

  One thread's transcript, read-only, live.

  Owner-only: an unknown id and another account's id both raise the plain 404

  (`OpenAgentsWeb.PublicNotFoundError`), matching how the API's

  `Threads.get_for_user/2` scopes reads — existence is never confirmed to a

  non-owner.

  The snapshot-to-live order follows the projection protocol the issue names:

  subscribe to the thread's topic first, then read the snapshot, then let

  buffered broadcasts drain through `handle_info/2` with a monotonic

  `last_event_id` dedup, so an event is never dropped and never doubled.

  The event vocabulary renders typed — `turn.user`, `turn.reasoning`,

  `tool.ran`, `turn.assistant` — and every payload field is read defensively:

  the payloads are client-written and their shape is not pinned by the server,

  so a missing or oddly typed field degrades to the neutral raw row rather

  than crashing the view. Unknown event types take the raw row too.

  """

  use OpenAgentsWeb, :live_view

  alias OpenAgents.Markdown

  alias OpenAgents.Threads

  # Transcript pages are capped at 50 by the context; forty pages bounds the

  # view at 2,000 events, which is past any measured session.

  @maximum_pages 40

  @bounded_json_characters 2_000

  @impl true

  def mount(%{"id" => thread_id}, _session, socket) do

    user = socket.assigns.current_user

    _reaped = Threads.reap_expired(user)

    case Threads.get_for_user(user, thread_id) do

      nil ->

        raise OpenAgentsWeb.PublicNotFoundError, message: "thread not found"

      thread ->

        # Attach the live subscriber before reading the snapshot: an append

        # that lands between the two arrives as a buffered message and is

        # deduped below by id, so the gap cannot lose an event.

        if connected?(socket), do: Threads.subscribe(thread)

        events = transcript(thread)

        {:ok,

         socket

         |> assign(:page_title, "Thread · OpenAgents")

         |> assign(:thread, thread)

         |> assign(:grant, Threads.latest_grant(thread))

         |> assign(:last_event_id, last_id(events))

         |> assign(:events_empty?, events == [])

         |> stream(:events, events)}

    end

  end

  @impl true

  def handle_info({:thread_event, event}, socket) do

    if event.id <= socket.assigns.last_event_id do

      {:noreply, socket}

    else

      {:noreply,

       socket

       |> assign(:last_event_id, event.id)

       |> assign(:events_empty?, false)

       |> update(:thread, fn thread -> %{thread | event_count: thread.event_count + 1} end)

       |> stream_insert(:events, event)}

    end

  end

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <main id="thread-show" class="mx-auto w-full max-w-4xl space-y-6 px-4 py-10">

        <header class="space-y-3">

          <div class="flex flex-wrap items-center gap-3">

            <.badge variant={status_variant(@thread.status)}>{@thread.status}</.badge>

            <span class="font-mono text-xs text-muted-foreground">{@thread.id}</span>

          </div>

          <h1 class="text-2xl font-semibold tracking-tight">{@thread.objective}</h1>

          <dl

            id="thread-facts"

            class="flex flex-wrap gap-x-6 gap-y-1 text-sm text-muted-foreground"

          >

            <div class="flex gap-1.5">

              <dt>Model</dt>

              <dd class="font-mono text-xs leading-5">{@thread.model}</dd>

            </div>

            <div class="flex gap-1.5">

              <dt>Reasoning</dt>

              <dd>{@thread.reasoning_effort}</dd>

            </div>

            <div class="flex gap-1.5">

              <dt>Permissions</dt>

              <dd>{@thread.permission_profile}</dd>

            </div>

            <div class="flex gap-1.5">

              <dt>Events</dt>

              <dd id="thread-event-count" class="tabular-nums">{@thread.event_count}</dd>

            </div>

            <div class="flex gap-1.5">

              <dt>Opened</dt>

              <dd><.time_ago at={@thread.started_at} /></dd>

            </div>

            <div :if={@thread.completed_at} class="flex gap-1.5">

              <dt>Completed</dt>

              <dd><.time_ago at={@thread.completed_at} /></dd>

            </div>

          </dl>

        </header>

        <.card :if={@grant} id="thread-budget" class="text-sm">

          <div class="flex flex-wrap gap-x-8 gap-y-2">

            <div>

              <div class="text-xs text-muted-foreground">Grant</div>

              <div>{@grant.status}</div>

            </div>

            <div>

              <div class="text-xs text-muted-foreground">Calls</div>

              <div class="tabular-nums">{@grant.call_count} / {@grant.max_calls}</div>

            </div>

            <div>

              <div class="text-xs text-muted-foreground">Tokens</div>

              <div class="tabular-nums">

                {grant_spent(@grant, "total_tokens")} / {@grant.max_total_tokens}

              </div>

            </div>

            <div>

              <div class="text-xs text-muted-foreground">Cost</div>

              <div class="tabular-nums">

                {dollars(grant_spent(@grant, "estimated_cost_microusd"))} / {dollars(

                  @grant.max_cost_microusd

                )}

              </div>

            </div>

            <div :if={@grant.expires_at}>

              <div class="text-xs text-muted-foreground">Expires</div>

              <div><.time_ago at={@grant.expires_at} /></div>

            </div>

          </div>

        </.card>

        <.card :if={@thread.report} id="thread-report" class="text-sm">

          <div class="mb-1 text-xs text-muted-foreground">Report</div>

          <div class="whitespace-pre-wrap">{@thread.report}</div>

        </.card>

        <section aria-label="Transcript" class="space-y-3">

          <.empty :if={@events_empty?} id="thread-transcript-empty" title="No events yet">

            The transcript fills as the thread works.

          </.empty>

          <div id="thread-events" phx-update="stream" class="space-y-3">

            <div :for={{dom_id, event} <- @streams.events} id={dom_id} data-kind={event.event_type}>

              <.event_row event={event} />

            </div>

          </div>

        </section>

      </main>

    </Layouts.app>

    """

  end

  # ── event rendering ──────────────────────────────────────────────────────

  # One transcript entry, dispatched on its type. Each typed clause reads its

  # payload defensively and falls back to the neutral raw row when the field

  # it renders around is missing, so a malformed payload degrades instead of

  # crashing the transcript.

  defp event_row(%{event: %{event_type: "turn.user"} = event} = assigns) do

    case text(event.payload) do

      nil ->

        raw_row(assigns)

      text ->

        assigns = assign(assigns, text: text, steered: steered?(event.payload))

        ~H"""

        <.card class="text-sm">

          <div class="mb-1 flex items-center gap-2 text-xs text-muted-foreground">

            <span class="font-medium text-foreground">You</span>

            <.badge :if={@steered} variant={:warning}>steered</.badge>

            <.time_ago at={@event.emitted_at} />

          </div>

          <div class="whitespace-pre-wrap">{@text}</div>

        </.card>

        """

    end

  end

  defp event_row(%{event: %{event_type: "turn.reasoning"} = event} = assigns) do

    case text(event.payload) do

      nil ->

        raw_row(assigns)

      text ->

        assigns = assign(assigns, text: text)

        ~H"""

        <details class="rounded-md border border-border">

          <summary class="cursor-pointer select-none px-3 py-2 text-xs text-muted-foreground">

            Reasoning · {String.length(@text)} chars · <.time_ago at={@event.emitted_at} />

          </summary>

          <div class="whitespace-pre-wrap border-t border-border px-3 py-2 text-sm text-muted-foreground">

            {@text}

          </div>

        </details>

        """

    end

  end

  defp event_row(%{event: %{event_type: "tool.ran"} = event} = assigns) do

    case string(event.payload, ["tool", "name"]) do

      nil ->

        raw_row(assigns)

      tool ->

        assigns =

          assign(assigns,

            tool: tool,

            tool_status: string(event.payload, ["status"]),

            arguments: bounded_json(Map.get(event.payload, "arguments")),

            result: bounded_json(Map.get(event.payload, "result"))

          )

        ~H"""

        <details class="rounded-md border border-border">

          <summary class="flex cursor-pointer select-none items-center gap-2 px-3 py-2 text-xs">

            <.kbd>{@tool}</.kbd>

            <.badge :if={@tool_status} variant={tool_status_variant(@tool_status)}>

              {@tool_status}

            </.badge>

            <span class="text-muted-foreground"><.time_ago at={@event.emitted_at} /></span>

          </summary>

          <div class="space-y-2 border-t border-border px-3 py-2 text-xs">

            <div :if={@arguments}>

              <div class="mb-1 text-muted-foreground">Arguments</div>

              <pre class="overflow-x-auto rounded-md bg-muted p-2 font-mono"><code phx-no-format>{@arguments}</code></pre>

            </div>

            <div :if={@result}>

              <div class="mb-1 text-muted-foreground">Result</div>

              <pre class="overflow-x-auto rounded-md bg-muted p-2 font-mono"><code phx-no-format>{@result}</code></pre>

            </div>

          </div>

        </details>

        """

    end

  end

  defp event_row(%{event: %{event_type: "turn.assistant"} = event} = assigns) do

    case text(event.payload) do

      nil ->

        raw_row(assigns)

      text ->

        assigns =

          assign(assigns,

            html: Markdown.to_html(text),

            usage: usage_line(event.payload)

          )

        ~H"""

        <.card class="text-sm">

          <div class="mb-1 flex items-center gap-2 text-xs text-muted-foreground">

            <span class="font-medium text-foreground">Assistant</span>

            <.time_ago at={@event.emitted_at} />

          </div>

          <div class="markdown space-y-2">{@html}</div>

          <div :if={@usage} class="mt-2 text-xs tabular-nums text-muted-foreground">{@usage}</div>

        </.card>

        """

    end

  end

  defp event_row(assigns), do: raw_row(assigns)

  # The neutral row: whatever the type, whatever the payload, it renders as

  # the recorded fact rather than crashing the transcript around it.

  defp raw_row(assigns) do

    assigns = assign(assigns, json: bounded_json(assigns.event.payload))

    ~H"""

    <details class="rounded-md border border-border">

      <summary class="flex cursor-pointer select-none items-center gap-2 px-3 py-2 text-xs">

        <code class="font-mono">{@event.event_type}</code>

        <span class="text-muted-foreground"><.time_ago at={@event.emitted_at} /></span>

      </summary>

      <pre

        :if={@json}

        class="overflow-x-auto border-t border-border px-3 py-2 font-mono text-xs"

      ><code phx-no-format>{@json}</code></pre>

    </details>

    """

  end

  # ── snapshot ─────────────────────────────────────────────────────────────

  defp transcript(thread), do: transcript(thread, nil, @maximum_pages, [])

  defp transcript(_thread, _after_id, 0, pages), do: pages |> Enum.reverse() |> List.flatten()

  defp transcript(thread, after_id, remaining, pages) do

    page = Threads.list_events(thread, after: after_id)

    case last_id(page) do

      0 -> transcript(thread, after_id, 0, pages)

      last -> transcript(thread, last, remaining - 1, [page | pages])

    end

  end

  defp last_id([]), do: 0

  defp last_id(events), do: List.last(events).id

  # ── payload readers ──────────────────────────────────────────────────────

  defp text(payload), do: string(payload, ["text"])

  defp string(payload, keys) when is_map(payload) do

    Enum.find_value(keys, fn key ->

      case Map.get(payload, key) do

        value when is_binary(value) and value != "" -> value

        _other -> nil

      end

    end)

  end

  defp string(_payload, _keys), do: nil

  defp steered?(payload) when is_map(payload), do: Map.get(payload, "steered") == true

  defp steered?(_payload), do: false

  defp bounded_json(nil), do: nil

  defp bounded_json(value) do

    case Jason.encode(value, pretty: true) do

      {:ok, json} when byte_size(json) > @bounded_json_characters ->

        String.slice(json, 0, @bounded_json_characters) <> "\n…"

      {:ok, json} ->

        json

      {:error, _unencodable} ->

        inspect(value, limit: 50, printable_limit: @bounded_json_characters)

    end

  end

  defp usage_line(payload) when is_map(payload) do

    case Map.get(payload, "usage") do

      usage when is_map(usage) ->

        parts =

          [

            {"input", integer(usage, "input_tokens") || integer(usage, "prompt_tokens")},

            {"output", integer(usage, "output_tokens") || integer(usage, "completion_tokens")},

            {"total", integer(usage, "total_tokens")}

          ]

          |> Enum.filter(fn {_label, value} -> value end)

          |> Enum.map(fn {label, value} -> "#{value} #{label}" end)

        if parts == [], do: nil, else: Enum.join(parts, " · ") <> " tok"

      _absent ->

        nil

    end

  end

  defp usage_line(_payload), do: nil

  defp integer(map, key) do

    case Map.get(map, key) do

      value when is_integer(value) -> value

      value when is_float(value) -> trunc(value)

      _absent -> nil

    end

  end

  defp grant_spent(grant, key) do

    case grant.usage do

      usage when is_map(usage) -> integer(usage, key) || 0

      _absent -> 0

    end

  end

  defp dollars(microusd), do: "$#{:erlang.float_to_binary(microusd / 1_000_000, decimals: 2)}"

  defp status_variant("open"), do: :info

  defp status_variant("succeeded"), do: :success

  defp status_variant("failed"), do: :danger

  defp status_variant("cancelled"), do: :dim

  defp status_variant(_status), do: :default

  defp tool_status_variant("ok"), do: :success

  defp tool_status_variant("success"), do: :success

  defp tool_status_variant("error"), do: :danger

  defp tool_status_variant("failed"), do: :danger

  defp tool_status_variant(_status), do: :default

end

      live "/artifact-catalog", ArtifactCatalogLive, :index

      live "/notifications", NotificationsLive, :index

      live "/settings/api-tokens", ApiTokensLive, :index

      live "/threads", ThreadIndexLive, :index

      live "/threads/:id", ThreadShowLive, :show

      live "/device", DeviceAuthorizationLive, :show

      live "/repositories", RepositoryIndexLive, :index

      live "/repositories/new", RepositoryNewLive, :new

defmodule OpenAgents.Threads.EventBroadcastTest do

  use OpenAgents.DataCase, async: false

  import OpenAgentsWeb.ConnCase, only: [github_user: 1]

  alias OpenAgents.Threads

  alias OpenAgents.Threads.Event

  test "a committed append is broadcast on the thread's topic" do

    user = github_user("thread-broadcast")

    {:ok, thread} = Threads.open(user, "Broadcast the transcript")

    :ok = Threads.subscribe(thread)

    {:ok, _updated} = Threads.record_event(thread, "turn.user", %{"text" => "hello"})

    assert_receive {:thread_event, %Event{event_type: "turn.user", payload: %{"text" => "hello"}}}

  end

  test "a refused append broadcasts nothing" do

    user = github_user("thread-broadcast-terminal")

    {:ok, thread} = Threads.open(user, "Terminal threads stay silent")

    {:ok, cancelled} = Threads.cancel(thread)

    :ok = Threads.subscribe(cancelled)

    assert {:error, :thread_terminal} =

             Threads.record_event(cancelled, "turn.user", %{"text" => "late"})

    refute_receive {:thread_event, _event}

  end

  test "another thread's subscriber hears nothing" do

    user = github_user("thread-broadcast-scope")

    {:ok, mine} = Threads.open(user, "Mine")

    {:ok, other} = Threads.open(user, "Other")

    :ok = Threads.subscribe(other)

    {:ok, _updated} = Threads.record_event(mine, "turn.user", %{"text" => "scoped"})

    refute_receive {:thread_event, _event}

  end

end

    {:open_and_mint, 3} => :returns_plaintext_token,

    {:open_count, 1} => :scoped_by_owner,

    {:reap_expired, 1} => :scoped_by_owner,

    {:record_event, 3} => :thread_struct

    {:record_event, 3} => :thread_struct,

    {:subscribe, 1} => :thread_struct

  }

  # Every module that reaches a token-returning `OpenAgents.Threads` export.

  # The one function that resolves a thread from an identifier, and every

  # module that calls it. It takes the acting account, so another account's

  # thread id resolves to `nil` (THREAD-001, IDENTITY-002).

  @thread_resolver_callers [OpenAgentsWeb.ThreadController]

  # thread id resolves to `nil` (THREAD-001, IDENTITY-002). The web thread

  # viewer resolves through the same lookup and renders a `nil` as the plain

  # 404 an absent id gets.

  @thread_resolver_callers [OpenAgentsWeb.ThreadController, OpenAgentsWeb.ThreadShowLive]

  test "the modules that mint a grant token are exactly the set THREAD-001 accounts for" do

    assert_exact_set(

defmodule OpenAgentsWeb.ThreadIndexLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  alias OpenAgents.Threads

  defp signed_in(conn, user), do: Plug.Test.init_test_session(conn, %{"user_id" => user.id})

  test "owner sees own threads and nobody else's", %{conn: conn} do

    owner = github_user("thread-index-owner")

    other = github_user("thread-index-other")

    {:ok, mine} = Threads.open(owner, "List my work")

    {:ok, theirs} = Threads.open(other, "Somebody else's work")

    {:ok, view, _html} = live(signed_in(conn, owner), ~p"/threads")

    assert has_element?(view, "#threads-table")

    assert has_element?(view, "#thread-link-#{mine.id}")

    refute has_element?(view, "#thread-link-#{theirs.id}")

  end

  test "a row carries status and event count without reading the transcript", %{conn: conn} do

    owner = github_user("thread-index-shell")

    {:ok, thread} = Threads.open(owner, "Shell projection")

    {:ok, _updated} = Threads.record_event(thread, "turn.user", %{"text" => "hi"})

    {:ok, view, _html} = live(signed_in(conn, owner), ~p"/threads")

    assert view |> element("#threads-#{thread.id}") |> render() =~ "open"

    assert view |> element("#threads-#{thread.id}") |> render() =~ ">2<"

  end

  test "an account with no threads sees the empty state", %{conn: conn} do

    owner = github_user("thread-index-empty")

    {:ok, view, _html} = live(signed_in(conn, owner), ~p"/threads")

    assert has_element?(view, "#threads-empty")

    refute has_element?(view, "#threads-table")

  end

  test "anonymous browser is redirected", %{conn: conn} do

    assert {:error, {:redirect, %{to: "/"}}} = live(conn, ~p"/threads")

  end

end

defmodule OpenAgentsWeb.ThreadShowLiveTest do

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  alias OpenAgents.Threads

  defp signed_in(conn, user), do: Plug.Test.init_test_session(conn, %{"user_id" => user.id})

  defp event_id(thread, event_type) do

    thread

    |> Threads.list_events()

    |> Enum.find(&(&1.event_type == event_type))

    |> Map.fetch!(:id)

  end

  test "renders each event kind of the vocabulary typed", %{conn: conn} do

    owner = github_user("thread-show-kinds")

    {:ok, thread} = Threads.open(owner, "Render the vocabulary")

    {:ok, thread} =

      Threads.record_event(thread, "turn.user", %{"text" => "Fix the bug", "steered" => true})

    {:ok, thread} =

      Threads.record_event(thread, "turn.reasoning", %{"text" => "The bug is in the parser."})

    {:ok, thread} =

      Threads.record_event(thread, "tool.ran", %{

        "tool" => "read_file",

        "status" => "ok",

        "arguments" => %{"path" => "lib/parser.ex"},

        "result" => "defmodule Parser do"

      })

    {:ok, thread} =

      Threads.record_event(thread, "turn.assistant", %{

        "text" => "Fixed. The parser **now** handles it.",

        "usage" => %{"input_tokens" => 100, "output_tokens" => 25, "total_tokens" => 125}

      })

    {:ok, view, _html} = live(signed_in(conn, owner), ~p"/threads/#{thread.id}")

    user_id = event_id(thread, "turn.user")

    assert view |> element("#events-#{user_id}[data-kind='turn.user']") |> render() =~

             "Fix the bug"

    assert view |> element("#events-#{user_id}") |> render() =~ "steered"

    reasoning_id = event_id(thread, "turn.reasoning")

    assert view |> element("#events-#{reasoning_id}[data-kind='turn.reasoning']") |> render() =~

             "The bug is in the parser."

    assert has_element?(view, "#events-#{reasoning_id} details")

    tool_id = event_id(thread, "tool.ran")

    tool_row = view |> element("#events-#{tool_id}[data-kind='tool.ran']") |> render()

    assert tool_row =~ "read_file"

    assert tool_row =~ "lib/parser.ex"

    assert tool_row =~ "defmodule Parser do"

    assert tool_row =~ "ok"

    assistant_id = event_id(thread, "turn.assistant")

    assistant_row =

      view |> element("#events-#{assistant_id}[data-kind='turn.assistant']") |> render()

    assert assistant_row =~ "<strong>now</strong>"

    assert assistant_row =~ "125 total"

  end

  test "an unknown event type renders as a neutral raw row", %{conn: conn} do

    owner = github_user("thread-show-unknown")

    {:ok, thread} = Threads.open(owner, "Survive the unknown")

    {:ok, thread} =

      Threads.record_event(thread, "plugin.custom", %{"whatever" => ["shape", 1, true]})

    # A typed event whose payload misses its text degrades the same way.

    {:ok, thread} = Threads.record_event(thread, "turn.user", %{"no_text" => true})

    {:ok, view, _html} = live(signed_in(conn, owner), ~p"/threads/#{thread.id}")

    unknown_id = event_id(thread, "plugin.custom")

    assert view |> element("#events-#{unknown_id}[data-kind='plugin.custom']") |> render() =~

             "plugin.custom"

    textless_id = event_id(thread, "turn.user")

    assert view |> element("#events-#{textless_id}") |> render() =~ "no_text"

  end

  test "another account's thread id is a plain 404", %{conn: conn} do

    owner = github_user("thread-show-owner")

    intruder = github_user("thread-show-intruder")

    {:ok, thread} = Threads.open(owner, "Private work")

    assert_raise OpenAgentsWeb.PublicNotFoundError, fn ->

      live(signed_in(conn, intruder), ~p"/threads/#{thread.id}")

    end

  end

  test "an unknown id is the same 404", %{conn: conn} do

    viewer = github_user("thread-show-unknown-id")

    assert_raise OpenAgentsWeb.PublicNotFoundError, fn ->

      live(signed_in(conn, viewer), ~p"/threads/#{Ecto.UUID.generate()}")

    end

    assert_raise OpenAgentsWeb.PublicNotFoundError, fn ->

      live(signed_in(conn, viewer), ~p"/threads/not-a-uuid")

    end

  end

end

defmodule OpenAgentsWeb.ThreadShowUpdatesTest do

  # async: false — the test broadcasts through the shared PubSub into a

  # LiveView process, following the other *_updates_test files.

  use OpenAgentsWeb.ConnCase, async: false

  import Phoenix.LiveViewTest

  alias OpenAgents.Threads

  defp signed_in(conn, user), do: Plug.Test.init_test_session(conn, %{"user_id" => user.id})

  test "a recorded event streams into the open transcript in order", %{conn: conn} do

    owner = github_user("thread-show-live")

    {:ok, thread} = Threads.open(owner, "Watch it live")

    {:ok, view, _html} = live(signed_in(conn, owner), ~p"/threads/#{thread.id}")

    {:ok, thread} = Threads.record_event(thread, "turn.user", %{"text" => "streamed in"})

    {:ok, thread} = Threads.record_event(thread, "turn.assistant", %{"text" => "and answered"})

    # Local PubSub dispatch sends before returning, so the view's mailbox

    # holds both events; get_state synchronizes past them.

    _ = :sys.get_state(view.pid)

    [user_event, assistant_event] =

      thread

      |> Threads.list_events()

      |> Enum.filter(&(&1.event_type in ["turn.user", "turn.assistant"]))

    assert view |> element("#events-#{user_event.id}") |> render() =~ "streamed in"

    assert view |> element("#events-#{assistant_event.id}") |> render() =~ "and answered"

    # thread.opened + the two appends.

    assert view |> element("#thread-event-count") |> render() =~ ">3<"

    # Order: the ids are monotonic and the DOM keeps append order.

    html = render(view)

    assert :binary.match(html, "events-#{user_event.id}") <

             :binary.match(html, "events-#{assistant_event.id}")

  end

  test "an event already in the snapshot is not doubled by its broadcast", %{conn: conn} do

    owner = github_user("thread-show-dedup")

    {:ok, thread} = Threads.open(owner, "Dedup by id")

    {:ok, thread} = Threads.record_event(thread, "turn.user", %{"text" => "snapshotted"})

    {:ok, view, _html} = live(signed_in(conn, owner), ~p"/threads/#{thread.id}")

    [event] = Enum.filter(Threads.list_events(thread), &(&1.event_type == "turn.user"))

    # Replay the broadcast the view may have buffered during mount.

    send(view.pid, {:thread_event, event})

    _ = :sys.get_state(view.pid)

    assert view |> element("#thread-event-count") |> render() =~ ">2<"

    assert has_element?(view, "#events-#{event.id}")

  end

end