attributes = %{

      objective: objective,

      repository: Keyword.get(options, :repository),

      model: Keyword.get(options, :model) || Models.default_id(),

      reasoning_effort:

        OpenRouter.reasoning_effort(Keyword.get(options, :reasoning, @default_reasoning)),

  def get_for_user(_user, _thread_id), do: nil

  @doc "The account's threads, newest first, bounded."

  @doc """

  The account's threads, newest first, bounded.

  `:repository` narrows the listing to threads recorded against exactly that

  repository string — an exact match on a bounded field the opener wrote, not a

  search. A resume picker filters here rather than parsing objectives.

  """

  @spec list_for_user(User.t(), keyword()) :: [Thread.t()]

  def list_for_user(%User{id: user_id}, options \\ []) do

    limit = options |> Keyword.get(:limit, @maximum_listed) |> min(@maximum_listed) |> max(1)

      order_by: [desc: t.inserted_at, desc: t.id],

      limit: ^limit

    )

    |> in_repository(Keyword.get(options, :repository))

    |> Repo.all()

  end

  defp in_repository(query, repository) when is_binary(repository),

    do: from(t in query, where: t.repository == ^repository)

  defp in_repository(query, _absent), do: query

  @doc """

  The thread's transcript, oldest first, bounded.

  @permission_profiles ~w(read_only workspace_write)

  @reasoning_efforts ~w(none minimal low medium high max)

  @objective_bytes 32_768

  @repository_bytes 200

  schema "threads" do

    belongs_to :owner_visitor, Visitor

    field :objective, :string, redact: true

    field :repository, :string

    field :status, :string, default: "open"

    field :model, :string

    field :reasoning_effort, :string

  The immutable capture at open time. `owner_visitor_id`, `status`,

  `generation`, and `started_at` are set by the context, never cast from a

  caller.

  `repository` is optional and deliberately unvalidated against the forge's

  repository table: a thread may concern a repository the forge does not host,

  so the field records the opener's `owner/name` string, bounded, with no

  foreign key and no format rule beyond non-blank.

  """

  def open_changeset(attributes, owner_visitor_id, now) do

    %__MODULE__{}

    |> cast(attributes, [:objective, :model, :reasoning_effort, :permission_profile])

    |> cast(attributes, [:objective, :model, :reasoning_effort, :permission_profile, :repository])

    |> put_change(:owner_visitor_id, owner_visitor_id)

    |> put_change(:status, "open")

    |> put_change(:generation, 0)

    |> validate_required([:objective, :model, :reasoning_effort, :permission_profile])

    |> validate_length(:objective, min: 1, max: @objective_bytes, count: :bytes)

    |> validate_length(:model, min: 1, max: 200)

    |> validate_length(:repository, min: 1, max: @repository_bytes, count: :bytes)

    |> validate_inclusion(:reasoning_effort, @reasoning_efforts)

    |> validate_inclusion(:permission_profile, @permission_profiles)

    |> foreign_key_constraint(:owner_visitor_id)

    |> check_constraint(:status, name: :threads_status_check)

    |> check_constraint(:objective, name: :threads_objective_bound_check)

    |> check_constraint(:repository, name: :threads_repository_bound_check)

    |> check_constraint(:reasoning_effort, name: :threads_reasoning_effort_check)

    |> check_constraint(:permission_profile, name: :threads_permission_profile_check)

  end

            "What this body of work is for. Required, non-blank, and capped " <>

              "at 32 KB."

        },

        "repository" => %{

          "endpoint" => "POST /api/v3/threads",

          "type" => "string",

          "description" =>

            "The repository the work concerns, as the opener names it " <>

              "(owner/name). Optional, trimmed, non-blank when present, and " <>

              "capped at 200 bytes; not validated against the forge's " <>

              "repositories, because a thread may concern a repository the " <>

              "forge does not host. Returned in every thread view, and " <>

              "GET /api/v3/threads?repository= filters the listing by exact " <>

              "match, so a resume picker filters structurally instead of " <>

              "parsing the objective back."

        },

        "model" => %{

          "endpoint" => "POST /api/v3/threads",

          "type" => "string",

  def create(conn, params) do

    with {:ok, objective} <- objective(params),

         {:ok, repository} <- repository(params),

         {:ok, options} <- execution_shape(params) do

      open(conn, objective, options)

      open(conn, objective, options ++ repository)

    else

      {:refused, field, message} -> ApiError.validation_failed(conn, %{field => [message]})

      {:unavailable, model_id} -> unavailable_model(conn, model_id)

    user = conn.assigns.current_user

    _reaped = Threads.reap_expired(user)

    threads = Threads.list_for_user(user, listing_options(params))

    threads =

      Threads.list_for_user(user, params |> listing_options() |> repository_filter(params))

    conn

    |> put_extension_header()

    end

  end

  # An exact match on the recorded string, so `?repository=` narrows the

  # listing to the threads opened against that repository. A blank filter is

  # no filter: nothing records a blank repository, and an empty listing would

  # read as an account with no threads.

  defp repository_filter(options, params) do

    case Map.get(params, "repository") do

      value when is_binary(value) ->

        case String.trim(value) do

          "" -> options

          repository -> Keyword.put(options, :repository, repository)

        end

      _absent ->

        options

    end

  end

  defp event_parameters(params) do

    with {:ok, event_type} <- event_type(params),

         {:ok, payload} <- payload(params) do

    {:refused, "objective", "A thread requires an objective: what this body of work is for."}

  end

  # Optional, trimmed, non-blank when present. No format rule and no lookup

  # against the forge's repository table: a thread may concern a repository the

  # forge does not host, so the field records the opener's `owner/name` string

  # as given. The bound is the changeset's (issue #210).

  defp repository(%{"repository" => repository}) when is_binary(repository) do

    case String.trim(repository) do

      "" ->

        {:refused, "repository",

         "The repository names where the work runs and cannot be blank. Omit it instead."}

      trimmed ->

        {:ok, [repository: trimmed]}

    end

  end

  defp repository(%{"repository" => repository}) do

    {:refused, "repository", "#{inspect(repository)} is not a string."}

  end

  defp repository(_params), do: {:ok, []}

  defp execution_shape(params) do

    with {:ok, model} <- admitted(params, "model", Models.ids(), Models.default_id()),

         :ok <- serving(model),

      "id" => thread.id,

      "status" => thread.status,

      "objective" => thread.objective,

      "repository" => thread.repository,

      "reasoning_effort" => thread.reasoning_effort,

      "permission_profile" => thread.permission_profile,

      "generation" => thread.generation,

            >

              {title(thread.objective)}

            </.link>

            <p

              :if={thread.repository}

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

              class="mt-0.5 font-mono text-xs text-muted-foreground"

            >

              {thread.repository}

            </p>

          </:col>

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

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

defmodule OpenAgents.Repo.Migrations.AddRepositoryToThreads do

  @moduledoc """

  Record the repository a thread concerns, when its opener names one.

  Nullable and bounded, with no foreign key: a thread may concern a repository

  the forge does not host, so the column records the opener's `owner/name`

  string rather than referencing the repositories table. `openagents coder

  --resume` filters its picker on this field instead of parsing the objective

  sentence the CLI itself composed (issue #210).

  """

  use Ecto.Migration

  def change do

    alter table(:threads) do

      add :repository, :text

    end

    create constraint(:threads, :threads_repository_bound_check,

             check: "repository IS NULL OR octet_length(repository) BETWEEN 1 AND 200"

           )

  end

end

      assert thread["permission_profile"] == "workspace_write"

    end

    test "records the repository the opener names and returns it", %{conn: conn} do

      thread =

        conn

        |> put_chat_api_token("thread-repository")

        |> post(~p"/api/v3/threads", %{

          "objective" => "openagents coder in OpenAgentsInc/openagents.com on main",

          "repository" => "OpenAgentsInc/openagents.com"

        })

        |> json_response(201)

        |> Map.fetch!("thread")

      assert thread["repository"] == "OpenAgentsInc/openagents.com"

      # No foreign key and no format rule: a thread may concern a repository

      # the forge does not host, so the recorded string is the opener's own.

      assert Repo.get!(OpenAgents.Threads.Thread, thread["id"]).repository ==

               "OpenAgentsInc/openagents.com"

    end

    test "a thread without a repository records none and reports null", %{conn: conn} do

      thread =

        conn

        |> put_chat_api_token("thread-no-repository")

        |> post(~p"/api/v3/threads", %{"objective" => "No repository named."})

        |> json_response(201)

        |> Map.fetch!("thread")

      assert Map.fetch!(thread, "repository") == nil

    end

    test "a blank repository is refused rather than recorded as noise", %{conn: conn} do

      body =

        conn

        |> put_chat_api_token("thread-blank-repository")

        |> post(~p"/api/v3/threads", %{"objective" => "Blank it.", "repository" => "   "})

        |> json_response(422)

      assert body["code"] == "validation_failed"

      assert Map.has_key?(body["errors"], "repository")

    end

    test "a repository over the bound is refused", %{conn: conn} do

      body =

        conn

        |> put_chat_api_token("thread-long-repository")

        |> post(~p"/api/v3/threads", %{

          "objective" => "Bound it.",

          "repository" => String.duplicate("a", 201)

        })

        |> json_response(422)

      assert Map.has_key?(body["errors"], "repository")

    end

    test "a caller may open a thread on another routed model", %{conn: conn} do

      body =

        conn

      assert Enum.map(body["threads"], & &1["objective"]) == ["newer", "older"]

    end

    test "?repository= narrows the listing to that repository, exactly", %{conn: conn} do

      authenticated = put_chat_api_token(conn, "thread-repository-filter")

      for {objective, repository} <- [

            {"here", "OpenAgentsInc/openagents.com"},

            {"elsewhere", "OpenAgentsInc/openagents"},

            {"nowhere", nil}

          ] do

        authenticated

        |> post(

          ~p"/api/v3/threads",

          %{"objective" => objective}

          |> Map.merge(if repository, do: %{"repository" => repository}, else: %{})

        )

        |> json_response(201)

      end

      body =

        authenticated

        |> get(~p"/api/v3/threads?repository=OpenAgentsInc/openagents.com")

        |> json_response(200)

      # An exact match on the recorded field, so a resume picker filters

      # structurally instead of parsing the objective sentence back.

      assert Enum.map(body["threads"], & &1["objective"]) == ["here"]

      assert Enum.map(body["threads"], & &1["repository"]) == ["OpenAgentsInc/openagents.com"]

      unfiltered = authenticated |> get(~p"/api/v3/threads") |> json_response(200)

      assert length(unfiltered["threads"]) == 3

    end

    test "does not list another account's threads", %{conn: conn} do

      put_chat_api_token(conn, "thread-mine")

      |> post(~p"/api/v3/threads", %{"objective" => "mine"})

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

  end

  test "a row names its repository when the thread records one", %{conn: conn} do

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

    {:ok, named} =

      Threads.open(owner, "Coder session", repository: "OpenAgentsInc/openagents.com")

    {:ok, bare} = Threads.open(owner, "No repository")

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

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

             "OpenAgentsInc/openagents.com"

    refute has_element?(view, "#thread-repository-#{bare.id}")

  end

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

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